@intentic/sandbox-contract 1.316.0 → 1.318.0

package/src/text/transcript-fold.ts

@@ -10,16 +10,18 @@ import {
     type TranscriptSubagent,
     type TranscriptTool,
 } from "../events/transcript.js";
-import { contextTrimLine } from "../schemas/context-trim.js";
-import { keptWarmLine } from "../schemas/keep-warm.js";
+import { contextTrimLine, contextTrimNotice } from "../schemas/context-trim.js";
+import { keptWarmLine, keptWarmNotice } from "../schemas/keep-warm.js";
 import { isLandConflict } from "../events/land-conflict.js";
 import { turnedAwayCode } from "../policy/turned-away.js";
 import { mentionedPathTokens } from "./mentions.js";
 import { unspokenPromptRow } from "../events/agent-words.js";
+import { needRowText } from "../events/need-wake.js";
+import { noticeCode, sandboxNoticeOf } from "../events/sandbox-notice.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.
+// screen. The main turn's frames are its rows; a frame a subagent produced (tagged with the call that spawned it) nests
+// under that call's card. 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
@@ -30,6 +32,7 @@ export type TurnEnding = "settled" | "stopped";
 
 // A compaction's row, live and restored from the provider's store alike.
 export const COMPACTED_NOTICE = "Context compacted to free up space.";
+export const compactedRow = (): TranscriptRow => ({ role: "notice", text: COMPACTED_NOTICE, noticeCode: noticeCode({ code: "compacted" }) });
 
 // Where a tool card lives: its row, and the parent card it nests under when it's a helper's own call.
 interface CardPlace {
@@ -77,7 +80,8 @@ const empty = (row: TranscriptRow): boolean =>
     !holdsRequest(row);
 
 // Clause appended to the landed notice for a workspace dependency change, or empty when there is none. Reports the
-// install as already started, or queued when other agents are still running; never as a request.
+// install as already started, or as on its way: the daemon starts it within seconds, in the install lane, behind any
+// install already running; never as a request.
 const dependencyLine = (deps: { missing: number; started: string[]; deferred: boolean } | undefined): string => {
     if (deps === undefined || deps.missing === 0) {
         return ``;
@@ -85,10 +89,40 @@ const dependencyLine = (deps: { missing: number; started: string[]; deferred: bo
     // `missing` counts versions the turn bumped as well as names it added, so the sentence names both.
     const what = `${deps.missing} ${deps.missing === 1 ? `dependency` : `dependencies`} it added or changed`;
     return deps.deferred
-        ? ` ${what} ${deps.missing === 1 ? `is` : `are`} queued: installation starts after this turn and any other active agents finish, appears in Work terminals, then its checks and outcome land in Activity.`
+        ? ` ${what} ${deps.missing === 1 ? `is` : `are`} being installed in your tree: the install waits for any other install to finish, appears in Work terminals, and its outcome lands in Activity.`
         : ` Installing ${what}; the project's checks run when that finishes, and the outcome lands in Activity.`;
 };
 
+// Said as an agent's own install starts: where it writes and what outlasts it. Names up to three projects, the workspace
+// root first; an install the gate could not place in a project says only where it writes. Coded like every sandbox
+// notice (sandbox-notice.ts `installing`), so the chat can say it in the reader's language.
+const INSTALL_NAMED = 3;
+const installRow = (event: { readonly reach: "own-copy" | "main-tree"; readonly projects: readonly string[] }): TranscriptRow => {
+    const root = event.projects.includes(``);
+    const dirs = event.projects.filter((dir) => dir !== ``).map((dir) => `${dir}/`);
+    const shownDirs = dirs.slice(0, INSTALL_NAMED - (root ? 1 : 0));
+    const more = dirs.length - shownDirs.length;
+    const named = [...(root ? [`the workspace root`] : []), ...shownDirs].join(`, `);
+    const list = more > 0 ? `${named} and ${more} more` : named;
+    const where = list === `` ? `` : ` in ${list}`;
+    const ownCopy = event.reach === `own-copy`;
+    return {
+        role: "notice",
+        text: ownCopy
+            ? `Installing packages${where} into this conversation's own copy. The manifest and lockfile land with the work, and the review lists what it adds.`
+            : `Installing packages${where} in the main tree, one install at a time.`,
+        noticeCode: noticeCode({
+            code: "installing",
+            params: {
+                ownCopy,
+                root: root || undefined,
+                projects: shownDirs.length === 0 ? undefined : shownDirs.join(`, `),
+                more: more > 0 ? more : undefined,
+            },
+        }),
+    };
+};
+
 // One line reporting the daemon's rebase of this agent's branch onto the current workspace; `blocked` names repos it
 // couldn't rebase, where the turn ran from an older base.
 const syncLine = (sync: { commits: number; blocked: readonly string[] }): string => {
@@ -103,30 +137,57 @@ const syncLine = (sync: { commits: number; blocked: readonly string[] }): string
     return [moved, blocked].filter((line) => line !== undefined).join(` `);
 };
 
+// Row for a spawned child's work gone into its parent's checkout, or held off it by a clash with the parent's edits.
+const intoParentRow = (event: Extract<AgentEvent, { kind: "landed" }>): TranscriptRow => {
+    if (event.landed) {
+        return {
+            role: "notice",
+            text: `Changes went into the parent agent's checkout, as its in-process subagents' edits do: they reach your workspace with its land.`,
+            noticeCode: noticeCode({ code: "intoParent" }),
+        };
+    }
+    const files = (event.conflicts ?? []).flatMap((conflict) => conflict.paths).length;
+    return {
+        role: "notice",
+        text: `${files} file(s) clash with the parent agent's own edits, so nothing was written into its checkout. The parent was told, and can bring the changes in to resolve.`,
+        noticeCode: noticeCode({ code: "intoParentClash", params: { files } }),
+    };
+};
+
 // Row for a finished turn: held on its branch, landed automatically, or conflicted. A landed turn that changed
 // dependencies appends dependencyLine, since the Changes diff can't show that.
 const landedRow = (event: Extract<AgentEvent, { kind: "landed" }>): TranscriptRow => {
+    if (event.into !== undefined) {
+        return intoParentRow(event);
+    }
     if (event.held === true) {
-        return { role: "notice", text: `Finished: the work is on this agent's branch, ready to land from its review.` };
+        return { role: "notice", text: `Finished: the work is on this agent's branch, ready to land from its review.`, noticeCode: noticeCode({ code: "landHeld" }) };
     }
     if (!event.landed) {
         // Per-file cause (your edits, a moved main line, a binary) is spelled out in the review, not named here.
         const conflicts = event.conflicts ?? [];
+        const files = conflicts.flatMap((conflict) => conflict.paths).length;
+        const repos = conflicts.map((conflict) => conflict.repo).join(`, `);
         return {
             role: "notice",
-            text: `${conflicts.flatMap((conflict) => conflict.paths).length} file(s) couldn't land automatically in ${conflicts
-                .map((conflict) => conflict.repo)
-                .join(`, `)}. Open the agent's review to see what blocked them and land from there.`,
+            text: `${files} file(s) couldn't land automatically in ${repos}. Open the agent's review to see what blocked them and land from there.`,
+            noticeCode: noticeCode({ code: "landConflict", params: { files, repos } }),
         };
     }
     // noticeAction fires only here, right as the auto-behavior ran; an active install takes the slot instead.
+    const deps = event.deps === undefined || event.deps.missing === 0 ? undefined : event.deps;
     return {
         role: "notice",
         text: `Changes landed in your workspace: review them in the Changes panel.${dependencyLine(event.deps)}`,
         noticeAction: (event.deps?.started.length ?? 0) > 0 ? "depsInstall" : "landHold",
+        noticeCode: noticeCode({ code: "landed", params: deps === undefined ? undefined : { deps: deps.missing, queued: deps.deferred || undefined } }),
     };
 };
 
+// A failure's own sentence and code, which every coded error row carries ahead of what it adds.
+const failureOf = (event: Extract<AgentEvent, { kind: "error" }>): { message: string; error?: string } =>
+    event.code === undefined ? { message: event.message } : { message: event.message, error: event.code };
+
 // The clause after a refusal that ran nothing. A turn somebody typed is held in its conversation's queue for another
 // press; a turn that started itself — an automation, a loop, a watch wake — has no typed message and nobody watching,
 // so promising a resend there names a composer the reader is not looking at. Neither version promises a retry: whether
@@ -147,6 +208,7 @@ const memoryPress = (event: Extract<AgentEvent, { kind: "error" }>): "sendAnyway
 const heldRow = (event: Extract<AgentEvent, { kind: "error" }>): TranscriptRow => {
     const unattended = event.unattended === true;
     const memory = event.code === "sandbox-memory-low";
+    const said = failureOf(event);
     if (event.held !== undefined && !unattended) {
         return {
             role: "notice",
@@ -155,55 +217,95 @@ const heldRow = (event: Extract<AgentEvent, { kind: "error" }>): TranscriptRow =
                 : `${event.message} Nothing has run yet: the message above is kept here to send again once that is sorted.`,
             noticeAction: memory ? memoryPress(event) : "sendAgain",
             sandboxHeld: true,
+            noticeCode: noticeCode({ code: "kept", params: { ...said, memory: memory || undefined } }),
         };
     }
     if (!memory || unattended) {
-        return { role: "notice", text: `${event.message} ${undelivered(unattended)}` };
+        return {
+            role: "notice",
+            text: `${event.message} ${undelivered(unattended)}`,
+            noticeCode: noticeCode({ code: "undelivered", params: { ...said, unattended: unattended || undefined } }),
+        };
     }
     return {
         role: "notice",
         text: `${event.message} Your message is held: send it again to start anyway.`,
         noticeAction: memoryPress(event),
+        noticeCode: noticeCode({ code: "memoryHeld", params: said }),
     };
 };
 
+// What an armed credential renewal promises, and what its row says instead once a later failure in the same run took
+// that promise back (TranscriptFold.withdrawRenewal).
+const RENEWING = "The credential is being renewed and this turn continues automatically.";
+const RENEWAL_WITHDRAWN =
+    "The credential was being renewed, but the turn stopped before it could continue: it will not carry on by itself, so press Continue to pick it back up.";
+
 // Row for a turn-ending error: the provider's own message plus one clause on what happens next. The live wait itself is
 // drawn by the chat, not stored here.
 const errorRow = (event: Extract<AgentEvent, { kind: "error" }>): TranscriptRow => {
     const { message, code } = event;
+    const said = failureOf(event);
     switch (code) {
-        case "provider-outage":
-            return { role: "notice", text: `${message} ${retryClause(event) ?? `Nothing is retrying it, so the turn is waiting here.`}` };
+        case "provider-outage": {
+            const retry = retryClause(event);
+            return retry === undefined
+                ? {
+                      role: "notice",
+                      text: `${message} Nothing is retrying it, so the turn is waiting here.`,
+                      noticeCode: noticeCode({ code: "outageWaiting", params: said }),
+                  }
+                : { role: "notice", text: `${message} ${retry.text}`, noticeCode: retry.code };
+        }
         case "claude-token-refused":
             return event.autoResume === "scheduled"
                 ? {
                       role: "notice",
-                      text: `${message} The credential is being renewed and this turn continues automatically.`,
+                      text: `${message} ${RENEWING}`,
                       noticeWait: "credentialRenewal",
+                      noticeCode: noticeCode({ code: "renewing", params: said }),
                   }
-                : { role: "notice", text: `${message} Reconnect the account to pick this conversation back up.` };
+                : {
+                      role: "notice",
+                      text: `${message} Reconnect the account to pick this conversation back up.`,
+                      noticeCode: noticeCode({ code: "reconnect", params: said }),
+                  };
         case "rate_limit":
             return { role: "notice", text: message };
         default:
             break;
     }
     if (!turnedAwayCode(code)) {
-        const clause = retryClause(event);
-        return { role: "notice", text: clause === undefined ? message : `${message} ${clause}` };
+        const retry = retryClause(event);
+        if (retry !== undefined) {
+            return { role: "notice", text: `${message} ${retry.text}`, noticeCode: retry.code };
+        }
+        // A failure the sandbox names by code is coded too, so a reader that words that failure itself can; the
+        // provider's own uncoded words are only ever themselves.
+        return code === undefined ? { role: "notice", text: message } : { role: "notice", text: message, noticeCode: noticeCode({ code: "failed", params: said }) };
     }
     return heldRow(event);
 };
 
 // What a laddered wall's automatic re-runs are doing, said on the failure's own row so the count stays in the record.
-const retryClause = (event: Extract<AgentEvent, { kind: "error" }>): string | undefined => {
+const retryClause = (event: Extract<AgentEvent, { kind: "error" }>): { text: string; code: NonNullable<TranscriptRow["noticeCode"]> } | undefined => {
     const { retries } = event;
     if (retries === undefined) {
         return undefined;
     }
+    const said = failureOf(event);
     if (event.autoResume === "scheduled") {
-        return `Retrying by itself: attempt ${retries.made + 1} of ${retries.max}.`;
+        return {
+            text: `Retrying by itself: attempt ${retries.made + 1} of ${retries.max}.`,
+            code: noticeCode({ code: "retrying", params: { ...said, attempt: retries.made + 1, of: retries.max } }),
+        };
     }
-    return retries.made >= retries.max ? `Retried ${retries.made} of ${retries.max} times by itself; nothing more is sent automatically.` : undefined;
+    return retries.made >= retries.max
+        ? {
+              text: `Retried ${retries.made} of ${retries.max} times by itself; nothing more is sent automatically.`,
+              code: noticeCode({ code: "retried", params: { ...said, made: retries.made, of: retries.max } }),
+          }
+        : undefined;
 };
 
 // The turn's opening user row: text, timestamp, attachments, the message's id, and whatever the daemon later stamps onto
@@ -236,10 +338,7 @@ export class TranscriptFold {
     // Set by `retract`: this turn was refused before it ran, and its message went back to the conversation's queue.
     private unrun = false;
 
-    constructor(
-        opening: readonly TranscriptRow[],
-        private readonly tag?: string,
-    ) {
+    constructor(opening: readonly TranscriptRow[]) {
         for (const row of opening) {
             this.rows.push(row);
         }
@@ -250,7 +349,7 @@ export class TranscriptFold {
     /** Folds one frame in; returns the patches it produced, in order. */
     apply(event: AgentEvent): TranscriptPatch[] {
         const parent = "parentToolUseId" in event ? event.parentToolUseId : undefined;
-        if (parent !== this.tag) {
+        if (parent !== undefined) {
             return this.applyChild(event, parent);
         }
         switch (event.kind) {
@@ -345,22 +444,25 @@ export class TranscriptFold {
             case "prompt_cache": {
                 // Only a conversation the sandbox kept warm gets a row: every other turn's cache is its own business.
                 const line = keptWarmLine(event);
-                return line === undefined ? [] : this.pushRow({ role: "notice", text: line });
+                const notice = keptWarmNotice(event);
+                return line === undefined || notice === undefined ? [] : this.pushRow({ role: "notice", text: line, noticeCode: noticeCode(notice) });
             }
             case "context_trim":
                 // A row of its own rather than a stamp on the message: what was left out is not part of what was sent,
                 // and the fold beside the message only ever lists notes that actually rode.
-                return this.pushRow({ role: "notice", text: contextTrimLine(event) });
+                return this.pushRow({ role: "notice", text: contextTrimLine(event), noticeCode: noticeCode(contextTrimNotice(event)) });
             case "worktree":
                 return event.sync === undefined ? [] : this.synced(event.sync);
             case "landed":
                 return this.pushRow(landedRow(event));
             case "compact":
-                return this.pushRow({ role: "notice", text: COMPACTED_NOTICE });
+                return this.pushRow(compactedRow());
+            case "install":
+                return this.pushRow(installRow(event));
             case "error":
                 // Keeps a refusal (no prose from the provider) from reading as a session that ended mid-question.
                 // A refusal that ran nothing takes its message back out ahead of the notice standing in for it.
-                return [...this.retract(event), ...this.pushRow(errorRow(event))];
+                return [...this.retract(event), ...this.withdrawRenewal(event), ...this.pushRow(errorRow(event))];
             case "plan": {
                 // Folds a plan into an identical retired prose bubble instead of drawing the same markdown twice.
                 const adjacent = this.rows.at(-1);
@@ -408,6 +510,9 @@ export class TranscriptFold {
                 return this.park(event.requestId, { paymentOffer: { requestId: event.requestId, offer: event.offer, status: "pending" } });
             case "credential_offer":
                 return this.park(event.requestId, { credentialOffer: { requestId: event.requestId, offer: event.offer, status: "pending" } });
+            case "need":
+                // A row of its own, not a park: the turn goes on, and the card reads the need's live state by its id.
+                return this.pushRow({ role: "notice", text: needRowText(event.need), need: event.need });
             case "resolved":
                 // Releases the card; the answering window already froze it locally, so this is a no-op there.
                 return this.patchParked(event.requestId, (row) => Object.assign(row, settledRequests(row, event.reply)));
@@ -530,6 +635,29 @@ export class TranscriptFold {
         return [{ op: "drop", index: opener }];
     }
 
+    // A run holds one hold, and each failure replaces it: a later failure in the run that armed a credential renewal is
+    // what the sandbox acts on now, so the renewal row's "continues automatically" is no longer true. It says the turn
+    // stopped instead, and no longer names a wait nobody is running. A renewal armed again keeps its promise.
+    private withdrawRenewal(event: Extract<AgentEvent, { kind: "error" }>): TranscriptPatch[] {
+        if (event.code === "claude-token-refused" && event.autoResume === "scheduled") {
+            return [];
+        }
+        const index = this.rows.findLastIndex((row) => row.role === "notice" && row.noticeWait === "credentialRenewal");
+        const row = this.rows[index];
+        if (row === undefined) {
+            return [];
+        }
+        const { noticeWait: _withdrawn, ...rest } = row;
+        const withdrawn: TranscriptRow = { ...rest, text: row.text.replace(RENEWING, RENEWAL_WITHDRAWN) };
+        // The code says the same as the words: the row still quotes its failure, and now reports the stop.
+        const renewing = sandboxNoticeOf(row);
+        if (renewing?.code === "renewing") {
+            withdrawn.noticeCode = noticeCode({ code: "renewalWithdrawn", params: renewing.params });
+        }
+        this.rows[index] = withdrawn;
+        return [this.replace(index)];
+    }
+
     /**
      * Ends the turn: closes the open bubble, freezes every still-pending card as nobody's decision, and notes a user
      * stop.
@@ -543,17 +671,17 @@ export class TranscriptFold {
             }
         }
         if (ending === "stopped") {
-            patches.push(...this.pushRow({ role: "notice", text: `Stopped.` }));
+            patches.push(...this.pushRow({ role: "notice", text: `Stopped.`, noticeCode: noticeCode({ code: "stopped" }) }));
         }
         return patches;
     }
 
-    // Routes a frame from a child stream onto the card that spawned it; its prose surfaces only when that child's own
-    // stream is read directly. A spawning call absent from this stream means there is nothing to nest under, so the
-    // frame is dropped.
-    private applyChild(event: AgentEvent, parent: string | undefined): TranscriptPatch[] {
-        const place = parent === undefined ? undefined : this.cards.get(parent);
-        if (place === undefined || parent === undefined) {
+    // Routes a frame from a child stream onto the card that spawned it: its calls and its thinking, never its prose,
+    // which is the child's own and reaches the parent as the call's result. A spawning call absent from this stream means
+    // there is nothing to nest under, so the frame is dropped.
+    private applyChild(event: AgentEvent, parent: string): TranscriptPatch[] {
+        const place = this.cards.get(parent);
+        if (place === undefined) {
             return [];
         }
         // Only the new words travel: the card whole, children and all, would go out again for every token.
@@ -710,8 +838,10 @@ export class TranscriptFold {
     // saying so again one row under its own errand only repeats it. What did move is still told.
     private synced(sync: { commits: number; blocked: readonly string[] }): TranscriptPatch[] {
         const opener = this.opener === undefined ? undefined : this.rows[this.opener];
-        const text = syncLine(opener !== undefined && isLandConflict(opener.text) ? { ...sync, blocked: [] } : sync);
-        return text === "" ? [] : this.pushRow({ role: "notice", text });
+        const told = opener !== undefined && isLandConflict(opener.text) ? { ...sync, blocked: [] } : sync;
+        const text = syncLine(told);
+        const blocked = told.blocked.length > 0 ? told.blocked.join(`, `) : undefined;
+        return text === "" ? [] : this.pushRow({ role: "notice", text, noticeCode: noticeCode({ code: "synced", params: { commits: told.commits, blocked } }) });
     }
 
     private stampOpener(mutate: (row: TranscriptRow) => void): TranscriptPatch[] {
@@ -728,13 +858,8 @@ export class TranscriptFold {
 }
 
 /** Folds a whole turn at once: opening rows, every frame, and how it ended; what a settled turn reads back as. */
-export const foldTurn = (
-    opening: readonly TranscriptRow[],
-    events: readonly AgentEvent[],
-    ending: TurnEnding = "settled",
-    tag?: string,
-): TranscriptRow[] => {
-    const fold = new TranscriptFold(opening, tag);
+export const foldTurn = (opening: readonly TranscriptRow[], events: readonly AgentEvent[], ending: TurnEnding = "settled"): TranscriptRow[] => {
+    const fold = new TranscriptFold(opening);
     for (const event of events) {
         fold.apply(event);
     }

package/src/webext/index.ts

@@ -7,3 +7,4 @@ export { webextContract } from "../contracts/webext.contract.js";
 export * from "../protocol/webext-links.js";
 export * from "../protocol/webext-protocol.js";
 export * from "../schemas/webext.js";
+export * from "../schemas/loopback-catch.js";

package/dist/schemas/workspace/push-checks.d.ts

@@ -1,222 +0,0 @@
-import { z } from "zod";
-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 RedDecisionKindSchema: z.ZodEnum<{
-    dismissed: "dismissed";
-    "fix-up": "fix-up";
-    reported: "reported";
-    resolved: "resolved";
-    spent: "spent";
-}>;
-export type RedDecisionKind = z.infer<typeof RedDecisionKindSchema>;
-export declare const RedDecisionSchema: z.ZodObject<{
-    kind: z.ZodEnum<{
-        dismissed: "dismissed";
-        "fix-up": "fix-up";
-        reported: "reported";
-        resolved: "resolved";
-        spent: "spent";
-    }>;
-    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 RedDecision = z.infer<typeof RedDecisionSchema>;
-export declare const RedSourceSchema: z.ZodEnum<{
-    ci: "ci";
-    push: "push";
-}>;
-export type RedSource = z.infer<typeof RedSourceSchema>;
-export declare const RedSchema: z.ZodObject<{
-    source: z.ZodEnum<{
-        ci: "ci";
-        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>>>;
-    decisions: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        kind: z.ZodEnum<{
-            dismissed: "dismissed";
-            "fix-up": "fix-up";
-            reported: "reported";
-            resolved: "resolved";
-            spent: "spent";
-        }>;
-        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 PushCheckSchema: 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 PushCheck = z.infer<typeof PushCheckSchema>;
-export declare const PushChecksSchema: z.ZodObject<{
-    pushed: 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.ZodArray<z.ZodObject<{
-        source: z.ZodEnum<{
-            ci: "ci";
-            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>>>;
-        decisions: z.ZodDefault<z.ZodArray<z.ZodObject<{
-            kind: z.ZodEnum<{
-                dismissed: "dismissed";
-                "fix-up": "fix-up";
-                reported: "reported";
-                resolved: "resolved";
-                spent: "spent";
-            }>;
-            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 PushChecks = z.infer<typeof PushChecksSchema>;
-export declare const PushDismissSchema: z.ZodObject<{
-    project: z.ZodString;
-    ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    restore: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-export type PushDismiss = z.infer<typeof PushDismissSchema>;
-export declare const PushDismissResultSchema: z.ZodObject<{
-    changed: z.ZodNumber;
-}, z.core.$strip>;
-export declare const PushRecheckSchema: z.ZodObject<{
-    project: z.ZodString;
-}, z.core.$strip>;
-export declare const PushRecheckResultSchema: z.ZodObject<{
-    measured: z.ZodBoolean;
-    resolved: z.ZodNumber;
-    open: z.ZodNumber;
-}, z.core.$strip>;
-export type PushRecheckResult = z.infer<typeof PushRecheckResultSchema>;
-export declare const PushFixSchema: 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 PushFix = z.infer<typeof PushFixSchema>;
-export declare const PushFixResultSchema: 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=push-checks.d.ts.map

package/dist/schemas/workspace/push-checks.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"push-checks.d.ts","sourceRoot":"","sources":["../../../src/schemas/workspace/push-checks.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAcxB,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;iBAmBxB,CAAC;AACH,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAGpD,eAAO,MAAM,qBAAqB;;;;;;EAWhC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;iBAS5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAK5D,eAAO,MAAM,eAAe;;;EAAyB,CAAC;AACtD,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAMpB,CAAC;AACH,MAAM,MAAM,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC;AAI5C,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkB1B,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAG3B,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D,eAAO,MAAM,iBAAiB;;;;iBAI5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,eAAO,MAAM,uBAAuB;;iBAElC,CAAC;AAEH,eAAO,MAAM,iBAAiB;;iBAE5B,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;iBAIlC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;iBASxB,CAAC;AACH,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAEpD,eAAO,MAAM,mBAAmB;;iBAE9B,CAAC;AAGH,eAAO,MAAM,SAAS,SAAU,SAAS,GAAG,EAAE,GAAG,SAAS,WAAW,MAAM,KAAG,GAAG,GAAG,SACb,CAAC;AAKxE,eAAO,MAAM,WAAW,QAAS,IAAI,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAAC,GAAG,SAAS,KAAG,MAAM,GAAG,SACoC,CAAC"}