@intentic/sandbox-contract 1.314.0 → 1.316.0

package/src/text/transcript-fold.ts

@@ -20,6 +20,11 @@ import { unspokenPromptRow } from "../events/agent-words.js";
 // Folds a turn's frames into rows once, live and for the settled record alike, so a reopened chat matches what was on
 // screen. `tag` selects the stream read: undefined is the main turn, a tool-call id is the subagent it spawned; other
 // frames nest under the card that spawned them. Rows mutate in place; every patch carries a copy of what it names.
+//
+// Every subagent lands on the card of the call that started it, whichever mechanism started it. An in-process one (the
+// runtime's own Agent/Task tool) is named by that call's id, so its card is found at once. A spawned one is named by its
+// own conversation id, and every door that spawns one answers with that id (the spawn tool's `child`, the `agents
+// spawn` CLI's first line), so its frames wait until a card's result names it, then ride that card from there on.
 
 export type TurnEnding = "settled" | "stopped";
 
@@ -40,6 +45,13 @@ const defined = <T extends object>(value: T): Partial<T> =>
 // A card's own fields: what a `tool` patch carries, so a delegation's growing subtree never rides one.
 const ownFields = ({ children: _children, thinking: _thinking, ...own }: TranscriptTool): TranscriptTool => own;
 
+// Everything a card's result said, as one string: what a subagent waiting for its card is looked for in.
+const resultWords = (tool: TranscriptTool): string =>
+    (tool.content ?? [])
+        .filter((entry) => entry.type === "text")
+        .map((entry) => entry.text)
+        .join("\n");
+
 const cardOf = (event: Extract<AgentEvent, { kind: "tool_call" }>): TranscriptTool => ({
     id: event.id,
     name: event.name,
@@ -212,6 +224,11 @@ export class TranscriptFold {
     // Index of the open assistant bubble; always the last row, since every other row kind closes it first.
     private bubble: number | undefined;
     private readonly cards = new Map<string, CardPlace>();
+    // A subagent's own id to the card of the call that started it, once that card is known.
+    private readonly placed = new Map<string, string>();
+    // A subagent heard before its card: born, and perhaps already moving, while the call that started it had not yet
+    // said its id. Placed as soon as a card claims it; dropped with the fold if none ever does.
+    private readonly unplaced = new Map<string, TranscriptSubagent>();
     // requestId to the row holding its card, for frames landing on it later (a reply, a late sentence, a receipt).
     private readonly parked = new Map<string, number>();
     // The turn's opening user row, where the checkpoint and daemon notes land; cleared once `retract` takes it back.
@@ -266,6 +283,7 @@ export class TranscriptFold {
                 const row = this.rows[index]!;
                 row.tools = [...(row.tools ?? []), tool];
                 this.cards.set(tool.id, { tool, row: index });
+                this.claimById(tool);
                 return [...opened, { op: "tool", index, tool: structuredClone(tool) }];
             }
             case "tool_call_update":
@@ -276,27 +294,16 @@ export class TranscriptFold {
                     }
                     if (event.content !== undefined) {
                         tool.content = event.content;
+                        this.claimByResult(tool);
                     }
                     if (event.locations !== undefined) {
                         tool.locations = event.locations;
                     }
                 });
-            case "subagent": {
-                // The frame's id is the spawning call's id, so the subagent record lands on that card.
-                const { kind: _kind, id, subagentKind, ...rest } = event;
-                return this.patchCard(id, (tool) => {
-                    tool.subagent = { ...rest, kind: subagentKind, status: "running" };
-                });
-            }
-            case "subagent_update": {
-                // Present fields replace, absent ones leave the child alone, as in tool_call_update.
-                const { kind: _kind, id, ...patch } = event;
-                return this.patchCard(id, (tool) => {
-                    if (tool.subagent !== undefined) {
-                        tool.subagent = { ...tool.subagent, ...(defined(patch) as Partial<TranscriptSubagent>) };
-                    }
-                });
-            }
+            case "subagent":
+                return this.subagentBorn(event);
+            case "subagent_update":
+                return this.subagentMoved(event);
             case "todos": {
                 const [index, opened] = this.open();
                 this.rows[index]!.todos = [...event.items];
@@ -561,11 +568,83 @@ export class TranscriptFold {
             const child = cardOf(event);
             place.tool.children = [...(place.tool.children ?? []), child];
             this.cards.set(child.id, { tool: child, row: place.row, parent });
+            this.claimById(child);
             return [{ op: "tool", index: place.row, tool: structuredClone(child), parent }];
         }
         return [];
     }
 
+    // A subagent starts: on its card when that is known, else held until a card claims it. A later birth under the same
+    // id (a follow-up turn of the same subagent) starts its card's state over.
+    private subagentBorn(event: Extract<AgentEvent, { kind: "subagent" }>): TranscriptPatch[] {
+        const { kind: _kind, id, subagentKind, ...rest } = event;
+        const born: TranscriptSubagent = { ...rest, kind: subagentKind, status: "running" };
+        const card = this.cardOfSubagent(id);
+        if (card === undefined) {
+            this.unplaced.set(id, born);
+            return [];
+        }
+        return this.patchCard(card, (tool) => this.place(tool, id, born));
+    }
+
+    // A subagent moves: present fields replace, absent ones leave it alone, as in tool_call_update; one still waiting for
+    // its card moves where it waits.
+    private subagentMoved(event: Extract<AgentEvent, { kind: "subagent_update" }>): TranscriptPatch[] {
+        const { kind: _kind, id, ...patch } = event;
+        const moved = defined(patch) as Partial<TranscriptSubagent>;
+        const card = this.cardOfSubagent(id);
+        if (card !== undefined) {
+            return this.patchCard(card, (tool) => {
+                if (tool.subagent !== undefined) {
+                    tool.subagent = { ...tool.subagent, ...moved };
+                }
+            });
+        }
+        const waiting = this.unplaced.get(id);
+        if (waiting !== undefined) {
+            this.unplaced.set(id, { ...waiting, ...moved });
+        }
+        return [];
+    }
+
+    // The card a subagent's frames land on: the one already carrying it, else the one sharing its id (an in-process
+    // subagent is named by the call that started it); undefined while the call that started it has not yet named it.
+    private cardOfSubagent(id: string): string | undefined {
+        return this.placed.get(id) ?? (this.cards.has(id) ? id : undefined);
+    }
+
+    // Puts a subagent on the card that started it. Its own id rides along only where it differs from the card's, so the
+    // card can still name it to the roster, `wait` and its own page.
+    private place(tool: TranscriptTool, id: string, subagent: TranscriptSubagent): void {
+        const { id: _id, ...state } = subagent;
+        tool.subagent = id === tool.id ? state : { ...state, id };
+        this.placed.set(id, tool.id);
+        this.unplaced.delete(id);
+    }
+
+    // A card appearing under the id a subagent was already heard by: the stream said the child before the call.
+    private claimById(tool: TranscriptTool): void {
+        const waiting = this.unplaced.get(tool.id);
+        if (waiting !== undefined) {
+            this.place(tool, tool.id, waiting);
+        }
+    }
+
+    // A call whose result names a subagent still waiting for its card is the call that started it. A card carries one
+    // subagent, so one that already has its own claims nothing more.
+    private claimByResult(tool: TranscriptTool): void {
+        if (this.unplaced.size === 0 || tool.subagent !== undefined) {
+            return;
+        }
+        const words = resultWords(tool);
+        for (const [id, waiting] of this.unplaced) {
+            if (words.includes(id)) {
+                this.place(tool, id, waiting);
+                return;
+            }
+        }
+    }
+
     // Returns the bubble frames write to, opening a fresh assistant row when the last one was retired.
     private open(): [number, TranscriptPatch[]] {
         if (this.bubble !== undefined) {

package/dist/schemas/workspace/mainline.d.ts

@@ -1,513 +0,0 @@
-import { z } from "zod";
-export declare const MainlineLandSchema: z.ZodObject<{
-    conversationId: z.ZodString;
-    title: z.ZodOptional<z.ZodString>;
-    at: z.ZodNumber;
-}, z.core.$strip>;
-export type MainlineLand = z.infer<typeof MainlineLandSchema>;
-export declare const MainlineLandRefSchema: z.ZodObject<{
-    conversationId: z.ZodString;
-    title: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export type MainlineLandRef = z.infer<typeof MainlineLandRefSchema>;
-export declare const MainlineFailureSchema: z.ZodObject<{
-    name: z.ZodString;
-    path: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export type MainlineFailure = z.infer<typeof MainlineFailureSchema>;
-export declare const MainlineRoutingKindSchema: z.ZodEnum<{
-    dismissed: "dismissed";
-    "fix-up": "fix-up";
-    held: "held";
-    original: "original";
-    reported: "reported";
-    resolved: "resolved";
-    spent: "spent";
-    waiting: "waiting";
-}>;
-export type MainlineRoutingKind = z.infer<typeof MainlineRoutingKindSchema>;
-export declare const MainlineRoutingSchema: z.ZodObject<{
-    kind: z.ZodEnum<{
-        dismissed: "dismissed";
-        "fix-up": "fix-up";
-        held: "held";
-        original: "original";
-        reported: "reported";
-        resolved: "resolved";
-        spent: "spent";
-        waiting: "waiting";
-    }>;
-    conversationId: z.ZodOptional<z.ZodString>;
-    at: z.ZodNumber;
-    detail: z.ZodOptional<z.ZodString>;
-    findings: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>;
-export type MainlineRouting = z.infer<typeof MainlineRoutingSchema>;
-export declare const MAINLINE_FAILURES_KEPT = 30;
-export declare const MainlineRunSchema: z.ZodObject<{
-    project: z.ZodString;
-    command: z.ZodString;
-    status: z.ZodEnum<{
-        green: "green";
-        red: "red";
-    }>;
-    startedAt: z.ZodNumber;
-    at: z.ZodNumber;
-    lands: z.ZodArray<z.ZodObject<{
-        conversationId: z.ZodString;
-        title: z.ZodOptional<z.ZodString>;
-        at: z.ZodNumber;
-    }, z.core.$strip>>;
-    failures: z.ZodArray<z.ZodString>;
-    failureCount: z.ZodNumber;
-    attempt: z.ZodNumber;
-    suspects: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    named: z.ZodOptional<z.ZodBoolean>;
-    units: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        path: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>;
-    routing: z.ZodOptional<z.ZodObject<{
-        kind: z.ZodEnum<{
-            dismissed: "dismissed";
-            "fix-up": "fix-up";
-            held: "held";
-            original: "original";
-            reported: "reported";
-            resolved: "resolved";
-            spent: "spent";
-            waiting: "waiting";
-        }>;
-        conversationId: z.ZodOptional<z.ZodString>;
-        at: z.ZodNumber;
-        detail: z.ZodOptional<z.ZodString>;
-        findings: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type MainlineRun = z.infer<typeof MainlineRunSchema>;
-export declare const MainlineProjectSchema: z.ZodObject<{
-    project: z.ZodString;
-    running: z.ZodOptional<z.ZodObject<{
-        command: z.ZodString;
-        startedAt: z.ZodNumber;
-        lands: z.ZodArray<z.ZodObject<{
-            conversationId: z.ZodString;
-            title: z.ZodOptional<z.ZodString>;
-            at: z.ZodNumber;
-        }, z.core.$strip>>;
-        on: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    session: z.ZodOptional<z.ZodString>;
-    queued: z.ZodArray<z.ZodObject<{
-        conversationId: z.ZodString;
-        title: z.ZodOptional<z.ZodString>;
-        at: z.ZodNumber;
-    }, z.core.$strip>>;
-    last: z.ZodOptional<z.ZodObject<{
-        project: z.ZodString;
-        command: z.ZodString;
-        status: z.ZodEnum<{
-            green: "green";
-            red: "red";
-        }>;
-        startedAt: z.ZodNumber;
-        at: z.ZodNumber;
-        lands: z.ZodArray<z.ZodObject<{
-            conversationId: z.ZodString;
-            title: z.ZodOptional<z.ZodString>;
-            at: z.ZodNumber;
-        }, z.core.$strip>>;
-        failures: z.ZodArray<z.ZodString>;
-        failureCount: z.ZodNumber;
-        attempt: z.ZodNumber;
-        suspects: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        named: z.ZodOptional<z.ZodBoolean>;
-        units: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            name: z.ZodString;
-            path: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>>;
-        routing: z.ZodOptional<z.ZodObject<{
-            kind: z.ZodEnum<{
-                dismissed: "dismissed";
-                "fix-up": "fix-up";
-                held: "held";
-                original: "original";
-                reported: "reported";
-                resolved: "resolved";
-                spent: "spent";
-                waiting: "waiting";
-            }>;
-            conversationId: z.ZodOptional<z.ZodString>;
-            at: z.ZodNumber;
-            detail: z.ZodOptional<z.ZodString>;
-            findings: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    redSince: z.ZodOptional<z.ZodNumber>;
-    red: z.ZodOptional<z.ZodObject<{
-        since: z.ZodNumber;
-        cause: z.ZodArray<z.ZodObject<{
-            conversationId: z.ZodString;
-            title: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        named: z.ZodBoolean;
-        fixer: z.ZodOptional<z.ZodObject<{
-            kind: z.ZodEnum<{
-                dismissed: "dismissed";
-                "fix-up": "fix-up";
-                held: "held";
-                original: "original";
-                reported: "reported";
-                resolved: "resolved";
-                spent: "spent";
-                waiting: "waiting";
-            }>;
-            conversationId: z.ZodOptional<z.ZodString>;
-            at: z.ZodNumber;
-            detail: z.ZodOptional<z.ZodString>;
-            findings: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type MainlineProject = z.infer<typeof MainlineProjectSchema>;
-export declare const FindingSchema: z.ZodObject<{
-    id: z.ZodString;
-    source: z.ZodString;
-    text: z.ZodString;
-    path: z.ZodOptional<z.ZodString>;
-    command: z.ZodOptional<z.ZodString>;
-    recheckable: z.ZodBoolean;
-    gate: z.ZodOptional<z.ZodEnum<{
-        code: "code";
-        tidy: "tidy";
-    }>>;
-    commit: z.ZodOptional<z.ZodObject<{
-        sha: z.ZodString;
-        subject: z.ZodString;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type Finding = z.infer<typeof FindingSchema>;
-export declare const RedSourceSchema: z.ZodEnum<{
-    ci: "ci";
-    land: "land";
-    push: "push";
-}>;
-export type RedSource = z.infer<typeof RedSourceSchema>;
-export declare const RED_POLICY: {
-    readonly land: "route";
-    readonly push: "owner";
-    readonly ci: "fix-agent";
-};
-export declare const RedSchema: z.ZodObject<{
-    source: z.ZodEnum<{
-        ci: "ci";
-        land: "land";
-        push: "push";
-    }>;
-    scope: z.ZodString;
-    since: z.ZodNumber;
-    findings: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        source: z.ZodString;
-        text: z.ZodString;
-        path: z.ZodOptional<z.ZodString>;
-        command: z.ZodOptional<z.ZodString>;
-        recheckable: z.ZodBoolean;
-        gate: z.ZodOptional<z.ZodEnum<{
-            code: "code";
-            tidy: "tidy";
-        }>>;
-        commit: z.ZodOptional<z.ZodObject<{
-            sha: z.ZodString;
-            subject: z.ZodString;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>>;
-    suspects: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    named: z.ZodDefault<z.ZodBoolean>;
-    decisions: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        kind: z.ZodEnum<{
-            dismissed: "dismissed";
-            "fix-up": "fix-up";
-            held: "held";
-            original: "original";
-            reported: "reported";
-            resolved: "resolved";
-            spent: "spent";
-            waiting: "waiting";
-        }>;
-        conversationId: z.ZodOptional<z.ZodString>;
-        at: z.ZodNumber;
-        detail: z.ZodOptional<z.ZodString>;
-        findings: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>>>;
-}, z.core.$strip>;
-export type Red = z.infer<typeof RedSchema>;
-export declare const MainlinePushSchema: z.ZodObject<{
-    project: z.ZodString;
-    id: z.ZodString;
-    at: z.ZodNumber;
-    remote: z.ZodOptional<z.ZodString>;
-    branch: z.ZodOptional<z.ZodString>;
-    base: z.ZodOptional<z.ZodString>;
-    head: z.ZodString;
-    commits: z.ZodNumber;
-    findings: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        source: z.ZodString;
-        text: z.ZodString;
-        path: z.ZodOptional<z.ZodString>;
-        command: z.ZodOptional<z.ZodString>;
-        recheckable: z.ZodBoolean;
-        gate: z.ZodOptional<z.ZodEnum<{
-            code: "code";
-            tidy: "tidy";
-        }>>;
-        commit: z.ZodOptional<z.ZodObject<{
-            sha: z.ZodString;
-            subject: z.ZodString;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    refused: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-export type MainlinePush = z.infer<typeof MainlinePushSchema>;
-export declare const MainlineStatusSchema: z.ZodObject<{
-    projects: z.ZodArray<z.ZodObject<{
-        project: z.ZodString;
-        running: z.ZodOptional<z.ZodObject<{
-            command: z.ZodString;
-            startedAt: z.ZodNumber;
-            lands: z.ZodArray<z.ZodObject<{
-                conversationId: z.ZodString;
-                title: z.ZodOptional<z.ZodString>;
-                at: z.ZodNumber;
-            }, z.core.$strip>>;
-            on: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        session: z.ZodOptional<z.ZodString>;
-        queued: z.ZodArray<z.ZodObject<{
-            conversationId: z.ZodString;
-            title: z.ZodOptional<z.ZodString>;
-            at: z.ZodNumber;
-        }, z.core.$strip>>;
-        last: z.ZodOptional<z.ZodObject<{
-            project: z.ZodString;
-            command: z.ZodString;
-            status: z.ZodEnum<{
-                green: "green";
-                red: "red";
-            }>;
-            startedAt: z.ZodNumber;
-            at: z.ZodNumber;
-            lands: z.ZodArray<z.ZodObject<{
-                conversationId: z.ZodString;
-                title: z.ZodOptional<z.ZodString>;
-                at: z.ZodNumber;
-            }, z.core.$strip>>;
-            failures: z.ZodArray<z.ZodString>;
-            failureCount: z.ZodNumber;
-            attempt: z.ZodNumber;
-            suspects: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            named: z.ZodOptional<z.ZodBoolean>;
-            units: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                name: z.ZodString;
-                path: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>>>;
-            routing: z.ZodOptional<z.ZodObject<{
-                kind: z.ZodEnum<{
-                    dismissed: "dismissed";
-                    "fix-up": "fix-up";
-                    held: "held";
-                    original: "original";
-                    reported: "reported";
-                    resolved: "resolved";
-                    spent: "spent";
-                    waiting: "waiting";
-                }>;
-                conversationId: z.ZodOptional<z.ZodString>;
-                at: z.ZodNumber;
-                detail: z.ZodOptional<z.ZodString>;
-                findings: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            }, z.core.$strip>>;
-        }, z.core.$strip>>;
-        redSince: z.ZodOptional<z.ZodNumber>;
-        red: z.ZodOptional<z.ZodObject<{
-            since: z.ZodNumber;
-            cause: z.ZodArray<z.ZodObject<{
-                conversationId: z.ZodString;
-                title: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>>;
-            named: z.ZodBoolean;
-            fixer: z.ZodOptional<z.ZodObject<{
-                kind: z.ZodEnum<{
-                    dismissed: "dismissed";
-                    "fix-up": "fix-up";
-                    held: "held";
-                    original: "original";
-                    reported: "reported";
-                    resolved: "resolved";
-                    spent: "spent";
-                    waiting: "waiting";
-                }>;
-                conversationId: z.ZodOptional<z.ZodString>;
-                at: z.ZodNumber;
-                detail: z.ZodOptional<z.ZodString>;
-                findings: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            }, z.core.$strip>>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    recent: z.ZodArray<z.ZodObject<{
-        project: z.ZodString;
-        command: z.ZodString;
-        status: z.ZodEnum<{
-            green: "green";
-            red: "red";
-        }>;
-        startedAt: z.ZodNumber;
-        at: z.ZodNumber;
-        lands: z.ZodArray<z.ZodObject<{
-            conversationId: z.ZodString;
-            title: z.ZodOptional<z.ZodString>;
-            at: z.ZodNumber;
-        }, z.core.$strip>>;
-        failures: z.ZodArray<z.ZodString>;
-        failureCount: z.ZodNumber;
-        attempt: z.ZodNumber;
-        suspects: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        named: z.ZodOptional<z.ZodBoolean>;
-        units: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            name: z.ZodString;
-            path: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>>;
-        routing: z.ZodOptional<z.ZodObject<{
-            kind: z.ZodEnum<{
-                dismissed: "dismissed";
-                "fix-up": "fix-up";
-                held: "held";
-                original: "original";
-                reported: "reported";
-                resolved: "resolved";
-                spent: "spent";
-                waiting: "waiting";
-            }>;
-            conversationId: z.ZodOptional<z.ZodString>;
-            at: z.ZodNumber;
-            detail: z.ZodOptional<z.ZodString>;
-            findings: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    pushed: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        project: z.ZodString;
-        id: z.ZodString;
-        at: z.ZodNumber;
-        remote: z.ZodOptional<z.ZodString>;
-        branch: z.ZodOptional<z.ZodString>;
-        base: z.ZodOptional<z.ZodString>;
-        head: z.ZodString;
-        commits: z.ZodNumber;
-        findings: z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            source: z.ZodString;
-            text: z.ZodString;
-            path: z.ZodOptional<z.ZodString>;
-            command: z.ZodOptional<z.ZodString>;
-            recheckable: z.ZodBoolean;
-            gate: z.ZodOptional<z.ZodEnum<{
-                code: "code";
-                tidy: "tidy";
-            }>>;
-            commit: z.ZodOptional<z.ZodObject<{
-                sha: z.ZodString;
-                subject: z.ZodString;
-            }, z.core.$strip>>;
-        }, z.core.$strip>>;
-        refused: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>>;
-    reds: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        source: z.ZodEnum<{
-            ci: "ci";
-            land: "land";
-            push: "push";
-        }>;
-        scope: z.ZodString;
-        since: z.ZodNumber;
-        findings: z.ZodDefault<z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            source: z.ZodString;
-            text: z.ZodString;
-            path: z.ZodOptional<z.ZodString>;
-            command: z.ZodOptional<z.ZodString>;
-            recheckable: z.ZodBoolean;
-            gate: z.ZodOptional<z.ZodEnum<{
-                code: "code";
-                tidy: "tidy";
-            }>>;
-            commit: z.ZodOptional<z.ZodObject<{
-                sha: z.ZodString;
-                subject: z.ZodString;
-            }, z.core.$strip>>;
-        }, z.core.$strip>>>;
-        suspects: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        named: z.ZodDefault<z.ZodBoolean>;
-        decisions: z.ZodDefault<z.ZodArray<z.ZodObject<{
-            kind: z.ZodEnum<{
-                dismissed: "dismissed";
-                "fix-up": "fix-up";
-                held: "held";
-                original: "original";
-                reported: "reported";
-                resolved: "resolved";
-                spent: "spent";
-                waiting: "waiting";
-            }>;
-            conversationId: z.ZodOptional<z.ZodString>;
-            at: z.ZodNumber;
-            detail: z.ZodOptional<z.ZodString>;
-            findings: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strip>>>;
-    }, z.core.$strip>>>;
-}, z.core.$strip>;
-export type MainlineStatus = z.infer<typeof MainlineStatusSchema>;
-export declare const MainlinePushDismissSchema: z.ZodObject<{
-    project: z.ZodString;
-    ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    restore: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-export type MainlinePushDismiss = z.infer<typeof MainlinePushDismissSchema>;
-export declare const MainlinePushDismissResultSchema: z.ZodObject<{
-    changed: z.ZodNumber;
-}, z.core.$strip>;
-export declare const MainlinePushRecheckSchema: z.ZodObject<{
-    project: z.ZodString;
-}, z.core.$strip>;
-export declare const MainlinePushRecheckResultSchema: z.ZodObject<{
-    measured: z.ZodBoolean;
-    resolved: z.ZodNumber;
-    open: z.ZodNumber;
-}, z.core.$strip>;
-export type MainlinePushRecheckResult = z.infer<typeof MainlinePushRecheckResultSchema>;
-export declare const MainlinePushFixSchema: z.ZodObject<{
-    project: z.ZodString;
-    pick: z.ZodOptional<z.ZodObject<{
-        agent: z.ZodString;
-        model: z.ZodString;
-        account: z.ZodOptional<z.ZodString>;
-        harness: z.ZodOptional<z.ZodEnum<{
-            "claude-code": "claude-code";
-            native: "native";
-        }>>;
-        effort: z.ZodOptional<z.ZodString>;
-        thinking: z.ZodOptional<z.ZodBoolean>;
-        fast: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    mode: z.ZodOptional<z.ZodEnum<{
-        continue: "continue";
-        "start-over": "start-over";
-    }>>;
-}, z.core.$strip>;
-export type MainlinePushFix = z.infer<typeof MainlinePushFixSchema>;
-export declare const MainlinePushFixResultSchema: z.ZodObject<{
-    conversationId: z.ZodString;
-}, z.core.$strip>;
-export declare const pushRedOf: (reds: readonly Red[] | undefined, project: string) => Red | undefined;
-export declare const pushFixBase: (red: Pick<Red, "scope" | "since"> | undefined) => string | undefined;
-//# sourceMappingURL=mainline.d.ts.map

package/dist/schemas/workspace/mainline.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mainline.d.ts","sourceRoot":"","sources":["../../../src/schemas/workspace/mainline.ts"],"names":[],"mappings":"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"}