@intentic/sandbox-contract 1.311.0 → 1.313.0

package/src/schemas/agents.ts

@@ -56,7 +56,7 @@ export const AgentAttentionSchema = z.object({
     plan: z.boolean().describe("It has proposed a plan and is waiting for a yes."),
     question: z.boolean().describe("It has asked you something."),
     permission: z.boolean().describe("It wants to use a tool it needs permission for."),
-    // A missing capability (capabilities/capability-offer.ts); lets the lane say "setup needed" rather than a generic
+    // A missing capability (capabilities/offers/capability-offer.ts); lets the lane say "setup needed" rather than a generic
     // pause.
     capability: z.boolean().describe("It needs something connected that is not connected yet."),
     // A gated credential parked on a named person's click; the one pause the board's reader may not be able to clear
@@ -83,10 +83,30 @@ export const UnfinishedWorkSchema = z.object({
         })
         .optional()
         .describe("The agent's own checklist where that turn left it. Absent for a conversation that kept no list."),
-    // Name of the `turn.ending` check still red when the turn ended, after its two repair rounds ran out.
-    check: z.string().optional().describe("The end-of-turn check that was still failing when the turn ended, by name."),
+    // Name of the `turn.ending` check still red when the turn ended. Retired with that check: nothing writes it now, and
+    // it stays so entries written before still read.
+    check: z
+        .string()
+        .optional()
+        .describe("The end-of-turn check that was still failing when the turn ended, by name. No longer written: checks run after work lands."),
 });
 export type UnfinishedWork = z.infer<typeof UnfinishedWorkSchema>;
+// What the last turn showed of its own work, read off its tool calls and never asked of the model: the record a card
+// badges instead of sending the turn back to prove anything. Checks run after the work lands (mainline.ts).
+export const TurnProofSchema = z.object({
+    at: z.number().describe("When the turn that left this ended, in milliseconds."),
+    verification: z
+        .enum(["verified", "unproven", "failing", "no-code"])
+        .describe(
+            "Verified: a check it ran passed after its last edit to code. Failing: the last one it ran failed. Unproven: it changed code and ran nothing that checked it. No-code: it changed nothing a check could speak to.",
+        ),
+    check: z.string().optional().describe("The command that spoke, when one did, so a targeted test is never read as the whole suite."),
+    unviewed: z
+        .number()
+        .optional()
+        .describe("How many rendered files it changed (pages, components, styles) without looking at the result afterwards. Absent when none."),
+});
+export type TurnProof = z.infer<typeof TurnProofSchema>;
 // A landing's commit message: subject plus the two trailer sentences a changelog repo gets. One schema, not three
 // duplicated fields, since both the live roster and the review carrier must read the same shape and can't disagree.
 export const LandedMessageSchema = z.object({
@@ -116,6 +136,12 @@ export const LandedMessageSchema = z.object({
         .string()
         .optional()
         .describe("Why a test this change weakened is meant to be weaker, in the conversation's own words. Nearly always absent."),
+    // Present only when the conversation declared an exception a check should grant this change (`Allow: <check> — <reason>`);
+    // the check after the land and the push read it off the commit.
+    allows: z
+        .array(z.string())
+        .optional()
+        .describe("Exceptions the conversation declared for this change, each `<check> — <reason>` in its own words. Nearly always absent."),
 });
 export type LandedMessage = z.infer<typeof LandedMessageSchema>;
 // One model's turn in the drafting walk (agent/role-model.ts tries connected models in order), in spend order:
@@ -238,6 +264,12 @@ export const AgentSummarySchema = z.object({
     // Both latched at the first turn, so a board scoped to one project can say which conversations are its own.
     startIn: z.string().optional().describe("Which folder it opened in, relative to the workspace root. Absent means the root."),
     actsAs: z.string().optional().describe("Which persona its first turn acted as. Absent for an ordinary chat."),
+    lastActsAs: z
+        .string()
+        .optional()
+        .describe(
+            "Which persona its last turn acted as: each turn runs as the persona it names, so this is who the conversation speaks as now, and what a view groups it under. Absent for an ordinary chat.",
+        ),
     // Per-conversation, so opening it restores its own choices rather than another tab's; `fast` here is what was asked
     // for, not what was served.
     model: z
@@ -336,10 +368,12 @@ export const AgentSummarySchema = z.object({
                 .describe(
                     "When the date written into the agent's prompt next changes, in milliseconds (midnight where the agent runs). Past it the next turn sends a different prompt, so nothing kept before it is read again.",
                 ),
-            keepable: z
-                .boolean()
+            keepableUntil: z
+                .number()
                 .optional()
-                .describe("Whether this sandbox can keep this cache warm: it holds the last turn's exact request to replay, on a Claude subscription account."),
+                .describe(
+                    "Present when this sandbox can keep this cache warm (its provider can replay the last turn's prefix): the furthest instant a hold can reach, in milliseconds, where refreshing would cost more than the cold resume it saves or the date in the prompt changes, whichever comes first.",
+                ),
         })
         .optional()
         .describe(
@@ -385,7 +419,7 @@ export const AgentSummarySchema = z.object({
             "When somebody last opened it, in milliseconds. Newer activity than this is what makes it unread. Kept by the sandbox rather than by a browser, so clearing site data or picking up a phone does not resurrect every badge.",
         ),
     attention: AgentAttentionSchema.describe("Which kinds of waiting-for-you it is doing."),
-    // Only the causes that still hold, re-read live (agents/land/standing.ts), never the stored report's own list: a
+    // Only the causes that still hold, re-read live (conversations/land/standing.ts), never the stored report's own list: a
     // blocker the user has since cleared is not something to offer them an action about.
     conflictCauses: z
         .array(LandConflictReasonSchema)
@@ -396,7 +430,11 @@ export const AgentSummarySchema = z.object({
     // Beside `attention` since a reader asks both at a glance, but opposite in shape: a turn gone, not one still parked
     // and waiting.
     unfinished: UnfinishedWorkSchema.optional().describe(
-        "What its last turn left open: steps it never completed, a check still failing. Absent for a turn that finished what it started.",
+        "What its last turn left open: steps it never completed. Absent for a turn that finished what it started.",
+    ),
+    // Written by the turn's own settle from its tool calls; nothing is asked of the model to earn or clear it.
+    proof: TurnProofSchema.optional().describe(
+        "What its last turn showed of its work: whether a check it ran passed after its last edit, and whether it looked at interface files it changed. Absent until a turn that edited or checked anything has ended.",
     ),
     // Completed turns and lifetime tool calls, the card's msgs/tools counters.
     turns: z.number().optional().describe("Turns it has finished."),
@@ -458,6 +496,14 @@ export const AgentSummarySchema = z.object({
         .describe(
             "The workflow run this conversation is a step of. Without it, a four-step run reads as four unrelated conversations that happen to have started together.",
         ),
+    // The one reading of "runs again by itself" (the daemon's awaitingWake, conversation-state.ts): status, fixStance and
+    // the card read it, never the watch list, which is only what the card lists. Absent from a daemon older than it.
+    awaitingWake: z
+        .boolean()
+        .optional()
+        .describe(
+            "Whether this conversation runs again by itself with nobody pressing anything: a watch is armed on it, or words the sandbox or another agent sent wait for it. A finished-looking card that is awaiting a wake is not finished yet.",
+        ),
     // Outside conditions a conversation is parked on; a finished-looking card can restart itself when one fires, and an
     // armed watch keeps a hosted machine (and its bill) awake. The check command itself never rides the wire, since it
     // may hold a secret.
@@ -484,6 +530,27 @@ export const AgentSummarySchema = z.object({
                 startedAt: z.number().describe("When it started, in milliseconds."),
                 endedAt: z.number().optional().describe("When the command exited, in milliseconds. Absent while it runs."),
                 exitCode: z.number().int().optional().describe("The code it exited with. Absent while it runs, or when its exit left none."),
+                // What the turn that left it running decided about it (agent/tools/jobs/job-fates.ts): one of these, or none
+                // while its turn is still going.
+                watch: z
+                    .string()
+                    .optional()
+                    .describe(
+                        "The watch its exit wakes this conversation through. Present once the turn that left it running has ended and the conversation is waiting on it.",
+                    ),
+                handed: z
+                    .boolean()
+                    .optional()
+                    .describe(
+                        "Left running for the person: the turn's reply gave its address, so it outlives the turn, wakes nothing and is theirs to stop.",
+                    ),
+                ports: z.array(z.number().int()).optional().describe("The ports it was listening on when its turn ended."),
+                stoppedBy: z
+                    .enum(["turn", "person", "agent"])
+                    .optional()
+                    .describe(
+                        "Who stopped it: the sandbox, when the turn that used it ended without handing it over; a person; or the agent itself. Present from the moment the stop is asked. Absent for a job that exited by itself.",
+                    ),
             }),
         )
         .optional()
@@ -500,6 +567,10 @@ export const AgentSummarySchema = z.object({
         ),
 });
 export type AgentSummary = z.infer<typeof AgentSummarySchema>;
+// Whether a conversation runs again by itself: the daemon's own reading, or, from a daemon older than it, whether a watch
+// is armed, which was all that one could say.
+export const awaitsWake = (agent: { readonly awaitingWake?: boolean | undefined; readonly watches?: readonly unknown[] | undefined }): boolean =>
+    agent.awaitingWake ?? (agent.watches?.length ?? 0) > 0;
 // One armed watch as a card carries it; derived from AgentSummarySchema.watches so the two shapes can't drift apart.
 export type AgentWatch = NonNullable<AgentSummary["watches"]>[number];
 // One background job as a card carries it.
@@ -514,6 +585,10 @@ export const AgentStopWatchingSchema = AgentIdSchema.extend({
     watchId: z.string().optional().describe("Which watch to disarm. Absent disarms every watch this conversation is parked on."),
 });
 
+export const AgentStopJobSchema = AgentIdSchema.extend({
+    jobId: z.string().min(1).describe("Which of its background jobs, by the id its card and transcript row carry."),
+});
+
 // Pages a transcript: a read returns its most recent turns and where they start (`from`); handing that back as `before`
 // asks for the page above. A stale cursor (a rewind, a fork) is clamped, never refused.
 export const AgentTranscriptQuerySchema = AgentIdSchema.extend({

package/src/schemas/automations.ts

@@ -297,8 +297,10 @@ export const AutomationSchema = z.object({
         .describe(
             "Which models this automation may run on, best first. Required, and nothing is chosen for you: work that fires while nobody is watching spends a real allowance, so it names the models it spends rather than inheriting one. Tried in order, so a spent account does not silently stop the job.",
         ),
-    // Absent means the provider's first account; pinning matters more here than for a chat, since nobody is watching to
-    // notice a stuck one.
+    // Absent means the daemon's pick: the account its conversation runs on for a continuing thread (moved off one that
+    // can no longer serve), else the one that can serve with the most room. Named, it is a pin, run whatever its state,
+    // so a refused account says so rather than being swapped; pinning matters more here than for a chat, since nobody
+    // is watching to notice a stuck one.
     account: z.string().optional().describe("Which account pays for it."),
     // Absent means the wake reaches no logged-in account at all, the strictest default here, since nobody is at the
     // composer when it fires.

package/src/schemas/devices.ts

@@ -1,6 +1,6 @@
 // What one of the user's own machines is running.
 import { z } from "zod";
-import { hostEntryOf, hostEnvironmentOf, type DeviceFacts, DeviceFactsSchema, userDistrosOf, WslEnvironmentSchema } from "./hosts.js";
+import { parseHostConnection, type DeviceFacts, DeviceFactsSchema, MachineIdSchema, userDistrosOf, WslEnvironmentSchema } from "./hosts.js";
 import { DEV_VERSION } from "../state/versions.js";
 // Desktop-sync report shape shared by the agent, daemon and browser, produced only by the agent's own `deviceReport`.
 // The agent never reports `sandboxes`; the docker half is filled in by whoever reads the report, scoped to the reader's
@@ -9,14 +9,32 @@ import { DEV_VERSION } from "../state/versions.js";
 // One sandbox's resource share as docker currently enforces it, read off the container by the machine agent.
 // `overlayRuntime` is the environment's locked demand; `hostRuntime` is the owner's addition; `privileged`/`gpu` are
 // docker's enforced truth.
-// Reshape request, turned into `ic sandbox reshape` flags: absent means leave it, `null` on the two caps means back to
-// the default; at least one key must be set.
+// A delta against what runs: absent means leave it, `null` on the two caps means back to the default; at least one key
+// must be set. What the old `reshape` op carries (`ic sandbox reshape` flags); `set-shape` carries a whole shape instead.
 export const SandboxResourcesAskFieldsSchema = z.object({
     memoryGib: z.int().positive().nullable().optional(),
     cpus: z.int().positive().nullable().optional(),
     privileged: z.boolean().optional(),
     gpu: z.boolean().optional(),
 });
+// A sandbox's shape, WHOLE: the owner's own ask for its share of the machine, every field a value. `null` on a cap is
+// the contract's default (the share derived from the engine, or every core). The switches are the owner's ask, not
+// docker's answer: a directive the approved environment demands rides beside it (`overlayRuntime`), and a host
+// without the NVIDIA runtime drops the GPU. `ic` stores it, validates it against the image's run contract when it is
+// saved, and prints it in `ic sandbox list --json`; nobody else merges anything into it.
+export const SandboxShapeSchema = z.object({
+    memoryGib: z.int().positive().nullable(),
+    cpus: z.int().positive().nullable(),
+    privileged: z.boolean(),
+    gpu: z.boolean(),
+});
+export type SandboxShape = z.infer<typeof SandboxShapeSchema>;
+// When a `set-shape` takes effect: `now` restarts the sandbox onto it; `nextRestart` saves it in ic's record and
+// restarts nothing, and the next restart through ic applies it — Restart or Start from any door, an update, a rollback
+// or a rebuild. Docker restarting the container by itself (after a crash or a reboot) does not: only ic recreates one.
+export const SandboxShapeWhenSchema = z.enum(["now", "nextRestart"]);
+export type SandboxShapeWhen = z.infer<typeof SandboxShapeWhenSchema>;
+
 export const SandboxResourcesSchema = z.object({
     // The cgroup memory ceiling in bytes; absent when docker imposes none (the hosted shape).
     memoryBytes: z.number().optional(),
@@ -26,14 +44,19 @@ export const SandboxResourcesSchema = z.object({
     gpu: z.boolean(),
     hostRuntime: z.array(z.string()),
     overlayRuntime: z.array(z.string()),
-    // A reshape saved for the sandbox's next restart (`ic sandbox reshape --later`) and not yet in force: the next
-    // update, rollback, rebuild, reshape or Restart applies it. Absent when nothing is saved.
+    // The shape the container runs with (the owner's ask it carries). Absent from an agent older than `set-shape`.
+    shape: SandboxShapeSchema.optional(),
+    // The shape saved for the sandbox's next restart through ic, and not yet in force. Absent when nothing is saved.
+    desired: SandboxShapeSchema.optional(),
+    // READ-ONLY, from agents older than `set-shape`: their saved share, a delta against what runs. Nothing new writes
+    // it; kept one release so a newer page can still show what an older agent saved. Remove with `later`.
     saved: SandboxResourcesAskFieldsSchema.optional(),
 });
 export type SandboxResources = z.infer<typeof SandboxResourcesSchema>;
 
 // Fields also exported separately for callers that compose them and enforce the at-least-one rule themselves.
-export const SandboxResourcesAskSchema = SandboxResourcesAskFieldsSchema.refine((ask) => Object.values(ask).some((value) => value !== undefined), {
+// Strict like every device input (DeviceSandboxFlowSchema says why): it is only ever sent to a device.
+export const SandboxResourcesAskSchema = SandboxResourcesAskFieldsSchema.strict().refine((ask) => Object.values(ask).some((value) => value !== undefined), {
     message: "a reshape must change at least one thing",
 });
 export type SandboxResourcesAsk = z.infer<typeof SandboxResourcesAskSchema>;
@@ -50,10 +73,14 @@ export const DeviceSandboxSchema = z.object({
     tunnelRunning: z.boolean().optional(),
     // Absent when the reader only ran a cheap `docker ps` listing without inspecting the container.
     resources: SandboxResourcesSchema.optional(),
+    // The update `ic sandbox prepare` built and left waiting for this sandbox; absent when nothing is staged.
+    staged: z.object({ image: z.string(), version: z.string().optional(), channel: z.string().optional() }).optional(),
 });
 export type DeviceSandbox = z.infer<typeof DeviceSandboxSchema>;
 // One operation on one sandbox, streamed as lines ending in a `result` or `error` frame. `prepare` builds the pending
-// update without touching the container; `reshape` changes only its resources and privileges, not the image.
+// update without touching the container. `set-shape` sets its resources and privileges, now or for the next restart;
+// `forget-shape` drops a shape saved for the next restart. `start`/`restart` apply a saved shape (all through `ic`).
+// `reshape` is the older spelling of `set-shape`, kept one release for pages served by older sandboxes.
 // `runner-up`/`runner-remove` act on a runner (this sandbox's own container), not a person's sandbox; gated by the
 // `sandboxes` switch, not removal, since a runner holds no separate workspace to lose.
 export const DeviceSandboxOpSchema = z.enum([
@@ -65,6 +92,8 @@ export const DeviceSandboxOpSchema = z.enum([
     "rebuild",
     "rollback",
     "reshape",
+    "set-shape",
+    "forget-shape",
     "remove",
     "logs",
     // The two ops that redeem a fresh setup code; every other one recreates a container from its own existing env.
@@ -76,7 +105,11 @@ export const DeviceSandboxOpSchema = z.enum([
     "runner-remove",
 ]);
 export type DeviceSandboxOp = z.infer<typeof DeviceSandboxOpSchema>;
-export const DeviceSandboxFlowSchema = z.object({
+// STRICT, like every input a device is sent: an agent rejects a field it does not know instead of dropping it and doing
+// something else (an older agent once dropped `later` and restarted a sandbox it had been asked to leave running). New
+// behaviour is a new `op`, which an older agent refuses by name, and the daemon refuses an op the agent has not
+// advertised before sending it (device-reports.ts).
+export const DeviceSandboxFlowSchema = z.strictObject({
     op: DeviceSandboxOpSchema,
     // Sandbox slug, the runner's name for the runner ops (as `/system/runners`/`ic runner list` know it), or for
     // `create` the name the claim is about to produce — the one op where the slug is an expectation rather than a
@@ -84,11 +117,14 @@ export const DeviceSandboxFlowSchema = z.object({
     slug: z.string().min(1),
     // Approved overlay's sha256, required only by `rebuild`; only content matching it is ever built.
     hash: z.string().optional(),
-    // What `reshape` should change, meaningless to the rest. Absent on a reshape applies what is saved for the next
-    // restart now; absent with `later` forgets what is saved.
+    // `set-shape` only, both required by it: the whole shape, and when it takes effect.
+    // Strict too, unlike the same shape read off a report (where a newer ic's extra field must not fail an older
+    // reader): an order carrying a field this agent does not know is refused rather than carried out without it.
+    shape: z.strictObject(SandboxShapeSchema.shape).optional(),
+    when: SandboxShapeWhenSchema.optional(),
+    // READ-ONLY for one release, from pages served by sandboxes older than `set-shape`: the old `reshape` op's delta,
+    // and `later` to save it for the next restart instead. Nothing new sends either.
     resources: SandboxResourcesAskSchema.optional(),
-    // `reshape` only: save `resources` for the sandbox's next restart instead of restarting it now, replacing
-    // whatever was saved before (`ic sandbox reshape --later`).
     later: z.boolean().optional(),
     // `runner-up` only, daemon-filled, never by the caller: the browser never holds the pairing credential.
     parentUrl: z.string().optional(),
@@ -104,6 +140,26 @@ export const DeviceSandboxFlowSchema = z.object({
     overlayHash: z.string().optional(),
 });
 export type DeviceSandboxFlow = z.infer<typeof DeviceSandboxFlowSchema>;
+// The `ic` argv for the shape and power ops, the one place any caller spells them: the machine agent runs it and the
+// Devices view prints it for a person to type when the app's route to the machine is shut. The shape travels as the
+// contract's own object, one `--set <field>=<JSON value>` per field, so no caller maps a field onto a flag of its own:
+// ic reads the pairs back into the contract's shape and refuses a field it does not know, as every device input does.
+// `when` is the contract's own word too. A field left out keeps what ic already has for it (the shape saved for the
+// next restart, else what runs): the Devices view always sends the whole shape, a model's tool call may name one
+// field. Nothing is judged here; ic checks the shape against the image's run contract. Needs an ic that takes `--set`
+// (the `set-shape` feature is advertised only then).
+export type SandboxShapeFields = { readonly [K in keyof SandboxShape]?: SandboxShape[K] | undefined };
+export const icShapeArgs = (slug: string, fields: SandboxShapeFields, when: SandboxShapeWhen): string[] => [
+    "sandbox",
+    "shape",
+    slug,
+    ...Object.entries(fields).flatMap(([field, value]) => (value === undefined ? [] : ["--set", `${field}=${JSON.stringify(value)}`])),
+    "--when",
+    when,
+];
+export const icForgetShapeArgs = (slug: string): string[] => ["sandbox", "shape", slug, "--forget"];
+// Power goes through ic too, so a Start or Restart from any door applies the shape saved for the next restart.
+export const icPowerArgs = (op: "start" | "stop" | "restart", slug: string): string[] => ["sandbox", op, slug];
 // Adds the device id to the flow input; the daemon looks up machines by id.
 export const DeviceSandboxFlowInputSchema = DeviceSandboxFlowSchema.extend({ id: z.string().min(1) });
 export type DeviceSandboxFlowInput = z.infer<typeof DeviceSandboxFlowInputSchema>;
@@ -123,7 +179,7 @@ export type DeviceFlowLine = z.infer<typeof DeviceFlowLineSchema>;
 // dropping one is always somebody's decision.
 export const DeviceAgentOpSchema = z.enum(["upgrade", "restart", "forget-unreachable"]);
 export type DeviceAgentOp = z.infer<typeof DeviceAgentOpSchema>;
-export const DeviceAgentFlowSchema = z.object({ op: DeviceAgentOpSchema });
+export const DeviceAgentFlowSchema = z.strictObject({ op: DeviceAgentOpSchema });
 export type DeviceAgentFlow = z.infer<typeof DeviceAgentFlowSchema>;
 // Adds the device id to the flow input.
 export const DeviceAgentFlowInputSchema = DeviceAgentFlowSchema.extend({ id: z.string().min(1) });
@@ -362,8 +418,10 @@ export const AGENT_STALL_AFTER_MS = 60_000;
 export const agentStalled = (agent: DeviceAgent, now: number): boolean =>
     agent.running && agent.lastTickAt !== undefined && now - agent.lastTickAt > AGENT_STALL_AFTER_MS;
 export const DeviceReportSchema = z.object({
-    // OS hostname; the join key that dedupes a machine seen via sync and via its `host` capability. Not unique on its
-    // own: a WSL distro inherits the Windows machine's name, so `wsl` below is what tells those apart.
+    // The computer this reading is from (MachineIdSchema): what a sync enrollment is stamped with when its agent posts,
+    // and so what joins a machine seen through sync to the same machine seen through its card. Absent from an older agent.
+    machineId: MachineIdSchema.optional(),
+    // OS hostname, for the owner to read; not a join key (a WSL distro inherits the Windows machine's name).
     hostname: z.string(),
     os: z.string(),
     // Present only inside a WSL distro; the same fact rides the connect-time facts, which no scope can withhold.
@@ -420,9 +478,8 @@ export const DeviceGapSchema = z.enum([
     "unreported",
 ]);
 export type DeviceGap = z.infer<typeof DeviceGapSchema>;
-// A machine may be reachable via desktop sync and a host capability at once; the two are reconciled on `hostname` plus
-// the environment it came from (`environmentOf`), and left as separate rows when there is nothing to reconcile them by
-// or when the environments positively disagree.
+// A machine may be reachable via desktop sync and a host capability at once; the two are one row when both say the same
+// `machineId` and the same environment, and separate rows whenever either has not said (an agent too old to carry it).
 // `machine` is the enrollment's name for the box (the ssh key's comment): what reports are filed under and what the
 // revoke route takes. Two machines sharing a key comment share one enrollment identity.
 export const DeviceSyncSchema = z.object({
@@ -431,6 +488,10 @@ export const DeviceSyncSchema = z.object({
     mode: z.enum(["sync", "mirror"]),
     // When this machine last used its enrollment; absent means never, not merely unknown, and is not healthy.
     seenAt: z.number().optional(),
+    // The computer and the environment on it that hold this enrollment, as its agent said when enrolling or in a report
+    // since; absent until an agent new enough to say has done so.
+    machineId: MachineIdSchema.optional(),
+    environment: z.string().optional(),
 });
 export type DeviceSync = z.infer<typeof DeviceSyncSchema>;
 export const DeviceSchema = z.object({
@@ -440,8 +501,14 @@ export const DeviceSchema = z.object({
     label: z.string(),
     // Desktop-sync enrollment with this sandbox; absent when reached only via a host capability.
     sync: DeviceSyncSchema.optional(),
-    // The host capability's id, when this machine is also a connected device. Absent otherwise.
+    // The host connection's key, when this machine is also a connected device. Absent otherwise.
     hostId: z.string().optional(),
+    // The card that connection is of, beside the key rather than parsed out of it: the machine's name, a label. Absent
+    // with `hostId`, and from a daemon older than the field (`deviceCard` reads the key then).
+    card: z.string().optional(),
+    // The computer this row is an environment of, from whichever door has said (MachineIdSchema): what `machinesOf`
+    // groups by. Absent when no door has, which leaves the row a computer of its own.
+    machineId: MachineIdSchema.optional(),
     // Host-capability liveness; absent when there is no host capability, not the same as offline.
     online: z.boolean().optional(),
     // Carried beside the report so a device with no report still has an OS; `platform` is the normalised slug, `facts`
@@ -480,7 +547,7 @@ export const deviceHostname = (device: Device): string | undefined => device.fac
 // and that is all an environment nobody has reached since this daemon booted can say about itself: liveness resets on
 // restart, so facts and reports are absent on a side that is merely asleep.
 export const deviceEnvironment = (device: Device): string | undefined =>
-    environmentOf(device.facts, device.report) ?? (device.hostId === undefined ? undefined : hostEnvironmentOf(device.hostId));
+    environmentOf(device.facts, device.report) ?? (device.hostId === undefined ? undefined : parseHostConnection(device.hostId).environment);
 
 const WSL_PREFIX = "wsl:";
 export const isWslDevice = (device: Device): boolean => deviceEnvironment(device)?.startsWith(WSL_PREFIX) === true;
@@ -495,24 +562,25 @@ export const deviceDistro = (device: Device): string | undefined => {
 const byEnvironment = (a: Device, b: Device): number =>
     Number(isWslDevice(a)) - Number(isWslDevice(b)) || (deviceDistro(a) ?? a.label).localeCompare(deviceDistro(b) ?? b.label);
 
-const hostnameKey = (device: Device): string | undefined => deviceHostname(device)?.toLowerCase();
-
 // The card a device's door hangs off: one card is one computer, so two doors naming the same card are one machine
 // whatever either has said about itself — which is the whole of what an environment that has never connected says.
-const cardKey = (device: Device): string | undefined => (device.hostId === undefined ? undefined : hostEntryOf(device.hostId));
-
-// What makes two devices one computer: a shared card, or a shared hostname where a distro answers to it, since WSL
-// hands a distro the Windows machine's name. Two native installs that merely share a name stay two machines.
-const tokensOf = (device: Device, distroNames: ReadonlySet<string>): string[] => {
-    const card = cardKey(device);
-    const hostname = hostnameKey(device);
-    return [
-        ...(card === undefined ? [] : [`card:${card.toLowerCase()}`]),
-        ...(hostname !== undefined && distroNames.has(hostname) ? [`host:${hostname}`] : []),
-    ];
+// The row's own label, else its key read by the one parser there is (a row from a daemon older than `card`).
+export const deviceCard = (device: Pick<Device, "card" | "hostId">): string | undefined =>
+    device.card ?? (device.hostId === undefined ? undefined : parseHostConnection(device.hostId).card);
+
+// The computer a device is on, by whichever door said: its row, its connect-time facts, its report, its sync enrollment.
+export const deviceMachineId = (device: Device): string | undefined =>
+    device.machineId ?? device.facts?.machineId ?? device.report?.machineId ?? device.sync?.machineId;
+
+// What makes two devices one computer: a shared card, or a shared machine id. Nothing else: a hostname is shared by a
+// PC and its WSL distros and by two unrelated machines with the same name, so it joined things by accident.
+const tokensOf = (device: Device): string[] => {
+    const card = deviceCard(device);
+    const machine = deviceMachineId(device);
+    return [...(card === undefined ? [] : [`card:${card.toLowerCase()}`]), ...(machine === undefined ? [] : [`machine:${machine}`])];
 };
 
-// Components over both joins at once: a device holding a card token and a hostname token is the evidence that merges
+// Components over both joins at once: a device holding a card token and a machine token is the evidence that merges
 // the machines those tokens named, so a distro connected under a card of its own still lands on the PC it runs on.
 interface Component {
     readonly tokens: Set<string>;
@@ -520,10 +588,9 @@ interface Component {
 }
 
 const componentsOf = (devices: readonly Device[]): Component[] => {
-    const distroNames = new Set(devices.filter(isWslDevice).map(hostnameKey).filter((name) => name !== undefined));
     const components: Component[] = [];
     for (const device of devices) {
-        const tokens = tokensOf(device, distroNames);
+        const tokens = tokensOf(device);
         const [head, ...merged] = components.filter((component) => tokens.some((token) => component.tokens.has(token)));
         if (head === undefined) {
             components.push({ tokens: new Set(tokens), devices: [device] });
@@ -544,7 +611,7 @@ const componentsOf = (devices: readonly Device[]): Component[] => {
 
 // Addressed by the card of the side that owns the screen, an address that does not change when a second environment
 // connects — unlike a row key, which is a hostname another environment can take first. An uncarded fold has only the
-// hostname its doors share, and an uncarded lone device its own key. Called what the owner calls it: the name the
+// machine id its doors share, and an uncarded lone device its own key. Called what the owner calls it: the name the
 // leading environment carries, unless that is nothing but its door id, which reads as a PC named after one of its
 // own sides.
 const machineOf = (environments: readonly Device[]): Machine => {
@@ -553,8 +620,8 @@ const machineOf = (environments: readonly Device[]): Machine => {
     if (first === undefined) {
         return { key: "", label: "", environments };
     }
-    const named = environments.map(cardKey).find((key) => key !== undefined) ?? (rest.length === 0 ? undefined : deviceHostname(first));
-    const label = first.label === first.hostId ? (cardKey(first) ?? first.label) : first.label;
+    const named = environments.map(deviceCard).find((key) => key !== undefined) ?? (rest.length === 0 ? undefined : deviceMachineId(first));
+    const label = first.label === first.hostId ? (deviceCard(first) ?? first.label) : first.label;
     return { key: named ?? first.key, label, environments };
 };
 

package/src/schemas/extension-updates.ts

@@ -177,6 +177,12 @@ export const ExtensionSummarySchema = z.object({
         })
         .optional()
         .describe("Present only for an extension that ships a server half."),
+    problems: z
+        .array(z.string())
+        .optional()
+        .describe(
+            "Declarations in its manifest the sandbox refused at load, each a sentence saying what and why, such as a listener for a provider another extension already owns. The rest of it still loads. Absent when nothing was refused.",
+        ),
     // Update lifecycle, present only for a git-installed extension (absent for builtin/workspace):
     // update: the badge.
     // advisory: the alarm.

package/src/schemas/git/git.ts

@@ -450,6 +450,11 @@ export const AgentChangesSchema = z.object({
 });
 export type AgentChanges = z.infer<typeof AgentChangesSchema>;
 
+// The review's `conflicts` alone, re-derived the same way. The whole review also takes a code-only line count per
+// file, and on a branch of hundreds of files that count, not the conflict check, is what takes seconds.
+export const AgentConflictsSchema = AgentChangesSchema.pick({ conflicts: true });
+export type AgentConflicts = z.infer<typeof AgentConflictsSchema>;
+
 // Names scratch exactly as `AgentChanges.scratch` lists it; anything else is refused, so a stale list cannot reach a
 // file that was never scratch.
 export const AgentScratchSchema = z.object({