@quickchatai/quickreview 1.1.0 → 1.3.1

package/src/wire.ts

@@ -30,7 +30,7 @@ import { Archiver } from "./archive/archiver.js";
 import { piGlobalSessionsDir } from "./archive/piglobal.js";
 import { runDirOf, toolUidSplit } from "./ipc/capability.js";
 import { PermitBroker } from "./ipc/permits.js";
-import { LoginRefreshSupervisor } from "./loginrefresh/supervisor.js";
+import { LoginRefreshSupervisor, loginDirOf } from "./loginrefresh/supervisor.js";
 import { pendingArchiveStatus } from "./archive/status.js";
 import { Learner, learnerKnobsOf } from "./learner/learner.js";
 import { renderNoPacketSection } from "./learner/packet.js";
@@ -54,7 +54,11 @@ import { priorSidecarPath } from "@quickchatai/pi-quickreview/src/priorfindings.
 import { completeRecordedFindings } from "./recordedfindings.js";
 import { makePostingGuard } from "@quickchatai/pi-quickreview/src/guards.js";
 import { classifyCi, ciBlocksApproval } from "@quickchatai/pi-quickreview/src/cigate.js";
-import { TokenMinter } from "@quickchatai/pi-quickreview/src/githubAuth.js";
+import {
+  githubCredential,
+  type GitHubCredential,
+} from "@quickchatai/pi-quickreview/src/githubAuth.js";
+import { botAccountLogin, isPersonMode } from "@quickchatai/pi-quickreview/src/identity.js";
 import {
   FeedbackEngine,
   FeedbackMemoryPump,
@@ -125,6 +129,7 @@ import {
 } from "./openviking/provisionreport.js";
 import { countedGapSink } from "./openviking/gapsink.js";
 import { recoverPrForOperator } from "./operator-recovery.js";
+import { reviewNow } from "./reviewnow.js";
 import { createWorkerLiveness, inFlightPrs } from "./workerliveness.js";
 import { resolveTerminalFailure } from "./terminal-failure.js";
 import type { MemoryStore } from "./memory/store.js";
@@ -158,7 +163,8 @@ import { buildWorkerWorld } from "./workerworld.js";
 export interface ProductionParts {
   cfg: Config;
   root: string;
-  minter: TokenMinter;
+  /** The `[github] auth` credential: the App minter, or the person's token file. */
+  minter: GitHubCredential;
   gate: MutationGate;
   adapter: GitHubAdapter;
   /** The tmux manager: it serves what has not moved to workers yet (the overseer) and
@@ -225,7 +231,7 @@ export function buildParts(
     process.env.QCR_OPENVIKING_BOOT_DISABLED === "1" && overlaid.openviking.enabled
       ? "OpenViking state migration is incomplete; memory is unavailable for this boot — original files were retained; retry after correcting storage and restarting"
       : undefined;
-  const minter = new TokenMinter(cfg.github.secrets_dir);
+  const minter = githubCredential(cfg.github);
   const gate: MutationGate = new MutationGate(
     cfg.dry_run,
     join(root, "state", "dryrun"),
@@ -764,6 +770,9 @@ export function createProductionDaemon(parts: ProductionParts = buildParts()): D
   // src/workerworld.ts. No config key picks the tmux route, and nothing births a
   // `pr-<n>` tmux session any more; `sessions` serves paths, worktrees and the replay harness.
   const agentDir = process.env["PI_CODING_AGENT_DIR"]?.trim() || join(homedir(), ".pi", "agent");
+  // The login itself: the agent dir, or the host's shared login on a single
+  // box (one login per box): the refresher owns it and every worker borrows it.
+  const loginDir = loginDirOf(process.env, agentDir);
   const workerWorld = buildWorkerWorld({
     cfg,
     root,
@@ -777,6 +786,7 @@ export function createProductionDaemon(parts: ProductionParts = buildParts()): D
     ...(parts.ovSessions ? { ovSessions: parts.ovSessions } : {}),
     permits: lensPermits,
     agentDir,
+    loginDir,
     pump: () => daemon.pump(),
     loginGate: {
       paused: () => loginRefresh?.paused() ?? false,
@@ -1052,7 +1062,9 @@ export function createProductionDaemon(parts: ProductionParts = buildParts()): D
     // the base clone; the daemon's own bot identity never qualifies.
     directiveAuthor: (sha, paths) =>
       sessions.worktrees.lastHumanAuthor(sha, paths, {
-        botLogins: [cfg.github.bot_login, cfg.github.app_slug],
+        // Person mode has no bot account: the person's own commits are a
+        // human's, and they may well be the one to mention.
+        botLogins: isPersonMode(cfg.github) ? [] : [cfg.github.bot_login, cfg.github.app_slug],
       }),
     log,
     // Lazy on purpose: the Slack subsystem is built in onStart, after the
@@ -1552,7 +1564,9 @@ export function createProductionDaemon(parts: ProductionParts = buildParts()): D
           outcomes: d.outcomes,
           memory,
           repo: cfg.github.repo,
-          botLogin: cfg.github.bot_login,
+          // The bot ACCOUNT, against captured human comments: none in person
+          // mode, where the person's replies are a human's.
+          botLogin: botAccountLogin(cfg.github),
           healthy: () => health.currentState() === "healthy",
           // No case batch starts while a review round reads memory (its seed,
           // its lesson selection); every batch sent reports its embedding
@@ -1580,7 +1594,7 @@ export function createProductionDaemon(parts: ProductionParts = buildParts()): D
           root,
           eodTime: cfg.eod.time,
           timeZone: cfg.eod.timezone,
-          botLogin: cfg.github.bot_login,
+          botLogin: botAccountLogin(cfg.github),
           baseBranch: cfg.github.base_branch,
           config: learnerKnobsOf(cfg.memory),
           git: sessions.worktrees,
@@ -1617,7 +1631,7 @@ export function createProductionDaemon(parts: ProductionParts = buildParts()): D
       if (cfg.login_refresh.enabled) {
         loginRefresh = new LoginRefreshSupervisor({
           repoRoot: root,
-          agentDir,
+          agentDir: loginDir,
           marginMin: cfg.login_refresh.margin_min,
           log,
           // One anomaly per failure episode, through the one durable funnel.
@@ -1696,6 +1710,21 @@ export function createProductionDaemon(parts: ProductionParts = buildParts()): D
             "restart-session",
           );
         },
+        // The operator's "review this PR now" (the onboarding proof round):
+        // the label path's state-machine trigger, with no GitHub write to ask.
+        reviewNow(pr) {
+          return reviewNow(
+            {
+              store: d.store,
+              getPr: (n) => adapter.getPr(n),
+              pump: () => d.pump(),
+              // On the own-account route the bot login is the person, whose
+              // own PRs are the point; only an App's bot is never reviewed.
+              ...(isPersonMode(cfg.github) ? {} : { botLogin: cfg.github.bot_login }),
+            },
+            pr,
+          );
+        },
         resolveTerminalFailure(payload) {
           return resolveTerminalFailure(
             {
@@ -1861,7 +1890,9 @@ export function createProductionDaemon(parts: ProductionParts = buildParts()): D
       // Webhook-URL self-heal: only under the tunnel-file ingress shape. The
       // gated PATCH rides the app-self-config class, so it executes even in
       // dry-run (AGENTS.md invariant 6) — loudly.
-      if (cfg.ingress.shape === "tunnel-file") {
+      // Never under the person's credential: there is no App whose webhook
+      // URL could be re-pointed (config load already refuses the shape).
+      if (cfg.ingress.shape === "tunnel-file" && !isPersonMode(cfg.github)) {
         webhookHeal = new WebhookHealer({
           hostnameFile: ingressHostnameFile(cfg, root),
           readConfig: () => adapter.getAppWebhookConfig(),
@@ -2112,6 +2143,8 @@ export function createProductionDaemon(parts: ProductionParts = buildParts()): D
       adapter,
       botLogin: cfg.github.bot_login,
       guards: cfg.guards,
+      // Person mode: every review event posts as COMMENT (guards.ts).
+      personMode: isPersonMode(cfg.github),
       log,
     }),
   );

package/src/workerworld.ts

@@ -18,6 +18,7 @@
 // PiSessionManager that still exists serves what has not moved yet (the overseer, for now)
 // and lends its path helpers and environment, which is what keeps a worker's session the same
 // session a tmux round saw.
+import { isPersonMode } from "@quickchatai/pi-quickreview/src/identity.js";
 import { mkdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { AnswerHost, answerCapsOf } from "./answerworker.js";
@@ -26,6 +27,7 @@ import type { Config } from "./config.js";
 import { DebugRoundManager } from "./debuground.js";
 import type { FileOutcome } from "./improvements.js";
 import { identityVars } from "@quickchatai/pi-quickreview/src/include.js";
+import { reviewProviders } from "@quickchatai/pi-quickreview/src/modelroute.js";
 import {
   CapabilityStore,
   LaunchFiles,
@@ -88,8 +90,12 @@ export interface WorkerWorldOptions {
   sessions: PiSessionManager;
   ovSessions?: OvSessionLifecycle;
   permits: PermitBroker;
-  /** pi's agent dir: where the login lives (the refresher keeps it). */
+  /** pi's agent dir: models.json, settings and the built lens agents. */
   agentDir: string;
+  /** Where the login lives (the refresher keeps it): the agent dir, unless
+   * the single box's shared login is mounted elsewhere (supervisor.ts
+   * `loginDirOf`). */
+  loginDir?: string;
   /** Run the daemon's pump (a lease freed, a worker gone). Late-bound: the daemon is built
    * after this. */
   pump: () => Promise<void>;
@@ -205,6 +211,8 @@ export function buildWorkerWorld(o: WorkerWorldOptions): WorkerWorld {
       root,
       cwd: root,
       agent_dir: o.agentDir,
+      ...(o.loginDir !== undefined && o.loginDir !== o.agentDir ? { login_dir: o.loginDir } : {}),
+      providers: reviewProviders(cfg),
       session_dir: sessions.sessionDir(row.session),
       system_prompt_file: sessions.writeSystemPrompt(row.session, prompt),
       model: cfg.models.conversation,
@@ -223,6 +231,7 @@ export function buildWorkerWorld(o: WorkerWorldOptions): WorkerWorld {
   const journal = new PostingJournal({
     dir: join(stateDir, "posting-receipts"),
     repo: cfg.github.repo,
+    personMode: isPersonMode(cfg.github),
   });
 
   // The takeover and debug managers are built before the supervisor (it takes their gates)
@@ -253,6 +262,7 @@ export function buildWorkerWorld(o: WorkerWorldOptions): WorkerWorld {
       takeoverPlanFor({
         root,
         agentDir: o.agentDir,
+        ...(o.loginDir !== undefined ? { loginDir: o.loginDir } : {}),
         sessionsRoot: sessions.sessionsRoot(),
         model: cfg.models.conversation,
         pr,
@@ -311,7 +321,11 @@ export function buildWorkerWorld(o: WorkerWorldOptions): WorkerWorld {
       store,
       journal,
       cfg,
-      botLogins: [cfg.github.bot_login, cfg.github.app_slug],
+      // Marker-matched (posting-outbox.ts markedReviewsOf), so the person's
+      // login alone is safe in person mode: there is no App slug to add.
+      botLogins: isPersonMode(cfg.github)
+        ? [cfg.github.bot_login]
+        : [cfg.github.bot_login, cfg.github.app_slug],
       roundOf: commandRoundOf(store, headOf),
       log,
     },

package/dist/src/live/projection.js

@@ -1,450 +0,0 @@
-// The round-progress v2 projection of a LiveEvent log.
-//
-// extensions/round-progress.ts publishes `state/round-progress/pr-<n>.json`
-// (and the append-only transition log beside it) from inside the tmux pi, by
-// listening to pi's events. This module reproduces both from the LiveEvent log
-// alone, so the engine routes - which have no such extension - and a viewer
-// reading a finished or running round all get the same snapshot, with the
-// contract in packages/pi-plugin/src/round-progress.ts unchanged: board.ts, requiredpasses.ts and
-// the supervisor read it as they always have.
-//
-// The extension is the REFERENCE. Every rule here mirrors the handler it
-// stands for, line by line, because the golden test
-// (tests/live-projection-golden.test.ts) holds the two byte-equal on the same
-// events. The one place the log is coarser than pi's stream is time: a held
-// update is stamped at its window's flush (~250 ms), so a heartbeat or a
-// `started_at` taken from an update can differ from the extension's by that
-// much. Nothing the supervisor decides on (the milestones' order, statuses,
-// command identity) depends on it.
-import { parseSessionCommandMarker } from "@quickchatai/pi-quickreview/src/session-command.js";
-import { isLiveAgentStatus, } from "@quickchatai/pi-quickreview/src/round-progress.js";
-function text(value) {
-    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
-}
-function number(value) {
-    return typeof value === "number" && Number.isFinite(value) ? Math.max(0, value) : 0;
-}
-function status(value, exitCode) {
-    if (isLiveAgentStatus(value))
-        return value;
-    return exitCode === 0 ? "completed" : exitCode === undefined ? "running" : "failed";
-}
-/** The round number rides the order's posting calls (`QCR_ROUND_NO=<k>`, with
- * or without `export`); the head rides the Worktree line. */
-function reviewIdentity(body) {
-    const round = /(?:^|\s)(?:export )?QCR_ROUND_NO=(\d+)(?=\s|$)/.exec(body);
-    const head = /\*\*Worktree\*\*:[^\n]* @ `([^`]+)`/.exec(body);
-    if (!round || !head)
-        return undefined;
-    const roundNo = Number(round[1]);
-    return Number.isInteger(roundNo) && roundNo > 0
-        ? { round_no: roundNo, head_sha: head[1] }
-        : undefined;
-}
-function currentTool(progress) {
-    if (!Array.isArray(progress?.recent_tools))
-        return undefined;
-    const tools = progress.recent_tools;
-    const picked = [...tools].reverse().find((x) => x.status === "running") ?? tools.at(-1);
-    if (!picked)
-        return undefined;
-    const name = text(picked.tool) ?? "tool";
-    const args = text(picked.args);
-    return args ? `${name}: ${args.slice(0, 120)}` : name;
-}
-function asAgent(result, fallbackAgent, live = false) {
-    const agent = text(result.agent) ?? fallbackAgent;
-    if (!agent)
-        return undefined;
-    const progress = result.progress;
-    const native = result.native ?? { tool_count: 0 };
-    const error = text(progress?.error) ?? text(result.error_message);
-    const exit = result.exit_code;
-    const nativeFailed = (typeof exit === "number" && exit > 0) ||
-        result.stop_reason === "error" ||
-        result.stop_reason === "aborted";
-    const st = isLiveAgentStatus(progress?.status)
-        ? progress.status
-        : nativeFailed
-            ? "failed"
-            : live || exit === -1 || exit === undefined
-                ? "running"
-                : status(undefined, exit);
-    const tool = currentTool(progress) ?? (live ? native.last_tool : undefined);
-    const last = text(progress?.last_message) ?? native.last_text;
-    return {
-        agent,
-        status: st,
-        duration_ms: number(progress?.duration_ms),
-        tool_count: number(progress?.tool_count) || native.tool_count,
-        ...(tool ? { current_tool: tool } : {}),
-        ...(last ? { last_message: last } : {}),
-        ...(error ? { error } : {}),
-    };
-}
-export class RoundProgressProjection {
-    who;
-    snapshotState;
-    written;
-    log = [];
-    lastHeartbeat = 0;
-    clock = "";
-    agents = new Map();
-    callAgents = new Map();
-    runKeys = new Map();
-    endLogged = new Set();
-    /** The children of each open lens call, rebuilt from the changed slots. */
-    calls = new Map();
-    constructor(who) {
-        this.who = who;
-    }
-    /** The snapshot as its file would hold it now (the last write). */
-    get snapshot() {
-        return this.written === undefined
-            ? undefined
-            : JSON.parse(this.written);
-    }
-    /** The bytes of `pr-<n>.json`. */
-    get snapshotJson() {
-        return this.written;
-    }
-    /** The transition lines, in order. */
-    get transitions() {
-        return this.log;
-    }
-    /** The bytes of `pr-<n>.jsonl` (before its size-cap rotation). */
-    get transitionsJsonl() {
-        return this.log.map((l) => `${JSON.stringify(l)}\n`).join("");
-    }
-    apply(event) {
-        this.clock = event.at;
-        switch (event.type) {
-            case "agent_start":
-                return this.agentStart();
-            case "message_start":
-                return this.messageStart(event.role, event.text);
-            case "turn_start":
-            case "message_delta":
-                return this.heartbeat();
-            case "tool_start":
-                return this.toolStart(event);
-            case "tool_update":
-                return this.toolUpdate(event);
-            case "tool_end":
-                return this.toolEnd(event);
-            case "agent_settled":
-                return this.settled();
-            default:
-                return;
-        }
-    }
-    // ---- the extension's helpers --------------------------------------------------
-    nowIso() {
-        return this.clock;
-    }
-    bindRun(run, key) {
-        if (run === null)
-            return key;
-        const held = this.runKeys.get(run);
-        if (held !== undefined)
-            return held;
-        this.runKeys.set(run, key);
-        return key;
-    }
-    executionKeys(callId, names) {
-        const seen = new Map();
-        return names.map((agent) => {
-            const n = (seen.get(agent) ?? 0) + 1;
-            seen.set(agent, n);
-            return n === 1 ? `${callId}:${agent}` : `${callId}:${agent}#${n}`;
-        });
-    }
-    write() {
-        const snapshot = this.snapshotState;
-        if (!snapshot)
-            return;
-        snapshot.updated_at = this.nowIso();
-        snapshot.agents = [...this.agents.values()];
-        this.written = `${JSON.stringify(snapshot)}\n`;
-    }
-    transition(entry) {
-        const snapshot = this.snapshotState;
-        if (!snapshot)
-            return;
-        this.log.push({
-            at: this.nowIso(),
-            pr: this.who.pr,
-            session: this.who.session,
-            run_started_at: snapshot.run_started_at,
-            ...(snapshot.command_id ? { command_id: snapshot.command_id } : {}),
-            ...entry,
-        });
-    }
-    passEnded(agent) {
-        const key = agent.execution_id;
-        if (!key || agent.status === "running" || this.endLogged.has(key))
-            return;
-        this.endLogged.add(key);
-        this.transition({
-            event: "pass_end",
-            execution_id: key,
-            agent: agent.agent,
-            status: agent.status,
-        });
-    }
-    fanoutSeen() {
-        const snapshot = this.snapshotState;
-        if (!snapshot || this.agents.size === 0)
-            return;
-        snapshot.first_lens_started_at ??= this.nowIso();
-        snapshot.fanout_started_at ??= snapshot.first_lens_started_at;
-    }
-    activity(description) {
-        const snapshot = this.snapshotState;
-        if (!snapshot)
-            return;
-        snapshot.last_activity = description;
-        snapshot.last_activity_at = this.nowIso();
-        this.write();
-    }
-    heartbeat() {
-        if (!this.snapshotState)
-            return;
-        const now = Date.parse(this.clock);
-        if (now - this.lastHeartbeat < 1_000)
-            return;
-        this.lastHeartbeat = now;
-        this.write();
-    }
-    freshSnapshot(lastActivity) {
-        const at = this.nowIso();
-        this.agents.clear();
-        this.callAgents.clear();
-        this.runKeys.clear();
-        this.endLogged.clear();
-        return {
-            version: 2,
-            pr: this.who.pr,
-            session: this.who.session,
-            run_started_at: at,
-            updated_at: at,
-            parent_status: "active",
-            last_activity_at: at,
-            last_activity: lastActivity,
-            agents: [],
-        };
-    }
-    /** The children of a call after this line: the slots it carries laid over
-     * what the call's earlier lines left. */
-    merge(id, n, changed) {
-        const held = this.calls.get(id) ?? [];
-        for (const r of changed)
-            held[r.slot] = r;
-        const full = Array.from({ length: n }, (_, slot) => held[slot] ?? { slot });
-        this.calls.set(id, full);
-        return full;
-    }
-    // ---- the handlers ---------------------------------------------------------------
-    agentStart() {
-        // pi's automatic retry or queued continuation emits another agent_start
-        // inside the SAME outer run: an inner start keeps the run's command,
-        // milestones and passes.
-        if (this.snapshotState && this.snapshotState.parent_status === "active") {
-            this.activity("parent run continued");
-            return;
-        }
-        this.snapshotState = this.freshSnapshot("parent run started");
-        this.write();
-        this.transition({ event: "parent_start" });
-    }
-    messageStart(role, body) {
-        const snapshot = this.snapshotState;
-        if (!snapshot || role !== "user" || !body)
-            return;
-        const marker = parseSessionCommandMarker(body);
-        if (!marker)
-            return;
-        // A different command in a run that has one already is a new execution.
-        let current = snapshot;
-        if (current.command_id !== undefined && current.command_id !== marker.id) {
-            current = this.freshSnapshot("parent run started");
-            this.snapshotState = current;
-        }
-        current.command_id = marker.id;
-        current.command_sha256 = marker.payloadSha256;
-        const identity = reviewIdentity(body);
-        if (identity) {
-            current.round_no = identity.round_no;
-            current.head_sha = identity.head_sha;
-        }
-        const firstAcceptance = current.command_accepted_at === undefined;
-        current.command_accepted_at ??= this.nowIso();
-        current.preparing_at ??= current.command_accepted_at;
-        if (firstAcceptance)
-            this.transition({
-                event: "command_accepted",
-                ...(current.round_no !== undefined ? { round_no: current.round_no } : {}),
-                ...(current.head_sha !== undefined ? { head_sha: current.head_sha } : {}),
-            });
-        this.activity(`command ${marker.id} accepted; parent preparing compact fanout context`);
-    }
-    toolStart(ev) {
-        const snapshot = this.snapshotState;
-        if (!snapshot)
-            return;
-        const executions = ev.executions ?? [];
-        if (executions.length > 0) {
-            const names = executions.map(({ agent }) => agent);
-            const at = this.nowIso();
-            this.callAgents.set(ev.id, names);
-            const keys = this.executionKeys(ev.id, names);
-            for (const [index, agent] of names.entries()) {
-                const key = keys[index];
-                const phase = executions[index]?.phase;
-                this.agents.set(key, {
-                    execution_id: key,
-                    agent,
-                    ...(phase ? { phase } : {}),
-                    status: "running",
-                    duration_ms: 0,
-                    tool_count: 0,
-                    started_at: at,
-                });
-                this.transition({ event: "pass_start", execution_id: key, agent });
-            }
-            snapshot.first_lens_started_at ??= at;
-            snapshot.fanout_started_at ??= snapshot.first_lens_started_at;
-            snapshot.active_tool = `subagent: ${names.join(", ")}`;
-            this.activity(`${names.join(", ")} started`);
-            return;
-        }
-        snapshot.active_tool = ev.preview ? `${ev.tool}: ${ev.preview}` : ev.tool;
-        this.activity(snapshot.active_tool);
-    }
-    toolUpdate(ev) {
-        const snapshot = this.snapshotState;
-        if (!snapshot)
-            return;
-        const fallbacks = this.callAgents.get(ev.id) ?? [];
-        const reported = this.merge(ev.id, ev.n, ev.results);
-        // Native parallel mode marks a still-running slot with exitCode -1 and a
-        // finished one with its real exit code.
-        let changed = false;
-        const updated = reported.flatMap((result, index) => {
-            const agent = asAgent(result, fallbacks[index] ?? (fallbacks.length === 1 ? fallbacks[0] : undefined), ev.mode === "parallel" ? result.exit_code === -1 : true);
-            return agent ? [{ agent, run: result.id ?? null }] : [];
-        });
-        const updateKeys = this.executionKeys(ev.id, updated.map(({ agent }) => agent.agent));
-        for (const [index, { agent, run }] of updated.entries()) {
-            const key = this.bindRun(run, updateKeys[index]);
-            const previous = this.agents.get(key);
-            // A parallel slot can finish while its siblings still run: a terminal
-            // record carries its completion milestone from the first update that
-            // reports it, and a running one never carries one.
-            const { finished_at: previousFinished, ...kept } = previous ?? {};
-            const next = {
-                ...kept,
-                ...agent,
-                execution_id: key,
-                started_at: previous?.started_at ?? this.nowIso(),
-                ...(agent.status === "running" ? {} : { finished_at: previousFinished ?? this.nowIso() }),
-            };
-            this.agents.set(key, next);
-            this.passEnded(next);
-            snapshot.active_tool = `subagent: ${agent.agent}`;
-            changed = true;
-        }
-        this.fanoutSeen();
-        if (changed)
-            this.write();
-        else
-            this.heartbeat();
-    }
-    toolEnd(ev) {
-        const snapshot = this.snapshotState;
-        if (!snapshot)
-            return;
-        const id = ev.id;
-        const fallbacks = this.callAgents.get(id) ?? [];
-        const reported = this.merge(id, ev.n, ev.results);
-        this.calls.delete(id);
-        const finalAgents = [];
-        const ended = reported.flatMap((result, index) => {
-            const agent = asAgent(result, fallbacks[index] ?? (fallbacks.length === 1 ? fallbacks[0] : undefined));
-            return agent ? [{ agent, run: result.id ?? null }] : [];
-        });
-        const endKeys = this.executionKeys(id, ended.map(({ agent }) => agent.agent));
-        for (const [index, { agent, run }] of ended.entries()) {
-            const key = this.bindRun(run, endKeys[index]);
-            const previous = this.agents.get(key);
-            // A child the call returns still running (a placeholder) carries no
-            // finish time, as in toolUpdate: the parser refuses the pair.
-            const { finished_at: previousFinished, ...kept } = previous ?? {};
-            const finalAgent = {
-                ...kept,
-                ...agent,
-                execution_id: key,
-                started_at: previous?.started_at ?? this.nowIso(),
-                ...(agent.status === "running" ? {} : { finished_at: previousFinished ?? this.nowIso() }),
-            };
-            this.agents.set(key, finalAgent);
-            finalAgents.push(finalAgent);
-            this.passEnded(finalAgent);
-        }
-        if (finalAgents.length === 0 && fallbacks.length > 0) {
-            const failed = ev.is_error;
-            const fallbackKeys = this.executionKeys(id, fallbacks);
-            for (const [index, fallback] of fallbacks.entries()) {
-                const key = fallbackKeys[index];
-                const previous = this.agents.get(key);
-                if (previous && previous.status !== "running") {
-                    finalAgents.push(previous);
-                    continue;
-                }
-                const finalAgent = {
-                    ...(previous ?? {
-                        execution_id: key,
-                        agent: fallback,
-                        duration_ms: 0,
-                        tool_count: 0,
-                        started_at: this.nowIso(),
-                    }),
-                    status: failed ? "failed" : "completed",
-                    finished_at: previous?.finished_at ?? this.nowIso(),
-                };
-                this.agents.set(key, finalAgent);
-                finalAgents.push(finalAgent);
-                this.passEnded(finalAgent);
-            }
-        }
-        this.fanoutSeen();
-        this.callAgents.delete(id);
-        snapshot.active_tool = undefined;
-        this.activity(finalAgents.length > 0
-            ? `${finalAgents.map((agent) => `${agent.agent} ${agent.status}`).join(", ")}`
-            : `${ev.tool} ${ev.is_error ? "failed" : "completed"}`);
-    }
-    settled() {
-        const snapshot = this.snapshotState;
-        if (!snapshot)
-            return;
-        snapshot.parent_status = "settled";
-        snapshot.active_tool = undefined;
-        this.activity("parent session settled");
-        this.transition({ event: "parent_settle" });
-    }
-}
-/** Project a main log. The identity (PR, session) comes from its
- * `session_start` line; a log with none, or for a round that has no PR number,
- * projects to nothing - as the extension does nothing outside a numbered PR
- * session. */
-export function projectRoundProgress(events) {
-    const start = events.find((e) => e.type === "session_start");
-    if (start?.type !== "session_start" || start.stream !== "main" || start.pr === null)
-        return undefined;
-    const projection = new RoundProgressProjection({ pr: start.pr, session: start.session });
-    for (const e of events)
-        projection.apply(e);
-    return projection;
-}
-//# sourceMappingURL=projection.js.map