@amaster.ai/employee-runtime-connector 0.1.0-beta.20 → 0.1.0-beta.22

package/README.md

@@ -32,6 +32,14 @@ The source of truth lives under this package's `src/` directory. The package bui
 
 Runtime code belongs in the container image. Persist only connector state, the result outbox, and workspaces under the configured state directory.
 
+## Mutation attestation
+
+The daemon reports its connector contract, exact package/build, platform/architecture, and discovered executor versions on every heartbeat. The server compares those facts with `AMASTER_RUNTIME_RECOMMENDED_VERSION` and `AMASTER_RUNTIME_RECOMMENDED_BUILD_COMMIT`, persists a short-lived content-bound attestation, and correlates Runtime V2 commands to that proof.
+
+`AMASTER_RUNTIME_ATTESTATION_MODE` defaults to `shadow`. Set it to `enforce` only after the expected version and build marker are configured and shadow diagnostics are clean; enforce mode refuses to create or lease Runtime V2 mutation commands without a current exact attestation. `AMASTER_RUNTIME_ATTESTATION_TTL_SECONDS` defaults to `300` and accepts `60`–`3600`. Invalid mode or TTL values fail server startup visibly.
+
+Threat model: these facts are self-reported by a connector authenticated with its existing connector credential. There is no hardware-backed signature, remote attestation, or independent trust root. The proof detects accidental version/schema/executor drift by an honest connector and correlates commands to the observed facts; it does not prove that a compromised or malicious connector is running the claimed code. Keep the default `shadow` mode observational. Do not treat this mechanism as a production security boundary or enable `enforce` until credential-epoch identity, transactional create/lease revalidation, batch-local rejection, and recovery from honest drift have passed review.
+
 The AMaster remote stack derives its runtime image from the Pi base image with
 `docker/Dockerfile.amaster-employee-pi-cli-runtime`. The build installs one exact
 connector package version under `/opt/pi-cli-runtime` and sets

package/dist/amaster-runtime-daemon.mjs

@@ -2,10 +2,10 @@
 // AMaster Employee runtime connector daemon bundle.
 
 // src/amaster-runtime-daemon.mjs
-import { createHash as createHash5 } from "node:crypto";
-import { chmodSync as chmodSync3, copyFileSync as copyFileSync2, existsSync as existsSync9, lstatSync as lstatSync3, mkdirSync as mkdirSync5, readFileSync as readFileSync6, readdirSync as readdirSync6, realpathSync as realpathSync2, renameSync as renameSync2, rmSync as rmSync4, statSync as statSync7, symlinkSync as symlinkSync2, unlinkSync, writeFileSync as writeFileSync5 } from "node:fs";
+import { createHash as createHash6 } from "node:crypto";
+import { chmodSync as chmodSync3, copyFileSync as copyFileSync2, existsSync as existsSync9, lstatSync as lstatSync4, mkdirSync as mkdirSync5, readFileSync as readFileSync7, readdirSync as readdirSync6, realpathSync as realpathSync3, renameSync as renameSync3, rmSync as rmSync5, statSync as statSync7, symlinkSync as symlinkSync2, unlinkSync, writeFileSync as writeFileSync5 } from "node:fs";
 import { arch as arch3, homedir as homedir3, hostname as hostname2, platform as platform3 } from "node:os";
-import { basename as basename6, delimiter as delimiter2, dirname as dirname6, extname as extname2, isAbsolute as isAbsolute5, join as join10, relative as relative5, resolve as resolve7 } from "node:path";
+import { basename as basename6, delimiter as delimiter2, dirname as dirname6, extname as extname2, isAbsolute as isAbsolute6, join as join10, relative as relative6, resolve as resolve8 } from "node:path";
 import { spawn, spawnSync as spawnSync5 } from "node:child_process";
 
 // src/amaster-runtime-daemon/common.mjs
@@ -2367,6 +2367,8 @@ function compileCommandPromptWithManifest(input, options = {}) {
   const governedReads = governedReadSection(context);
   const hasTask = Boolean(readString(input.taskMarkdown));
   const taskText = readString(input.taskMarkdown) ?? "";
+  const continuationSummary = continuationText(context);
+  const includeTask = mode === "cold" || !continuationSummary && asRecord(input.nativeSession).mode !== "governed_action_approval";
   const wakeBodies = commentBodies(context);
   const commentsDuplicatedByTask = hasTask && wakeBodies.length > 0 && wakeBodies.every((body) => taskText.includes(body));
   const commentsSelected = mode !== "cold" || !commentsDuplicatedByTask;
@@ -2378,9 +2380,9 @@ function compileCommandPromptWithManifest(input, options = {}) {
   const rawSections = [
     { name: "runtime_rules", title: "", priority: 100, sourceRef: `command:${input.commandId}`, content: fixedRules(input, !hasTask) },
     { name: "approval_continuation", title: "Approved Runtime Action Continuation", priority: 99, sourceRef: `run:${input.runId ?? "unknown"}`, content: approvalContinuationText(input), truncationReason: mode === "continuation" ? null : "mode_selection" },
-    { name: "continuation_summary", title: "Continuation Summary", priority: 97, sourceRef: readString(asRecord(context.paperclipContinuationSummary).key) ?? `issue:${input.issueId ?? "unknown"}`, observedAt: readString(asRecord(context.paperclipContinuationSummary).updatedAt), originalContent: continuationText(context), content: mode === "cold" ? "" : continuationText(context), truncationReason: mode === "cold" ? "mode_selection" : null },
+    { name: "continuation_summary", title: "Continuation Summary", priority: 97, sourceRef: readString(asRecord(context.paperclipContinuationSummary).key) ?? `issue:${input.issueId ?? "unknown"}`, observedAt: readString(asRecord(context.paperclipContinuationSummary).updatedAt), originalContent: continuationSummary, content: mode === "cold" ? "" : continuationSummary, truncationReason: mode === "cold" ? "mode_selection" : null },
     { name: "wake_comments", title: "Wake Comment Delta", priority: 95, sourceRef: commentRefs(context).map((id) => `comment:${id}`), originalContent: readString(input.comments) ?? "", content: commentsSelected ? readString(input.comments) ?? "" : "", truncationReason: commentsSelected ? null : "duplicate_task_context" },
-    { name: "task", title: "Task Context", priority: 90, sourceRef: `issue:${input.issueId ?? "unknown"}`, originalContent: taskText, content: mode === "cold" ? taskText : "", truncationReason: mode === "cold" ? null : "mode_selection" },
+    { name: "task", title: "Task Context", priority: 90, sourceRef: `issue:${input.issueId ?? "unknown"}`, originalContent: taskText, content: includeTask ? taskText : "", truncationReason: includeTask ? null : "mode_selection" },
     { name: "governed_reads", title: "Governed External Reads", priority: 88, sourceRef: governedReads.provenance.map((entry) => entry.sourceRef), observedAt: governedReads.provenance.map((entry) => entry.observedAt), freshness: governedReads.provenance.map((entry) => entry.freshness), scope: governedReads.provenance.map((entry) => entry.scope), content: governedReads.content },
     { name: "agent_instructions", title: "Agent Instructions", priority: 85, sourceRef: "agent_instructions_bundle", content: readString(input.agentInstructions) ?? "" },
     { name: "attachments", title: "Materialized Inputs", priority: 80, sourceRef: "materialized_attachments", content: readString(input.attachmentsText) ?? "" },
@@ -2433,7 +2435,7 @@ function compileCommandPromptWithManifest(input, options = {}) {
 }
 
 // src/amaster-runtime-daemon/config-state.mjs
-import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, renameSync, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "node:fs";
 import { homedir as homedir2, hostname } from "node:os";
 import { dirname as dirname3, join as join4 } from "node:path";
 
@@ -2557,16 +2559,53 @@ function runtimeHome(env) {
 function stateFilePath(env) {
   return env.AMASTER_DAEMON_STATE_FILE ? expandHomePath(String(env.AMASTER_DAEMON_STATE_FILE)) : join4(runtimeHome(env), "runtime-connector-state.json");
 }
+function corruptStatePath(path) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/\D/g, "").slice(0, 14);
+  const base = `${path}.corrupt-${timestamp}Z`;
+  let candidate = base;
+  for (let suffix = 1; existsSync3(candidate); suffix += 1) {
+    candidate = `${base}.${suffix}`;
+  }
+  return candidate;
+}
 function readState(env) {
   const path = stateFilePath(env);
   if (!existsSync3(path)) return {};
-  return JSON.parse(readFileSync3(path, "utf8"));
+  try {
+    const state = JSON.parse(readFileSync3(path, "utf8"));
+    if (!state || typeof state !== "object" || Array.isArray(state)) {
+      throw new TypeError("runtime connector state must be a JSON object");
+    }
+    return state;
+  } catch {
+    const quarantinePath = corruptStatePath(path);
+    try {
+      renameSync(path, quarantinePath);
+      process.stderr.write(`AMaster runtime state was invalid and quarantined at ${quarantinePath}
+`);
+    } catch (error) {
+      process.stderr.write(
+        `AMaster runtime state was invalid but could not be quarantined (${error?.code ?? "unknown error"})
+`
+      );
+    }
+    return {};
+  }
 }
 function writeState(env, state) {
   const path = stateFilePath(env);
   mkdirSync3(dirname3(path), { recursive: true });
-  writeFileSync3(path, `${JSON.stringify(state, null, 2)}
-`);
+  const temporaryPath = `${path}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  try {
+    writeFileSync3(temporaryPath, `${JSON.stringify(state, null, 2)}
+`, {
+      flag: "wx",
+      mode: 384
+    });
+    renameSync(temporaryPath, path);
+  } finally {
+    rmSync3(temporaryPath, { force: true });
+  }
 }
 function buildConfig(env = process.env, flags = {}) {
   const serverUrl = String(flags.serverUrl ?? env.AMASTER_EMPLOYEE_SERVER_URL ?? "http://127.0.0.1:3100").replace(/\/+$/, "");
@@ -3151,6 +3190,13 @@ function shouldPreserveExecutorJsonlForTranscript(executorKind, event) {
 var CODEX_TRANSIENT_UPSTREAM_RE = /(?:we(?:'|’)re\s+currently\s+experiencing\s+high\s+demand|temporary\s+errors|rate[-\s]?limit(?:ed)?|too\s+many\s+requests|\b429\b|server\s+overloaded|service\s+unavailable|try\s+again\s+later)/i;
 var CODEX_REMOTE_COMPACTION_RE = /remote\s+compact\s+task/i;
 var CODEX_USAGE_LIMIT_RE = /you(?:'|’)ve hit your usage limit for .+\.\s+switch to another model now,\s+or try again at\s+([^.!\n]+)(?:[.!]|\n|$)/i;
+function approvedMcpInvocationSucceeded(results, invocationId) {
+  const approvedInvocationId = readString(invocationId);
+  return Boolean(approvedInvocationId && (Array.isArray(results) ? results : []).some((rawResult) => {
+    const result2 = asRecord(rawResult);
+    return readString(result2.invocationId) === approvedInvocationId && readString(result2.status) === "succeeded" && !["rejected", "blocked"].includes(readString(result2.providerStatus) ?? "");
+  }));
+}
 function parseCodexJsonl(stdout) {
   let sessionId = null;
   let summary = "";
@@ -3171,7 +3217,19 @@ function parseCodexJsonl(stdout) {
         summary = readString(item.text) ?? summary;
       }
       if (item.type === "mcp_tool_call") {
-        const structuredContent = asRecord(asRecord(item.result).structuredContent);
+        const result2 = asRecord(item.result);
+        let structuredContent = asRecord(result2.structuredContent);
+        if (Object.keys(structuredContent).length === 0 && Array.isArray(result2.content)) {
+          for (const part of result2.content) {
+            const text = readString(asRecord(part).text);
+            if (!text) continue;
+            try {
+              structuredContent = asRecord(JSON.parse(text));
+            } catch {
+            }
+            if (Object.keys(structuredContent).length > 0) break;
+          }
+        }
         const status = readString(structuredContent.status);
         if (status) {
           const invocationId = readString(structuredContent.invocationId);
@@ -3536,7 +3594,21 @@ function piMcpToolResults(event) {
     const status = readString(structuredContent.status);
     if (!status) continue;
     const invocationId = readString(structuredContent.invocationId);
-    results.push({ ...invocationId ? { invocationId } : {}, status });
+    const providerContent = asRecord(structuredContent.content);
+    const providerStatus = readString(providerContent.status);
+    const effectResult = asRecord(asRecord(providerContent.result).effectResult);
+    const intentId = readString(effectResult.artifactIntentId);
+    const manifestId = readString(effectResult.manifestId);
+    const sourceRelativePath = readString(effectResult.sourceRelativePath);
+    const sha256 = readString(effectResult.sha256);
+    const byteSize = readNumber(effectResult.byteSize, 0);
+    const artifactIntent = providerContent.status === "pending_reconcile" && intentId && manifestId && sourceRelativePath && /^[a-f0-9]{64}$/.test(sha256 ?? "") && Number.isSafeInteger(byteSize) && byteSize > 0 ? { intentId, manifestId, sourceRelativePath, sha256, byteSize } : null;
+    results.push({
+      ...invocationId ? { invocationId } : {},
+      status,
+      ...providerStatus ? { providerStatus } : {},
+      ...artifactIntent ? { artifactIntent } : {}
+    });
   }
   return results;
 }
@@ -3705,6 +3777,26 @@ async function postRuntimeConnectorJson(config, path, payload) {
   }
   return body;
 }
+async function postRuntimeConnectorBytes(config, path, body, headers = {}) {
+  if (!Buffer.isBuffer(body)) throw new TypeError("Runtime connector byte upload body must be a Buffer");
+  const res = await fetch(`${config.serverUrl}${path}`, {
+    method: "POST",
+    headers: {
+      ...headers,
+      "content-type": "application/octet-stream",
+      ...buildRuntimeConnectorAuthHeaders(config)
+    },
+    body
+  });
+  const text = await res.text();
+  const response = text ? JSON.parse(text) : null;
+  if (!res.ok) {
+    const error = new Error(`POST ${path} returned HTTP ${res.status}: ${text}`);
+    error.httpStatus = res.status;
+    throw error;
+  }
+  return response;
+}
 async function bestEffortPostRuntimeConnectorJson(config, path, payload, options = {}) {
   try {
     return await postRuntimeConnectorJson(config, path, payload);
@@ -3722,13 +3814,73 @@ async function bestEffortPostRuntimeConnectorJson(config, path, payload, options
 var postJson = postRuntimeConnectorJson;
 var bestEffortPostJson = bestEffortPostRuntimeConnectorJson;
 
-// src/amaster-runtime-daemon/workspace-guard.mjs
+// src/amaster-runtime-daemon/runtime-artifact-upload.mjs
 import { createHash as createHash3 } from "node:crypto";
-import { existsSync as existsSync5, mkdirSync as mkdirSync4, realpathSync, statSync as statSync3 } from "node:fs";
-import { basename as basename4, join as join6, isAbsolute as isAbsolute3, relative as relative3, resolve as resolve3 } from "node:path";
+import { lstatSync as lstatSync3, readFileSync as readFileSync4, realpathSync } from "node:fs";
+import { isAbsolute as isAbsolute3, relative as relative3, resolve as resolve3 } from "node:path";
+var SHA256_PATTERN = /^[a-f0-9]{64}$/;
+function requiredString(value, name) {
+  if (typeof value !== "string" || !value.trim()) throw new Error(`Runtime Artifact ${name} is required`);
+  return value.trim();
+}
+function ownedRelativePath(value) {
+  const normalized = requiredString(value, "sourceRelativePath").replaceAll("\\", "/");
+  if (normalized.startsWith("/") || /^[a-z]:\//i.test(normalized) || normalized.split("/").some((segment) => !segment || segment === "." || segment === "..")) throw new Error(`Runtime Artifact source path is not owned: ${normalized}`);
+  return normalized;
+}
+function pathWithin(candidate, root) {
+  const rel = relative3(root, candidate);
+  return rel === "" || !rel.startsWith("..") && !isAbsolute3(rel);
+}
+function prepareRuntimeArtifactUploads(cwd, mcpToolResults) {
+  const root = realpathSync(resolve3(cwd));
+  const uploads = /* @__PURE__ */ new Map();
+  for (const result2 of Array.isArray(mcpToolResults) ? mcpToolResults : []) {
+    const intent = result2 && typeof result2 === "object" && !Array.isArray(result2) ? result2.artifactIntent : null;
+    if (!intent || typeof intent !== "object" || Array.isArray(intent)) continue;
+    const intentId = requiredString(intent.intentId, "intentId");
+    const manifestId = requiredString(intent.manifestId, "manifestId");
+    const sourceRelativePath = ownedRelativePath(intent.sourceRelativePath);
+    const expectedSha256 = requiredString(intent.sha256, "sha256");
+    const expectedByteSize = intent.byteSize;
+    if (!SHA256_PATTERN.test(expectedSha256)) throw new Error(`Runtime Artifact ${intentId} has an invalid SHA-256`);
+    if (!Number.isSafeInteger(expectedByteSize) || expectedByteSize <= 0) {
+      throw new Error(`Runtime Artifact ${intentId} has an invalid byte size`);
+    }
+    const existing = uploads.get(intentId);
+    if (existing) {
+      if (existing.manifestId !== manifestId || existing.sourceRelativePath !== sourceRelativePath || existing.sha256 !== expectedSha256 || existing.byteSize !== expectedByteSize) throw new Error(`Runtime Artifact ${intentId} was emitted with conflicting ownership metadata`);
+      continue;
+    }
+    const sourcePath = resolve3(root, sourceRelativePath);
+    const stat = lstatSync3(sourcePath);
+    if (!stat.isFile() || stat.isSymbolicLink() || !pathWithin(realpathSync(sourcePath), root)) {
+      throw new Error(`Runtime Artifact ${intentId} source is not an owned regular file`);
+    }
+    const body = readFileSync4(sourcePath);
+    const actualSha256 = createHash3("sha256").update(body).digest("hex");
+    if (body.length !== expectedByteSize || actualSha256 !== expectedSha256) {
+      throw new Error(`Runtime Artifact ${intentId} bytes do not match the governed ownership manifest`);
+    }
+    uploads.set(intentId, {
+      intentId,
+      manifestId,
+      sourceRelativePath,
+      sha256: expectedSha256,
+      byteSize: expectedByteSize,
+      body
+    });
+  }
+  return [...uploads.values()];
+}
+
+// src/amaster-runtime-daemon/workspace-guard.mjs
+import { createHash as createHash4 } from "node:crypto";
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, realpathSync as realpathSync2, statSync as statSync3 } from "node:fs";
+import { basename as basename4, join as join6, isAbsolute as isAbsolute4, relative as relative4, resolve as resolve4 } from "node:path";
 
 // src/amaster-runtime-daemon/workspace-manifest.mjs
-import { existsSync as existsSync4, readFileSync as readFileSync4, renameSync, rmSync as rmSync3, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync4, readFileSync as readFileSync5, renameSync as renameSync2, rmSync as rmSync4, writeFileSync as writeFileSync4 } from "node:fs";
 import { basename as basename3, dirname as dirname4, join as join5 } from "node:path";
 var WORKSPACE_MANIFEST_FILENAME = ".amaster-runtime.json";
 function nowIso() {
@@ -3743,7 +3895,7 @@ function workspaceManifestPath(workspaceOrCwd) {
 function readWorkspaceManifest(manifestPath) {
   if (!manifestPath || !existsSync4(manifestPath)) return null;
   try {
-    const parsed = JSON.parse(readFileSync4(manifestPath, "utf8"));
+    const parsed = JSON.parse(readFileSync5(manifestPath, "utf8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
   } catch {
     return null;
@@ -3757,9 +3909,9 @@ function writeWorkspaceManifest(manifestPath, manifest) {
   try {
     writeFileSync4(tempPath, `${JSON.stringify(manifest, null, 2)}
 `, { mode: 384 });
-    renameSync(tempPath, manifestPath);
+    renameSync2(tempPath, manifestPath);
   } catch (err) {
-    rmSync3(tempPath, { force: true });
+    rmSync4(tempPath, { force: true });
     throw err;
   }
   return manifest;
@@ -3807,23 +3959,23 @@ function updateWorkspaceManifest(workspaceOrManifestPath, patch = {}) {
 }
 
 // src/amaster-runtime-daemon/workspace-guard.mjs
-function pathWithin(candidate, root) {
-  const rel = relative3(root, candidate);
-  return rel === "" || !rel.startsWith("..") && !isAbsolute3(rel);
+function pathWithin2(candidate, root) {
+  const rel = relative4(root, candidate);
+  return rel === "" || !rel.startsWith("..") && !isAbsolute4(rel);
 }
 function resolveWorkspaceCwd(config, command) {
   const payload = asRecord(command.payload);
   const requested = readString(payload.workspacePath);
   const fallback = config.workspaceBindings[0] ?? process.cwd();
-  const cwd = realpathSync(resolve3(expandHomePath(requested ?? fallback)));
+  const cwd = realpathSync2(resolve4(expandHomePath(requested ?? fallback)));
   const allowlist = config.workspaceBindings.flatMap((entry) => {
     try {
-      return [realpathSync(resolve3(expandHomePath(entry)))];
+      return [realpathSync2(resolve4(expandHomePath(entry)))];
     } catch {
       return [];
     }
   });
-  const allowed = allowlist.some((entry) => pathWithin(cwd, entry));
+  const allowed = allowlist.some((entry) => pathWithin2(cwd, entry));
   if (!allowed) {
     throw new Error(`Workspace path is outside AMASTER_WORKSPACE_ALLOWLIST: ${cwd}`);
   }
@@ -3833,7 +3985,7 @@ function resolveWorkspaceCwd(config, command) {
   return cwd;
 }
 function shortHash(value, length = 12) {
-  return createHash3("sha256").update(String(value)).digest("hex").slice(0, length);
+  return createHash4("sha256").update(String(value)).digest("hex").slice(0, length);
 }
 function safeSegment(value, fallback) {
   const raw = String(value ?? "").trim();
@@ -3857,9 +4009,9 @@ function workspaceLabel(sourceWorkspacePath, payload) {
   return readString(payload.workspaceName) ?? readString(payload.projectName) ?? readString(context.projectName) ?? basename4(sourceWorkspacePath) ?? "workspace";
 }
 function workspacesRoot(config) {
-  const root = resolve3(expandHomePath(config.runtimeWorkspacesRoot ?? "~/.amaster-employee/workspaces"));
+  const root = resolve4(expandHomePath(config.runtimeWorkspacesRoot ?? "~/.amaster-employee/workspaces"));
   mkdirSync4(root, { recursive: true });
-  return realpathSync(root);
+  return realpathSync2(root);
 }
 function resolveExecutionWorkspace(config, command, opts = {}) {
   const sourceWorkspacePath = resolveWorkspaceCwd(config, command);
@@ -3897,7 +4049,7 @@ function resolveExecutionWorkspace(config, command, opts = {}) {
 
 // src/amaster-runtime-daemon/workspace-gc.mjs
 import { existsSync as existsSync6, readdirSync as readdirSync3, statSync as statSync4 } from "node:fs";
-import { join as join7, resolve as resolve4 } from "node:path";
+import { join as join7, resolve as resolve5 } from "node:path";
 function readIsoTime(value) {
   if (typeof value !== "string" || !value.trim()) return null;
   const time = new Date(value).getTime();
@@ -3979,7 +4131,7 @@ function summarizeWorkdir(path, manifest, nowMs) {
   };
 }
 function planManagedWorkspaceGcDryRun(input) {
-  const root = resolve4(String(input.root ?? ""));
+  const root = resolve5(String(input.root ?? ""));
   const now = input.now instanceof Date ? input.now : /* @__PURE__ */ new Date();
   const nowMs = now.getTime();
   const ttlHours = Math.max(1, Number(input.ttlHours ?? 72));
@@ -4025,7 +4177,7 @@ function planManagedWorkspaceGcDryRun(input) {
 
 // src/amaster-runtime-daemon/runtime-status-summary.mjs
 import { existsSync as existsSync7, readdirSync as readdirSync4, statSync as statSync5 } from "node:fs";
-import { dirname as dirname5, join as join8, resolve as resolve5 } from "node:path";
+import { dirname as dirname5, join as join8, resolve as resolve6 } from "node:path";
 function runtimeStatusDirectoryEntries(path) {
   try {
     return readdirSync4(path, { withFileTypes: true });
@@ -4117,7 +4269,7 @@ function countRuntimeStatusJsonEntries(dir) {
 }
 function summarizeRuntimeLocalState(input) {
   const config = input.config ?? {};
-  const root = resolve5(String(config.AMASTER_RUNTIME_WORKSPACES_ROOT ?? config.runtimeWorkspacesRoot ?? input.runtimeWorkspacesRoot ?? ""));
+  const root = resolve6(String(config.AMASTER_RUNTIME_WORKSPACES_ROOT ?? config.runtimeWorkspacesRoot ?? input.runtimeWorkspacesRoot ?? ""));
   const now = input.now instanceof Date ? input.now : /* @__PURE__ */ new Date();
   const workdirs = walkRuntimeStatusManagedWorkdirs(root);
   let managedWorkdirBytes = 0;
@@ -4193,9 +4345,9 @@ function summarizeAmasterRuntimeVersionDrift(input = {}) {
 
 // src/amaster-runtime-daemon/workspace-status.mjs
 import { spawnSync as spawnSync4 } from "node:child_process";
-import { createHash as createHash4 } from "node:crypto";
-import { existsSync as existsSync8, readdirSync as readdirSync5, readFileSync as readFileSync5, statSync as statSync6 } from "node:fs";
-import { basename as basename5, extname, isAbsolute as isAbsolute4, join as join9, relative as relative4, resolve as resolve6 } from "node:path";
+import { createHash as createHash5 } from "node:crypto";
+import { existsSync as existsSync8, readdirSync as readdirSync5, readFileSync as readFileSync6, statSync as statSync6 } from "node:fs";
+import { basename as basename5, extname, isAbsolute as isAbsolute5, join as join9, relative as relative5, resolve as resolve7 } from "node:path";
 var WORKSPACE_RUNTIME_SERVICES_FILENAME = ".amaster-runtime-services.json";
 var ARTIFACT_EXTENSIONS = /* @__PURE__ */ new Map([
   [".md", "markdown"],
@@ -4226,9 +4378,12 @@ var SKIP_DIR_NAMES = /* @__PURE__ */ new Set([
   "build",
   "coverage",
   ".turbo",
-  ".cache"
+  ".cache",
+  ".venv",
+  "venv"
 ]);
 var SECRET_PATH_PATTERN = /(^|\/)(\.env($|[._-])|.*\.(pem|key|p12|pfx)$|.*(secret|token|credential|password|authorization|cookie).*)/i;
+var RUNTIME_INSTRUCTION_FILENAMES = /* @__PURE__ */ new Set(["AGENTS.md", "SOUL.md"]);
 var MAX_CANDIDATES = 200;
 var MAX_SCAN_ENTRIES = 5e3;
 var MAX_HASH_BYTES = 50 * 1024 * 1024;
@@ -4237,16 +4392,17 @@ var SAFE_RUNTIME_SERVICE_STATUSES = /* @__PURE__ */ new Set(["starting", "runnin
 var SAFE_RUNTIME_SERVICE_HEALTH_STATUSES = /* @__PURE__ */ new Set(["unknown", "healthy", "unhealthy"]);
 var SAFE_RUNTIME_SERVICE_LIFECYCLES = /* @__PURE__ */ new Set(["shared", "ephemeral"]);
 function statusPathWithin(candidate, root) {
-  const rel = relative4(root, candidate);
-  return rel === "" || !rel.startsWith("..") && !isAbsolute4(rel);
+  const rel = relative5(root, candidate);
+  return rel === "" || !rel.startsWith("..") && !isAbsolute5(rel);
 }
 function normalizeRelativePath(root, filePath) {
-  return relative4(root, filePath).split(/[\\/]+/).join("/");
+  return relative5(root, filePath).split(/[\\/]+/).join("/");
 }
 function isSafeRelativePath(value) {
   const text = String(value ?? "").trim().split(/[\\/]+/).join("/");
   if (!text || text.startsWith("../") || text === ".." || text.startsWith("/")) return false;
-  return !SECRET_PATH_PATTERN.test(text);
+  const segments = text.split("/").filter(Boolean);
+  return !SECRET_PATH_PATTERN.test(text) && !RUNTIME_INSTRUCTION_FILENAMES.has(basename5(text)) && !segments.some((segment) => segment === ".venv" || segment === "venv");
 }
 function gitStatusPath(line) {
   if (line.startsWith("?? ")) return line.slice(3);
@@ -4260,7 +4416,7 @@ function sanitizeTrackedChange(line) {
   return isSafeRelativePath(path) ? line : null;
 }
 function sha256File(filePath) {
-  return createHash4("sha256").update(readFileSync5(filePath)).digest("hex");
+  return createHash5("sha256").update(readFileSync6(filePath)).digest("hex");
 }
 function artifactHashCacheKey(relativePath, stat) {
   return `${relativePath}\0${stat.size}\0${stat.mtimeMs}`;
@@ -4288,7 +4444,7 @@ function artifactSha256(filePath, relativePath, stat, opts = {}) {
   return hash;
 }
 function scanArtifactCandidates(cwd, opts = {}) {
-  const root = resolve6(cwd);
+  const root = resolve7(cwd);
   const maxCandidates = opts.maxCandidates ?? MAX_CANDIDATES;
   const maxEntries = opts.maxEntries ?? MAX_SCAN_ENTRIES;
   const candidates = [];
@@ -4328,7 +4484,7 @@ function scanArtifactCandidates(cwd, opts = {}) {
       } catch {
         continue;
       }
-      if (!statusPathWithin(resolve6(fullPath), root) || stat.size > MAX_HASH_BYTES) continue;
+      if (!statusPathWithin(resolve7(fullPath), root) || stat.size > MAX_HASH_BYTES) continue;
       candidates.push({
         relativePath,
         name: basename5(fullPath),
@@ -4388,10 +4544,10 @@ function sanitizeRuntimeService(entry) {
   };
 }
 function readRuntimeServicesSnapshot(cwd) {
-  const snapshotPath = join9(resolve6(cwd), WORKSPACE_RUNTIME_SERVICES_FILENAME);
+  const snapshotPath = join9(resolve7(cwd), WORKSPACE_RUNTIME_SERVICES_FILENAME);
   if (!existsSync8(snapshotPath)) return [];
   try {
-    const parsed = JSON.parse(readFileSync5(snapshotPath, "utf8"));
+    const parsed = JSON.parse(readFileSync6(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 {
@@ -4462,7 +4618,8 @@ function readWorkspaceStatus(cwd, opts = {}) {
 }
 
 // src/amaster-runtime-daemon.mjs
-var CONNECTOR_VERSION = "0.1.0-beta.20";
+var CONNECTOR_VERSION = "0.1.0-beta.22";
+var CONNECTOR_CONTRACT_VERSION = "2026-06-04.v1";
 var MAX_CHECKPOINT_BYTES = 20 * 1024 * 1024;
 var CHECKPOINT_TTL_MS = 24 * 60 * 60 * 1e3;
 var PROMPT_AGENT_INSTRUCTION_FILE_ORDER = ["AGENTS.md", "SOUL.md"];
@@ -4575,11 +4732,11 @@ function piExtraArgsDiagnostics(value) {
 }
 function safeExpandPath(value) {
   const text = readString(value);
-  return text ? resolve7(expandHomePath(text)) : null;
+  return text ? resolve8(expandHomePath(text)) : null;
 }
 function safeJsonObjectFromFile(filePath) {
   try {
-    const parsed = JSON.parse(readFileSync6(filePath, "utf8"));
+    const parsed = JSON.parse(readFileSync7(filePath, "utf8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
   } catch {
     return null;
@@ -4814,6 +4971,11 @@ function buildRegisterPayload(config) {
     networkDomains: config.networkDomains,
     executors: config.executors,
     capabilities: config.capabilities,
+    contractVersion: CONNECTOR_CONTRACT_VERSION,
+    connectorVersion: CONNECTOR_VERSION,
+    ...buildCommit ? { buildCommit } : {},
+    platform: process.platform,
+    arch: process.arch,
     metadata: {
       daemon: "amaster-runtime-daemon.mjs",
       connectorVersion: CONNECTOR_VERSION,
@@ -4856,6 +5018,9 @@ function buildHeartbeatPayload(config, options = {}) {
     capabilities: config.capabilities,
     connectorVersion: CONNECTOR_VERSION,
     ...buildCommit ? { buildCommit } : {},
+    contractVersion: CONNECTOR_CONTRACT_VERSION,
+    platform: process.platform,
+    arch: process.arch,
     runtimeStatus: {
       daemon: "running",
       pid: process.pid,
@@ -5395,7 +5560,7 @@ function commandExecutorEnv(command) {
 }
 function readJsonFile(filePath) {
   try {
-    const parsed = JSON.parse(readFileSync6(filePath, "utf8"));
+    const parsed = JSON.parse(readFileSync7(filePath, "utf8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
   } catch {
     return {};
@@ -5406,7 +5571,7 @@ function writeJsonFileAtomic(filePath, value) {
   const tmpPath = `${filePath}.tmp.${process.pid}.${Date.now()}`;
   writeFileSync5(tmpPath, `${JSON.stringify(value, null, 2)}
 `, { mode: 384 });
-  renameSync2(tmpPath, filePath);
+  renameSync3(tmpPath, filePath);
 }
 function isPlainRecord(value) {
   return value && typeof value === "object" && !Array.isArray(value);
@@ -5565,12 +5730,12 @@ function safeAgentInstructionMaterializationTarget(workspace, filePath) {
   const raw = readString(filePath);
   if (!raw || raw.includes("\0")) return null;
   const normalized = raw.replace(/\\/g, "/");
-  if (isAbsolute5(normalized)) return null;
+  if (isAbsolute6(normalized)) return null;
   const segments = normalized.split("/").filter(Boolean);
   if (segments.length === 0 || segments.some((segment) => segment === "." || segment === "..")) return null;
   const relativePath = segments.join("/");
-  const targetPath = resolve7(workspace.cwd, relativePath);
-  if (!pathWithin(targetPath, workspace.cwd)) return null;
+  const targetPath = resolve8(workspace.cwd, relativePath);
+  if (!pathWithin2(targetPath, workspace.cwd)) return null;
   return { relativePath, targetPath };
 }
 async function materializeAgentInstructionsBundle(config, command, workspace) {
@@ -5653,14 +5818,14 @@ function safeCompanyPiHomeSegment(companyId) {
   if (!raw) return null;
   if (/^[A-Za-z0-9][A-Za-z0-9._-]{0,119}$/.test(raw)) return raw;
   const normalized = raw.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^[._-]+|[._-]+$/g, "").slice(0, 80);
-  const hash = createHash5("sha256").update(raw).digest("hex").slice(0, 12);
+  const hash = createHash6("sha256").update(raw).digest("hex").slice(0, 12);
   return normalized ? `${normalized}-${hash}` : `company-${hash}`;
 }
 function companyPiHomeRoot(baseEnv) {
   const explicitRoot = readString(baseEnv.AMASTER_COMPANY_PI_HOME_ROOT);
-  if (explicitRoot) return resolve7(expandHomePath(explicitRoot));
+  if (explicitRoot) return resolve8(expandHomePath(explicitRoot));
   const configuredPiHome = readString(baseEnv.PI_AGENT_HOME) ?? readString(baseEnv.PI_CODING_AGENT_DIR);
-  if (configuredPiHome) return join10(dirname6(resolve7(expandHomePath(configuredPiHome))), "companies");
+  if (configuredPiHome) return join10(dirname6(resolve8(expandHomePath(configuredPiHome))), "companies");
   return join10(homedir3(), ".amaster-employee", "companies");
 }
 function companyPiAgentHome(baseEnv, companyId) {
@@ -5725,9 +5890,9 @@ function resolveNativeSessionRequest(command, workspace) {
   let cwdMatched = false;
   if (requestedCwd && sourceWorkspacePath) {
     try {
-      cwdMatched = realpathSync2(requestedCwd) === realpathSync2(sourceWorkspacePath);
+      cwdMatched = realpathSync3(requestedCwd) === realpathSync3(sourceWorkspacePath);
     } catch {
-      cwdMatched = resolve7(requestedCwd) === resolve7(sourceWorkspacePath);
+      cwdMatched = resolve8(requestedCwd) === resolve8(sourceWorkspacePath);
     }
   }
   const used = Boolean(enabled && requested && sessionId && requestedCwd && cwdMatched);
@@ -6105,6 +6270,11 @@ function createLiveOutputLogger(config, command, executorKind, protectedValues =
     }
   };
 }
+function isRuntimeMetadataArtifactPath(value) {
+  const normalized = String(value ?? "").replaceAll("\\", "/").replace(/^\.\//, "");
+  const name = basename6(normalized);
+  return name === WORKSPACE_MANIFEST_FILENAME || name === WORKSPACE_RUNTIME_SERVICES_FILENAME;
+}
 function sampleProcessGroupRssBytes(processGroupId) {
   if (process.platform === "win32" || processGroupId === null) return null;
   const now = Date.now();
@@ -6130,15 +6300,15 @@ function sampleProcessGroupRssBytes(processGroupId) {
 }
 function realOrResolvedPath(value) {
   try {
-    return realpathSync2(value);
+    return realpathSync3(value);
   } catch {
-    return resolve7(value);
+    return resolve8(value);
   }
 }
 function processCwdForPid(pid) {
   if (process.platform === "linux") {
     try {
-      return realpathSync2(`/proc/${pid}/cwd`);
+      return realpathSync3(`/proc/${pid}/cwd`);
     } catch {
       return null;
     }
@@ -6229,7 +6399,7 @@ function listWorkspaceResidentProcesses(cwd, processGroupId, options = {}) {
     if (processGroupId !== null && pgid === processGroupId) continue;
     const commandMatches = commandLine.includes(cwd) || commandLine.includes(normalizedCwd);
     const processCwd = commandMatches ? null : options.processCwdsByPid instanceof Map ? options.processCwdsByPid.get(pid) ?? null : processCwdForPid(pid);
-    const cwdMatches = processCwd ? pathWithin(processCwd, normalizedCwd) : false;
+    const cwdMatches = processCwd ? pathWithin2(processCwd, normalizedCwd) : false;
     if (!commandMatches && !cwdMatches) continue;
     rows.push({ pid, pgid, command: commandLine.slice(0, 300) });
   }
@@ -6308,8 +6478,8 @@ function manifestMatchesActiveRuntimeRef(manifest, refs, workdir = null) {
 }
 function buildOrphanReaperSample(root, workdir, manifest, residents) {
   const relativeWorkdir = (() => {
-    const value = relative5(root, workdir);
-    return value && !value.startsWith("..") && !isAbsolute5(value) ? value : basename6(workdir);
+    const value = relative6(root, workdir);
+    return value && !value.startsWith("..") && !isAbsolute6(value) ? value : basename6(workdir);
   })();
   return {
     workdir: relativeWorkdir,
@@ -6613,6 +6783,53 @@ async function ingestWorkspaceStatus(config, command, cwd) {
     runId: commandRunId(command) ?? void 0,
     ...status
   });
+  return status;
+}
+async function ingestRuntimeArtifacts(config, command, cwd, mcpToolResults) {
+  const connectorId = requireConnectorId(config);
+  const runId = commandRunId(command);
+  if (!runId) throw new Error("Runtime Artifact ingest requires a correlated runId");
+  const uploads = prepareRuntimeArtifactUploads(cwd, mcpToolResults);
+  const receipts = [];
+  for (const upload of uploads) {
+    const path = `/api/amaster/runtime-connectors/${connectorId}/artifact-intents/${encodeURIComponent(upload.intentId)}/ingest`;
+    try {
+      const receipt = asRecord(await postRuntimeConnectorBytes(config, path, upload.body, {
+        "x-amaster-command-id": command.commandId,
+        "x-amaster-run-id": runId,
+        "x-amaster-artifact-manifest-id": upload.manifestId,
+        "x-amaster-artifact-source-path": upload.sourceRelativePath
+      }));
+      if (readString(receipt.intentId) !== upload.intentId || readString(receipt.status) !== "finalized") {
+        throw new Error(`Runtime Artifact ${upload.intentId} was not finalized: ${JSON.stringify(receipt)}`);
+      }
+      receipts.push(receipt);
+      await ingestLog(config, command, "system", "info", `Finalized Runtime Artifact ${upload.sourceRelativePath}`, {
+        presentationKind: "runtime_artifact_ingest",
+        intentId: upload.intentId,
+        manifestId: upload.manifestId,
+        sourceRelativePath: upload.sourceRelativePath,
+        sha256: upload.sha256,
+        byteSize: upload.byteSize,
+        attachmentId: readString(receipt.attachmentId),
+        workProductId: readString(receipt.workProductId),
+        status: readString(receipt.status)
+      });
+    } catch (err) {
+      const message = `Runtime Artifact ${upload.intentId} ingest failed: ${err instanceof Error ? err.message : String(err)}`;
+      await ingestLog(config, command, "system", "error", message, {
+        presentationKind: "runtime_artifact_ingest",
+        intentId: upload.intentId,
+        manifestId: upload.manifestId,
+        sourceRelativePath: upload.sourceRelativePath,
+        sha256: upload.sha256,
+        byteSize: upload.byteSize,
+        status: "failed"
+      });
+      throw new Error(message);
+    }
+  }
+  return receipts;
 }
 function resultOutboxActiveRunSnapshot(command) {
   const commandId = readString(command.commandId) ?? readString(command.id);
@@ -6664,7 +6881,7 @@ async function completeCommand(config, command, status, result2, error) {
 }
 function resultOutboxDir(config) {
   const explicit = readString(process.env.AMASTER_RESULT_OUTBOX_DIR);
-  if (explicit) return resolve7(expandHomePath(explicit));
+  if (explicit) return resolve8(expandHomePath(explicit));
   return join10(dirname6(stateFilePath(process.env)), "result-outbox");
 }
 function resultOutboxInvalidDir(config) {
@@ -6689,7 +6906,7 @@ function moveResultOutboxEntryToInvalid(config, file, fullPath, reason, detail,
   const invalidPath = join10(invalidDir, file);
   if (original === void 0) {
     try {
-      renameSync2(fullPath, invalidPath);
+      renameSync3(fullPath, invalidPath);
     } catch {
       copyFileSync2(fullPath, invalidPath);
       unlinkSync(fullPath);
@@ -6709,7 +6926,7 @@ function moveResultOutboxEntryToInvalid(config, file, fullPath, reason, detail,
 function readValidResultOutboxEntryOrQuarantine(config, file, fullPath) {
   let entry;
   try {
-    entry = JSON.parse(readFileSync6(fullPath, "utf8"));
+    entry = JSON.parse(readFileSync7(fullPath, "utf8"));
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     moveResultOutboxEntryToInvalid(config, file, fullPath, "malformed_result_outbox_json", message);
@@ -6987,7 +7204,7 @@ async function materializeIssueAttachments(config, command, workspace) {
     const body = await runtimeApiBuffer(runtimeAuth, contentPath);
     writeFileSync5(targetPath, body);
     const attachmentId = readString(attachment.id);
-    const actualSha256 = createHash5("sha256").update(body).digest("hex");
+    const actualSha256 = createHash6("sha256").update(body).digest("hex");
     const lineageCandidates = lineageCandidatesByAttachmentId.get(attachmentId) ?? [];
     const lineage = selectAttachmentLineage(lineageCandidates, actualSha256);
     if (lineageCandidates.length > 0 && !lineage) {
@@ -7010,7 +7227,7 @@ async function materializeIssueAttachments(config, command, workspace) {
       id: attachmentId,
       name: readString(attachment.originalFilename) ?? filename,
       path: targetPath,
-      relativePath: relative5(workspace.cwd, targetPath),
+      relativePath: relative6(workspace.cwd, targetPath),
       contentType: readString(attachment.contentType),
       byteSize: body.byteLength,
       contentPath,
@@ -7060,7 +7277,7 @@ async function materializeRequiredArtifactInputs(config, command, workspace) {
     throw new Error("artifact_input_manifest_invalid: expected version 1 entries array");
   }
   const targetRoot = join10(workspace.cwd, "input-artifacts");
-  rmSync4(targetRoot, { recursive: true, force: true });
+  rmSync5(targetRoot, { recursive: true, force: true });
   mkdirSync5(targetRoot, { recursive: true });
   const usedPaths = /* @__PURE__ */ new Set();
   const materialized = [];
@@ -7079,7 +7296,7 @@ async function materializeRequiredArtifactInputs(config, command, workspace) {
       throw new Error(`artifact_input_manifest_invalid: entry ${index} contentPath does not match attachmentId`);
     }
     const body = await runtimeApiBuffer(runtimeAuth, contentPath);
-    const actualSha256 = createHash5("sha256").update(body).digest("hex");
+    const actualSha256 = createHash6("sha256").update(body).digest("hex");
     if (body.byteLength !== byteSize || actualSha256 !== sha256) {
       throw new Error(
         `artifact_input_integrity_mismatch: workProductId=${workProductId} expectedBytes=${byteSize} actualBytes=${body.byteLength} expectedSha256=${sha256} actualSha256=${actualSha256}`
@@ -7136,53 +7353,56 @@ function issueCheckpointDir(workspace) {
 async function clearIssueCheckpoint(config, command, workspace, reason) {
   const checkpointDir = issueCheckpointDir(workspace);
   if (!existsSync9(checkpointDir)) return false;
-  rmSync4(checkpointDir, { recursive: true, force: true });
+  rmSync5(checkpointDir, { recursive: true, force: true });
   await ingestLog(config, command, "system", "info", "Cleared issue continuation checkpoint", { reason });
   return true;
 }
 function safeCheckpointRelativePath(rawPath) {
   const raw = String(rawPath ?? "").trim();
-  if (isAbsolute5(raw) || /^[A-Za-z]:[\\/]/.test(raw)) return null;
+  if (isAbsolute6(raw) || /^[A-Za-z]:[\\/]/.test(raw)) return null;
   const normalized = raw.split(/[\\/]+/).filter(Boolean).join("/");
   if (!normalized || normalized.startsWith("../") || normalized.split("/").some((segment) => segment.startsWith("."))) return null;
   if (normalized.startsWith("input-attachments/") || isRuntimeMetadataArtifactPath(normalized)) return null;
   return normalized;
 }
+function hashFileSha256(filePath) {
+  return createHash6("sha256").update(readFileSync7(filePath)).digest("hex");
+}
 async function materializeIssueCheckpoint(config, command, workspace) {
   const checkpointDir = issueCheckpointDir(workspace);
   const manifestPath = join10(checkpointDir, "manifest.json");
   if (!existsSync9(manifestPath)) return [];
   let manifest;
   try {
-    manifest = asRecord(JSON.parse(readFileSync6(manifestPath, "utf8")));
+    manifest = asRecord(JSON.parse(readFileSync7(manifestPath, "utf8")));
   } catch (err) {
-    rmSync4(checkpointDir, { recursive: true, force: true });
+    rmSync5(checkpointDir, { recursive: true, force: true });
     throw new Error(`invalid issue checkpoint manifest: ${err instanceof Error ? err.message : String(err)}`);
   }
   const expiresAt = Date.parse(readString(manifest.expiresAt) ?? "");
   if (!Number.isFinite(expiresAt) || expiresAt <= Date.now() || readString(manifest.issueId) !== commandIssueId(command)) {
-    rmSync4(checkpointDir, { recursive: true, force: true });
+    rmSync5(checkpointDir, { recursive: true, force: true });
     return [];
   }
   try {
     const files = Array.isArray(manifest.files) ? manifest.files : [];
     if (files.length > 20) throw new Error("issue checkpoint manifest exceeds the limit of 20 files");
-    const filesRoot = realpathSync2(join10(checkpointDir, "files"));
-    const workspaceRoot = realpathSync2(workspace.cwd);
+    const filesRoot = realpathSync3(join10(checkpointDir, "files"));
+    const workspaceRoot = realpathSync3(workspace.cwd);
     const validated = [];
     let totalBytes = 0;
     for (const rawFile of files) {
       const file = asRecord(rawFile);
       const relativePath = safeCheckpointRelativePath(readString(file.path));
       if (!relativePath) throw new Error("issue checkpoint manifest contains an invalid file path");
-      const sourceCandidate = resolve7(filesRoot, relativePath);
-      const target = resolve7(workspaceRoot, relativePath);
-      if (!pathWithin(sourceCandidate, filesRoot) || !pathWithin(target, workspaceRoot)) {
+      const sourceCandidate = resolve8(filesRoot, relativePath);
+      const target = resolve8(workspaceRoot, relativePath);
+      if (!pathWithin2(sourceCandidate, filesRoot) || !pathWithin2(target, workspaceRoot)) {
         throw new Error(`issue checkpoint path escapes its workspace: ${relativePath}`);
       }
       if (!existsSync9(sourceCandidate)) throw new Error(`issue checkpoint file is missing: ${relativePath}`);
-      const source = realpathSync2(sourceCandidate);
-      if (!pathWithin(source, filesRoot) || !statSync7(source).isFile()) {
+      const source = realpathSync3(sourceCandidate);
+      if (!pathWithin2(source, filesRoot) || !statSync7(source).isFile()) {
         throw new Error(`issue checkpoint source escapes its storage root: ${relativePath}`);
       }
       const expectedSha256 = readString(file.sha256);
@@ -7200,14 +7420,14 @@ async function materializeIssueCheckpoint(config, command, workspace) {
     const materialized = [];
     for (const { relativePath, source, target } of validated) {
       try {
-        lstatSync3(target);
+        lstatSync4(target);
         continue;
       } catch (err) {
         if (err?.code !== "ENOENT") throw err;
       }
       mkdirSync5(dirname6(target), { recursive: true });
-      const targetParent = realpathSync2(dirname6(target));
-      if (!pathWithin(targetParent, workspaceRoot)) {
+      const targetParent = realpathSync3(dirname6(target));
+      if (!pathWithin2(targetParent, workspaceRoot)) {
         throw new Error(`issue checkpoint target escapes its workspace: ${relativePath}`);
       }
       copyFileSync2(source, target);
@@ -7232,6 +7452,49 @@ async function materializeIssueCheckpoint(config, command, workspace) {
     throw restoreErr;
   }
 }
+async function saveIssueCheckpoint(config, command, workspace, candidates) {
+  const checkpointDir = issueCheckpointDir(workspace);
+  const filesDir = join10(checkpointDir, "files");
+  rmSync5(checkpointDir, { recursive: true, force: true });
+  mkdirSync5(filesDir, { recursive: true });
+  const files = [];
+  let totalBytes = 0;
+  const workspaceRoot = realpathSync3(workspace.cwd);
+  for (const candidate of candidates.slice(0, 20)) {
+    const relativePath = safeCheckpointRelativePath(candidate.rawPath);
+    const source = readString(candidate.filePath);
+    if (!relativePath || !source || !existsSync9(source) || !statSync7(source).isFile()) continue;
+    const ownedSource = realpathSync3(source);
+    if (!pathWithin2(ownedSource, workspaceRoot)) {
+      throw new Error(`issue checkpoint source escapes its execution workspace: ${relativePath}`);
+    }
+    const byteSize = statSync7(ownedSource).size;
+    if (byteSize <= 0 || totalBytes + byteSize > MAX_CHECKPOINT_BYTES) continue;
+    const target = resolve8(filesDir, relativePath);
+    if (!pathWithin2(target, filesDir)) continue;
+    mkdirSync5(dirname6(target), { recursive: true });
+    copyFileSync2(ownedSource, target);
+    totalBytes += byteSize;
+    files.push({ path: relativePath, byteSize, sha256: hashFileSha256(ownedSource) });
+  }
+  if (files.length === 0) {
+    rmSync5(checkpointDir, { recursive: true, force: true });
+    return null;
+  }
+  const manifest = {
+    version: 1,
+    issueId: commandIssueId(command),
+    sourceRunId: commandRunId(command),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    expiresAt: new Date(Date.now() + CHECKPOINT_TTL_MS).toISOString(),
+    totalBytes,
+    files
+  };
+  writeFileSync5(join10(checkpointDir, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
+`);
+  await ingestLog(config, command, "system", "warn", `Saved ${files.length} required deliverable(s) for continuation recovery`, manifest);
+  return manifest;
+}
 function piOutputUsageMetadataMissing(parsed) {
   const usage = parsed?.usage ?? {};
   const totalTokens = Number(usage.inputTokens ?? 0) + Number(usage.cachedInputTokens ?? 0) + Number(usage.outputTokens ?? 0);
@@ -7284,6 +7547,7 @@ async function executeRunCommand(config, command) {
       error: err instanceof Error ? err.message : String(err)
     });
   }
+  await ingestWorkspaceStatus(config, command, cwd);
   const promptCompilation = buildCommandPrompt(command, workspace, materializedAttachments, {
     executorKind: executor.kind,
     artifactVerifierCommands: config.artifactVerifierCommands
@@ -7429,7 +7693,7 @@ async function executeRunCommand(config, command) {
       }
     );
     await ingestCost(config, command, executor, parsed);
-    await ingestWorkspaceStatus(config, command, cwd);
+    const workspaceStatus = await ingestWorkspaceStatus(config, command, cwd);
     let nativeSessionRollout = null;
     let nativeSessionRolloutError = null;
     let nativeSessionRolloutCleanup = null;
@@ -7438,6 +7702,7 @@ async function executeRunCommand(config, command) {
       ...Array.isArray(parsed.mcpToolResults) ? parsed.mcpToolResults.map(asRecord) : [],
       ...liveOutputLogger.mcpToolResults().map(asRecord)
     ];
+    const runtimeArtifacts = await ingestRuntimeArtifacts(config, command, cwd, mcpToolResults);
     const shouldPreserveNativeSession = managedMcpProfile && parsed.sessionId && (execution.exitCode === 0 || execution.completionOutputType === "approval_required") && !execution.timedOut && execution.cancelled !== true && !execution.spawnError && ["codex", "pi"].includes(executor.kind) && mcpToolResults.some((result3) => readString(result3.status) === "approval_required");
     if (shouldPreserveNativeSession) {
       try {
@@ -7446,7 +7711,20 @@ async function executeRunCommand(config, command) {
           sessionId: parsed.sessionId,
           sourceWorkspacePath: workspace.sourceWorkspacePath
         });
-        nativeSessionRollout = { status: preservedRollout.status, sessionId: preservedRollout.sessionId };
+        const checkpoint = await saveIssueCheckpoint(
+          config,
+          command,
+          workspace,
+          workspaceStatus.artifacts.map((artifact) => ({
+            rawPath: artifact.relativePath,
+            filePath: resolve8(cwd, artifact.relativePath)
+          }))
+        );
+        nativeSessionRollout = {
+          status: preservedRollout.status,
+          sessionId: preservedRollout.sessionId,
+          ...checkpoint ? { checkpoint: { fileCount: checkpoint.files.length, totalBytes: checkpoint.totalBytes } } : {}
+        };
         await ingestLog(config, command, "system", "info", `Preserved ${executor.kind} session rollout for an approved action continuation`, {
           presentationKind: "managed_mcp_session_rollout",
           status: nativeSessionRollout.status,
@@ -7461,8 +7739,10 @@ async function executeRunCommand(config, command) {
         });
       }
     }
-    const approvedInvocationId = readString(nativeSessionRequest.invocationId);
-    const approvedContinuationSucceeded = nativeSessionRequest.mode === "governed_action_approval" && approvedInvocationId && mcpToolResults.some((result3) => readString(result3.invocationId) === approvedInvocationId && readString(result3.status) === "succeeded");
+    const approvedContinuationSucceeded = nativeSessionRequest.mode === "governed_action_approval" && approvedMcpInvocationSucceeded(mcpToolResults, nativeSessionRequest.invocationId);
+    if (approvedContinuationSucceeded) {
+      await clearIssueCheckpoint(config, command, workspace, "approved_action_succeeded");
+    }
     if (managedMcpProfile && executor.kind === "codex" && approvedContinuationSucceeded) {
       try {
         nativeSessionRolloutCleanup = cleanupRestoredManagedCodexSessionRollout(managedMcpProfile);
@@ -7537,6 +7817,7 @@ async function executeRunCommand(config, command) {
       summary: parsed.summary || (succeeded ? "Executor completed without a text summary." : ""),
       usage: parsed.usage,
       ...costUsage ? { costUsage } : {},
+      ...runtimeArtifacts.length > 0 ? { runtimeArtifacts } : {},
       outputTelemetry,
       contextManifest,
       stdout: truncateText(execution.stdout, 8e3),
@@ -7802,7 +8083,7 @@ async function runLoop(config) {
 ${message}
 `);
     }
-    await new Promise((resolve8) => setTimeout(resolve8, config.pollIntervalSeconds * 1e3));
+    await new Promise((resolve9) => setTimeout(resolve9, config.pollIntervalSeconds * 1e3));
   }
 }
 function help() {

package/dist/amaster-runtime.mjs

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
-import { closeSync, existsSync, mkdirSync, openSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { spawn, spawnSync } from "node:child_process";
 import { dirname, join, resolve } from "node:path";
 import { homedir, hostname } from "node:os";
 import { fileURLToPath } from "node:url";
 
-const CONNECTOR_VERSION = "0.1.0-beta.20";
+const CONNECTOR_VERSION = "0.1.0-beta.22";
 
 const CAPABILITIES = [
   "remote_registration",
@@ -277,8 +277,26 @@ function readState(config) {
   const statePath = config.AMASTER_DAEMON_STATE_FILE || join(configDir, "runtime-connector-state.json");
   if (!existsSync(statePath)) return {};
   try {
-    return JSON.parse(readFileSync(statePath, "utf8"));
+    const state = JSON.parse(readFileSync(statePath, "utf8"));
+    if (!state || typeof state !== "object" || Array.isArray(state)) {
+      throw new TypeError("runtime connector state must be a JSON object");
+    }
+    return state;
   } catch {
+    const timestamp = new Date().toISOString().replace(/\D/g, "").slice(0, 14);
+    const base = `${statePath}.corrupt-${timestamp}Z`;
+    let quarantinePath = base;
+    for (let suffix = 1; existsSync(quarantinePath); suffix += 1) {
+      quarantinePath = `${base}.${suffix}`;
+    }
+    try {
+      renameSync(statePath, quarantinePath);
+      process.stderr.write(`AMaster runtime state was invalid and quarantined at ${quarantinePath}\n`);
+    } catch (error) {
+      process.stderr.write(
+        `AMaster runtime state was invalid but could not be quarantined (${error?.code ?? "unknown error"})\n`,
+      );
+    }
     return {};
   }
 }
@@ -286,7 +304,16 @@ function readState(config) {
 function writeState(config, state) {
   const statePath = withDefaults(config).AMASTER_DAEMON_STATE_FILE || join(configDir, "runtime-connector-state.json");
   mkdirSync(dirname(statePath), { recursive: true });
-  writeFileSync(statePath, `${JSON.stringify(state, null, 2)}\n`);
+  const temporaryPath = `${statePath}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  try {
+    writeFileSync(temporaryPath, `${JSON.stringify(state, null, 2)}\n`, {
+      flag: "wx",
+      mode: 0o600,
+    });
+    renameSync(temporaryPath, statePath);
+  } finally {
+    rmSync(temporaryPath, { force: true });
+  }
 }
 
 function readPidInfo() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amaster.ai/employee-runtime-connector",
-  "version": "0.1.0-beta.20",
+  "version": "0.1.0-beta.22",
   "description": "AMaster Employee runtime connector CLI and daemon",
   "license": "MIT",
   "type": "module",