@adecore/agents 0.23.0 → 0.24.0

package/dist/chat/claude-backend.js

@@ -1,9 +1,12 @@
 import { randomUUID } from 'node:crypto';
 import { errorText } from '../error-text.js';
 import { claudeArgs, claudeEnv, promptPrefix } from '../providers/claude.js';
-import { ChatChild } from './chat-process.js';
+import { ChatChild, MAX_LINE_LENGTH, readStreamLines } from './chat-process.js';
 import { ClaudeProtocol } from './claude-protocol.js';
 import { buildUserMessage } from './input.js';
+// Claude may echo a steer only once a slow tool returns, so a running turn sets no deadline; after the turn ended, a message
+// it still holds opens the next turn at once or never arrives.
+const STEER_GRACE_MS = 30_000;
 /*
  * One `claude -p` process on the stream-json protocol: flags from the selection and the modes,
  * frames in over stdout, frames out over stdin. The process stays alive between turns; the session
@@ -15,17 +18,19 @@ export class ClaudeBackend {
     launch;
     host;
     allowedTools;
-    protocol = new ClaudeProtocol();
+    protocol;
     child = null;
     stdinClosed = false;
     // The person asked to stop; the result frame that follows closes the turn as aborted.
     interrupted = false;
     steers = new Map();
+    steerTimer = null;
     active = false;
     constructor(launch, host, options = {}) {
         this.launch = launch;
         this.host = host;
         this.allowedTools = options.allowedTools ?? [];
+        this.protocol = new ClaudeProtocol(launch.goal ?? null);
     }
     get running() {
         return this.child !== null;
@@ -51,7 +56,7 @@ export class ClaudeBackend {
             cwd: this.launch.cwd,
             env: { ...this.launch.env, ...claudeEnv(selection) },
             ...(this.launch.spawn ? { spawn: this.launch.spawn } : {}),
-            onError: (error) => this.failed(error),
+            onError: (error) => this.broken(error),
             onExit: (exitCode, stderr) => this.handleExit(child, exitCode, stderr)
         });
         this.child = child;
@@ -87,6 +92,7 @@ export class ClaudeBackend {
     }
     interrupt() {
         this.interrupted = true;
+        this.protocol.noteInterrupt();
         this.write({ type: 'control_request', request_id: `interrupt-${Date.now()}`, request: { subtype: 'interrupt' } });
     }
     stopTask(taskId) {
@@ -129,35 +135,18 @@ export class ClaudeBackend {
         return buildUserMessage({ text: input.text, attachments: input.attachments, prefix, skills: input.skills, promptId });
     }
     async readLines(child) {
-        const reader = child.process.stdout.getReader();
-        const decoder = new TextDecoder();
-        let buffered = '';
         try {
-            while (true) {
-                const { value, done } = await reader.read();
-                if (done) {
-                    break;
+            await readStreamLines(child.process.stdout, (line) => this.readLine(child, line), () => {
+                if (this.child === child) {
+                    this.failed(new Error(`Claude wrote a frame of more than ${MAX_LINE_LENGTH / 1_000_000} million characters, which was dropped`));
                 }
-                buffered += decoder.decode(value, { stream: true });
-                let newline = buffered.indexOf('\n');
-                while (newline >= 0) {
-                    this.readLine(child, buffered.slice(0, newline));
-                    buffered = buffered.slice(newline + 1);
-                    newline = buffered.indexOf('\n');
-                }
-            }
-            if (buffered.trim() !== '') {
-                this.readLine(child, buffered);
-            }
+            });
         }
         catch (error) {
             if (this.child === child) {
-                this.failed(error);
+                this.broken(error);
             }
         }
-        finally {
-            reader.releaseLock();
-        }
     }
     handleLine(child, line) {
         if (this.child !== child || line.trim() === '') {
@@ -174,10 +163,14 @@ export class ClaudeBackend {
         if (echoed?.type === 'user' && typeof echoed.uuid === 'string' && echoed.parent_tool_use_id == null) {
             this.steers.get(echoed.uuid)?.resolve(true);
             this.steers.delete(echoed.uuid);
+            if (this.steers.size === 0) {
+                this.clearSteerTimer();
+            }
         }
         for (const event of this.protocol.handle(frame)) {
             if (event.type === 'turn.done') {
                 this.active = false;
+                this.awaitSteers();
             }
             if (event.type === 'turn.done' && this.interrupted) {
                 this.interrupted = false;
@@ -195,13 +188,38 @@ export class ClaudeBackend {
             this.failed(error);
         }
     }
+    awaitSteers() {
+        if (this.steers.size === 0 || this.steerTimer !== null) {
+            return;
+        }
+        this.steerTimer = setTimeout(() => {
+            this.steerTimer = null;
+            for (const pending of this.steers.values()) {
+                pending.reject(new Error('Claude ended its turn without taking your message'));
+            }
+            this.steers.clear();
+        }, STEER_GRACE_MS);
+        this.steerTimer.unref?.();
+    }
+    clearSteerTimer() {
+        if (this.steerTimer !== null) {
+            clearTimeout(this.steerTimer);
+            this.steerTimer = null;
+        }
+    }
     rejectSteers(reason) {
         this.active = false;
+        this.clearSteerTimer();
         for (const pending of this.steers.values()) {
             pending.reject(new Error(reason));
         }
         this.steers.clear();
     }
+    /* A pipe that failed takes no more writes; a frame a consumer choked on leaves it as it was. */
+    broken(error) {
+        this.stdinClosed = true;
+        this.failed(error);
+    }
     failed(error) {
         this.rejectSteers(`Claude transport failed: ${errorText(error)}`);
         this.protocol.forgetPending();
@@ -228,8 +246,14 @@ export class ClaudeBackend {
         if (!child || this.stdinClosed) {
             throw new Error('Claude stdin is closed');
         }
-        child.process.stdin.write(`${JSON.stringify(frame)}\n`);
-        child.process.stdin.flush();
+        try {
+            child.process.stdin.write(`${JSON.stringify(frame)}\n`);
+            child.process.stdin.flush();
+        }
+        catch (error) {
+            this.stdinClosed = true;
+            throw error;
+        }
     }
     closeStdin() {
         if (!this.child || this.stdinClosed) {

package/dist/chat/claude-protocol.d.ts

@@ -1,4 +1,7 @@
+import type { ChatGoal } from '@adecore/agent-contracts';
 import type { ApprovalDecision, BackendEvent } from './backend.ts';
+export declare function claudeGoalFromCommand(text: string, current: ChatGoal | null): ChatGoal | null | undefined;
+export declare function claudeGoalCheck(text: string, current: ChatGoal | null): ChatGoal | undefined;
 export declare class ClaudeProtocol {
     private promptId;
     private readonly pending;
@@ -17,6 +20,13 @@ export declare class ClaudeProtocol {
     private readonly refusedWindows;
     private readonly stopRequests;
     private readonly steerIds;
+    private goal;
+    private goalAnswered;
+    private interrupting;
+    private readonly backgroundAgents;
+    constructor(goal?: ChatGoal | null);
+    noteInterrupt(): void;
+    private setGoal;
     beginSteer(promptId: string): void;
     beginPrompt(promptId: string): void;
     handle(frame: unknown): BackendEvent[];
@@ -34,6 +44,8 @@ export declare class ClaudeProtocol {
     private handleControlResponse;
     private handleStreamEvent;
     private handleAssistant;
+    private trackGoal;
+    private settleGoal;
     private handleToolProgress;
     private handleUser;
     private handleResult;

package/dist/chat/claude-protocol.js

@@ -1,8 +1,6 @@
+import { isRecord } from '@adecore/agent-contracts';
 import { readClaudeEvent } from '../usage/limits/normalize.js';
 import { claudeRuntimeMode } from '../providers/claude.js';
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
 function str(value) {
     return typeof value === 'string' ? value : null;
 }
@@ -89,6 +87,65 @@ function parseQuestions(input) {
         multiSelect: question.multiSelect === true
     }));
 }
+/*
+ * What Claude Code 2.1.296 answers a `/goal` with, as a `<synthetic>` assistant message of its own: the goal
+ * it set, the one it cleared, or the one that is active with how many turns its check sent back. Undefined
+ * for any other text, null where no goal is left.
+ */
+const GOAL_SET = 'Goal set: ';
+const GOAL_ACTIVE = /^Goal active: ([\s\S]+?) \(([^)]*)\)(?:\nLast check: ([\s\S]*))?$/;
+const GOAL_GONE = ['Goal cleared: ', 'Goal cleared after ', 'No goal set'];
+export function claudeGoalFromCommand(text, current) {
+    const said = text.trim();
+    if (said.startsWith(GOAL_SET)) {
+        const objective = said.slice(GOAL_SET.length).trim();
+        return objective === '' ? undefined : { objective, status: 'active', checks: 0 };
+    }
+    if (GOAL_GONE.some((prefix) => said.startsWith(prefix))) {
+        return null;
+    }
+    const active = GOAL_ACTIVE.exec(said);
+    if (!active) {
+        return undefined;
+    }
+    const objective = active[1];
+    const checks = /\d+/.exec(active[2])?.[0];
+    const lastCheck = active[3]?.trim();
+    return {
+        ...(current?.objective === objective ? current : {}),
+        objective,
+        status: 'active',
+        checks: checks === undefined ? 0 : Number(checks),
+        ...(lastCheck ? { lastCheck } : {})
+    };
+}
+// The messages whose blocks are still counted. The frames of one message come close together, so only the newest can still grow.
+const COUNTED_MESSAGES = 256;
+/* The ordinal of the next block of `messageId`; a count moves to the back on every block and the oldest goes. */
+function nextOrdinal(counts, messageId) {
+    const ordinal = counts.get(messageId) ?? 0;
+    counts.delete(messageId);
+    counts.set(messageId, ordinal + 1);
+    if (counts.size > COUNTED_MESSAGES) {
+        counts.delete(counts.keys().next().value);
+    }
+    return ordinal;
+}
+/*
+ * One check of the goal's Stop hook that found it not met yet: a synthetic user message the CLI feeds the
+ * agent before it goes on, which names the objective in brackets. Undefined for any other message.
+ */
+export function claudeGoalCheck(text, current) {
+    if (current === null) {
+        return undefined;
+    }
+    const prefix = `Stop hook feedback:\n[${current.objective}]: `;
+    if (!text.startsWith(prefix)) {
+        return undefined;
+    }
+    const lastCheck = text.slice(prefix.length).trim();
+    return { ...current, status: 'active', checks: (current.checks ?? 0) + 1, ...(lastCheck === '' ? {} : { lastCheck }) };
+}
 /*
  * Claude Code's stream-json frames, in and out. Text is keyed by message id plus the ordinal of the
  * text block inside that message, because the streaming events and the final `assistant` frames
@@ -120,6 +177,25 @@ export class ClaudeProtocol {
     // The task each `stop_task` request named, so an error answer finds it again.
     stopRequests = new Map();
     steerIds = new Set();
+    // The goal this process works toward, which `--resume` takes up from the transcript; a model answer since it was
+    // set or last checked is what lets a turn that ends normally count as its check passing.
+    goal;
+    goalAnswered = false;
+    interrupting = false;
+    // Background subagents still at work; Claude Code holds a goal's check until they report.
+    backgroundAgents = new Set();
+    constructor(goal = null) {
+        this.goal = goal;
+    }
+    /* A stop is on its way; the turn it ends leaves the goal set but nobody working on it. */
+    noteInterrupt() {
+        this.interrupting = true;
+    }
+    setGoal(goal, events) {
+        this.goal = goal;
+        this.goalAnswered = false;
+        events.push({ type: 'goal', goal });
+    }
     beginSteer(promptId) {
         this.steerIds.add(promptId);
     }
@@ -313,6 +389,7 @@ export class ClaudeProtocol {
             if (taskId) {
                 this.endBackground(taskId, events);
                 this.workflows.delete(taskId);
+                this.backgroundAgents.delete(taskId);
             }
             // The CLI wakes the main agent itself when a background task settles; this frame is the only
             // thing that says what it was about, and it arrives before the turn nobody asked for.
@@ -335,6 +412,10 @@ export class ClaudeProtocol {
     handleTaskStarted(frame, events) {
         const ref = str(frame.tool_use_id);
         if (frame.task_type === 'local_agent') {
+            const agentTask = str(frame.task_id);
+            if (agentTask && frame.is_backgrounded === true) {
+                this.backgroundAgents.add(agentTask);
+            }
             if (ref) {
                 events.push({
                     type: 'task.started',
@@ -383,6 +464,7 @@ export class ClaudeProtocol {
         const status = str(patch.status);
         if (status !== null && ENDED_TASK_STATUSES.has(status)) {
             this.foregroundShells.delete(taskId);
+            this.backgroundAgents.delete(taskId);
             this.endBackground(taskId, events);
             this.endWorkflow(taskId, null, status === 'completed', events);
         }
@@ -485,6 +567,9 @@ export class ClaudeProtocol {
             this.apiError = frame.error;
         }
         const model = str(message.model);
+        if (!parentRef) {
+            this.trackGoal(model, content, events);
+        }
         // The CLI answers some frames itself and names them `<synthetic>`; no model wrote those.
         if (parentRef && model && model !== '<synthetic>' && this.subagentModels.get(parentRef) !== model) {
             this.subagentModels.set(parentRef, model);
@@ -495,14 +580,12 @@ export class ClaudeProtocol {
                 continue;
             }
             if (block.type === 'text') {
-                const ordinal = this.frameTextCount.get(messageId) ?? 0;
-                this.frameTextCount.set(messageId, ordinal + 1);
+                const ordinal = nextOrdinal(this.frameTextCount, messageId);
                 // A subagent's text is its own report, not the thread's answer; the parent says whose row it is.
                 events.push({ type: 'text.done', ref: this.textRef(messageId, ordinal), text: str(block.text) ?? '', ...(parentRef ? { parentRef } : {}) });
             }
             else if (block.type === 'thinking' && !parentRef) {
-                const ordinal = this.frameThinkingCount.get(messageId) ?? 0;
-                this.frameThinkingCount.set(messageId, ordinal + 1);
+                const ordinal = nextOrdinal(this.frameThinkingCount, messageId);
                 events.push({ type: 'thinking.done', ref: this.thinkingRef(messageId, ordinal), text: str(block.thinking) ?? '' });
             }
             else if (block.type === 'tool_use') {
@@ -524,6 +607,44 @@ export class ClaudeProtocol {
             events.push({ type: 'note', level: 'error', text: `The request failed: ${error.replaceAll('_', ' ')}` });
         }
     }
+    trackGoal(model, content, events) {
+        if (model === '<synthetic>') {
+            const next = claudeGoalFromCommand(resultText(content), this.goal);
+            if (next !== undefined) {
+                this.setGoal(next, events);
+            }
+            return;
+        }
+        if (this.goal === null) {
+            return;
+        }
+        this.goalAnswered = true;
+        // A message after a stop takes the goal up again; its hook never went away.
+        if (this.goal.status === 'paused') {
+            this.goal = { ...this.goal, status: 'active' };
+            events.push({ type: 'goal', goal: this.goal });
+        }
+    }
+    /*
+     * Where a turn leaves the goal. Claude Code ends a turn on its own only once the goal's check passed, so
+     * a turn that ends normally after the model answered met it; Claude Code 2.1.296 says nothing more
+     * about it in stream-json. A check it defers while background work runs leaves the goal active, and a
+     * stopped or failed turn leaves it set with nobody working on it.
+     */
+    settleGoal(failed, events) {
+        const goal = this.goal;
+        const interrupted = this.interrupting;
+        this.interrupting = false;
+        if (goal?.status !== 'active') {
+            return;
+        }
+        if (failed || interrupted) {
+            this.setGoal({ ...goal, status: 'paused' }, events);
+        }
+        else if (this.goalAnswered && this.backgroundTasks.size === 0 && this.workflows.size === 0 && this.backgroundAgents.size === 0) {
+            this.setGoal({ ...goal, status: 'complete' }, events);
+        }
+    }
     /*
      * `tool_progress` carries how long the call has run (once per 30 s for a Bash under the CLI's
      * remote gate, or a heartbeat for a slow MCP tool); the start is kept so the client can count on.
@@ -543,6 +664,13 @@ export class ClaudeProtocol {
         }
         const message = isRecord(frame.message) ? frame.message : {};
         const content = Array.isArray(message.content) ? message.content : [];
+        if (frame.isSynthetic === true && !str(frame.parent_tool_use_id)) {
+            const checked = claudeGoalCheck(resultText(message.content), this.goal);
+            if (checked !== undefined) {
+                this.setGoal(checked, events);
+                events.push({ type: 'note', level: 'info', text: `Goal not met yet: ${checked.lastCheck ?? checked.objective}` });
+            }
+        }
         for (const block of content) {
             if (!isRecord(block) || block.type !== 'tool_result') {
                 continue;
@@ -587,6 +715,8 @@ export class ClaudeProtocol {
         const limit = failed ? this.limit() : null;
         this.apiError = null;
         this.refusedWindows.clear();
+        // Before the turn ends, so whoever settles work on that end already reads where the goal stands.
+        this.settleGoal(failed, events);
         events.push({
             type: 'turn.done',
             ...(promptId === null ? {} : { promptId }),

package/dist/chat/claude-title.d.ts

@@ -1,11 +1,9 @@
 export declare class ClaudeTitleReader {
     private readonly progress;
-    private readonly found;
     private readonly projectsDir;
     private readonly chunkBytes;
     constructor(projectsDir?: string, chunkBytes?: number);
-    forSession(agentSessionId: string, projectsDir?: string): Promise<string | null>;
+    forSession(agentSessionId: string, projectsDir?: string, cwd?: string): Promise<string | null>;
     forTranscript(path: string): Promise<string | null>;
     private take;
-    private locate;
 }

package/dist/chat/claude-title.js

@@ -1,8 +1,8 @@
-import { existsSync } from 'node:fs';
-import { readdir, stat } from 'node:fs/promises';
-import { join } from 'node:path';
+import { stat } from 'node:fs/promises';
+import { isRecord } from '@adecore/agent-contracts';
 import { cleanTitle, readLines } from '../title-file.js';
 import { usageRoots } from '../usage/roots.js';
+import { findClaudeSession } from './claude-transcript.js';
 // The two records carry these words; a line without them is never parsed.
 const MARKERS = ['"ai-title"', '"custom-title"'];
 /*
@@ -14,16 +14,15 @@ const MARKERS = ['"ai-title"', '"custom-title"'];
  */
 export class ClaudeTitleReader {
     progress = new Map();
-    found = new Map();
     projectsDir;
     chunkBytes;
     constructor(projectsDir = usageRoots().find((root) => root.provider === 'claude')?.path ?? '', chunkBytes = 4 * 1024 * 1024) {
         this.projectsDir = projectsDir;
         this.chunkBytes = chunkBytes;
     }
-    /* The title of a session found by its id, for a chat, which knows no transcript path; in the projects of its account. */
-    async forSession(agentSessionId, projectsDir = this.projectsDir) {
-        const path = await this.locate(agentSessionId, projectsDir);
+    /* The title of a session found by its id, for a chat, which knows no transcript path; in the projects of its account, its own folder first. */
+    async forSession(agentSessionId, projectsDir = this.projectsDir, cwd) {
+        const path = await findClaudeSession(projectsDir, agentSessionId, cwd);
         return path === null ? null : await this.forTranscript(path);
     }
     async forTranscript(path) {
@@ -57,41 +56,14 @@ export class ClaudeTitleReader {
         catch {
             return;
         }
-        if (typeof record !== 'object' || record === null) {
+        if (!isRecord(record)) {
             return;
         }
-        const entry = record;
-        if (entry.type === 'ai-title') {
-            progress.aiTitle = cleanTitle(entry.aiTitle) ?? progress.aiTitle;
+        if (record.type === 'ai-title') {
+            progress.aiTitle = cleanTitle(record.aiTitle) ?? progress.aiTitle;
         }
-        else if (entry.type === 'custom-title') {
-            progress.customTitle = cleanTitle(entry.customTitle) ?? progress.customTitle;
+        else if (record.type === 'custom-title') {
+            progress.customTitle = cleanTitle(record.customTitle) ?? progress.customTitle;
         }
     }
-    /* The folder a transcript sits in is named after the working directory, so the file name is the only key a session id gives. */
-    async locate(agentSessionId, projectsDir) {
-        const known = this.found.get(agentSessionId);
-        if (known !== undefined && existsSync(known)) {
-            return known;
-        }
-        if (projectsDir === '' || agentSessionId.includes('/')) {
-            return null;
-        }
-        let dirs;
-        try {
-            dirs = await readdir(projectsDir);
-        }
-        catch {
-            return null;
-        }
-        const file = `${agentSessionId}.jsonl`;
-        for (const dir of dirs) {
-            const path = join(projectsDir, dir, file);
-            if (existsSync(path)) {
-                this.found.set(agentSessionId, path);
-                return path;
-            }
-        }
-        return null;
-    }
 }

package/dist/chat/claude-transcript.d.ts

@@ -8,6 +8,7 @@ export interface SubagentMeta {
     transcript: string;
 }
 export declare function claudeProjectSlug(cwd: string): string;
+export declare function findClaudeSession(projectsDir: string, sessionId: string, cwd?: string): Promise<string | null>;
 export declare function findSubagentsDir(projectsDir: string, cwd: string, sessionId: string): Promise<string | null>;
 export declare function readSubagentMetas(dir: string): Promise<SubagentMeta[]>;
 export declare function findWorkflowAgent(subagentsDir: string, agentId: string): Promise<SubagentMeta | null>;

package/dist/chat/claude-transcript.js

@@ -1,13 +1,12 @@
 import { existsSync } from 'node:fs';
 import { readdir, readFile, stat } from 'node:fs/promises';
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
+import { isRecord } from '@adecore/agent-contracts';
+import { fileExists } from '../fs.js';
 import { readLines } from '../title-file.js';
 import { ClaudeProtocol } from './claude-protocol.js';
 import { readingThread, settledReading } from './subagent-projection.js';
 const CHUNK_BYTES = 4 * 1024 * 1024;
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
 function str(value) {
     return typeof value === 'string' && value !== '' ? value : null;
 }
@@ -26,19 +25,30 @@ export function spokenText(content) {
 export function claudeProjectSlug(cwd) {
     return cwd.replace(/[^a-zA-Z0-9]/g, '-');
 }
+// Where each session was found last, by projects folder and session id; a path whose file went is searched for again.
+const sessionPaths = new Map();
 /*
- * Where the subagents of a session keep their transcripts. The folder of the chat's own directory
- * first; a slug the CLI wrote differently (or a session resumed from somewhere else) is found by the
- * session id alone, which is unique across every project.
+ * The transcript Claude Code keeps of a session, found by its id: in the folder of `cwd` first, then
+ * where it was found before, then in every project folder, since the id is unique across all of them
+ * and a slug the CLI wrote differently (or a session resumed from elsewhere) sits in another folder.
+ * Null when no folder holds it, and for an id that would reach outside the projects folder.
  */
-export async function findSubagentsDir(projectsDir, cwd, sessionId) {
-    if (projectsDir === '' || sessionId.includes('/') || sessionId.includes('..')) {
+export async function findClaudeSession(projectsDir, sessionId, cwd) {
+    if (projectsDir === '' || sessionId === '' || /[/\\]|\.\./.test(sessionId)) {
         return null;
     }
-    const own = join(projectsDir, claudeProjectSlug(cwd), sessionId, 'subagents');
-    if (existsSync(own)) {
+    const file = `${sessionId}.jsonl`;
+    const key = `${projectsDir}\n${sessionId}`;
+    const own = cwd === undefined ? null : join(projectsDir, claudeProjectSlug(cwd), file);
+    if (own !== null && (await fileExists(own))) {
+        sessionPaths.set(key, own);
         return own;
     }
+    const known = sessionPaths.get(key);
+    if (known !== undefined && known !== own && (await fileExists(known))) {
+        return known;
+    }
+    sessionPaths.delete(key);
     let dirs;
     try {
         dirs = await readdir(projectsDir);
@@ -46,13 +56,22 @@ export async function findSubagentsDir(projectsDir, cwd, sessionId) {
     catch {
         return null;
     }
-    for (const dir of dirs) {
-        const candidate = join(projectsDir, dir, sessionId, 'subagents');
-        if (existsSync(candidate)) {
-            return candidate;
-        }
+    const candidates = dirs.map((dir) => join(projectsDir, dir, file)).filter((candidate) => candidate !== own);
+    const present = await Promise.all(candidates.map(fileExists));
+    const found = candidates.find((_candidate, i) => present[i]) ?? null;
+    if (found !== null) {
+        sessionPaths.set(key, found);
     }
-    return null;
+    return found;
+}
+/* Where the subagents of a session keep their transcripts: the folder beside its own transcript, once the CLI made it. */
+export async function findSubagentsDir(projectsDir, cwd, sessionId) {
+    const transcript = await findClaudeSession(projectsDir, sessionId, cwd);
+    if (transcript === null) {
+        return null;
+    }
+    const dir = join(dirname(transcript), sessionId, 'subagents');
+    return (await fileExists(dir)) ? dir : null;
 }
 /* Every meta file in a subagents folder that says which agent it is about; one that does not parse is left out. */
 export async function readSubagentMetas(dir) {

package/dist/chat/codex-backend.d.ts

@@ -1,7 +1,20 @@
-import { type ChatSkill } from '@adecore/agent-contracts';
+import { type ChatGoalAction, type ChatSkill } from '@adecore/agent-contracts';
 import type { ApprovalDecision, BackendHost, BackendLaunch, ChatBackend, TurnInput } from './backend.ts';
 import { type CodexClientInfo } from './codex-transport.ts';
 export declare function parseSkillsList(result: unknown): ChatSkill[];
+export type GoalCommand = {
+    kind: 'show';
+} | {
+    kind: 'clear';
+} | {
+    kind: 'pause';
+} | {
+    kind: 'resume';
+} | {
+    kind: 'set';
+    objective: string;
+};
+export declare function parseGoalCommand(text: string): GoalCommand | null;
 export interface CodexBackendOptions {
     client?: CodexClientInfo;
 }
@@ -20,12 +33,19 @@ export declare class CodexBackend implements ChatBackend {
     private imageInputSupported;
     private turnUnnamed;
     private interruptOwed;
+    private goalNow;
     constructor(launch: BackendLaunch, host: BackendHost, options?: CodexBackendOptions);
     get running(): boolean;
     get pid(): number | null;
     start(): Promise<void>;
+    private handshake;
+    private readGoal;
     private turnInput;
     sendTurn(input: TurnInput): void;
+    private turnStartParams;
+    private runGoalCommand;
+    private reply;
+    goal(action: ChatGoalAction): Promise<void>;
     steerTurn(input: TurnInput): Promise<boolean>;
     private acceptPrompt;
     private fail;