@intentic/sandbox-contract 1.229.0 → 1.230.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentic/sandbox-contract",
-  "version": "1.229.0",
+  "version": "1.230.1",
   "description": "oRPC wire contract for the intentic sandbox daemon, shared by the daemon and its browser client",
   "license": "MIT",
   "type": "module",
@@ -89,9 +89,9 @@
     "@orpc/contract": "1.14.13",
     "tslib": "2.8.1",
     "zod": "4.4.3",
-    "@intentic/constants": "1.229.0",
-    "@intentic/registry": "1.229.0",
-    "@intentic/extension-manifest": "1.229.0"
+    "@intentic/constants": "1.230.1",
+    "@intentic/extension-manifest": "1.230.1",
+    "@intentic/registry": "1.230.1"
   },
   "devDependencies": {
     "@types/node": "24.13.2",

package/src/contracts/agents.contract.ts

@@ -165,6 +165,27 @@ export const agentsContract = {
         })
         .input(AgentIdSchema)
         .output(AgentSummarySchema),
+    /* DISARM EVERY CONDITION WATCH THIS CONVERSATION IS PARKED ON (AgentSummary.watches), the way off the one
+     * standing arrangement an agent can enter into on the user's behalf without being asked again.
+     *
+     * ALL OF THEM, NOT ONE. The id of an individual watch is on the card, but the press a person makes about a
+     * card means "stop this conversation waking itself up", and picking watches off a submenu one at a time is a
+     * chore invented by the data shape rather than wanted by anybody. A conversation that should go on watching
+     * one thing and not another can be told so in the chat, which is where the watches were armed.
+     *
+     * No wake fires for what this disarms, which is the whole point: a watch left armed keeps a hosted machine
+     * awake and eventually starts a turn nobody is expecting. Nothing else about the conversation moves, so the
+     * card it hands back differs only by having lost its watches. */
+    stopWatching: oc
+        .route({
+            method: "POST",
+            path: "/agents/{id}/stop-watching",
+            summary: "Stop every condition watch a conversation is parked on",
+            description:
+                "Disarms all of this conversation's outside-condition watches, so none of them will wake it. All of them rather than one, because that is what the press means when it is made about a card. Nothing else about the conversation changes.",
+        })
+        .input(AgentIdSchema)
+        .output(AgentSummarySchema),
     seenAll: oc
         .route({
             method: "POST",

package/src/schemas.ts

@@ -1322,6 +1322,42 @@ 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 OUTSIDE CONDITIONS THIS CONVERSATION IS PARKED ON, the armed condition watches (the daemon's
+     * agent/watchers.ts), projected onto the card for the same reason the loop and the workflow above are.
+     *
+     * IT IS THE ONE PROMISE THE BOARD USED TO KEEP SILENTLY. An agent that arms a watch ends its turn: nothing
+     * is running, nothing is owed to the user, so every surface filed it under finished and drew the resting
+     * `idle`. Then, some hours later, the daemon's check exits 0 and that same conversation starts working
+     * again, on its own, in front of somebody who had been told it was done. The wake is the feature; the card
+     * saying nothing about it beforehand is what made it read as the sandbox acting unasked.
+     *
+     * It also has a bill attached, which no other projection here does. An armed watch keeps a hosted machine
+     * awake (system/idle-stop.ts counts them, deliberately: stopping the box is how a watch silently never
+     * fires), so an invisible watch is invisible compute. A user looking at a board of finished agents,
+     * wondering why the machine will not go quiet, could not have found the answer anywhere.
+     *
+     * WHAT IS ON THE WIRE IS WHAT A CARD CAN ACT ON, and nothing else. The note (the agent's own line on what
+     * it is waiting for), the cadence, and the deadline, which is what turns "waiting" into a countdown with an
+     * end. Deliberately NOT the check command: it is shell text the reader cannot run, judge or fix from a
+     * board, and it is the one field that could carry a secret reference into a surface that is read over
+     * shoulders. Deliberately NOT the check COUNT either, which would move every interval and buy a whole
+     * roster broadcast to advance a number nobody is reading.
+     *
+     * Absent ⇒ nothing armed, which is nearly every conversation. Empty is never sent: the daemon clears the
+     * projection instead, so the field's PRESENCE is the signal. */
+    watches: z
+        .array(
+            z.object({
+                id: z.string().describe("The daemon's handle for this watch, the same one the agent was given when it armed it."),
+                note: z.string().describe("The agent's own line on what it is waiting for."),
+                intervalSeconds: z.number().int().min(1).describe("How often the check runs."),
+                deadlineAt: z.number().describe("When it gives up and wakes the conversation anyway, in milliseconds. Every watch has one."),
+            }),
+        )
+        .optional()
+        .describe(
+            "Outside conditions this conversation is parked on, each of which will wake it. Absent means none, which is nearly every conversation: an armed watch is why a finished-looking agent starts working by itself, and why a hosted machine will not go idle.",
+        ),
     // When the agent was ARCHIVED (ms epoch), off the board, but nothing lost: its checkout was retired
     // (worktree removed) while the agent/<id> branch, the transcript, and every counter stayed. Absent ⇒ live
     // on the board. Archived agents are excluded from the roster the fleet renders; `agents.archived` lists
@@ -1334,6 +1370,9 @@ export const AgentSummarySchema = z.object({
         ),
 });
 export type AgentSummary = z.infer<typeof AgentSummarySchema>;
+// One armed condition watch as a card carries it (AgentSummarySchema.watches). Named off the summary rather
+// than declared beside it, so the shape the daemon publishes and the shape the wire promises cannot drift.
+export type AgentWatch = NonNullable<AgentSummary["watches"]>[number];
 // AgentsListSchema lives further down, after AutomationApprovalSchema, the fleet list carries the held wakes,
 // and zod declaration order forces the ride-along to be declared first.
 export const AgentIdSchema = z.object({ id: z.string().min(1).describe("Which conversation.") });