@phnx-labs/agents-cli 1.20.56 → 1.20.58

package/dist/lib/session/parse.js

@@ -55,6 +55,8 @@ function sanitizeEvent(e) {
         e.command = sanitizeForTerminal(e.command);
     if (e.path)
         e.path = sanitizeForTerminal(e.path);
+    if (e.name)
+        e.name = sanitizeForTerminal(e.name);
     if (e.output)
         e.output = sanitizeForTerminal(e.output);
     if (e.tool)
@@ -66,6 +68,36 @@ function sanitizeEvent(e) {
     if (e.args)
         e.args = sanitizeArgsDeep(e.args);
 }
+function firstString(...values) {
+    for (const value of values) {
+        if (typeof value === 'string' && value.trim())
+            return value.trim();
+    }
+    return undefined;
+}
+function attachmentPath(block, source) {
+    return firstString(source?.path, source?.file_path, source?.filePath, source?.url, source?.ref, block?.path, block?.file_path, block?.filePath, block?.ref);
+}
+function attachmentName(block, source, filePath) {
+    return firstString(block?.name, block?.title, source?.name, source?.filename, source?.file_name, source?.fileName, filePath ? path.basename(filePath) : undefined);
+}
+function normalizedAttachmentEvent(agent, timestamp, block, source, defaultMediaType, sizeBytes) {
+    const filePath = attachmentPath(block, source);
+    const name = attachmentName(block, source, filePath);
+    const explicitSize = typeof source?.sizeBytes === 'number' ? source.sizeBytes :
+        typeof source?.size === 'number' ? source.size :
+            typeof block?.sizeBytes === 'number' ? block.sizeBytes :
+                undefined;
+    return {
+        type: 'attachment',
+        agent,
+        timestamp,
+        path: filePath,
+        name,
+        mediaType: firstString(source?.media_type, source?.mediaType, block?.media_type, block?.mediaType) || defaultMediaType,
+        sizeBytes: sizeBytes || explicitSize || 0,
+    };
+}
 /**
  * Read a session file, refusing files above maxBytes. Bounded read protects
  * against multi-GB session blobs that would OOM the CLI or exceed V8's
@@ -351,24 +383,15 @@ export function parseClaudeContent(content) {
                         const source = block.source || {};
                         if (source.type === 'base64') {
                             const sizeBytes = Math.ceil((source.data?.length || 0) * 0.75);
-                            events.push({
-                                type: 'attachment',
-                                agent: 'claude',
-                                timestamp,
-                                mediaType: source.media_type || 'image/png',
-                                sizeBytes,
-                            });
+                            events.push(normalizedAttachmentEvent('claude', timestamp, block, source, 'image/png', sizeBytes));
+                        }
+                        else {
+                            events.push(normalizedAttachmentEvent('claude', timestamp, block, source, 'image/png', 0));
                         }
                     }
                     else if (block.type === 'document') {
                         const source = block.source || {};
-                        events.push({
-                            type: 'attachment',
-                            agent: 'claude',
-                            timestamp,
-                            mediaType: source.media_type || 'application/pdf',
-                            sizeBytes: 0,
-                        });
+                        events.push(normalizedAttachmentEvent('claude', timestamp, block, source, 'application/pdf', 0));
                     }
                     else if (block.type === 'tool_result') {
                         const toolId = block.tool_use_id;
@@ -1554,7 +1577,7 @@ export function parseDroid(filePath) {
             else if (block.type === 'image') {
                 const source = block.source || {};
                 const sizeBytes = source.type === 'base64' ? Math.ceil((source.data?.length || 0) * 0.75) : 0;
-                events.push({ type: 'attachment', agent: 'droid', timestamp, mediaType: source.media_type || 'image/png', sizeBytes });
+                events.push(normalizedAttachmentEvent('droid', timestamp, block, source, 'image/png', sizeBytes));
             }
         }
     }

package/dist/lib/session/state.d.ts

@@ -14,7 +14,7 @@
  * markers. Codex has no such tools, so it falls back to last-role + question
  * shape + mtime — same function, driven off the normalized events.
  */
-import type { SessionEvent } from './types.js';
+import type { SessionAttachment, SessionEvent } from './types.js';
 export type SessionActivity = 'working' | 'waiting_input' | 'idle';
 export type AwaitingReason = 'question' | 'plan_review' | 'permission';
 /** One discrete choice the agent offered the user. */
@@ -98,6 +98,8 @@ export interface SessionState {
     createdTickets?: string[];
     /** Team name this session SPAWNED via `agents teams create/add`. */
     spawnedTeam?: string;
+    /** Displayable files/screenshots attached to the session prompt. */
+    attachments?: SessionAttachment[];
 }
 export interface StateContext {
     /** Session file mtime; drives running-vs-stale. */
@@ -169,6 +171,7 @@ export declare function detectDurableSignals(events: SessionEvent[]): {
     ticket?: DetectedTicket;
     createdTickets?: string[];
     spawnedTeam?: string;
+    attachments?: SessionAttachment[];
 };
 /** Full inference: activity + preview + durable signals + worktree/ticket from ctx. */
 export declare function inferSessionState(events: SessionEvent[], ctx?: StateContext): SessionState;

package/dist/lib/session/state.js

@@ -352,6 +352,8 @@ export function detectDurableSignals(events) {
     let sawTicketCreate = false;
     let spawnedTeam;
     const createdTickets = new Set();
+    const attachments = [];
+    const seenAttachments = new Set();
     for (const e of events) {
         // Structural PR signal: a real `gh pr create` tool call, then the pull URL
         // from a following tool_result — never a bare URL mentioned in prose.
@@ -384,18 +386,32 @@ export function detectDurableSignals(events) {
         if (!ticket && e.type === 'message' && e.role === 'user') {
             ticket = detectTicket(e.content);
         }
+        if (e.type === 'attachment') {
+            const mediaType = e.mediaType || 'application/octet-stream';
+            const key = e.path || e.name || `${mediaType}:${e.sizeBytes ?? 0}:${e.timestamp}`;
+            if (key && !seenAttachments.has(key)) {
+                seenAttachments.add(key);
+                attachments.push({
+                    path: e.path,
+                    name: e.name,
+                    mediaType,
+                    sizeBytes: e.sizeBytes,
+                });
+            }
+        }
     }
     return {
         pr,
         ticket,
         createdTickets: createdTickets.size > 0 ? [...createdTickets] : undefined,
         spawnedTeam,
+        attachments: attachments.length > 0 ? attachments : undefined,
     };
 }
 /** Full inference: activity + preview + durable signals + worktree/ticket from ctx. */
 export function inferSessionState(events, ctx = {}) {
     const state = inferActivity(events, ctx);
-    const { pr, ticket, createdTickets, spawnedTeam } = detectDurableSignals(events);
+    const { pr, ticket, createdTickets, spawnedTeam, attachments } = detectDurableSignals(events);
     const worktree = detectWorktree(ctx.cwd, ctx.gitBranch);
     // Rate-limit: scan the most recent assistant messages + tool errors (tail-first).
     let rateLimited = false;
@@ -421,6 +437,7 @@ export function inferSessionState(events, ctx = {}) {
         ticket: ticket ?? detectTicket(undefined, ctx.gitBranch) ?? state.ticket,
         createdTickets,
         spawnedTeam,
+        attachments,
         rateLimited: rateLimited || undefined,
     };
 }

package/dist/lib/session/types.d.ts

@@ -30,9 +30,17 @@ export interface SessionEvent {
     outputTokens?: number;
     cacheReadTokens?: number;
     cacheCreationTokens?: number;
+    name?: string;
     mediaType?: string;
     sizeBytes?: number;
 }
+/** A displayable file attachment discovered in a session transcript. */
+export interface SessionAttachment {
+    path?: string;
+    name?: string;
+    mediaType: string;
+    sizeBytes?: number;
+}
 /** Metadata attached when a session was spawned by `agents teams`. */
 export interface TeamOrigin {
     /** Teammate name if set, otherwise first 8 chars of the agent UUID. */

package/dist/lib/staleness/detectors/permissions.js

@@ -13,6 +13,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import * as TOML from 'smol-toml';
+import * as yaml from 'yaml';
 import { capableAgents } from '../../capabilities.js';
 import { discoverPermissionGroups, buildPermissionsFromGroups, CODEX_RULES_FILENAME, } from '../../permissions.js';
 import { lazyAgentMap } from '../writers/lazy-map.js';
@@ -181,6 +182,45 @@ function buildKimiDetector() {
         },
     };
 }
+function buildCursorDetector() {
+    return {
+        kind: 'permissions',
+        agent: 'cursor',
+        list({ versionHome }) {
+            const configPath = path.join(versionHome, '.cursor', 'cli-config.json');
+            if (!fs.existsSync(configPath))
+                return [];
+            try {
+                const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+                const allow = config.permissions?.allow?.length ?? 0;
+                const deny = config.permissions?.deny?.length ?? 0;
+                if (allow + deny > 0)
+                    return discoverPermissionGroups().map(g => g.name);
+            }
+            catch { /* parse fail */ }
+            return [];
+        },
+    };
+}
+function buildKiroDetector() {
+    return {
+        kind: 'permissions',
+        agent: 'kiro',
+        list({ versionHome }) {
+            const permissionsPath = path.join(versionHome, '.kiro', 'settings', 'permissions.yaml');
+            if (!fs.existsSync(permissionsPath))
+                return [];
+            try {
+                const config = yaml.parse(fs.readFileSync(permissionsPath, 'utf-8'));
+                if (config && Array.isArray(config.rules) && config.rules.length > 0) {
+                    return discoverPermissionGroups().map(g => g.name);
+                }
+            }
+            catch { /* parse fail */ }
+            return [];
+        },
+    };
+}
 const handlers = {
     claude: buildClaudeDetector,
     codex: buildCodexDetector,
@@ -189,6 +229,8 @@ const handlers = {
     antigravity: buildAntigravityDetector,
     grok: buildGrokDetector,
     kimi: buildKimiDetector,
+    cursor: buildCursorDetector,
+    kiro: buildKiroDetector,
 };
 export const permissionsDetectors = lazyAgentMap(() => {
     const m = {};

package/dist/lib/staleness/detectors/subagents.js

@@ -57,6 +57,20 @@ function buildDroidDetector() {
         },
     };
 }
+function buildCopilotDetector() {
+    return {
+        kind: 'subagents',
+        agent: 'copilot',
+        list({ versionHome }) {
+            const agentsDir = path.join(versionHome, '.copilot', 'agents');
+            if (!fs.existsSync(agentsDir))
+                return [];
+            return fs.readdirSync(agentsDir)
+                .filter(f => f.endsWith('.agent.md'))
+                .map(f => f.replace('.agent.md', ''));
+        },
+    };
+}
 function buildOpenclawDetector() {
     return {
         kind: 'subagents',
@@ -71,6 +85,20 @@ function buildOpenclawDetector() {
         },
     };
 }
+function buildKiroDetector() {
+    return {
+        kind: 'subagents',
+        agent: 'kiro',
+        list({ versionHome }) {
+            const agentsDir = path.join(versionHome, '.kiro', 'agents');
+            if (!fs.existsSync(agentsDir))
+                return [];
+            return fs.readdirSync(agentsDir)
+                .filter(f => f.endsWith('.json'))
+                .map(f => f.replace('.json', ''));
+        },
+    };
+}
 function buildKimiDetector() {
     return {
         kind: 'subagents',
@@ -102,12 +130,14 @@ function buildOpenCodeDetector() {
 }
 const handlers = {
     claude: buildClaudeDetector,
+    copilot: buildCopilotDetector,
     grok: buildGrokDetector,
     codex: buildCodexDetector,
     kimi: buildKimiDetector,
     opencode: buildOpenCodeDetector,
     droid: buildDroidDetector,
     openclaw: buildOpenclawDetector,
+    kiro: buildKiroDetector,
 };
 export const subagentsDetectors = lazyAgentMap(() => {
     const m = {};

package/dist/lib/staleness/writers/subagents.js

@@ -13,7 +13,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { capableAgents } from '../../capabilities.js';
-import { listInstalledSubagents, transformSubagentForClaude, transformSubagentForCodex, writeKimiSubagentFiles, buildKimiSubagentsParentYaml, KIMI_SUBAGENTS_PARENT_FILE, transformSubagentForOpenCode, transformSubagentForDroid, syncSubagentToOpenclaw, parseSubagentFrontmatter, } from '../../subagents.js';
+import { listInstalledSubagents, transformSubagentForClaude, transformSubagentForCodex, transformSubagentForCopilot, writeKimiSubagentFiles, buildKimiSubagentsParentYaml, KIMI_SUBAGENTS_PARENT_FILE, transformSubagentForOpenCode, transformSubagentForDroid, transformSubagentForKiro, syncSubagentToOpenclaw, parseSubagentFrontmatter, } from '../../subagents.js';
 import { safeJoin } from '../../paths.js';
 import { lazyAgentMap } from './lazy-map.js';
 function buildSubagentsWriter(agent) {
@@ -57,12 +57,24 @@ function buildSubagentsWriter(agent) {
                         fs.writeFileSync(safeJoin(droidsDir, `${sub.name}.md`), transformSubagentForDroid(sub.path));
                         synced.push(sub.name);
                     }
+                    else if (agent === 'copilot') {
+                        const agentsDir = path.join(versionHome, '.copilot', 'agents');
+                        fs.mkdirSync(agentsDir, { recursive: true });
+                        fs.writeFileSync(safeJoin(agentsDir, `${sub.name}.agent.md`), transformSubagentForCopilot(sub.path));
+                        synced.push(sub.name);
+                    }
                     else if (agent === 'openclaw') {
                         const target = safeJoin(path.join(versionHome, '.openclaw'), sub.name);
                         const r = syncSubagentToOpenclaw(sub.path, target);
                         if (r.success)
                             synced.push(sub.name);
                     }
+                    else if (agent === 'kiro') {
+                        const agentsDir = path.join(versionHome, '.kiro', 'agents');
+                        fs.mkdirSync(agentsDir, { recursive: true });
+                        fs.writeFileSync(safeJoin(agentsDir, `${sub.name}.json`), transformSubagentForKiro(sub.path));
+                        synced.push(sub.name);
+                    }
                 }
                 catch { /* per-item sync failure: skip */ }
             }

package/dist/lib/subagents.d.ts

@@ -56,6 +56,18 @@ export declare function transformSubagentForClaude(subagentDir: string): string;
  * See https://docs.factory.ai/cli/configuration/custom-droids.
  */
 export declare function transformSubagentForDroid(subagentDir: string): string;
+/**
+ * Transform a subagent into a GitHub Copilot CLI custom agent `.agent.md` file.
+ *
+ * Copilot custom agents are Markdown profiles with YAML frontmatter stored in
+ * `~/.copilot/agents/` (user) or `.github/agents/` (project). The file name
+ * ends in `.agent.md` and the frontmatter carries `name`, `description`, and
+ * optionally `model` and `tools`. The emitted body is identical to Factory
+ * Droid's custom-droid format (flatten frontmatter + body + appended .md
+ * sections, `color` dropped), so this is an alias of transformSubagentForDroid.
+ * See GitHub docs for custom agents.
+ */
+export declare const transformSubagentForCopilot: typeof transformSubagentForDroid;
 /**
  * Transform a subagent into an OpenCode agent markdown file.
  *
@@ -107,6 +119,16 @@ export declare function writeKimiSubagentFiles(agentsDir: string, subagentDir: s
  * https://developers.openai.com/codex/subagents (custom agents section)
  */
 export declare function transformSubagentForCodex(subagentDir: string): string;
+/**
+ * Transform a subagent into a Kiro CLI custom-agent JSON file.
+ *
+ * Kiro custom agents live in `~/.kiro/agents/<name>.json` (or `.kiro/agents/`
+ * workspace-local) and declare name, description, prompt, tools, and optional
+ * model. We flatten the AGENT.md frontmatter + body plus any sibling .md files
+ * as sections into a single `prompt`, and expose the standard built-in tool
+ * set so the subagent can actually run.
+ */
+export declare function transformSubagentForKiro(subagentDir: string): string;
 /**
  * Sync a subagent to an OpenClaw workspace
  * Copies full directory, renames AGENT.md to AGENTS.md

package/dist/lib/subagents.js

@@ -262,6 +262,18 @@ export function transformSubagentForDroid(subagentDir) {
     }
     return result;
 }
+/**
+ * Transform a subagent into a GitHub Copilot CLI custom agent `.agent.md` file.
+ *
+ * Copilot custom agents are Markdown profiles with YAML frontmatter stored in
+ * `~/.copilot/agents/` (user) or `.github/agents/` (project). The file name
+ * ends in `.agent.md` and the frontmatter carries `name`, `description`, and
+ * optionally `model` and `tools`. The emitted body is identical to Factory
+ * Droid's custom-droid format (flatten frontmatter + body + appended .md
+ * sections, `color` dropped), so this is an alias of transformSubagentForDroid.
+ * See GitHub docs for custom agents.
+ */
+export const transformSubagentForCopilot = transformSubagentForDroid;
 /**
  * Transform a subagent into an OpenCode agent markdown file.
  *
@@ -409,6 +421,43 @@ export function transformSubagentForCodex(subagentDir) {
     toml += `developer_instructions = """\n${safeInstructions}\n"""\n`;
     return toml;
 }
+/**
+ * Transform a subagent into a Kiro CLI custom-agent JSON file.
+ *
+ * Kiro custom agents live in `~/.kiro/agents/<name>.json` (or `.kiro/agents/`
+ * workspace-local) and declare name, description, prompt, tools, and optional
+ * model. We flatten the AGENT.md frontmatter + body plus any sibling .md files
+ * as sections into a single `prompt`, and expose the standard built-in tool
+ * set so the subagent can actually run.
+ */
+export function transformSubagentForKiro(subagentDir) {
+    const agentMd = path.join(subagentDir, 'AGENT.md');
+    const frontmatter = parseSubagentFrontmatter(agentMd);
+    const body = getSubagentBody(agentMd);
+    if (!frontmatter) {
+        throw new Error(`Invalid AGENT.md in ${subagentDir}`);
+    }
+    const files = fs.readdirSync(subagentDir)
+        .filter(f => f.endsWith('.md') && f !== 'AGENT.md')
+        .sort();
+    let prompt = body;
+    for (const file of files) {
+        const content = fs.readFileSync(path.join(subagentDir, file), 'utf-8').trim();
+        const sectionName = file.replace('.md', '');
+        const title = sectionName.charAt(0).toUpperCase() + sectionName.slice(1).toLowerCase();
+        prompt += `\n\n## ${title}\n\n${content}`;
+    }
+    const config = {
+        name: frontmatter.name,
+        description: frontmatter.description,
+        prompt,
+        tools: ['read', 'write', 'shell', 'web_search', 'web_fetch'],
+    };
+    if (frontmatter.model) {
+        config.model = frontmatter.model;
+    }
+    return JSON.stringify(config, null, 2);
+}
 /**
  * Sync a subagent to an OpenClaw workspace
  * Copies full directory, renames AGENT.md to AGENTS.md
@@ -497,6 +546,21 @@ export function installSubagentToAgent(subagentDir, subagentName, agent, agentHo
         const targetDir = safeJoin(path.join(agentHome, '.openclaw'), subagentName);
         return syncSubagentToOpenclaw(subagentDir, targetDir);
     }
+    else if (agent === 'kiro') {
+        // Kiro: JSON custom-agent file under ~/.kiro/agents/
+        const agentsDir = path.join(agentHome, '.kiro', 'agents');
+        if (!fs.existsSync(agentsDir)) {
+            fs.mkdirSync(agentsDir, { recursive: true });
+        }
+        try {
+            const transformed = transformSubagentForKiro(subagentDir);
+            fs.writeFileSync(safeJoin(agentsDir, `${subagentName}.json`), transformed);
+            return { success: true };
+        }
+        catch (err) {
+            return { success: false, error: String(err) };
+        }
+    }
     else {
         // Other agents don't support subagents yet
         return { success: false, error: `Agent '${agent}' does not support subagents` };
@@ -545,6 +609,13 @@ export function removeSubagentFromAgent(subagentName, agent, agentHome) {
             }
             return { success: true };
         }
+        else if (agent === 'kiro') {
+            const targetPath = safeJoin(path.join(agentHome, '.kiro', 'agents'), `${subagentName}.json`);
+            if (fs.existsSync(targetPath)) {
+                fs.unlinkSync(targetPath);
+            }
+            return { success: true };
+        }
         else {
             return { success: true }; // No-op for unsupported agents
         }
@@ -656,6 +727,22 @@ export function listSubagentsForAgent(agentId, home) {
             subagents.push({ name, path: filePath, files: [file], frontmatter });
         }
     }
+    else if (agentId === 'copilot') {
+        // Copilot: flat `<name>.agent.md` files under ~/.copilot/agents/
+        const agentsDir = path.join(home, '.copilot', 'agents');
+        if (!fs.existsSync(agentsDir))
+            return subagents;
+        for (const file of fs.readdirSync(agentsDir)) {
+            if (!file.endsWith('.agent.md'))
+                continue;
+            const filePath = path.join(agentsDir, file);
+            if (!fs.statSync(filePath).isFile())
+                continue;
+            const name = file.replace(/\.agent\.md$/, '');
+            const frontmatter = parseSubagentFrontmatter(filePath) ?? { name, description: '' };
+            subagents.push({ name, path: filePath, files: [file], frontmatter });
+        }
+    }
     else if (agentId === 'openclaw') {
         // OpenClaw: directories with AGENTS.md
         const openclawDir = path.join(home, '.openclaw');
@@ -697,6 +784,38 @@ export function listSubagentsForAgent(agentId, home) {
             });
         }
     }
+    else if (agentId === 'kiro') {
+        // Kiro: JSON files under ~/.kiro/agents/
+        const agentsDir = path.join(home, '.kiro', 'agents');
+        if (!fs.existsSync(agentsDir))
+            return subagents;
+        for (const file of fs.readdirSync(agentsDir)) {
+            if (!file.endsWith('.json'))
+                continue;
+            const filePath = path.join(agentsDir, file);
+            if (!fs.statSync(filePath).isFile())
+                continue;
+            let frontmatter;
+            try {
+                const config = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+                frontmatter = {
+                    name: config.name || file.replace('.json', ''),
+                    description: config.description || '',
+                    model: config.model,
+                };
+            }
+            catch {
+                continue;
+            }
+            const name = file.replace('.json', '');
+            subagents.push({
+                name,
+                path: filePath,
+                files: [file],
+                frontmatter,
+            });
+        }
+    }
     return subagents;
 }
 /**
@@ -768,6 +887,19 @@ export function diffVersionSubagents(agent, version) {
             }
         }
     }
+    else if (agent === 'kiro') {
+        const agentsDir = path.join(versionHome, '.kiro', 'agents');
+        if (fs.existsSync(agentsDir)) {
+            for (const file of fs.readdirSync(agentsDir)) {
+                if (!file.endsWith('.json'))
+                    continue;
+                const name = path.basename(file, '.json');
+                if (!discovered.has(name)) {
+                    orphans.push(name);
+                }
+            }
+        }
+    }
     return { agent, version, orphans: orphans.sort() };
 }
 /**
@@ -826,6 +958,13 @@ export function removeSubagentFromVersion(agent, version, subagentName) {
                 fs.renameSync(targetPath, path.join(trashDir, `${subagentName}.md.${stamp}`));
             }
         }
+        else if (agent === 'copilot') {
+            const targetPath = path.join(versionHome, '.copilot', 'agents', `${subagentName}.agent.md`);
+            if (fs.existsSync(targetPath)) {
+                fs.mkdirSync(trashDir, { recursive: true, mode: 0o700 });
+                fs.renameSync(targetPath, path.join(trashDir, `${subagentName}.agent.md.${stamp}`));
+            }
+        }
         else if (agent === 'openclaw') {
             const targetDir = path.join(versionHome, '.openclaw', subagentName);
             if (fs.existsSync(targetDir)) {
@@ -834,6 +973,13 @@ export function removeSubagentFromVersion(agent, version, subagentName) {
                 fs.renameSync(targetDir, trashDest);
             }
         }
+        else if (agent === 'kiro') {
+            const targetPath = path.join(versionHome, '.kiro', 'agents', `${subagentName}.json`);
+            if (fs.existsSync(targetPath)) {
+                fs.mkdirSync(trashDir, { recursive: true, mode: 0o700 });
+                fs.renameSync(targetPath, path.join(trashDir, `${subagentName}.json.${stamp}`));
+            }
+        }
         return { success: true };
     }
     catch (err) {

package/dist/lib/teams/agents.d.ts

@@ -213,6 +213,10 @@ export declare class AgentProcess {
      * round-trips so a bare `teams status`/`teams logs` is still correct.
      */
     private syncRemoteMirror;
+    /** Reset the local stdout cursor for a newly truncated resume log. */
+    resetLogReadPosition(): number;
+    /** Restore the cursor when a resume transaction puts the prior log back. */
+    restoreLogReadPosition(position: number): void;
     readNewEvents(): Promise<void>;
     /**
      * Truncate the local mirror to its trailing REMOTE_MIRROR_MAX_BYTES and reset
@@ -268,6 +272,16 @@ export declare class AgentProcess {
 export type CloudDispatchFn = (agent: AgentProcess) => Promise<{
     cloudSessionId: string;
 }>;
+interface ResumeLogTransaction {
+    agent: AgentProcess;
+    stdoutPath: string;
+    backupPath: string;
+    hadOriginal: boolean;
+    previousReadPos: number;
+}
+export declare function beginResumeLogTransaction(agent: AgentProcess): Promise<ResumeLogTransaction>;
+export declare function commitResumeLogTransaction(transaction: ResumeLogTransaction): Promise<void>;
+export declare function terminateSpawnedProcess(pid: number): Promise<void>;
 export declare class AgentManager {
     private agents;
     private maxAgents;
@@ -301,6 +315,22 @@ export declare class AgentManager {
     rescanFromDisk(): Promise<number>;
     private loadExistingAgents;
     spawn(taskName: string, agentType: AgentType, prompt: string, cwd?: string | null, mode?: Mode | null, effort?: EffortLevel, parentSessionId?: string | null, workspaceDir?: string | null, version?: string | null, name?: string | null, after?: string[], model?: string | null, envOverrides?: Record<string, string> | null, taskType?: TaskType | null, cloudProvider?: string | null, cloudSessionId?: string | null, cloudRepo?: string | null, cloudBranch?: string | null, worktreeName?: string | null, worktreePath?: string | null, profileName?: string | null, hostName?: string | null, hostTarget?: string | null, repoPath?: string | null): Promise<AgentProcess>;
+    /**
+     * Resume a STOPPED teammate (completed / failed / stopped) by re-entering its
+     * own session with `message` as the next user turn. Re-launches through the
+     * SAME backend the teammate first used (local process or remote host), reusing
+     * its stored cwd / worktree / host / version / model / effort, and flips it
+     * back to RUNNING so the team tracks it live again.
+     *
+     * The resume target is the teammate's underlying agent session id: for Claude
+     * that IS its agent_id (unified identity, pinned via --session-id at first
+     * launch); other harnesses only expose their session/thread id after their
+     * first stream event, captured as `remoteSessionId`.
+     *
+     * Callers branch on status first — a RUNNING teammate is steered via its
+     * mailbox, never re-launched — so this method assumes a non-running teammate.
+     */
+    resumeTeammate(agentId: string, message: string): Promise<AgentProcess>;
     /**
      * Actually spawn the OS process for a teammate. Extracted from spawn() so
      * staged teammates can be launched later by startReady().