@intentic/sandbox-contract 1.238.1 → 1.240.0

package/src/schemas/plan-limits.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { EditorContextSchema } from "./agent.js";
+import { AgentHarnessSchema, AgentProviderSchema, EditorContextSchema } from "./agent.js";
 // Declared ABOVE both account shapes because both carry it: headroom is one idea in this product, not a Claude
 // idea that other providers imitate. A native account (OauthAccount) and a routed subscription
 // (TranslatorAccount) differ in who holds the credential and how the reading is taken, never in what a
@@ -237,19 +237,38 @@ export const SteerSchema = z
 // True cancel for the conversation's in-flight turn, aborts the agent daemon-side, unlike closing the
 // /agent fetch (which sends no cancel frame).
 export const StopTurnSchema = z.object({ conversationId: z.string().min(1).describe("Which conversation's running turn to cancel.") });
-/* RUN THE HELD TURN AGAIN, and it carries a conversation id and NOTHING else, which is the entire point of it
- * existing as its own route rather than as a flag on a turn.
+/* WHO SERVES THE RE-RUN, the one part of a held turn a press is allowed to move, and the field that exists
+ * because leaving it out made the press useless in exactly the case it was built for.
  *
- * A spent allowance leaves a turn stranded that the daemon still holds in full: the prompt, the attachments, the
- * model, the effort, the mode, the worktree, the session that holds whatever it managed to do. Every one of
- * those is on the turn the daemon already has, and a client that re-derived them from its own transcript would
- * be re-deriving them from the STRIPPED copy it renders (no preamble notes, no attachment note, no model), which
- * is how a re-send comes to run a different turn from the one it claims to repeat.
+ * A spent allowance is a refusal by an ACCOUNT, and the fix a person reaches for is the account switcher in the
+ * composer: switch to one with headroom, press Continue. Replaying the turn with everything it carried replayed
+ * the refused account too, so the press bounced off the same limit, reported it in the same words, and the user's
+ * only way through was to type "Continue" by hand — a send, which reads the composer's current selection, which
+ * is the very thing the press was ignoring.
  *
- * So the caller says only WHICH conversation, and the daemon re-runs the turn it kept. What comes back is an
- * ordinary StartedTurn, and the caller then attaches to it exactly as it would to a turn somebody else started
- * (the resume note on the prompt is what tells an attaching window to reuse the bubble that is already there
- * instead of drawing the same message twice). */
+ * So the press carries WHO, and the daemon keeps WHAT. Everything that makes the turn the turn (the prompt, the
+ * attachments, the effort, the mode, the worktree, the session holding whatever it managed to do) stays on the
+ * daemon's own copy, because a client re-deriving those from its transcript would be re-deriving them from the
+ * STRIPPED copy it renders, which is how a re-send comes to run a different turn from the one it claims to
+ * repeat. Routing is the exception, and it is the exception on purpose: it is not a property of the request, it
+ * is the answer to "who pays for it", and the whole reason the user is pressing is that they have changed it. */
+export const ResumeRoutingSchema = z.object({
+    agent: AgentProviderSchema.describe("Which provider serves the re-run."),
+    harness: AgentHarnessSchema.describe("Which agentic loop runs it."),
+    account: z.string().optional().describe("Which of that provider's accounts pays for it. Leave it out for the first one."),
+    // Omitted rather than guessed: a client whose catalog hasn't loaded has no pick to send, and the turn's own
+    // model is a better answer than a blank one.
+    model: z.string().optional().describe("Which model. Leave it out to keep the one the refused turn named."),
+});
+export type ResumeRouting = z.infer<typeof ResumeRoutingSchema>;
+/* RUN THE HELD TURN AGAIN: which conversation, and who serves it now.
+ *
+ * What comes back is an ordinary StartedTurn, and the caller then attaches to it exactly as it would to a turn
+ * somebody else started (the resume note on the prompt is what tells an attaching window to reuse the bubble that
+ * is already there instead of drawing the same message twice). */
 export const ResumeTurnSchema = z.object({
     conversationId: z.string().min(1).describe("Which conversation's held turn to run again."),
+    routing: ResumeRoutingSchema.optional().describe(
+        "Who serves the re-run, when the conversation has been re-pointed since it was refused. Leave it out to run it on whatever the turn carried.",
+    ),
 });

package/src/workspace-state.test.ts

@@ -334,6 +334,11 @@ describe(`VERSIONED_STATE_PATHS`, () => {
              * node:fs, and both used to reach that far with no diff anywhere. Kept rather than consumed, one
              * small file at a time, so tracking them yields a record instead of churn. */
             `.intentic/config/drafts/`,
+            /* Where each agent engine takes its version from. Tracked for the same reason heavy-commands is:
+             * it is a standing decision about what runs for everyone on this workspace — tracking upstream's
+             * newest Claude Code, or pinning one while a regression is open — and `git log` is the only thing
+             * that answers "since when". */
+            `.intentic/config/engines.json`,
             `.intentic/config/environment.Dockerfile`,
             `.intentic/config/environment.custom.Dockerfile`,
             `.intentic/config/environment.d/`,

package/src/workspace-state.ts

@@ -249,6 +249,18 @@ const STATE_FILES = [
      * missing tools, and arriving with the recurrence memory is the whole reason it is kept. The drift snapshot
      * inside is machine-scoped, and self-expires on the move: its bornAt can never match the new container. */
     { path: ".intentic/records/runtime-installs.json", invalidates: ["environment"], portability: "carry" },
+    /* Where each agent ENGINE's version comes from: the blessed list, upstream's newest, a pin, or the image
+     * (schemas/engines.ts). The versions themselves are machine state and live on the daemon's volume, because
+     * they are architecture-specific binaries; the POLICY is a decision about this workspace's work and travels
+     * with it — a team that pins Claude Code while a regression is open wants that pin to survive the move to a
+     * fresh sandbox rather than to be rediscovered by hitting the regression again.
+     *
+     * `versioned` for the config slice's usual reason (personas.json's entry argues it): it changes at human
+     * speed, holds no secret, and "since when have we been tracking upstream's newest on this repo" is a
+     * question only `git log` answers. Its own key rather than `environment`'s: the engines card is drawn on
+     * that page but reads its own route, and a channel change must not cost every open Environment tab a
+     * re-read of the overlay it did not touch. */
+    { path: ".intentic/config/engines.json", invalidates: ["engines"], portability: "carry", versioned: true },
     /* Written by the AGENT's file tools (the drafts skill), read by the owner's approval inbox, the one entry
      * here whose whole point is that a change arrives from outside the browser that renders it. `authored`:
      * a draft is text somebody wrote, and "find the reddit draft about X" is an ordinary search.