@intentic/sandbox-contract 1.315.0 → 1.317.0

package/src/schemas/speaker.ts

@@ -68,12 +68,12 @@ export const speakerOwner = (speaker: TurnSpeaker): Pick<SessionOwner, "email" |
 /** A person, verified, at the keyboard: never a program holding a token a person minted. */
 export const spokenByPerson = (speaker: TurnSpeaker | undefined): boolean => speaker?.kind === "person";
 
-// WHAT A COMPOSED PROMPT IS FOR, when the sandbox or the app wrote it rather than whoever is named as speaking: a land's
-// breakage sent back to it, a fresh fix-up on a red main line and its later nudges, a note to a conversation still
-// working on what failed, the brief a person's press hands an agent (what a push left, main's red CI), a land conflict to
+// WHAT A COMPOSED PROMPT IS FOR, when the sandbox or the app wrote it rather than whoever is named as speaking: the brief
+// a fix agent is handed (what a push left, main's red CI, each later failure on main) and its nudges, a land conflict to
 // resolve. Carried on the turn and the row it opens, so a reader shows it as the sandbox's words, not the owner's, and
 // never has to recognise the prompt by its opening; the four openings older rows are recognised by stay what they are
-// (events/errands.ts, errandOfPrompt).
+// (events/errands.ts, errandOfPrompt). `verify-nudge` and the `land-*` errands are retired with the checks that sent them
+// and stay only because records hold them.
 export const TurnErrandSchema = z.enum([
     "land-conflict",
     "verify-nudge",

package/src/schemas/state-plan.ts

@@ -40,8 +40,15 @@ export type StatePlan = z.infer<typeof StatePlanSchema>;
 
 // The `state` of `/health`: whether an update's state changes are still uncommitted. The host rolls an update back when
 // the journal stays open, so this rides the same probe as the boot's progress.
+// `failed`: a conversion or structural step threw partway through this boot; the daemon put back every file the episode
+// had touched and keeps running on read-time conversions, and a host rolls the update back as it would an open journal
+// that never commits (this version could not bring the files to its shape, the one before it can read them as they are).
 export const StateStatusSchema = z.object({
-    journal: z.enum(["open", "none"]).describe("Open from the start of a boot that changed stored files until that boot has converged."),
+    journal: z
+        .enum(["open", "none", "failed"])
+        .describe(
+            "Open from the start of a boot that changed stored files until that boot has converged. Failed when a conversion threw partway: the files were put back as they were, and a host takes that as the update not having taken.",
+        ),
     engine: z.number().describe("The running build's conversion count."),
 });
 export type StateStatus = z.infer<typeof StateStatusSchema>;

package/src/schemas/system.ts

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { StatePlanSchema } from "./state-plan.js";
+import { UpdateOutcomeSchema, WithdrawnReleaseSchema } from "./updates.js";
 // version is this build's baked-in version; latest/updateAvailable come from comparing it to the published stable
 // release.
 // Whether a runtime can serve a turn, probed off the turn path. "unknown" reads as available-but-unverified, never as
@@ -82,6 +83,20 @@ export const InfoSchema = z.object({
     staged: StagedUpdateSchema.optional().describe(
         "An update already downloaded and built on the machine running this container, waiting only for the restart that applies it. That restart is seconds, where an unprepared update is minutes, which is a different decision entirely. Absent when nothing is waiting.",
     ),
+    // What the host last did about this sandbox's version (update-outcome.json on /history, written by ic); absent
+    // when no host has said, which is every hosted sandbox and every host older than the file.
+    lastUpdate: UpdateOutcomeSchema.optional().describe(
+        "What the machine running this sandbox last did about its version: an update that took, one it gave up on and why, and until when the previous version stays ready. Absent when that machine has never said.",
+    ),
+    // The running version was taken back after it shipped; absent for every version still standing.
+    withdrawn: WithdrawnReleaseSchema.optional().describe(
+        "Set when the version this sandbox runs was withdrawn after it shipped, which is the moment to go back to the one before it. Absent for every version still standing.",
+    ),
+    // The owner's "not this one" (POST /system/update/skip); updateAvailable reads false while `latest` is it.
+    skippedVersion: z
+        .string()
+        .optional()
+        .describe("A release the owner chose to skip. While it is the newest, no update is offered; a newer one is. Absent when nothing is skipped."),
 });
 export type Info = z.infer<typeof InfoSchema>;
 // What the daemon could not read in its own `.intentic/` state files, and in the files on its volume that

package/src/schemas/updates.ts

@@ -0,0 +1,56 @@
+import { z } from "zod";
+
+// WHAT THE HOST LAST DID ABOUT THIS SANDBOX'S VERSION, in the host's own words. Written by `ic` (the swap, its health
+// check and the probation that follows it: _sandbox/ic/src/sandbox/outcome.rs) onto /history as `update-outcome.json`,
+// the same volume whichever container runs, so the version that ends up running reads what happened to the other one.
+// Advisory: the swap and its undoing are the host's; this is only how the sandbox and its owner hear about them.
+export const UpdateOutcomeResultSchema = z.enum(["updated", "kept", "restored", "rolled-back"]);
+export type UpdateOutcomeResult = z.infer<typeof UpdateOutcomeResultSchema>;
+
+export const UpdateOutcomeSchema = z.object({
+    result: UpdateOutcomeResultSchema.describe(
+        "What happened. Updated: the new version passed its first health check and runs, with the previous one kept ready until keepUntil. Kept: that probation ended and the new version stays. Restored: the new version never came up, so the previous container was put back at once. Rolled back: the new version came up and then failed its probation (it kept crashing, never became ready, or lost its tunnel), so the host went back to the previous one by itself.",
+    ),
+    // What the person or program asked for. A string rather than an enum: a newer ic's verb must not make an older
+    // daemon drop the whole outcome.
+    verb: z.string().optional().describe("What was asked for: update, rollback, rebuild, dev, reshape, or the probation watch acting on its own."),
+    at: z.number().describe("When it happened, in milliseconds."),
+    from: z.string().optional().describe("The version (or, when it would not say, the image) that ran before."),
+    to: z.string().optional().describe("The version (or image) that was moved onto, or that was tried and given up on."),
+    // Plain words for the owner: why a version was given up on. Absent for an update that simply worked.
+    reason: z.string().optional().describe("Why the host gave up on the new version, in plain words. Absent when nothing went wrong."),
+    // A path on the machine that runs the sandbox, which only means something to a person on that machine.
+    log: z.string().optional().describe("Where the host kept the full log of the swap, as a path on the machine that runs the sandbox."),
+    keepUntil: z
+        .number()
+        .optional()
+        .describe(
+            "Until when the previous version stays parked and ready, in milliseconds. While it does, going back takes seconds and nothing is downloaded or rebuilt; after it, going back uses the pinned image.",
+        ),
+});
+export type UpdateOutcome = z.infer<typeof UpdateOutcomeSchema>;
+
+// A published release that was taken back after it shipped (the release pipeline's rollback-stable.sh marks it on its
+// GitHub release). A sandbox running one is told, and offered the way back.
+export const WithdrawnReleaseSchema = z.object({
+    version: z.string().describe("The withdrawn version, which is the one this sandbox is running."),
+    reason: z.string().optional().describe("Why it was withdrawn, as the people who withdrew it put it."),
+});
+export type WithdrawnRelease = z.infer<typeof WithdrawnReleaseSchema>;
+
+// The owner's "not this one": no update is offered while the newest release is the skipped one. `null` clears it.
+export const SkipUpdateInputSchema = z.object({
+    version: z
+        .string()
+        .min(1)
+        .nullable()
+        .describe("The release to stop offering, or null to offer the newest release again. A newer release than the skipped one is always offered."),
+});
+export type SkipUpdateInput = z.infer<typeof SkipUpdateInputSchema>;
+
+// One image a sandbox can go back to, as `ic sandbox versions` knows it: the pinned local image and what it says it is.
+export const RollbackTargetSchema = z.object({
+    image: z.string().describe("The local image a rollback would run, pinned under a tag no other flow writes."),
+    version: z.string().optional().describe("What that image says it is. Absent when it would not say."),
+});
+export type RollbackTarget = z.infer<typeof RollbackTargetSchema>;

package/src/schemas/workspace/{mainline.test.ts → push-checks.test.ts}

@@ -1,5 +1,5 @@
 import { pushFixConversationId } from "../../ids/conversation-ids.js";
-import { pushFixBase, pushRedOf, type Red, RedSchema } from "./mainline.js";
+import { pushFixBase, pushRedOf, type Red, RedSchema } from "./push-checks.js";
 
 // What a push left is a Red like any other (source `push`, scope the project), and the hand-over's id is named by when
 // that red began, so the editor and the daemon find the same attempt whichever of them asks.
@@ -7,12 +7,12 @@ import { pushFixBase, pushRedOf, type Red, RedSchema } from "./mainline.js";
 const red = (over: Partial<Red>): Red => RedSchema.parse({ source: `push`, scope: `app`, since: 100, ...over });
 
 describe(`a project's push red`, () => {
-    test(`is the push red of that project, never a land check's red of the same folder or another project's`, () => {
-        const land = red({ source: `land` });
+    test(`is the push red of that project, never a CI red of the same name or another project's`, () => {
+        const ci = red({ source: `ci` });
         const other = red({ scope: `web` });
         const mine = red({});
-        expect(pushRedOf([land, other, mine], `app`)).toBe(mine);
-        expect(pushRedOf([land, other], `app`)).toBeUndefined();
+        expect(pushRedOf([ci, other, mine], `app`)).toBe(mine);
+        expect(pushRedOf([ci, other], `app`)).toBeUndefined();
         expect(pushRedOf(undefined, `app`)).toBeUndefined();
     });
 

package/src/schemas/workspace/push-checks.ts

@@ -0,0 +1,155 @@
+// what the pre-push hook let through, and the one record every red keeps, whatever went red
+import { z } from "zod";
+import { pushFixConversationId } from "../../ids/conversation-ids.js";
+import { AgentRunPickSchema } from "../agent.js";
+
+// Nothing checks work inside a conversation or after it lands: CI checks what the owner pushes (ci/main-fixer.ts puts
+// one fix agent on main's red), and the pre-push hook measures the push on the way out without ever refusing it
+// (verify-push.mjs, `--advisory`). What the hook found used to vanish with the terminal it printed to. It now leaves a
+// report in the repository's git dir, the daemon files it once the push has actually reached the remote, and what it
+// found is owed, as the project's push Red, until a later measurement no longer prints it or somebody dismisses it.
+// Nobody is sent after it: acting on it is the owner's call.
+
+// ONE FINDING, whatever measured it: a check run's line as the repository's own tooling printed it, named by what
+// printed it (`source`, the repository's word: a check's id, `lint`, a hook), with the command that shows it again and
+// whether a later measurement can say it is gone. A push's findings are these; a CI run's failed jobs become them too.
+export const FindingSchema = z.object({
+    id: z.string().describe("Stable across measurements: the same problem found again is the same id."),
+    source: z.string().describe("What measured it, in the repository's own words: a check's id, `lint`, a hook."),
+    text: z.string().describe("The finding as it was printed."),
+    path: z.string().optional().describe("The repository path it is about, when it names one."),
+    command: z.string().optional().describe("The command that shows it again."),
+    recheckable: z
+        .boolean()
+        .describe("Whether a later measurement can find it gone. False for one about commits already made, which ends only when dismissed."),
+    gate: z
+        .enum(["code", "tidy"])
+        .optional()
+        .describe(
+            "For a check's finding: `code` means the tree fails the check whoever caused it; `tidy` means the change measured added this line.",
+        ),
+    commit: z
+        .object({ sha: z.string(), subject: z.string() })
+        .optional()
+        .describe("The newest commit of the change measured that touched the path it names, when it names one."),
+});
+export type Finding = z.infer<typeof FindingSchema>;
+
+// What was decided about a red, in the order it was decided.
+export const RedDecisionKindSchema = z.enum([
+    // A fix agent was put on it: pressed for by a person, or started by the sandbox on main's red CI.
+    "fix-up",
+    // Nobody was sent: repairs are switched off, or nothing could take it.
+    "reported",
+    // A later measurement no longer found it (`findings` names which).
+    "resolved",
+    // The fix agent had its turns, or stopped without a fix: it waits for a person.
+    "spent",
+    // A person set findings aside as not to be fixed (`findings` names which).
+    "dismissed",
+]);
+export type RedDecisionKind = z.infer<typeof RedDecisionKindSchema>;
+
+export const RedDecisionSchema = z.object({
+    kind: RedDecisionKindSchema.describe("What was decided."),
+    conversationId: z.string().optional().describe("The conversation working on it, when one is."),
+    at: z.number().describe("When that was decided, in milliseconds."),
+    detail: z.string().optional().describe("One sentence on why, in the sandbox's words."),
+    findings: z
+        .array(z.string())
+        .optional()
+        .describe("The findings it was about, by id, when it was about some of a red's findings rather than the whole red."),
+});
+export type RedDecision = z.infer<typeof RedDecisionSchema>;
+
+// ONE RED, whatever went red: what a push left in a project, main's CI on a branch. What it owes (its findings) and every
+// decision about it, oldest first. A push's red waits for the owner's press (conversations/fix/push-fix.ts); main's CI
+// red gets one fix agent by itself (ci/main-fixer.ts). The record is the same.
+export const RedSourceSchema = z.enum(["push", "ci"]);
+export type RedSource = z.infer<typeof RedSourceSchema>;
+
+export const RedSchema = z.object({
+    source: RedSourceSchema.describe("What went red."),
+    scope: z.string().describe("Where: a project's folder, or a repository and branch."),
+    since: z.number().describe("When the red streak began (state/red-streak.ts)."),
+    findings: z.array(FindingSchema).default([]).describe("What it owes, as the red's own measurement named it."),
+    decisions: z.array(RedDecisionSchema).default([]).describe("What was decided about it, oldest first."),
+});
+export type Red = z.infer<typeof RedSchema>;
+
+// ONE PUSH THE HOOK MEASURED, as the record lists it: where it went and what it found that it brought in. What of that is
+// still owed is the project's push Red's to say (`findings`), never the push's.
+export const PushCheckSchema = z.object({
+    project: z.string().describe("Which project, by folder relative to the workspace. Empty is the workspace root."),
+    id: z.string().describe("The report's own id."),
+    at: z.number().describe("When the push check ran, in milliseconds."),
+    remote: z.string().optional().describe("The remote it was pushed to."),
+    branch: z.string().optional().describe("The branch it was pushed to."),
+    base: z.string().optional().describe("The commit the pushed range starts from; absent when the remote had nothing to compare with."),
+    head: z.string().describe("The commit that was pushed."),
+    commits: z.number().describe("How many commits the push carried."),
+    findings: z
+        .array(FindingSchema)
+        .describe("What it found that this push brought in, less what an earlier push had already left open. Empty for a clean push."),
+    refused: z
+        .boolean()
+        .optional()
+        .describe(
+            "True when the repository's own pre-push hook refused it, so nothing reached the remote and its one finding is what the hook said.",
+        ),
+});
+export type PushCheck = z.infer<typeof PushCheckSchema>;
+
+export const PushChecksSchema = z.object({
+    pushed: z.array(PushCheckSchema).describe("The latest pushes the hook measured across every project, newest first, with what each brought in."),
+    reds: z.array(RedSchema).describe("What pushes left in each project and is still owed, one push Red per project, with every decision about it."),
+});
+export type PushChecks = z.infer<typeof PushChecksSchema>;
+
+export const PushDismissSchema = z.object({
+    project: z.string().describe("Which project, by folder relative to the workspace."),
+    ids: z.array(z.string()).optional().describe("Which findings. Leave it out for every open one in the project."),
+    restore: z.boolean().optional().describe("Undo: open the named dismissed findings again."),
+});
+export type PushDismiss = z.infer<typeof PushDismissSchema>;
+
+export const PushDismissResultSchema = z.object({
+    changed: z.number().describe("How many findings changed state."),
+});
+
+export const PushRecheckSchema = z.object({
+    project: z.string().describe("Which project, by folder relative to the workspace."),
+});
+
+export const PushRecheckResultSchema = z.object({
+    measured: z.boolean().describe("Whether the project could be measured at all; false leaves every finding as it was."),
+    resolved: z.number().describe("How many findings the measurement no longer saw."),
+    open: z.number().describe("How many are still open."),
+});
+export type PushRecheckResult = z.infer<typeof PushRecheckResultSchema>;
+
+export const PushFixSchema = z.object({
+    project: z.string().describe("Which project's open push findings to hand over, by folder relative to the workspace."),
+    pick: AgentRunPickSchema.describe("Which model to open the conversation on, when somebody chose one. Leave it out for the sandbox's own choice."),
+    mode: z
+        .enum(["continue", "start-over"])
+        .optional()
+        .describe(
+            "What to do about an attempt already made at these findings: `continue` carries on in it, `start-over` files it away and opens the next attempt. Leave it out for the plain press.",
+        ),
+});
+export type PushFix = z.infer<typeof PushFixSchema>;
+
+export const PushFixResultSchema = z.object({
+    conversationId: z.string().describe("The conversation holding the findings. Open it to watch."),
+});
+
+// What pushes left in `project`, as the reds name it; undefined while nothing is owed.
+export const pushRedOf = (reds: readonly Red[] | undefined, project: string): Red | undefined =>
+    reds?.find((red) => red.source === "push" && red.scope === project);
+
+// The conversation id a hand-over of a push red wears (attempt 1), derived from when the red began, so the editor and the
+// daemon agree on whether an agent is already on it: pressing again while anything is owed continues the same attempt,
+// and a red that begins after everything was handled starts a fresh one. Undefined when nothing is owed.
+export const pushFixBase = (red: Pick<Red, "scope" | "since"> | undefined): string | undefined =>
+    red === undefined ? undefined : pushFixConversationId(red.scope === "" ? "workspace" : red.scope, `red:${red.since}`);

package/src/schemas/workspace/workspace-tree.ts

@@ -132,6 +132,21 @@ export const WorkspaceMediaTicketSchema = z.object({
     ticket: z.string().describe("Hand this to the streaming route in the query string. It buys exactly the one file it was minted for."),
     expiresAt: z.number().describe("When it stops working, in milliseconds, so a player can tell a dead ticket from a dead file."),
 });
+// Credential for GET /workspace/download, which the browser navigates to so its own download manager streams the archive
+// to disk. The ticket carries the whole selection, resolved when minted, so however many entries it names the URL stays
+// short.
+export const WorkspaceDownloadTicketQuerySchema = WorkspaceScopeSchema.extend({
+    paths: z
+        .array(z.string().min(1))
+        .min(1)
+        .max(10_000)
+        .describe("The files and folders to download together, as workspace paths. A folder brings everything inside it."),
+});
+export const WorkspaceDownloadTicketSchema = z.object({
+    ticket: z.string().describe("Hand this to the download route in the query string. It buys exactly the selection it was minted for, once resolved."),
+    expiresAt: z.number().describe("When it stops working, in milliseconds. It is meant to be used at once."),
+    filename: z.string().describe("What the archive is saved as, so a caller can say what is on its way."),
+});
 // A read of a window: offset negative reads that many bytes from the end (for following a growing log); limit is
 // clamped to the daemon's own cap. Coerced from query strings.
 export const WorkspaceFileReadQuerySchema = WorkspaceScopeSchema.extend({

package/src/state/fix-stance.test.ts

@@ -50,7 +50,8 @@ test.each([
     ["holding nothing yet", undefined],
 ] as const)("a turn that ended waiting on its own watch, %s, is still working", (_case, diff) => {
     const watches = [{ id: `watch-a1b2`, note: `CI on the pushed branch`, intervalSeconds: 60, deadlineAt: 9_000 }];
-    expect(fixStance(agent({ status: `idle`, watches, ...(diff === undefined ? {} : { diff }) }))).toStrictEqual({
+    // The daemon reads the armed watch as a wake to come (awaitingWake); the stance reads that, never the watch list.
+    expect(fixStance(agent({ status: `idle`, watches, awaitingWake: true, ...(diff === undefined ? {} : { diff }) }))).toStrictEqual({
         kind: `working`,
         ongoing: true,
         retry: false,

package/src/state/history-state.ts

@@ -78,6 +78,11 @@ export const HISTORY_STATE_FILES: readonly StateFile[] = [
     { path: "engines/", portability: "derived" },
     // An update the host downloaded and built for this sandbox (`ic sandbox prepare`); about this machine only.
     { path: "update-staged.json", portability: "derived" },
+    // What the host last did about this sandbox's version (ic writes it), the owner's skipped release, and why the
+    // last boot could not start (the daemon writes it, the host's probation reads it): all rebuilt by whoever next says.
+    { path: "update-outcome.json", portability: "derived" },
+    { path: "update-skipped.json", portability: "derived" },
+    { path: "boot-failure.json", portability: "derived" },
 
     /* ---- credentials ---- */
 

package/src/state/landed-commit.ts

@@ -18,5 +18,5 @@ export const landedCommitMessage = (landed: LandedMessage): string => {
 export const declaredTestNote = (said: string): string | undefined => /^Test-Note:[ \t]*(\S.*)$/m.exec(said)?.[1]?.trim();
 
 // The `Allow: <check> — <reason>` lines a conversation ended its last message with, each an exception it declared for
-// its change on purpose; the check after the land and the push read them off the landed commit.
+// its change on purpose; the push reads them off the landed commit.
 export const declaredAllows = (said: string): string[] => [...said.matchAll(/^Allow:[ \t]*(\S.*)$/gm)].map((match) => match[1]!.trim());

package/src/state/red-streak.ts

@@ -1,7 +1,7 @@
-// ONE DEFINITION OF A RED STREAK, for every source that goes red: a land check's project (verify-store.ts), main's CI
-// (repair-gate.ts), a pipeline branch on the board (the pipelines extension's ciStreaks.ts) and the Main line's older
-// daemons (the editor's mainlineView.ts). A streak is the unbroken run of red at the head: a red extends it, anything
-// else ends it, and `since` is where it began, which is what names one failure across every red that continues it.
+// ONE DEFINITION OF A RED STREAK, for every source that goes red: what a project's pushes left (push-checks-store.ts)
+// and a pipeline branch on the board (the pipelines extension's ciStreaks.ts). A streak is the unbroken run of red at
+// the head: a red extends it, anything else ends it, and `since` is where it began, which is what names one failure
+// across every red that continues it.
 
 export interface Streak {
     // When (or at which run) the streak began: the first red of the unbroken run.

package/src/state/runtime-state.ts

@@ -59,9 +59,8 @@ const RUNTIME_DOMAINS = [
     // The audit log grew or a gateway's status moved or aged out; the log lives outside /work, so no file push carries it.
     { domain: "activity", invalidates: [["activity"], ["activity-status"]] },
 
-    // The main tree's own check after a land: queued, started, settled, or its red handed to somebody. Held in the
-    // daemon's memory as much as in a file, so a push is the only way a watcher hears it move.
-    { domain: "mainline", invalidates: [["mainline"]] },
+    // What the pre-push hook left behind: a push filed, a finding measured gone, dismissed or handed to an agent.
+    { domain: "pushes", invalidates: [["push-checks"]] },
 ] as const satisfies readonly RuntimeDomainBinding[];
 
 export const RUNTIME_DOMAIN_BINDINGS: readonly RuntimeDomainBinding[] = RUNTIME_DOMAINS;

package/src/state/workspace-state.ts

@@ -132,6 +132,10 @@ const STATE_FILES = [
     // needing, not what one machine did. The drift snapshot self-expires on a move since its `bornAt` won't match the
     // new container.
     { path: ".intentic/records/runtime-installs.json", invalidates: ["environment"], portability: "carry" },
+    // What agents are waiting on people for (docs/architecture/needs.md): every open need and the recent closed ones.
+    // Holds no credential (a secret need names the secret, its value goes to the secret store), so it may `carry`: a
+    // question a moved sandbox still has to ask. `needs` is the chat cards', the board's and the inbox's shared read.
+    { path: ".intentic/records/needs.json", invalidates: ["needs"], portability: "carry" },
     // Where each agent engine's version comes from: blessed list, upstream newest, a pin, or the image
     // (schemas/engines.ts). The versions themselves are machine state on the daemon's volume (architecture-specific
     // binaries); the policy here travels. `versioned`: a human decision worth reviewing. Own key, not `environment`'s:
@@ -379,24 +383,12 @@ const STATE_FILES = [
         portability: "derived",
         note: "The target stamps its own daemon version on first boot.",
     },
-    {
-        path: ".intentic/records/verify.json",
-        invalidates: [],
-        why: "The main-line check's memory: each project's last verdict and red streak, and the latest runs with what became of each red one. Read through GET /workspace/mainline, which the daemon pushes itself (the `mainline` runtime domain), so no file watch is needed.",
-        portability: "carry",
-    },
     {
         path: ".intentic/records/push-checks.json",
         invalidates: [],
-        why: "What each push check found and let through, per project, and what became of every finding: still open, measured gone, or dismissed. Filed from the report the pre-push hook leaves in the repository's git dir; read through GET /workspace/mainline, which the daemon pushes itself (the `mainline` runtime domain).",
+        why: "What each push check found and let through, per project, and what became of every finding: still open, measured gone, or dismissed. Filed from the report the pre-push hook leaves in the repository's git dir; read through GET /workspace/push-checks, which the daemon pushes itself (the `pushes` runtime domain).",
         portability: "carry",
     },
-    {
-        path: ".intentic/local/verify/",
-        invalidates: [],
-        why: "A running check's wrapper artifacts (log + exit status), read once by the daemon when the panel finishes.",
-        portability: "derived",
-    },
     // What an update converted before it booted all the way (the sandbox daemon's state-journal.ts): a copy of every
     // file the new version changed, kept until it commits and for a grace window after. `secret` whatever the source
     // was, since a vault's copy is a vault; locked below for the same reason.

package/src/text/transcript-fold.ts

@@ -16,6 +16,7 @@ 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";
 
 // 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
@@ -408,6 +409,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)));