klyro 0.1.63 → 1.0.1

package/dist/agent/task-manager.js

@@ -0,0 +1,250 @@
+/**
+ * Task manager — tracks the lifecycle of a (possibly nested) agent run.
+ *
+ * Each `spawn_agent` call creates a `TaskRecord` in a `TaskManager`.
+ * The manager owns an `AbortController` per task so that the parent (or
+ * the user) can cancel a running child without tearing down the entire
+ * process. It enforces a recursion / depth cap and emits `subtask.*`
+ * events so the event bus and trace writer can see the task tree.
+ *
+ * Exactly one task manager exists per session, wired into the orchestrator
+ * (src/agent/orchestrator.ts), which the runtime reaches via
+ * `parentContext`.
+ */
+import { globalBus } from '../events/bus.js';
+export class TaskManager {
+    tasks = new Map();
+    watchers = new Map();
+    counter = 0;
+    sessionId;
+    bus;
+    constructor(opts) {
+        this.sessionId = opts.sessionId;
+        this.bus = opts.bus ?? globalBus;
+    }
+    /** Create a task. Blocks instead of running when the recursion cap is exceeded. */
+    create(opts) {
+        const id = `task_${++this.counter}`;
+        const running = opts.autoStart !== false;
+        let resolveDone;
+        const record = {
+            id,
+            parentTaskId: opts.parentTaskId,
+            sessionId: this.sessionId,
+            agentName: opts.agentName,
+            status: running ? 'running' : 'queued',
+            cwd: opts.cwd,
+            depth: opts.depth,
+            maxDepth: opts.maxDepth,
+            model: opts.model,
+            startedAt: Date.now(),
+            summary: [],
+            abortController: new AbortController(),
+            done: new Promise((res) => {
+                resolveDone = res;
+            }),
+            _resolveDone: (r) => resolveDone(r),
+        };
+        this.tasks.set(id, record);
+        // Recursion / depth guard — enforced at the boundary so a deep-deep
+        // call chain can never be constructed in the first place.
+        if (opts.depth > opts.maxDepth) {
+            record.status = 'blocked';
+            record.timeoutHandle = undefined;
+            record.error = {
+                code: 'BLOCKED',
+                message: `recursion limit: depth ${opts.depth} exceeds maxDepth ${opts.maxDepth}`,
+            };
+            this.resolve(record);
+            this.emit(record);
+            return record;
+        }
+        // Parent abort → child abort chain.
+        if (opts.abortOnParent) {
+            const onAbort = () => this.cancel(id, 'parent aborted');
+            if (opts.abortOnParent.aborted) {
+                onAbort();
+            }
+            else {
+                opts.abortOnParent.addEventListener('abort', onAbort, { once: true });
+                record._cleanupParentAbort = () => opts.abortOnParent.removeEventListener('abort', onAbort);
+            }
+        }
+        // Timeout: transition to 'timed_out' and abort if still live.
+        if (opts.timeoutMs !== undefined && opts.timeoutMs > 0) {
+            record.timeoutHandle = setTimeout(() => {
+                const r = this.tasks.get(id);
+                if (r && (r.status === 'running' || r.status === 'queued')) {
+                    this.cancel(id, 'timeout', 'timed_out');
+                }
+            }, opts.timeoutMs);
+        }
+        this.emit(record);
+        return record;
+    }
+    /** Look up a live record. */
+    get(id) {
+        return this.tasks.get(id);
+    }
+    /** List tasks, optionally filtered by parent and/or status. Returns summaries. */
+    list(filter) {
+        const out = [];
+        for (const r of this.tasks.values()) {
+            if (filter?.parentTaskId !== undefined && r.parentTaskId !== filter.parentTaskId)
+                continue;
+            if (filter?.status !== undefined && r.status !== filter.status)
+                continue;
+            out.push(this.toSummary(r));
+        }
+        return out;
+    }
+    /** Transition a task to a terminal status and resolve its `done`. */
+    finish(id, status, patch) {
+        const r = this.get(id);
+        if (!r)
+            throw new Error(`unknown task: ${id}`);
+        if (status !== 'blocked' && r.timeoutHandle) {
+            clearTimeout(r.timeoutHandle);
+            r.timeoutHandle = undefined;
+        }
+        if (patch?.summary)
+            r.summary.push(...patch.summary);
+        r.status = status;
+        r.finishedAt = Date.now();
+        if (patch?.error)
+            r.error = patch.error;
+        this.resolve(r);
+        this.emit(r);
+        return r;
+    }
+    /** Cancel a live task: abort, mark cancelled/timed_out, resolve done. */
+    cancel(id, reason = 'cancelled', finalStatus = 'cancelled') {
+        const r = this.get(id);
+        if (!r)
+            throw new Error(`unknown task: ${id}`);
+        if (r.status !== 'queued' && r.status !== 'running')
+            return r; // idempotent on terminal
+        r.abortController.abort(reason);
+        r._cleanupParentAbort?.();
+        r._cleanupParentAbort = undefined;
+        if (r.timeoutHandle) {
+            clearTimeout(r.timeoutHandle);
+            r.timeoutHandle = undefined;
+        }
+        r.status = finalStatus;
+        r.finishedAt = Date.now();
+        r.error = {
+            code: finalStatus === 'timed_out' ? 'TIMED_OUT' : 'CANCELLED',
+            message: reason,
+        };
+        this.resolve(r);
+        this.emit(r);
+        return r;
+    }
+    /** Confirm a task that policy/depth prevented from running. */
+    block(id, reason) {
+        return this.finish(id, 'blocked', {
+            error: { code: 'BLOCKED', message: reason },
+        });
+    }
+    /** Cancel `id` and every transitive descendant. */
+    async cancelTree(id, reason = 'cancelled') {
+        const ids = [id];
+        const walk = (pid) => {
+            for (const r of this.tasks.values()) {
+                if (r.parentTaskId === pid) {
+                    ids.push(r.id);
+                    walk(r.id);
+                }
+            }
+        };
+        walk(id);
+        // Children first so a parent's abort doesn't race a child still being torn down.
+        ids.reverse();
+        for (const tid of ids) {
+            this.cancel(tid, reason);
+        }
+    }
+    /** Subscribe to status transitions for one task. Delivers the current status immediately. */
+    subscribe(id, listener) {
+        let set = this.watchers.get(id);
+        if (!set) {
+            set = new Set();
+            this.watchers.set(id, set);
+        }
+        set.add(listener);
+        const r = this.get(id);
+        if (r) {
+            try {
+                listener(r);
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        return () => {
+            set.delete(listener);
+            if (set.size === 0)
+                this.watchers.delete(id);
+        };
+    }
+    /** Cancel every live task (used on shutdown / ctrl-c). */
+    async shutdown() {
+        for (const id of [...this.tasks.keys()]) {
+            const r = this.get(id);
+            if (r && (r.status === 'queued' || r.status === 'running')) {
+                this.cancel(id, 'shutdown');
+            }
+        }
+    }
+    /** Compact serialisable summary. */
+    toSummary(r) {
+        return {
+            id: r.id,
+            ...(r.parentTaskId ? { parentTaskId: r.parentTaskId } : {}),
+            agentName: r.agentName,
+            sessionId: r.sessionId,
+            status: r.status,
+            cwd: r.cwd,
+            depth: r.depth,
+            ...(typeof r.model === 'string' ? { model: r.model } : {}),
+            ...(r.finishedAt ? { durationMs: r.finishedAt - r.startedAt } : {}),
+        };
+    }
+    /* ---------------------- internals ---------------------- */
+    /** Resolve a record's `done` (idempotent). */
+    resolve(r) {
+        this._resolveOnce(r);
+    }
+    _resolveOnce(r) {
+        try {
+            r._resolveDone(r);
+        }
+        catch {
+            /* already resolved */
+        }
+    }
+    /** Deliver a transition to the task's own watchers, then each ancestor's. */
+    emit(r) {
+        this.notify(r.id, r);
+        let pid = r.parentTaskId;
+        while (pid) {
+            const p = this.get(pid);
+            this.notify(pid, r);
+            pid = p?.parentTaskId;
+        }
+    }
+    notify(id, r) {
+        const set = this.watchers.get(id);
+        if (!set)
+            return;
+        for (const fn of [...set]) {
+            try {
+                fn(r);
+            }
+            catch {
+                /* ignore */
+            }
+        }
+    }
+}

package/dist/agent/worker-spawner.d.ts

@@ -1,21 +1,23 @@
 /**
- * In-process worker spawner (MVP).
+ * In-process worker spawner.
  *
- * Per `docs/plan-fix.md` Step 2: workers run in-process for the MVP.
- * Real subprocess / child-process spawning belongs to a later level
- * (Level 7: sandboxed execution, Level 19: distributed workers).
+ * A "worker" here is just an async task tied to an AbortController. The
+ * spawner keeps the controllers so workers can actually be cancelled
+ * (user Ctrl+C, /abort, session shutdown, or a parent signalling a child).
  *
- * A "worker" here is just an async task with an AbortController. The
- * spawner keeps a registry so they can be cancelled together (e.g. on
- * user Ctrl+C, /abort, or session shutdown).
+ * Real subprocess / child-process spawning belongs to a later level;
+ * this module is the single-process cancellation primitive the agent
+ * orchestration layer builds on.
  */
 export interface WorkerHandle {
     /** Stable id, monotonically increasing per spawner instance. */
     readonly id: number;
     /** Human-readable label, used in logs. */
     readonly label: string;
-    /** AbortController tied to this worker's lifetime. */
+    /** AbortSignal delivered to the factory so it can observe cancellation. */
     readonly signal: AbortSignal;
+    /** The controller backing `signal` — retained so we can actually abort. */
+    readonly controller: AbortController;
     /** Resolves when the worker's main promise settles. */
     readonly done: Promise<void>;
 }
@@ -28,12 +30,15 @@ export declare class WorkerSpawner {
     private nextId;
     private readonly handles;
     /**
-     * Spawn a worker. The factory returns a promise; the spawner wires it
-     * up to an AbortController and tracks it.
+     * Spawn a worker. The factory receives an AbortSignal; when the worker is
+     * cancelled (via `cancel`, `cancelAll`, or the parent signal wiring) that
+     * signal fires and `done` settles.
      */
     spawn(factory: (signal: AbortSignal) => Promise<void>, opts?: SpawnOptions): WorkerHandle;
-    /** Abort every active worker. Their factories should observe signal. */
-    cancelAll(reason?: string): void;
+    /** Cancel a single worker: fires its AbortSignal. */
+    cancel(handle: WorkerHandle, reason?: unknown): void;
+    /** Cancel every active worker by firing their AbortSignals. */
+    cancelAll(reason?: unknown): void;
     /** Count of currently-active workers. */
     activeCount(): number;
     /** Snapshot of all live worker handles. */

package/dist/agent/worker-spawner.js

@@ -1,20 +1,21 @@
 /**
- * In-process worker spawner (MVP).
+ * In-process worker spawner.
  *
- * Per `docs/plan-fix.md` Step 2: workers run in-process for the MVP.
- * Real subprocess / child-process spawning belongs to a later level
- * (Level 7: sandboxed execution, Level 19: distributed workers).
+ * A "worker" here is just an async task tied to an AbortController. The
+ * spawner keeps the controllers so workers can actually be cancelled
+ * (user Ctrl+C, /abort, session shutdown, or a parent signalling a child).
  *
- * A "worker" here is just an async task with an AbortController. The
- * spawner keeps a registry so they can be cancelled together (e.g. on
- * user Ctrl+C, /abort, or session shutdown).
+ * Real subprocess / child-process spawning belongs to a later level;
+ * this module is the single-process cancellation primitive the agent
+ * orchestration layer builds on.
  */
 export class WorkerSpawner {
     nextId = 0;
     handles = new Set();
     /**
-     * Spawn a worker. The factory returns a promise; the spawner wires it
-     * up to an AbortController and tracks it.
+     * Spawn a worker. The factory receives an AbortSignal; when the worker is
+     * cancelled (via `cancel`, `cancelAll`, or the parent signal wiring) that
+     * signal fires and `done` settles.
      */
     spawn(factory, opts = {}) {
         const id = this.nextId++;
@@ -31,16 +32,16 @@ export class WorkerSpawner {
             id,
             label,
             signal: ac.signal,
+            controller: ac,
             done,
         };
         this.handles.add(handle);
         if (!autoStart) {
-            // Caller will invoke factory manually and pass the signal — for now
-            // we just resolve immediately so .done doesn't hang.
+            // Caller will invoke the factory manually and pass the signal.
             resolveDone();
             return handle;
         }
-        // Fire-and-forget; user awaits handle.done.
+        // Fire-and-forget; the caller awaits handle.done.
         factory(ac.signal).then(() => {
             this.handles.delete(handle);
             resolveDone();
@@ -50,20 +51,25 @@ export class WorkerSpawner {
         });
         return handle;
     }
-    /** Abort every active worker. Their factories should observe signal. */
-    cancelAll(reason = 'cancelled') {
+    /** Cancel a single worker: fires its AbortSignal. */
+    cancel(handle, reason) {
+        try {
+            handle.controller.abort(reason);
+        }
+        catch {
+            /* already aborted */
+        }
+    }
+    /** Cancel every active worker by firing their AbortSignals. */
+    cancelAll(reason) {
         for (const h of [...this.handles]) {
             try {
-                h.signal.reason = reason;
+                h.controller.abort(reason);
             }
             catch {
-                // AbortSignal.reason is read-only in some envs — fine.
+                /* already aborted */
             }
         }
-        // Real abort uses the controller stored on the handle's signal — we
-        // don't keep the controller here. In the MVP, callers can pass their
-        // own AbortController via factory; this method is a no-op stub for
-        // the contract. See `cancel(handle)` for the per-worker variant.
     }
     /** Count of currently-active workers. */
     activeCount() {

package/dist/agent/worktree-manager.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Git worktree isolation for parallel write-capable child agents.
+ *
+ * Each write-capable child gets its own worktree on a branch
+ * `klyro/<taskId>` so concurrent children never clobber each other's files.
+ * `task_apply` merges the branch back into the parent tree; failures,
+ * cancellations, and timeouts remove the worktree best-effort.
+ *
+ * Semantics worth knowing:
+ *   - Dirty parent: the merge runs in the parent checkout, so uncommitted
+ *     parent edits can conflict. On conflict the merge is ABORTED (no
+ *     commit), the branch is kept, and the caller gets MERGE_CONFLICT with
+ *     the file list — resolve and re-apply.
+ *   - Stale branch: a leftover `klyro/<taskId>` branch (e.g. from a crashed
+ *     session) makes `createWorktree` fail. Delete the stale branch
+ *     (`deleteBranch`) or sweep orphaned worktrees (`pruneStaleWorktrees`)
+ *     before retrying.
+ *   - No-apply: tasks that never reach `succeeded` are NEVER merged — their
+ *     worktrees are removed best-effort and `task_apply` reports NOT_READY.
+ *
+ * All git invocations go through `execFile` argv (no shell) with a ~30s
+ * timeout, so this is safe on Windows.
+ */
+/** Per-command timeout for every git invocation. */
+export declare const GIT_TIMEOUT_MS = 30000;
+export interface WorktreeInfo {
+    worktreePath: string;
+    branch: string;
+}
+export interface MergeResult {
+    merged: boolean;
+    conflictFiles: string[];
+}
+/** True when `cwd` is inside a git working tree. Never throws — false on any failure. */
+export declare function ensureGitRepo(cwd: string): Promise<boolean>;
+/** Resolve the repo top-level for any path inside it. Throws when not in a repo. */
+export declare function repoTopLevel(cwd: string): Promise<string>;
+/**
+ * Create an isolated worktree for a task on branch `klyro/<taskId>`,
+ * rooted at `<repo>/.klyro/worktrees/<taskId>` from HEAD.
+ */
+export declare function createWorktree(opts: {
+    repoCwd: string;
+    taskId: string;
+}): Promise<WorktreeInfo>;
+/**
+ * Merge a task branch into the current checkout (`repoCwd`) with
+ * `git merge --no-ff --no-edit`. On conflict, parses `git status
+ * --porcelain` for unmerged paths (UU/AA/DD), aborts the merge WITHOUT
+ * committing, and returns `{ merged: false, conflictFiles }`.
+ */
+export declare function mergeWorktree(opts: {
+    repoCwd: string;
+    branch: string;
+}): Promise<MergeResult>;
+/** Remove a worktree and prune its metadata. Throws with context on failure. */
+export declare function removeWorktree(opts: {
+    repoCwd: string;
+    worktreePath: string;
+    force?: boolean;
+}): Promise<void>;
+/** Delete a task branch (best-effort cleanup after a successful merge). Never throws. */
+export declare function deleteBranch(opts: {
+    repoCwd: string;
+    branch: string;
+}): Promise<void>;
+/**
+ * Remove worktrees under `.klyro/worktrees` whose task id is NOT in
+ * `activeTaskIds` (orphans from crashed/timed-out sessions). Lists
+ * `git worktree list --porcelain`, force-removes each stale entry, and
+ * returns the removed paths. Never throws — per-worktree failures are
+ * skipped and a failing `git` itself yields `[]`.
+ */
+export declare function pruneStaleWorktrees(repoCwd: string, activeTaskIds: readonly string[]): Promise<string[]>;

package/dist/agent/worktree-manager.js

@@ -0,0 +1,189 @@
+/**
+ * Git worktree isolation for parallel write-capable child agents.
+ *
+ * Each write-capable child gets its own worktree on a branch
+ * `klyro/<taskId>` so concurrent children never clobber each other's files.
+ * `task_apply` merges the branch back into the parent tree; failures,
+ * cancellations, and timeouts remove the worktree best-effort.
+ *
+ * Semantics worth knowing:
+ *   - Dirty parent: the merge runs in the parent checkout, so uncommitted
+ *     parent edits can conflict. On conflict the merge is ABORTED (no
+ *     commit), the branch is kept, and the caller gets MERGE_CONFLICT with
+ *     the file list — resolve and re-apply.
+ *   - Stale branch: a leftover `klyro/<taskId>` branch (e.g. from a crashed
+ *     session) makes `createWorktree` fail. Delete the stale branch
+ *     (`deleteBranch`) or sweep orphaned worktrees (`pruneStaleWorktrees`)
+ *     before retrying.
+ *   - No-apply: tasks that never reach `succeeded` are NEVER merged — their
+ *     worktrees are removed best-effort and `task_apply` reports NOT_READY.
+ *
+ * All git invocations go through `execFile` argv (no shell) with a ~30s
+ * timeout, so this is safe on Windows.
+ */
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import * as path from 'node:path';
+import { filteredEnv } from '../tools/shell/shell-exec.js';
+const execFileAsync = promisify(execFile);
+/** Per-command timeout for every git invocation. */
+export const GIT_TIMEOUT_MS = 30_000;
+async function git(repoCwd, args) {
+    // Filtered env (same call shape as shell-exec) so secrets never reach
+    // child processes. Then strip repo-pinning vars so discovery is always
+    // relative to `repoCwd` (a sandbox may export GIT_DIR for its own
+    // harness — that must not make every directory look like a repo).
+    const env = { ...filteredEnv() };
+    delete env.GIT_DIR;
+    delete env.GIT_WORK_TREE;
+    delete env.GIT_NAMESPACE;
+    const r = await execFileAsync('git', [...args], {
+        cwd: repoCwd,
+        timeout: GIT_TIMEOUT_MS,
+        windowsHide: true,
+        maxBuffer: 4 * 1024 * 1024,
+        env,
+    });
+    return { stdout: r.stdout, stderr: r.stderr };
+}
+/** True when `cwd` is inside a git working tree. Never throws — false on any failure. */
+export async function ensureGitRepo(cwd) {
+    try {
+        const r = await git(cwd, ['rev-parse', '--is-inside-work-tree']);
+        return r.stdout.trim() === 'true';
+    }
+    catch {
+        return false;
+    }
+}
+/** Resolve the repo top-level for any path inside it. Throws when not in a repo. */
+export async function repoTopLevel(cwd) {
+    const r = await git(cwd, ['rev-parse', '--show-toplevel']);
+    return r.stdout.trim();
+}
+function branchForTask(taskId) {
+    return `klyro/${taskId}`;
+}
+/**
+ * Create an isolated worktree for a task on branch `klyro/<taskId>`,
+ * rooted at `<repo>/.klyro/worktrees/<taskId>` from HEAD.
+ */
+export async function createWorktree(opts) {
+    const branch = branchForTask(opts.taskId);
+    const top = await repoTopLevel(opts.repoCwd);
+    const worktreePath = path.join(top, '.klyro', 'worktrees', opts.taskId);
+    await git(opts.repoCwd, ['worktree', 'add', '-b', branch, worktreePath, 'HEAD']);
+    return { worktreePath, branch };
+}
+/**
+ * Merge a task branch into the current checkout (`repoCwd`) with
+ * `git merge --no-ff --no-edit`. On conflict, parses `git status
+ * --porcelain` for unmerged paths (UU/AA/DD), aborts the merge WITHOUT
+ * committing, and returns `{ merged: false, conflictFiles }`.
+ */
+export async function mergeWorktree(opts) {
+    try {
+        await git(opts.repoCwd, ['merge', '--no-ff', '--no-edit', opts.branch]);
+        return { merged: true, conflictFiles: [] };
+    }
+    catch {
+        const conflictFiles = await unmergedFiles(opts.repoCwd);
+        try {
+            await git(opts.repoCwd, ['merge', '--abort']);
+        }
+        catch {
+            /* best-effort: leave the repo as-is if abort itself fails */
+        }
+        return { merged: false, conflictFiles };
+    }
+}
+async function unmergedFiles(repoCwd) {
+    try {
+        const r = await git(repoCwd, ['status', '--porcelain']);
+        const out = [];
+        for (const line of r.stdout.split('\n')) {
+            if (line.length < 4)
+                continue;
+            const x = line[0];
+            const y = line[1];
+            const unmerged = (x === 'U' || y === 'U' || x === 'A' || y === 'A') && (x === 'U' || y === 'U' || (x === 'A' && y === 'A'));
+            // Unmerged statuses: UU, AA, DD, AU, UA, UD, DU.
+            const code = `${x}${y}`;
+            if (['UU', 'AA', 'DD', 'AU', 'UA', 'UD', 'DU'].includes(code) || unmerged) {
+                out.push(line.slice(3).trim());
+            }
+        }
+        return out;
+    }
+    catch {
+        return [];
+    }
+}
+/** Remove a worktree and prune its metadata. Throws with context on failure. */
+export async function removeWorktree(opts) {
+    const args = ['worktree', 'remove', ...(opts.force ? ['--force'] : []), opts.worktreePath];
+    try {
+        await git(opts.repoCwd, args);
+    }
+    catch (err) {
+        throw new Error(`git worktree remove failed for ${opts.worktreePath}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    finally {
+        try {
+            await git(opts.repoCwd, ['worktree', 'prune']);
+        }
+        catch {
+            /* best-effort */
+        }
+    }
+}
+/** Delete a task branch (best-effort cleanup after a successful merge). Never throws. */
+export async function deleteBranch(opts) {
+    try {
+        await git(opts.repoCwd, ['branch', '-D', opts.branch]);
+    }
+    catch {
+        /* best-effort */
+    }
+}
+/**
+ * Remove worktrees under `.klyro/worktrees` whose task id is NOT in
+ * `activeTaskIds` (orphans from crashed/timed-out sessions). Lists
+ * `git worktree list --porcelain`, force-removes each stale entry, and
+ * returns the removed paths. Never throws — per-worktree failures are
+ * skipped and a failing `git` itself yields `[]`.
+ */
+export async function pruneStaleWorktrees(repoCwd, activeTaskIds) {
+    const removed = [];
+    try {
+        const r = await git(repoCwd, ['worktree', 'list', '--porcelain']);
+        const active = new Set(activeTaskIds);
+        for (const line of r.stdout.split('\n')) {
+            const raw = /^worktree (.+)$/.exec(line.trim())?.[1];
+            if (!raw)
+                continue;
+            // git prints forward slashes even on win32 — normalize so returned
+            // paths textually match the path.join-built worktreePath.
+            const wp = path.normalize(raw);
+            // Only manage our own namespace: <repo>/.klyro/worktrees/<taskId>.
+            const parts = wp.split(/[\\/]/);
+            const idx = parts.lastIndexOf('worktrees');
+            if (idx < 1 || parts[idx - 1] !== '.klyro' || idx + 1 >= parts.length)
+                continue;
+            const taskId = parts[idx + 1];
+            if (!taskId || active.has(taskId))
+                continue;
+            try {
+                await removeWorktree({ repoCwd, worktreePath: wp, force: true });
+                removed.push(wp);
+            }
+            catch {
+                /* skip — never throws */
+            }
+        }
+    }
+    catch {
+        /* git itself failed (not a repo, binary missing) — return what we have */
+    }
+    return removed;
+}