@webpresso/agent-kit 3.1.30 → 3.3.0

package/dist/esm/worktrees/orphan-scan.js

@@ -0,0 +1,211 @@
+/**
+ * Filesystem-level orphan scan for `wp worktree prune --orphans`.
+ *
+ * Complements the existing registry-only `wp worktree prune --all`: that
+ * command only drops stale bookkeeping rows from `registry.json`. This module
+ * instead walks the physical managed-worktree roots
+ * (`~/.webpresso/worktrees`, legacy `~/.agent/worktrees`) directly, because a
+ * large share of stale directories on disk were never registered at all
+ * (crashed sessions, `gh pr merge --delete-branch` deregistering the git
+ * worktree out from under the directory, manual `rm` of only part of a
+ * worktree). Git metadata and the registry can both be perfectly clean while
+ * the `~/.webpresso` tree still accumulates dozens of dead directories.
+ *
+ * Classification (see `catalog blueprint worktree-prune-stale-dirs`):
+ *
+ * - `alive`        — path is listed by `git worktree list` for its resolved
+ *                     primary repo. Never removable.
+ * - `orphan`        — a resolvable, existing primary repo's `git worktree
+ *                     list` output does NOT include this path. Removable only
+ *                     when a `git status --porcelain` probe inside the
+ *                     directory succeeds AND reports no changes.
+ * - `broken`        — a primary repo pointer was resolved, but the target
+ *                     repo itself is missing on disk, or its `git worktree
+ *                     list` probe failed outright (bounded, non-retrying).
+ *                     Never removable — the directory's true state cannot be
+ *                     proven.
+ * - `unrecognized`  — no primary repo pointer could be resolved at all
+ *                     (neither `registry.json` nor the directory's own
+ *                     `.git` file yields one), or the directory's `.git`
+ *                     pointer resolves but `git status --porcelain` cannot
+ *                     even run inside it (not a functioning checkout).
+ *                     Reported for manual review; never removable.
+ */
+import { readdirSync, statSync } from "node:fs";
+import { join, relative, sep } from "node:path";
+import { canonicalizeWorktreePath } from "./identity.js";
+function measureSizeSafely(path, deps) {
+    try {
+        return deps.measureSize(path);
+    }
+    catch {
+        return "unknown";
+    }
+}
+function finalizeRow(candidate, classification, reason, deps) {
+    if (classification !== "orphan") {
+        return {
+            ...candidate,
+            classification,
+            dirty: "unknown",
+            sizeBytes: "unknown",
+            removable: false,
+            reason,
+        };
+    }
+    const dirty = deps.probeDirty(candidate.path);
+    if (dirty === "unknown") {
+        return {
+            ...candidate,
+            classification: "unrecognized",
+            dirty,
+            sizeBytes: "unknown",
+            removable: false,
+            reason: "git status probe failed — not a functioning git checkout",
+        };
+    }
+    // Size is decision-relevant only once a row is a confirmed orphan, so it is
+    // measured here — never for alive/broken/unrecognized rows above.
+    const sizeBytes = measureSizeSafely(candidate.path, deps);
+    return {
+        ...candidate,
+        classification,
+        dirty,
+        sizeBytes,
+        removable: dirty === false,
+        reason: dirty ? "uncommitted/untracked changes present" : reason,
+    };
+}
+/** Classify a single on-disk candidate. Pure aside from the injected deps. */
+export function classifyOrphanCandidate(candidate, deps) {
+    const repoRoot = deps.resolveRepoRoot(candidate);
+    if (!repoRoot) {
+        return finalizeRow(candidate, "unrecognized", "no resolvable primary repo pointer", deps);
+    }
+    if (!deps.repoRootExists(repoRoot)) {
+        return finalizeRow(candidate, "broken", `target repo missing: ${repoRoot}`, deps);
+    }
+    const inventory = deps.buildInventory(repoRoot);
+    if (!inventory.complete) {
+        return finalizeRow(candidate, "broken", "git worktree list unavailable for target repo", deps);
+    }
+    const canonical = canonicalizeWorktreePath(candidate.path);
+    if (inventory.canonicalPaths.has(canonical)) {
+        return finalizeRow(candidate, "alive", "present in git worktree list", deps);
+    }
+    return finalizeRow(candidate, "orphan", "absent from git worktree list", deps);
+}
+/** Namespace-keyed lookup of a known-live `repoRoot`, first-registered-wins. */
+export function buildRegistryRepoRootMap(entries) {
+    const map = new Map();
+    for (const entry of entries) {
+        if (!map.has(entry.repoNamespace))
+            map.set(entry.repoNamespace, entry.repoRoot);
+    }
+    return map;
+}
+const WORKTREES_GITDIR_MARKER = "/.git/worktrees/";
+/**
+ * Fallback primary-repo resolver for candidates the registry never recorded:
+ * a linked worktree's `.git` is a file containing `gitdir: <repoRoot>/.git/
+ * worktrees/<name>`. Returns `undefined` when unreadable or unparseable
+ * (e.g. `.git` is a directory, or the pointer target was already reaped).
+ */
+export function resolveRepoRootFromGitPointer(path, readGitPointer) {
+    const content = readGitPointer(join(path, ".git"));
+    if (!content)
+        return undefined;
+    const match = /^gitdir:\s*(.+)$/mu.exec(content.trim());
+    const gitdir = match?.[1]?.trim();
+    if (!gitdir)
+        return undefined;
+    const markerIndex = gitdir.lastIndexOf(WORKTREES_GITDIR_MARKER);
+    if (markerIndex === -1)
+        return undefined;
+    return gitdir.slice(0, markerIndex);
+}
+const MAX_SCAN_DEPTH = 8;
+const SKIP_DIR_NAMES = new Set([".git", "node_modules"]);
+function repoNamespaceFromPath(root, path) {
+    const segments = relative(root, path).split(sep).filter(Boolean);
+    const reposIndex = segments.indexOf("repos");
+    if (reposIndex === -1)
+        return undefined;
+    return segments[reposIndex + 1];
+}
+function walkForCandidates(root, dir, depth, out) {
+    if (depth > MAX_SCAN_DEPTH)
+        return;
+    let entries;
+    try {
+        entries = readdirSync(dir, { withFileTypes: true, encoding: "utf8" });
+    }
+    catch {
+        return;
+    }
+    if (entries.some((entry) => entry.name === ".git")) {
+        const repoNamespace = repoNamespaceFromPath(root, dir);
+        if (repoNamespace)
+            out.push({ path: dir, repoNamespace });
+        return; // never descend into a worktree checkout's own contents
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory() || SKIP_DIR_NAMES.has(entry.name))
+            continue;
+        walkForCandidates(root, join(dir, entry.name), depth + 1, out);
+    }
+}
+/** Walk every known managed-worktree root and collect worktree-shaped leaf dirs. */
+export function discoverOrphanScanCandidates(roots, options = {}) {
+    const dirExists = options.dirExists ??
+        ((path) => {
+            try {
+                return statSync(path).isDirectory();
+            }
+            catch {
+                return false;
+            }
+        });
+    const out = [];
+    for (const root of roots) {
+        if (!dirExists(root))
+            continue;
+        walkForCandidates(root, root, 0, out);
+    }
+    return options.repoNamespaceFilter
+        ? out.filter((candidate) => candidate.repoNamespace === options.repoNamespaceFilter)
+        : out;
+}
+/** Bounded recursive directory size, symlinks excluded, unreadable entries skipped. */
+export function measureDirectorySizeBytes(path) {
+    let total = 0;
+    const stack = [path];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (current === undefined)
+            break;
+        let entries;
+        try {
+            entries = readdirSync(current, { withFileTypes: true, encoding: "utf8" });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (entry.isSymbolicLink())
+                continue;
+            const full = join(current, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(full);
+                continue;
+            }
+            try {
+                total += statSync(full).size;
+            }
+            catch {
+                // unreadable file: skip rather than fail the whole scan
+            }
+        }
+    }
+    return total;
+}

package/dist/esm/worktrees/registry.d.ts

@@ -50,6 +50,13 @@ export interface PruneStaleWorktreeRegistryOptions extends RegistryOptions {
     readonly inventory: WorktreeInventory;
     readonly scope: MembershipScope;
 }
+export interface StaleWorktreeRegistryPrunePlan {
+    readonly kept: ManagedWorktreeEntry[];
+    readonly removed: ManagedWorktreeEntry[];
+    readonly warnings: string[];
+    /** Persist the already-classified registry mutation after dependent cleanup succeeds. */
+    commit(): void;
+}
 /** Read one physical registry file at `root`. */
 export declare function readPhysicalRegistry(root: string): WorktreeRegistry;
 /** Write one physical registry file at `root`. */
@@ -100,6 +107,7 @@ export declare function removeWorktreeRegistryEntries(predicate: (entry: Managed
  * when it is PROVEN-SAME-REPO and STALE against a COMPLETE inventory; unknown,
  * other-repo, and present entries are RETAINED.
  */
+export declare function planStaleWorktreeRegistryPrune(options: PruneStaleWorktreeRegistryOptions): StaleWorktreeRegistryPrunePlan;
 export declare function pruneStaleWorktreeRegistryEntries(options: PruneStaleWorktreeRegistryOptions): {
     kept: ManagedWorktreeEntry[];
     removed: ManagedWorktreeEntry[];

package/dist/esm/worktrees/registry.js

@@ -193,7 +193,7 @@ export function removeWorktreeRegistryEntries(predicate, options = {}) {
  * when it is PROVEN-SAME-REPO and STALE against a COMPLETE inventory; unknown,
  * other-repo, and present entries are RETAINED.
  */
-export function pruneStaleWorktreeRegistryEntries(options) {
+export function planStaleWorktreeRegistryPrune(options) {
     const resolveKey = options.scope.resolveMembershipRepoKey ?? ((dir) => resolveRepoIdentity(dir));
     const shouldPrune = (entry) => {
         const membership = classifyMembership(entry.repoRoot, options.scope.authoritativeRepoKey, resolveKey);
@@ -205,16 +205,31 @@ export function pruneStaleWorktreeRegistryEntries(options) {
     };
     const kept = [];
     const removed = [];
+    const pendingWrites = [];
     for (const root of physicalRoots(options)) {
         const registry = readPhysicalRegistry(root);
         const rootRemoved = registry.entries.filter(shouldPrune);
         const rootKept = registry.entries.filter((entry) => !shouldPrune(entry));
         if (rootRemoved.length > 0)
-            writePhysicalRegistry({ version: 1, entries: rootKept }, root);
+            pendingWrites.push({ root, entries: rootKept });
         kept.push(...rootKept);
         removed.push(...rootRemoved);
     }
-    return { kept, removed, warnings: [...options.inventory.warnings] };
+    return {
+        kept,
+        removed,
+        warnings: [...options.inventory.warnings],
+        commit() {
+            for (const pendingWrite of pendingWrites) {
+                writePhysicalRegistry({ version: 1, entries: pendingWrite.entries }, pendingWrite.root);
+            }
+        },
+    };
+}
+export function pruneStaleWorktreeRegistryEntries(options) {
+    const plan = planStaleWorktreeRegistryPrune(options);
+    plan.commit();
+    return plan;
 }
 /**
  * LISTING-ONLY logical lookup by id. Identity-sensitive owner resolution must

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webpresso/agent-kit",
-  "version": "3.1.30",
+  "version": "3.3.0",
   "private": false,
   "description": "TypeScript-first agent harness for guarded develop/deploy workflows: wp CLI gates, MCP tools, hooks, memory, worktrees, secrets, audits, and evidence checks.",
   "keywords": [
@@ -142,6 +142,8 @@
     "#compiler/*": "./src/compiler/*.ts",
     "#review/*.js": "./src/review/*.ts",
     "#review/*": "./src/review/*.ts",
+    "#rust/*.js": "./src/rust/*.ts",
+    "#rust/*": "./src/rust/*.ts",
     "#telemetry/*.js": "./src/telemetry/*.ts",
     "#telemetry/*": "./src/telemetry/*.ts",
     "#codex/app-server/client": "./src/codex/app-server/client.ts",
@@ -365,7 +367,7 @@
     "version": "changeset version && vp run sync-marketplace-version && vp run generate-skills && ./bin/wp format",
     "release:publish": "bun scripts/release-publish.ts",
     "typecheck": "./bin/wp typecheck",
-    "test": "vitest run",
+    "test": "bun scripts/run-vitest-projects.ts",
     "test:mutation": "bun stryker run stryker.config.ts",
     "eval": "bun src/runners/evals/index.ts",
     "bench:dash": "bun scripts/bench/wp-dash-menu.tsx",
@@ -392,6 +394,9 @@
     "audits:check": "./bin/wp audit guardrails && vp run workflow-actions:check && vp run hooks:doctor:ci && vp run check:blueprint-done-ledger",
     "hooks:doctor": "./bin/wp hooks doctor",
     "hooks:doctor:ci": "./bin/wp hooks doctor --skip-mcp && PATH=\"$PWD/bin:$PATH\" ./bin/wp hooks conformance --hosts codex,claude,opencode --lanes generated,repo,runtime,global,plugin --strict",
+    "proof:host-native": "bun scripts/host-native-proof.ts",
+    "proof:host-native:claude": "bun scripts/host-native-proof.ts --host claude",
+    "proof:host-native:grok": "bun scripts/host-native-proof.ts --host grok",
     "qa": "vp run build && bun scripts/run-parallel-checks.ts",
     "changeset": "changeset",
     "changeset:status": "GIT_WORK_TREE=$PWD changeset status",
@@ -502,16 +507,16 @@
     "setupWpActionRef": "c2c71a7a4be446fc6858e6b57bf55a11ccfa2d88"
   },
   "optionalDependencies": {
-    "@webpresso/agent-kit-runtime-darwin-arm64": "3.1.30",
-    "@webpresso/agent-kit-runtime-darwin-x64": "3.1.30",
-    "@webpresso/agent-kit-runtime-linux-x64": "3.1.30",
-    "@webpresso/agent-kit-runtime-linux-arm64": "3.1.30",
-    "@webpresso/agent-kit-runtime-windows-x64": "3.1.30",
-    "@webpresso/agent-kit-session-memory-darwin-x64": "3.1.30",
-    "@webpresso/agent-kit-session-memory-darwin-arm64": "3.1.30",
-    "@webpresso/agent-kit-session-memory-linux-x64": "3.1.30",
-    "@webpresso/agent-kit-session-memory-linux-arm64": "3.1.30",
-    "@webpresso/agent-kit-session-memory-win32-x64": "3.1.30",
-    "@webpresso/agent-kit-session-memory-win32-arm64": "3.1.30"
+    "@webpresso/agent-kit-runtime-darwin-arm64": "3.3.0",
+    "@webpresso/agent-kit-runtime-darwin-x64": "3.3.0",
+    "@webpresso/agent-kit-runtime-linux-x64": "3.3.0",
+    "@webpresso/agent-kit-runtime-linux-arm64": "3.3.0",
+    "@webpresso/agent-kit-runtime-windows-x64": "3.3.0",
+    "@webpresso/agent-kit-session-memory-darwin-x64": "3.3.0",
+    "@webpresso/agent-kit-session-memory-darwin-arm64": "3.3.0",
+    "@webpresso/agent-kit-session-memory-linux-x64": "3.3.0",
+    "@webpresso/agent-kit-session-memory-linux-arm64": "3.3.0",
+    "@webpresso/agent-kit-session-memory-win32-x64": "3.3.0",
+    "@webpresso/agent-kit-session-memory-win32-arm64": "3.3.0"
   }
 }