@intentic/sandbox-contract 1.338.0 → 1.339.0

package/dist/state/history-state.js.map

@@ -1 +1 @@
-{"version":3,"file":"history-state.js","sourceRoot":"","sources":["../../src/state/history-state.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"history-state.js","sourceRoot":"","sources":["../../src/state/history-state.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentic/sandbox-contract",
-  "version": "1.338.0",
+  "version": "1.339.0",
   "description": "oRPC wire contract for the intentic sandbox daemon, shared by the daemon and its browser client",
   "license": "MIT",
   "type": "module",
@@ -361,10 +361,10 @@
     }
   },
   "dependencies": {
-    "@intentic/base": "1.338.0",
-    "@intentic/constants": "1.338.0",
-    "@intentic/extension-manifest": "1.338.0",
-    "@intentic/registry": "1.338.0",
+    "@intentic/base": "1.339.0",
+    "@intentic/constants": "1.339.0",
+    "@intentic/extension-manifest": "1.339.0",
+    "@intentic/registry": "1.339.0",
     "@orpc/contract": "1.15.4",
     "tslib": "2.8.1",
     "zod": "4.6.5"

package/src/contracts/agents.contract.ts

@@ -26,7 +26,7 @@ import {
     AgentUnsentSchema,
     LandResultSchema,
 } from "../schemas/agents.js";
-import { AgentsListSchema } from "../schemas/agents-list.js";
+import { AgentsAttentionSchema, AgentsListSchema } from "../schemas/agents-list.js";
 import { AgentChangesSchema, AgentConflictsSchema, AgentIgnoredSchema, AgentScratchSchema, AgentHistorySchema } from "../schemas/git/git.js";
 import { FileDiffSchema } from "../schemas/history.js";
 import { OkSchema } from "../schemas/shared.js";
@@ -51,6 +51,18 @@ export const agentsContract = {
         })
         .meta({ guest: true })
         .output(AgentsListSchema),
+    // The owner's only, and never a program's or a panel's: it is how the machine that runs the sandbox reads it with a
+    // session it minted for the owner (`ic sandbox attention`), and a member's count would not be the owner's anyway.
+    attention: procedure
+        .route({
+            method: "GET",
+            path: "/agents/attention",
+            summary: "What needs you, and what is working",
+            description:
+                "Two counts over the live fleet, by the board's own rules: the cards in its Attention lane plus the automations waiting for a yes, and the conversations producing something right now. What a status bar shows without reading the whole fleet.",
+        })
+        .meta({ floor: "owner", control: "never", panel: false })
+        .output(AgentsAttentionSchema),
     archived: procedure
         .route({
             method: "GET",

package/src/models/agent-lanes.ts

@@ -0,0 +1,152 @@
+import type { AgentAttention } from "../schemas/agents.js";
+import type { AutomationApproval } from "../schemas/automations.js";
+import { parentOf } from "./agent-starter.js";
+import {
+    type AgentStanding,
+    blocked,
+    heardByParent,
+    limitScheduled,
+    onlyOwnerCanAnswer,
+    scheduledSend,
+    turnInFlight,
+    turnWorking,
+    watching,
+} from "./agent-standing.js";
+
+// The lane every surface files a conversation in, and what of a fleet calls the person. Moved here from the editor
+// (_editor/web/src/models/agent-status/agentStatus-lanes.ts, which re-exports it) on 2026-10-16, so the daemon's
+// `agents.attention` (what the desktop app's status bar and `ic sandbox attention` read) counts by the board's own rules.
+
+// Whether what a child agent stopped on is the reader's to answer rather than its parent's, given the lanes both stand
+// in and when the parent last moved. An ask only the owner can answer always is; anything else it stopped on (a spent
+// allowance, a failure, a stop, a question, a land conflict) is its parent's news while the parent supervises, and the
+// reader's once it no longer does: nothing running there to hear it and nothing armed to wake it, which is a parent out
+// of Active. That holds only until the parent moves past it (heardByParent). After that the stop is the family's
+// history, drawn in the tray, and no longer something the reader owes a press. The sandbox draws the same line for a
+// child's land news (subagents/child-lands.ts): the parent's while it has a live turn, the owner's after.
+export const callsOwner = (
+    child: AgentStanding & { readonly updatedAt: number },
+    family: { readonly child: FleetLane; readonly parent: FleetLane; readonly parentAt: number },
+): boolean => onlyOwnerCanAnswer(child) || (family.child === "attention" && family.parent !== "active" && !heardByParent(child, family.parentAt));
+
+export type FleetLane = "attention" | "active" | "finished";
+
+// Nothing owed to the user. The one "no attention" block in the app: a client-only card has no daemon account of
+// what a turn asked, and two copies of this would let two surfaces place the same conversation differently.
+export const NO_ATTENTION: AgentAttention = {
+    plan: false,
+    question: false,
+    permission: false,
+    capability: false,
+    credential: false,
+    conflict: false,
+};
+
+// The lane projection every surface must agree with (see the header). Pure reading of the state machine:
+// "finished" needs no explicit timer since auto-land already flips a cleanly-completed turn to landed/idle within
+// ms, and any follow-up message moves the card back to active. Unread stays a badge, not a lane.
+export const laneOf = (agent: AgentStanding): FleetLane => {
+    // A spent allowance nothing is booked for reaches Attention through `blocked` alone, no branch of its own, and ahead
+    // of the `watching` branch below: a watch is the agent's own plan for waiting, a spent allowance an obstacle in
+    // the way of it, and a watch firing into a shut window runs nothing (turn-admission.ts holds its words back).
+    if (blocked(agent) || agent.status === "awaiting" || agent.status === "conflict") {
+        return "attention";
+    }
+    // Settled from the press, ahead of the in-flight check below, rather than routed through Active: a waved-away turn
+    // is one the user is already done with (unlike `stopping`, which rests in Attention), and a land spends no model at
+    // all. Active means a turn in progress, so a land must end in the lane it was pressed in.
+    if (agent.status === "dismissing" || agent.status === "landing") {
+        return "finished";
+    }
+    // `resuming` is why in-flight must outrank the settled readings below: without this order the card would drop
+    // into Finished for the seconds a credential takes to re-mint, then climb back out.
+    if (turnInFlight(agent) || agent.status === "draft") {
+        return "active";
+    }
+    // An armed watch is Active, not Finished: nothing is running, but the conversation restarts itself later, and
+    // filing it Finished would announce as over work that resumes at 3am. Active rather than Attention since nothing
+    // is owed by the user. Checked after the in-flight readings: an agent that armed a watch and is now running again
+    // is running.
+    if (watching(agent)) {
+        return "active";
+    }
+    // A stranded turn booked to go again is Active: at the reset, or on the resume pass's next beat for a move to another
+    // account. Reached only because `blocked` let it through; stated explicitly or the card would fall through to
+    // Finished, which would announce as over work that resumes by itself.
+    if (limitScheduled(agent)) {
+        return "active";
+    }
+    // Messages booked for later are the same: the conversation starts again by itself, at a time or once the agent it
+    // waits for has landed, so filing it Finished would announce as done work that has not started yet.
+    if (scheduledSend(agent)) {
+        return "active";
+    }
+    // `landed`/`idle`/`ready` all finish here: `ready` is work held on the branch because auto-land is off, still
+    // finished rather than attention since nothing is failing. `resumed` lands here too: nothing running, nothing
+    // owed.
+    return "finished";
+};
+
+// How many cards the board's Attention lane draws for one fleet, as the board folds child agents under their parents
+// (models/fleet/board/childFold.ts): an agent in Attention is a card of its own, except a child agent whose parent is in the
+// fleet, which rides under its family's one card and lifts that card to Attention only when it calls the reader
+// (callsOwner). A family counts once however many of its children call, and not again when its own card is in
+// Attention already; a child with words left in its composer keeps a card of its own, as on the board. The rail
+// badge's count, for this sandbox's fleet and another's alike, so the badge cannot disagree with the lane it names.
+export const attentionCards = (agents: readonly CallerStanding[]): number => new Set(attentionCalls(agents).map((call) => call.card)).size;
+
+// Enough of a fleet's agent to say whether it calls the reader, and through which card.
+export type CallerStanding = AgentStanding & {
+    readonly id: string;
+    readonly updatedAt: number;
+    readonly startedBy?: string | undefined;
+    readonly unsent?: boolean | undefined;
+};
+
+// Every agent calling the reader, each with the card it is drawn on: its own, or its family's where it rides one. The
+// count above is the cards; the browser tab's chime wants the callers, so a second child calling under a family already
+// in Attention is news although the lane's count does not move.
+export const attentionCalls = (agents: readonly CallerStanding[]): readonly { readonly id: string; readonly card: string }[] => {
+    type Standing = (typeof agents)[number];
+    const byId = new Map(agents.map((agent) => [agent.id, agent] as const));
+    const parentIn = (agent: Standing): Standing | undefined => {
+        const id = parentOf(agent.startedBy);
+        return id === undefined ? undefined : byId.get(id);
+    };
+    // The card a child rides under: its eldest ancestor in this fleet, walked with a guard against a record naming its
+    // own descendant as its parent.
+    const familyOf = (agent: Standing): string => {
+        const seen = new Set([agent.id]);
+        let top = agent;
+        for (let above = parentIn(top); above !== undefined && !seen.has(above.id); above = parentIn(top)) {
+            seen.add(above.id);
+            top = above;
+        }
+        return top.id;
+    };
+    const calls: { readonly id: string; readonly card: string }[] = [];
+    for (const agent of agents) {
+        const parent = parentIn(agent);
+        if (parent === undefined || agent.unsent === true) {
+            if (laneOf(agent) === "attention") {
+                calls.push({ id: agent.id, card: agent.id });
+            }
+        } else if (callsOwner(agent, { child: laneOf(agent), parent: laneOf(parent), parentAt: parent.updatedAt })) {
+            calls.push({ id: agent.id, card: familyOf(agent) });
+        }
+    }
+    return calls;
+};
+
+// What one fleet owes the person and how much of it is under way, as the desktop app's status bar and the sandbox
+// switcher count it: the Attention lane's cards as the board draws them (attentionCards) plus held automation wakes,
+// which lead that lane with no card of their own; and the turns producing something right now (turnWorking).
+export interface FleetAttention {
+    readonly needsYou: number;
+    readonly working: number;
+}
+
+export const fleetAttention = (agents: readonly CallerStanding[], held: readonly Pick<AutomationApproval, "id">[]): FleetAttention => ({
+    needsYou: attentionCards(agents) + held.length,
+    working: agents.filter(turnWorking).length,
+});

package/src/models/agent-standing.ts

@@ -0,0 +1,279 @@
+import {
+    type AgentAttention,
+    type AgentJob,
+    type AgentStatus,
+    type AgentWatch,
+    awaitsWake,
+    type LandConflictReason,
+    type LandFailure,
+} from "../schemas/agents.js";
+import type { QueuePause } from "../schemas/agent.js";
+
+// (2026-10-16) Moved here from the editor (_editor/web/src/models/agent-status/agentStatus-standing.ts, which re-exports
+// it), so the daemon counts what needs the person by the very rules the board draws with (models/agent-lanes.ts): the
+// desktop app's status bar asks the daemon (`agents.attention`), and the board and the bar must never disagree.
+
+// Every projection of a fleet agent's state (lane, attention label, drill-in verb, glyphs). Nothing else may
+// derive these from `status` alone: a parked turn is `idle` with an attention flag raised. Pure functions over
+// plain data, no store, no Vue.
+
+// Four standings a conversation gets when the daemon has not registered it. `draft`: not sent yet. `starting`:
+// sent but not yet filed as an agent. `failed`: send refused, never became an agent. `resumed`: a past conversation
+// reopened from History with no surviving registry entry. All four have no registry entry, so nothing to archive,
+// review, land or drop (`unregistered` below). None may be widened into `AgentStatus`: that enum is only the
+// daemon's account of agents it has.
+export type ClientAgentStatus = "draft" | "starting" | "failed" | "resumed";
+
+// Enough of an agent to place one; every predicate below takes only this, so a FleetAgent, a roster AgentSummary,
+// or a test literal can all answer the same question. Each optional field also takes `undefined`, as the contract's own
+// AgentSummary spells it, so the daemon (strict about the difference) hands its roster over as it is.
+export interface AgentStanding {
+    readonly status: AgentStatus | ClientAgentStatus;
+    readonly attention: AgentAttention;
+    // Outside conditions this conversation is parked on (AgentSummary.watches); `laneOf` reads it alongside `status`
+    // and `attention`. Absent for nearly every conversation.
+    readonly watches?: readonly AgentWatch[] | undefined;
+    // Whether it runs again by itself (AgentSummary.awaitingWake): the daemon's one reading, which `watching` asks.
+    readonly awaitingWake?: boolean | undefined;
+    // The commands it left running and how the recent ones ended (AgentSummary.jobs); `heldByPrompt` reads which of its
+    // watches a job at a prompt holds. Absent for nearly every conversation.
+    readonly jobs?: readonly AgentJob[] | undefined;
+    // Why a refused land is still refusing (AgentSummary.conflictCauses), which decides whose press can clear it.
+    // Absent for every card but one refusing to merge.
+    readonly conflictCauses?: readonly LandConflictReason[] | undefined;
+    // Which kind of failure ended the last turn. `status: "error"` alone conflates a broken harness with a spent
+    // allowance; both belong in Attention, but this says which so the card can tell them apart. `laneOf` reads it too,
+    // so the lane, badge and chip stay in agreement.
+    readonly failureCode?: string | undefined;
+    // The words that turn died on (AgentSummary.failure), cleared with the code when it runs again.
+    readonly failure?: string | undefined;
+    /** When the spent allowance reopens, in epoch SECONDS (the wire's unit). Absent when nobody published one. */
+    readonly limitResetsAt?: number | undefined;
+    /** Whether the refused turn is held whole, so a press re-runs it rather than sending a new message after it. */
+    readonly limitHeld?: boolean | undefined;
+    /** Whether a fire is already booked for it (at the reset, or a move now), so no press is needed. */
+    readonly limitScheduled?: boolean | undefined;
+    /** The account the owner's policy is moving the held turn to, while that move is booked (a scheduled card's sentence). */
+    readonly limitMoving?: string | undefined;
+    // A land that broke (AgentSummary.landFailure), standing until one goes through whatever turns run after it. Absent
+    // from a sandbox older than it, where only a turn's own `failure` can say so.
+    readonly landFailure?: LandFailure | undefined;
+    // What waits for its next turn (AgentSummary.queue), read here only for its hold: messages booked to go by
+    // themselves at a time or once another agent's work lands (`scheduled`), which make the conversation one that runs
+    // again by itself. Never the words.
+    readonly queue?: QueueHold | undefined;
+}
+
+// The part of a conversation's queue the board reads: why it holds, and what a scheduled hold waits for. A queue-level
+// `scheduled` with its `until` or `after` is the soonest booked message's; a Stop's or a refusal's hold on the messages
+// with no booking takes that place, so each message's own booking (`items`, from sandboxes that book each message on its
+// own) is read then.
+export interface QueueHold {
+    readonly paused?: QueuePause | undefined;
+    readonly until?: number | undefined;
+    readonly after?: string | undefined;
+    readonly items?: readonly { readonly until?: number | undefined; readonly after?: string | undefined }[] | undefined;
+}
+
+// The soonest booking a queue holds, as a scheduled hold: the queue's own while it reads `scheduled`, else the earliest
+// message's time, else the first message waiting on a land; undefined when nothing is booked. One thing, never both.
+export const soonestHold = (queue: QueueHold | undefined): QueueHold | undefined => {
+    if (queue?.paused === "scheduled") {
+        if (queue.after !== undefined) {
+            return { paused: "scheduled", after: queue.after };
+        }
+        return queue.until === undefined ? { paused: "scheduled" } : { paused: "scheduled", until: queue.until };
+    }
+    const items = queue?.items ?? [];
+    const instants = items.flatMap((item) => (item.until === undefined ? [] : [item.until]));
+    if (instants.length > 0) {
+        return { paused: "scheduled", until: Math.min(...instants) };
+    }
+    const after = items.find((item) => item.after !== undefined)?.after;
+    return after === undefined ? undefined : { paused: "scheduled", after };
+};
+
+// Messages booked to go by themselves (sendLater.ts, or a spent allowance's reopen): the conversation runs again with
+// nobody pressing anything, so it is not finished, and nothing is owed by the reader for it to.
+export const scheduledSend = (agent: Pick<AgentStanding, "queue">): boolean => soonestHold(agent.queue) !== undefined;
+
+// How many messages are booked to go by themselves: each by its own booking, or all of them when an older sandbox booked
+// the queue whole. What an archive by hand cancels (the sandbox's archive.ts), which the card's Archive says first.
+export const scheduledCount = (agent: Pick<AgentStanding, "queue">): number => {
+    const items = agent.queue?.items ?? [];
+    return agent.queue?.paused === "scheduled" ? items.length : items.filter((item) => item.until !== undefined || item.after !== undefined).length;
+};
+
+// A spent allowance, not a failure to fix: nothing broken, and it comes back. Read off `failureCode` rather than
+// the provider's own sentence, which varies per provider; the code is the daemon's own classification
+// (error-frames.ts).
+export const limited = (agent: AgentStanding): boolean => agent.status === "error" && agent.failureCode === "rate_limit";
+
+// A message held at the door because the sandbox is short of memory (turn-admission): nothing ran and nothing failed,
+// it waits for a person's "send anyway". The daemon files it as an `error`, so this is read off the code, as `limited`
+// is, and the chip and glyph say held rather than error; the lane stays Attention, since the press is the reader's.
+export const memoryHeld = (agent: Pick<AgentStanding, "status" | "failureCode">): boolean =>
+    agent.status === "error" && agent.failureCode === "sandbox-memory-low";
+
+// Whether the window is still shut, feeding only the card's countdown, never the lane: a stranded card stays in
+// Attention shut or open. No published instant means never closed, not a guessed one.
+export const limitClosed = (agent: AgentStanding, now: number = Date.now()): boolean =>
+    limited(agent) && agent.limitResetsAt !== undefined && agent.limitResetsAt * 1_000 > now;
+
+// A booked fire needs no press: the held turn goes again at the reset by itself. Only where this conversation's answer
+// for the limit says so (`resend` or `move`); that answer starts at `wait`. Nothing is owed then, so it leaves Attention
+// for Active, as an armed watch does: a card counted in the badge and the tab title for the hours until a reset the
+// reader already answered was a call nobody could answer. The stall still shows, on the card's own chip and clock.
+export const limitScheduled = (agent: AgentStanding): boolean => limited(agent) && agent.limitScheduled === true;
+
+// A booked move: the owner's policy is already carrying the held turn to another account, on the resume pass's next
+// beat, seconds away, so the card names where it is going rather than when it goes.
+export const limitMoveBooked = (agent: AgentStanding): boolean => limitScheduled(agent) && agent.limitMoving !== undefined;
+
+// A refused land nothing the agent does can clear: every blocker left is a file the user has uncommitted edits on,
+// which only a commit or stash releases (git cannot merge through unstaged work, and the agent's checkout cannot
+// even see it). The distinction the board used to lack: it offered "have the agent resolve it" for every conflict,
+// including the ones where that press was refused the moment it was made.
+// False when the daemon named no causes, which is a build that predates them or a refusal it could not attribute;
+// the board then falls back to offering the agent, as it always did.
+export const conflictIsYours = (agent: AgentStanding): boolean =>
+    agent.conflictCauses !== undefined && agent.conflictCauses.length > 0 && agent.conflictCauses.every((cause) => cause === "workspace");
+
+// This conversation runs again by itself, with nobody pressing anything: its last turn ended (status is `idle`/`landed`,
+// never `ready`, since the daemon holds the land for the wake), but the conversation is not over. The daemon's own
+// reading (a watch, or a wake waiting in its queue); a daemon older than it is read by its watches.
+export const watching = (agent: AgentStanding): boolean => awaitsWake(agent);
+
+// The running job behind one of its armed watches that sits at a prompt (AgentJob.inputWait: blocked reading its
+// terminal, nothing moving), the first such where there are several. Its watch fires only on an exit that will not
+// come, so the card names it and offers to end it.
+export const promptHeldJob = (agent: AgentStanding): AgentJob | undefined => {
+    const armed = new Set((agent.watches ?? []).map((watch) => watch.id));
+    return agent.jobs?.find((job) => job.endedAt === undefined && job.inputWait !== undefined && job.watch !== undefined && armed.has(job.watch));
+};
+
+// Parked only on jobs at a prompt: every watch it holds waits on an exit nobody in the sandbox will bring about, so the
+// conversation is not resuming by itself, it is stuck until the reader ends the command (or types into its terminal).
+// Not while a turn runs, whose own readout says what it is doing. On 2026-10-04 such a card sat in Active for hours
+// under a six-hour countdown, with its Land press hidden behind the wake it was waiting for.
+export const heldByPrompt = (agent: AgentStanding): boolean => {
+    const watches = agent.watches ?? [];
+    if (watches.length === 0 || turnInFlight(agent)) {
+        return false;
+    }
+    const prompts = new Set(
+        (agent.jobs ?? [])
+            .filter((job) => job.endedAt === undefined && job.inputWait !== undefined && job.watch !== undefined)
+            .map((job) => job.watch),
+    );
+    return watches.every((watch) => prompts.has(watch.id));
+};
+
+// No registry entry behind this card: archiving, reviewing, landing, discarding and dropping all address an agent
+// by id through the daemon, and none of these ids name anything there.
+// Takes the status alone, unlike the lane predicates: callers like the tab's `open` and the detail page's
+// `registered` hold a status without an attention block to pair it with.
+export const unregistered = (status: AgentStatus | ClientAgentStatus): boolean =>
+    status === "draft" || status === "starting" || status === "failed" || status === "resumed";
+
+// A turn is in flight: running, unwinding after a Stop, or repairing itself after its daemon died. Every hands-off
+// guard (its worktree is a live turn's working state) and the live readouts (elapsed, activity line) key off this.
+// `starting` counts even though nothing is registered yet, elapsed should tick from the send. `dismissing` and
+// `landing` count for the guards only; both settle in Finished, so their lane is decided separately (see laneOf).
+// A land runs no turn, but the daemon holds the worktree exactly as a turn would, and every guard wants the same answer.
+// `awaiting` is deliberately excluded: it's live but parked, handled by `awaitingUser` instead.
+export const turnInFlight = (agent: AgentStanding): boolean =>
+    agent.status === "running" ||
+    agent.status === "starting" ||
+    agent.status === "stopping" ||
+    agent.status === "dismissing" ||
+    agent.status === "resuming" ||
+    agent.status === "landing";
+
+// The two standings a person's ending unwinds as, from the press until the turn has let go: Stop, or waving away the
+// question it was parked on. Both differ only in the lane they settle in (see laneOf).
+export type EndingByHand = Extract<AgentStatus, "stopping" | "dismissing">;
+
+// How a person ended this turn, while it unwinds; undefined for a turn nobody ended. The one reading both the board's
+// card and the chat's live line are drawn from, so the two say the same word about the same press.
+export const endingOf = (agent: AgentStanding): EndingByHand | undefined =>
+    agent.status === "stopping" || agent.status === "dismissing" ? agent.status : undefined;
+
+// A person already ended this turn and it's unwinding. Narrower than `turnInFlight`, which also covers turns nobody
+// ended.
+export const endingByHand = (agent: AgentStanding): boolean => endingOf(agent) !== undefined;
+
+// A turn actually producing something, as a card's readouts mean it: `landing` is in flight for the hands-off guards
+// but spends no model, and its `startedAt` belongs to the turn before it, so an elapsed clock would be someone else's.
+// A turn a person already ended produces nothing more either: its readout is the ending itself (the card's chip, the
+// chat's line), not the step it was on under a clock still counting, which reads as a Stop that did not take.
+export const turnWorking = (agent: AgentStanding): boolean => turnInFlight(agent) && agent.status !== "landing" && !endingByHand(agent);
+
+// The browser's copy of the daemon's `writing` guard (agents-registry.ts); exists for Land, where typing vs.
+// parked matters (everything else treats them alike). `stopping` and `resuming` are excluded because the provider
+// isn't producing anything then; the two sides must stay in step or the UI offers a press the daemon refuses.
+export const writingNow = (agent: AgentStanding): boolean => agent.status === "running" || agent.status === "starting";
+
+// "Blocked on you": the agent cannot proceed (or has failed) until the user acts. Not the same as unread.
+// `stopped`/`interrupted` leave a half-written worktree only a new message can carry forward; `stopping` is
+// counted the moment the press lands rather than once the unwind finishes, since it settles in the same lane
+// either way; `failed` is the same kind of dead end one step earlier, before a worktree existed. A spent allowance
+// counts until something is booked to carry it on (limitScheduled): a resend at the reset, or a move now.
+const BLOCKING_ENDINGS: ReadonlySet<AgentStatus | ClientAgentStatus> = new Set(["error", "interrupted", "stopping", "stopped", "failed"]);
+
+// A land that broke and still stands: its work is stuck on the branch, whatever the turn after it did, so the card is
+// the reader's to look at. Not while a turn or a land is under way, which ends in another land of its own.
+export const landBroken = (agent: AgentStanding): boolean => agent.landFailure !== undefined && !turnInFlight(agent);
+
+export const blocked = (agent: AgentStanding): boolean =>
+    limitScheduled(agent)
+        ? false
+        : agent.attention.plan ||
+          agent.attention.question ||
+          agent.attention.permission ||
+          agent.attention.capability ||
+          agent.attention.conflict ||
+          // A need outlives its turn (docs/architecture/needs.md): a conversation still running carries on beside it
+          // and stays in Active, one that stopped is waiting on nothing but the answer.
+          (agent.attention.need === true && agent.status !== "running") ||
+          landBroken(agent) ||
+          heldByPrompt(agent) ||
+          BLOCKING_ENDINGS.has(agent.status);
+
+// The half of `blocked` that is literally waiting on an answer (plan, question, permission, capability), narrower
+// than `blocked`: dead ends (a failed turn, an unlandable conflict) want looking at but owe the user nothing, so
+// ending the agent loses no answer.
+export const awaitingUser = (agent: AgentStanding): boolean =>
+    agent.attention.plan || agent.attention.question || agent.attention.permission || agent.attention.capability || agent.status === "awaiting";
+
+// An ask only the owner may answer: a plan to approve, a permission, a setup, a credential release, a hand-off to a
+// browser or terminal (a bare `awaiting`), or a refused land only their own commit clears. The parent a child agent
+// works for can answer its question (subagents/children.ts) and hears how its turns end, but none of these, so these
+// are what reach the reader from a child whatever its parent is doing (callsOwner).
+export const onlyOwnerCanAnswer = (agent: AgentStanding): boolean =>
+    agent.attention.plan ||
+    agent.attention.permission ||
+    agent.attention.capability ||
+    agent.attention.credential ||
+    agent.attention.need === true ||
+    (agent.status === "awaiting" && !agent.attention.question) ||
+    ((agent.attention.conflict || agent.status === "conflict") && conflictIsYours(agent));
+
+// Whether a child agent's stop is news its parent has already had. Every ending of a turn the parent started reaches
+// the parent (subagents/child-report.ts: a parked `wait` takes it, or it wakes the parent like any wake), so a parent
+// that moved after the child stopped (ran a turn, landed) heard it, and its own ending is the account the reader gets:
+// an orchestrator that worked around three spent allowances and landed is done, not stuck. Only a turn's ending
+// counts. A question is still parked and waits for an answer whoever has moved since, and a land refused or broken
+// leaves work stuck on the child's branch that no report settles. A turn a person ran in the child's own chat is never
+// reported to the parent, and it ends after the parent's last move, so it still reads as unheard here.
+// `updatedAt` is the clock on both sides: a rename keeps it (agents-registry), and reading does not move it.
+export const heardByParent = (child: AgentStanding & { readonly updatedAt: number }, parentAt: number): boolean =>
+    BLOCKING_ENDINGS.has(child.status) &&
+    // Still unwinding: its ending has not reached anyone yet.
+    child.status !== "stopping" &&
+    // Booked to run again by itself: not over, whatever its parent made of the pause.
+    !limitScheduled(child) &&
+    !child.attention.question &&
+    !child.attention.conflict &&
+    !landBroken(child) &&
+    child.updatedAt < parentAt;

package/src/models/agent-starter.ts

@@ -0,0 +1,26 @@
+// Who started a conversation when it was not a person, read off the summary's `startedBy` (the daemon's
+// auth/principal.ts writes these prefixes). Moved here from the editor's ownership.ts (2026-10-16), which re-exports it,
+// because which card a child agent rides under (models/agent-lanes.ts) is the daemon's count too.
+
+// A starter that is not a person: a program holding a control token, or the conversation that spawned this one.
+export type StarterLook = { readonly kind: "token"; readonly label: string } | { readonly kind: "child"; readonly parent: string };
+
+const TOKEN_PREFIX = "token:";
+const CHILD_PREFIX = "agent:";
+
+export const starterLook = (startedBy: string | undefined): StarterLook | undefined => {
+    if (startedBy?.startsWith(TOKEN_PREFIX) === true) {
+        return { kind: "token", label: startedBy.slice(TOKEN_PREFIX.length) };
+    }
+    if (startedBy?.startsWith(CHILD_PREFIX) === true) {
+        return { kind: "child", parent: startedBy.slice(CHILD_PREFIX.length) };
+    }
+    return undefined;
+};
+
+// The conversation that spawned this one, when one did. A fact apart from whose it is: a child inherits its parent's
+// owner, so on the reader's own work an ownership mark would never get to say it.
+export const parentOf = (startedBy: string | undefined): string | undefined => {
+    const look = starterLook(startedBy);
+    return look?.kind === "child" ? look.parent : undefined;
+};

package/src/netd/generated/netd-wire.json

@@ -648,7 +648,8 @@
   },
   "headers": [
     "x-intentic-preview",
-    "x-intentic-preview-unreachable"
+    "x-intentic-preview-unreachable",
+    "x-intentic-listener"
   ],
   "toNode": {
     "$defs": {

package/src/netd/generated/wire.ts

@@ -41,7 +41,7 @@ export type NetdAnswer = { "answer": "sync", generations: Array<number | null>,
  * Request headers only netd sets on what it forwards to Node; it strips them from everything arriving outside.
  * Exported as a literal type, so a Node constant naming one that drifts from this spelling fails to compile.
  */
-export type NetdHeader = "x-intentic-preview" | "x-intentic-preview-unreachable";
+export type NetdHeader = "x-intentic-preview" | "x-intentic-preview-unreachable" | "x-intentic-listener";
 
 /**
  * A question Node asks netd.

package/src/policy/persona-capability.ts

@@ -0,0 +1,57 @@
+// WHETHER A PERSONA LETS A TURN ACT THROUGH ONE CONNECTED CAPABILITY. Pure and shared, because the daemon mounts a turn's
+// tools on this answer (personas/personas.ts `turnPersona`) and the Sandbox ▸ Map view draws who reaches what from it,
+// and two implementations would disagree at exactly the boundary that matters.
+
+// The two fields of a connection the rule reads; structural, so neither side has to hand over its own record type.
+export interface CapabilityRef {
+    readonly id: string;
+    readonly kind: string;
+}
+
+// The persona's shelves the rule reads, fully resolved (PersonaPowersSchema's defaults applied): a list absent means
+// every connection of its kind, an empty one none.
+export interface PersonaShelves {
+    readonly sandbox: boolean;
+    readonly delegate: boolean;
+    readonly connectors?: readonly string[] | undefined;
+    readonly devices?: readonly string[] | undefined;
+    readonly mcp?: readonly string[] | undefined;
+}
+
+/** The kinds that are someone signed in: a site account, and the identity whose browser holds every account born of it. */
+export const isSignedInAccount = (kind: string): boolean => kind === "browser" || kind === "identity";
+
+const listed = (list: readonly string[] | undefined, id: string): boolean => list === undefined || list.includes(id);
+
+/**
+ * Whether a persona carrying these accounts (its `capabilities`) and these shelves may act through a capability. A kind
+ * absent from the switch (an agent runtime, a devops entry, a VPN) passes untouched, so a new kind is never silently
+ * denied.
+ */
+export const personaAllowsCapability = (capability: CapabilityRef, accounts: readonly string[], shelves: PersonaShelves): boolean => {
+    switch (capability.kind) {
+        // The signed-in browsers: the persona's own `capabilities` list, and the field that predates the shelves. Granting
+        // an account (`reddit-work`) grants its hands; granting the identity itself grants the someone.
+        case "browser":
+        case "identity":
+            return accounts.includes(capability.id);
+        // Connector credentials reach the shell; an ungranted id keeps its env vars out of the turn entirely.
+        case "cli":
+            return listed(shelves.connectors, capability.id);
+        // A phone is one of the owner's own devices, on the same shelf as their computers.
+        case "device":
+        case "phone":
+            return listed(shelves.devices, capability.id);
+        case "mcp":
+            return listed(shelves.mcp, capability.id);
+        // Making sandboxes on the owner's account is administering what this one runs beside: the sandbox shelf.
+        case "fleet":
+            return shelves.sandbox;
+        // Another of the owner's sandboxes sits on the devices list beside their computers, picked one by one, and handing
+        // it a task is delegating, as spawning a subagent is.
+        case "link":
+            return shelves.delegate && listed(shelves.devices, capability.id);
+        default:
+            return true;
+    }
+};