@open-mercato/cezar 0.9.1 → 0.9.2-pr710.1256

package/dist/runs/store.d.ts

@@ -1,5 +1,6 @@
 import { EventEmitter } from 'node:events';
 import { z } from 'zod';
+import type { RunnerId } from '../core/agent-runner.ts';
 export type RunStatus = 'queued' | 'running' | 'waiting' | 'review' | 'done' | 'failed' | 'cancelled';
 /**
  * A sub-state of `running` (spec 2026-07-18-subagent-monitoring-status, #490):
@@ -13,46 +14,43 @@ export type StepStatus = 'pending' | 'running' | 'waiting' | 'review' | 'done' |
 declare const stepStateSchema: z.ZodObject<{
     id: z.ZodString;
     name: z.ZodString;
-    kind: z.ZodEnum<["agent", "check"]>;
-    status: z.ZodEnum<["pending", "running", "waiting", "review", "done", "failed", "cancelled", "skipped"]>;
+    kind: z.ZodEnum<{
+        agent: "agent";
+        check: "check";
+    }>;
+    status: z.ZodEnum<{
+        cancelled: "cancelled";
+        done: "done";
+        failed: "failed";
+        pending: "pending";
+        review: "review";
+        running: "running";
+        skipped: "skipped";
+        waiting: "waiting";
+    }>;
     iterations: z.ZodNumber;
     tokensUsed: z.ZodNumber;
+    inputTokens: z.ZodOptional<z.ZodNumber>;
+    outputTokens: z.ZodOptional<z.ZodNumber>;
+    usageInvocationsStarted: z.ZodOptional<z.ZodNumber>;
+    usageInvocationsObserved: z.ZodOptional<z.ZodNumber>;
+    usageTurnsStarted: z.ZodOptional<z.ZodNumber>;
+    usageTurnsRecorded: z.ZodOptional<z.ZodNumber>;
+    usageInvocationEpoch: z.ZodOptional<z.ZodNumber>;
     startedAt: z.ZodOptional<z.ZodString>;
     finishedAt: z.ZodOptional<z.ZodString>;
     error: z.ZodOptional<z.ZodString>;
-    /** Latest backend-owned session id, used for same-backend Continue. */
     sessionId: z.ZodOptional<z.ZodString>;
-    /** Backend that owns `sessionId`. Optional so pre-affinity runs.json files still parse. */
-    backend: z.ZodOptional<z.ZodEnum<["claude", "codex", "opencode"]>>;
-    /** Dollar cost reported by the claude CLI for this step's turns. */
+    backend: z.ZodOptional<z.ZodPipe<z.ZodEnum<{
+        claude: "claude";
+        "claude-cli": "claude-cli";
+        codex: "codex";
+        opencode: "opencode";
+        pi: "pi";
+    }>, z.ZodTransform<"claude" | "codex" | "opencode" | "pi", "claude" | "claude-cli" | "codex" | "opencode" | "pi">>>;
+    profileId: z.ZodOptional<z.ZodString>;
     costUsd: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    id: string;
-    name: string;
-    kind: "agent" | "check";
-    status: "cancelled" | "done" | "failed" | "pending" | "review" | "running" | "skipped" | "waiting";
-    iterations: number;
-    tokensUsed: number;
-    startedAt?: string | undefined;
-    finishedAt?: string | undefined;
-    error?: string | undefined;
-    sessionId?: string | undefined;
-    backend?: "claude" | "codex" | "opencode" | undefined;
-    costUsd?: number | undefined;
-}, {
-    id: string;
-    name: string;
-    kind: "agent" | "check";
-    status: "cancelled" | "done" | "failed" | "pending" | "review" | "running" | "skipped" | "waiting";
-    iterations: number;
-    tokensUsed: number;
-    startedAt?: string | undefined;
-    finishedAt?: string | undefined;
-    error?: string | undefined;
-    sessionId?: string | undefined;
-    backend?: "claude" | "codex" | "opencode" | undefined;
-    costUsd?: number | undefined;
-}>;
+}, z.core.$strip>;
 /** One prompt message stacked onto a run while it waits for a free agent slot
  *  (#472). Folded into `{{task}}` at dequeue by `hydrateQueuedInput`; never
  *  delivered as its own turn — a follow-up turn would reach only the first step
@@ -60,365 +58,174 @@ declare const stepStateSchema: z.ZodObject<{
 declare const queuedMessageSchema: z.ZodObject<{
     id: z.ZodString;
     text: z.ZodString;
-    /** `/api/runs/:id/images/…` URLs — the base64 never enters `runs.json`. */
-    images: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    images: z.ZodOptional<z.ZodArray<z.ZodString>>;
     createdAt: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    id: string;
-    text: string;
-    images?: string[] | undefined;
-    createdAt: string;
-}, {
-    id: string;
-    text: string;
-    images?: string[] | undefined;
-    createdAt: string;
-}>;
-declare const runRecordSchema: z.ZodObject<{
+}, z.core.$strip>;
+/** Exported for `./run-index.ts`, the read-only reader of the same file. Nothing else should
+ *  parse `runs.json` — see `reconcileLoadedRun` for why a second parser is a correctness risk. */
+export declare const runRecordSchema: z.ZodObject<{
     id: z.ZodString;
     title: z.ZodString;
-    /** Display title (#389): the auto-derived summary of the first agent turn,
-     *  or the user's inline edit (`PATCH /api/runs/:id` sets it together with
-     *  `title` so edits always win). The UI shows `titleSummary ?? title`. */
     titleSummary: z.ZodOptional<z.ZodString>;
-    /** `git diff --shortstat` of the worktree vs its base, refreshed on every
-     *  turn-end (#389) — what the quick list / table shows without a git call. */
     diffStat: z.ZodOptional<z.ZodObject<{
         adds: z.ZodNumber;
         dels: z.ZodNumber;
         files: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        adds: number;
-        dels: number;
-        files: number;
-    }, {
-        adds: number;
-        dels: number;
-        files: number;
-    }>>;
+        repointed: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
     workflow: z.ZodString;
     task: z.ZodString;
-    /** Prompt messages stacked onto this run while it was queued (#472). Optional:
-     *  `undefined` on every pre-#472 record reads as an empty stack. Like `task`,
-     *  `text` is the user's own prompt and is replayed into `{{task}}`, so it is
-     *  deliberately NOT in `redactPatch`'s field list — scrubbing it would corrupt
-     *  the run the same way scrubbing `task` would. */
     queuedMessages: z.ZodOptional<z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         text: z.ZodString;
-        /** `/api/runs/:id/images/…` URLs — the base64 never enters `runs.json`. */
-        images: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        images: z.ZodOptional<z.ZodArray<z.ZodString>>;
         createdAt: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        id: string;
-        text: string;
-        images?: string[] | undefined;
-        createdAt: string;
-    }, {
-        id: string;
-        text: string;
-        images?: string[] | undefined;
-        createdAt: string;
-    }>, "many">>;
-    /** URLs of images attached to the initial task prompt, for the thread's first bubble
-     *  (#image-display) — persisted like agent screenshots, served from `/images/`. */
-    taskImages: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, z.core.$strip>>>;
+    taskImages: z.ZodOptional<z.ZodArray<z.ZodString>>;
     model: z.ZodOptional<z.ZodString>;
-    /** Canonical provider/model identity (#405) — the normalised `provider/model`
-     *  (e.g. `anthropic/claude-opus-4-8`) the run actually used, resolved from the
-     *  free-text `model` against the chosen runner. Additive and optional: pre-#405
-     *  records carry only `model`, and it stays the human/hand-edit surface; this
-     *  is the parseable identity cost attribution and reproducible replay key off. */
     modelIdentity: z.ZodOptional<z.ZodString>;
-    /** Agent backend this run used — drives "open in CLI" resume command. */
-    runner: z.ZodOptional<z.ZodEnum<["claude", "codex", "opencode"]>>;
-    /** Echo of the extra system prompt this run actually used (R2): the
-     *  `POST /api/runs` override, or the `config.json` default it fell back to.
-     *  Deliberately NOT the full composed prompt — skill bodies and the handoff
-     *  contract are derivable from the persisted workflow and would bloat the
-     *  index. Resolved at execute time (a queued run picks up config edits). */
+    runner: z.ZodOptional<z.ZodPipe<z.ZodEnum<{
+        claude: "claude";
+        "claude-cli": "claude-cli";
+        codex: "codex";
+        opencode: "opencode";
+        pi: "pi";
+    }>, z.ZodTransform<"claude" | "codex" | "opencode" | "pi", "claude" | "claude-cli" | "codex" | "opencode" | "pi">>>;
+    agentProfile: z.ZodOptional<z.ZodString>;
     systemPrompt: z.ZodOptional<z.ZodString>;
-    /** Per-task follow-up inbox contract (spec 007, #444). Missing on old runs
-     *  means enabled — the historical behavior. */
     generateFollowups: z.ZodOptional<z.ZodBoolean>;
-    /** Autonomous mode (#489): the run was started with the "autonomous" checkbox,
-     *  so it never parks at `waiting` (auto-nudge) and — once persisted here —
-     *  never parks at the terminal `review` gate either (`settleSuccess` + the
-     *  group-pick winner-park read it). Additive-safe: absent = falsy = not
-     *  autonomous. Set at creation from `WorkflowInput.autonomous`. */
     autonomous: z.ZodOptional<z.ZodBoolean>;
-    status: z.ZodEnum<["queued", "running", "waiting", "review", "done", "failed", "cancelled"]>;
-    /** Sub-state of `running` (spec 2026-07-18-subagent-monitoring-status, #490):
-     *  `monitoring` while the agent is still working on its own downstream work.
-     *  Optional/absent on old runs; cleared when the run resumes or ends. */
-    activity: z.ZodOptional<z.ZodEnum<["monitoring"]>>;
+    automation: z.ZodOptional<z.ZodObject<{
+        automationId: z.ZodString;
+        automationRevision: z.ZodNumber;
+        receiptId: z.ZodString;
+        event: z.ZodString;
+        githubUrl: z.ZodString;
+    }, z.core.$strip>>;
+    status: z.ZodEnum<{
+        cancelled: "cancelled";
+        done: "done";
+        failed: "failed";
+        queued: "queued";
+        review: "review";
+        running: "running";
+        waiting: "waiting";
+    }>;
+    activity: z.ZodOptional<z.ZodEnum<{
+        monitoring: "monitoring";
+    }>>;
+    monitoringWakeAt: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    monitoringWakeCapReached: z.ZodOptional<z.ZodBoolean>;
+    autoResumeAt: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    autoResumeAttempts: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
     createdAt: z.ZodString;
     startedAt: z.ZodOptional<z.ZodString>;
     finishedAt: z.ZodOptional<z.ZodString>;
     tokensUsed: z.ZodNumber;
+    inputTokens: z.ZodOptional<z.ZodNumber>;
+    outputTokens: z.ZodOptional<z.ZodNumber>;
     costUsd: z.ZodOptional<z.ZodNumber>;
-    /** First GitHub PR URL spotted in the transcript (the janitor trick). */
     pullRequestUrl: z.ZodOptional<z.ZodString>;
-    /** The PR this task is ABOUT (#407, spec 2026-07-16-pr-autodiscovery):
-     *  auto-discovered from conversation references for tasks that work on an
-     *  existing PR (review/continue/merge). Display-only tier — `pullRequestUrl`
-     *  (the PR this task CREATED) always wins, and action gates ignore this. */
     referencedPullRequestUrl: z.ZodOptional<z.ZodString>;
-    /** The PR/issue number this task is ABOUT (spec 2026-07-17-task-auto-naming):
-     *  regex-extracted from the task prompt, upgradable by the namer's
-     *  cross-checked output. Display tier — never gates actions. */
     prNumber: z.ZodOptional<z.ZodNumber>;
     issueNumber: z.ZodOptional<z.ZodNumber>;
-    /** Provenance for an `issueNumber` seeded by referenced-issue discovery.
-     *  Persisted so ambiguity can revoke only the janitor's own value, including
-     *  after a restart. Any prompt, namer, or marker write clears this flag. */
     referencedIssueNumberSeeded: z.ZodOptional<z.ZodBoolean>;
-    /** Who owns the display title: `user` (PATCH rename — never auto-overwritten),
-     *  `marker` (agent-declared via `CEZ:TITLE`, spec 2026-07-18-task-ref-markers —
-     *  beats the namer, silences live refresh) or `auto` (namer-owned — a later
-     *  namer result may replace it). Missing on old runs = legacy behavior (auto
-     *  fills only an unset titleSummary). Precedence: user > marker > auto. */
-    titleOrigin: z.ZodOptional<z.ZodEnum<["user", "auto", "marker"]>>;
-    /** References the agent itself declared via `CEZ:PR=` / `CEZ:ISSUE=` markers
-     *  (spec 2026-07-18-task-ref-markers). Presence of a kind makes it
-     *  authoritative: the namer may no longer write that kind, and a declared PR
-     *  owns the referenced tier's resolution. */
+    titleOrigin: z.ZodOptional<z.ZodEnum<{
+        auto: "auto";
+        marker: "marker";
+        user: "user";
+    }>>;
     markerRefs: z.ZodOptional<z.ZodObject<{
         pr: z.ZodOptional<z.ZodNumber>;
         issue: z.ZodOptional<z.ZodNumber>;
-    }, "strip", z.ZodTypeAny, {
-        pr?: number | undefined;
-        issue?: number | undefined;
-    }, {
-        pr?: number | undefined;
-        issue?: number | undefined;
-    }>>;
-    /** Distinct PR URLs spotted so far — the referenced tier's working set,
-     *  persisted so a resumed run keeps disambiguating against the full history
-     *  instead of re-adopting the next URL as "the only one". Capped. */
-    referencedPrCandidates: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    /** The issue this task is ABOUT (spec 2026-07-21-report-ref-discovery):
-     *  auto-discovered from `github.com/…/issues/N` links in the conversation,
-     *  mirroring the referenced-PR tier. Display-only; never gates actions. */
+    }, z.core.$strip>>;
+    referencedPrCandidates: z.ZodOptional<z.ZodArray<z.ZodString>>;
     referencedIssueUrl: z.ZodOptional<z.ZodString>;
-    /** Distinct issue URLs spotted so far — the referenced-issue working set,
-     *  persisted like `referencedPrCandidates`. Capped. */
-    referencedIssueCandidates: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    /** Task worktree (spec 006) — absent when the run executed in the repo root. */
+    referencedIssueCandidates: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    worktree: z.ZodOptional<z.ZodLiteral<false>>;
     worktreePath: z.ZodOptional<z.ZodString>;
-    /** The task's own branch (`cez/<id8>`), created off `baseBranch`. */
     branch: z.ZodOptional<z.ZodString>;
-    /** Branch (or commit, when HEAD was detached) the worktree was forked from. */
     baseBranch: z.ZodOptional<z.ZodString>;
-    /** Set when count-based retention (#483) reclaimed this run's worktree
-     *  *directory* (the `cez/<id8>` branch is kept). Presence means "materialized
-     *  dir gone, recoverable via `git worktree add`"; it excludes the run from the
-     *  retention budget until the dir is re-materialized (resume clears it). */
     worktreeReclaimedAt: z.ZodOptional<z.ZodString>;
-    /** Parallel variants (spec 010): tasks sharing a groupId are one group. */
     groupId: z.ZodOptional<z.ZodString>;
-    /** Variant letter within the group — 'A' | 'B' | 'C' (kept as a string). */
     variant: z.ZodOptional<z.ZodString>;
-    /** Peak resident memory (bytes) / process count observed across the run's
-     *  agent process trees (#348) — written when a session's telemetry ends.
-     *  Optional: old runs.json files and `ps`-less platforms have neither. */
     peakRssBytes: z.ZodOptional<z.ZodNumber>;
     peakProcCount: z.ZodOptional<z.ZodNumber>;
     archived: z.ZodDefault<z.ZodBoolean>;
     archivedAt: z.ZodOptional<z.ZodString>;
+    seenAt: z.ZodOptional<z.ZodString>;
     currentStepId: z.ZodOptional<z.ZodString>;
     error: z.ZodOptional<z.ZodString>;
     steps: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         name: z.ZodString;
-        kind: z.ZodEnum<["agent", "check"]>;
-        status: z.ZodEnum<["pending", "running", "waiting", "review", "done", "failed", "cancelled", "skipped"]>;
+        kind: z.ZodEnum<{
+            agent: "agent";
+            check: "check";
+        }>;
+        status: z.ZodEnum<{
+            cancelled: "cancelled";
+            done: "done";
+            failed: "failed";
+            pending: "pending";
+            review: "review";
+            running: "running";
+            skipped: "skipped";
+            waiting: "waiting";
+        }>;
         iterations: z.ZodNumber;
         tokensUsed: z.ZodNumber;
+        inputTokens: z.ZodOptional<z.ZodNumber>;
+        outputTokens: z.ZodOptional<z.ZodNumber>;
+        usageInvocationsStarted: z.ZodOptional<z.ZodNumber>;
+        usageInvocationsObserved: z.ZodOptional<z.ZodNumber>;
+        usageTurnsStarted: z.ZodOptional<z.ZodNumber>;
+        usageTurnsRecorded: z.ZodOptional<z.ZodNumber>;
+        usageInvocationEpoch: z.ZodOptional<z.ZodNumber>;
         startedAt: z.ZodOptional<z.ZodString>;
         finishedAt: z.ZodOptional<z.ZodString>;
         error: z.ZodOptional<z.ZodString>;
-        /** Latest backend-owned session id, used for same-backend Continue. */
         sessionId: z.ZodOptional<z.ZodString>;
-        /** Backend that owns `sessionId`. Optional so pre-affinity runs.json files still parse. */
-        backend: z.ZodOptional<z.ZodEnum<["claude", "codex", "opencode"]>>;
-        /** Dollar cost reported by the claude CLI for this step's turns. */
+        backend: z.ZodOptional<z.ZodPipe<z.ZodEnum<{
+            claude: "claude";
+            "claude-cli": "claude-cli";
+            codex: "codex";
+            opencode: "opencode";
+            pi: "pi";
+        }>, z.ZodTransform<"claude" | "codex" | "opencode" | "pi", "claude" | "claude-cli" | "codex" | "opencode" | "pi">>>;
+        profileId: z.ZodOptional<z.ZodString>;
         costUsd: z.ZodOptional<z.ZodNumber>;
-    }, "strip", z.ZodTypeAny, {
-        id: string;
-        name: string;
-        kind: "agent" | "check";
-        status: "cancelled" | "done" | "failed" | "pending" | "review" | "running" | "skipped" | "waiting";
-        iterations: number;
-        tokensUsed: number;
-        startedAt?: string | undefined;
-        finishedAt?: string | undefined;
-        error?: string | undefined;
-        sessionId?: string | undefined;
-        backend?: "claude" | "codex" | "opencode" | undefined;
-        costUsd?: number | undefined;
-    }, {
-        id: string;
-        name: string;
-        kind: "agent" | "check";
-        status: "cancelled" | "done" | "failed" | "pending" | "review" | "running" | "skipped" | "waiting";
-        iterations: number;
-        tokensUsed: number;
-        startedAt?: string | undefined;
-        finishedAt?: string | undefined;
-        error?: string | undefined;
-        sessionId?: string | undefined;
-        backend?: "claude" | "codex" | "opencode" | undefined;
-        costUsd?: number | undefined;
-    }>, "many">;
-    /** Full workflow definition, persisted so a `queued` run can be re-enqueued
-     *  after a restart (#367) — including ad-hoc "(planned)" chains that exist
-     *  nowhere else. Kept loose here to avoid an upward import; the run manager
-     *  validates the shape before reviving it. */
-    workflowDef: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, "strip", z.ZodTypeAny, {
-    id: string;
-    title: string;
-    titleSummary?: string | undefined;
-    diffStat?: {
-        adds: number;
-        dels: number;
-        files: number;
-    } | undefined;
-    workflow: string;
-    task: string;
-    queuedMessages?: {
-        id: string;
-        text: string;
-        images?: string[] | undefined;
-        createdAt: string;
-    }[] | undefined;
-    taskImages?: string[] | undefined;
-    model?: string | undefined;
-    modelIdentity?: string | undefined;
-    runner?: "claude" | "codex" | "opencode" | undefined;
-    systemPrompt?: string | undefined;
-    generateFollowups?: boolean | undefined;
-    autonomous?: boolean | undefined;
-    status: "cancelled" | "done" | "failed" | "queued" | "review" | "running" | "waiting";
-    activity?: "monitoring" | undefined;
-    createdAt: string;
-    startedAt?: string | undefined;
-    finishedAt?: string | undefined;
-    tokensUsed: number;
-    costUsd?: number | undefined;
-    pullRequestUrl?: string | undefined;
-    referencedPullRequestUrl?: string | undefined;
-    prNumber?: number | undefined;
-    issueNumber?: number | undefined;
-    referencedIssueNumberSeeded?: boolean | undefined;
-    titleOrigin?: "auto" | "marker" | "user" | undefined;
-    markerRefs?: {
-        pr?: number | undefined;
-        issue?: number | undefined;
-    } | undefined;
-    referencedPrCandidates?: string[] | undefined;
-    referencedIssueUrl?: string | undefined;
-    referencedIssueCandidates?: string[] | undefined;
-    worktreePath?: string | undefined;
-    branch?: string | undefined;
-    baseBranch?: string | undefined;
-    worktreeReclaimedAt?: string | undefined;
-    groupId?: string | undefined;
-    variant?: string | undefined;
-    peakRssBytes?: number | undefined;
-    peakProcCount?: number | undefined;
-    archived: boolean;
-    archivedAt?: string | undefined;
-    currentStepId?: string | undefined;
-    error?: string | undefined;
-    steps: {
-        id: string;
-        name: string;
-        kind: "agent" | "check";
-        status: "cancelled" | "done" | "failed" | "pending" | "review" | "running" | "skipped" | "waiting";
-        iterations: number;
-        tokensUsed: number;
-        startedAt?: string | undefined;
-        finishedAt?: string | undefined;
-        error?: string | undefined;
-        sessionId?: string | undefined;
-        backend?: "claude" | "codex" | "opencode" | undefined;
-        costUsd?: number | undefined;
-    }[];
-    workflowDef?: Record<string, unknown> | undefined;
-}, {
-    id: string;
-    title: string;
-    titleSummary?: string | undefined;
-    diffStat?: {
-        adds: number;
-        dels: number;
-        files: number;
-    } | undefined;
-    workflow: string;
-    task: string;
-    queuedMessages?: {
-        id: string;
-        text: string;
-        images?: string[] | undefined;
-        createdAt: string;
-    }[] | undefined;
-    taskImages?: string[] | undefined;
-    model?: string | undefined;
-    modelIdentity?: string | undefined;
-    runner?: "claude" | "codex" | "opencode" | undefined;
-    systemPrompt?: string | undefined;
-    generateFollowups?: boolean | undefined;
-    autonomous?: boolean | undefined;
-    status: "cancelled" | "done" | "failed" | "queued" | "review" | "running" | "waiting";
-    activity?: "monitoring" | undefined;
-    createdAt: string;
-    startedAt?: string | undefined;
-    finishedAt?: string | undefined;
-    tokensUsed: number;
-    costUsd?: number | undefined;
-    pullRequestUrl?: string | undefined;
-    referencedPullRequestUrl?: string | undefined;
-    prNumber?: number | undefined;
-    issueNumber?: number | undefined;
-    referencedIssueNumberSeeded?: boolean | undefined;
-    titleOrigin?: "auto" | "marker" | "user" | undefined;
-    markerRefs?: {
-        pr?: number | undefined;
-        issue?: number | undefined;
-    } | undefined;
-    referencedPrCandidates?: string[] | undefined;
-    referencedIssueUrl?: string | undefined;
-    referencedIssueCandidates?: string[] | undefined;
-    worktreePath?: string | undefined;
-    branch?: string | undefined;
-    baseBranch?: string | undefined;
-    worktreeReclaimedAt?: string | undefined;
-    groupId?: string | undefined;
-    variant?: string | undefined;
-    peakRssBytes?: number | undefined;
-    peakProcCount?: number | undefined;
-    archived?: boolean | undefined;
-    archivedAt?: string | undefined;
-    currentStepId?: string | undefined;
-    error?: string | undefined;
-    steps: {
-        id: string;
-        name: string;
-        kind: "agent" | "check";
-        status: "cancelled" | "done" | "failed" | "pending" | "review" | "running" | "skipped" | "waiting";
-        iterations: number;
-        tokensUsed: number;
-        startedAt?: string | undefined;
-        finishedAt?: string | undefined;
-        error?: string | undefined;
-        sessionId?: string | undefined;
-        backend?: "claude" | "codex" | "opencode" | undefined;
-        costUsd?: number | undefined;
-    }[];
-    workflowDef?: Record<string, unknown> | undefined;
-}>;
+    }, z.core.$strip>>;
+    workflowDef: z.ZodCatch<z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        steps: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            prompt: z.ZodOptional<z.ZodString>;
+            skill: z.ZodOptional<z.ZodString>;
+            model: z.ZodOptional<z.ZodString>;
+            runner: z.ZodOptional<z.ZodEnum<{
+                claude: "claude";
+                codex: "codex";
+                opencode: "opencode";
+                pi: "pi";
+            }>>;
+            allowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            bashAllowlist: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            command: z.ZodOptional<z.ZodString>;
+            onFail: z.ZodOptional<z.ZodObject<{
+                retry: z.ZodString;
+                max: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        source: z.ZodEnum<{
+            "built-in": "built-in";
+            file: "file";
+        }>;
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
 export type StepState = z.infer<typeof stepStateSchema>;
 export type QueuedMessage = z.infer<typeof queuedMessageSchema>;
 export type RunRecord = z.infer<typeof runRecordSchema>;
@@ -430,6 +237,22 @@ export interface RunEvent {
     type: string;
     [key: string]: unknown;
 }
+/**
+ * Reconcile one record just read off disk with the fact that whichever process wrote it is gone.
+ *
+ * Mutates and returns `run`. Extracted from `RunStore.open` so the read-only index reader
+ * (`./run-index.ts`) answers the SAME question about a `running` row on disk. Two parsers that
+ * disagree here is a visible bug, not an internal one: the cockpit would show a task as running
+ * in the ⌘K index and failed the moment you opened it.
+ *
+ * `keepLive` (#367): leave `queued`/`running`/`waiting` untouched so the caller can recover them
+ * (RunManager.recover re-queues queued runs, resumes interrupted ones). Without it — one-shot CLI
+ * paths that never recover, and the index reader, which has no manager at all — live-looking runs
+ * are marked failed so no ghost stays behind.
+ */
+export declare function reconcileLoadedRun(run: RunRecord, opts?: {
+    keepLive?: boolean;
+}): RunRecord;
 /**
  * File-backed run store: `runs.json` index (atomic tmp+rename writes, the
  * pattern from @cezar/core's IssueStore) plus one append-only NDJSON event
@@ -441,12 +264,7 @@ export declare class RunStore extends EventEmitter {
     private runs;
     private saveTimer;
     private constructor();
-    /**
-     * `keepLive` (#367): leave `queued`/`running`/`waiting` statuses untouched
-     * so the caller can recover them (RunManager.recover re-queues queued runs,
-     * resumes interrupted ones). Without it — one-shot CLI paths that never
-     * recover — live-looking runs are marked failed so no ghost stays behind.
-     */
+    /** See `reconcileLoadedRun` for what `keepLive` (#367) decides about live-looking rows. */
     static open(dataDir: string, opts?: {
         keepLive?: boolean;
     }): RunStore;
@@ -457,9 +275,12 @@ export declare class RunStore extends EventEmitter {
         workflow: string;
         task: string;
         model?: string;
-        runner?: 'claude' | 'codex' | 'opencode';
+        runner?: RunnerId;
+        /** Composer's per-task agent account (spec 2026-07-29-agent-profiles). */
+        agentProfile?: string;
         generateFollowups?: boolean;
         autonomous?: boolean;
+        worktree?: false;
         groupId?: string;
         variant?: string;
         steps: Array<Pick<StepState, 'id' | 'name' | 'kind'>>;
@@ -494,6 +315,50 @@ export declare class RunStore extends EventEmitter {
     setArchived(id: string, archived: boolean): RunRecord | undefined;
     /** Bulk-archive every finished run; returns how many were archived. */
     archiveFinished(): number;
+    /** Mark one run as read (#unread-done-items): stamp the read receipt now. Mirrors
+     *  `setArchived` — sets the field then persists + broadcasts via `touch`, so the
+     *  updated record rides the existing `run` SSE with no new event. Idempotent by
+     *  design: opening an already-read thread just re-stamps a later `seenAt`. */
+    setRead(id: string): RunRecord | undefined;
+    /** Mark one run as UNread (#775): drop the read receipt so the run rejoins the unread
+     *  list. The inverse of `setRead` and, like it, `touch`es so the updated record rides the
+     *  existing `run` SSE.
+     *
+     *  Deleting the field rather than adding a "manually unread" flag is the whole point:
+     *  absent `seenAt` is ALREADY what every reader treats as unread (`isUnread` in the
+     *  cockpit's read-state.ts, and `markAllRead`'s clause-for-clause copy of it below), so
+     *  clearing needs no new state and writes a shape any older cezar already parses.
+     *
+     *  Deliberately unconditional: clearing a receipt is always a legal write, so this
+     *  succeeds for an already-unread run (idempotent) and for statuses that can never wear
+     *  the marker. WHETHER the action means anything for a given run is UI policy, and lives
+     *  in the cockpit's `runActionFlags` — the same split the rest of the store keeps. */
+    setUnread(id: string): RunRecord | undefined;
+    /** Bulk mark-read: stamp every currently-unread finished run; returns the count.
+     *  "Unread" here is the same rule the cockpit paints (`isUnread` in read-state.ts),
+     *  clause for clause:
+     *   - a `done` or `failed` run that finished and has not been seen since;
+     *   - cancelled runs are never unread — you stopped them yourself;
+     *   - archived ones never are either, since archiving is a stronger "done with this"
+     *     than reading;
+     *   - and a `failed` run with a pending `autoResumeAt` is not a done item AT ALL
+     *     (`isScheduledResume`, spec 2026-08-03-auto-resume-after-usage-limit): it has an
+     *     appointment to pick the work back up, so there is no outcome to have missed.
+     *
+     *  Keeping the two rules identical is what makes the returned count the number the
+     *  cockpit's unread badge was showing. The `autoResumeAt` clause is the one that drifted
+     *  (#803): `isUnread` gained it with auto-resume and this sweep did not, so a task waiting
+     *  out a usage limit was uncounted by the badge but stamped read by the sweep — and this
+     *  comment asserted an invariant the code no longer held.
+     *
+     *  This rule lives in two languages of the same repo, which is why it has now drifted
+     *  once. The cockpit cannot import it (`packages/web` does not depend on the service, and
+     *  should not), so a single definition would have to move to `packages/contract` — the one
+     *  package both sides already import. Worth doing; deliberately not done here, because
+     *  widening the contract package's remit from "shapes" to "behavior" is a design change
+     *  that deserves its own review rather than riding along in a bug fix. Until then: EDIT
+     *  BOTH, and the case-table tests on either side are what catch you if you don't. */
+    markAllRead(): number;
     appendEvent(runId: string, event: {
         type: string;
         stepId?: string;