@adecore/agents 0.23.1 → 0.24.0

package/src/coordination/index.ts

@@ -0,0 +1,67 @@
+// Public API: exports.test.ts snapshots this list, so a name added or dropped here is an API change.
+export { type OutboxEntryOf, OutboxStore, type OutboxWorkShape, type OutboxEntryFields, type OutboxStoreOptions } from '../outbox/outbox.ts';
+export {
+    RETRY_DELAYS_MS,
+    type OutboxClock,
+    systemClock,
+    type OutboxOutcome,
+    type OutboxHandlers,
+    OutboxWorker,
+    type OutboxWorkerOptions
+} from '../outbox/outbox-worker.ts';
+export { restartBackgroundLimits, type RestartedOutbox } from '../tasks/background-limit.ts';
+export {
+    EndChildrenWorkSchema,
+    endChildren,
+    type EndChildrenWork,
+    type EndChildrenEntry,
+    type EndChildrenOutbox,
+    type EndChildrenDeps,
+    type EndChildren
+} from '../tasks/end-children.ts';
+export { type TaskCoordinatorDeps, TaskCoordinator } from '../tasks/task-coordinator.ts';
+export { TaskStore, type TaskListener, type TaskEvent, type TaskSink } from '../tasks/task-store.ts';
+export {
+    BackgroundLimitWorkSchema,
+    WakeParentWorkSchema,
+    GiveTaskWorkSchema,
+    DeliverWaitingWorkSchema,
+    type BackgroundLimitWork,
+    type WakeParentWork,
+    type GiveTaskWork,
+    type DeliverWaitingWork,
+    type TaskWork,
+    type BackgroundLimitEntry,
+    type AnyOutboxEntry,
+    type TaskOutbox
+} from '../tasks/task-work.ts';
+export {
+    type ChatRequests,
+    chatRequests,
+    WAITING_GRACE_MS,
+    WaitingObserver,
+    type WaitingRequest,
+    type WaitingObserverDeps,
+    type WaitingWords
+} from '../tasks/waiting-child.ts';
+export { RESULT_PREVIEW_BYTES, wakePrompt } from '../tasks/wake-parent.ts';
+export { type TaskVerbs, type TaskWords, wireTasks, type TaskChats, type TaskRecord, type TaskWiringDeps, type TaskWiring } from '../tasks/wiring.ts';
+export {
+    DeliverMessageWorkSchema,
+    deliverMessageHandler,
+    type DeliverMessageWork,
+    type DeliverMessageEntry,
+    type DeliverMessageDeps
+} from '../messages/deliver-message.ts';
+export {
+    type MessageWords,
+    type ChatNoticeTargets,
+    type ChatDelivery,
+    chatNoticeTargets,
+    deliverToChat,
+    showNotices,
+    type NoticeChat
+} from '../messages/deliver-notice.ts';
+export { NoticeNotes, unshownNotes } from '../messages/notice-notes.ts';
+export { MAX_NOTICES, NOTICE_MAX_AGE_MS, type Notice, NoticeStore } from '../messages/notice-store.ts';
+export { AgentLineageStore } from '../lineage.ts';

package/src/host/handlers.ts

@@ -55,6 +55,10 @@ export function chatHandlers(chats: ChatCore, providers: ProviderRegistry): { [T
             await chats.stopTask(payload.chatId, payload.taskId);
             return {};
         },
+        'chat.goal': async (payload) => {
+            await chats.goal(payload.chatId, payload.action);
+            return {};
+        },
         'chat.detach': (payload, clientId) => {
             chats.detach(payload.chatId, clientId);
             return {};
@@ -112,6 +116,10 @@ export function chatHandlers(chats: ChatCore, providers: ProviderRegistry): { [T
             await chats.kill(payload.chatId);
             return {};
         },
+        'chat.restart': async (payload) => {
+            await chats.restart(payload.chatId);
+            return {};
+        },
         'chat.list': () => ({ chats: chats.list() })
     };
 }

package/src/host/index.ts

@@ -0,0 +1,8 @@
+// Public API: exports.test.ts snapshots this list, so a name added or dropped here is an API change.
+export { AgentHost, type AgentHostOptions } from './agent-host.ts';
+export { RUIMTE_SESSION_VARIABLES, cliEnvironment, type CliEnvironmentPolicy } from './environment.ts';
+export { type AgentHandler, type AgentHandlers, chatHandlers, accountHandlers, usageHandlers, type AgentRequestMap, type ChatRequestType } from './handlers.ts';
+export { memoryPortPair } from './memory-port.ts';
+export { type AgentWiring, wireAgents, type AgentWiringOptions } from './wiring.ts';
+export { ClientSinks } from '../client-sinks.ts';
+export type { AgentEvent, AgentEventMap, AgentSink } from '../events.ts';

package/src/index.ts

@@ -0,0 +1,20 @@
+// Public API: exports.test.ts snapshots this list, so a name added or dropped here is an API change.
+export { wait, withTimeout } from './async.ts';
+export { CodedError } from './coded-error.ts';
+export { describeError, setErrorStacks, errorText } from './error-text.ts';
+export { tempNameFor, writeAtomic, replaceSync, writeAtomicSync, isNotFound, fileExists, type WriteAtomicOptions } from './fs.ts';
+export { recordFileName, RecordDirectory, type RecordDirectoryOptions } from './record-directory.ts';
+export { runProcess, type ProcessResult, type RunProcessOptions } from './run-process.ts';
+export { Serializer, KeyedSerializer } from './serializer.ts';
+export { cleanTitle, readLines } from './title-file.ts';
+export {
+    type DirectoryWatcher,
+    type WatchSeams,
+    supportsRecursive,
+    SYSTEM_WATCH,
+    type Settled,
+    settled,
+    PerClientWatches,
+    type WatchDirectory,
+    type Schedule
+} from './watch-seam.ts';

package/src/providers/accounts/status.ts

@@ -1,4 +1,5 @@
 import type { AgentKind } from '@adecore/agent-contracts';
+import { isRecord } from '@adecore/agent-contracts';
 import { withTimeout } from '../../async.ts';
 import { CodexTransport, type CodexClientInfo } from '../../chat/codex-transport.ts';
 import { runProcess } from '../../run-process.ts';
@@ -20,10 +21,6 @@ function text(value: unknown): string | null {
     return typeof value === 'string' && value !== '' ? value : null;
 }
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-
 /* `claude auth status --json`, as Claude Code 2.1.282 prints it: `loggedIn`, `email`, `orgName`, `subscriptionType`. */
 export function readClaudeAuthStatus(output: string): AccountReading {
     let status: unknown;

package/src/providers/claude.ts

@@ -101,6 +101,7 @@ export const CLAUDE_CAPABILITIES: ProviderCapabilities = {
     denyReason: true,
     allowAlways: true,
     asyncQuestions: false,
+    steer: true,
     compaction: 'prompt',
     reportsCost: true,
     /*
@@ -110,7 +111,8 @@ export const CLAUDE_CAPABILITIES: ProviderCapabilities = {
      */
     reportsContextWindow: false,
     reportsThinking: true,
-    slashCommands: true
+    slashCommands: true,
+    goals: 'command'
 };
 
 // Claude Code takes its flags before `--resume`, which takes the id.

package/src/providers/codex.ts

@@ -58,11 +58,13 @@ export const CODEX_CAPABILITIES: ProviderCapabilities = {
     denyReason: false,
     allowAlways: true,
     asyncQuestions: true,
+    steer: true,
     compaction: 'native',
     reportsCost: false,
     reportsContextWindow: true,
     reportsThinking: true,
-    slashCommands: false
+    slashCommands: false,
+    goals: 'native'
 };
 
 // `codex resume` is a subcommand that reads `[OPTIONS] [SESSION_ID]`, so the flags go after it.

package/src/providers/index.ts

@@ -0,0 +1,15 @@
+// Public API: exports.test.ts snapshots this list, so a name added or dropped here is an API change.
+export { AccountError, type AccountLaunches, storedAccount, launchEnv } from './accounts/launch.ts';
+export { ProviderAccountsService, type ProviderAccountsOptions } from './accounts/service.ts';
+export type { ShadowHomeReport } from './accounts/shadow-home.ts';
+export type { AccountReading, AskAccount } from './accounts/status.ts';
+export { type AccountsHost, variablesProblem, keychainService, type SecretStore, type ReservedVariables } from './accounts/variables.ts';
+export { ModelCatalog, type ModelCatalogInput } from './catalog.ts';
+export { createClaudeProvider } from './claude-provider.ts';
+export { createCodexProvider } from './codex-provider.ts';
+export { type CodexRules, codexRulesText, codexRulesPathIn, defaultCodexHome, installCodexRules, type CodexRulesResult } from './codex-rules.ts';
+export { codexThreadOptions, codexServiceTier } from './codex.ts';
+export { type CliDetection, detectCli } from './detect.ts';
+export type { ChatProvider, ProviderHome } from './provider.ts';
+export { ProviderRegistry, type ProviderRegistryOptions } from './registry.ts';
+export { MODE_ORDER, narrowerMode, ceilingForOpening, modeFlag } from '../modes.ts';

package/src/run-process.ts

@@ -1,4 +1,5 @@
 import { spawn } from 'node:child_process';
+import { killProcessTree } from './chat/chat-process.ts';
 
 export interface ProcessResult {
     // Null when the process ended on a signal.
@@ -12,11 +13,16 @@ export interface RunProcessOptions {
     cwd?: string;
     // Written and closed at once; absent, the process reads from nothing.
     stdin?: string;
-    // The process is sent a SIGTERM after this, and the run fails.
+    // The process and what it started are sent a SIGTERM after this, a SIGKILL after a grace, and the run fails.
     timeoutMs?: number;
     timeoutMessage?: string;
 }
 
+// What a command and everything it started get between the SIGTERM and the SIGKILL.
+const KILL_GRACE_MS = 2000;
+// Stdout and stderr together; a short command that prints more is ended and fails instead of filling memory.
+const MAX_OUTPUT_BYTES = 16 * 1024 * 1024;
+
 /* One short command to its end, with what it printed. A command that cannot start rejects. */
 export function runProcess(command: readonly string[], options: RunProcessOptions = {}): Promise<ProcessResult> {
     return new Promise((resolve, reject) => {
@@ -28,30 +34,64 @@ export function runProcess(command: readonly string[], options: RunProcessOption
         const child = spawn(executable, args, {
             ...(options.cwd === undefined ? {} : { cwd: options.cwd }),
             ...(options.env === undefined ? {} : { env: options.env }),
-            stdio: [options.stdin === undefined ? 'ignore' : 'pipe', 'pipe', 'pipe']
+            stdio: [options.stdin === undefined ? 'ignore' : 'pipe', 'pipe', 'pipe'],
+            // A group of its own, so ending the command also ends what it started; Windows ends the tree through `taskkill`.
+            detached: process.platform !== 'win32',
+            windowsHide: true
         });
         const stdout: Buffer[] = [];
         const stderr: Buffer[] = [];
-        child.stdout?.on('data', (chunk: Buffer) => stdout.push(chunk));
-        child.stderr?.on('data', (chunk: Buffer) => stderr.push(chunk));
-        const timer =
-            options.timeoutMs === undefined
-                ? null
-                : setTimeout(() => {
-                      child.kill('SIGTERM');
-                      reject(new Error(options.timeoutMessage ?? `${executable} did not finish in time`));
-                  }, options.timeoutMs);
-        child.on('error', (error) => {
+        let printed = 0;
+        let settled = false;
+        let timer: ReturnType<typeof setTimeout> | null = null;
+        const settle = (): boolean => {
+            if (settled) {
+                return false;
+            }
+            settled = true;
             if (timer !== null) {
                 clearTimeout(timer);
             }
-            reject(error);
+            return true;
+        };
+        const end = (message: string): void => {
+            if (!settle()) {
+                return;
+            }
+            const pid = child.pid;
+            if (pid !== undefined) {
+                killProcessTree(pid, 'SIGTERM');
+                // Sent even when the command left in time: what it started may still ignore the SIGTERM.
+                setTimeout(() => killProcessTree(pid, 'SIGKILL'), KILL_GRACE_MS).unref?.();
+            }
+            reject(new Error(message));
+        };
+        const collect = (into: Buffer[]) => (chunk: Buffer) => {
+            if (settled) {
+                return;
+            }
+            printed += chunk.length;
+            if (printed > MAX_OUTPUT_BYTES) {
+                end(`${executable} printed more than ${MAX_OUTPUT_BYTES / 1024 / 1024} MB`);
+                return;
+            }
+            into.push(chunk);
+        };
+        child.stdout?.on('data', collect(stdout));
+        child.stderr?.on('data', collect(stderr));
+        if (options.timeoutMs !== undefined) {
+            const message = options.timeoutMessage ?? `${executable} did not finish in time`;
+            timer = setTimeout(() => end(message), options.timeoutMs);
+        }
+        child.on('error', (error) => {
+            if (settle()) {
+                reject(error);
+            }
         });
         child.on('close', (exitCode) => {
-            if (timer !== null) {
-                clearTimeout(timer);
+            if (settle()) {
+                resolve({ exitCode, stdout: Buffer.concat(stdout).toString('utf8'), stderr: Buffer.concat(stderr).toString('utf8') });
             }
-            resolve({ exitCode, stdout: Buffer.concat(stdout).toString('utf8'), stderr: Buffer.concat(stderr).toString('utf8') });
         });
         if (options.stdin !== undefined && child.stdin) {
             child.stdin.on('error', () => undefined);

package/src/skills.ts

@@ -195,4 +195,9 @@ export class SkillIndex {
         this.cache.set(key, { at: Date.now(), skills });
         return skills;
     }
+
+    /* Drops the scan of one CLI in one folder, so the next look reads the disk again. */
+    forget(kind: AgentKind, cwd: string): void {
+        this.cache.delete(`${kind}:${cwd}`);
+    }
 }

package/src/tasks/task-coordinator.ts

@@ -27,6 +27,11 @@ export interface TaskCoordinatorDeps {
      * it (`reports`), nothing (`silent`), or nothing ever again, since its process went (`gone`).
      */
     afterBackgroundWork(chatId: string): 'reports' | 'silent' | 'gone';
+    /*
+     * The goal a chat's CLI works toward, while one is active: `running` while its process is there to open the
+     * next turn toward it; null once the goal is met, paused or cleared, or when there never was one.
+     */
+    activeGoal?(chatId: string): { objective: string; running: boolean } | null;
     /* The commands and monitors a chat's CLI runs in the background right now. */
     commandsOf(chatId: string): readonly ChatBackgroundTask[];
     /* The `background-limit` outbox entry of a task, which settles it once its commands ran too long. */
@@ -73,6 +78,10 @@ function restartedNote(commands: readonly string[]): string {
     return `The machine restarted while this still ran in the background: ${commandList(commands)}.`;
 }
 
+function goalLostNote(objective: string): string {
+    return `The agent stopped before its goal was met: ${objective}`;
+}
+
 /* What a settled turn of a child makes of its task. */
 export function resultOfTurn(turn: ChatTurnItem, items: readonly ChatItem[], at: number): { status: 'done' | 'failed'; result: TaskResult } {
     if (turn.state === 'done') {
@@ -90,8 +99,9 @@ export function resultOfTurn(turn: ChatTurnItem, items: readonly ChatItem[], at:
 /*
  * Settles tasks from what children do and does nothing else: it writes the task store and owes wakes
  * in the outbox, never starts a turn, since it runs inside the broadcast of the child it heard. A chat
- * child settles when a turn ends with none of its own tasks still open or waiting to wake it and no work
- * of its CLI's still running in the background, or once the commands it runs there outlast their limit;
+ * child settles when a turn ends with none of its own tasks still open or waiting to wake it, no goal
+ * still active and no work of its CLI's still running in the background, or once the commands it runs
+ * there outlast their limit;
  * an agent that is not a chat, which the host tells it about, settles only on `done`, or fails when it
  * ends without one.
  */
@@ -236,6 +246,16 @@ export class TaskCoordinator {
             this.hold(task, paused);
             return;
         }
+        // A goal holds the task with no limit, and the parent sleeps on through the turns its CLI opens toward it.
+        const goal = turn.state === 'done' ? (this.deps.activeGoal?.(chatId) ?? null) : null;
+        if (goal?.running === true) {
+            return;
+        }
+        if (goal !== null) {
+            const { result } = resultOfTurn(turn, items, this.deps.now());
+            this.settle(task, 'failed', { ...result, text: `${result.text}\n\n${goalLostNote(goal.objective)}`, source: 'exit' });
+            return;
+        }
         // A turn a person stopped or that failed ends the task as it always did, whatever still runs beside it.
         if (turn.state === 'done' && this.heldInBackground(chatId, task, items)) {
             this.track(

package/src/tasks/wiring.ts

@@ -106,6 +106,11 @@ export function wireTasks(deps: TaskWiringDeps): TaskWiring {
             return reportsOnBackgroundWork(chat.info.provider) ? 'reports' : 'silent';
         },
         commandsOf: (chatId) => chats.get(chatId)?.info.background ?? [],
+        activeGoal: (chatId) => {
+            const chat = chats.get(chatId);
+            const goal = chat?.info.goal;
+            return chat && goal?.status === 'active' ? { objective: goal.objective, running: chat.running } : null;
+        },
         limit
     });
 
@@ -142,7 +147,8 @@ export function wireTasks(deps: TaskWiringDeps): TaskWiring {
         }
         const stored = await chats.storedBackground(task.childId);
         const storedWork = stored.items.length > 0 || stored.commands.length > 0;
-        if (!deps.placed(task.childId) || (task.background === undefined && task.requiresTaskTurn !== true && !storedWork)) {
+        // A goal still active went down with the CLI, which its child's last turn settles on.
+        if (!deps.placed(task.childId) || (task.background === undefined && task.requiresTaskTurn !== true && !storedWork && !stored.goal)) {
             return;
         }
         if (task.background === undefined && stored.turnId !== null && storedWork) {

package/src/{providers/accounts/test-accounts.ts → testing/accounts.ts}

@@ -1,8 +1,8 @@
 import type { AgentKind, ProviderAccountMap, ProviderInfo } from '@adecore/agent-contracts';
-import { providerFor } from '../registry.ts';
-import { ProviderAccountsService } from './service.ts';
-import { accountsPath, writeAccounts } from './store.ts';
-import type { SecretStore } from './variables.ts';
+import { providerFor } from '../providers/registry.ts';
+import { ProviderAccountsService } from '../providers/accounts/service.ts';
+import { accountsPath, writeAccounts } from '../providers/accounts/store.ts';
+import type { SecretStore } from '../providers/accounts/variables.ts';
 
 /* A keychain in memory; `values` is what it holds, by key. */
 export function memorySecrets(values = new Map<string, string>()): SecretStore & { values: Map<string, string> } {

package/src/testing/bin/fake-claude.ts

@@ -0,0 +1,7 @@
+import { fakeClaude } from '../fake-claude.ts';
+import { runOverStdio } from '../fake-cli.ts';
+
+// Run as a script, it stands in for the Claude CLI behind real pipes; imported, it does nothing.
+if (import.meta.main) {
+    await runOverStdio(fakeClaude);
+}

package/src/testing/bin/fake-codex.ts

@@ -0,0 +1,7 @@
+import { fakeCodex } from '../fake-codex.ts';
+import { runOverStdio } from '../fake-cli.ts';
+
+// Run as a script, it stands in for `codex app-server` behind real pipes; imported, it does nothing.
+if (import.meta.main) {
+    await runOverStdio(fakeCodex);
+}

package/src/{chat → testing}/fake-claude.ts

@@ -5,7 +5,7 @@
 import { spawn } from 'node:child_process';
 import { writeFileSync } from 'node:fs';
 import { resolve } from 'node:path';
-import { runOverStdio, type FakeCli, type FakeIo, type FakeProgram } from './fake-cli.ts';
+import type { FakeCli, FakeIo, FakeProgram } from './fake-cli.ts';
 
 export function fakeClaude(io: FakeIo): FakeProgram {
     const args = io.argv;
@@ -1074,7 +1074,3 @@ export function claudeStoppingOnResume(sessionIds: ReadonlySet<string>, how: 'mi
         return { onLine: () => undefined };
     };
 }
-
-if (import.meta.main) {
-    await runOverStdio(fakeClaude);
-}

package/src/{chat → testing}/fake-cli.ts

@@ -1,4 +1,4 @@
-import type { ChatProcess, ChatSpawnOptions, SpawnChatProcess } from './chat-process.ts';
+import type { ChatProcess, ChatSpawnOptions, SpawnChatProcess } from '../chat/chat-process.ts';
 
 /* What a fake CLI has instead of `process`, so the same fake runs in a test and as a child process. */
 export interface FakeIo {

package/src/{chat → testing}/fake-codex.ts

@@ -1,8 +1,8 @@
 /*
  * Network-free `codex app-server` fake. Prompt commands exercise approvals, edits, questions,
- * interrupts, failures, names, subagents, pagination and forks through the real JSON-RPC shapes.
+ * interrupts, failures, names, subagents, pagination, forks and goals through the real JSON-RPC shapes.
  */
-import { runOverStdio, type FakeCli } from './fake-cli.ts';
+import type { FakeCli } from './fake-cli.ts';
 
 type Frame = Record<string, unknown>;
 
@@ -119,6 +119,37 @@ export function fakeCodexWith(options: FakeCodexOptions): FakeCli {
             turnId = '';
         };
 
+        /*
+         * The thread's goal (Codex 0.162.1). An objective `steps:N` takes N turns: the first is the one the client
+         * starts, which ends when the test says later is, and Codex opens every next one itself while the goal
+         * is active, also later, and marks the goal complete in the last.
+         */
+        let goal: Frame | null = null;
+        let goalSteps = 0;
+
+        const goalChanged = (): void => {
+            notify('thread/goal/updated', { threadId, turnId: turnId === '' ? null : turnId, goal });
+        };
+
+        const goalStep = (): void => {
+            goalSteps += 1;
+            agentMessage(`goal step ${goalSteps}`);
+            const needed = Number(/steps:(\d+)/.exec(String(goal?.objective ?? ''))?.[1] ?? '1');
+            if (goal !== null) {
+                goal = { ...goal, tokensUsed: Number(goal.tokensUsed) + 100, status: goalSteps >= needed ? 'complete' : goal.status };
+                goalChanged();
+            }
+            turnCompleted('completed');
+            if (goal?.status === 'active') {
+                io.later(() => {
+                    if (goal?.status === 'active') {
+                        turnStarted();
+                        goalStep();
+                    }
+                });
+            }
+        };
+
         let pendingApproval: PendingApproval | null = null;
         let pendingQuestion: { rpcId: number; questionId: string } | null = null;
         let pendingSteer = false;
@@ -160,6 +191,10 @@ export function fakeCodexWith(options: FakeCodexOptions): FakeCli {
             const user = item('userMessage', { clientId: null, content: [{ type: 'text', text, text_elements: [] }] });
             started(user);
             completed(user);
+            if (goal !== null && (text === goal.objective || text === '')) {
+                io.later(goalStep);
+                return;
+            }
             if (text === 'crash') {
                 io.exit(1);
                 return;
@@ -525,6 +560,44 @@ export function fakeCodexWith(options: FakeCodexOptions): FakeCli {
                         turnCompleted('interrupted');
                     }
                     return;
+                case 'thread/goal/get':
+                    out({ id, result: { goal } });
+                    return;
+                case 'thread/goal/set': {
+                    const at = Math.floor(Date.now() / 1000);
+                    if (typeof params.objective === 'string') {
+                        goal = {
+                            threadId,
+                            objective: params.objective,
+                            status: 'active',
+                            tokenBudget: null,
+                            tokensUsed: 0,
+                            timeUsedSeconds: 0,
+                            createdAt: at,
+                            updatedAt: at
+                        };
+                        goalSteps = 0;
+                    }
+                    if (goal === null) {
+                        out({ id, error: { code: -32600, message: 'no goal to update' } });
+                        return;
+                    }
+                    if (typeof params.status === 'string') {
+                        goal = { ...goal, status: params.status, updatedAt: at };
+                    }
+                    out({ id, result: { goal } });
+                    goalChanged();
+                    return;
+                }
+                case 'thread/goal/clear': {
+                    const cleared = goal !== null;
+                    goal = null;
+                    out({ id, result: { cleared } });
+                    if (cleared) {
+                        notify('thread/goal/cleared', { threadId });
+                    }
+                    return;
+                }
                 case 'thread/compact/start':
                     out({ id, result: {} });
                     turnStarted();
@@ -562,7 +635,3 @@ export function fakeCodexWith(options: FakeCodexOptions): FakeCli {
 }
 
 export const fakeCodex: FakeCli = fakeCodexWith({});
-
-if (import.meta.main) {
-    await runOverStdio(fakeCodex);
-}

package/src/testing/index.ts

@@ -0,0 +1,7 @@
+// Public API: exports.test.ts snapshots this list, so a name added or dropped here is an API change.
+export { type FakeIo, type FakeProgram, type FakeCli, type StartedFake, type InProcessCli, inProcess, runOverStdio } from './fake-cli.ts';
+export { fakeClaude, claudeStoppingOnResume } from './fake-claude.ts';
+export { FAKE_CHILD_STEPS, fakeCodexForks, type FakeCodexOptions, fakeCodexWith, fakeCodex } from './fake-codex.ts';
+export { memorySecrets, testAccounts } from './accounts.ts';
+export { ManualClock } from './manual-clock.ts';
+export { FakeDirectoryWatcher, FakeWatch, EventLog } from './watch.ts';

package/src/{outbox → testing}/manual-clock.ts

@@ -1,4 +1,4 @@
-import type { OutboxClock } from './outbox-worker.ts';
+import type { OutboxClock } from '../outbox/outbox-worker.ts';
 
 /* A clock a test moves by hand. A timer fires only inside `advance`, never on its own. */
 export class ManualClock implements OutboxClock {

package/src/{watch-test-helpers.ts → testing/watch.ts}

@@ -1,4 +1,4 @@
-import type { DirectoryWatcher, WatchDirectory, WatchSeams } from './watch-seam.ts';
+import type { DirectoryWatcher, WatchDirectory, WatchSeams } from '../watch-seam.ts';
 
 export class FakeDirectoryWatcher implements DirectoryWatcher {
     readonly path: string;