@welluable/orch 1.3.0 → 1.4.0

package/lib/resume.js

@@ -0,0 +1,264 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { readJob, reconcileJob, patchJob, jobPaths } from './jobs.js';
+import { readSeq } from './seq.js';
+import { snapshotPriorOutcome } from './continue.js';
+
+const FAILURE_RESUME_STATES = new Set(['failed', 'stopped', 'crashed']);
+const UNPAUSE_STATES = new Set(['paused', 'pausing']);
+
+/** Plain Error whose `toString()` is just the message (no `Error:` prefix). */
+function fail(message) {
+    const err = new Error(message);
+    err.name = '';
+    return err;
+}
+
+function cursorLabel(record) {
+    const phase = record.phase ?? record.lastOutcome?.phase ?? '?';
+    const stage = record.stage ?? record.lastOutcome?.stage ?? '?';
+    return `${phase}/${stage}`;
+}
+
+/**
+ * Pure eligibility gate for `orch resume`. Reconciles first; never mutates
+ * beyond reconcile's dead-pid → crashed rewrite.
+ *
+ * Returns `{ mode, record }` where mode is:
+ *   - `'unpause'`  — live paused/pausing → existing requestResume path
+ *   - `'noop'`     — already running (successful no-op)
+ *   - `'failure'`  — terminal failure resume (recover → reentry)
+ */
+export function validateResume(cwd, slug, { ask, quick } = {}) {
+    const existing = readJob(cwd, slug);
+    if (!existing) throw fail(`unknown run ${slug}`);
+
+    if (ask) throw fail('orch resume does not support --ask; use the default orch command');
+    if (quick) throw fail('orch resume does not support --quick; use the default orch command');
+
+    const record = reconcileJob(cwd, slug, existing);
+
+    if (UNPAUSE_STATES.has(record.state)) {
+        return { mode: 'unpause', record };
+    }
+
+    if (record.state === 'running') {
+        return { mode: 'noop', record };
+    }
+
+    if (record.state === 'done') {
+        throw fail(
+            `${slug} is done; nothing to resume.\nuse: orch continue ${slug} "<new task>"`,
+        );
+    }
+
+    if (!FAILURE_RESUME_STATES.has(record.state)) {
+        throw fail(`cannot resume ${slug} while state is ${record.state}`);
+    }
+
+    if (record.role === 'coordinator') {
+        if (readSeq(cwd, slug)) {
+            throw fail(
+                `cannot resume coordinator ${slug}; resume each failed unit slug, then orch --seq-continue ${slug}`,
+            );
+        }
+        throw fail(
+            `cannot resume coordinator ${slug}; resume each failed worker slug, then orch --integrate ${slug}`,
+        );
+    }
+
+    if (record.role === 'integration') {
+        const parent = record.parent ?? '<parent-slug>';
+        throw fail(
+            `cannot resume integration ${slug}; use orch --integrate ${parent}`,
+        );
+    }
+
+    if (!record.worktree || !record.branch) {
+        throw fail(
+            `${slug} has no worktree; nothing to stage-resume (quick-fix / ask runs cannot be resumed)`,
+        );
+    }
+
+    if (!fs.existsSync(record.worktree)) {
+        throw fail(`worktree missing at ${record.worktree}; cannot resume ${slug}`);
+    }
+
+    return { mode: 'failure', record };
+}
+
+/**
+ * Reopen a terminal failure job for same-task resume. Restores
+ * phase/stage/round from `prior` (not research reset). Same slug/worktree.
+ */
+export function reopenForResume(cwd, slug, {
+    pid,
+    prior,
+    agent,
+    maxRounds,
+    startedAt,
+} = {}) {
+    const existing = readJob(cwd, slug);
+    if (!existing) throw new Error(`reopenForResume: unknown job ${slug}`);
+
+    const started = startedAt ?? new Date().toISOString();
+    const resumeCount = (existing.resumeCount ?? 0) + 1;
+    const resumes = Array.isArray(existing.resumes) ? [...existing.resumes] : [];
+    resumes.push({
+        n: resumeCount,
+        startedAt: started,
+        prior: prior ?? null,
+    });
+
+    const phase = prior?.phase ?? existing.phase ?? null;
+    const stage = prior?.stage ?? existing.stage ?? null;
+    const round = prior?.round ?? existing.round ?? null;
+
+    return patchJob(cwd, slug, {
+        agent: agent ?? existing.agent,
+        maxRounds: maxRounds ?? existing.maxRounds,
+        pid,
+        startedAt: started,
+        state: 'running',
+        phase,
+        stage,
+        round,
+        finishedAt: null,
+        exitCode: null,
+        pauseRequested: false,
+        lastOutcome: null,
+        resumeCount,
+        resumes,
+    });
+}
+
+function readOptional(filePath) {
+    try {
+        if (fs.existsSync(filePath)) return fs.readFileSync(filePath, 'utf8');
+    } catch {
+        // best-effort
+    }
+    return null;
+}
+
+function shortGitSummary(worktreePath) {
+    if (!worktreePath || !fs.existsSync(worktreePath)) return '(worktree missing)';
+    try {
+        const status = execFileSync('git', ['status', '--short'], {
+            cwd: worktreePath,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+        }).trim();
+        if (!status) return 'clean working tree';
+        const lines = status.split('\n');
+        const head = lines.slice(0, 8).join('; ');
+        const more = lines.length > 8 ? ` (+${lines.length - 8} more)` : '';
+        return `${lines.length} change(s): ${head}${more}`;
+    } catch (err) {
+        return `(git status unavailable: ${err.message?.split('\n')[0] ?? 'error'})`;
+    }
+}
+
+function oneLineOrientation(prior, { hasTask, hasResearch, gitSummary }) {
+    const state = prior?.state ?? 'unknown';
+    const stage = prior?.stage ?? prior?.phase ?? 'unknown';
+    const round = prior?.round != null ? ` round ${prior.round}` : '';
+    const errHint = prior?.error
+        ? prior.error.includes('failure.log')
+            ? ' (see failure.log)'
+            : ` (${String(prior.error).slice(0, 60)})`
+        : '';
+    const artifacts = [
+        hasTask ? 'task.md present' : null,
+        hasResearch ? 'research.md present' : null,
+        gitSummary?.startsWith('clean') ? 'worktree intact' : 'worktree has changes',
+    ].filter(Boolean).join(', ');
+    return `${state} at ${stage}${round}${errHint}; ${artifacts}`;
+}
+
+/**
+ * Deterministic recover: read cursor + failure.log + artifacts + git summary,
+ * write recover.md, return brief + one-liner for UI / stage injection.
+ */
+export function runRecover(cwd, slug, { prior, worktreePath } = {}) {
+    const paths = jobPaths(cwd, slug);
+    const artifactDir = paths.dir;
+    const failureLogPath = paths.failureLogPath;
+    const researchPath = path.join(artifactDir, 'research.md');
+    const taskPath = path.join(artifactDir, 'task.md');
+    const statusPath = path.join(artifactDir, 'status.md');
+    const recoverPath = path.join(artifactDir, 'recover.md');
+
+    const failureLog = readOptional(failureLogPath);
+    const research = readOptional(researchPath);
+    const task = readOptional(taskPath);
+    const status = readOptional(statusPath);
+    const gitSummary = shortGitSummary(worktreePath ?? readJob(cwd, slug)?.worktree);
+
+    const p = prior ?? snapshotPriorOutcome(cwd, slug, readJob(cwd, slug) ?? {});
+    const oneLiner = oneLineOrientation(p, {
+        hasTask: Boolean(task),
+        hasResearch: Boolean(research),
+        gitSummary,
+    });
+
+    const lines = [
+        '# Recover',
+        '',
+        `- Slug: \`${slug}\``,
+        `- Prior state: ${p.state ?? '(none)'}`,
+        `- Prior phase: ${p.phase ?? '(none)'}`,
+        `- Prior stage: ${p.stage ?? '(none)'}`,
+        `- Prior round: ${p.round ?? 'null'}`,
+        `- Prior task: ${p.task ?? '(none)'}`,
+        `- Prior summary: ${p.summary || '(none)'}`,
+        `- Prior error: ${p.error ?? '(none)'}`,
+        `- failure.log: ${failureLog ? failureLogPath : '(absent)'}`,
+        `- research.md: ${research ? 'present' : 'absent'}`,
+        `- task.md: ${task ? 'present' : 'absent'}`,
+        `- status.md: ${status ? 'present' : 'absent'}`,
+        `- Worktree git: ${gitSummary}`,
+        '',
+        '## Orientation',
+        '',
+        oneLiner,
+        '',
+        '## Guidance',
+        '',
+        '- Re-enter the unfinished stage; do not restart research/plan when task.md / research.md already exist.',
+        '- No destructive git (no reset/clean/force checkout).',
+        '- Retry the recorded stage; overwrite its outputs safely.',
+        '',
+    ];
+
+    if (failureLog) {
+        const excerpt = failureLog.length > 4000
+            ? `${failureLog.slice(-4000)}\n…(truncated)…`
+            : failureLog;
+        lines.push('## failure.log (excerpt)', '', '```', excerpt.trimEnd(), '```', '');
+    }
+
+    fs.mkdirSync(artifactDir, { recursive: true });
+    fs.writeFileSync(recoverPath, `${lines.join('\n')}\n`, 'utf8');
+
+    const brief = [
+        '[Recover brief]',
+        `- Orientation: ${oneLiner}`,
+        `- Reentry: ${p.phase ?? '?'}/${p.stage ?? '?'} round ${p.round ?? 'null'}`,
+        `- failure.log: ${failureLog ? failureLogPath : '(absent)'}`,
+        `- recover.md: ${recoverPath}`,
+        `- Worktree git: ${gitSummary}`,
+        '- Do not re-run research/plan unless this stage is research or plan.',
+        '[/Recover brief]',
+    ].join('\n');
+
+    return {
+        oneLiner,
+        brief,
+        recoverPath,
+        failureLogPath: failureLog ? failureLogPath : null,
+    };
+}
+
+export { snapshotPriorOutcome, cursorLabel, FAILURE_RESUME_STATES };

package/lib/seq.js

@@ -0,0 +1,281 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { isPidAlive } from './jobs.js';
+
+const SLUG_SAFE_ID = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const FANOUT_FIELDS = ['dependsOn', 'owns', 'scaffold', 'area'];
+
+/** Absolute paths for a seq run's on-disk state under `<cwd>/.orch/<parentSlug>/`. */
+function seqPaths(cwd, parentSlug) {
+    const dir = path.join(path.resolve(cwd), '.orch', parentSlug);
+    return {
+        dir,
+        seqJsonPath: path.join(dir, 'seq.json'),
+        lockPath: path.join(dir, '.seq.lock'),
+    };
+}
+
+function atomicWriteJson(dir, filePath, data) {
+    fs.mkdirSync(dir, { recursive: true });
+    const tmpPath = path.join(
+        dir,
+        `.${path.basename(filePath)}.${process.pid}.${crypto.randomBytes(4).toString('hex')}.tmp`,
+    );
+    fs.writeFileSync(tmpPath, JSON.stringify(data, null, 2));
+    fs.renameSync(tmpPath, filePath);
+}
+
+function sleepSync(ms) {
+    const view = new Int32Array(new SharedArrayBuffer(4));
+    Atomics.wait(view, 0, 0, ms);
+}
+
+/**
+ * Acquires `.seq.lock` via exclusive create, busy-waiting on contention.
+ * A lock whose owner pid is no longer alive is treated as stale and removed.
+ */
+function acquireLock(lockPath, { timeoutMs = 5000, retryMs = 5 } = {}) {
+    const start = Date.now();
+    for (;;) {
+        try {
+            const fd = fs.openSync(lockPath, 'wx');
+            fs.writeSync(fd, JSON.stringify({ pid: process.pid }));
+            fs.closeSync(fd);
+            return;
+        } catch (err) {
+            if (err.code !== 'EEXIST') throw err;
+
+            let ownerPid = null;
+            try {
+                ownerPid = JSON.parse(fs.readFileSync(lockPath, 'utf8')).pid;
+            } catch {
+                // Lock file mid-write or briefly unreadable; treat as contention.
+            }
+
+            if (ownerPid != null && !isPidAlive(ownerPid)) {
+                try {
+                    fs.unlinkSync(lockPath);
+                } catch {
+                    // Another process may have removed it first; retry.
+                }
+                continue;
+            }
+
+            if (Date.now() - start > timeoutMs) {
+                throw new Error(`patchUnit/patchTip: timed out waiting for lock ${lockPath}`);
+            }
+            sleepSync(retryMs);
+        }
+    }
+}
+
+function withSeqLock(cwd, parentSlug, fn) {
+    const { dir, seqJsonPath, lockPath } = seqPaths(cwd, parentSlug);
+    fs.mkdirSync(dir, { recursive: true });
+    acquireLock(lockPath);
+    try {
+        return fn({ dir, seqJsonPath });
+    } finally {
+        try {
+            fs.unlinkSync(lockPath);
+        } catch {
+            // Already gone; nothing to clean up.
+        }
+    }
+}
+
+/** Reads and parses `seq.json`; `null` if missing; throws on invalid JSON. */
+export function readSeq(cwd, parentSlug) {
+    const { seqJsonPath } = seqPaths(cwd, parentSlug);
+    let content;
+    try {
+        content = fs.readFileSync(seqJsonPath, 'utf8');
+    } catch (err) {
+        if (err.code === 'ENOENT') return null;
+        throw err;
+    }
+    return JSON.parse(content);
+}
+
+/** Atomically (write-temp + rename) writes the full seq document. */
+export function writeSeq(cwd, parentSlug, data) {
+    const { dir, seqJsonPath } = seqPaths(cwd, parentSlug);
+    atomicWriteJson(dir, seqJsonPath, data);
+}
+
+/**
+ * Locks, re-reads the latest document, shallow-merges `patchFnOrObject` (an
+ * object, or a `(currentUnit) => partialPatch` function) onto the matching
+ * entry in `units[]`, atomically writes the whole document back, unlocks,
+ * and returns the updated full document.
+ */
+export function patchUnit(cwd, parentSlug, unitId, patchFnOrObject) {
+    return withSeqLock(cwd, parentSlug, ({ dir, seqJsonPath }) => {
+        const current = readSeq(cwd, parentSlug);
+        if (!current) throw new Error(`unknown parent ${parentSlug} (no seq.json)`);
+        const units = current.units.map((unit) => {
+            if (unit.id !== unitId) return unit;
+            const patch = typeof patchFnOrObject === 'function' ? patchFnOrObject(unit) : patchFnOrObject;
+            return { ...unit, ...patch };
+        });
+        const updated = { ...current, units };
+        atomicWriteJson(dir, seqJsonPath, updated);
+        return updated;
+    });
+}
+
+/** Locks and sets top-level `tip`. */
+export function patchTip(cwd, parentSlug, tipSha) {
+    return withSeqLock(cwd, parentSlug, ({ dir, seqJsonPath }) => {
+        const current = readSeq(cwd, parentSlug);
+        if (!current) throw new Error(`unknown parent ${parentSlug} (no seq.json)`);
+        const updated = { ...current, tip: tipSha };
+        atomicWriteJson(dir, seqJsonPath, updated);
+        return updated;
+    });
+}
+
+/** Locks and pushes onto `adjustments[]` (creating the array if absent). */
+export function appendAdjustment(cwd, parentSlug, entry) {
+    return withSeqLock(cwd, parentSlug, ({ dir, seqJsonPath }) => {
+        const current = readSeq(cwd, parentSlug);
+        if (!current) throw new Error(`unknown parent ${parentSlug} (no seq.json)`);
+        const adjustments = [...(current.adjustments ?? []), entry];
+        const updated = { ...current, adjustments };
+        atomicWriteJson(dir, seqJsonPath, updated);
+        return updated;
+    });
+}
+
+/** Returns a violation list for a seq decomposition (empty array = valid). */
+export function validateSeqDecomposition(decomposition, { maxUnits } = {}) {
+    const violations = [];
+    const units = decomposition?.units ?? [];
+
+    if (units.length < 2) {
+        violations.push('fewer than two units; not decomposable');
+    }
+    if (typeof maxUnits === 'number' && units.length > maxUnits) {
+        violations.push(`too many units: ${units.length} exceeds maxUnits ${maxUnits}`);
+    }
+
+    const seen = new Set();
+    for (const unit of units) {
+        const id = unit?.id;
+        if (typeof id !== 'string' || !id.trim()) {
+            violations.push('unit has empty id');
+        } else if (!SLUG_SAFE_ID.test(id)) {
+            violations.push(`unit id ${id} is not slug-safe`);
+        } else if (seen.has(id)) {
+            violations.push(`duplicate unit id ${id}`);
+        } else {
+            seen.add(id);
+        }
+
+        if (typeof unit?.title !== 'string' || !unit.title.trim()) {
+            violations.push(`unit ${id ?? '?'} has empty title`);
+        }
+        if (typeof unit?.subtask !== 'string' || !unit.subtask.trim()) {
+            violations.push(`unit ${id ?? '?'} has empty subtask`);
+        }
+
+        for (const field of FANOUT_FIELDS) {
+            if (Object.hasOwn(unit, field)) {
+                violations.push(`unit ${id ?? '?'} has fan-out field ${field}`);
+            }
+        }
+    }
+
+    return violations;
+}
+
+/** Thin per-unit prompt: id/title, original task fence, subtask; no backlog dump. */
+export function buildUnitEnvelope({ id, title, subtask, originalTask }) {
+    return [
+        `You are unit ${id} (${title}) of a sequential orch run for:`,
+        originalTask,
+        '',
+        'Your unit subtask:',
+        subtask,
+        '',
+        'Work only on this unit. Do not implement later backlog items. Prior units',
+        'may already be merged into the branch you are based on — inspect the tree',
+        'and build on it.',
+    ].join('\n');
+}
+
+function nextPendingIds(units, limit = 2) {
+    return units.filter((u) => u.state === 'pending').slice(0, limit).map((u) => u.id);
+}
+
+/** Returns a violation list for an adjust result (empty array = valid). */
+export function validateAdjustResult(result, { units, maxUnits } = {}) {
+    const violations = [];
+    const rewrites = Array.isArray(result?.rewrites) ? result.rewrites : null;
+    const drops = Array.isArray(result?.drops) ? result.drops : null;
+
+    if (!rewrites || !drops) {
+        violations.push('adjust result must include rewrites[] and drops[]');
+        return violations;
+    }
+
+    const byId = new Map((units || []).map((u) => [u.id, u]));
+    const nextPending = nextPendingIds(units || [], 2);
+
+    if (rewrites.length > 2) {
+        violations.push('cannot rewrite more than the next two pending units');
+    }
+
+    // Rewrites must be a contiguous prefix of the next pending units (no skip-ahead).
+    for (let i = 0; i < rewrites.length; i += 1) {
+        const id = rewrites[i]?.id;
+        if (typeof id !== 'string' || !byId.has(id)) {
+            violations.push(`cannot invent new id ${id}`);
+            continue;
+        }
+        const unit = byId.get(id);
+        if (unit.state !== 'pending') {
+            violations.push(`cannot rewrite ${unit.state} unit ${id}`);
+            continue;
+        }
+        if (nextPending[i] !== id) {
+            violations.push(`cannot rewrite non-next pending unit ${id}`);
+        }
+    }
+
+    for (const id of drops) {
+        if (typeof id !== 'string' || !byId.has(id)) {
+            violations.push(`cannot invent new id ${id}`);
+            continue;
+        }
+        const unit = byId.get(id);
+        if (unit.state !== 'pending') {
+            violations.push(`cannot drop ${unit.state} unit ${id}`);
+        }
+    }
+
+    if (typeof maxUnits === 'number' && (units || []).length > maxUnits) {
+        violations.push(`total units ${(units || []).length} exceeds maxUnits ${maxUnits}`);
+    }
+
+    return violations;
+}
+
+/** Applies rewrites/drops to a cloned seq document; does not mutate input. */
+export function applyAdjustResult(seqDoc, result) {
+    const units = seqDoc.units.map((unit) => {
+        const rewrite = (result.rewrites || []).find((r) => r.id === unit.id);
+        let next = unit;
+        if (rewrite) {
+            next = { ...next };
+            if (rewrite.title != null) next.title = rewrite.title;
+            if (rewrite.subtask != null) next.subtask = rewrite.subtask;
+        }
+        if ((result.drops || []).includes(unit.id)) {
+            next = { ...next, state: 'skipped' };
+        }
+        return next;
+    });
+    return { ...seqDoc, units };
+}

package/lib/stage-summary.js

@@ -38,6 +38,30 @@ function splitSummaryIntoBullets(summary) {
         .filter(Boolean);
 }
 
+/**
+ * Safety-net summary for the printed stage box when the agent omitted
+ * `<<<SUMMARY>>>`. Never invents a delimiter into forwarded content — callers
+ * pass only the resolved string to `printStageSummary`.
+ *
+ * @param {string} label
+ * @param {string} summary
+ * @param {unknown} content
+ * @returns {string}
+ */
+export function resolveStageSummary(label, summary, content) {
+    if (typeof summary === 'string' && summary.trim()) return summary;
+
+    if (typeof content !== 'string') return '';
+    const trimmed = content.trim();
+    if (!trimmed) return '';
+
+    const [first] = splitSummaryIntoBullets(trimmed);
+    if (!first) return `${label} completed`;
+
+    if (first.length <= 160) return first;
+    return `${first.slice(0, 160).trimEnd()}`;
+}
+
 const FILES_NOTES_HEADER_RE = /^\s*files\s*:?\s*$/i;
 
 /**

package/lib/tool-status.js

@@ -18,6 +18,17 @@ export function basename(p) {
     return parts[parts.length - 1] || str;
 }
 
+/**
+ * Shared path alias for tool args: `path` | `file_path` | `filePath`.
+ * @param {Record<string, unknown>|null|undefined} args
+ * @returns {string|null}
+ */
+export function toolPath(args) {
+    if (!args || typeof args !== 'object') return null;
+    const p = args.path ?? args.file_path ?? args.filePath;
+    return typeof p === 'string' && p ? p : null;
+}
+
 /** Pick the first 1-2 short scalar args to preview for unknown tools, e.g. "path=foo". */
 export function formatArgPreview(args = {}) {
     const parts = [];
@@ -161,14 +172,45 @@ export function normalizeAgnToolEvent(event) {
     };
 }
 
+const OPENCODE_TOOL_NAME_TO_FORMATTER_KEY = {
+    bash: 'shell',
+};
+
+/**
+ * Normalize an OpenCode stream event into a `NormalizedToolEvent`, or `null`
+ * if the event isn't a well-formed completed `tool_use` part.
+ * OpenCode `--format json` only emits completed tool parts.
+ * @param {object} event
+ * @returns {NormalizedToolEvent|null}
+ */
+export function normalizeOpencodeToolEvent(event) {
+    if (event?.type !== 'tool_use') return null;
+    const part = event.part;
+    if (typeof part?.tool !== 'string' || part.tool === '') return null;
+    if (typeof part?.callID !== 'string' || part.callID === '') return null;
+    if (part?.state?.status !== 'completed') return null;
+
+    const canonicalName = OPENCODE_TOOL_NAME_TO_FORMATTER_KEY[part.tool] ?? part.tool;
+    const rawTitle = part.state?.title ?? part.title;
+    const title = typeof rawTitle === 'string' && rawTitle.trim() ? rawTitle.trim() : undefined;
+    return {
+        name: canonicalName,
+        args: part.state?.input ?? {},
+        phase: 'completed',
+        callId: part.callID,
+        ...(title ? { title } : {}),
+    };
+}
+
 /**
  * Format a single normalized tool event as a human-readable status line.
- * @param {{ name: string, args?: Record<string, unknown> }} tool
+ * @param {{ name: string, args?: Record<string, unknown>, title?: string }} tool
  * @param {{ maxLen?: number }} [options]
  */
-export function formatToolStatus({ name, args = {} }, { maxLen = 60 } = {}) {
+export function formatToolStatus({ name, args = {}, title }, { maxLen = 60 } = {}) {
     const n = String(name ?? 'tool');
     const key = n.toLowerCase();
+    const file = toolPath(args) ?? 'file';
 
     switch (key) {
         case 'grep':
@@ -176,13 +218,13 @@ export function formatToolStatus({ name, args = {} }, { maxLen = 60 } = {}) {
         case 'glob':
             return `Finding: ${truncate(args.glob_pattern ?? args.pattern ?? 'files', maxLen)}…`;
         case 'read':
-            return `Reading ${truncate(basename(args.path ?? args.file_path ?? 'file'), maxLen)}…`;
+            return `Reading ${truncate(basename(file), maxLen)}…`;
         case 'write':
-            return `Writing ${truncate(basename(args.path ?? args.file_path ?? 'file'), maxLen)}…`;
+            return `Writing ${truncate(basename(file), maxLen)}…`;
         case 'edit':
-            return `Editing ${truncate(basename(args.path ?? args.file_path ?? 'file'), maxLen)}…`;
+            return `Editing ${truncate(basename(file), maxLen)}…`;
         case 'delete':
-            return `Deleting ${truncate(basename(args.path ?? args.file_path ?? 'file'), maxLen)}…`;
+            return `Deleting ${truncate(basename(file), maxLen)}…`;
         case 'shell':
         case 'bash':
             return `Running: ${truncate(args.command ?? '', maxLen)}…`;
@@ -192,7 +234,12 @@ export function formatToolStatus({ name, args = {} }, { maxLen = 60 } = {}) {
             return `Searching web: ${truncate(args.search_term ?? args.query ?? '', maxLen)}…`;
         case 'task':
             return `Running subagent: ${truncate(args.description ?? args.prompt ?? 'task', maxLen)}…`;
+        case 'apply_patch':
+            return 'Applying patch…';
         default: {
+            if (typeof title === 'string' && title.trim()) {
+                return truncate(title.trim(), maxLen);
+            }
             const preview = formatArgPreview(args);
             return preview ? `Running ${n}(${preview})…` : `Running ${n}…`;
         }