@ricsam/r5d-worker 0.0.160 → 0.0.162

package/dist/cjs/package.json

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

package/dist/mjs/internal-r5dctl.cjs

@@ -20605,7 +20605,7 @@ function resolveEntrypointPath(entrypoint) {
   }
 }
 function getR5dctlVersion() {
-  if (true) return "0.0.160";
+  if (true) return "0.0.162";
   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.160" : "development"}`);
+  console.log(`r5d-worker ${true ? "0.0.162" : "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.160" : "development"
+    true ? "0.0.162" : "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.160",
+  "version": "0.0.162",
   "type": "module"
 }

package/dist/mjs/personal/publication-refusal.mjs

@@ -0,0 +1,38 @@
+const CONFLICT_PUBLICATION_CODES = /* @__PURE__ */ new Set([
+  "conflict",
+  "workbench_conflict",
+  "workbench_operation_in_progress"
+]);
+const BLOCKED_PUBLICATION_CODES = /* @__PURE__ */ new Set([
+  "secret_or_runtime_path",
+  "secret_content",
+  "unsafe_file",
+  "unsafe_git",
+  "unsafe_path",
+  "unsafe_tree",
+  "too_large"
+]);
+const PUBLICATION_OBSERVATION_THRESHOLDS = /* @__PURE__ */ new Map([["unsafe_file", 2]]);
+const OPERATION_IN_PROGRESS_CODE = "workbench_operation_in_progress";
+const ABANDONED_OPERATION_OBSERVATIONS = 2;
+const STUCK_OPERATION_OBSERVATIONS = 30;
+function publicationRefusalOutcome(code) {
+  if (CONFLICT_PUBLICATION_CODES.has(code)) return "conflict_blocked";
+  if (BLOCKED_PUBLICATION_CODES.has(code)) return "large_diff_blocked";
+  return "failed";
+}
+function publicationRefusalElects(code, observations, context = {}) {
+  if (code === OPERATION_IN_PROGRESS_CODE)
+    return context.workbenchHasLiveRun ? observations >= STUCK_OPERATION_OBSERVATIONS : observations >= ABANDONED_OPERATION_OBSERVATIONS;
+  return observations >= (PUBLICATION_OBSERVATION_THRESHOLDS.get(code) ?? 1);
+}
+export {
+  ABANDONED_OPERATION_OBSERVATIONS,
+  BLOCKED_PUBLICATION_CODES,
+  CONFLICT_PUBLICATION_CODES,
+  OPERATION_IN_PROGRESS_CODE,
+  PUBLICATION_OBSERVATION_THRESHOLDS,
+  STUCK_OPERATION_OBSERVATIONS,
+  publicationRefusalElects,
+  publicationRefusalOutcome
+};

package/dist/mjs/personal/runtime.mjs

@@ -1,4 +1,5 @@
 import path from "node:path";
+import { publicationRefusalElects, publicationRefusalOutcome } from "./publication-refusal.mjs";
 import { PersonalTcpManager } from "./tcp.mjs";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { promises as fs } from "node:fs";
@@ -253,16 +254,6 @@ exec ${quote(executable)} ${quote(cli)} "$@"
         }
       }
     }
-    const blockedPublicationCodes = /* @__PURE__ */ new Set([
-      "secret_or_runtime_path",
-      "secret_content",
-      "unsafe_file",
-      "unsafe_git",
-      "unsafe_path",
-      "unsafe_tree",
-      "too_large"
-    ]);
-    const conflictPublicationCodes = /* @__PURE__ */ new Set(["conflict", "workbench_conflict"]);
     const failedPublicationAttempts = /* @__PURE__ */ new Map();
     let publication = null, closing = false;
     const synchronize = () => {
@@ -287,13 +278,21 @@ exec ${quote(executable)} ${quote(cli)} "$@"
                 startingHead = status.head;
               } catch {
               }
-              const outcome = conflictPublicationCodes.has(code) ? "conflict_blocked" : blockedPublicationCodes.has(code) ? "large_diff_blocked" : "failed";
+              const outcome = publicationRefusalOutcome(code);
               const fingerprint = canonicalJson({ code, startingHead, outcome });
               let attempt = failedPublicationAttempts.get(workbenchId);
               if (!attempt || attempt.fingerprint !== fingerprint) {
-                attempt = { fingerprint, attemptId: randomUUID() };
+                attempt = { fingerprint, attemptId: randomUUID(), observations: 1 };
                 failedPublicationAttempts.set(workbenchId, attempt);
+              } else {
+                attempt.observations++;
               }
+              let workbenchHasLiveRun = false;
+              try {
+                workbenchHasLiveRun = await authority.workbenchHasLiveRun({ userId: grant.userId, sessionId });
+              } catch {
+              }
+              if (!publicationRefusalElects(code, attempt.observations, { workbenchHasLiveRun })) continue;
               try {
                 await options.publicationReport(WorkspacePublicationReport.parse({
                   protocol: 1,

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

@@ -26,7 +26,8 @@ import {
   selectedTree,
   sha256,
   snapshotTree,
-  sourceBytes
+  sourceBytes,
+  WORKBENCH_CONFLICT_CODES
 } from "./files.mjs";
 const GITHUB_CREDENTIAL_HELPER = '!f() { if [ "$1" = get ] && [ -n "$R5D_GIT_CREDENTIAL" ]; then git credential-store --file="$R5D_GIT_CREDENTIAL" get; else return 0; fi; }; f';
 class WorkspaceAuthority {
@@ -417,6 +418,13 @@ class WorkspaceAuthority {
   async assertAvailable(b, allowBlocked = false) {
     if (b.state.blocked && !allowBlocked) throw new WorkspaceError(b.state.blocked.code, b.state.blocked.message);
   }
+  /** Whether any run on this physical workbench is still live, across every
+   * session sharing it. An in-progress Git operation marker belongs to such a
+   * run, so publication defers to it instead of electing an incident over it. */
+  async workbenchHasLiveRun(identity) {
+    const b = await this.bench(identity);
+    return Object.values(b.state.runs).some((run) => !["completed", "cancelled", "rejected_capacity"].includes(run.state));
+  }
   async status(identity) {
     const b = await this.bench(identity);
     return this.serial(b, async () => {
@@ -870,7 +878,7 @@ class WorkspaceAuthority {
     let mode = 420;
     let retainedBlock = null;
     const check = async () => {
-      if (b.state.blocked && !(allowBlockedConflict && (b.state.blocked.code === "conflict" || b.state.blocked.code === "workbench_conflict")))
+      if (b.state.blocked && !(allowBlockedConflict && WORKBENCH_CONFLICT_CODES.has(b.state.blocked.code)))
         throw new WorkspaceError(b.state.blocked.code, b.state.blocked.message);
       retainedBlock = b.state.blocked;
       if (!b.state.initialized) throw new WorkspaceError("uninitialized", "Hydrate this workspace before writing files");
@@ -1154,7 +1162,7 @@ class WorkspaceAuthority {
     const b = await this.bench(identity);
     if (b.config.rootProfile === "account") return { head: "", unchanged: true };
     return this.serial(b, async () => {
-      const conflictBlocked = b.state.blocked?.code === "conflict" || b.state.blocked?.code === "workbench_conflict";
+      const conflictBlocked = !!b.state.blocked && WORKBENCH_CONFLICT_CODES.has(b.state.blocked.code);
       await this.assertAvailable(b, options.allowBlockedConflict === true && conflictBlocked);
       return this.publishIdle(b, identity, "Destination workspace snapshot", options.allowLargeDiff === true);
     });
@@ -1313,7 +1321,7 @@ class WorkspaceAuthority {
     const b = await this.bench(identity);
     const operation = OperationEnvelope.parse(JSON.parse(canonicalJson(input)));
     return this.serial(b, async () => {
-      const conflictBlocked = b.state.blocked?.code === "conflict" || b.state.blocked?.code === "workbench_conflict";
+      const conflictBlocked = !!b.state.blocked && WORKBENCH_CONFLICT_CODES.has(b.state.blocked.code);
       if (!b.state.initialized || b.state.blocked && !(allowBlockedConflict && conflictBlocked))
         throw new WorkspaceError("workbench_blocked", b.state.blocked?.message ?? "Initialize workbench first");
       if (operation.installationId !== this.config.installationId || operation.userId !== identity.userId || operation.sessionId !== identity.sessionId || operation.kind !== "host.shell")

package/dist/mjs/runtime/workspace/files.mjs

@@ -6,6 +6,20 @@ import { createHash } from "node:crypto";
 import { safeTreePath, STORAGE_LIMITS } from "./storage-wire.mjs";
 import { WorkspaceError } from "./contracts.mjs";
 const sha256 = (bytes) => createHash("sha256").update(bytes).digest("hex");
+const WORKBENCH_OPERATION_MARKERS = [
+  "MERGE_HEAD",
+  "CHERRY_PICK_HEAD",
+  "REVERT_HEAD",
+  "REBASE_HEAD",
+  "rebase-merge",
+  "rebase-apply",
+  "index.lock"
+];
+const WORKBENCH_CONFLICT_CODES = /* @__PURE__ */ new Set([
+  "conflict",
+  "workbench_conflict",
+  "workbench_operation_in_progress"
+]);
 async function privateRoot(root, installationId) {
   if (!path.isAbsolute(root) || path.normalize(root) !== root || path.basename(root) !== installationId || root.split(path.sep).some((p) => [".r5d", "r5d-dev", "legacy", "app-data"].includes(p.toLowerCase())))
     throw new WorkspaceError("unsafe_root", "Use an independently allocated private new-installation root, never a legacy worktree");
@@ -287,7 +301,7 @@ async function snapshotTree(repo, cwd, canonicalHead, maxBytes = 128 * 1024 * 10
       if (!gitDirectory.startsWith(worktrees)) throw new WorkspaceError("unsafe_git", "Linked worktree belongs to another repository");
       await noSymlinkAncestors(gitDirectory);
     } else if (!metadataStat.isDirectory()) throw new WorkspaceError("unsafe_git", "Invalid worktree metadata");
-    for (const name of ["MERGE_HEAD", "CHERRY_PICK_HEAD", "REVERT_HEAD", "REBASE_HEAD", "rebase-merge", "rebase-apply", "index.lock"]) {
+    for (const name of WORKBENCH_OPERATION_MARKERS) {
       if (await fs.lstat(path.join(gitDirectory, name)).then(
         () => true,
         (e) => {
@@ -296,7 +310,7 @@ async function snapshotTree(repo, cwd, canonicalHead, maxBytes = 128 * 1024 * 10
         }
       ))
         throw new WorkspaceError(
-          "workbench_conflict",
+          "workbench_operation_in_progress",
           "Git merge/rebase/index operation remains in progress; preserve and resolve it before publication"
         );
     }
@@ -406,6 +420,8 @@ async function snapshotTree(repo, cwd, canonicalHead, maxBytes = 128 * 1024 * 10
   return (await git(repo, ["write-tree"])).toString().trim();
 }
 export {
+  WORKBENCH_CONFLICT_CODES,
+  WORKBENCH_OPERATION_MARKERS,
   durableJson,
   ensureAuthorityGitRepositoryLayout,
   git,

package/dist/types/personal/publication-refusal.d.ts

@@ -0,0 +1,31 @@
+/** Publication refusals, and how long one must persist before it becomes a
+ * durable remediation incident.
+ *
+ * Refusing to publish is cheap and immediate. Electing an incident is not: it
+ * interrupts whoever owns the checkout with an automatic remediation session.
+ * So a condition an ordinary command produces in passing has to outlive that
+ * command before it counts as evidence of a stuck checkout. */
+/** Leaves the checkout holding unpublished conflict state. */
+export declare const CONFLICT_PUBLICATION_CODES: ReadonlySet<string>;
+/** Refused because the source candidate itself is unsafe or oversized. */
+export declare const BLOCKED_PUBLICATION_CODES: ReadonlySet<string>;
+/** Consecutive identical observations required before electing an incident.
+ * `unsafe_file`: a package manager or Git command can atomically replace a file
+ * between directory enumeration and the bounded single-link read. */
+export declare const PUBLICATION_OBSERVATION_THRESHOLDS: ReadonlyMap<string, number>;
+/** A merge, rebase, revert, cherry-pick or index lock belongs to whatever is
+ * running in that checkout. Its duration is the agent's, not ours: resolving a
+ * conflicted cherry-pick legitimately takes minutes, so no fixed number of
+ * samples is a safe bound. Publication defers while a run is live and elects
+ * only once the marker has outlived it. */
+export declare const OPERATION_IN_PROGRESS_CODE = "workbench_operation_in_progress";
+/** Observations required once no run is live — the marker has been abandoned. */
+export declare const ABANDONED_OPERATION_OBSERVATIONS = 2;
+/** Backstop for a run that never reaches a terminal state while holding a
+ * marker. At the one-minute publication interval this is roughly half an hour. */
+export declare const STUCK_OPERATION_OBSERVATIONS = 30;
+export declare function publicationRefusalOutcome(code: string): "conflict_blocked" | "large_diff_blocked" | "failed";
+/** True once this refusal has proven durable enough to elect an incident. */
+export declare function publicationRefusalElects(code: string, observations: number, context?: {
+    workbenchHasLiveRun?: boolean;
+}): boolean;

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

@@ -186,6 +186,10 @@ export declare class WorkspaceAuthority {
      * agents remain ordinary concurrent filesystem writers whose later changes
      * are observed by a subsequent publication cycle. */
     private assertAvailable;
+    /** Whether any run on this physical workbench is still live, across every
+     * session sharing it. An in-progress Git operation marker belongs to such a
+     * run, so publication defers to it instead of electing an incident over it. */
+    workbenchHasLiveRun(identity: WorkspaceIdentity): Promise<boolean>;
     status(identity: WorkspaceIdentity): Promise<{
         files: string[] | null;
         initialized: boolean;

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

@@ -1,4 +1,10 @@
 export declare const sha256: (bytes: Buffer | string) => string;
+/** A Git command is mid-flight. Owned by whoever is running it, and gone as soon
+ * as it finishes, so it is never on its own evidence of a stuck checkout. */
+export declare const WORKBENCH_OPERATION_MARKERS: readonly ["MERGE_HEAD", "CHERRY_PICK_HEAD", "REVERT_HEAD", "REBASE_HEAD", "rebase-merge", "rebase-apply", "index.lock"];
+/** Publication refusals that leave the checkout holding unpublished conflict
+ * state. Remediation is admitted against exactly these. */
+export declare const WORKBENCH_CONFLICT_CODES: ReadonlySet<string>;
 export declare function privateRoot(root: string, installationId: string): Promise<void>;
 export declare function noSymlinkAncestors(file: string): Promise<void>;
 export declare function readRegular(file: string, limit?: number): Promise<Buffer>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.160",
+  "version": "0.0.162",
   "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.160",
+    "@ricsam/r5d-api": "^0.0.162",
     "node-pty": "1.1.0",
     "zod": "^4.1.13",
     "picomatch": "^4.0.3"