fix: harden journal repair, task detach, subagent prompts, and login cancel (#221)

## Related Issue

No linked issue — maintainer-authored reliability and API work.

## Problem

Five separate gaps:

- A wire journal repair that fails (disk full, backup write refused)
left the journal corrupted, and the next `appendRecord` wrote behind the
corrupted tail. Callers of `flush()` saw success.
- Subagent turns opened in the transcript with no prompt, so the reader
could not see what the subagent was asked to do.
- A running foreground task could only be cancelled, never moved to the
background, over the server API.
- In the VS Code extension, two concurrent opens of the same session for
one view each wrapped the SDK session, so every streamed event was
delivered twice.
- Denying the OpenAI Codex consent page ended as `OpenAI Codex login
failed` after first prompting for the redirect URL, and the web sign-in
page waited out its full TTL.

## What changed

- `repairWireJournal` reports `repaired` / `failed`. `WireService` keeps
the failed repair pending, retries it before the next append, and
rethrows a `RECORDS_WRITE_FAILED` `WireError` from `flush()` when it
still fails, so nothing is appended behind a corrupted tail.
- `turn.started` now carries the prompt for `system_trigger` /
`subagent` origins, and the cold-path grouping folds the opening input
onto that turn. Search extraction still filters those messages out.
- New `POST /api/v1/sessions/{session_id}/tasks/{task_id}:detach`
action, answering `{ detached, status }`. The bash and subagent tools
report a user-initiated detach distinctly from a timeout detach, and
process tasks carry their parent tool call id.
- `PythinkerRuntime` serializes open / attach / detach per webview id,
so concurrent callers cannot both miss the session map.
- The OpenAI Codex callback distinguishes `error=access_denied` from
every other dead end. The CLI reports it as cancelled, and
`CodexLoginFlow` moves the attempt to `cancelled` with a reason instead
of waiting for expiry — the web sign-in page already renders that state.

## Checklist

- [x] I have read the
[CONTRIBUTING](https://github.com/PyModel/pythinker-code/blob/main/CONTRIBUTING.md)
document.
- [ ] I have linked a related issue (external PRs: the issue must have a
maintainer's `/approve`).
- [x] I have added tests that prove my feature works.
- [x] Ran `gen-changesets` skill, or this PR needs no changeset.
- [x] Ran `gen-docs` skill, or this PR needs no doc update.

## Risk

- Risk level: medium. Boundaries touched: session journal persistence,
the tasks REST surface, the VS Code session runtime, and the OAuth
callback.
- The journal change makes a previously silent failure loud: `flush()`
can now reject where it used to resolve. That is the intent — the
alternative is losing the record.
- The detach action is additive; `:cancel` keeps its behavior and its
error codes.
- No new dependency and no lockfile change.

## Verification

All exited 0:

- `pnpm run typecheck`
- `pnpm run lint` (0 errors, pre-existing warnings only)
- `pnpm test` — 1,218 files passed, 12 skipped; 20,522 tests passed, 3
expected fail, 79 skipped, 2 todo
- `pnpm run build`, `pnpm run build:web`, `pnpm run check:web`
- `pnpm sherif`, `node scripts/check-nix-workspace.mjs` (18 workspaces)
- `pnpm -C apps/vscode run typecheck`, `pnpm -C apps/vscode test` (18
files / 369 tests)

Each new guard was proven by mutation — reverting it fails the test that
covers it:

- dropping the `system_trigger`/`subagent` case from
`isDisplayablePromptOrigin` → 1 failure in `loop.test.ts`
- collapsing the per-view serialization → 3 failures in
`pythinker-runtime.test.ts`
- settling the callback with `null` instead of the denial → 1 failure in
`openai-codex-oauth.test.ts`
- folding the denial back into the timeout branch → 1 failure in
`codexLogin.test.ts`

`packages/transcript` and `packages/protocol` are web build inputs, so
`dist-web` was rebuilt; only `.web-bundle-manifest.json` changed.

## Rollback and review

- Rollback: revert the single commit; every change is additive or behind
a new branch.
- Residual risk: the journal `flush()` rejection is a new failure
surface for callers that previously ignored a silent loss.
- Human review wanted on the journal repair retry and the tasks route
split.

<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit

- **New Features**
  - Foreground tasks can now be detached into the background.
- Background tasks and pending questions appear in the client’s
background-task panel.
  - Subagent prompts and attachments display correctly in transcripts.
  - Task details can retain parent tool-call information.

- **Bug Fixes**
- Prevented duplicated streaming output during concurrent session opens.
  - Improved recovery from session journal write failures.
  - Codex sign-in denials now appear as cancelled.
  - Improved task detachment behavior and status reporting.

- **Documentation**
  - Documented task detachment and updated background-task guidance.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

Author: elkaix

.changeset/codex-login-denied-cancelled.md

@@ -0,0 +1,5 @@
+---
+"@pymodel/pythinker-code": patch
+---
+
+Report a denied OpenAI Codex sign-in as cancelled instead of asking for the redirect URL.

.changeset/subagent-turn-prompts.md

@@ -0,0 +1,5 @@
+---
+"@pymodel/pythinker-code": patch
+---
+
+Show the prompt that started a subagent turn in the transcript.

.changeset/task-detach-action.md

@@ -0,0 +1,5 @@
+---
+"@pymodel/pythinker-code": minor
+---
+
+Add a task detach action to the server API. Call `POST /api/v1/sessions/{session_id}/tasks/{task_id}:detach` to move a running foreground task to the background.

.changeset/vscode-duplicated-stream-events.md

@@ -0,0 +1,5 @@
+---
+"pythinker": patch
+---
+
+Fix duplicated streaming output when a session is opened twice at the same time.

.changeset/wire-journal-repair-retry.md

@@ -0,0 +1,5 @@
+---
+"@pymodel/pythinker-code": patch
+---
+
+Retry a failed session journal repair before writing new records, so no message is appended behind a corrupted tail.

apps/pythinker-code/dist-web/.web-bundle-manifest.json

@@ -1,4 +1,4 @@
 {
-  "sourceHash": "d84e17f04092f5fb9afa9f4d323b614d3945ec8e33abbbc92f5793ad2c30959e",
+  "sourceHash": "aa9ad464f74ddd042d5435d29ed27bac364c25274ede0eade5d39cc7593d0eb6",
   "sourceFileCount": 404
 }

apps/vscode/src/runtime/pythinker-runtime.ts

@@ -48,6 +48,7 @@ export class PythinkerRuntime {
   private readonly log: PythinkerRuntimeOptions["log"];
   private readonly sessions = new Map<string, SessionRuntime>();
   private readonly sessionByView = new Map<string, string>();
+  private readonly viewChains = new Map<string, Promise<void>>();
   private readonly pendingPermissionByView = new Map<string, PermissionMode>();
   private closed = false;
 
@@ -101,6 +102,10 @@ export class PythinkerRuntime {
   }
 
   async openSession(options: OpenSessionOptions): Promise<SessionRuntime> {
+    return this.serializeView(options.webviewId, () => this.openSessionInner(options));
+  }
+
+  private async openSessionInner(options: OpenSessionOptions): Promise<SessionRuntime> {
     this.ensureOpen();
     const current = this.getSessionForView(options.webviewId);
     const requestedId = options.sessionId ?? current?.id;
@@ -119,7 +124,7 @@ export class PythinkerRuntime {
     if (runtime !== undefined) {
       assertSessionWorkDir(runtime.session, options.workDir);
       await applySessionPermission(runtime.session, runtime.permissionMode);
-      await this.detachView(options.webviewId);
+      await this.detachViewInner(options.webviewId);
     } else {
       const seedMode = defaultPermissionMode(options.yoloMode);
       const session =
@@ -135,7 +140,7 @@ export class PythinkerRuntime {
       try {
         assertSessionWorkDir(session, options.workDir);
         const mode = await restorePermissionMode(session, seedMode);
-        await this.detachView(options.webviewId);
+        await this.detachViewInner(options.webviewId);
         runtime = this.wrapSession(session, mode);
       } catch (error) {
         await session.close().catch((closeError: unknown) => {
@@ -156,14 +161,24 @@ export class PythinkerRuntime {
     webviewId: string,
     session: Session,
     yoloModeSetting = false,
+  ): Promise<SessionRuntime> {
+    return this.serializeView(webviewId, () =>
+      this.attachResumedSessionInner(webviewId, session, yoloModeSetting),
+    );
+  }
+
+  private async attachResumedSessionInner(
+    webviewId: string,
+    session: Session,
+    yoloModeSetting: boolean,
   ): Promise<SessionRuntime> {
     const existing = this.sessions.get(session.id);
     if (existing !== undefined && this.sessionByView.get(webviewId) === session.id) {
       existing.subscribe(webviewId);
       await existing.announceStatus(webviewId);
       return existing;
     }
-    await this.detachView(webviewId);
+    await this.detachViewInner(webviewId);
     let runtime = existing ?? this.sessions.get(session.id);
     if (runtime === undefined) {
       try {
@@ -184,6 +199,10 @@ export class PythinkerRuntime {
   }
 
   async detachView(webviewId: string): Promise<void> {
+    return this.serializeView(webviewId, () => this.detachViewInner(webviewId));
+  }
+
+  private async detachViewInner(webviewId: string): Promise<void> {
     const id = this.sessionByView.get(webviewId);
     if (id === undefined) return;
     this.sessionByView.delete(webviewId);
@@ -196,6 +215,23 @@ export class PythinkerRuntime {
     }
   }
 
+  // A view attaches to at most one session, so opens/detaches for one view
+  // must never overlap: concurrent callers that both miss `this.sessions`
+  // would wrap the same SDK session twice and double every streamed event.
+  private serializeView<T>(webviewId: string, work: () => Promise<T>): Promise<T> {
+    const prev = this.viewChains.get(webviewId) ?? Promise.resolve();
+    const run = prev.then(work, work);
+    const next = run.then(
+      () => undefined,
+      () => undefined,
+    );
+    this.viewChains.set(webviewId, next);
+    void next.finally(() => {
+      if (this.viewChains.get(webviewId) === next) this.viewChains.delete(webviewId);
+    });
+    return run;
+  }
+
   async closeSession(id: string): Promise<void> {
     const runtime = this.sessions.get(id);
     if (runtime === undefined) {

apps/vscode/test/pythinker-runtime.test.ts

@@ -382,6 +382,91 @@ describe("Pythinker runtime (owns shared SDK sessions for Webviews)", () => {
     expect(boundary.handlerInstallations).toEqual({ approval: 1, question: 1 });
   });
 
+  it("does not double-wrap the SDK session when two opens race for it", async () => {
+    const sdk = createFakeHarness();
+    const broadcasts: { event: string; data: unknown; webviewId?: string }[] = [];
+    const runtime = new PythinkerRuntime({
+      version: "0.6.0",
+      harness: sdk.harness,
+      broadcast: (event, data, webviewId) => {
+        broadcasts.push({ event, data, webviewId });
+      },
+      captureBaseline: () => undefined,
+      log: () => undefined,
+    });
+    const boundary = sdk.addSession("saved-1", "/workspace");
+
+    const [first, second] = await Promise.all([
+      runtime.openSession(openOptions({ sessionId: "saved-1" })),
+      runtime.openSession(openOptions({ sessionId: "saved-1" })),
+    ]);
+
+    expect(second).toBe(first);
+    expect(boundary.subscriptionCount()).toBe(1);
+
+    boundary.emit({
+      type: "assistant.delta",
+      sessionId: "saved-1",
+      agentId: "main",
+      turnId: 1,
+      delta: "Hello",
+    });
+
+    const parts = broadcasts.filter(
+      ({ data }) => (data as { type?: string }).type === "ContentPart",
+    );
+    expect(parts).toHaveLength(1);
+  });
+
+  it("coalesces two concurrent new-session opens for one view onto one session", async () => {
+    const { runtime, sdk } = createRuntime();
+
+    const [first, second] = await Promise.all([
+      runtime.openSession(openOptions()),
+      runtime.openSession(openOptions()),
+    ]);
+
+    expect(second).toBe(first);
+    expect(sdk.createInputs).toHaveLength(1);
+    expect(first.subscribers).toEqual(["view-1"]);
+  });
+
+  it("does not double-wrap the SDK session when two attaches race for it", async () => {
+    const sdk = createFakeHarness();
+    const broadcasts: { event: string; data: unknown; webviewId?: string }[] = [];
+    const runtime = new PythinkerRuntime({
+      version: "0.6.0",
+      harness: sdk.harness,
+      broadcast: (event, data, webviewId) => {
+        broadcasts.push({ event, data, webviewId });
+      },
+      captureBaseline: () => undefined,
+      log: () => undefined,
+    });
+    const boundary = sdk.addSession("saved-1", "/workspace");
+
+    const [first, second] = await Promise.all([
+      runtime.attachResumedSession("view-1", boundary.session),
+      runtime.attachResumedSession("view-1", boundary.session),
+    ]);
+
+    expect(second).toBe(first);
+    expect(boundary.subscriptionCount()).toBe(1);
+
+    boundary.emit({
+      type: "assistant.delta",
+      sessionId: "saved-1",
+      agentId: "main",
+      turnId: 1,
+      delta: "Hello",
+    });
+
+    const parts = broadcasts.filter(
+      ({ data }) => (data as { type?: string }).type === "ContentPart",
+    );
+    expect(parts).toHaveLength(1);
+  });
+
   it("preserves the resumed session's model instead of reapplying the configured default", async () => {
     const { runtime, sdk } = createRuntime();
     const session = sdk.addSession("saved-1", "/workspace", { model: "old-model" });

docs/reference/server-api.md

@@ -177,6 +177,7 @@ Endpoints are grouped by resource below. A `:{action}` suffix in a path is the a
 | `GET /api/v1/sessions/{session_id}/tasks` | List background tasks |
 | `GET /api/v1/sessions/{session_id}/tasks/{task_id}` | Read a task (optional output preview) |
 | `POST /api/v1/sessions/{session_id}/tasks/{task_id}:cancel` | Cancel a task |
+| `POST /api/v1/sessions/{session_id}/tasks/{task_id}:detach` | Move a foreground task to the background |
 
 ### Skills, tools, and MCP
 

packages/agent-core-v2/docs/state-manifest.d.ts

@@ -1353,6 +1353,7 @@ export interface AgentStateSnapshot {
     readonly command: string;
     readonly pid: number;
     readonly exitCode: number | null;
+    readonly parentToolCallId?: string;
     readonly taskId: string;
     readonly description: string;
     readonly status: /* AgentTaskStatus — packages/agent-core-v2/src/agent/task/types.ts */ 'completed' | 'failed' | 'running' | 'timed_out' | 'killed' | 'lost';
@@ -1400,6 +1401,7 @@ export interface AgentStateSnapshot {
     readonly command: string;
     readonly pid: number;
     readonly exitCode: number | null;
+    readonly parentToolCallId?: string;
     readonly taskId: string;
     readonly description: string;
     readonly status: /* AgentTaskStatus — packages/agent-core-v2/src/agent/task/types.ts */ 'completed' | 'failed' | 'running' | 'timed_out' | 'killed' | 'lost';