toolroll 0.9.8 → 0.9.9

package/dist/work-summary.d.ts

@@ -8,7 +8,9 @@ export type WorkTarget = {
     decisionId: number | null;
 };
 export type WorkAction = {
-    code: DispatchAction | "inspect-task" | "inspect-run" | "inspect-stop" | "inspect-decisions" | "reconcile-run" | "open-pr";
+    /** `confirm-stopped`: an approver confirms a finished build stopped (behind the password);
+     * `sign-in`: the agent's sign-in, in Settings. */
+    code: DispatchAction | "inspect-task" | "inspect-run" | "inspect-stop" | "inspect-decisions" | "reconcile-run" | "open-pr" | "confirm-stopped" | "sign-in";
     label: string;
     target: WorkTarget;
     access: "read" | "operator-control" | "proposal-only" | "operator-handoff";

package/dist/workspace-ui.js

@@ -291,7 +291,7 @@ const DISPATCH_ACTION_LABELS = {
     "place-task": "Choose a project",
     "write-scope": "Define the task",
     "select-agent": "Choose an agent",
-    "approve-scope": "Review plan",
+    "approve-scope": "Approve plan",
     "answer-decision": "Answer the question",
     unhold: "Review hold",
     "inspect-hold": "Review hold",

package/dist/worktree.d.ts

@@ -76,6 +76,8 @@ export type KeptWhy = "has changes" | "has commits" | "unreadable" | "git refuse
  * something is in there.
  */
 export declare const MARKER = ".standing-orders-lease";
+/** What a kept checkout drops once its run ends (only where .gitignore hides it): dependencies and build output. */
+export declare const SLIM_NAMES: readonly string[];
 /** Creating a worktree copies a tree; it is local work but not instant. */
 export declare const WORKTREE_TIMEOUT_MS = 60000;
 /**
@@ -251,6 +253,20 @@ export declare class WorktreePool {
             why: KeptWhy;
         }[];
     }>;
+    /**
+     * Drop a let-go, idle checkout's dependencies and build output: the folders .gitignore hides that are named like
+     * them (SLIM_NAMES). Its work, tracked or untracked, is untouched. The setup stamp goes first, so the next lease
+     * runs the project's setup again and restores them. `wanted` is asked again right before anything goes; `deps`
+     * false keeps node_modules (no setup would restore it).
+     */
+    slim(row: WorktreeRow, wanted: (row: WorktreeRow) => boolean, deps?: boolean): Promise<{
+        ok: true;
+        dropped: string[];
+        bytes: number;
+    } | {
+        ok: false;
+        message: string;
+    }>;
     /**
      * Throw away a let-go checkout kept for its changes, on purpose: the working copy and what is uncommitted in it
      * go; its branch, and every commit on it, stays. Refused while anything holds it.

package/dist/worktree.js

@@ -30,6 +30,7 @@ import { run } from "./exec.js";
 import { currentBootId, provenDeadByBootChange } from "./boot-identity.js";
 import { HANDOFF_PREFIX, MAILBOX_SUFFIX, looksLikeProtocolFile, readMailbox } from "./evidence.js";
 import { parseHandoff } from "./decision.js";
+import { diskBytes } from "./storage.js";
 /**
  * The note a lease leaves in the checkout, naming the process holding it.
  *
@@ -40,6 +41,8 @@ import { parseHandoff } from "./decision.js";
 export const MARKER = ".standing-orders-lease";
 /** Checkouts this process is leasing or removing right now: a lease and storage retention never overlap on one. */
 const busy = new Map();
+/** What a kept checkout drops once its run ends (only where .gitignore hides it): dependencies and build output. */
+export const SLIM_NAMES = ["node_modules", "dist", "build", "out", ".next", ".nuxt", ".svelte-kit", ".turbo", ".parcel-cache", "coverage", "target"];
 /** Creating a worktree copies a tree; it is local work but not instant. */
 export const WORKTREE_TIMEOUT_MS = 60_000;
 const GIT = "git";
@@ -706,6 +709,50 @@ export class WorktreePool {
         }
         return { removed, kept };
     }
+    /**
+     * Drop a let-go, idle checkout's dependencies and build output: the folders .gitignore hides that are named like
+     * them (SLIM_NAMES). Its work, tracked or untracked, is untouched. The setup stamp goes first, so the next lease
+     * runs the project's setup again and restores them. `wanted` is asked again right before anything goes; `deps`
+     * false keeps node_modules (no setup would restore it).
+     */
+    async slim(row, wanted, deps = true) {
+        const idle = (now) => now !== null && now.runner === null && now.releasedAt !== null && now.releasedAt === row.releasedAt && !this.inUse(row.path).held;
+        if (busy.has(row.path) || !existsSync(row.path) || !idle(this.store.getWorktree(row.path)))
+            return { ok: false, message: `${row.path} is in use` };
+        const listed = await this.runner(GIT, [...READ_ONLY, "ls-files", "--others", "--ignored", "--exclude-standard", "--directory", "-z"], { cwd: row.path, timeoutMs: WORKTREE_TIMEOUT_MS });
+        if (listed.code !== 0)
+            return { ok: false, message: `git couldn't list ${row.path}` };
+        const drop = listed.stdout.split("\0").filter(one => one.endsWith("/")).map(one => one.slice(0, -1))
+            .filter(one => { const name = one.split("/").at(-1); return SLIM_NAMES.includes(name) && (deps || name !== "node_modules"); });
+        if (drop.length === 0)
+            return { ok: true, dropped: [], bytes: 0 };
+        busy.set(row.path, "removing");
+        const note = join(row.path, MARKER);
+        let held = false;
+        try {
+            const now = this.store.getWorktree(row.path);
+            if (!idle(now) || !wanted(now))
+                return { ok: false, message: `${row.path} is in use` };
+            // Held while it slims: another process's lease sees this process in it.
+            try {
+                writeFileSync(note, `${process.pid} storage-retention slimming ${currentBootId() ?? "unknown"} ${hostname()}\n`, "utf8");
+                held = true;
+            }
+            catch {
+                return { ok: false, message: `${row.path} couldn't be held` };
+            }
+            const sizes = diskBytes(drop.map(one => join(row.path, one)));
+            this.store.forgetWorktreeSetup(row.path);
+            for (const one of drop)
+                rmSync(join(row.path, one), { recursive: true, force: true, maxRetries: 3 });
+            return { ok: true, dropped: drop, bytes: [...sizes.values()].reduce((sum, one) => sum + one, 0) };
+        }
+        finally {
+            if (held)
+                rmSync(note, { force: true });
+            busy.delete(row.path);
+        }
+    }
     /**
      * Throw away a let-go checkout kept for its changes, on purpose: the working copy and what is uncommitted in it
      * go; its branch, and every commit on it, stays. Refused while anything holds it.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolroll",
-  "version": "0.9.8",
+  "version": "0.9.9",
   "description": "A control plane for unattended coding agents — queue tasks, walk away, come back to pull requests. Agents build in leased worktrees, never touch your default branch, and interrupt you only for decisions that need a human.",
   "directories": {
     "doc": "docs"