toolroll 0.9.67 → 0.9.68

package/dist/builder.js

@@ -74,7 +74,7 @@ import { captureParkEvidence, captureTerminalDiff, captureBaseTree, evidenceRoot
 import { attemptKeyOf, closeRunQuestions, noteOpenTool, recordAgentTurn } from "./agent-board.js";
 import { openStatusFile, pulseAgentBoard, removeStatusFile, statusBrief } from "./agent-pulse.js";
 import { withAgentTurns } from "./agent-turns.js";
-import { PROOF_LIMITS, parseProof, serializeProof, adjudicate, artifactManifestOnly, sameDiffStatFacts } from "./proof.js";
+import { PROOF_LIMITS, parseProof, serializeProof, adjudicate, sameDiffStatFacts } from "./proof.js";
 import { parseHandoffArtifact } from "./contracts/handoff.js";
 import { captureReviewContext } from "./review-context.js";
 import { authoritySnapshotDigest, classifyRevisionAuthority, isMilestoneRegression, milestonesOf, parseExecutionPlanDocument, parsePlanRevisionProposal, parseProgressSnapshot, renderExecutionPlanDocument, PROGRESS_LIMITS, REVISION_LIMITS, } from "./plan.js";
@@ -369,7 +369,7 @@ export function proveApprovedProfile(scope, given) {
  * that forgot one is exactly the caller this is protecting against.
  */
 export async function build(store, request) {
-    const { taskId, taskRef, runner, worktree, branch, now, permissionMode = "auto", skipPermissions = false, provider = "claude", model, maxTurns = DEFAULT_MAX_TURNS, timeoutMs = DEFAULT_BUILD_TIMEOUT_MS, agent, git: givenGit = run, } = request;
+    const { taskId, taskRef, runner, worktree, branch, now, permissionMode = "auto", skipPermissions = false, provider = "claude", maxTurns = DEFAULT_MAX_TURNS, timeoutMs = DEFAULT_BUILD_TIMEOUT_MS, agent, git: givenGit = run, } = request;
     // The plane's own git on this build's checkout runs hardened, and never where the checkout's config names a command.
     const git = buildCheckoutGit(givenGit, worktree, store.getWorktree(worktree)?.repo ?? null);
     const scope = store.getScope(taskId);
@@ -1527,7 +1527,7 @@ export async function settleProviderOutcome(captured, result) {
         }
         catch { /* The commit gate still excludes it. */ }
     }
-    const { store, request, agent, git, worktree, branch, baseRevision, taskId, taskRef, runner, provider, scope, effective, answers, timeoutMs, root, mailbox, done, proof, clock } = captured;
+    const { store, request, agent, git, worktree, branch, baseRevision, taskId, taskRef, runner, provider, scope, effective, answers, timeoutMs, root, mailbox, done, clock } = captured;
     // THE STOP FENCE after the provider (v52): a stop recorded while the
     // agent ran ends the attempt HERE, before any handoff is read, any park
     // sealed, or any commit made — whatever the process wrote is preserved
@@ -3534,29 +3534,6 @@ async function stripEvidenceImages(git, worktree) {
     const rest = await git(GIT, ["--no-optional-locks", "diff", "--cached", "--quiet"], { cwd: worktree });
     return { ok: true, notice: evidenceImagesNotice(images), staged: rest.code !== 0 };
 }
-/**
- * `claude --output-format json` returns an envelope: the result is the
- * summary, and the session id is what lets a malformed park be repaired by
- * resuming the conversation that produced it instead of paying for a new one.
- */
-function envelope(stdout) {
-    try {
-        const parsed = JSON.parse(stdout);
-        return {
-            summary: typeof parsed.result === "string" && parsed.result.trim() !== ""
-                ? parsed.result.trim()
-                : "unattended build",
-            ...(typeof parsed.session_id === "string" && parsed.session_id !== ""
-                ? { sessionId: parsed.session_id }
-                : {}),
-        };
-    }
-    catch {
-        // An agent that printed something unparseable still did work — and a
-        // session nobody can name simply cannot be resumed.
-        return { summary: "unattended build" };
-    }
-}
 /**
  * What a non-zero agent exit means, in words a person can act on: the
  * harness's own result line names the ending (a turn ceiling, an error

package/dist/canonical-json.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Deterministic JSON for digests and equality. These bytes are sealed into approvals and stored digests, so neither
+ * function may change its output for any input. The two differ on purpose and must stay distinct:
+ *
+ * - `canonicalJson` drops object keys whose value is undefined and returns JSON.stringify's own answer for a bare
+ *   value (an undefined array element therefore renders as nothing: `[,1]`).
+ * - `canonicalJsonUndefinedAsNull` keeps every key and renders an undefined (or otherwise unserializable) value as
+ *   `null` — the planner contract's bytes.
+ *
+ * Both sort object keys by UTF-16 code units and keep arrays in order.
+ */
+export declare function canonicalJson(value: unknown): string;
+/** Stable JSON for hashing and equality only — no filling, no trimming; undefined reads as null. */
+export declare function canonicalJsonUndefinedAsNull(value: unknown): string;

package/dist/canonical-json.js

@@ -0,0 +1,36 @@
+/**
+ * Deterministic JSON for digests and equality. These bytes are sealed into approvals and stored digests, so neither
+ * function may change its output for any input. The two differ on purpose and must stay distinct:
+ *
+ * - `canonicalJson` drops object keys whose value is undefined and returns JSON.stringify's own answer for a bare
+ *   value (an undefined array element therefore renders as nothing: `[,1]`).
+ * - `canonicalJsonUndefinedAsNull` keeps every key and renders an undefined (or otherwise unserializable) value as
+ *   `null` — the planner contract's bytes.
+ *
+ * Both sort object keys by UTF-16 code units and keep arrays in order.
+ */
+export function canonicalJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(",")}]`;
+    if (value !== null && typeof value === "object") {
+        const entries = Object.entries(value)
+            .filter(([, v]) => v !== undefined)
+            .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+            .map(([k, v]) => `${JSON.stringify(k)}:${canonicalJson(v)}`);
+        return `{${entries.join(",")}}`;
+    }
+    return JSON.stringify(value);
+}
+/** Stable JSON for hashing and equality only — no filling, no trimming; undefined reads as null. */
+export function canonicalJsonUndefinedAsNull(value) {
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJsonUndefinedAsNull).join(",")}]`;
+    if (value !== null && typeof value === "object") {
+        const body = value;
+        return `{${Object.keys(body)
+            .sort()
+            .map(key => `${JSON.stringify(key)}:${canonicalJsonUndefinedAsNull(body[key])}`)
+            .join(",")}}`;
+    }
+    return JSON.stringify(value) ?? "null";
+}

package/dist/chat-actions.js

@@ -16,7 +16,6 @@ import { changeKnowledge, knowledgeVersion, knowledgeView, } from "./project-kno
 import { passwordlessSessionFor, approve, authenticateApprover, describeScope, scopeAuthorityOf, freshnessFor, spendingOnlyOnSuccess, ssoNowAvailable, withFreshness, } from "./scope.js";
 import { readVerifiedArtifact, scanForSecrets } from "./evidence.js";
 import { readAuthModeStrict } from "./keys.js";
-import { parseProof } from "./proof.js";
 import { acceptAndCompleteAsOperator, assignmentOf } from "./assignment.js";
 import { getDecision, recordDecision, retireDecision } from "./project-memory.js";
 import { resumeTaskStop, taskControlOf } from "./task-control.js";
@@ -26,7 +25,7 @@ import { saveScript, scriptDigest, validateScript } from "./flow-scripts.js";
 import { addCardToFlow, advanceFlows, cancelFlowCard, crossProjectProblem, decideFlowCard, flowCardHref, flowCardText, flowDefinitionOf, moveCardInFlow } from "./flow-engine.js";
 import { chooseFlowCard, flowPersonOf } from "./flow-send.js";
 import { assignFlowCard, commentOnFlowCard, flowPeople, mentionsIn, watchFlowCard } from "./flow-people.js";
-import { addFlowTriggerTo, describeTrigger, readLinearKey, removeFlowTrigger, scheduleFromWords, takesDeliveries, triggerConfigOf, validateTriggerConfig } from "./flow-triggers.js";
+import { addFlowTriggerTo, describeTrigger, readLinearKey, removeFlowTrigger, takesDeliveries, triggerConfigOf, validateTriggerConfig } from "./flow-triggers.js";
 import { describeSchedule, parseSchedule } from "./flow-schedule.js";
 import { dirname } from "node:path";
 import { handleOf, parseSoul, SOUL_CHARS, SUBAGENT_TEMPLATES, subagentLabel } from "./subagents.js";

package/dist/chat-admission.d.ts

@@ -0,0 +1,19 @@
+import type { ChatBinding, ChatState } from "./chat-delivery-state.js";
+import type { ChatEventBody } from "./contracts/chat-content.js";
+import type { ChatApp } from "./contracts/flow.js";
+/**
+ * Whether a received message or tap, already proved to come from this app, may be queued — and under which binding.
+ * A room (any conversation that isn't a direct message) is taken only while it follows a conversation, for the words
+ * that make it follow one, or when it feeds a flow (v89: anyone's message then, as a card with no say over anything).
+ * A pairing message comes only from someone unpaired, in a direct message; everything else only from a live paired
+ * member in their own conversation or a followed room. Null when it is not taken.
+ */
+export declare function admitChatEvent(state: ChatState, app: ChatApp, installation: string, event: {
+    kind: "message" | "pair" | "action";
+    member: string;
+    channel: string;
+    isRoom: boolean;
+    payload: ChatEventBody;
+}): {
+    binding: ChatBinding | null;
+} | null;

package/dist/chat-admission.js

@@ -0,0 +1,22 @@
+import { channelInbox } from "./chat-inbox.js";
+import { roomCommand } from "./chat-rooms.js";
+/**
+ * Whether a received message or tap, already proved to come from this app, may be queued — and under which binding.
+ * A room (any conversation that isn't a direct message) is taken only while it follows a conversation, for the words
+ * that make it follow one, or when it feeds a flow (v89: anyone's message then, as a card with no say over anything).
+ * A pairing message comes only from someone unpaired, in a direct message; everything else only from a live paired
+ * member in their own conversation or a followed room. Null when it is not taken.
+ */
+export function admitChatEvent(state, app, installation, event) {
+    const { kind, member, channel, isRoom, payload } = event;
+    const words = "text" in payload ? payload.text ?? "" : "";
+    const inbox = isRoom && kind === "message" ? channelInbox(state.store, app, installation, channel, words) : { watched: false, command: false };
+    const roomish = isRoom && (state.room(installation, channel) !== null || (kind === "message" && roomCommand(words) !== null) || inbox.watched || inbox.command);
+    if (isRoom && !roomish)
+        return null;
+    const binding = state.bindingFor(installation, member);
+    const open = inbox.watched && !inbox.command;
+    if (kind === "pair" ? !!binding || isRoom : !open && (!binding || !state.live(binding) || (binding.channel !== channel && !roomish)))
+        return null;
+    return { binding };
+}

package/dist/chat-channel.js

@@ -9,7 +9,7 @@ import { LEAD_TOOL_SCHEMAS } from "./lead-tools.js";
 import { verifyApproverStanding } from "./principal.js";
 import { canonicalProject } from "./project.js";
 import { phoneText, projectLabel } from "./telegram-status.js";
-import { CHAT_CONTROLS, chatControlHref, chatResultHref, isChatControl, } from "./chat-controls.js";
+import { CHAT_CONTROLS, chatControlHref, isChatControl, } from "./chat-controls.js";
 import { CHAT_TASK_ACTIONS, isChatTaskAction } from "./chat-task-actions.js";
 export function channelRepos(store, approver, registry) {
     const seen = new Set();

package/dist/chat-delivery.js

@@ -23,7 +23,6 @@ import { phoneText, PHONE_HELP, phoneCommand, phoneStatus, phoneTaskView, phoneT
 import { applyRoomInbound, conversationRow, roomCardApprover, roomCommand, roomGrantAllowed, roomMessagesAfter, roomMessageText, teamDomain } from "./chat-rooms.js";
 import { isTelegramProgressNotification, proposalTaskOf } from "./store.js";
 import { isShotsKind, resultShotsFor } from "./result-shots.js";
-import { CHAT_APP_NAMES } from "./flow-triggers.js";
 import { answersPrompt, applyDecideFeedback, applyDecideTap, decideFallbackLink, decideOffer, decideTargetOf, hasLiveDecideTokens, linksFor, mergedText, mintDecideButtons, offerFingerprint, openPromptFor, recordChatMerge } from "./chat-decide.js";
 import { mergePullRequest } from "./pull-request-flow.js";
 import { attentionSubjectOf, neverHeld, watchedPing } from "./agent-board.js";

package/dist/chat-follow.d.ts

@@ -0,0 +1,17 @@
+/** A pause that ends early, and quietly, when `signal` aborts. */
+export declare const abortablePause: (signal: AbortSignal) => (ms: number) => Promise<void>;
+/**
+ * Works the queue while this connection stays the current, leased one: each pass takes in saved events, plans room
+ * messages, delivers one part and plans notifications (when they are on), checking it is still current between steps.
+ * A pass waits while the connection isn't ready (offline, or the provider asked to retry later).
+ */
+export declare function workChatQueue(steps: {
+    same: () => boolean;
+    ready: () => boolean;
+    pause: (ms: number) => Promise<void>;
+    notifications: () => boolean;
+    process: () => Promise<unknown>;
+    rooms: () => Promise<unknown>;
+    deliver: () => Promise<unknown>;
+    notify: () => Promise<unknown>;
+}): Promise<void>;

package/dist/chat-follow.js

@@ -0,0 +1,32 @@
+/** The loop every hosted chat connection (Slack, Discord, Teams) runs over its saved queue. */
+import { setTimeout as sleep } from "node:timers/promises";
+/** A pause that ends early, and quietly, when `signal` aborts. */
+export const abortablePause = (signal) => async (ms) => {
+    try {
+        await sleep(ms, undefined, { signal });
+    }
+    catch {
+        /* shutdown */
+    }
+};
+/**
+ * Works the queue while this connection stays the current, leased one: each pass takes in saved events, plans room
+ * messages, delivers one part and plans notifications (when they are on), checking it is still current between steps.
+ * A pass waits while the connection isn't ready (offline, or the provider asked to retry later).
+ */
+export async function workChatQueue(steps) {
+    while (steps.same()) {
+        if (!steps.ready()) {
+            await steps.pause(1000);
+            continue;
+        }
+        await steps.process();
+        if (steps.same())
+            await steps.rooms();
+        if (steps.same())
+            await steps.deliver();
+        if (steps.same() && steps.notifications())
+            await steps.notify();
+        await steps.pause(1000);
+    }
+}

package/dist/chat-messages.js

@@ -8,7 +8,6 @@
  *
  * Imports the store's types only (no runtime cycle): the store builds its chats on it.
  */
-import { join } from "node:path";
 import { neverHeld, watchedPing } from "./agent-board.js";
 import { ChatCore } from "./chat-core.js";
 import { readChatMessageBody, readChatPart, savedChatEventBody, savedChatPart } from "./contracts/chat-content.js";

package/dist/chat-settings-page.d.ts

@@ -0,0 +1,23 @@
+import type { Store } from "./store.js";
+import { type Html } from "./html.js";
+import { type ChatIdentity } from "./chat-delivery-state.js";
+export type ChatSettingsOptions = {
+    code?: string;
+    problem?: string;
+    now?: Date;
+    who?: string;
+};
+/** What differs between the Slack and Discord settings pages; everything else is one page. */
+export type ChatSettingsPage = {
+    provider: "slack" | "discord";
+    label: string;
+    credentials: ChatIdentity | null;
+    /** How to create the app, shown before it is connected. */
+    setup: Html;
+    /** The connect form's fields around the password. */
+    connect: (password: Html) => Html;
+    /** The "Access and setup" paragraphs. */
+    access: Html;
+};
+/** Settings → Slack or Discord: connect the app once, then each teammate pairs their own account. */
+export declare function chatSettingsHtml(store: Store, dir: string, options: ChatSettingsOptions, page: ChatSettingsPage): Html;

package/dist/chat-settings-page.js

@@ -0,0 +1,41 @@
+import { loadPrimary } from "./webhooks.js";
+import { html, postForm } from "./html.js";
+import { ChatState } from "./chat-delivery-state.js";
+/** Settings → Slack or Discord: connect the app once, then each teammate pairs their own account. */
+export function chatSettingsHtml(store, dir, options, page) {
+    const { provider, label, credentials } = page, state = new ChatState(store, provider), bindings = credentials ? state.bindings(credentials.installation).filter(one => state.live(one)) : [], binding = options.who === undefined ? null : bindings.find(one => one.approver === options.who) ?? null, others = bindings.length - (binding === null ? 0 : 1);
+    const runtime = credentials ? state.runtime(credentials.installation) : null;
+    const now = options.now ?? new Date(), live = runtime &&
+        runtime.leaseUntil !== null &&
+        runtime.leaseUntil > now.toISOString() &&
+        runtime.connected;
+    const password = html `<label>Your Toolroll password<input style="min-height:44px" type="password" name="password" autocomplete="current-password" required></label>`;
+    const post = (action, content) => postForm(`/settings/${provider}/${action}`, content, { attrs: { class: "card" } });
+    const parts = [];
+    if (!credentials) {
+        parts.push(html `<p>Manage projects and review results in a private ${label} conversation.</p>`, page.setup, post("connect", page.connect(password)));
+    }
+    else {
+        parts.push(html `<p><strong>${credentials.workspace}</strong> · ${live ? "Connected" : "Waiting for connection"}</p>`);
+        if (runtime?.problem)
+            parts.push(html `<p role="status">${String(runtime.problem)}</p>`);
+        if (!live && !runtime?.problem)
+            parts.push(html `<p>Keep the Toolroll worker running to receive ${label} messages.</p>`);
+        if (options.code) {
+            parts.push(html `<h2>Pair your account</h2><p>Send this in a direct message to your Toolroll ${label} app. It expires in 10 minutes.</p>`, html `<label>Pairing message<input type="text" readonly value="pair ${options.code}" autocomplete="off" style="width:100%;max-width:100%;font-size:14px;min-height:44px"></label>`, html `<a class="button-link" style="min-height:44px;white-space:nowrap" href="/settings/${provider}">Check connection</a>`);
+        }
+        else if (binding && state.live(binding)) {
+            const { pending, dropped: failed } = state.partCounts(binding.id);
+            parts.push(html `<p>Your ${label} account is paired.${others ? ` ${others} teammate${others === 1 ? " is" : "s are"} paired too.` : ""}${pending ? ` ${pending} replies waiting to send.` : ""}${failed ? ` ${failed} replies could not be delivered. Open the saved chat to recover them.` : ""}</p>`, html `<p>Try “What needs my attention?” or “Show the evidence for the latest result.”</p>`, html `<p><a href="/chat">Open saved chat</a></p>`, loadPrimary(process.env, dir) === provider
+                ? html `<p>Task updates are sent here.</p>`
+                : post("alerts", html `<button type="submit">Send task updates here</button>`));
+        }
+        else {
+            parts.push(post("pair", html `<h2>Pair your account</h2><p>Your paired ${label} account can read your connected projects and confirm proposed changes. Password approvals still open in Toolroll.${others ? ` ${others} teammate${others === 1 ? " is" : "s are"} already paired.` : ""}</p>${password}<button type="submit">Create pairing code</button>`));
+        }
+        if (binding && state.live(binding) && !options.code)
+            parts.push(post("unpair", html `${password}<p class="meta">Unpairing ends every open button in your chat. Teammates are unaffected.</p><button type="submit">Unpair my account</button>`));
+        parts.push(html `<details><summary>Connection settings</summary>${post("disconnect", html `${password}<button type="submit">Disconnect ${label}</button>`)}</details>`);
+    }
+    return html `<section style="max-width:42rem;overflow-wrap:anywhere"><p><a href="/settings">Settings</a></p><h1>${label}</h1>${options.problem ? html `<p class="problem" role="alert">${options.problem}</p>` : ""}${parts}<details><summary>Access and setup</summary>${page.access}</details></section>`;
+}

package/dist/claim.js

@@ -749,7 +749,7 @@ export const MAX_STRIKES = 3;
 function sealInterrupted(store, leaseId, args) {
     const { runId, taskId, stopRun, now } = args;
     const db = store.handle;
-    const run = openAttempt(store, leaseId, runId, "an interruption");
+    openAttempt(store, leaseId, runId, "an interruption");
     // A lease the world moved past still ends its run as interrupted — that IS the honest ending — touching no task state.
     const fenced = !releaseAs(store, leaseId, "interrupted", now);
     if (args.message !== undefined && args.message.trim() !== "") {
@@ -797,7 +797,7 @@ function sealInterrupted(store, leaseId, args) {
 function sealHandBack(store, leaseId, args) {
     const { runId, taskId, now } = args;
     const db = store.handle;
-    const run = openAttempt(store, leaseId, runId, "a hand-back");
+    openAttempt(store, leaseId, runId, "a hand-back");
     // A lease the world moved past still ends its run as interrupted — that IS the honest ending — touching no task state.
     const fenced = !releaseAs(store, leaseId, "interrupted", now);
     if (args.message.trim() !== "")
@@ -974,7 +974,6 @@ const PLAN_BACKOFF_MS = [60_000, 2 * 60_000, 4 * 60_000];
  */
 function sealPlan(store, leaseId, args) {
     const { runId, taskId, plan, now } = args;
-    const db = store.handle;
     // The ingestion record (contract handoff, task 1) is composed here from
     // the filed terms and the drafted plan; its file and row land inside the
     // transaction below, only after the stale-source check admits the draft.
@@ -1199,7 +1198,7 @@ function describeSourceDrift(source, current) {
  */
 function sealRevision(store, leaseId, args) {
     const { runId, taskId, taskRef, revision, now } = args;
-    const run = openAttempt(store, leaseId, runId, "a plan revision", "builder");
+    openAttempt(store, leaseId, runId, "a plan revision", "builder");
     const stopped = interruptIfStopped(store, { leaseId, runId, taskId, now });
     if (stopped !== null)
         return { ok: false, reason: "stopped" };
@@ -1249,7 +1248,6 @@ function sealRevision(store, leaseId, args) {
  */
 function sealPlanFailure(store, leaseId, args) {
     const { runId, taskId, failure: kind, message, now } = args;
-    const db = store.handle;
     const run = openAttempt(store, leaseId, runId, "a failure", "planner");
     const stopped = interruptIfStopped(store, { leaseId, runId, taskId, now });
     if (stopped !== null)
@@ -1331,7 +1329,6 @@ function sealPlanFailure(store, leaseId, args) {
  */
 function sealScout(store, leaseId, args) {
     const { runId, taskId, report, now } = args;
-    const db = store.handle;
     const run = openAttempt(store, leaseId, runId, "a report", "scout");
     const stopped = interruptIfStopped(store, { leaseId, runId, taskId, now });
     if (stopped !== null)

package/dist/claude-print.d.ts

@@ -0,0 +1,12 @@
+import type { ExecResult, run } from "./exec.js";
+export type CommandRunner = (file: string, args: readonly string[], options: Parameters<typeof run>[2]) => Promise<ExecResult>;
+/** No tools, no permission prompts, no MCP servers, nothing kept: a `claude -p` call that can only answer. */
+export declare const CLAUDE_NO_TOOLS_ARGS: readonly string[];
+/** `--model <model>`, or nothing for the CLI's own default. */
+export declare const claudeModelArgs: (model: string) => string[];
+/** What a failed call's output says when this computer's Claude isn't signed in. */
+export declare const CLAUDE_SIGNED_OUT: RegExp;
+/** `claude -p --output-format json` stdout as its one object, or null. */
+export declare function claudeJsonBody(stdout: string, cap: number): Record<string, unknown> | null;
+/** Runs `work` in a fresh temporary folder named `<prefix>…`, removed afterwards whatever happens. */
+export declare function inScratchDir<T>(prefix: string, work: (dir: string) => Promise<T>): Promise<T>;

package/dist/claude-print.js

@@ -0,0 +1,34 @@
+/**
+ * The parts every bare `claude -p` call shares: a throwaway working folder, the flags that leave it with no tools,
+ * no MCP servers and no saved session, and reading its one JSON reply. Each caller still builds its own argv around
+ * these, in its own order.
+ */
+import { Buffer } from "node:buffer";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { strictJsonParse } from "./converse.js";
+/** No tools, no permission prompts, no MCP servers, nothing kept: a `claude -p` call that can only answer. */
+export const CLAUDE_NO_TOOLS_ARGS = [
+    "--safe-mode", "--no-session-persistence", "--tools", "", "--permission-mode", "dontAsk",
+    "--permission-prompts", "none", "--strict-mcp-config", "--mcp-config", '{"mcpServers":{}}',
+];
+/** `--model <model>`, or nothing for the CLI's own default. */
+export const claudeModelArgs = (model) => (model === "default" ? [] : ["--model", model]);
+/** What a failed call's output says when this computer's Claude isn't signed in. */
+export const CLAUDE_SIGNED_OUT = /not logged in|login|authenticat/i;
+/** `claude -p --output-format json` stdout as its one object, or null. */
+export function claudeJsonBody(stdout, cap) {
+    const parsed = strictJsonParse(Buffer.from(stdout, "utf8"), cap, 12);
+    return parsed.ok && typeof parsed.value === "object" && parsed.value !== null && !Array.isArray(parsed.value) ? parsed.value : null;
+}
+/** Runs `work` in a fresh temporary folder named `<prefix>…`, removed afterwards whatever happens. */
+export async function inScratchDir(prefix, work) {
+    const dir = mkdtempSync(join(tmpdir(), prefix));
+    try {
+        return await work(dir);
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+}

package/dist/cli-http.d.ts

@@ -3,7 +3,6 @@ import type { Store } from './store.js';
 import type { Principal } from './operate.js';
 import { type RemoteCommandLookup } from './remote-command.js';
 import { type Admission, type BudgetLimit } from './request-budget.js';
-import type { SessionRunner } from './session-remote.js';
 /**
  * `POST /api/cli` (remote CLI, Phase 1): a teammate's laptop sends the argv it would have run locally, and the central
  * server runs that same command as that person. There is no per-resource API here and no second policy: the transport
@@ -12,10 +11,6 @@ import type { SessionRunner } from './session-remote.js';
  *
  * Only `Authorization: Bearer so_…` is accepted — never a password, cookie or the owner's saved login — and a request
  * carrying a browser Origin is refused, so a page can never drive it.
- *
- * `session …` (D7) is the one command the server answers through its own owner rather than runOperateAs: native
- * session operations need the server's live coding workspace (session-remote.ts). They are admitted, budgeted and
- * refused here exactly like every other command.
  */
 /** Who a remote command runs as, and the runner: operate.ts's own types, so a change there breaks this build instead of
  * drifting. Type-only: the value is loaded lazily through `run` (operate.ts imports the server that imports this). */
@@ -50,8 +45,6 @@ export type CliHttpOptions = {
     modeOf?: RemoteCommandLookup | undefined;
     /** The token's request budget (request-budget.ts), charged once per request before its body is read. */
     admit?: ((principal: Principal) => Admission) | undefined;
-    /** Native session operations (`session …`), run by the server's session owner; absent where none is ready. */
-    session?: SessionRunner | undefined;
     store: Store;
 };
 /** Decode the request's shape and byte limits. The endpoint checks file references against its command policy. */

package/dist/cli-http.js

@@ -123,8 +123,6 @@ export async function handleCliHttp(request, response, options) {
     const parsed = cliRequest(value);
     if ('problem' in parsed)
         return reject(parsed.tooLarge ? 413 : 400, 'invalid-request', parsed.problem);
-    if (parsed.argv[0] === 'session')
-        return runSession(response, options, principal, parsed);
     const row = (options.modeOf ?? contractRow)(parsed.argv);
     if (row?.mode === 'step-up')
         return reject(403, 'step-up', STEP_UP_MESSAGE);
@@ -161,22 +159,3 @@ export async function handleCliHttp(request, response, options) {
     send(response, 200, { exitCode, stdout: out.join(''), stderr: '' });
     return true;
 }
-/** `session …`: the prompt is the request's one file; the session owner answers one session envelope on stdout. */
-async function runSession(response, options, principal, parsed) {
-    const refuse = (status, code, message) => { send(response, status, { ok: false, code, message }); return true; };
-    if (options.session === undefined)
-        return refuse(501, 'remote-unavailable', 'This server cannot run session commands. Update it, or use the console.');
-    const at = parsed.argv.indexOf('--file'), file = at < 0 ? undefined : parsed.argv[at + 1];
-    if (Object.keys(parsed.files).some(path => path !== file))
-        return refuse(400, 'invalid-request', 'Each file must name a declared input file argument.');
-    const out = [];
-    let exitCode;
-    try {
-        exitCode = await options.session(principal, parsed.argv, parsed.files, line => { out.push(`${line}\n`); });
-    }
-    catch {
-        return refuse(500, 'command-failed', 'The command stopped unexpectedly on the server. Check its state before running it again.');
-    }
-    send(response, 200, { exitCode, stdout: out.join(''), stderr: '' });
-    return true;
-}

package/dist/cli.d.ts

@@ -12,8 +12,7 @@
  */
 import { previewGithubRepo, cloneGithubRepo } from "./onboard.js";
 import { type QuickStartSeams } from "./quick-start.js";
-import { type SessionCliOptions } from "./session-cli.js";
-import { type TeamCliOptions } from "./team-cli.js";
+import { type ConnectOptions } from "./connect-cli.js";
 import { type RemoteExecOptions } from "./remote-exec.js";
 import type { UpdateCliDeps } from "./toolroll-update-cli.js";
 import type { ReleaseCliDeps } from "./release-cli.js";
@@ -47,19 +46,13 @@ type Write = (line: string) => void;
 export { HELP };
 export declare function parseArgs(argv: readonly string[]): ParseResult;
 /** The commands that operate the queue rather than report on the world. */
-/** Every verb the CLI routes OUTSIDE runOperate. Exported (with
- * OPERATE_COMMANDS) so the declared command guide's drift tests compare
- * exact sets instead of regex-reading source. "" is the no-verb report,
- * which answers as `scan`. */
-export declare const TOP_LEVEL_COMMANDS: readonly string[];
 export declare const OPERATE_COMMANDS: Set<string>;
 /** binSource exists so tests can exercise linking without depending on a build. */
 export type MainOptions = {
     binSource?: string;
     operate?: OperateOptions;
-    session?: SessionCliOptions;
-    team?: TeamCliOptions;
-    /** Injected by tests: the remote CLI's profile, fetch and output streams (defaults to `team`'s profile seams). */
+    connect?: ConnectOptions;
+    /** Injected by tests: the remote CLI's profile, fetch and output streams (defaults to `connect`'s profile seams). */
     remote?: RemoteExecOptions;
     /** Injected by tests: the gh-facing halves of `repos add-from-github` —
      * the verb's parsing, gating, and enrollment are what CLI tests prove;

package/dist/cli.js

@@ -26,9 +26,8 @@ import { parseGithubRepo, previewGithubRepo, cloneGithubRepo, isLargeRepo } from
 import { run as execRun } from "./exec.js";
 import { isBareInvocation, runQuickStart } from "./quick-start.js";
 import { COMMAND_GUIDE, SURFACE_NOTES, SURFACE_SCHEMA_VERSION } from "./surface.js";
-import { runSessionCommand, SESSION_CLI_ACTIONS } from "./session-cli.js";
-import { maybeRunTeamCommand, TEAM_CLI_ACTIONS } from "./team-cli.js";
-import { deprecationWarning } from "./deprecations.js";
+import { hasCentralProfile, maybeRunConnectCommand } from "./connect-cli.js";
+import { removedCommand, removedMessage } from "./deprecations.js";
 import { maybeRunRemoteCommand } from "./remote-exec.js";
 import { discover, inspectAll } from "./discover.js";
 import { readPulls } from "./pulls.js";
@@ -107,16 +106,6 @@ export function parseArgs(argv) {
     };
 }
 /** The commands that operate the queue rather than report on the world. */
-/** Every verb the CLI routes OUTSIDE runOperate. Exported (with
- * OPERATE_COMMANDS) so the declared command guide's drift tests compare
- * exact sets instead of regex-reading source. "" is the no-verb report,
- * which answers as `scan`. */
-export const TOP_LEVEL_COMMANDS = [
-    "", "scan", "pulls", "graph", "repos", "repos add", "repos remove", "repos add-from-github",
-    "link", "unlink", "update", "release", "contract", "skills list", "skills get", "skills install", "demo",
-    ...SESSION_CLI_ACTIONS.map(action => `session ${action}`),
-    ...TEAM_CLI_ACTIONS,
-];
 export const OPERATE_COMMANDS = new Set([
     "up",
     // Only `lead token` reaches here; the central service's lead verbs answer first.
@@ -310,21 +299,29 @@ async function dispatch(argv, write, mainOptions) {
     // hidden from help and the contract, before anything remote or local opens, changing nothing.
     if (argv[0] === "routine")
         return routinesMoved(argv, write);
+    // D5: the central team CLI and native sessions are gone; each old invocation says so and changes nothing.
+    const connectOptions = mainOptions.connect ?? mainOptions.remote;
+    const removed = removedCommand(argv, () => hasCentralProfile(connectOptions ?? {}));
+    if (removed !== null) {
+        const message = removedMessage(removed.named, removed.kind);
+        write(argv.includes("--json") ? envelopeJson({ ok: false, command: removed.named, reason: "removed", message }) : message);
+        return 2;
+    }
     // A saved API token sends commands marked remote to the central server, before anything local opens.
     // Command families below load when their command runs, so one command never pays for the others.
     if (argv[0] === 'health')
-        return (await import("./health-cli.js")).runHealthCommand(argv.slice(1), write, mainOptions.team ?? mainOptions.remote);
+        return (await import("./health-cli.js")).runHealthCommand(argv.slice(1), write, mainOptions.connect ?? mainOptions.remote);
     // This computer's own service, read here and never on a central server.
     if (argv[0] === 'doctor')
         return (await import("./doctor.js")).runDoctorCommand(argv.slice(1), write);
-    const central = await maybeRunRemoteCommand(argv, mainOptions.remote ?? mainOptions.team);
+    const central = await maybeRunRemoteCommand(argv, mainOptions.remote ?? mainOptions.connect);
     if (typeof central === "number")
         return central;
     if (central !== null)
         argv = central.local;
-    const team = await maybeRunTeamCommand(argv, write, mainOptions.team);
-    if (team !== null)
-        return team;
+    const connected = await maybeRunConnectCommand(argv, write, mainOptions.connect);
+    if (connected !== null)
+        return connected;
     if ((argv[0] === "chat" || argv[0] === "brief") && argv.includes("--local"))
         argv = argv.filter(arg => arg !== "--local");
     const [first, ...rest] = argv;
@@ -345,12 +342,6 @@ async function dispatch(argv, write, mainOptions) {
     }
     if (first === "contract")
         return runContractCommand(rest, write);
-    if (first === "session") {
-        // D5: native coding sessions are deprecated. They still run this release; each use says so once, on stderr.
-        (mainOptions.session?.stderr ?? (line => process.stderr.write(`${line}\n`)))(deprecationWarning(`session ${rest.find(arg => !arg.startsWith("-")) ?? ""}`.trim(), "session"));
-        // D7: it runs on the saved connection over /api/cli, signed in with that profile's API token.
-        return runSessionCommand(rest, write, { ...(mainOptions.remote ?? mainOptions.team), ...mainOptions.session });
-    }
     if (first === "demo")
         return runDemoCommand(rest, write);
     if (first === "skills")

package/dist/coding-provider.js

@@ -6,6 +6,7 @@ import { createContainer, currentContainment } from "./containment.js";
 import { processMayBeAlive } from "./process-liveness.js";
 import { observeProcessTree, sampleProcessTree, stopProcessTree } from "./process-tree.js";
 import { isOwnEnv } from "./names.js";
+import { sleep } from "./sleep.js";
 /** A response from the server, distinct from an ambiguous transport failure. */
 export class CodingProviderRequestError extends Error {
     code;
@@ -374,7 +375,7 @@ export function createCodexCodingProvider(options = {}) {
             const absent = () => (owned.pid === undefined || !processMayBeAlive(owned.pid, process.platform !== "win32")) && [...descendants.values()].every(({ pid, group }) => !processMayBeAlive(pid, group));
             const until = Date.now() + EXIT_GRACE_MS;
             while (!ancestryUnknown && !absent() && Date.now() < until)
-                await new Promise(resolve => setTimeout(resolve, 25));
+                await sleep(25);
             clean = clean && !ancestryUnknown && absent();
         }
         if (!clean)

package/dist/coding-workspace.js

@@ -1,6 +1,6 @@
 import { createHash, randomUUID } from 'node:crypto';
 import { mkdirSync, chmodSync, realpathSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
+import { dirname, join } from 'node:path';
 import { hostname } from 'node:os';
 import { provenDeadByBootChange } from './boot-identity.js';
 import { containerEmptiness } from './container-state.js';