archctx 0.7.1 → 0.7.2

package/assets/catalog.yaml

@@ -1,7 +1,7 @@
 {
   "schemaVersion": "archcontext.practice-catalog-manifest/v1",
   "catalogVersion": "2026.06.0",
-  "productVersion": "0.7.1",
+  "productVersion": "0.7.2",
   "generatedAt": "1970-01-01T00:00:00.000Z",
   "entries": [
     {
@@ -389,5 +389,5 @@
     "structurizr.dsl",
     "twelve-factor"
   ],
-  "catalogDigest": "sha256:09f15d17439ef2ef12ec5eede5244505e7cdb124628657c7df640e8a049e7cb7"
+  "catalogDigest": "sha256:b5dd0791d81dae183a03d5ea53e18645d6d7eb8a89ea2540fabd3547a5454536"
 }

package/bin/archctx.mjs

@@ -1869,7 +1869,7 @@ function productVersionManifest() {
     }
   };
 }
-var ARCHCONTEXT_PRODUCT_NAME = "archctx", ARCHCONTEXT_PRODUCT_VERSION = "0.7.1", ARCHCONTEXT_PACKAGE_MANAGER = "bun@1.4.3", ARCHCONTEXT_NODE_RANGE = ">=22.22 <26", LOCAL_RUNTIME_RPC_SCHEMA_VERSION = "archcontext.runtime-rpc/v1", ARCHCONTEXT_SCHEMA_SET_VERSION = "2026-07-11.explorer-view-v2";
+var ARCHCONTEXT_PRODUCT_NAME = "archctx", ARCHCONTEXT_PRODUCT_VERSION = "0.7.2", ARCHCONTEXT_PACKAGE_MANAGER = "bun@1.4.3", ARCHCONTEXT_NODE_RANGE = ">=22.22 <26", LOCAL_RUNTIME_RPC_SCHEMA_VERSION = "archcontext.runtime-rpc/v1", ARCHCONTEXT_SCHEMA_SET_VERSION = "2026-07-11.explorer-view-v2";
 
 // packages/contracts/src/refactor.ts
 function refactorProposalDigest(proposal) {
@@ -32792,6 +32792,17 @@ function acquireDaemonLock(lockPath, root) {
     throw new Error(`archctxd already running for ${root}; lock=${lockPath}`);
   }
 }
+function liveDaemonLockOwnerPid(root = process.cwd()) {
+  try {
+    const body = readPrivateControlFile(defaultDaemonLockPath(root));
+    if (body === undefined)
+      return;
+    const pid = JSON.parse(body).pid;
+    return typeof pid === "number" && pid > 0 && isProcessAlive(pid) ? pid : undefined;
+  } catch {
+    return;
+  }
+}
 function isValidRuntimeRpcConnection(value) {
   return value.schemaVersion === RUNTIME_RPC_VERSION && value.protocol === "http-loopback" && value.version === 1 && typeof value.url === "string" && value.url.startsWith("http://127.0.0.1:") && typeof value.token === "string" && value.token.length > 0 && typeof value.pid === "number" && typeof value.connectionPath === "string" && typeof value.lockPath === "string";
 }
@@ -42695,6 +42706,9 @@ function runNodeInvestigationTransport(input, options) {
     child.once("exit", (code) => {
       settleResolve(unwrapClaudeCodeEnvelope(code ?? 1, stdout, stderr));
     });
+    child.stdin?.on("error", () => {
+      return;
+    });
     child.stdin?.end(input.stdin);
   });
 }
@@ -51830,7 +51844,6 @@ function completeTaskProjectionFreshness(root) {
     currentSourceTreeDigest: architectureDocumentationSourceTreeDigest(root, model, sourceFiles)
   });
 }
-
 // packages/surfaces/adapter-likec4/src/index.ts
 init_src();
 function exportLikeC4Model(model) {
@@ -55202,14 +55215,14 @@ async function createOrStartRuntimeRpcClient(cwd) {
     throw new RuntimeVersionUnsupportedError(fileIssue);
   const client = createRuntimeRpcClientFromConnectionFile(cwd);
   if (client) {
-    const health = await client.health().catch(() => {
-      return;
-    });
+    const { health, unresponsivePid } = await probeDaemonHealth(client);
     const healthIssue = runtimeRpcCompatibilityIssueFromHealth(cwd, client, health);
     if (healthIssue)
       throw new RuntimeVersionUnsupportedError(healthIssue);
     if (health?.ok === true)
       return client;
+    if (unresponsivePid !== undefined)
+      throw new Error(unresponsiveDaemonMessage(unresponsivePid));
     recoverStaleDaemonControlFiles(cwd, { removeUnhealthyConnection: true });
   } else {
     recoverStaleDaemonControlFiles(cwd);
@@ -55291,16 +55304,16 @@ async function runDaemonCommand(args, cwd) {
         return okEnvelope("daemon.status", incompatibleDaemonStatus(compatibilityIssue));
       }
       const recovery = recoverStaleDaemonControlFiles(cwd);
+      const lockOwnerPid = liveDaemonLockOwnerPid(cwd);
       return okEnvelope("daemon.status", {
         running: false,
         protocol: "http-loopback",
         connectionPath: defaultDaemonConnectionPath(cwd),
+        ...lockOwnerPid === undefined ? {} : { lockOwnerPid, action: orphanedDaemonMessage(lockOwnerPid) },
         ...recoveryData(recovery)
       });
     }
-    const health = await client.health().catch(() => {
-      return;
-    });
+    const { health, unresponsivePid } = await probeDaemonHealth(client);
     const healthIssue = runtimeRpcCompatibilityIssueFromHealth(cwd, client, health);
     if (healthIssue) {
       return okEnvelope("daemon.status", incompatibleDaemonStatus(healthIssue));
@@ -55319,6 +55332,16 @@ async function runDaemonCommand(args, cwd) {
         token: "stored-in-connection-file"
       });
     }
+    if (unresponsivePid !== undefined) {
+      return okEnvelope("daemon.status", {
+        running: true,
+        responding: false,
+        pid: unresponsivePid,
+        protocol: "http-loopback",
+        connectionPath: client.connectionInfo().connectionPath,
+        action: unresponsiveDaemonMessage(unresponsivePid)
+      });
+    }
     const recovery = recoverStaleDaemonControlFiles(cwd, { removeUnhealthyConnection: true });
     return okEnvelope("daemon.status", {
       running: false,
@@ -55358,6 +55381,9 @@ async function startBackgroundDaemon(args, cwd) {
   if (discovered.compatibilityIssue?.pidAlive) {
     return errorEnvelope("daemon.start", "AC_RUNTIME_VERSION_UNSUPPORTED", runtimeVersionUnsupportedMessage(discovered.compatibilityIssue));
   }
+  if (discovered.unresponsivePid !== undefined) {
+    return errorEnvelope("daemon.start", "AC_RUNTIME_UNAVAILABLE", unresponsiveDaemonMessage(discovered.unresponsivePid));
+  }
   if (discovered.info) {
     return okEnvelope("daemon.start", {
       running: true,
@@ -55399,7 +55425,7 @@ async function startBackgroundDaemon(args, cwd) {
     child.unref();
     const ready = await waitForDaemonReady(cwd, daemonStartTimeoutMs(args), () => childError !== undefined || childExit !== undefined && childExit.code !== DAEMON_OWNED_ELSEWHERE_EXIT_CODE);
     if (!ready) {
-      return errorEnvelope("daemon.start", "AC_RUNTIME_UNAVAILABLE", daemonStartFailureMessage(logPath, childExit, childError));
+      return errorEnvelope("daemon.start", "AC_RUNTIME_UNAVAILABLE", daemonStartFailureMessage(cwd, logPath, child.pid, childExit, childError));
     }
     return okEnvelope("daemon.start", {
       running: true,
@@ -55469,9 +55495,7 @@ async function discoverRunningDaemonInfo(cwd, options = {}) {
       recovery: options.recoverStale ? recoverStaleDaemonControlFiles(cwd) : emptyRecovery(cwd)
     };
   }
-  const health = await client.health().catch(() => {
-    return;
-  });
+  const { health, unresponsivePid } = await probeDaemonHealth(client);
   const compatibilityIssue = runtimeRpcCompatibilityIssueFromHealth(cwd, client, health) ?? cliEntryStalenessIssue(cwd);
   if (compatibilityIssue) {
     return {
@@ -55483,6 +55507,9 @@ async function discoverRunningDaemonInfo(cwd, options = {}) {
   if (health?.ok === true) {
     return { info: client.connectionInfo(), compatibilityIssue: undefined, recovery: emptyRecovery(cwd) };
   }
+  if (unresponsivePid !== undefined) {
+    return { info: undefined, compatibilityIssue: undefined, unresponsivePid, recovery: emptyRecovery(cwd) };
+  }
   return {
     info: undefined,
     compatibilityIssue: undefined,
@@ -55548,6 +55575,24 @@ function runtimeVersionUnsupportedMessage(issue) {
   }
   return `archctxd RPC version ${issue.received} is incompatible with this CLI (${issue.expected}); run ${issue.upgradeCommand} to replace the local daemon.`;
 }
+async function probeDaemonHealth(client) {
+  try {
+    return { health: await client.health() };
+  } catch (error) {
+    const pid = client.connectionInfo().pid;
+    const busy = error instanceof RuntimeRpcTransportError && error.code === "RPC_TIMEOUT" && typeof pid === "number" && isPidAlive(pid);
+    return { health: undefined, ...busy ? { unresponsivePid: pid } : {} };
+  }
+}
+function stopProcessCommand(pid) {
+  return process.platform === "win32" ? `taskkill /PID ${pid}` : `kill -TERM ${pid}`;
+}
+function unresponsiveDaemonMessage(pid) {
+  return `archctxd pid ${pid} is alive but did not answer its health check in time; it is likely busy, so its connection file was kept. Retry later, or stop it with \`${stopProcessCommand(pid)}\` and run the command again.`;
+}
+function orphanedDaemonMessage(pid) {
+  return `the daemon lock names live pid ${pid}, but no connection file points to it; stop it with \`${stopProcessCommand(pid)}\`, then run the command again.`;
+}
 async function waitForPidExit(pid, timeoutMs) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
@@ -55582,9 +55627,11 @@ function daemonStartTimeoutMs(args) {
   const parsed = Number(configured);
   return Number.isFinite(parsed) && parsed > 0 ? parsed : DAEMON_START_TIMEOUT_MS;
 }
-function daemonStartFailureMessage(logPath, childExit, childError) {
+function daemonStartFailureMessage(cwd, logPath, childPid, childExit, childError) {
   const childState = childError ? `childError=${childError.message}` : childExit ? `childExit=${childExit.code ?? "null"}/${childExit.signal ?? "none"}` : "childState=still-running";
-  return `archctxd did not become ready; ${childState}; log=${logPath}; logTail=${readFileTail(logPath)}`;
+  const lockOwnerPid = existsSync28(defaultDaemonConnectionPath(cwd)) ? undefined : liveDaemonLockOwnerPid(cwd);
+  const owner = lockOwnerPid === undefined || lockOwnerPid === childPid ? "" : `; ${orphanedDaemonMessage(lockOwnerPid)}`;
+  return `archctxd did not become ready; ${childState}${owner}; log=${logPath}; logTail=${readFileTail(logPath)}`;
 }
 async function waitForDaemonReady(cwd, timeoutMs, shouldStop) {
   const deadline = Date.now() + timeoutMs;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "archctx",
-  "version": "0.7.1",
+  "version": "0.7.2",
   "description": "Local architecture context CLI for agentic coding workflows.",
   "private": false,
   "type": "module",