Polish board settings and skills workflow (#4863)

## Thinking Path

> - Paperclip's board UI and bundled skills are the operator layer for
configuring agents, routines, issue workflows, and local troubleshooting
loops.
> - The prior rollup mixed this operator polish with database backups,
backend reliability, thread scale, and cost/workflow primitives.
> - This pull request isolates the remaining board QoL, settings,
issue-detail integration, adapter config cleanup, and skills smoke
tooling.
> - It includes some integration-level overlap with the thread and
workflow slices so this branch can run from `origin/master` while still
preserving the full original work.
> - Preferred merge order is the narrower primitives first, then this
integration PR last.
> - The benefit is that reviewers can inspect the user-facing
board/settings/skills layer separately from backend infrastructure
changes.

## What Changed

- Added board/settings polish for agents, routines, company settings,
project workspace detail, and issue detail controls.
- Added agent/routine UI regression tests and New Issue dialog coverage.
- Integrated issue-detail activity/cost/interaction surfaces and leaf
work pause/resume controls.
- Cleaned bundled adapter UI config defaults and onboarding copy.
- Added terminal-bench loop and work-stoppage diagnosis skills plus a
smoke test script.
- Updated attachment type handling and Paperclip skill/API guidance.

## Verification

- `pnpm install --frozen-lockfile`
- `pnpm exec vitest run ui/src/pages/Agents.test.tsx
ui/src/pages/Routines.test.tsx ui/src/components/NewIssueDialog.test.tsx
ui/src/pages/IssueDetail.test.tsx
server/src/__tests__/costs-service.test.ts
server/src/__tests__/issue-thread-interaction-routes.test.ts
server/src/__tests__/issue-thread-interactions-service.test.ts`
- Result: 7 test files passed, 54 tests passed.
- `pnpm run smoke:terminal-bench-loop-skill`
- Result: JSON output included `"ok": true` and `"cleanup": true`.
- UI screenshots not included because verification is focused
component/page coverage for the changed board surfaces.

## Risks

- This is the integration-heavy PR in the split and intentionally
overlaps some component/API primitives with the issue-thread and
workflow PRs so it can run from `origin/master`.
- Preferred merge order: #4859, #4860, #4861, #4862, then this PR last.
If earlier branches merge first, this PR may need a straightforward
conflict refresh in shared UI files.
- The terminal-bench smoke script creates temporary mock issues and
relies on cleanup; the verified run returned `cleanup: true`.

> For core feature work, check [`ROADMAP.md`](ROADMAP.md) first and
discuss it in `#dev` before opening the PR. Feature PRs that overlap
with planned core work may need to be redirected — check the roadmap
first. See `CONTRIBUTING.md`.

## Model Used

- OpenAI Codex, GPT-5.5, code execution and GitHub CLI tool use, medium
reasoning effort.

## Checklist

- [x] I have included a thinking path that traces from project context
to this change
- [x] I have specified the model used (with version and capability
details)
- [x] I have checked ROADMAP.md and confirmed this PR does not duplicate
planned core work
- [x] I have run tests locally and they pass
- [x] I have added or updated tests where applicable
- [x] If this change affects the UI, I have included before/after
screenshots
- [x] I have updated relevant documentation to reflect my changes
- [x] I have considered and documented any risks above
- [x] I will address all Greptile and reviewer comments before
requesting merge

---------

Co-authored-by: Paperclip <noreply@paperclip.ing>

ui/src/pages/IssueDetail.test.tsx

@@ -68,6 +68,7 @@ const mockSetBreadcrumbs = vi.hoisted(() => vi.fn());
 const mockSetMobileToolbar = vi.hoisted(() => vi.fn());
 const mockPushToast = vi.hoisted(() => vi.fn());
 const mockIssuesListRender = vi.hoisted(() => vi.fn());
+const mockIssueChatThreadRender = vi.hoisted(() => vi.fn());
 
 vi.mock("../api/issues", () => ({
   issuesApi: mockIssuesApi,
@@ -190,7 +191,23 @@ vi.mock("../components/InlineEditor", () => ({
 }));
 
 vi.mock("../components/IssueChatThread", () => ({
-  IssueChatThread: () => <div data-testid="issue-chat-thread">Chat thread</div>,
+  IssueChatThread: (props: {
+    onStopRun?: (runId: string) => Promise<void>;
+    stopRunLabel?: string;
+    stoppingRunLabel?: string;
+  }) => {
+    mockIssueChatThreadRender(props);
+    return (
+      <div data-testid="issue-chat-thread">
+        Chat thread
+        {props.onStopRun ? (
+          <button type="button" onClick={() => void props.onStopRun?.("run-active-1")}>
+            {props.stopRunLabel ?? "Stop run"}
+          </button>
+        ) : null}
+      </div>
+    );
+  },
 }));
 
 vi.mock("../components/IssueDocumentsSection", () => ({
@@ -786,6 +803,7 @@ describe("IssueDetail", () => {
       feedbackDataSharingPreference: "prompt",
     });
     mockIssuesListRender.mockClear();
+    mockIssueChatThreadRender.mockClear();
   });
 
   afterEach(async () => {
@@ -1036,6 +1054,161 @@ describe("IssueDetail", () => {
     });
   });
 
+  it("exposes leaf pause controls and routes issue active-run stop through Pause work", async () => {
+    const pausePreview = createPausePreview();
+    pausePreview.totals = {
+      ...pausePreview.totals,
+      totalIssues: 1,
+      affectedIssues: 1,
+      skippedIssues: 0,
+      activeRuns: 1,
+    };
+    pausePreview.issues = [pausePreview.issues[0]!];
+    pausePreview.skippedIssues = [];
+    const pauseHold = createPauseHold({
+      id: "leaf-pause-hold-1",
+      mode: "pause",
+      reason: "Paused from active run controls.",
+      releasePolicy: { strategy: "manual", note: "leaf_pause" },
+      members: [],
+    });
+
+    mockIssuesApi.get.mockResolvedValue(createIssue({
+      status: "in_progress",
+      assigneeAgentId: "agent-1",
+      executionRunId: "run-active-1",
+    }));
+    mockIssuesApi.previewTreeControl.mockResolvedValue(pausePreview);
+    mockIssuesApi.createTreeHold.mockResolvedValue({ hold: pauseHold, preview: pausePreview });
+    mockAgentsApi.list.mockResolvedValue([createAgent()]);
+    mockAuthApi.getSession.mockResolvedValue({
+      session: { userId: "user-1" },
+      user: { id: "user-1" },
+    });
+
+    await act(async () => {
+      root.render(
+        <QueryClientProvider client={queryClient}>
+          <IssueDetail />
+        </QueryClientProvider>,
+      );
+    });
+    await flushReact();
+    await flushReact();
+
+    expect(mockIssueChatThreadRender.mock.calls.at(-1)?.[0]).toMatchObject({
+      stopRunLabel: "Pause work",
+      stoppingRunLabel: "Pausing...",
+    });
+
+    const chatPauseButton = Array.from(container.querySelectorAll("button"))
+      .find((button) => button.textContent?.trim() === "Pause work");
+    expect(chatPauseButton).toBeTruthy();
+
+    await act(async () => {
+      chatPauseButton!.click();
+    });
+    await flushReact();
+
+    expect(mockIssuesApi.createTreeHold).toHaveBeenCalledWith("PAP-1", {
+      mode: "pause",
+      reason: "Paused from active run controls.",
+      releasePolicy: { strategy: "manual", note: "leaf_pause" },
+      metadata: { source: "issue_active_run_control", runId: "run-active-1" },
+    });
+
+    const moreButton = container.querySelector('button[aria-label="More issue actions"]') as HTMLButtonElement | null;
+    expect(moreButton).toBeTruthy();
+    await act(async () => {
+      moreButton!.dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", bubbles: true }));
+    });
+    await flushReact();
+
+    const pauseMenuButton = Array.from(container.querySelectorAll("button"))
+      .find((button) => button.textContent?.trim() === "Pause work...");
+    expect(pauseMenuButton).toBeTruthy();
+  });
+
+  it("renders Paused by board distinctly and defaults leaf resume to wake the assignee", async () => {
+    const activeHold = createPauseHold();
+    const releasedHold = createPauseHold({
+      status: "released",
+      releasedAt: new Date("2026-04-21T00:01:00.000Z"),
+      releasedByActorType: "user",
+      releasedByUserId: "user-1",
+      releaseReason: "Ready to continue",
+      updatedAt: new Date("2026-04-21T00:01:00.000Z"),
+    });
+
+    mockIssuesApi.get.mockResolvedValue(createIssue({
+      status: "in_review",
+      assigneeAgentId: "agent-1",
+    }));
+    mockIssuesApi.getTreeControlState.mockResolvedValue({
+      activePauseHold: {
+        holdId: "hold-1",
+        rootIssueId: "issue-1",
+        issueId: "issue-1",
+        isRoot: true,
+        mode: "pause",
+        reason: null,
+        releasePolicy: { strategy: "manual", note: "leaf_pause" },
+      },
+    });
+    mockIssuesApi.listTreeHolds.mockResolvedValue([activeHold]);
+    mockIssuesApi.previewTreeControl.mockResolvedValue(createResumePreview());
+    mockIssuesApi.releaseTreeHold.mockResolvedValue(releasedHold);
+    mockAgentsApi.list.mockResolvedValue([createAgent()]);
+    mockAuthApi.getSession.mockResolvedValue({
+      session: { userId: "user-1" },
+      user: { id: "user-1" },
+    });
+
+    await act(async () => {
+      root.render(
+        <QueryClientProvider client={queryClient}>
+          <IssueDetail />
+        </QueryClientProvider>,
+      );
+    });
+    await flushReact();
+    await flushReact();
+
+    await waitForAssertion(() => {
+      expect(container.textContent).toContain("Paused by board.");
+      expect(container.textContent).toContain("in_review");
+      expect(container.textContent).not.toContain("Subtree pause is active.");
+    });
+
+    const resumeButton = Array.from(container.querySelectorAll("button"))
+      .find((button) => button.textContent?.trim() === "Resume work");
+    expect(resumeButton).toBeTruthy();
+
+    await act(async () => {
+      resumeButton!.click();
+    });
+    await flushReact();
+    await flushReact();
+
+    const wakeCheckbox = container.querySelector('input[type="checkbox"]') as HTMLInputElement | null;
+    expect(wakeCheckbox?.checked).toBe(true);
+
+    const applyResumeButton = Array.from(container.querySelectorAll("button"))
+      .filter((button) => button.textContent?.trim() === "Resume work")
+      .at(-1);
+    expect(applyResumeButton).toBeTruthy();
+
+    await act(async () => {
+      applyResumeButton!.click();
+    });
+    await flushReact();
+
+    expect(mockIssuesApi.releaseTreeHold).toHaveBeenCalledWith("PAP-1", "hold-1", {
+      reason: null,
+      metadata: { wakeAgents: true },
+    });
+  });
+
   it("exposes restore subtree from the issue actions menu", async () => {
     const childIssue = createIssue({
       id: "child-1",