@amaster.ai/employee-runtime-connector 0.1.1-beta.44 → 0.1.1-beta.45

package/dist/amaster-runtime-daemon.mjs

@@ -3,7 +3,7 @@
 
 // src/amaster-runtime-daemon.mjs
 import { createHash as createHash12 } from "node:crypto";
-import { chmodSync as chmodSync4, copyFileSync as copyFileSync2, existsSync as existsSync11, lstatSync as lstatSync5, mkdirSync as mkdirSync7, mkdtempSync, readFileSync as readFileSync9, readdirSync as readdirSync8, realpathSync as realpathSync5, renameSync as renameSync6, rmSync as rmSync5, statSync as statSync8, symlinkSync as symlinkSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync7 } from "node:fs";
+import { chmodSync as chmodSync4, copyFileSync as copyFileSync2, existsSync as existsSync11, lstatSync as lstatSync5, mkdirSync as mkdirSync7, mkdtempSync, readFileSync as readFileSync10, readdirSync as readdirSync9, realpathSync as realpathSync5, renameSync as renameSync6, rmSync as rmSync5, statSync as statSync8, symlinkSync as symlinkSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync7 } from "node:fs";
 import { arch as arch3, homedir as homedir3, hostname as hostname2, platform as platform3, tmpdir } from "node:os";
 import { basename as basename6, delimiter as delimiter3, dirname as dirname7, extname as extname2, isAbsolute as isAbsolute6, join as join12, relative as relative6, resolve as resolve9 } from "node:path";
 import { spawn, spawnSync as spawnSync5 } from "node:child_process";
@@ -4162,13 +4162,52 @@ function selectExecutor(config, command) {
 }
 
 // src/amaster-runtime-daemon/executor-process.mjs
+import { readdirSync as readdirSync4, readFileSync as readFileSync4 } from "node:fs";
+var TERMINAL_LINUX_PROCESS_STATES = /* @__PURE__ */ new Set(["Z", "X", "x"]);
 function processGroupIdForChild(child, processPlatform = process.platform) {
   return processPlatform === "win32" || typeof child.pid !== "number" || child.pid <= 0 ? null : child.pid;
 }
-function isExecutorProcessAlive(child, processGroupId = processGroupIdForChild(child), processApi = process) {
+function linuxProcState(stat) {
+  const commandEnd = stat.lastIndexOf(")");
+  if (commandEnd === -1) return null;
+  const fields = stat.slice(commandEnd + 1).trim().split(/\s+/);
+  if (fields.length < 3) return null;
+  const processGroupId = Number.parseInt(fields[2], 10);
+  return Number.isInteger(processGroupId) ? { state: fields[0], processGroupId } : null;
+}
+function linuxProcessGroupHasLiveMembers(processGroupId, procRoot = "/proc", fsApi = { readdirSync: readdirSync4, readFileSync: readFileSync4 }) {
+  let entries;
+  try {
+    entries = fsApi.readdirSync(procRoot, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+  let foundMember = false;
+  let unreadableMember = false;
+  for (const entry of entries) {
+    if (!entry.isDirectory() || !/^\d+$/.test(entry.name)) continue;
+    let parsed;
+    try {
+      parsed = linuxProcState(fsApi.readFileSync(`${procRoot}/${entry.name}/stat`, "utf8"));
+    } catch {
+      unreadableMember = true;
+      continue;
+    }
+    if (parsed?.processGroupId !== processGroupId) continue;
+    foundMember = true;
+    if (!TERMINAL_LINUX_PROCESS_STATES.has(parsed.state)) return true;
+  }
+  if (foundMember) return false;
+  return unreadableMember ? null : false;
+}
+function isExecutorProcessAlive(child, processGroupId = processGroupIdForChild(child), processApi = process, inspectLinuxProcessGroup = linuxProcessGroupHasLiveMembers) {
   if (processGroupId !== null) {
     try {
       processApi.kill(-processGroupId, 0);
+      if (processApi.platform === "linux") {
+        const hasLiveMembers = inspectLinuxProcessGroup(processGroupId);
+        if (hasLiveMembers !== null) return hasLiveMembers;
+      }
       return true;
     } catch (error) {
       if (error?.code === "ESRCH") return false;
@@ -4181,6 +4220,13 @@ function isProcessIdAlive(pid, processApi = process) {
   if (!Number.isInteger(pid) || pid <= 0) return false;
   try {
     processApi.kill(pid, 0);
+    if (processApi.platform === "linux") {
+      try {
+        const parsed = linuxProcState(readFileSync4(`/proc/${pid}/stat`, "utf8"));
+        if (parsed && TERMINAL_LINUX_PROCESS_STATES.has(parsed.state)) return false;
+      } catch {
+      }
+    }
     return true;
   } catch (error) {
     return error?.code !== "ESRCH";
@@ -4226,7 +4272,7 @@ function isTerminalResultOutboxStatus(status) {
 }
 
 // src/amaster-runtime-daemon/run-completion-state.mjs
-import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync4, readdirSync as readdirSync4, renameSync as renameSync3, unlinkSync, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync5, readdirSync as readdirSync5, renameSync as renameSync3, unlinkSync, writeFileSync as writeFileSync4 } from "node:fs";
 import { join as join5 } from "node:path";
 var RUN_COMPLETION_STATE_VERSION = 1;
 var RUN_COMPLETION_USAGE_SCHEMA_VERSION = "runtime-command-usage-v1";
@@ -4465,11 +4511,11 @@ function writeRunCompletionState(directory, state) {
   return filePath;
 }
 function readRunCompletionState(filePath) {
-  return assertValidRunCompletionState(JSON.parse(readFileSync4(filePath, "utf8")));
+  return assertValidRunCompletionState(JSON.parse(readFileSync5(filePath, "utf8")));
 }
 function listRunCompletionStateFiles(directory) {
   if (!existsSync4(directory)) return [];
-  return readdirSync4(directory).filter((name) => name.endsWith(".json")).sort().map((name) => join5(directory, name));
+  return readdirSync5(directory).filter((name) => name.endsWith(".json")).sort().map((name) => join5(directory, name));
 }
 function removeRunCompletionState(directory, commandId) {
   const filePath = join5(directory, runCompletionStateFileName(commandId));
@@ -5524,6 +5570,27 @@ function interactionResolutionText(context) {
     jsonText(resolution)
   ].filter(Boolean).join("\n");
 }
+function currentIssueMetadataReadText(input) {
+  const issueId = readString(input.issueId) ?? readString(asRecord(asRecord(input.context).paperclipIssue).id);
+  if (!issueId) {
+    return "Required current-issue read is unavailable because the current Issue id is missing. Stop without recording a disposition.";
+  }
+  if (!input.hasGovernedMcp) {
+    return "Required current-issue read is unavailable because managed governed MCP is missing. Stop without recording a disposition.";
+  }
+  const args = { issueId };
+  const directToolName = managedDirectToolName(input, "amaster.read_issue");
+  if (directToolName) {
+    return `Required current-issue read: call \`${directToolName}\` with these exact object arguments: ${JSON.stringify(args)}`;
+  }
+  if (input.executorKind === "pi" && managedPiMcpProxyAvailable(input)) {
+    return `Required current-issue read: emit an actual \`mcp\` tool call with these exact proxy arguments: ${JSON.stringify(managedPiMcpProxyCall("amaster.read_issue", args))}`;
+  }
+  if (input.managedMcpToolMode === "direct_typed") {
+    return "Required current-issue read is unavailable because amaster.read_issue is absent from the attested direct tool catalog. Stop without recording a disposition.";
+  }
+  return `Required current-issue read: call amaster.read_issue with these exact arguments: ${JSON.stringify(args)}`;
+}
 function recoveryInstructionText(input) {
   const context = asRecord(input.context);
   if (input.wakeReason === "finish_successful_run_handoff" && context.handoffRequired === true) {
@@ -5580,7 +5647,9 @@ function recoveryInstructionText(input) {
     ].join("\n");
     return [
       "This is a status-only source recovery. Do not repeat the original source work or create or revise deliverables.",
-      "Inspect the existing task and run evidence, then choose exactly one explicit disposition using task-governance actions:",
+      `Before choosing or recording any disposition, execute this required current-issue read and inspect result.content.documents for every persisted document identity: ${currentIssueMetadataReadText(input)}`,
+      "Do not claim that a durable document is absent from workspace or Delivery-readiness evidence. The required read is authoritative for current Issue document metadata; use amaster.read_issue_document only when a returned key needs body inspection.",
+      "After the required read succeeds, inspect the existing task and run evidence, then choose exactly one explicit disposition using task-governance actions:",
       "- done only when the existing evidence already satisfies acceptance;",
       "- in_review or input when a specific human review or answer is required;",
       blockedDisposition,
@@ -6732,7 +6801,7 @@ function resolveAgentInstructionSystemKernelBundle(bundle, options = {}) {
 }
 
 // src/amaster-runtime-daemon/config-state.mjs
-import { existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync5, renameSync as renameSync4, rmSync as rmSync3, writeFileSync as writeFileSync5 } from "node:fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync6, renameSync as renameSync4, rmSync as rmSync3, writeFileSync as writeFileSync5 } from "node:fs";
 import { homedir as homedir2, hostname } from "node:os";
 import { dirname as dirname4, join as join6 } from "node:path";
 
@@ -6885,7 +6954,7 @@ function readState(env) {
   const path = stateFilePath(env);
   if (!existsSync5(path)) return {};
   try {
-    const state = JSON.parse(readFileSync5(path, "utf8"));
+    const state = JSON.parse(readFileSync6(path, "utf8"));
     if (!state || typeof state !== "object" || Array.isArray(state)) {
       throw new TypeError("runtime connector state must be a JSON object");
     }
@@ -8667,7 +8736,7 @@ var bestEffortPostJson = bestEffortPostRuntimeConnectorJson;
 
 // src/amaster-runtime-daemon/runtime-artifact-upload.mjs
 import { createHash as createHash8 } from "node:crypto";
-import { closeSync, constants, fstatSync, lstatSync as lstatSync4, openSync, readFileSync as readFileSync6, realpathSync as realpathSync3 } from "node:fs";
+import { closeSync, constants, fstatSync, lstatSync as lstatSync4, openSync, readFileSync as readFileSync7, realpathSync as realpathSync3 } from "node:fs";
 import { isAbsolute as isAbsolute3, relative as relative3, resolve as resolve4 } from "node:path";
 var SHA256_PATTERN = /^[a-f0-9]{64}$/;
 function requiredString(value, name) {
@@ -8719,7 +8788,7 @@ function readOwnedWorkspaceFile(rootPath, sourceRelativePath, label = "Runtime w
         );
       }
     }
-    const body = readFileSync6(descriptor);
+    const body = readFileSync7(descriptor);
     options.afterRead?.({ sourcePath, descriptor });
     const after = fstatSync(descriptor);
     const pathAfter = lstatSync4(sourcePath);
@@ -8867,23 +8936,48 @@ function prepareRuntimeDocumentUploads(cwd, mcpToolResults) {
 // src/amaster-runtime-daemon/runtime-document-ingest-queue.mjs
 function createRuntimeDocumentIngestQueue({ ingest }) {
   const handledCallIds = /* @__PURE__ */ new Set();
+  const documentIdentityByCallId = /* @__PURE__ */ new Map();
+  const finalizedDocumentIdentities = /* @__PURE__ */ new Set();
   const receipts = [];
   const errors = [];
   let queue = Promise.resolve();
+  const documentIdentity = (intent) => {
+    const sourceRelativePath = readString(asRecord(intent).sourceRelativePath);
+    const sha2562 = readString(asRecord(intent).sha256);
+    const byteSize = asRecord(intent).byteSize;
+    return sourceRelativePath && sha2562 && Number.isSafeInteger(byteSize) && byteSize > 0 ? `document:${sourceRelativePath}\0${sha2562}\0${byteSize}` : null;
+  };
+  const retainReceipts = (nextReceipts) => {
+    receipts.push(...nextReceipts);
+    for (const receipt of nextReceipts) {
+      const callId = readString(asRecord(receipt).callId);
+      const identity2 = callId ? documentIdentityByCallId.get(callId) : null;
+      if (identity2) finalizedDocumentIdentities.add(identity2);
+    }
+  };
   return {
     enqueue(results) {
       const pending = results.filter((result3) => {
-        const callId = result3 && typeof result3 === "object" && !Array.isArray(result3) ? result3.workspaceDocumentIntent?.callId : null;
-        if (typeof callId !== "string" || handledCallIds.has(callId)) return false;
+        const intent = asRecord(result3).workspaceDocumentIntent;
+        const callId = readString(asRecord(intent).callId);
+        if (!callId || handledCallIds.has(callId)) return false;
         handledCallIds.add(callId);
+        documentIdentityByCallId.set(callId, documentIdentity(intent) ?? `call:${callId}`);
         return true;
       });
       if (pending.length === 0) return;
+      const pendingIdentities = new Set(pending.map((result3) => {
+        const callId = readString(asRecord(asRecord(result3).workspaceDocumentIntent).callId);
+        return callId ? documentIdentityByCallId.get(callId) : null;
+      }).filter(Boolean));
       queue = queue.then(async () => {
         try {
-          receipts.push(...await ingest(pending));
+          retainReceipts(await ingest(pending));
         } catch (error) {
-          errors.push(error instanceof Error ? error : new Error(String(error)));
+          errors.push({
+            error: error instanceof Error ? error : new Error(String(error)),
+            identities: pendingIdentities
+          });
         }
       });
     },
@@ -8892,8 +8986,12 @@ function createRuntimeDocumentIngestQueue({ ingest }) {
     },
     async flush() {
       await queue;
-      if (errors.length > 0) {
-        throw new AggregateError(errors, `${errors.length} Runtime Document ingest operation(s) failed`);
+      const unresolvedErrors = errors.filter(({ identities }) => identities.size === 0 || [...identities].some((identity2) => !finalizedDocumentIdentities.has(identity2))).map(({ error }) => error);
+      if (unresolvedErrors.length > 0) {
+        throw new AggregateError(
+          unresolvedErrors,
+          `${unresolvedErrors.length} Runtime Document ingest operation(s) failed`
+        );
       }
       return [...receipts];
     }
@@ -8979,7 +9077,7 @@ import { existsSync as existsSync7, mkdirSync as mkdirSync6, realpathSync as rea
 import { basename as basename4, join as join8, isAbsolute as isAbsolute4, relative as relative4, resolve as resolve5 } from "node:path";
 
 // src/amaster-runtime-daemon/workspace-manifest.mjs
-import { chownSync as chownSync2, existsSync as existsSync6, readFileSync as readFileSync7, renameSync as renameSync5, rmSync as rmSync4, statSync as statSync3, writeFileSync as writeFileSync6 } from "node:fs";
+import { chownSync as chownSync2, existsSync as existsSync6, readFileSync as readFileSync8, renameSync as renameSync5, rmSync as rmSync4, statSync as statSync3, writeFileSync as writeFileSync6 } from "node:fs";
 import { basename as basename3, dirname as dirname5, join as join7 } from "node:path";
 var WORKSPACE_MANIFEST_FILENAME = ".amaster-runtime.json";
 function syncManifestDirOwnership(manifestPath, deps = {}) {
@@ -9008,7 +9106,7 @@ function workspaceManifestPath(workspaceOrCwd) {
 function readWorkspaceManifest(manifestPath) {
   if (!manifestPath || !existsSync6(manifestPath)) return null;
   try {
-    const parsed = JSON.parse(readFileSync7(manifestPath, "utf8"));
+    const parsed = JSON.parse(readFileSync8(manifestPath, "utf8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
   } catch {
     return null;
@@ -9164,7 +9262,7 @@ function resolveExecutionWorkspace(config, command, opts = {}) {
 }
 
 // src/amaster-runtime-daemon/workspace-gc.mjs
-import { existsSync as existsSync8, readdirSync as readdirSync5, statSync as statSync5 } from "node:fs";
+import { existsSync as existsSync8, readdirSync as readdirSync6, statSync as statSync5 } from "node:fs";
 import { join as join9, resolve as resolve6 } from "node:path";
 function readIsoTime(value) {
   if (typeof value !== "string" || !value.trim()) return null;
@@ -9182,7 +9280,7 @@ function walkWorkdirs(root) {
     if (!current) continue;
     let entries = [];
     try {
-      entries = readdirSync5(current, { withFileTypes: true });
+      entries = readdirSync6(current, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -9215,7 +9313,7 @@ function directorySizeBytes(path) {
     if (stat.isDirectory()) {
       let entries = [];
       try {
-        entries = readdirSync5(current, { withFileTypes: true });
+        entries = readdirSync6(current, { withFileTypes: true });
       } catch {
         continue;
       }
@@ -9292,11 +9390,11 @@ function planManagedWorkspaceGcDryRun(input) {
 }
 
 // src/amaster-runtime-daemon/runtime-status-summary.mjs
-import { existsSync as existsSync9, readdirSync as readdirSync6, statSync as statSync6 } from "node:fs";
+import { existsSync as existsSync9, readdirSync as readdirSync7, statSync as statSync6 } from "node:fs";
 import { dirname as dirname6, join as join10, resolve as resolve7 } from "node:path";
 function runtimeStatusDirectoryEntries(path) {
   try {
-    return readdirSync6(path, { withFileTypes: true });
+    return readdirSync7(path, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -9546,7 +9644,7 @@ function summarizeAmasterRuntimeVersionDrift(input = {}) {
 // src/amaster-runtime-daemon/workspace-status.mjs
 import { spawnSync as spawnSync4 } from "node:child_process";
 import { createHash as createHash11 } from "node:crypto";
-import { existsSync as existsSync10, readdirSync as readdirSync7, readFileSync as readFileSync8, statSync as statSync7 } from "node:fs";
+import { existsSync as existsSync10, readdirSync as readdirSync8, readFileSync as readFileSync9, statSync as statSync7 } from "node:fs";
 import { basename as basename5, extname, isAbsolute as isAbsolute5, join as join11, relative as relative5, resolve as resolve8 } from "node:path";
 var WORKSPACE_RUNTIME_SERVICES_FILENAME = ".amaster-runtime-services.json";
 var ARTIFACT_EXTENSIONS = /* @__PURE__ */ new Map([
@@ -9616,7 +9714,7 @@ function sanitizeTrackedChange(line) {
   return isSafeRelativePath(path) ? line : null;
 }
 function sha256File(filePath) {
-  return createHash11("sha256").update(readFileSync8(filePath)).digest("hex");
+  return createHash11("sha256").update(readFileSync9(filePath)).digest("hex");
 }
 function artifactHashCacheKey(relativePath, stat) {
   return `${relativePath}\0${stat.size}\0${stat.mtimeMs}`;
@@ -9654,7 +9752,7 @@ function scanArtifactCandidates(cwd, opts = {}) {
     const current = stack.pop();
     let entries;
     try {
-      entries = readdirSync7(current, { withFileTypes: true });
+      entries = readdirSync8(current, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -9746,7 +9844,7 @@ function readRuntimeServicesSnapshot(cwd) {
   const snapshotPath = join11(resolve8(cwd), WORKSPACE_RUNTIME_SERVICES_FILENAME);
   if (!existsSync10(snapshotPath)) return [];
   try {
-    const parsed = JSON.parse(readFileSync8(snapshotPath, "utf8"));
+    const parsed = JSON.parse(readFileSync9(snapshotPath, "utf8"));
     const rawServices = Array.isArray(parsed) ? parsed : Array.isArray(parsed?.services) ? parsed.services : [];
     return rawServices.map((entry) => sanitizeRuntimeService(entry)).filter((entry) => entry !== null).slice(0, 50);
   } catch {
@@ -9991,7 +10089,7 @@ var source_acquisition_compatibility_default = {
 };
 
 // src/amaster-runtime-daemon.mjs
-var CONNECTOR_VERSION = "0.1.1-beta.44";
+var CONNECTOR_VERSION = "0.1.1-beta.45";
 var CONNECTOR_CONTRACT_VERSION = "2026-06-04.v1";
 var SOURCE_ACQUISITION_CAPABILITY = source_acquisition_compatibility_default.profileVersion;
 var SOURCE_ACQUISITION_PROFILE_VERSION = source_acquisition_compatibility_default.profileVersion;
@@ -10032,7 +10130,7 @@ function resultOutboxPendingCount(config) {
   if (!existsSync11(dir)) return 0;
   try {
     let pending = 0;
-    for (const file of readdirSync8(dir).filter((name) => name.endsWith(".json"))) {
+    for (const file of readdirSync9(dir).filter((name) => name.endsWith(".json"))) {
       if (readValidResultOutboxEntryOrQuarantine(config, file, join12(dir, file))) {
         pending += 1;
       }
@@ -10109,7 +10207,7 @@ function resultOutboxActiveRunCommands(config) {
   if (!existsSync11(dir)) return [];
   const outboxPending = resultOutboxPendingCount(config);
   const entries = [];
-  for (const file of readdirSync8(dir).filter((name) => name.endsWith(".json")).sort()) {
+  for (const file of readdirSync9(dir).filter((name) => name.endsWith(".json")).sort()) {
     const entry = readValidResultOutboxEntryOrQuarantine(config, file, join12(dir, file));
     if (!entry) continue;
     const activeRun = asRecord(entry.activeRun);
@@ -10142,10 +10240,10 @@ function resultOutboxFailedRunCommands(config) {
   const dir = resultOutboxInvalidDir(config);
   if (!existsSync11(dir)) return [];
   const entries = [];
-  for (const file of readdirSync8(dir).filter((name) => name.endsWith(".json")).sort().slice(-100)) {
+  for (const file of readdirSync9(dir).filter((name) => name.endsWith(".json")).sort().slice(-100)) {
     let entry;
     try {
-      entry = asRecord(JSON.parse(readFileSync9(join12(dir, file), "utf8")));
+      entry = asRecord(JSON.parse(readFileSync10(join12(dir, file), "utf8")));
     } catch {
       continue;
     }
@@ -10212,7 +10310,7 @@ function safeExpandPath(value) {
 }
 function safeJsonObjectFromFile(filePath) {
   try {
-    const parsed = JSON.parse(readFileSync9(filePath, "utf8"));
+    const parsed = JSON.parse(readFileSync10(filePath, "utf8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
   } catch {
     return null;
@@ -10229,7 +10327,7 @@ function safeDirectorySummary(pathValue) {
     }
     let entryCount = 0;
     let truncated = false;
-    for (const name of readdirSync8(pathValue)) {
+    for (const name of readdirSync9(pathValue)) {
       if (name.startsWith(".")) continue;
       entryCount += 1;
       if (entryCount >= MAX_PI_CAPABILITY_SOURCE_ENTRIES) {
@@ -10253,7 +10351,7 @@ function safeSkillRootSummary(kind, source, pathValue) {
   let truncated = false;
   if (directory.available && pathValue) {
     try {
-      for (const name of readdirSync8(pathValue)) {
+      for (const name of readdirSync9(pathValue)) {
         if (name.startsWith(".")) continue;
         const skillDir = join12(pathValue, name);
         try {
@@ -11226,7 +11324,7 @@ function sourceAcquisitionRuntimeProfile(config, command) {
 }
 function readJsonFile2(filePath) {
   try {
-    const parsed = JSON.parse(readFileSync9(filePath, "utf8"));
+    const parsed = JSON.parse(readFileSync10(filePath, "utf8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
   } catch {
     return {};
@@ -12147,7 +12245,7 @@ function allProcessCwdsByPid() {
   if (process.platform === "linux") {
     const procEntries = (() => {
       try {
-        return readdirSync8("/proc", { withFileTypes: true });
+        return readdirSync9("/proc", { withFileTypes: true });
       } catch {
         return [];
       }
@@ -12250,7 +12348,7 @@ function walkManagedWorkdirs(root) {
     if (!current) continue;
     let entries = [];
     try {
-      entries = readdirSync8(current, { withFileTypes: true });
+      entries = readdirSync9(current, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -13927,7 +14025,7 @@ function moveResultOutboxEntryToInvalid(config, file, fullPath, reason, detail,
 function readValidResultOutboxEntryOrQuarantine(config, file, fullPath) {
   let entry;
   try {
-    entry = JSON.parse(readFileSync9(fullPath, "utf8"));
+    entry = JSON.parse(readFileSync10(fullPath, "utf8"));
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     moveResultOutboxEntryToInvalid(config, file, fullPath, "malformed_result_outbox_json", message);
@@ -13987,7 +14085,7 @@ function quarantineResultOutboxEntry(config, fullPath, file, entry, reason, err)
 async function flushResultOutbox(config) {
   const dir = resultOutboxDir(config);
   if (!existsSync11(dir)) return { attempted: 0, completed: 0 };
-  const files = readdirSync8(dir).filter((name) => name.endsWith(".json")).sort();
+  const files = readdirSync9(dir).filter((name) => name.endsWith(".json")).sort();
   let completed = 0;
   for (const file of files) {
     const fullPath = join12(dir, file);
@@ -14368,7 +14466,7 @@ function safeCheckpointRelativePath(rawPath) {
   return normalized;
 }
 function hashFileSha256(filePath) {
-  return createHash12("sha256").update(readFileSync9(filePath)).digest("hex");
+  return createHash12("sha256").update(readFileSync10(filePath)).digest("hex");
 }
 async function materializeIssueCheckpoint(config, command, workspace) {
   const checkpointDir = issueCheckpointDir(workspace);
@@ -14376,7 +14474,7 @@ async function materializeIssueCheckpoint(config, command, workspace) {
   if (!existsSync11(manifestPath)) return [];
   let manifest;
   try {
-    manifest = asRecord(JSON.parse(readFileSync9(manifestPath, "utf8")));
+    manifest = asRecord(JSON.parse(readFileSync10(manifestPath, "utf8")));
   } catch (err) {
     rmSync5(checkpointDir, { recursive: true, force: true });
     throw new Error(`invalid issue checkpoint manifest: ${err instanceof Error ? err.message : String(err)}`);

package/dist/amaster-runtime.mjs

@@ -6,7 +6,7 @@ import { basename, dirname, join, resolve } from "node:path";
 import { homedir, hostname } from "node:os";
 import { fileURLToPath } from "node:url";
 
-const CONNECTOR_VERSION = "0.1.1-beta.44";
+const CONNECTOR_VERSION = "0.1.1-beta.45";
 
 const CAPABILITIES = [
   "remote_registration",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amaster.ai/employee-runtime-connector",
-  "version": "0.1.1-beta.44",
+  "version": "0.1.1-beta.45",
   "description": "MirrorX runtime connector CLI and daemon",
   "license": "MIT",
   "type": "module",