@xingular/harness 1.2.0 → 1.3.1-unstable.0

package/dist/sdk/sessions/compactionCheckpoint.js

@@ -1,14 +1,14 @@
 import { renderCompactionCheckpoint } from "../prompt/compile.js";
-import { CHECKLIST_WRITE } from "../tools/checklist.js";
-import { checklistItemSchema, MAX_CHECKLIST_ITEMS } from "./contracts.js";
+import { TODO_WRITE } from "../tools/todo.js";
+import { todoItemSchema, MAX_TODO_ITEMS } from "./contracts.js";
 export const COMPACTION_CHECKPOINT_EXTENSION = 'compaction-checkpoint';
-function validatedChecklist(value) {
-    if (!Array.isArray(value) || value.length > MAX_CHECKLIST_ITEMS)
+function validatedTodo(value) {
+    if (!Array.isArray(value) || value.length > MAX_TODO_ITEMS)
         return null;
     const items = [];
     for (const valueItem of value) {
         const item = valueItem;
-        const parsed = checklistItemSchema.safeParse({
+        const parsed = todoItemSchema.safeParse({
             text: typeof item?.text === 'string' ? item.text.trim() : item?.text,
             status: item?.status
         });
@@ -22,12 +22,12 @@ function validatedChecklist(value) {
 export function compactionCheckpoint(options = {}) {
     return (pi) => {
         let goal = '';
-        let checklist = validatedChecklist(options.initialChecklist ?? []) ?? [];
+        let todo = validatedTodo(options.initialTodo ?? []) ?? [];
         let lastCompactionKey = null;
         let compacted = false;
         const reset = () => {
             goal = '';
-            checklist = validatedChecklist(options.initialChecklist ?? []) ?? [];
+            todo = validatedTodo(options.initialTodo ?? []) ?? [];
             lastCompactionKey = null;
             compacted = false;
         };
@@ -35,16 +35,16 @@ export function compactionCheckpoint(options = {}) {
             if (event.messageType !== 'user')
                 return;
             goal = event.prompt;
-            checklist = validatedChecklist(options.initialChecklist ?? []) ?? [];
+            todo = validatedTodo(options.initialTodo ?? []) ?? [];
             lastCompactionKey = null;
             compacted = false;
         });
         pi.on('tool_result', (event) => {
-            if (event.toolName !== CHECKLIST_WRITE || event.isError)
+            if (event.toolName !== TODO_WRITE || event.isError)
                 return;
-            const items = validatedChecklist(event.input.items);
+            const items = validatedTodo(event.input.items);
             if (items)
-                checklist = items;
+                todo = items;
         });
         pi.on('context', (event) => {
             const summary = event.messages.findLast((message) => message.role === 'compactionSummary');
@@ -60,7 +60,7 @@ export function compactionCheckpoint(options = {}) {
             }
             if (!compacted)
                 return;
-            const content = renderCompactionCheckpoint({ goal, checklist, planInstructions });
+            const content = renderCompactionCheckpoint({ goal, todo, planInstructions });
             if (!content)
                 return;
             return {

package/dist/sdk/sessions/continuation.d.ts

@@ -1,7 +1,7 @@
 import type { CapabilitySet } from "../capabilities/types.js";
 import type { HostSection } from "../prompt/compile.js";
 import type { Checkpoint } from "./contracts.js";
-import { type ChecklistItem } from "./contracts.js";
+import { type TodoItem } from "./contracts.js";
 import { type PendingDecision } from "./runStore.js";
 export declare const CONTINUATION_SECTION_ID = "continuation";
 /** Right after the plan section, before the variant's own sections. */
@@ -28,7 +28,9 @@ export interface Continuation {
     capabilities: CapabilitySet | null;
     stoppedAt: string | null;
     terminalReason: string | null;
-    checklist: ChecklistItem[];
+    todo: TodoItem[];
+    /** @deprecated Use `todo`; kept for one release so hosts can migrate. */
+    checklist: TodoItem[];
     /** The last work-slice handoff, when the run wrote one (PROP-0041). */
     checkpoint: Checkpoint | null;
     pending: PendingDecision[];

package/dist/sdk/sessions/continuation.js

@@ -2,7 +2,7 @@
 // own (INV-RUN-4); it says whether a run can be continued and, when the application starts a new
 // run with `continueFrom`, tells the model where the earlier one stopped.
 import { loadRun as loadCapabilities } from "../capabilities/runSnapshot.js";
-import { checklistOf, describeChecklist } from "../tools/checklist.js";
+import { todoOf, describeTodo } from "../tools/todo.js";
 import { checkpointOf, describeCheckpoint } from "../tools/checkpoint.js";
 import { isActiveStatus } from "./contracts.js";
 import { findHistory } from "./history.js";
@@ -18,7 +18,7 @@ const CONTINUATION_BUDGET = 2000;
 export function continuationOf(root, runId, sessionDir) {
     const record = findRun(root, runId);
     if (!record) {
-        return { runId, sessionId: '', status: 'missing', resumable: false, reason: 'not_found', resume: null, accountId: null, variant: null, capabilities: null, stoppedAt: null, terminalReason: null, checklist: [], checkpoint: null, pending: [], lastTool: null, unfinishedSubagents: [] };
+        return { runId, sessionId: '', status: 'missing', resumable: false, reason: 'not_found', resume: null, accountId: null, variant: null, capabilities: null, stoppedAt: null, terminalReason: null, todo: [], checklist: [], checkpoint: null, pending: [], lastTool: null, unfinishedSubagents: [] };
     }
     const events = readEvents(root, runId);
     const started = events.filter((event) => event.type === 'tool.started').at(-1);
@@ -46,7 +46,8 @@ export function continuationOf(root, runId, sessionDir) {
         capabilities,
         stoppedAt: record.endedAt,
         terminalReason: record.terminalReason,
-        checklist: checklistOf(events),
+        checklist: todoOf(events),
+        todo: todoOf(events),
         checkpoint: checkpointOf(events),
         pending: pendingDecisions(events),
         lastTool,
@@ -73,12 +74,12 @@ export function continuationBody(continuation) {
         lines.push(continuation.lastTool.finished ? `Its last tool call, ${continuation.lastTool.name}, finished.` : `Its last tool call, ${continuation.lastTool.name}, did not finish; its effect is unknown.`);
     if (continuation.checkpoint)
         lines.push('', 'The handoff it wrote when it stopped:', describeCheckpoint(continuation.checkpoint));
-    if (continuation.checklist.length)
-        lines.push('', 'Its checklist when it stopped:', describeChecklist(continuation.checklist));
+    if (continuation.todo.length)
+        lines.push('', 'Its todo list when it stopped:', describeTodo(continuation.todo));
     if (continuation.pending.length)
         lines.push('', 'Unanswered when it stopped (ask again if still needed; never assume an answer):', ...continuation.pending.map(describePending));
     if (continuation.unfinishedSubagents.length)
-        lines.push('', `Subagents that did not finish: ${continuation.unfinishedSubagents.join(', ')}. Start them again if their work is still needed.`);
+        lines.push('', `Subagents that did not finish: ${continuation.unfinishedSubagents.join(', ')}. Their conversations are saved: continue one with spawn_subagent { "continue": "<run ID>" } if its work is still needed, instead of starting it again from scratch.`);
     return lines.join('\n');
 }
 /** The dynamic section for a continuation; on a later run, the empty slot withdraws it. */

package/dist/sdk/sessions/contracts.d.ts

@@ -30,6 +30,7 @@ export declare const runEventTypeSchema: z.ZodEnum<{
     "extension.notice": "extension.notice";
     "reaction.added": "reaction.added";
     "agent.message": "agent.message";
+    "todo.updated": "todo.updated";
     "checklist.updated": "checklist.updated";
     checkpoint: "checkpoint";
     heartbeat: "heartbeat";
@@ -67,8 +68,8 @@ export declare const questionOptionSchema: z.ZodObject<{
     sketch: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type QuestionOption = z.infer<typeof questionOptionSchema>;
-/** One line of the run's checklist. The list has no ids: every update replaces all of it. */
-export declare const checklistItemSchema: z.ZodObject<{
+/** One line of the run's todo list. The list has no ids: every update replaces all of it. */
+export declare const todoItemSchema: z.ZodObject<{
     text: z.ZodString;
     status: z.ZodEnum<{
         completed: "completed";
@@ -76,8 +77,8 @@ export declare const checklistItemSchema: z.ZodObject<{
         in_progress: "in_progress";
     }>;
 }, z.core.$strict>;
-export type ChecklistItem = z.infer<typeof checklistItemSchema>;
-export declare const MAX_CHECKLIST_ITEMS = 50;
+export type TodoItem = z.infer<typeof todoItemSchema>;
+export declare const MAX_TODO_ITEMS = 50;
 export declare const MAX_CHECKPOINT_SUMMARY = 1200;
 export declare const MAX_CHECKPOINT_DONE = 20;
 export declare const MAX_CHECKPOINT_EVIDENCE = 5;
@@ -432,6 +433,16 @@ export declare const runEventPayloadSchemas: {
         agentName: z.ZodString;
         text: z.ZodString;
     }, z.core.$strip>;
+    'todo.updated': z.ZodObject<{
+        items: z.ZodArray<z.ZodObject<{
+            text: z.ZodString;
+            status: z.ZodEnum<{
+                completed: "completed";
+                pending: "pending";
+                in_progress: "in_progress";
+            }>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
     'checklist.updated': z.ZodObject<{
         items: z.ZodArray<z.ZodObject<{
             text: z.ZodString;
@@ -624,6 +635,7 @@ export declare const runEventSchema: z.ZodObject<{
         "extension.notice": "extension.notice";
         "reaction.added": "reaction.added";
         "agent.message": "agent.message";
+        "todo.updated": "todo.updated";
         "checklist.updated": "checklist.updated";
         checkpoint: "checkpoint";
         heartbeat: "heartbeat";
@@ -681,6 +693,10 @@ export interface RunRecord {
     profile?: string | null;
     /** The short name a parent gave a subagent, shown in the roster (PROP-0030). */
     title?: string | null;
+    /** The model the run used, as `provider/id`: the launch selection, then the one the session opened. */
+    model?: string | null;
+    /** The reasoning effort the run used. */
+    effort?: string | null;
 }
 export declare const runRecordSchema: z.ZodObject<{
     resumedFromRunId: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | null, string | null | undefined>>;
@@ -711,6 +727,8 @@ export declare const runRecordSchema: z.ZodObject<{
     variantVersion: z.ZodOptional<z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | null, string | null | undefined>>>;
     profile: z.ZodOptional<z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | null, string | null | undefined>>>;
     title: z.ZodOptional<z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | null, string | null | undefined>>>;
+    model: z.ZodOptional<z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | null, string | null | undefined>>>;
+    effort: z.ZodOptional<z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | null, string | null | undefined>>>;
 }, z.core.$strip>;
 /** Records written before PROP-0009 name the variant `harnessScope` and `harnessVersion`. */
 export declare function upgradeRunRecord(raw: unknown): unknown;

package/dist/sdk/sessions/contracts.js

@@ -21,6 +21,8 @@ export const runEventTypeSchema = z.enum([
     'extension.notice',
     'reaction.added',
     'agent.message',
+    'todo.updated',
+    // Written before the rename; accepted so stored run logs keep their lists. Never written now.
     'checklist.updated',
     'checkpoint',
     'heartbeat',
@@ -174,11 +176,11 @@ const extensionNoticePayload = z.object({
     text: z.string(),
     extension: z.string().optional()
 });
-/** One line of the run's checklist. The list has no ids: every update replaces all of it. */
-export const checklistItemSchema = z.object({ text: z.string().min(1).max(500), status: z.enum(['pending', 'in_progress', 'completed']) }).strict();
-export const MAX_CHECKLIST_ITEMS = 50;
-/** The whole checklist as the model last wrote it; the latest event replaces every earlier one. */
-const checklistPayload = z.object({ items: z.array(checklistItemSchema).max(MAX_CHECKLIST_ITEMS) }).strict();
+/** One line of the run's todo list. The list has no ids: every update replaces all of it. */
+export const todoItemSchema = z.object({ text: z.string().min(1).max(500), status: z.enum(['pending', 'in_progress', 'completed']) }).strict();
+export const MAX_TODO_ITEMS = 50;
+/** The whole todo list as the model last wrote it; the latest event replaces every earlier one. */
+const todoPayload = z.object({ items: z.array(todoItemSchema).max(MAX_TODO_ITEMS) }).strict();
 export const MAX_CHECKPOINT_SUMMARY = 1_200;
 export const MAX_CHECKPOINT_DONE = 20;
 export const MAX_CHECKPOINT_EVIDENCE = 5;
@@ -319,7 +321,8 @@ export const runEventPayloadSchemas = {
     'extension.notice': extensionNoticePayload,
     'reaction.added': reactionAddedPayload,
     'agent.message': agentMessagePayload,
-    'checklist.updated': checklistPayload,
+    'todo.updated': todoPayload,
+    'checklist.updated': todoPayload,
     checkpoint: checkpointPayload,
     heartbeat: heartbeatPayload,
     'artifact.added': artifactPayload,
@@ -378,7 +381,9 @@ export const runRecordSchema = z.object({
     variantScope: text.optional(),
     variantVersion: text.optional(),
     profile: text.optional(),
-    title: text.optional()
+    title: text.optional(),
+    model: text.optional(),
+    effort: text.optional()
 });
 /** Records written before PROP-0009 name the variant `harnessScope` and `harnessVersion`. */
 export function upgradeRunRecord(raw) {

package/dist/sdk/sessions/planMode.js

@@ -3,7 +3,7 @@
 // gate refuses everything else, and the instruction arrives as a context update.
 import { deliveredSnapshot } from "../prompt/compile.js";
 import { ASK_USER } from "../tools/askUser.js";
-import { CHECKLIST_WRITE } from "../tools/checklist.js";
+import { TODO_WRITE } from "../tools/todo.js";
 import { SESSION_NAME } from "../tools/sessionName.js";
 import { GET_CAPABILITIES } from "../tools/getCapabilities.js";
 import { PLAN_RESEARCH_TOOLS } from "../agents/planResearch.js";
@@ -18,7 +18,7 @@ export function normalModeTools(tools) {
     return tools.filter((name) => !QUESTION_TOOL_NAMES.has(name));
 }
 export const PLAN_READ_ONLY_TOOLS = new Set([
-    'read', 'grep', 'find', 'ls', SESSION_NAME, CHECKLIST_WRITE, ASK_USER, 'ask_user_question', GET_CAPABILITIES,
+    'read', 'grep', 'find', 'ls', SESSION_NAME, TODO_WRITE, ASK_USER, 'ask_user_question', GET_CAPABILITIES,
     'history_search', 'history_read', 'trajectory_search', 'trajectory_read',
     'wiki_entrypoint', 'wiki_search', 'wiki_read', 'wiki_list', 'memory_facts', 'skill_load', 'mcp_list_tools', WAIT_SUBAGENTS
 ]);

package/dist/sdk/sessions/runStore.js

@@ -43,7 +43,9 @@ function ordered(record) {
         ...(record.variantScope ? { variantScope: record.variantScope } : {}),
         ...(record.variantVersion ? { variantVersion: record.variantVersion } : {}),
         ...(record.profile ? { profile: record.profile } : {}),
-        ...(record.title ? { title: record.title } : {})
+        ...(record.title ? { title: record.title } : {}),
+        ...(record.model ? { model: record.model } : {}),
+        ...(record.effort ? { effort: record.effort } : {})
     };
 }
 function write(root, record) {

package/dist/sdk/sessions/runner.js

@@ -1,7 +1,7 @@
 import { classifyMessage } from "../accounts/accounts.js";
 import { EFFORTS } from "../core/effort.js";
 import { HarnessError } from "../core/errors.js";
-import { withWorkspaceWriteScope } from "../core/workspaceBashTool.js";
+import { createWorkspaceShellTool } from "../core/workspaceBashTool.js";
 import { DEFAULT_COMMAND_TIMEOUT_SECONDS, withCommandBudget } from "../core/commandBudget.js";
 import { createWorkspaceBashOperations } from "../core/workspaceSandbox.js";
 import { withWorkspaceWriteAuthorization, workspaceEditOperations, workspaceWriteOperations } from "../core/workspaceWriteOperations.js";
@@ -632,7 +632,7 @@ export const piSessionFactory = async ({ params, allow, gate, tools, runtime: lo
     });
     const gatedExtension = (api) => {
         const writeAuthorizations = new Map();
-        const bash = withWorkspaceWriteScope(pi.createBashTool(params.cwd, { operations: workspaceBash }));
+        const bash = createWorkspaceShellTool(pi, params.cwd, workspaceBash);
         const write = withWorkspaceWriteAuthorization(pi.createWriteTool(params.cwd, { operations: workspaceWriteOperations }), writeAuthorizations);
         const edit = withWorkspaceWriteAuthorization(pi.createEditTool(params.cwd, { operations: workspaceEditOperations }), writeAuthorizations);
         api.registerTool({ ...bash, defaultActive: false });

package/dist/sdk/sessions/sessions.js

@@ -18,7 +18,7 @@ import { FIRST_PARTY_PLUGINS, firstPartyExtensions } from "../plugins/firstParty
 import { imagePruning } from "../world/images.js";
 import { materialise } from "../variant/materialise.js";
 import { ASK_USER } from "../tools/askUser.js";
-import { CHECKLIST_WRITE } from "../tools/checklist.js";
+import { TODO_WRITE } from "../tools/todo.js";
 import { CHECKPOINT_WRITE, checkpointOf } from "../tools/checkpoint.js";
 import { SESSION_NAME, sessionNameTool } from "../tools/sessionName.js";
 import { DEFAULT_TOOL_NAMES } from "../tools/definitions.js";
@@ -400,7 +400,7 @@ export class Sessions {
         const canAskUser = pinnedAskUser || (interactivePlan && harnessToolsEnabled);
         const requestedTools = [...new Set([
                 ...input.tools.allow.filter((name) => name !== SPAWN_SUBAGENT && name !== WAIT_SUBAGENTS && (name !== ASK_USER || canAskUser)),
-                ...(harnessToolsEnabled ? [...(canAskUser ? [ASK_USER] : []), CHECKLIST_WRITE, CHECKPOINT_WRITE, SESSION_NAME, GET_CAPABILITIES, ...DEFAULT_TOOL_NAMES] : []),
+                ...(harnessToolsEnabled ? [...(canAskUser ? [ASK_USER] : []), TODO_WRITE, CHECKPOINT_WRITE, SESSION_NAME, GET_CAPABILITIES, ...DEFAULT_TOOL_NAMES] : []),
                 ...(broker?.toolNames ?? []),
                 ...(canSpawn ? [SPAWN_SUBAGENT, WAIT_SUBAGENTS] : [])
             ])];
@@ -452,7 +452,9 @@ export class Sessions {
             variantScope: variant?.scope ?? null,
             variantVersion: variant?.fingerprint ?? null,
             ...(input.run.profile ? { profile: input.run.profile } : {}),
-            ...(input.run.title ? { title: input.run.title } : {})
+            ...(input.run.title ? { title: input.run.title } : {}),
+            ...(input.model ? { model: input.model } : {}),
+            ...(input.effort ? { effort: input.effort } : {})
         });
         // What the session is, kept with the run so later consolidation knows which memory it had.
         try {
@@ -476,7 +478,14 @@ export class Sessions {
             const delivered = historyFile ? deliveredSnapshot(historyFile) : null;
             const resumed = continuationSection(continuation, delivered?.some((entry) => entry.id === CONTINUATION_SECTION_ID) ?? false);
             // The profiles replace the variant's own subagent list, which they include.
-            const profiles = capabilities.tools.includes(SPAWN_SUBAGENT) ? profileSection(root, input.cwd, variant?.dir ?? null, input.plan === true) : null;
+            const researchContext = input.plan === true ? {
+                frozenTools: capabilities.tools,
+                contributions: capabilities.contributions,
+                descriptors: BUILTIN_PLUGIN_REGISTRY.descriptors()
+            } : undefined;
+            const profiles = capabilities.tools.includes(SPAWN_SUBAGENT)
+                ? profileSection(root, input.cwd, variant?.dir ?? null, input.plan === true, researchContext)
+                : null;
             if (profiles && variant)
                 variant = { ...variant, sections: variant.sections.filter((section) => section.id !== profiles.id) };
             const own = [plan, resumed, profiles].filter((section) => section !== null);
@@ -493,8 +502,10 @@ export class Sessions {
             fail(error);
             throw error;
         }
-        // A reply is bounded only when its checkpoint tool is part of the frozen capability set.
-        const sliceEnabled = slicePolicy.enabled && capabilities.tools.includes(CHECKPOINT_WRITE);
+        // Plan-research children are bounded too, but their read-only capability set omits checkpoint_write.
+        const checkpointAvailable = capabilities.tools.includes(CHECKPOINT_WRITE);
+        const planResearchChild = input.plan === true && input.run.relation === 'subagent';
+        const sliceEnabled = slicePolicy.enabled && (checkpointAvailable || planResearchChild);
         const sliceState = createSliceState(slicePolicy, sliceOf(root, runId));
         const run = this.options.runs.start(input.run.sessionId, runId);
         if (run.finished)
@@ -594,8 +605,8 @@ export class Sessions {
                     runLineageJoin(root, runId),
                     this.options.subagents.extension(runId),
                     { name: 'image-pruning', factory: imagePruning() },
-                    { name: COMPACTION_CHECKPOINT_EXTENSION, factory: compactionCheckpoint({ initialChecklist: continuation?.checklist, planInstructions: checkpointPlanInstructions }) },
-                    ...(sliceEnabled ? [{ name: WORK_SLICE_EXTENSION, factory: workSliceGuard({ policy: slicePolicy, state: sliceState }) }] : [])
+                    { name: COMPACTION_CHECKPOINT_EXTENSION, factory: compactionCheckpoint({ initialTodo: continuation?.todo, planInstructions: checkpointPlanInstructions }) },
+                    ...(sliceEnabled ? [{ name: WORK_SLICE_EXTENSION, factory: workSliceGuard({ policy: slicePolicy, state: sliceState, checkpointAvailable }) }] : [])
                 ],
                 ...(plugins ? { plugins: { loading: () => plugins.loading({ cwd: input.cwd, agentDir: context.configDir, install: true, caller: { agentId: caller.agentId ?? null, projectId: caller.projectId ?? null }, contributions: capabilities.contributions }), loaded: (extensions) => plugins.loaded(extensions) } } : {}),
                 system,
@@ -625,10 +636,17 @@ export class Sessions {
                 throw new HarnessError('native_resume_unavailable', 'The saved conversation could not be restored.');
             }
             const opened = pi;
-            updateRun(root, runId, (record) => void (record.nativeSessionId = opened.sessionId));
+            const openedModel = pi.model?.id && pi.model.provider ? `${pi.model.provider}/${pi.model.id}` : null;
+            updateRun(root, runId, (record) => {
+                record.nativeSessionId = opened.sessionId;
+                if (openedModel)
+                    record.model = openedModel;
+                if (opened.thinkingLevel)
+                    record.effort = opened.thinkingLevel;
+            });
             this.options.subagents.register(input, account.id, capabilities, Boolean(pi.sessionManager));
-            if (pi.model?.id && pi.model.provider)
-                this.options.subagents.resolvedModel(runId, `${pi.model.provider}/${pi.model.id}`, pi.thinkingLevel);
+            if (openedModel)
+                this.options.subagents.resolvedModel(runId, openedModel, pi.thinkingLevel);
             params.settle = () => this.options.subagents.verify(runId, opened.sessionManager ? subagentHistory(opened.sessionManager.getBranch()) : undefined);
             void runTurn(run, pi, params).then(() => (sliceEnabled && !input.command ? this.continueSlice({ root, runId, source: input, policy: slicePolicy }) : undefined));
             return { runId, nativeSessionId: pi.sessionId };

package/dist/sdk/sessions/subagentService.d.ts

@@ -14,6 +14,7 @@ type Started = {
 export type SpawnedSubagent = Started & {
     agent?: string;
     unavailableTools?: string[];
+    continued?: string;
 };
 export interface SubagentRuntimeSettings {
     model: string | null;
@@ -42,9 +43,23 @@ export declare class Subagents {
     private rememberRuntimeSettings;
     resolvedModel(runId: string, model: string, effort?: Effort): void;
     private parent;
+    private planSpawnCheck;
     /** The plan-mode per-call gate and spawn implementation share this eligibility check. */
     planSpawnRefusal(parentRunId: string, args: unknown): string | null;
     spawn(request: SubagentInput): Promise<SpawnedSubagent>;
+    /** Records ownership, starts the child, and writes a failed record when it never opened. */
+    private launchChild;
+    /** The children this parent may read or continue: its own, and those recovered from its history. */
+    private owned;
+    /** The newest run in a continued child's chain, among the runs this parent owns. */
+    private latestLink;
+    /** The first run of a chain: its folder holds the child's history for every later link. */
+    private firstLink;
+    /**
+     * Continues a stopped child as a new child run with `continueFrom`: the same history, profile,
+     * account, variant version and capability set, which must still lie within the parent's.
+     */
+    private continueChild;
     private selected;
     results(selection: SubagentSelection): SubagentResult[];
     wait(selection: SubagentSelection, signal?: AbortSignal): Promise<SubagentResult[]>;