agent-dealer 1.2.6 → 1.2.7

package/bundle/server/static-ui/index.html

@@ -8,8 +8,8 @@
     <link rel="apple-touch-icon" href="/apple-touch-icon.png" />
     <meta name="theme-color" content="#0a0e14" />
     <link rel="preload" href="/fonts/Monaco.ttf" as="font" type="font/ttf" crossorigin />
-    <script type="module" crossorigin src="/assets/index-CoDzZcsz.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-BII-LgB8.css">
+    <script type="module" crossorigin src="/assets/index-yLyxRd-7.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-DyAJNyfV.css">
   </head>
   <body>
     <div id="root"></div>

package/bundle/shared/dist/action-presentation.d.ts

@@ -0,0 +1,51 @@
+export interface ActionPresentationInput {
+    actionType: string;
+    question: string;
+    reason: string;
+    evidenceJson: string | null;
+    responseOptionsJson: string | null;
+    continuationPreviewJson: string | null;
+}
+export type ActionSummaryKind = "diverged-push" | "unpushed" | "worktree-conflict" | "dirty-worktree" | "merge-failure" | "reviewer-retry" | "ordinary-escalation" | "other";
+export interface ActionResponseOption {
+    choice: string;
+    label: string;
+}
+export interface ActionSummaryDetails {
+    /** Full stored question, verbatim — never truncated. */
+    question: string;
+    /** Full stored reason, verbatim — never truncated. */
+    reason: string;
+    /** Exact recovery commands parsed out of the reason. */
+    commands: string[];
+    /** Worktree / log paths parsed out of the reason, question, and evidence. */
+    paths: string[];
+    /** Structured recovery facts (push pins, continuation, review verdict). */
+    factLines: string[];
+    /** Full structured evidence, pretty-printed — null when the action has none. */
+    evidencePretty: string | null;
+}
+export interface ActionSummary {
+    kind: ActionSummaryKind;
+    /** Short human question for the default (collapsed) view. */
+    title: string;
+    /** One-sentence blocker / next-step context, or null when there is none. */
+    context: string | null;
+    /**
+     * True only where coordinator semantics prove Resume continues without
+     * discarding preserved work or re-colliding with the same blocker: a
+     * reviewer-origin retry (fresh reviewer at a pinned head, no worktree
+     * touched) or an ordinary escalation with no preserved-work markers.
+     * Worktree conflicts, dirty worktrees, and unpushed/diverged pushes keep
+     * their preserved work — never safe to promise.
+     */
+    safeResume: boolean;
+    /** Server-declared choices, with `resume` shown as "Resume safely" only when safeResume. */
+    displayOptions: ActionResponseOption[];
+    /** The safest server-declared next action: push_with_lease for a diverged push,
+     * otherwise the first non-destructive choice. Null when no options exist. */
+    primaryChoice: string | null;
+    details: ActionSummaryDetails;
+}
+export declare function parseActionResponseOptions(action: ActionPresentationInput): ActionResponseOption[];
+export declare function summarizeHumanAction(action: ActionPresentationInput): ActionSummary;

package/bundle/shared/dist/action-presentation.js

@@ -0,0 +1,280 @@
+// NOT-288: one shared presentation read of a human action for every friend-path
+// surface (Issues home NeedsAttentionPanel, Issue Detail). The stored
+// `question`/`reason` still carry the full folded recovery text (paths, git
+// commands, SHAs) so the timeline and evidence stay auditable and pre-change
+// open actions keep working — this layer only derives a short question, a
+// one-sentence next step, and the expandable Details from those stored fields.
+function parseJsonSafe(json) {
+    if (!json)
+        return null;
+    try {
+        return JSON.parse(json);
+    }
+    catch {
+        return null;
+    }
+}
+export function parseActionResponseOptions(action) {
+    const parsed = parseJsonSafe(action.responseOptionsJson);
+    if (!Array.isArray(parsed))
+        return [];
+    return parsed.filter((o) => typeof o?.choice === "string" && typeof o?.label === "string");
+}
+function parseEvidence(action) {
+    return parseJsonSafe(action.evidenceJson) ?? {};
+}
+function pushFacts(action) {
+    const evidence = parseEvidence(action);
+    const facts = evidence["pushDivergence"];
+    if (!facts || typeof facts !== "object")
+        return null;
+    return facts;
+}
+function hasWorktreeBlockerEvidence(action) {
+    const evidence = parseEvidence(action);
+    const blocker = evidence["worktreeBlocker"];
+    return (!!blocker &&
+        typeof blocker === "object" &&
+        typeof blocker.fingerprint === "string");
+}
+function isMergeFailureEvidence(action) {
+    return parseEvidence(action)["mergeFailure"] === true;
+}
+function resumeContinuationRole(action) {
+    const parsed = parseJsonSafe(action.continuationPreviewJson);
+    return typeof parsed?.resumeRole === "string" ? parsed.resumeRole : null;
+}
+/** Signals that local work is preserved and Resume cannot be promised safe. */
+const PRESERVED_WORK_PATTERN = /worktree|unpushed|uncommitted|dirty|preserved|non-fast-forward|diverged|already used by|recovery:|force-with-lease/i;
+const UNPUSHED_TEXT_PATTERN = /could not be pushed|non-fast-forward|rejected.*push|push.*rejected/i;
+const DIRTY_TEXT_PATTERN = /uncommitted|dirty worktree|has uncommitted changes/i;
+/** Splits the folded "Recovery:\n<commands>" tail the coordinator appends to reasons. */
+function splitRecovery(reason) {
+    const marker = /\n?Recovery:\s*\n?/;
+    const match = reason.match(marker);
+    if (!match || match.index === undefined)
+        return { head: reason.trim(), commands: [] };
+    const head = reason.slice(0, match.index).trim();
+    const tail = reason.slice(match.index + match[0].length);
+    const commands = tail
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    return { head, commands };
+}
+/** First sentence of a blocker statement — the one-sentence context source. */
+function firstSentence(text) {
+    const head = splitRecovery(text).head;
+    const singleLine = head.replace(/\s+/g, " ").trim();
+    const match = singleLine.match(/^(.+?[.!?])(\s|$)/);
+    return (match ? match[1] : singleLine).trim();
+}
+const PATH_PATTERN = /(?:~|\/(?:[^/\s\\:"'*?<>|][^/\s\\:"'*?<>|]*))+(?:\/[^/\s\\:"'*?<>|]+)*/g;
+/** Absolute worktree/log paths from free text plus the structured evidence path. */
+function extractPaths(action) {
+    const found = [];
+    const seen = new Set();
+    const push = (p) => {
+        const trimmed = p.trim().replace(/[.,;:!?)"'\]]+$/, "");
+        if (trimmed.length < 2 || seen.has(trimmed))
+            return;
+        seen.add(trimmed);
+        found.push(trimmed);
+    };
+    for (const text of [action.reason, action.question]) {
+        for (const match of text.matchAll(PATH_PATTERN)) {
+            const candidate = match[0];
+            // Guard against version numbers and SHAs matching the loose pattern.
+            if (/^\/\d+(\.\d+)*$/.test(candidate))
+                continue;
+            if (!candidate.includes("/") && !candidate.startsWith("~"))
+                continue;
+            push(candidate);
+        }
+    }
+    const facts = pushFacts(action);
+    if (typeof facts?.worktreePath === "string" && facts.worktreePath)
+        push(facts.worktreePath);
+    return found;
+}
+function shortSha(sha) {
+    return sha.length > 12 ? sha.slice(0, 12) : sha;
+}
+/** Recovery facts both panels show the same way: pins, tips, continuation. */
+function factLines(action) {
+    const lines = [];
+    const facts = pushFacts(action);
+    if (facts && typeof facts.localSha === "string" && typeof facts.remoteSha === "string") {
+        const branch = typeof facts.branch === "string" ? facts.branch : "the branch";
+        const ahead = typeof facts.ahead === "number" ? ` (+${facts.ahead})` : "";
+        const behind = typeof facts.behind === "number" ? ` (+${facts.behind})` : "";
+        lines.push(`Push: local ${facts.localSha}${ahead} · origin/${branch} ${facts.remoteSha}${behind}`);
+        if (typeof facts.observedRemoteSha === "string" && facts.observedRemoteSha !== facts.remoteSha) {
+            lines.push(`Remote moved: origin/${branch} is now at ${facts.observedRemoteSha}`);
+        }
+        if (typeof facts.lastLeaseError === "string" && facts.lastLeaseError) {
+            lines.push(`Last lease attempt: ${facts.lastLeaseError}`);
+        }
+    }
+    const role = resumeContinuationRole(action);
+    if (role)
+        lines.push(`Continuation: resumes as ${role}`);
+    return lines;
+}
+function isDestructiveChoice(choice) {
+    return choice === "close" || choice === "reject" || choice === "abort";
+}
+function primaryChoiceFor(options) {
+    if (options.length === 0)
+        return null;
+    if (options.some((o) => o.choice === "push_with_lease"))
+        return "push_with_lease";
+    return (options.find((o) => !isDestructiveChoice(o.choice)) ?? options[0]).choice;
+}
+function classify(action) {
+    if (action.actionType !== "policy_escalation")
+        return "other";
+    if (isMergeFailureEvidence(action))
+        return "merge-failure";
+    const facts = pushFacts(action);
+    if (facts?.relationship === "diverged")
+        return "diverged-push";
+    if (facts && (facts.relationship === "behind" || typeof facts.localSha === "string"))
+        return "unpushed";
+    const text = `${action.reason}\n${action.question}`;
+    if (UNPUSHED_TEXT_PATTERN.test(text))
+        return "unpushed";
+    // A reviewer-origin retry re-queues a fresh reviewer at a pinned head without
+    // touching a developer worktree — classify before the generic worktree text
+    // check so a "reviewer worktree checkout failed" reason still reads as safe.
+    if (resumeContinuationRole(action) === "reviewer")
+        return "reviewer-retry";
+    // Dirty before worktree: a preserved-dirt escalation names its worktree path in
+    // the recovery commands but stays a dirty worktree, not a branch collision.
+    if (DIRTY_TEXT_PATTERN.test(text))
+        return "dirty-worktree";
+    if (hasWorktreeBlockerEvidence(action) ||
+        /already used by worktree/i.test(text) ||
+        (/worktree/i.test(text) && /Recovery:/.test(text))) {
+        return "worktree-conflict";
+    }
+    return "ordinary-escalation";
+}
+const SAFE_RESUME_LABEL = "Resume safely";
+export function summarizeHumanAction(action) {
+    const kind = classify(action);
+    const options = parseActionResponseOptions(action);
+    const { commands } = splitRecovery(action.reason);
+    const paths = extractPaths(action);
+    const facts = factLines(action);
+    const evidencePretty = (() => {
+        const evidence = parseJsonSafe(action.evidenceJson);
+        if (evidence === null || evidence === undefined)
+            return null;
+        return JSON.stringify(evidence, null, 2);
+    })();
+    const details = {
+        question: action.question,
+        reason: action.reason,
+        commands,
+        paths,
+        factLines: facts,
+        evidencePretty,
+    };
+    switch (kind) {
+        case "diverged-push": {
+            const f = pushFacts(action);
+            const pin = f && typeof f.branch === "string" && typeof f.localSha === "string" && typeof f.remoteSha === "string"
+                ? ` (origin/${f.branch}: local ${shortSha(f.localSha)} against remote ${shortSha(f.remoteSha)})`
+                : "";
+            return {
+                kind,
+                title: "Publish these finished commits with a pinned lease?",
+                context: `Your branch diverged from the remote — confirm the pinned commits${pin} under Details, then choose Push with lease.`,
+                safeResume: false,
+                displayOptions: options,
+                primaryChoice: primaryChoiceFor(options),
+                details,
+            };
+        }
+        case "unpushed":
+            return {
+                kind,
+                title: "The push was rejected — how should we proceed?",
+                context: "Your commits are saved; resuming continues development without discarding them.",
+                safeResume: false,
+                displayOptions: options,
+                primaryChoice: primaryChoiceFor(options),
+                details,
+            };
+        case "worktree-conflict":
+            return {
+                kind,
+                title: "A saved worktree still holds this branch — how should we proceed?",
+                context: "Your work is preserved; check the worktree path and recovery steps under Details before choosing.",
+                safeResume: false,
+                displayOptions: options,
+                primaryChoice: primaryChoiceFor(options),
+                details,
+            };
+        case "dirty-worktree":
+            return {
+                kind,
+                title: "Uncommitted changes were preserved — how should we proceed?",
+                context: "Nothing was discarded; review the saved changes under Details before choosing.",
+                safeResume: false,
+                displayOptions: options,
+                primaryChoice: primaryChoiceFor(options),
+                details,
+            };
+        case "merge-failure":
+            return {
+                kind,
+                title: "The merge failed after approval — retry it?",
+                context: "The work is already approved; retrying the merge publishes the same commits without a new developer round.",
+                safeResume: false,
+                displayOptions: options,
+                primaryChoice: primaryChoiceFor(options),
+                details,
+            };
+        case "reviewer-retry":
+            return {
+                kind,
+                title: "The review attempt failed — retry it?",
+                context: "Nothing is wrong with the code itself; retrying re-queues the reviewer at the same pinned commit.",
+                safeResume: true,
+                displayOptions: options,
+                primaryChoice: primaryChoiceFor(options),
+                details,
+            };
+        case "ordinary-escalation": {
+            const blocker = firstSentence(action.reason);
+            const safe = !PRESERVED_WORK_PATTERN.test(`${action.reason}\n${action.question}`);
+            const displayOptions = safe
+                ? options.map((o) => o.choice === "resume" && o.label === "Resume development"
+                    ? { ...o, label: SAFE_RESUME_LABEL }
+                    : o)
+                : options;
+            return {
+                kind,
+                title: "Development is parked — resume or close?",
+                context: blocker ? `${blocker} Choose ${safe ? "Resume safely" : "Resume"} to continue, or Close to stop.` : null,
+                safeResume: safe,
+                displayOptions,
+                primaryChoice: primaryChoiceFor(displayOptions),
+                details,
+            };
+        }
+        case "other":
+        default:
+            return {
+                kind: "other",
+                title: action.question,
+                context: null,
+                safeResume: false,
+                displayOptions: options,
+                primaryChoice: primaryChoiceFor(options),
+                details,
+            };
+    }
+}

package/bundle/shared/dist/action-presentation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/bundle/shared/dist/action-presentation.test.js

@@ -0,0 +1,180 @@
+// NOT-288: the shared presentation layer keeps worktree/policy escalations
+// concise by default while preserving every technical fact under Details.
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { summarizeHumanAction, } from "./action-presentation.js";
+const LOCAL_SHA = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
+const REMOTE_SHA = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
+const WORKTREE_PATH = "/Users/friend/.agent-dealer-dev/worktrees/310f25af-developer";
+function baseAction(extra = {}) {
+    return {
+        actionType: "policy_escalation",
+        question: "reason Resume development, or close the issue?",
+        reason: "reason",
+        evidenceJson: null,
+        responseOptionsJson: JSON.stringify([
+            { choice: "resume", label: "Resume development" },
+            { choice: "close", label: "Close" },
+        ]),
+        continuationPreviewJson: null,
+        ...extra,
+    };
+}
+function worktreeConflictAction() {
+    const reason = `issue branch is already used by worktree at ${WORKTREE_PATH}. ` +
+        `Recovery:\n` +
+        `git -C ${WORKTREE_PATH} status\n` +
+        `git worktree remove --force ${WORKTREE_PATH}`;
+    return baseAction({
+        reason,
+        question: `${reason} Resume development, or close the issue?`,
+        evidenceJson: JSON.stringify({ worktreeBlocker: { fingerprint: "abc123" } }),
+    });
+}
+test("worktree conflict shows a short question with paths and commands under Details", () => {
+    const summary = summarizeHumanAction(worktreeConflictAction());
+    assert.equal(summary.kind, "worktree-conflict");
+    assert.ok(!summary.title.includes(WORKTREE_PATH), "default question hides the path");
+    assert.ok(!summary.title.includes("git "), "default question hides git commands");
+    assert.ok(summary.context && summary.context.length > 0, "one-sentence next step present");
+    assert.equal(summary.safeResume, false);
+    // Labels stay server-accurate: no promise of safety on preserved work.
+    assert.deepEqual(summary.displayOptions.map((o) => o.label), ["Resume development", "Close"]);
+    assert.ok(!summary.displayOptions.some((o) => /safely/i.test(o.label)));
+    // Details preserve everything without truncation.
+    assert.equal(summary.details.reason, worktreeConflictAction().reason);
+    assert.equal(summary.details.question, worktreeConflictAction().question);
+    assert.deepEqual(summary.details.commands, [
+        `git -C ${WORKTREE_PATH} status`,
+        `git worktree remove --force ${WORKTREE_PATH}`,
+    ]);
+    assert.ok(summary.details.paths.includes(WORKTREE_PATH));
+});
+test("dirty worktree shows a short question and never promises a safe resume", () => {
+    const reason = "Developer worktree has uncommitted changes after the session ended. " +
+        `Recovery:\ngit -C ${WORKTREE_PATH} status\ngit -C ${WORKTREE_PATH} stash list`;
+    const summary = summarizeHumanAction(baseAction({ reason, question: `${reason} Resume development, or close the issue?` }));
+    assert.equal(summary.kind, "dirty-worktree");
+    assert.ok(!summary.title.includes(WORKTREE_PATH));
+    assert.ok(!summary.title.includes("git "));
+    assert.ok(summary.context);
+    assert.equal(summary.safeResume, false);
+    assert.ok(!summary.displayOptions.some((o) => /safely/i.test(o.label)));
+    assert.deepEqual(summary.details.commands, [
+        `git -C ${WORKTREE_PATH} status`,
+        `git -C ${WORKTREE_PATH} stash list`,
+    ]);
+    assert.ok(summary.details.paths.includes(WORKTREE_PATH));
+});
+test("ordinary escalation shows a short question plus one-sentence context, Details keep the reason", () => {
+    const reason = "Git/GitHub verification failed: gh pr checks timed out. (infra-attempt limit reached).";
+    const summary = summarizeHumanAction(baseAction({ reason, question: `${reason} Resume development, or close the issue?` }));
+    assert.equal(summary.kind, "ordinary-escalation");
+    assert.equal(summary.title, "Development is parked — resume or close?");
+    assert.ok(summary.context && summary.context.includes("Git/GitHub verification failed"));
+    assert.ok(!summary.title.includes("gh "), "no command block as the first question");
+    assert.equal(summary.safeResume, true);
+    assert.deepEqual(summary.displayOptions.map((o) => o.label), ["Resume safely", "Close"]);
+    assert.equal(summary.primaryChoice, "resume");
+    assert.equal(summary.details.reason, reason);
+    assert.deepEqual(summary.details.commands, []);
+});
+test("reviewer retry keeps its specific label and reads as safe", () => {
+    const summary = summarizeHumanAction(baseAction({
+        reason: "Reviewer session failed: timeout.",
+        question: "Reviewer session failed: timeout. Retry the review, or close the issue?",
+        continuationPreviewJson: JSON.stringify({ resumeRole: "reviewer", resumeHeadSha: "deadbeef" }),
+        responseOptionsJson: JSON.stringify([
+            { choice: "resume", label: "Retry review" },
+            { choice: "close", label: "Close" },
+        ]),
+    }));
+    assert.equal(summary.kind, "reviewer-retry");
+    assert.equal(summary.safeResume, true);
+    assert.deepEqual(summary.displayOptions.map((o) => o.label), ["Retry review", "Close"]);
+});
+test("diverged push keeps push_with_lease with full SHAs visible in Details", () => {
+    const summary = summarizeHumanAction(baseAction({
+        reason: "Developer's commits could not be pushed: rejected: non-fast-forward",
+        question: "Developer's commits could not be pushed: rejected. Push local, resume, or close?",
+        evidenceJson: JSON.stringify({
+            pushDivergence: {
+                branch: "issue-1",
+                localSha: LOCAL_SHA,
+                remoteSha: REMOTE_SHA,
+                ahead: 2,
+                behind: 1,
+                relationship: "diverged",
+                worktreePath: WORKTREE_PATH,
+            },
+        }),
+        responseOptionsJson: JSON.stringify([
+            { choice: "push_with_lease", label: "Push with lease" },
+            { choice: "resume", label: "Resume development" },
+            { choice: "close", label: "Close" },
+        ]),
+    }));
+    assert.equal(summary.kind, "diverged-push");
+    assert.equal(summary.safeResume, false);
+    assert.deepEqual(summary.displayOptions.map((o) => o.choice), ["push_with_lease", "resume", "close"]);
+    assert.equal(summary.primaryChoice, "push_with_lease");
+    assert.ok(!summary.displayOptions.some((o) => /safely/i.test(o.label)));
+    const facts = summary.details.factLines.join("\n");
+    assert.ok(facts.includes(LOCAL_SHA), "full local SHA, not truncated");
+    assert.ok(facts.includes(REMOTE_SHA), "full remote SHA, not truncated");
+    assert.ok(facts.includes("origin/issue-1"));
+    assert.ok(summary.details.paths.includes(WORKTREE_PATH));
+    assert.ok(summary.details.evidencePretty?.includes(LOCAL_SHA));
+});
+test("behind-only push evidence never offers push_with_lease", () => {
+    const summary = summarizeHumanAction(baseAction({
+        reason: "Developer's commits could not be pushed: rejected: non-fast-forward",
+        question: "Developer's commits could not be pushed. Resume development, or close the issue?",
+        evidenceJson: JSON.stringify({
+            pushDivergence: {
+                branch: "issue-1",
+                localSha: LOCAL_SHA,
+                remoteSha: REMOTE_SHA,
+                ahead: 0,
+                behind: 2,
+                relationship: "behind",
+            },
+        }),
+    }));
+    assert.equal(summary.kind, "unpushed");
+    assert.deepEqual(summary.displayOptions.map((o) => o.choice), ["resume", "close"]);
+    assert.equal(summary.safeResume, false);
+});
+test("legacy actions without evidence render sensibly and lose nothing", () => {
+    const reason = `issue branch is already used by worktree at ${WORKTREE_PATH}. ` +
+        `Recovery:\ngit worktree list\ngit worktree remove --force ${WORKTREE_PATH}`;
+    const question = `${reason} Resume development, or close the issue?`;
+    const summary = summarizeHumanAction(baseAction({ reason, question }));
+    assert.equal(summary.kind, "worktree-conflict");
+    assert.ok(!summary.title.includes(WORKTREE_PATH));
+    assert.equal(summary.safeResume, false);
+    assert.equal(summary.details.reason, reason);
+    assert.equal(summary.details.question, question);
+    assert.deepEqual(summary.details.commands, [
+        "git worktree list",
+        `git worktree remove --force ${WORKTREE_PATH}`,
+    ]);
+    assert.deepEqual(summary.displayOptions.map((o) => o.choice), ["resume", "close"]);
+});
+test("non-policy actions pass through with their own question and options", () => {
+    const summary = summarizeHumanAction(baseAction({
+        actionType: "final_review",
+        reason: "Reviewer approved the PR",
+        question: "Merge this work, send it back for another repair round, or close it?",
+        responseOptionsJson: JSON.stringify([
+            { choice: "merge", label: "Merge" },
+            { choice: "repair", label: "Another repair round" },
+            { choice: "close", label: "Close" },
+        ]),
+    }));
+    assert.equal(summary.kind, "other");
+    assert.equal(summary.title, "Merge this work, send it back for another repair round, or close it?");
+    assert.equal(summary.safeResume, false);
+    assert.deepEqual(summary.displayOptions.map((o) => o.label), ["Merge", "Another repair round", "Close"]);
+    assert.equal(summary.primaryChoice, "merge");
+});

package/bundle/shared/dist/attempt-waste.d.ts

@@ -27,21 +27,21 @@ export declare const CheckpointObservedPayload: z.ZodObject<{
     samplingPrecisionMs: z.ZodNullable<z.ZodNumber>;
     branch: z.ZodNullable<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
+    branch: string | null;
     inputSha: string | null;
     kind: "commit" | "verification_receipt" | "branch_pushed";
     observedSha: string | null;
     observedAt: string;
     origin: "sampler" | "salvage" | "session_end" | null;
     samplingPrecisionMs: number | null;
-    branch: string | null;
 }, {
+    branch: string | null;
     inputSha: string | null;
     kind: "commit" | "verification_receipt" | "branch_pushed";
     observedSha: string | null;
     observedAt: string;
     origin: "sampler" | "salvage" | "session_end" | null;
     samplingPrecisionMs: number | null;
-    branch: string | null;
 }>;
 export type CheckpointObservedPayload = z.infer<typeof CheckpointObservedPayload>;
 export declare const RetryReusedPayload: z.ZodObject<{

package/bundle/shared/dist/execution-report.d.ts

@@ -43,7 +43,7 @@ export declare const ExecutionReportQuery: z.ZodObject<{
     limit: number;
     page: number;
     status?: string | undefined;
-    role?: "developer" | "reviewer" | "legacy" | undefined;
+    role?: "reviewer" | "developer" | "legacy" | undefined;
     runtime?: string | undefined;
     model?: string | undefined;
     from?: string | undefined;
@@ -51,7 +51,7 @@ export declare const ExecutionReportQuery: z.ZodObject<{
     repo?: string | undefined;
 }, {
     status?: string | undefined;
-    role?: "developer" | "reviewer" | "legacy" | undefined;
+    role?: "reviewer" | "developer" | "legacy" | undefined;
     runtime?: string | undefined;
     model?: string | undefined;
     from?: string | undefined;

package/bundle/shared/dist/human-actions.d.ts

@@ -29,34 +29,34 @@ export declare const HumanAction: z.ZodObject<{
     requestedAt: z.ZodString;
     resolvedAt: z.ZodNullable<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
+    actionType: "policy_escalation" | "final_review" | "product_scope_decision" | "attempts_exhausted" | "deck_interaction_required" | "reflection_interaction_required" | "outbound_delivery_interaction_required";
+    question: string;
+    reason: string;
+    evidenceJson: string | null;
+    responseOptionsJson: string | null;
+    continuationPreviewJson: string | null;
     status: "open" | "resolved";
     id: string;
     issueId: string | null;
     runId: string | null;
     workflowInstanceId: string | null;
-    actionType: "product_scope_decision" | "policy_escalation" | "attempts_exhausted" | "final_review" | "deck_interaction_required" | "reflection_interaction_required" | "outbound_delivery_interaction_required";
-    reason: string;
-    question: string;
-    evidenceJson: string | null;
-    responseOptionsJson: string | null;
-    continuationPreviewJson: string | null;
     requestId: string | null;
     resolutionJson: string | null;
     resolvedBy: string | null;
     requestedAt: string;
     resolvedAt: string | null;
 }, {
+    actionType: "policy_escalation" | "final_review" | "product_scope_decision" | "attempts_exhausted" | "deck_interaction_required" | "reflection_interaction_required" | "outbound_delivery_interaction_required";
+    question: string;
+    reason: string;
+    evidenceJson: string | null;
+    responseOptionsJson: string | null;
+    continuationPreviewJson: string | null;
     status: "open" | "resolved";
     id: string;
     issueId: string | null;
     runId: string | null;
     workflowInstanceId: string | null;
-    actionType: "product_scope_decision" | "policy_escalation" | "attempts_exhausted" | "final_review" | "deck_interaction_required" | "reflection_interaction_required" | "outbound_delivery_interaction_required";
-    reason: string;
-    question: string;
-    evidenceJson: string | null;
-    responseOptionsJson: string | null;
-    continuationPreviewJson: string | null;
     requestId: string | null;
     resolutionJson: string | null;
     resolvedBy: string | null;