@ricsam/r5d-worker 0.0.164 → 0.0.165

package/dist/cjs/package.json

@@ -1,5 +1,5 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.164",
+  "version": "0.0.165",
   "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.165";
   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.165" : "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.165" : "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.165",
   "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/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/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.165",
   "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.165",
     "node-pty": "1.1.0",
     "zod": "^4.1.13",
     "picomatch": "^4.0.3"