@ricsam/r5d-worker 0.0.164 → 0.0.166

package/dist/cjs/package.json

@@ -1,5 +1,5 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.164",
+  "version": "0.0.166",
   "type": "commonjs"
 }

package/dist/mjs/internal-r5dctl.cjs

@@ -20605,7 +20605,7 @@ function resolveEntrypointPath(entrypoint) {
   }
 }
 function getR5dctlVersion() {
-  if (true) return "0.0.164";
+  if (true) return "0.0.166";
   const entrypoint = process.argv[1] ? resolveEntrypointPath(process.argv[1]) : null;
   let current = entrypoint ? import_node_path2.default.dirname(entrypoint) : process.cwd();
   for (let index = 0; index < 12; index += 1) {

package/dist/mjs/main.mjs

@@ -7,7 +7,7 @@ import { startManagerRpc } from "./runtime/releases/rpc-main.mjs";
 import { ManagerRpcConfig } from "./runtime/releases/rpc-protocol.mjs";
 const args = process.argv.slice(2);
 if (args.includes("--version")) {
-  console.log(`r5d-worker ${true ? "0.0.164" : "development"}`);
+  console.log(`r5d-worker ${true ? "0.0.166" : "development"}`);
 } else if (!args.length || args.includes("--help")) {
   console.log(
     "Usage: r5d-worker start --label <label> [--root <dir>] [--base-url <url>] [--token <worker-token>]\n       r5d-worker executor /absolute/private/config.json\n       r5d-worker manager /absolute/private/config.json\n\nRun independently supervised durable runtime services. Provision configuration with r5dinfra."
@@ -15,7 +15,7 @@ if (args.includes("--version")) {
 } else if (args[0] === "start") {
   const runtime = await startPersonalWorker(
     parsePersonalWorkerOptions(args.slice(1)),
-    true ? "0.0.164" : "development"
+    true ? "0.0.166" : "development"
   );
   console.log(`Worker connected: ${runtime.resourceId}`);
   let closing = false;

package/dist/mjs/package.json

@@ -1,5 +1,5 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.164",
+  "version": "0.0.166",
   "type": "module"
 }

package/dist/mjs/personal/client.mjs

@@ -103,7 +103,7 @@ async function startPersonalWorker(options, version) {
     platform: process.platform,
     arch: process.arch,
     hostname: os.hostname(),
-    capabilities: { updateClis: true, durableWorkspace: true, outerWorkspace: true }
+    capabilities: { updateClis: true, durableWorkspace: true, outerWorkspace: true, fileWalk: true }
   });
   const grant = PersonalWorkerGrant.parse(
     await request("/api/personal/resources/register", { kind: "worker", ...identity, label: options.label, metadata: metadata() })
@@ -127,7 +127,9 @@ async function startPersonalWorker(options, version) {
       }
     },
     publicationReport: async (report) => {
-      await request(`${endpoint}/publication`, { instanceId: identity.instanceId, report });
+      const response = await request(`${endpoint}/publication`, { instanceId: identity.instanceId, report });
+      const result = response?.result;
+      return result && typeof result === "object" && typeof result.incidentId === "string" ? { incidentId: result.incidentId } : void 0;
     }
   });
   const ledgerFile = path.join(root, "relay.sqlite");

package/dist/mjs/personal/runtime.mjs

@@ -261,10 +261,12 @@ exec ${quote(executable)} ${quote(cli)} "$@"
     }
     const failedPublicationAttempts = /* @__PURE__ */ new Map();
     let publication = null, closing = false;
+    let pausedForIncident = null;
     const synchronize = () => {
       if (publication) return publication;
       const next = (async () => {
         const results = [];
+        if (pausedForIncident) return [{ workbenchId: "workspace", error: "remediation_paused" }];
         try {
           const outer = await authority.synchronizeOuter(grant.userId);
           failedPublicationAttempts.delete("workspace");
@@ -290,7 +292,7 @@ exec ${quote(executable)} ${quote(cli)} "$@"
             }
             if (publicationRefusalElects(code, attempt.observations)) {
               try {
-                await options.publicationReport(WorkspacePublicationReport.parse({
+                const elected = await options.publicationReport(WorkspacePublicationReport.parse({
                   protocol: 1,
                   attemptId: attempt.attemptId,
                   scope: "workspace",
@@ -300,6 +302,11 @@ exec ${quote(executable)} ${quote(cli)} "$@"
                   error: code,
                   ...paths.length ? { paths } : {}
                 }));
+                if (elected?.incidentId && pausedForIncident !== elected.incidentId) {
+                  pausedForIncident = elected.incidentId;
+                  process.stderr.write(`[r5d-worker] workspace synchronization paused for remediation ${elected.incidentId}
+`);
+                }
               } catch (reportError) {
                 process.stderr.write(`[r5d-worker] publication report deferred: ${reportError instanceof WorkspaceError ? reportError.code : "publication_report_failed"}
 `);
@@ -322,7 +329,7 @@ exec ${quote(executable)} ${quote(cli)} "$@"
       publication = next;
       void next.then(
         (results) => {
-          const deferred = results.filter((result) => result.error && !TRANSIENT_PUBLICATION_CODES.has(result.error));
+          const deferred = results.filter((result) => result.error && result.error !== "remediation_paused" && !TRANSIENT_PUBLICATION_CODES.has(result.error));
           if (deferred.length)
             process.stderr.write(`[r5d-worker] periodic workspace publication deferred: ${deferred.map((result) => `${result.workbenchId}:${result.error}`).join(", ")}
 `);
@@ -363,6 +370,7 @@ exec ${quote(executable)} ${quote(cli)} "$@"
         if (command.method === "git") return authority.inspectGit(identity, { ...command, method: command.action });
         if (command.method === "fileHistoryDates") return authority.fileHistoryDates(identity, command.path);
         if (command.method === "directory" || command.method === "raw") return authority.inspectFiles(identity, command);
+        if (command.method === "walk") return authority.walkFiles(identity, command);
       }
       if (request.kind === "terminal") {
         await authority.ensureHydrated(identity);
@@ -412,10 +420,18 @@ exec ${quote(executable)} ${quote(cli)} "$@"
         if (command.method === "commit") return authority.commit(identity, command);
         if (command.method === "push") return authority.push(identity, command);
         if (command.method === "reset") return authority.reset(identity, command);
-        if (command.method === "publish") return authority.publish(identity, {
-          allowLargeDiff: request.remediation === true && command.allowLargeDiff === true,
-          allowBlockedConflict: request.remediation === true
-        });
+        if (command.method === "publish") {
+          const published = await authority.publish(identity, {
+            allowLargeDiff: request.remediation === true && command.allowLargeDiff === true,
+            allowBlockedConflict: request.remediation === true
+          });
+          if (request.remediation === true && pausedForIncident) {
+            process.stderr.write(`[r5d-worker] workspace synchronization resumed after remediation ${pausedForIncident}
+`);
+            pausedForIncident = null;
+          }
+          return published;
+        }
         if (command.method === "reconcilePublication") return authority.reconcilePublication(identity);
       }
       if (request.kind === "agent") {

package/dist/mjs/runtime/workspace/authority.mjs

@@ -14,6 +14,7 @@ import {
 import { OuterRepository, OuterSnapshotRefusal, OUTER_BRANCH, OUTER_CONFLICT_CODE } from "./outer.mjs";
 import { SessionArtifactStore, SessionArtifactChunk, RESERVED_ARTIFACT_ENV } from "./artifacts.mjs";
 import { WorkspaceFileWrite, WorkspaceFileWriteLookup } from "./file-write.mjs";
+import { walkDirectoryTree } from "./walk.mjs";
 import { WorkspaceStorageClient } from "./storage-client.mjs";
 import {
   durableJson,
@@ -317,6 +318,26 @@ class WorkspaceAuthority {
     }));
     return { directory: display, entries };
   }
+  /** Walks a directory tree locally in one operation. Paths are reported
+   * relative to the walked directory; the shared ignore list and bounds live
+   * in `./walk` so the server's fallback agrees with them. */
+  async walkFiles(identity, command) {
+    const b = await this.bench(identity);
+    const relative = command.hostPath ? "" : command.path.replace(/^\/+/, "").replace(/\/+$/, "");
+    if (!command.hostPath && relative) safeTreePath(relative);
+    const target = command.hostPath ? this.resolveHostPath(command.path) : path.join(b.config.cwd, relative);
+    const display = command.hostPath ? target : `/${relative}`;
+    const inspect = command.hostPath ? fs.lstat(target).then((stat) => {
+      if (stat.isSymbolicLink()) throw new WorkspaceError("unsafe_path", "Final symlink paths are not inspected");
+    }) : noSymlinkAncestors(target);
+    await inspect.catch((error) => {
+      if (error.code === "ENOENT" || error.code === "ENOTDIR") throw new WorkspaceError("not_found", "File or directory not found");
+      throw error;
+    });
+    if (!(await fs.stat(target)).isDirectory()) throw new WorkspaceError("not_found", "Directory not found");
+    const walked = await walkDirectoryTree(target);
+    return { directory: display, ...walked };
+  }
   async inspectGit(identity, command) {
     const b = await this.bench(identity);
     return this.serial(b, async () => {

package/dist/mjs/runtime/workspace/outer.mjs

@@ -146,24 +146,22 @@ class OuterRepository {
   async snapshot(inners, options = {}) {
     const limit = options.limitBytes ?? OUTER_SNAPSHOT_LIMIT_BYTES;
     await this.seed(inners);
-    const dependencies = nulSplit(
-      await this.run(["ls-files", "--others", "--exclude-standard", "--directory", "-z", "--", ":(glob)**/node_modules/**"])
-    );
-    if (dependencies.length && !options.allowLargeDiff)
-      throw new OuterSnapshotRefusal("too_large", "An unignored dependency tree exceeds the automatic publication limit", dependencies.slice(0, MAX_REPORTED_PATHS));
     const others = nulSplit(await this.run(["ls-files", "--others", "--exclude-standard", "-z"]));
     const foreign = others.filter((file) => file.endsWith("/")).map((file) => file.slice(0, -1));
+    const collapsed = nulSplit(await this.run(["ls-files", "--others", "--exclude-standard", "--directory", "-z"])).filter((entry) => entry.endsWith("/") && !foreign.includes(entry.slice(0, -1)));
+    const attribute = (paths) => [...new Set(paths.map((file) => collapsed.find((directory) => file.startsWith(directory)) ?? file))].slice(0, MAX_REPORTED_PATHS);
     const tracked = /* @__PURE__ */ new Map();
+    const trackedOf = async (inner) => {
+      let set = tracked.get(inner.root);
+      if (!set) tracked.set(inner.root, set = await inner.tracked());
+      return set;
+    };
     let unexplainedBytes = 0;
     const unexplainedPaths = [];
     for (const file of others) {
       if (file.endsWith("/")) continue;
       const inner = inners.find((candidate) => withinRoot(file, candidate.root));
-      if (inner) {
-        let set = tracked.get(inner.root);
-        if (!set) tracked.set(inner.root, set = await inner.tracked());
-        if (set.has(file.slice(inner.root.length + 1))) continue;
-      }
+      if (inner && (await trackedOf(inner)).has(file.slice(inner.root.length + 1))) continue;
       const stat = await fs.lstat(path.join(this.workTree, file)).catch((error) => {
         if (error.code === "ENOENT" || error.code === "ENOTDIR") return null;
         throw error;
@@ -175,7 +173,7 @@ class OuterRepository {
         throw new OuterSnapshotRefusal(
           "too_large",
           `Unexplained workspace content exceeds the ${limit}-byte automatic publication limit`,
-          unexplainedPaths.slice(0, MAX_REPORTED_PATHS)
+          attribute(unexplainedPaths)
         );
     }
     for (const file of unexplainedPaths) {
@@ -192,9 +190,40 @@ class OuterRepository {
     }
     await this.run(["add", "-A", "--", ".", ...foreign.map((directory) => `:(exclude,literal)${directory}`)]);
     await this.stripUnsupported();
+    await this.evictIgnored(inners, trackedOf);
     const tree = GitOid.parse((await this.run(["write-tree"])).toString("utf8").trim());
     return { tree, unexplainedBytes, unexplainedPaths };
   }
+  /** Under a checkout the outer tree holds exactly what the checkout tracks plus
+   * what it shows as untracked-and-not-ignored. Staging never drops a tracked
+   * file that has since become ignored — npm's cache, published by a cycle that
+   * raced `npm install` while it was still under the limit, then excluded by a
+   * restored `.gitignore` — so such files are removed from the index here. The
+   * working tree is untouched; a fixed ignore file simply cleans what was
+   * published. The seeding invariant holds: a checkout never loses its last
+   * outer entry. */
+  async evictIgnored(inners, trackedOf) {
+    const cached = nulSplit(await this.run(["ls-files", "--cached", "-z"]));
+    const tracked = /* @__PURE__ */ new Map(), untracked = /* @__PURE__ */ new Map();
+    for (const file of cached) {
+      const inner = inners.find((candidate) => withinRoot(file, candidate.root));
+      if (!inner) continue;
+      if ((await trackedOf(inner)).has(file.slice(inner.root.length + 1))) tracked.set(inner.root, (tracked.get(inner.root) ?? 0) + 1);
+      else untracked.set(inner.root, [...untracked.get(inner.root) ?? [], file]);
+    }
+    const paths = [...untracked.values()].flat();
+    if (!paths.length) return;
+    const { code, stdout } = await this.result(["check-ignore", "--no-index", "-z", "--stdin"], `${paths.join("\0")}\0`);
+    if (code !== 0 && code !== 1) throw new WorkspaceError("git_failed", "Outer repository ignore rules are unreadable");
+    const ignored = new Set(nulSplit(stdout));
+    const removals = [];
+    for (const [root, files] of untracked) {
+      const drop = files.filter((file) => ignored.has(file));
+      const survivors = (tracked.get(root) ?? 0) + files.length - drop.length;
+      removals.push(...survivors ? drop : drop.sort().slice(1));
+    }
+    if (removals.length) await this.run(["update-index", "--force-remove", "-z", "--stdin"], `${removals.join("\0")}\0`);
+  }
   /** Staging records a symlink as a link entry, and a nested repository that
    * appeared between the walk and the add as a gitlink. Neither can be
    * materialized on another host; both are dropped from the index without

package/dist/mjs/runtime/workspace/walk.mjs

@@ -0,0 +1,94 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+const WORKSPACE_WALK_IGNORED = /* @__PURE__ */ new Set([
+  ".git",
+  "node_modules",
+  ".next",
+  "dist",
+  "build",
+  "coverage",
+  ".cache",
+  ".r5d",
+  ".r5d-next",
+  ".venv",
+  "venv",
+  "__pycache__",
+  ".npm",
+  ".pnpm-store",
+  ".yarn",
+  ".bun",
+  ".turbo",
+  ".parcel-cache",
+  ".mypy_cache",
+  ".pytest_cache",
+  ".ruff_cache",
+  ".gradle",
+  ".tox",
+  ".svelte-kit",
+  ".nuxt",
+  ".terraform"
+]);
+const WORKSPACE_WALK_LIMITS = Object.freeze({
+  /** Entries reported before the result is marked truncated. */
+  entries: 2e3,
+  /** Nesting depth below the walked directory. */
+  depth: 32,
+  /** Names read from any single directory; a larger directory truncates. */
+  directoryEntries: 2e5
+});
+const WorkspaceWalk = z.object({
+  method: z.literal("walk"),
+  path: z.string().max(4096),
+  hostPath: z.boolean().optional()
+}).strict();
+async function walkDirectoryTree(root, options = {}) {
+  const ignored = options.ignored ?? WORKSPACE_WALK_IGNORED, limits = options.limits ?? WORKSPACE_WALK_LIMITS;
+  const entries = [], queue = [{ relative: "", depth: 0 }];
+  let truncated = false;
+  while (queue.length) {
+    const next = queue.shift();
+    const directory = next.relative ? path.join(root, next.relative) : root;
+    let names;
+    try {
+      names = await fs.readdir(directory, { withFileTypes: true });
+    } catch (error) {
+      if (error.code === "ENOENT" || error.code === "ENOTDIR") continue;
+      throw error;
+    }
+    if (names.length > limits.directoryEntries) {
+      truncated = true;
+      continue;
+    }
+    names.sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of names) {
+      if (ignored.has(entry.name) || entry.isSymbolicLink() || !(entry.isFile() || entry.isDirectory())) continue;
+      if (entries.length >= limits.entries) {
+        truncated = true;
+        break;
+      }
+      const relative = next.relative ? path.posix.join(next.relative, entry.name) : entry.name;
+      let size = null;
+      if (entry.isFile()) {
+        try {
+          size = (await fs.stat(path.join(directory, entry.name))).size;
+        } catch {
+          continue;
+        }
+      }
+      entries.push({ path: relative, type: entry.isDirectory() ? "directory" : "file", size });
+      if (entry.isDirectory()) {
+        if (next.depth < limits.depth) queue.push({ relative, depth: next.depth + 1 });
+        else truncated = true;
+      }
+    }
+    if (entries.length >= limits.entries) break;
+  }
+  return { entries: entries.sort((a, b) => a.path.localeCompare(b.path)), truncated: truncated || queue.length > 0 };
+}
+export {
+  WORKSPACE_WALK_IGNORED,
+  WORKSPACE_WALK_LIMITS,
+  WorkspaceWalk,
+  walkDirectoryTree
+};

package/dist/types/personal/runtime.d.ts

@@ -111,7 +111,9 @@ export declare function openPersonalWorkerRuntime(options: {
     publicationIntervalMs?: number;
     /** Authenticated transport for autonomous publication evidence. Failures are
      * retried with the same attempt identity on the next publication cycle. */
-    publicationReport?: (report: z.infer<typeof WorkspacePublicationReport>) => Promise<void>;
+    publicationReport?: (report: z.infer<typeof WorkspacePublicationReport>) => Promise<{
+        incidentId?: string;
+    } | void>;
 }): Promise<{
     grant: {
         [x: string]: unknown;

package/dist/types/runtime/workspace/authority.d.ts

@@ -3,6 +3,7 @@ import { type PollResult, type RunIdentity } from "../protocol";
 import { WorkspaceConfig, type ExecutorRoute, type WorkspaceIdentity, type OuterState, type ApprovedWorkbench as ApprovedWorkbenchInput } from "./contracts";
 import { SessionArtifactChunk } from "./artifacts";
 import { WorkspaceFileWrite } from "./file-write";
+import { type WorkspaceWalk, type WorkspaceWalkResult } from "./walk";
 import { WorkspaceStorageClient } from "./storage-client";
 export interface WorkspaceAuthorityOptions {
     config: WorkspaceConfig;
@@ -107,6 +108,10 @@ export declare class WorkspaceAuthority {
         size?: undefined;
         modifiedAt?: undefined;
     }>;
+    /** Walks a directory tree locally in one operation. Paths are reported
+     * relative to the walked directory; the shared ignore list and bounds live
+     * in `./walk` so the server's fallback agrees with them. */
+    walkFiles(identity: WorkspaceIdentity, command: WorkspaceWalk): Promise<WorkspaceWalkResult>;
     inspectGit(identity: WorkspaceIdentity, command: {
         method: "status" | "diff" | "history" | "fileDiff";
         path?: string;

package/dist/types/runtime/workspace/outer.d.ts

@@ -75,6 +75,15 @@ export declare class OuterRepository {
         allowLargeDiff?: boolean;
         limitBytes?: number;
     }): Promise<OuterSnapshot>;
+    /** Under a checkout the outer tree holds exactly what the checkout tracks plus
+     * what it shows as untracked-and-not-ignored. Staging never drops a tracked
+     * file that has since become ignored — npm's cache, published by a cycle that
+     * raced `npm install` while it was still under the limit, then excluded by a
+     * restored `.gitignore` — so such files are removed from the index here. The
+     * working tree is untouched; a fixed ignore file simply cleans what was
+     * published. The seeding invariant holds: a checkout never loses its last
+     * outer entry. */
+    private evictIgnored;
     /** Staging records a symlink as a link entry, and a nested repository that
      * appeared between the walk and the add as a gitlink. Neither can be
      * materialized on another host; both are dropped from the index without

package/dist/types/runtime/workspace/walk.d.ts

@@ -0,0 +1,49 @@
+import { z } from "zod";
+/** Directory names never descended by find/grep: dependency trees, build
+ * output and package-manager caches. The worker walks a checkout locally, so
+ * this list decides what a search sees; it is shared with the server so its
+ * per-directory fallback (older workers, virtual directories) agrees.
+ *
+ * Package-manager caches are here deliberately: `npm install` writes a deep
+ * hash-sharded `.npm/_cacache` into the checkout whenever its cache resolves
+ * there, and before this walk moved to the worker a single find over it cost
+ * one network round-trip per directory — enough to exhaust the agent's tool
+ * timeout and strand a workspace-remediation run. */
+export declare const WORKSPACE_WALK_IGNORED: ReadonlySet<string>;
+/** Bounds a walk regardless of what a checkout contains. */
+export declare const WORKSPACE_WALK_LIMITS: Readonly<{
+    /** Entries reported before the result is marked truncated. */
+    entries: 2000;
+    /** Nesting depth below the walked directory. */
+    depth: 32;
+    /** Names read from any single directory; a larger directory truncates. */
+    directoryEntries: 200000;
+}>;
+/** Inspect command: walk a directory tree in one worker operation. */
+export declare const WorkspaceWalk: z.ZodObject<{
+    method: z.ZodLiteral<"walk">;
+    path: z.ZodString;
+    hostPath: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type WorkspaceWalk = z.infer<typeof WorkspaceWalk>;
+export type WorkspaceWalkEntry = {
+    path: string;
+    type: "file" | "directory";
+    size: number | null;
+};
+export type WorkspaceWalkResult = {
+    directory: string;
+    entries: WorkspaceWalkEntry[];
+    truncated: boolean;
+};
+/** Breadth-first walk of `root`, reporting paths relative to it (POSIX). Names
+ * in `ignored` are neither reported nor descended; symlinks and anything that
+ * is not a regular file or directory are skipped. The result is sorted by path
+ * and bounded by `limits`. */
+export declare function walkDirectoryTree(root: string, options?: {
+    ignored?: ReadonlySet<string>;
+    limits?: typeof WORKSPACE_WALK_LIMITS;
+}): Promise<{
+    entries: WorkspaceWalkEntry[];
+    truncated: boolean;
+}>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.164",
+  "version": "0.0.166",
   "type": "module",
   "main": "./dist/mjs/main.mjs",
   "module": "./dist/mjs/main.mjs",
@@ -21,7 +21,7 @@
     "r5d-worker": "dist/mjs/main.mjs"
   },
   "dependencies": {
-    "@ricsam/r5d-api": "^0.0.164",
+    "@ricsam/r5d-api": "^0.0.166",
     "node-pty": "1.1.0",
     "zod": "^4.1.13",
     "picomatch": "^4.0.3"