@xingular/harness 1.3.1-unstable.8 → 1.4.0-unstable

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

@@ -0,0 +1,78 @@
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
+import { type CheckModel } from "./completionCheck.js";
+import { type Checkpoint, type TodoItem } from "./contracts.js";
+import type { GoalState } from "./goal.js";
+export declare const STOP_GATE_EXTENSION = "stop-gate";
+export declare const STOP_GATE_CUSTOM_TYPE = "xingular-stop-gate";
+/** Nudges per reply before the reply is handed back to the person. */
+export declare const MAX_STOP_GATE_NUDGES = 3;
+/** What the gate knows about the live reply. */
+export interface StopGateState {
+    /** The reply's todo list as the model last wrote it (or as a continued run inherited it). */
+    todo: TodoItem[];
+    /** The person's request this reply answers. */
+    request: string;
+    /** Nudges sent in this reply. */
+    nudges: number;
+    /** Work tool calls since the last nudge. */
+    callsSinceNudge: number;
+    /** Work tool calls in this reply. */
+    callsInReply: number;
+}
+export declare function createStopGateState(initialTodo?: readonly TodoItem[]): StopGateState;
+/** A new reply starts from the inherited todo list, with no nudges. */
+export declare function resetStopGateState(state: StopGateState, initialTodo?: readonly TodoItem[], request?: string): void;
+/** The todo items a reply has not finished. */
+export declare function openItems(todo: readonly TodoItem[]): TodoItem[];
+/** How a settled reply ended when its work is not done; `null` when it is. */
+export type StopOutcome = {
+    code: 'needs_person';
+    reason: string;
+    open: TodoItem[];
+} | {
+    code: 'unfinished';
+    reason: string;
+    open: TodoItem[];
+};
+/**
+ * `goal` is the session's /goal, when it has one: a goal that ended `blocked` needs the person,
+ * and one that ended on a limit, a pause or a stall leaves work (ADR-0072).
+ */
+export declare function stopOutcome(state: StopGateState, goal?: GoalState | null): StopOutcome | null;
+/** What a checkpoint learns from the reply's todo list and the goal. */
+export declare function handoffFields(state?: StopGateState | null, goal?: GoalState | null): Pick<Checkpoint, 'done' | 'next'> & {
+    blocked?: string;
+};
+/** Why a checkpoint written for a stop outcome was written. */
+export declare const stopCheckpointReason: (outcome: StopOutcome) => Checkpoint["reason"];
+/** The summary a stop outcome's checkpoint falls back to when the reply left no text. */
+export declare function stopSummary(outcome: StopOutcome): string;
+/** The text the model reads when the todo gate sends its reply back. */
+export declare function nudgeText(count: number, max: number, open: readonly TodoItem[]): string;
+/** What the gate reports for the run record: each nudge. */
+export type StopGateEvent = {
+    kind: 'todo';
+    count: number;
+    open: TodoItem[];
+};
+/** One line for the run record per stop-gate nudge. */
+export declare function stopGateNotice(event: StopGateEvent): string;
+export interface StopGateOptions {
+    state: StopGateState;
+    /** The todo list a continued run inherits; each new reply starts from it. */
+    initialTodo?: readonly TodoItem[];
+    /** The person's request when the prompt is not it (a continuation's "Continue from where you stopped."). */
+    request?: () => string | null;
+    /** Whether the gate applies to the current reply; a function follows the terminal's live plan switch. */
+    active?: () => boolean;
+    /** True when the work-slice guard ended this reply: the gate stays silent and the slice hands off. */
+    sliceEnded?: () => boolean;
+    /** True when the reply already failed (a provider error): nothing to continue. */
+    failed?: () => boolean;
+    max?: number;
+    /** Called for each nudge, for the run record. */
+    onEvent?: (event: StopGateEvent) => void;
+}
+export declare function stopGate(options: StopGateOptions): (pi: ExtensionAPI) => void;
+/** The model a goal-claim check asks: the session's own model, at low effort, through Pi's registry. */
+export declare function sessionCheckModel(ctx: unknown): CheckModel | null;

package/dist/sdk/sessions/stopGate.js

@@ -0,0 +1,143 @@
+import { TODO_WRITE } from "../tools/todo.js";
+import { validatedTodo } from "./compactionCheckpoint.js";
+import { answerText } from "./completionCheck.js";
+import { MAX_CHECKPOINT_DONE } from "./contracts.js";
+export const STOP_GATE_EXTENSION = 'stop-gate';
+export const STOP_GATE_CUSTOM_TYPE = 'xingular-stop-gate';
+/** Nudges per reply before the reply is handed back to the person. */
+export const MAX_STOP_GATE_NUDGES = 3;
+/** Calls that are bookkeeping, not work: they neither count as progress nor make a reply checkable. */
+const BOOKKEEPING_TOOLS = new Set([TODO_WRITE, 'session_name']);
+export function createStopGateState(initialTodo = []) {
+    return { todo: validatedTodo(initialTodo) ?? [], request: '', nudges: 0, callsSinceNudge: 0, callsInReply: 0 };
+}
+/** A new reply starts from the inherited todo list, with no nudges. */
+export function resetStopGateState(state, initialTodo = [], request = '') {
+    state.todo = validatedTodo(initialTodo) ?? [];
+    state.request = request;
+    state.nudges = 0;
+    state.callsSinceNudge = 0;
+    state.callsInReply = 0;
+}
+/** The todo items a reply has not finished. */
+export function openItems(todo) {
+    return todo.filter((item) => item.status !== 'completed');
+}
+/**
+ * `goal` is the session's /goal, when it has one: a goal that ended `blocked` needs the person,
+ * and one that ended on a limit, a pause or a stall leaves work (ADR-0072).
+ */
+export function stopOutcome(state, goal) {
+    const open = openItems(state.todo);
+    if (goal?.status === 'blocked')
+        return { code: 'needs_person', reason: goal.lastReason || 'The goal is blocked.', open };
+    if (goal && (goal.status === 'budget_limited' || goal.status === 'usage_limited' || goal.status === 'paused')) {
+        return { code: 'unfinished', reason: goal.lastReason || `The goal is ${goal.status.replace('_', ' ')}.`, open };
+    }
+    if (open.length)
+        return { code: 'unfinished', reason: '', open };
+    return null;
+}
+/** What a checkpoint learns from the reply's todo list and the goal. */
+export function handoffFields(state, goal) {
+    const todo = state?.todo ?? [];
+    const next = openItems(todo)[0]?.text || '';
+    const blocked = goal?.status === 'blocked' ? (goal.lastReason || 'The goal is blocked.').slice(0, 500) : '';
+    return {
+        done: todo.filter((item) => item.status === 'completed').slice(0, MAX_CHECKPOINT_DONE).map((item) => ({ item: item.text.slice(0, 300), evidence: [] })),
+        next: next.slice(0, 500),
+        ...(blocked ? { blocked } : {})
+    };
+}
+/** Why a checkpoint written for a stop outcome was written. */
+export const stopCheckpointReason = (outcome) => outcome.code === 'needs_person' ? 'requested' : 'stuck';
+/** The summary a stop outcome's checkpoint falls back to when the reply left no text. */
+export function stopSummary(outcome) {
+    if (outcome.code === 'needs_person')
+        return `The reply stopped for the person: ${outcome.reason}`.slice(0, 1_200);
+    if (outcome.reason)
+        return `The reply ended with work left: ${outcome.reason}`.slice(0, 1_200);
+    return `The reply ended with ${outcome.open.length} open todo item${outcome.open.length === 1 ? '' : 's'}.`;
+}
+/** The text the model reads when the todo gate sends its reply back. */
+export function nudgeText(count, max, open) {
+    const list = open.slice(0, 12).map((item) => `- ${item.text}`).join('\n');
+    const more = open.length > 12 ? `\n- …and ${open.length - 12} more` : '';
+    return [
+        `Harness stop gate (${count}/${max}): your reply ended with ${open.length} open todo item${open.length === 1 ? '' : 's'}:`,
+        `${list}${more}`,
+        'Continue with the next open item now. Mark an item completed only after it is done and checked.',
+        'The list shows progress; it is not the limit of the work. If the request needs more than the list says, add it and do it.',
+        'Decisions inside the request are yours. Stop only for something only the person can do (a deploy, a secret, remote data, money, missing access), and then say exactly what it is.'
+    ].join('\n');
+}
+/** One line for the run record per stop-gate nudge. */
+export function stopGateNotice(event) {
+    return `Stop gate ${event.count}: the reply ended with ${event.open.length} open todo item${event.open.length === 1 ? '' : 's'}; continuing.`;
+}
+export function stopGate(options) {
+    const { state } = options;
+    const max = options.max ?? MAX_STOP_GATE_NUDGES;
+    return (pi) => {
+        // Pi emits agent_start again for every continuation, so a reply resets only on a person's message.
+        pi.on('before_agent_start', (event) => {
+            if (event.messageType !== undefined && event.messageType !== 'user')
+                return;
+            resetStopGateState(state, options.initialTodo, options.request?.() || (typeof event.prompt === 'string' ? event.prompt : ''));
+        });
+        pi.on('tool_call', (event) => {
+            if (BOOKKEEPING_TOOLS.has(event.toolName))
+                return;
+            state.callsSinceNudge += 1;
+            state.callsInReply += 1;
+        });
+        pi.on('tool_result', (event) => {
+            if (event.toolName !== TODO_WRITE || event.isError)
+                return;
+            const items = validatedTodo(event.input?.items);
+            if (items)
+                state.todo = items;
+        });
+        pi.on('agent_before_settle', (event, ctx) => {
+            if (event.outcome !== 'completed' || event.continue || ctx?.signal?.aborted)
+                return;
+            if (options.active && !options.active())
+                return;
+            if (options.sliceEnded?.() || options.failed?.())
+                return;
+            if (state.nudges >= max)
+                return;
+            // A nudge that produced no work will not be followed by one that does: hand it back.
+            if (state.nudges > 0 && state.callsSinceNudge === 0)
+                return;
+            const open = openItems(state.todo);
+            if (!open.length)
+                return;
+            state.nudges += 1;
+            state.callsSinceNudge = 0;
+            options.onEvent?.({ kind: 'todo', count: state.nudges, open });
+            return {
+                entries: [...event.entries, { type: 'custom_message', customType: STOP_GATE_CUSTOM_TYPE, content: nudgeText(state.nudges, max, open), display: true }],
+                continue: true
+            };
+        });
+    };
+}
+/** The model a goal-claim check asks: the session's own model, at low effort, through Pi's registry. */
+export function sessionCheckModel(ctx) {
+    const session = (ctx ?? {});
+    const model = session.model;
+    const registry = session.modelRegistry;
+    if (!model || !registry)
+        return null;
+    // Some providers (opencode-go) reject a request without a session id.
+    const sessionId = session.sessionManager?.getSessionId?.();
+    return async (system, user, signal) => {
+        const context = { systemPrompt: system, messages: [{ role: 'user', content: user, timestamp: Date.now() }] };
+        const message = await registry.streamSimple(model, context, { ...(model.reasoning ? { reasoning: 'low' } : {}), ...(sessionId ? { sessionId } : {}), maxTokens: 4_000, signal }).result();
+        const failed = message.stopReason;
+        if (failed === 'error' || failed === 'aborted')
+            throw new Error(message.errorMessage || `the check request ended: ${failed}`);
+        return { text: answerText(message), message };
+    };
+}

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

@@ -11,8 +11,10 @@ type Started = {
     nativeSessionId: string | null;
 };
 /** What a spawn returns: the child, the profile it started from, and profile tools missing here. */
+/** `tools` is what the child can actually use, so the parent sees a brief/tool mismatch at once. */
 export type SpawnedSubagent = Started & {
     agent?: string;
+    tools?: string[];
     unavailableTools?: string[];
     continued?: string;
 };

package/dist/sdk/sessions/subagentService.js

@@ -232,7 +232,7 @@ export class Subagents {
                 ...(input.plan ? { connections: false, subagents: null } : {})
             };
             const result = await this.launchChild(parent, request, child);
-            return { ...result, ...(profile ? { agent: profile.name } : {}), ...(narrowed.unavailable.length ? { unavailableTools: narrowed.unavailable } : {}) };
+            return { ...result, ...(profile ? { agent: profile.name } : {}), tools, ...(narrowed.unavailable.length ? { unavailableTools: narrowed.unavailable } : {}) };
         }
         finally {
             this.release(request.parentRunId, runId);

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

@@ -41,32 +41,35 @@ export interface SliceState {
     startedAt: number;
     lastTool: string | null;
     compactions: number;
-    checkpointWritten: boolean;
     /** Set when the guard ended the reply instead of the model finishing it. */
     endedBy: SliceEnd | null;
     /** The limit that ended it, for the record. */
     endedByLimit: string | null;
     /** Steps past which every non-exempt tool call is refused, once one was refused. */
     refusedAt: number | null;
+    /** Whether this slice did work: a successful command or file change. A fruitless slice is not continued. */
+    progressed: boolean;
 }
 export declare function createSliceState(_policy: SlicePolicy, slice?: number, now?: number): SliceState;
 /** Counters start again for each reply; a terminal session keeps one guard across replies. */
 export declare function resetSliceState(state: SliceState, now?: number): void;
+/**
+ * The next slice of the same reply: fresh counters and clock, one more slice. Compactions carry
+ * over, so a reply that keeps compacting still ends.
+ */
+export declare function beginNextSlice(state: SliceState, now?: number): void;
 /** The first limit this reply has passed, named as a person would say it. */
 export declare function sliceLimitReached(policy: SlicePolicy, state: SliceState, now?: number): string | null;
 interface ToolCall {
     toolCallId: string;
     toolName: string;
 }
-interface ToolResult {
-    toolName: string;
-    isError?: boolean;
-}
 /** The part of Pi's extension API this guard uses. Structural, so the module needs no Pi import. */
 interface GuardApi {
-    on(event: 'agent_start', handler: () => unknown): void;
+    on(event: 'before_agent_start', handler: (event: {
+        messageType?: string;
+    }) => unknown): void;
     on(event: 'tool_call', handler: (event: ToolCall) => unknown): void;
-    on(event: 'tool_result', handler: (event: ToolResult) => unknown): void;
     on(event: 'message_end', handler: (event: {
         message: {
             role: string;
@@ -82,18 +85,64 @@ interface GuardApi {
 export interface WorkSliceGuardOptions {
     policy: SlicePolicy;
     state: SliceState;
-    /** Whether checkpoint_write is active; a function supports the terminal's live plan-mode switch. */
-    checkpointAvailable?: boolean | (() => boolean);
     /** Called when a triggering call terminates the reply; the runner ends it. */
     onEnd?: (end: SliceEnd, limit: string) => void;
     onRefuse?: (event: ToolCall, reason: string) => void;
 }
 /**
- * Bounds one reply. A call past the budget is refused, with one wrap-up request when a checkpoint
- * is available, and an ended reply lets only a handoff call through. Three compactions in one reply
- * end it too. Every other call is allowed, however often it is made.
+ * Bounds one reply. A call past the budget is refused with one wrap-up request, and an ended reply
+ * lets only a handoff call through. Three compactions in one reply end it too. Every other call is
+ * allowed, however often it is made.
  */
 export declare function workSliceGuard(options: WorkSliceGuardOptions): (pi: GuardApi) => void;
+export declare const SLICE_CONTINUE_CUSTOM_TYPE = "xingular-slice-continue";
+/** The part of Pi's extension API the continuation uses. Structural, so the module needs no Pi import. */
+interface ContinuationApi {
+    on(event: 'before_agent_start', handler: (event: {
+        messageType?: string;
+    }) => unknown): void;
+    on(event: 'tool_result', handler: (event: {
+        toolName: string;
+        isError?: boolean;
+    }) => unknown): void;
+    on(event: 'agent_before_settle', handler: (event: {
+        outcome?: string;
+        continue?: boolean;
+        entries: unknown[];
+    }, ctx?: {
+        signal?: AbortSignal;
+    }) => unknown): void;
+}
+export interface SliceContinuationOptions {
+    policy: SlicePolicy;
+    state: SliceState;
+    /** False while a plan runs: a plan is not continued. */
+    active?: () => boolean;
+    failed?: () => boolean;
+    /** True when the completion check said the reply needs the person (ADR-0071). */
+    blocked?: () => boolean;
+    /** The todo list: when every item is done, the work is not continued. */
+    todo?: () => readonly {
+        status: string;
+    }[];
+    /** The next open step, for the continue message. */
+    next?: () => string;
+    /** True while a /goal is active: a goal's slices go on even when every todo item is done (ADR-0072). */
+    goalActive?: () => boolean;
+    /** Called before the next slice starts, with the slice that ended. */
+    onContinue?: (ended: {
+        slice: number;
+        steps: number;
+        limit: string | null;
+    }) => void;
+}
+/**
+ * Continues a reply in place when its slice ended at the budget (PROP-0041, ADR-0070): the same
+ * run and the same cached prompt, with fresh counters, up to `maxSlices`. Never after a fruitless,
+ * blocked, failed, aborted or plan slice, or when every todo item is done. A person's message
+ * starts again at slice 1.
+ */
+export declare function sliceContinuation(options: SliceContinuationOptions): (pi: ContinuationApi) => void;
 /**
  * Which slice of its session a run is, from 1. Counts the recorded continuation chain, so it
  * survives a restart and needs no extra field on the run record.

package/dist/sdk/sessions/workSlice.js

@@ -23,6 +23,17 @@ const LIMITS = {
 };
 export class WorkSliceError extends Error {
 }
+/** `XINGULAR_WORK_SLICE=maxToolCalls=15,maxSlices=3` at launch: the same fields as a run's policy. */
+function launchPolicy(text) {
+    const record = {};
+    for (const part of text.split(',')) {
+        const [key, raw] = part.split('=').map((value) => value.trim());
+        if (!key || raw === undefined)
+            throw new WorkSliceError(`XINGULAR_WORK_SLICE must be off or key=value pairs, not ${JSON.stringify(text)}.`);
+        record[key] = raw === 'true' ? true : raw === 'false' ? false : Number(raw);
+    }
+    return record;
+}
 /**
  * The policy a run asked for, or the defaults. `XINGULAR_WORK_SLICE=off` at launch turns the guard
  * off for every run in this process; nothing is persisted, so restarting without it restores the
@@ -30,8 +41,12 @@ export class WorkSliceError extends Error {
  */
 export function parseWorkSlice(input) {
     if (input === undefined || input === null) {
-        const launch = process.env.XINGULAR_WORK_SLICE?.trim().toLowerCase();
-        return { ...DEFAULT_SLICE_POLICY, ...(launch === 'off' || launch === '0' || launch === 'false' ? { enabled: false } : {}) };
+        const launch = process.env.XINGULAR_WORK_SLICE?.trim();
+        if (launch === undefined || launch === '')
+            return { ...DEFAULT_SLICE_POLICY };
+        if (['off', '0', 'false'].includes(launch.toLowerCase()))
+            return { ...DEFAULT_SLICE_POLICY, enabled: false };
+        return parseWorkSlice(launchPolicy(launch));
     }
     if (typeof input !== 'object' || Array.isArray(input))
         throw new WorkSliceError('workSlice must be an object.');
@@ -68,7 +83,7 @@ export function parseWorkSlice(input) {
     return policy;
 }
 export function createSliceState(_policy, slice = 1, now = Date.now()) {
-    return { slice, steps: 0, tokens: 0, startedAt: now, lastTool: null, compactions: 0, checkpointWritten: false, endedBy: null, endedByLimit: null, refusedAt: null };
+    return { slice, steps: 0, tokens: 0, startedAt: now, lastTool: null, compactions: 0, endedBy: null, endedByLimit: null, refusedAt: null, progressed: false };
 }
 /** Counters start again for each reply; a terminal session keeps one guard across replies. */
 export function resetSliceState(state, now = Date.now()) {
@@ -77,10 +92,20 @@ export function resetSliceState(state, now = Date.now()) {
     state.startedAt = now;
     state.lastTool = null;
     state.compactions = 0;
-    state.checkpointWritten = false;
     state.endedBy = null;
     state.endedByLimit = null;
     state.refusedAt = null;
+    state.progressed = false;
+}
+/**
+ * The next slice of the same reply: fresh counters and clock, one more slice. Compactions carry
+ * over, so a reply that keeps compacting still ends.
+ */
+export function beginNextSlice(state, now = Date.now()) {
+    const compactions = state.compactions;
+    resetSliceState(state, now);
+    state.compactions = compactions;
+    state.slice += 1;
 }
 /** The first limit this reply has passed, named as a person would say it. */
 export function sliceLimitReached(policy, state, now = Date.now()) {
@@ -92,37 +117,40 @@ export function sliceLimitReached(policy, state, now = Date.now()) {
         return `${Math.round(policy.maxNewTokens / 1000)}k new tokens`;
     return null;
 }
-/** Tools a reply may still call while it writes its handoff. A plan update waits for the next slice. */
-const HANDOFF_TOOLS = new Set(['checkpoint_write', 'session_name']);
+/** Tools a reply may still call after its slice ended. A plan update waits for the next slice. */
+const HANDOFF_TOOLS = new Set(['session_name']);
 const clip = (value, limit) => (value.length <= limit ? value : `${value.slice(0, limit - 1)}…`);
-function handoffRequest(limit, state, checkpointAvailable = true) {
-    const handoff = checkpointAvailable
-        ? 'Call checkpoint_write now with what is done, the single next step, anything blocking, the files you touched and the checks that matter. Then tell the user in a few lines where you stopped.'
-        : 'Stop using tools and return a concise partial research report with findings, blockers and the next useful research step. The Harness records an evidence-derived checkpoint.';
-    return clip(`This reply reached its work-slice limit (${limit}; step ${state.steps}). ${handoff} Do not call other tools.`, 600);
+// The harness writes the handoff itself from the reply's files, checks and todo list (ADR-0069), so
+// the model is only asked to stop and say where it is.
+function handoffRequest(limit, state) {
+    return clip(`This reply reached its work-slice limit (${limit}; step ${state.steps}). Stop using tools and write a short report: what is done or found, what is left, and the single next step. ` +
+        'The Harness records a checkpoint from this reply\'s evidence, and the next slice continues from it. Do not call other tools.', 600);
 }
 /**
- * Bounds one reply. A call past the budget is refused, with one wrap-up request when a checkpoint
- * is available, and an ended reply lets only a handoff call through. Three compactions in one reply
- * end it too. Every other call is allowed, however often it is made.
+ * Bounds one reply. A call past the budget is refused with one wrap-up request, and an ended reply
+ * lets only a handoff call through. Three compactions in one reply end it too. Every other call is
+ * allowed, however often it is made.
  */
 export function workSliceGuard(options) {
     const { policy, state } = options;
-    const checkpointAvailable = () => typeof options.checkpointAvailable === 'function'
-        ? options.checkpointAvailable()
-        : options.checkpointAvailable !== false;
     const end = (kind, limit) => {
         state.endedBy = kind;
         state.endedByLimit = limit;
         options.onEnd?.(kind, limit);
-        const canCheckpoint = checkpointAvailable();
         const reason = kind === 'compaction-thrash'
-            ? handoffRequest('three context compactions in one reply', state, canCheckpoint)
-            : handoffRequest(limit, state, canCheckpoint);
+            ? handoffRequest('three context compactions in one reply', state)
+            : handoffRequest(limit, state);
         return { block: true, terminate: true, reason };
     };
     return (pi) => {
-        pi.on('agent_start', () => resetSliceState(state));
+        // Pi emits agent_start again for every continuation (a stop-gate nudge, delivered subagent
+        // results, a plan repair), and those belong to the same reply and the same budget. Only a
+        // person's message starts a new slice.
+        pi.on('before_agent_start', (event) => {
+            if (event.messageType !== undefined && event.messageType !== 'user')
+                return;
+            resetSliceState(state);
+        });
         pi.on('message_end', (event) => {
             const usage = event.message.usage;
             if (event.message.role !== 'assistant' || !usage)
@@ -130,22 +158,15 @@ export function workSliceGuard(options) {
             // New tokens only: the cached prefix was sent before and is not new context or new cost.
             state.tokens += (usage.input ?? 0) + (usage.cacheWrite ?? 0) + (usage.output ?? 0);
         });
-        pi.on('tool_result', (event) => {
-            if (event.toolName === 'checkpoint_write' && !event.isError)
-                state.checkpointWritten = true;
-        });
         pi.on('tool_call', (event) => {
             const name = event.toolName;
             const refuse = (result) => { options.onRefuse?.(event, result.reason); return result; };
             state.steps += 1;
             state.lastTool = name;
-            const canCheckpoint = checkpointAvailable();
-            const handoff = canCheckpoint && HANDOFF_TOOLS.has(name);
-            // A handoff is callable only when checkpoint_write is active; after the slice ended it is the only one.
+            const handoff = HANDOFF_TOOLS.has(name);
+            // After the slice ended, a handoff call is the only one that runs.
             if (state.endedBy) {
-                const reason = state.checkpointWritten
-                    ? 'This reply is over. Its checkpoint is recorded; nothing else runs.'
-                    : 'This reply is over. The Harness will record an evidence-derived checkpoint; nothing else runs.';
+                const reason = 'This reply is over. The Harness will record an evidence-derived checkpoint; nothing else runs.';
                 return handoff ? undefined : refuse({ block: true, terminate: true, reason });
             }
             if (state.compactions >= 3) {
@@ -158,16 +179,64 @@ export function workSliceGuard(options) {
             }
             const limit = sliceLimitReached(policy, state);
             if (limit) {
-                // The slice ends here; the model gets one wrap-up request to write the handoff. A handoff
+                // The slice ends here; the model gets one wrap-up request to report where it is. A handoff
                 // call is never refused, including when it is the very first call past the budget.
                 state.endedBy = 'budget';
                 state.endedByLimit = limit;
                 state.refusedAt ??= state.steps;
-                return handoff ? undefined : refuse({ block: true, reason: handoffRequest(limit, state, canCheckpoint) });
+                return handoff ? undefined : refuse({ block: true, reason: handoffRequest(limit, state) });
             }
         });
     };
 }
+export const SLICE_CONTINUE_CUSTOM_TYPE = 'xingular-slice-continue';
+/** Successful tools that change the workspace count as progress. */
+const PROGRESS_TOOLS = new Set(['bash', 'edit', 'write']);
+/**
+ * Continues a reply in place when its slice ended at the budget (PROP-0041, ADR-0070): the same
+ * run and the same cached prompt, with fresh counters, up to `maxSlices`. Never after a fruitless,
+ * blocked, failed, aborted or plan slice, or when every todo item is done. A person's message
+ * starts again at slice 1.
+ */
+export function sliceContinuation(options) {
+    const { policy, state } = options;
+    return (pi) => {
+        pi.on('before_agent_start', (event) => {
+            if (event.messageType !== undefined && event.messageType !== 'user')
+                return;
+            state.slice = 1;
+        });
+        pi.on('tool_result', (event) => {
+            if (!event.isError && PROGRESS_TOOLS.has(event.toolName))
+                state.progressed = true;
+        });
+        pi.on('agent_before_settle', (event, ctx) => {
+            if (event.outcome !== 'completed' || event.continue || ctx?.signal?.aborted)
+                return;
+            if (!policy.enabled || !policy.continue || state.endedBy !== 'budget')
+                return;
+            if (options.active && !options.active())
+                return;
+            if (options.failed?.() || options.blocked?.() || !state.progressed)
+                return;
+            if (state.slice >= policy.maxSlices)
+                return;
+            const todo = options.todo?.() ?? [];
+            if (!options.goalActive?.() && todo.length && todo.every((item) => item.status === 'completed'))
+                return;
+            const ended = { slice: state.slice, steps: state.steps, limit: state.endedByLimit };
+            options.onContinue?.(ended);
+            beginNextSlice(state);
+            const next = options.next?.().trim();
+            const content = clip(`Work slice ${ended.slice} reached its limit (${ended.limit ?? 'budget'}). Slice ${state.slice} of up to ${policy.maxSlices} starts now with a fresh budget. ` +
+                `Continue the task from ${next ? `the next step: ${next}` : 'the next step you reported'}. Do not redo finished work.`, 900);
+            return {
+                entries: [...event.entries, { type: 'custom_message', customType: SLICE_CONTINUE_CUSTOM_TYPE, content, display: true }],
+                continue: true
+            };
+        });
+    };
+}
 /**
  * Which slice of its session a run is, from 1. Counts the recorded continuation chain, so it
  * survives a restart and needs no extra field on the run record.

package/dist/sdk/terminal/controller.d.ts

@@ -1,5 +1,5 @@
 import { type RunEvent, type RunRecord } from "../sessions/contracts.js";
-import type { ActiveRun, ApprovalDecision, QuestionAnswer } from "../sessions/registry.js";
+import type { ActiveRun, ApprovalDecision, InterruptStop, QuestionAnswer } from "../sessions/registry.js";
 import { type TerminalSubagentActivity, type TerminalSubagentProfile, type TerminalSubagentRun } from "./subagentMonitor.js";
 type MonitorRuntime = Pick<TerminalSubagentRun, 'accountLabel' | 'model' | 'effort'>;
 /** A saved run to show in the monitor after the conversation is reopened. */
@@ -48,7 +48,7 @@ export interface ControllerHooks {
      */
     hydrate?(owners: string[]): void;
     telemetry(event: string): void;
-    interrupt?(runId: string): Promise<void>;
+    interrupt?(runId: string, stop?: InterruptStop): Promise<void>;
     resolveApproval?(runId: string, requestId: string, decision: ApprovalDecision): void;
     answerQuestion?(runId: string, requestId: string, answer: QuestionAnswer): void;
     answerQuestions?(runId: string, batchId: string, answers: Array<{

package/dist/sdk/terminal/controller.js

@@ -8,6 +8,8 @@ import { runStatusSchema } from "../sessions/contracts.js";
 import { briefTitle } from "../sessions/subagents.js";
 import { MAIN_PROFILE, SubagentMonitor } from "./subagentMonitor.js";
 import { replyStalled } from "./stallWatch.js";
+/** Stop codes the native extension may report for a reply it settled itself. */
+const SETTLED_CODES = new Set(['slice_budget', 'compaction_thrash', 'needs_person', 'unfinished']);
 function monitorRun(record, relation, profile, runtime) {
     return {
         id: record.id,
@@ -274,8 +276,13 @@ export class TerminalController {
             return { requests: [...this.pending.values()] };
         if (call === 'terminal.pending.wait')
             return this.waitPending(data.revision);
-        if (call === 'terminal.interrupt')
-            return this.activeRun && this.hooks.interrupt ? this.hooks.interrupt(this.activeRun.runId) : {};
+        if (call === 'terminal.interrupt') {
+            const run = this.activeRun;
+            if (!run || !this.hooks.interrupt)
+                return {};
+            // Pi's abort reports through here as a person's Esc does; one the stall watch asked for is a stall.
+            return this.hooks.interrupt(run.runId, this.stallRequested === run.runId ? { reason: 'stalled', code: 'stalled' } : undefined);
+        }
         if (call === 'terminal.policy') {
             const run = this.activeRun;
             if (!run || typeof data.tool !== 'string' || !data.tool)
@@ -436,11 +443,12 @@ export class TerminalController {
         }
         if (event === 'settled') {
             // A reply that stopped at its work-slice boundary is interrupted, not completed: the record
-            // says `slice_complete` (or `stalled`) so a host can continue it (PROP-0041).
+            // says `slice_complete` (or `stalled`) so a host can continue it (PROP-0041). So is one that
+            // ended with open todo items: `needs_person` or `unfinished` (ADR-0069).
             const stalled = this.stallRequested !== null && this.stallRequested === this.run?.runId;
             const reason = data.error ? undefined : stalled ? 'stalled' : typeof data.reason === 'string' ? data.reason : undefined;
             const outcome = data.error ? 'failed' : data.aborted || reason ? 'interrupted' : 'completed';
-            const code = data.error ? data.errorCode === 'provider_error' ? 'provider_error' : undefined : stalled ? 'stalled' : data.code === 'slice_budget' || data.code === 'compaction_thrash' ? data.code : data.aborted ? 'user_abort' : undefined;
+            const code = data.error ? data.errorCode === 'provider_error' ? 'provider_error' : undefined : stalled ? 'stalled' : SETTLED_CODES.has(data.code) ? data.code : data.aborted ? 'user_abort' : undefined;
             this.finish(outcome, data.error ? String(data.error) : undefined, reason, code);
             return {};
         }
@@ -496,6 +504,8 @@ export class TerminalController {
             run.emit('todo.updated', { items: data.items });
         else if (event === 'checkpoint')
             run.emit('checkpoint', data);
+        else if (event === 'notice')
+            run.emit('extension.notice', data);
         else if (event === 'file')
             run.emit('file.changed', data);
         else if (event === 'delta')

package/dist/sdk/terminal/credentialStore.d.ts

@@ -0,0 +1,4 @@
+import type { CredentialStore } from '@earendil-works/pi-ai';
+type Call = <T>(call: string, params?: Record<string, unknown>, timeoutMs?: number, signal?: AbortSignal) => Promise<T>;
+export declare function terminalCredentialStore(call?: Call): CredentialStore;
+export {};