@ricsam/r5d-worker 0.0.143 → 0.0.145

package/dist/cjs/package.json

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

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.143" : "development"}`);
+  console.log(`r5d-worker ${true ? "0.0.145" : "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.143" : "development"
+    true ? "0.0.145" : "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.143",
+  "version": "0.0.145",
   "type": "module"
 }

package/dist/mjs/personal/runtime.mjs

@@ -132,7 +132,7 @@ exec ${quote(executable)} ${quote(cli)} "$@"
       timeoutMs: 1e4
     });
     let current = grant, installed = false, retirementPending = false;
-    const manifests = /* @__PURE__ */ new Map(), routes = /* @__PURE__ */ new Map();
+    const manifests = /* @__PURE__ */ new Map(), routes = /* @__PURE__ */ new Map(), publicationSessions = /* @__PURE__ */ new Map();
     const manifestFile = path.join(root, "workbenches.json");
     try {
       const rows = z.array(ApprovedWorkbench).parse(readPrivateJson(manifestFile));
@@ -140,6 +140,8 @@ exec ${quote(executable)} ${quote(cli)} "$@"
         if (row.userId !== grant.userId || row.cwd !== workspaceRoot && !row.cwd.startsWith(workspaceRoot + path.sep))
           throw new Error("Invalid retained workbench");
         manifests.set(row.id, row);
+        routes.set(row.sessionId, row.id);
+        if (row.rootProfile === "project") publicationSessions.set(row.id, row.sessionId);
       }
     } catch (error) {
       if (error.code !== "ENOENT") throw error;
@@ -227,6 +229,7 @@ exec ${quote(executable)} ${quote(cli)} "$@"
         await fs.rename(tmp, manifestFile);
       }
       routes.set(input.sessionId, input.id);
+      if (row.rootProfile === "project") publicationSessions.set(row.id, input.sessionId);
     }
     async function installCredentials(values) {
       for (const source of values) {
@@ -247,6 +250,48 @@ exec ${quote(executable)} ${quote(cli)} "$@"
         }
       }
     }
+    let publication = null, closing = false;
+    const synchronize = () => {
+      if (publication) return publication;
+      const next = (async () => {
+        const results = [];
+        for (const [workbenchId, sessionId] of publicationSessions) {
+          if (closing) break;
+          const manifest = manifests.get(workbenchId);
+          if (!manifest || manifest.rootProfile !== "project") continue;
+          try {
+            const result = await authority.publish({ userId: grant.userId, sessionId });
+            results.push({ workbenchId, ...result });
+          } catch (error) {
+            const code = error instanceof WorkspaceError ? error.code : "publication_failed";
+            results.push({ workbenchId, error: code });
+          }
+        }
+        return results;
+      })();
+      publication = next;
+      void next.then(
+        (results) => {
+          if (results.some((result) => result.error && result.error !== "not_initialized"))
+            process.stderr.write(`[r5d-worker] periodic workspace publication deferred: ${results.filter((result) => result.error).map((result) => `${result.workbenchId}:${result.error}`).join(", ")}
+`);
+          if (publication === next) publication = null;
+        },
+        (error) => {
+          process.stderr.write(`[r5d-worker] periodic workspace publication failed: ${error instanceof WorkspaceError ? error.code : "publication_failed"}
+`);
+          if (publication === next) publication = null;
+        }
+      );
+      return next;
+    };
+    const publicationIntervalMs = options.publicationIntervalMs ?? 6e4;
+    if (!Number.isSafeInteger(publicationIntervalMs) || publicationIntervalMs <= 0)
+      throw new Error("Publication interval must be a positive integer");
+    const publicationTimer = setInterval(() => {
+      void synchronize();
+    }, publicationIntervalMs);
+    publicationTimer.unref?.();
     const tcp = new PersonalTcpManager(path.join(root, "tcp"));
     async function dispatch(raw) {
       const request = PersonalWorkspaceRequest.parse(raw);
@@ -357,7 +402,11 @@ exec ${quote(executable)} ${quote(cli)} "$@"
       renew,
       dispatch,
       authority,
+      synchronize,
       async close() {
+        closing = true;
+        clearInterval(publicationTimer);
+        await publication;
         await tcp.close();
         await authority.close();
         await daemon.close();

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

@@ -10,7 +10,6 @@ import {
   ApprovedWorkbench,
   WorkspaceConfig,
   WorkspaceError,
-  WorkspacePublicationNotAdmitted,
   DEFAULT_WORKSPACE_IGNORE
 } from "./contracts.mjs";
 import { SessionArtifactStore, SessionArtifactChunk, RESERVED_ARTIFACT_ENV } from "./artifacts.mjs";
@@ -403,13 +402,11 @@ class WorkspaceAuthority {
     }
     await this.save(b);
   }
-  async idle(b, allowBlocked = false) {
-    await this.refresh(b);
-    if (Object.values(b.state.runs).some((r) => r.mutating && !["completed", "cancelled", "rejected_capacity"].includes(r.state)))
-      throw new WorkspaceError(
-        "workbench_busy",
-        "A mutating command is active/unknown; poll original executor run to terminal before syncing"
-      );
+  /** Workspace synchronization is independent of process lifetime. The serial
+   * authority queue excludes other authority mutations, while shells and
+   * agents remain ordinary concurrent filesystem writers whose later changes
+   * are observed by a subsequent publication cycle. */
+  async assertAvailable(b, allowBlocked = false) {
     if (b.state.blocked && !allowBlocked) throw new WorkspaceError(b.state.blocked.code, b.state.blocked.message);
   }
   async status(identity) {
@@ -425,7 +422,11 @@ class WorkspaceAuthority {
         } catch {
         }
       }
-      return { workbench: { ...b.config, sessionId: identity.sessionId }, ...structuredClone(b.state), files };
+      const state = structuredClone(b.state);
+      state.runs = Object.fromEntries(
+        Object.entries(state.runs).filter(([, run]) => (run.sessionId ?? b.config.sessionId) === identity.sessionId)
+      );
+      return { workbench: { ...b.config, sessionId: identity.sessionId }, ...state, files };
     });
   }
   async cleanRefreshBase(b, expectedBase) {
@@ -454,8 +455,8 @@ class WorkspaceAuthority {
     if (!unchangedPublishedMetadata && (await git(b.repo, ["write-tree"], void 0, index)).toString().trim() !== expectedTree)
       throw new WorkspaceError("dirty_workbench", "Staged changes are retained; resolve them before refreshing");
   }
-  /** No-argument hydration is initial-only. Explicit expectedBase permits a clean,
-   * idle workbench refresh; all replaced source/index/ref bytes are retained. */
+  /** No-argument hydration is initial-only. Explicit expectedBase permits a
+   * clean workbench refresh; process/PTY liveness never gates synchronization. */
   async hydrate(identity, expectedBase) {
     const b = await this.bench(identity);
     if (b.config.rootProfile === "account") return { head: "", unchanged: true };
@@ -463,7 +464,7 @@ class WorkspaceAuthority {
   }
   async hydrateIdle(b, identity, expectedBase) {
     if (b.state.blocked?.code === "account_initialization_unknown") {
-      await this.idle(b, true);
+      await this.assertAvailable(b, true);
       await this.assertFreshAccountWorkbench(b, expectedBase);
       const operationId = `account-initialize-${sha256(b.config.userId)}`;
       if (b.state.blocked.operationId !== operationId) throw new WorkspaceError("wrong_binding", "Account initialization receipt identity changed");
@@ -474,10 +475,11 @@ class WorkspaceAuthority {
       b.state.blocked = null;
       await this.save(b);
     }
-    await this.idle(b);
+    await this.assertAvailable(b);
     if (expectedBase !== void 0) {
       GitOid.parse(expectedBase);
-      await this.cleanRefreshBase(b, expectedBase);
+      if (!b.state.initialized || b.state.head !== expectedBase)
+        throw new WorkspaceError("conflict", "Workbench base changed; inspect before refreshing");
     } else if (b.state.initialized || (await fs.readdir(b.config.cwd)).length)
       throw new WorkspaceError(
         "nonempty_workbench",
@@ -507,6 +509,7 @@ class WorkspaceAuthority {
     if (!head) throw new WorkspaceError("empty_repository", "Seed README explicitly for an empty canonical branch");
     GitOid.parse(head);
     if (expectedBase === head) return { head };
+    if (expectedBase !== void 0) await this.cleanRefreshBase(b, expectedBase);
     b.state.blocked = {
       code: expectedBase === void 0 ? "hydration_incomplete" : "refresh_incomplete",
       message: "Source synchronization interrupted; preserve workbench and inspect staged tree/retained originals before maintenance"
@@ -732,7 +735,7 @@ class WorkspaceAuthority {
   async seedReadme(identity, readme) {
     const b = await this.bench(identity);
     return this.serial(b, async () => {
-      await this.idle(b);
+      await this.assertAvailable(b);
       if (Buffer.byteLength(readme) > 1024 * 1024) throw new WorkspaceError("too_large", "README seed exceeds limit");
       sourceBytes(Buffer.from(readme));
       if (b.state.initialized || (await fs.readdir(b.config.cwd)).length)
@@ -948,7 +951,7 @@ class WorkspaceAuthority {
       const head = GitOid.parse((await git(b.repo, ["rev-parse", "FETCH_HEAD"])).toString().trim());
       return this.importCommit(b, head, input.id, identity);
     }, async () => {
-      await this.idle(b);
+      await this.assertAvailable(b);
       if (b.state.initialized || (await fs.readdir(b.config.cwd)).length) throw new WorkspaceError("nonempty_workbench", "Import requires a new empty workbench");
     }));
   }
@@ -972,7 +975,7 @@ class WorkspaceAuthority {
     if (source.config.repositoryId !== target.config.repositoryId || source.config.branch === target.config.branch) throw new WorkspaceError("forbidden", "Branch source must belong to the same project");
     await this.ensureHydrated(sourceIdentity);
     const prepared = await this.serial(source, async () => {
-      await this.idle(source);
+      await this.assertAvailable(source);
       let head = source.state.head;
       if (input.workingTree === "carry") {
         const tree = await snapshotTree(source.repo, source.config.cwd, head);
@@ -990,7 +993,7 @@ class WorkspaceAuthority {
       await git(target.repo, ["bundle", "unbundle", file]);
       return this.importCommit(target, prepared.head, input.id, identity);
     }, async () => {
-      await this.idle(target);
+      await this.assertAvailable(target);
       if (target.state.initialized || (await fs.readdir(target.config.cwd)).length) throw new WorkspaceError("nonempty_workbench", "Branch already has a workbench");
     }));
   }
@@ -1070,7 +1073,7 @@ ${DEFAULT_WORKSPACE_IGNORE}`, { mode: 384 });
       await this.installGitPolicy(b, result.head);
       return { ...result, treeHash: (await git(b.repo, ["rev-parse", `${result.head}^{tree}`])).toString().trim() };
     }, async () => {
-      await this.idle(b);
+      await this.assertAvailable(b);
       if (input.expectedHead !== void 0 && input.expectedHead !== b.state.head) throw new WorkspaceError("conflict", "Workbench head changed");
     }));
   }
@@ -1085,7 +1088,7 @@ ${DEFAULT_WORKSPACE_IGNORE}`, { mode: 384 });
       await git(b.repo, ["-c", "protocol.https.allow=always", "push", "--porcelain", ...input.remote.expectedHead !== void 0 ? [`--force-with-lease=refs/heads/${input.remote.branch}:${input.remote.expectedHead ?? ""}`] : [], "--", input.remote.url, `${b.state.head}:refs/heads/${input.remote.branch}`], void 0, void 0, { token: input.remote.token });
       return { head: b.state.head, pushed: true };
     }, async () => {
-      await this.idle(b);
+      await this.assertAvailable(b);
       if (!b.state.head || input.expectedHead !== void 0 && input.expectedHead !== b.state.head) throw new WorkspaceError("conflict", "Workbench head changed");
     }));
   }
@@ -1105,13 +1108,13 @@ ${DEFAULT_WORKSPACE_IGNORE}`, { mode: 384 });
       b.state.blocked = { code: "archived", message: "This branch incarnation is archived; its workbench and source are retained" };
       await this.save(b);
       return { removed: true, receipt: result };
-    }, () => this.idle(b)));
+    }, () => this.assertAvailable(b)));
   }
   /** An explicit user reset retains the complete old tree/index before hydration. */
   async reset(identity, input) {
     const b = await this.bench(identity);
     return this.serial(b, () => this.productAction(b, input.id, { method: "reset", expectedHead: input.expectedHead }, async () => {
-      await this.idle(b, true);
+      await this.assertAvailable(b, true);
       if (input.expectedHead !== void 0 && input.expectedHead !== b.state.head) throw new WorkspaceError("conflict", "Workbench base changed before reset");
       if (b.state.blocked?.code === "archived") throw new WorkspaceError("archived", "A deleted branch cannot be reset");
       const storage = await this.storage(b, identity);
@@ -1145,12 +1148,7 @@ ${DEFAULT_WORKSPACE_IGNORE}`, { mode: 384 });
     const b = await this.bench(identity);
     if (b.config.rootProfile === "account") return { head: "", unchanged: true };
     return this.serial(b, async () => {
-      try {
-        await this.idle(b);
-      } catch (error) {
-        if (!(error instanceof WorkspaceError) || error.code !== "workbench_busy") throw error;
-        throw new WorkspacePublicationNotAdmitted("workbench_busy", error.message);
-      }
+      await this.assertAvailable(b);
       return this.publishIdle(b, identity);
     });
   }
@@ -1361,13 +1359,13 @@ ${DEFAULT_WORKSPACE_IGNORE}`, { mode: 384 });
   async runRoute(identity, run) {
     const b = await this.bench(identity);
     if (run.userId !== identity.userId || run.sessionId !== identity.sessionId || !b.state.runs[run.operationId] || (b.state.runs[run.operationId].sessionId ?? b.config.sessionId) !== identity.sessionId)
-      throw new WorkspaceError("forbidden", "Run does not belong to this workbench");
+      throw new WorkspaceError("forbidden", "Run does not belong to this workbench", true);
     if (b.state.runs[run.operationId].state === "rejected_capacity")
-      throw new WorkspaceError("run_not_admitted", "This operation was definitively rejected; no executor run exists");
+      throw new WorkspaceError("run_not_admitted", "This operation was definitively rejected; no executor run exists", true);
     await this.owned();
     const route = await this.route(b, identity);
     if (run.fence.installationId !== this.config.installationId || run.fence.resourceType !== route.workerFence.resourceType || run.fence.resourceId !== route.workerFence.resourceId)
-      throw new WorkspaceError("wrong_resource", "Wrong worker resource");
+      throw new WorkspaceError("wrong_resource", "Wrong worker resource", true);
     return { b, route };
   }
   action(fn) {

package/dist/mjs/runtime/workspace/contracts.mjs

@@ -34,8 +34,6 @@ class WorkspaceError extends Error {
   code;
   rejectedBeforeAdmission;
 }
-class WorkspacePublicationNotAdmitted extends WorkspaceError {
-}
 const DEFAULT_WORKSPACE_IGNORE = `# Required destination workbench exclusions; keep these rules effective.
 .env
 .env.*
@@ -59,6 +57,5 @@ export {
   ApprovedWorkbench,
   DEFAULT_WORKSPACE_IGNORE,
   WorkspaceConfig,
-  WorkspaceError,
-  WorkspacePublicationNotAdmitted
+  WorkspaceError
 };

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

@@ -101,6 +101,8 @@ export declare function openPersonalWorkerRuntime(options: {
     grant: z.infer<typeof PersonalWorkerGrant>;
     storage: (sessionId: string) => StorageTransport;
     cliEntrypoint?: string;
+    /** Internal test/embedding override. Personal workers publish every minute. */
+    publicationIntervalMs?: number;
 }): Promise<{
     grant: {
         [x: string]: unknown;
@@ -132,5 +134,11 @@ export declare function openPersonalWorkerRuntime(options: {
     renew: (value: unknown) => Promise<void>;
     dispatch: (raw: unknown) => Promise<any>;
     authority: WorkspaceAuthority;
+    synchronize: () => Promise<{
+        workbenchId: string;
+        head?: string;
+        unchanged?: boolean;
+        error?: string;
+    }[]>;
     close(): Promise<void>;
 }>;

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

@@ -11,7 +11,7 @@ export interface WorkspaceAuthorityOptions {
     /** Trusted catalog authorization; never a client-supplied filesystem path. */
     resolveWorkbench?: (identity: WorkspaceIdentity) => Promise<ApprovedWorkbenchInput | null>;
 }
-/** Independent resource owner. Gate and workbench never live in replaceable adapters/gateways.
+/** Independent resource owner. Run receipts and workbench never live in replaceable adapters/gateways.
  * Private root is exclusively owned; a crash leaves lock+intent for explicit maintenance.
  */
 export declare class WorkspaceAuthority {
@@ -179,7 +179,11 @@ export declare class WorkspaceAuthority {
     private route;
     private storage;
     private refresh;
-    private idle;
+    /** Workspace synchronization is independent of process lifetime. The serial
+     * authority queue excludes other authority mutations, while shells and
+     * agents remain ordinary concurrent filesystem writers whose later changes
+     * are observed by a subsequent publication cycle. */
+    private assertAvailable;
     status(identity: WorkspaceIdentity): Promise<{
         files: string[] | null;
         initialized: boolean;
@@ -221,8 +225,8 @@ export declare class WorkspaceAuthority {
         };
     }>;
     private cleanRefreshBase;
-    /** No-argument hydration is initial-only. Explicit expectedBase permits a clean,
-     * idle workbench refresh; all replaced source/index/ref bytes are retained. */
+    /** No-argument hydration is initial-only. Explicit expectedBase permits a
+     * clean workbench refresh; process/PTY liveness never gates synchronization. */
     hydrate(identity: WorkspaceIdentity, expectedBase?: string): Promise<{
         head: string;
     } | {

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

@@ -54,20 +54,9 @@ export declare class WorkspaceError extends Error {
     readonly rejectedBeforeAdmission: boolean;
     constructor(code: string, message: string, rejectedBeforeAdmission?: boolean);
 }
-/** Constructed only by the authority before it admits publication work. */
-export declare class WorkspacePublicationNotAdmitted extends WorkspaceError {
-}
 export type WorkspacePublishResult = {
     head: string;
     unchanged?: boolean;
-    rejectedBeforeAdmission?: never;
-} | {
-    state: "rejected";
-    code: "capacity_busy";
-    rejectedBeforeAdmission: true;
-    message: string;
-    head?: never;
-    unchanged?: never;
 };
 export type WorkspaceState = {
     initialized: boolean;

package/package.json

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