@amaster.ai/employee-runtime-connector 0.1.0-beta.41 → 0.1.0-beta.42

package/dist/amaster-runtime-daemon.mjs

@@ -2,10 +2,10 @@
 // MirrorX runtime connector daemon bundle.
 
 // src/amaster-runtime-daemon.mjs
-import { createHash as createHash8 } from "node:crypto";
-import { chmodSync as chmodSync5, copyFileSync as copyFileSync3, existsSync as existsSync11, lstatSync as lstatSync6, mkdirSync as mkdirSync7, readFileSync as readFileSync9, readdirSync as readdirSync8, realpathSync as realpathSync3, renameSync as renameSync4, rmSync as rmSync6, statSync as statSync7, symlinkSync as symlinkSync3, unlinkSync, writeFileSync as writeFileSync7 } from "node:fs";
+import { createHash as createHash9 } from "node:crypto";
+import { chmodSync as chmodSync6, copyFileSync as copyFileSync3, existsSync as existsSync12, lstatSync as lstatSync7, mkdirSync as mkdirSync8, readFileSync as readFileSync10, readdirSync as readdirSync8, realpathSync as realpathSync3, renameSync as renameSync5, rmSync as rmSync7, statSync as statSync7, symlinkSync as symlinkSync4, unlinkSync, writeFileSync as writeFileSync8 } 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 dirname8, extname as extname2, isAbsolute as isAbsolute7, join as join12, relative as relative7, resolve as resolve10 } from "node:path";
+import { basename as basename6, delimiter as delimiter2, dirname as dirname9, extname as extname2, isAbsolute as isAbsolute8, join as join13, relative as relative8, resolve as resolve11 } from "node:path";
 import { spawn, spawnSync as spawnSync5 } from "node:child_process";
 
 // src/amaster-runtime-daemon/common.mjs
@@ -1876,7 +1876,7 @@ var piManagedMcpProfileApi = (() => {
   const PROFILE_MARKER2 = ".amaster-managed-pi-profile.json";
   const SESSION_ROLLOUT_MARKER2 = ".amaster-pi-session-rollout.json";
   const DEFAULT_SESSION_ROLLOUT_TTL_MS2 = 24 * 60 * 60 * 1e3;
-  function record3(value) {
+  function record4(value) {
     return value && typeof value === "object" && !Array.isArray(value) ? value : {};
   }
   function npmPackageName(source) {
@@ -1889,7 +1889,7 @@ var piManagedMcpProfileApi = (() => {
     if (typeof value !== "string" || value.trim() === "") throw new Error(`pi_managed_mcp_invalid: ${label} is required`);
     return value.trim();
   }
-  function within3(candidate, root) {
+  function within4(candidate, root) {
     const rel = relative2(root, candidate);
     return rel === "" || !rel.startsWith("..") && !isAbsolute2(rel);
   }
@@ -1932,7 +1932,7 @@ var piManagedMcpProfileApi = (() => {
     return matches[0];
   }
   function restoreManagedPiSessionRollout(input, sessionsRoot, runDir, executorHome, authority) {
-    const session = record3(input.nativeSession);
+    const session = record4(input.nativeSession);
     if (session.mode !== "governed_action_approval" || session.required !== true) return null;
     const sessionId = nonEmpty2(session.sessionId, "nativeSession.sessionId");
     const sourceRunId = nonEmpty2(session.sourceRunId, "nativeSession.sourceRunId");
@@ -1956,11 +1956,11 @@ var piManagedMcpProfileApi = (() => {
       throw new Error("pi_managed_mcp_session_rollout_authority_mismatch: source rollout does not match the approved continuation");
     }
     const sourceRollout = resolve2(cacheRoot, nonEmpty2(marker.rolloutRelativePath, "rolloutRelativePath"));
-    if (!within3(sourceRollout, cacheRoot) || lstatSync2(sourceRollout).isSymbolicLink() || !lstatSync2(sourceRollout).isFile()) {
+    if (!within4(sourceRollout, cacheRoot) || lstatSync2(sourceRollout).isSymbolicLink() || !lstatSync2(sourceRollout).isFile()) {
       throw new Error("pi_managed_mcp_session_rollout_unsafe: source rollout path is invalid");
     }
     const targetRollout = resolve2(sessionsRoot, marker.rolloutRelativePath);
-    if (!within3(targetRollout, sessionsRoot)) {
+    if (!within4(targetRollout, sessionsRoot)) {
       throw new Error("pi_managed_mcp_session_rollout_unsafe: target rollout path is invalid");
     }
     mkdirSync3(dirname3(targetRollout), { recursive: true, mode: 448 });
@@ -1982,8 +1982,8 @@ var piManagedMcpProfileApi = (() => {
     return tuple.join(".");
   }
   function validateAuthority2(input) {
-    const runtimeAuth = record3(input.runtimeAuth);
-    const gateway = record3(runtimeAuth.governedMcp);
+    const runtimeAuth = record4(input.runtimeAuth);
+    const gateway = record4(runtimeAuth.governedMcp);
     const runId = nonEmpty2(input.runId, "runId");
     if (runtimeAuth.runId !== runId) throw new Error("pi_managed_mcp_owner_mismatch: command runId does not match runtime authority");
     if (gateway.schemaVersion !== SUPPORTED_SCHEMA_VERSION2) throw new Error("pi_managed_mcp_invalid: unsupported schema version");
@@ -1999,7 +1999,7 @@ var piManagedMcpProfileApi = (() => {
     if (!Number.isFinite(expiresAt) || expiresAt <= Date.now() + 3e4) {
       throw new Error("pi_managed_mcp_session_expired: Gateway session must remain valid through spawn preflight");
     }
-    const headers = record3(gateway.headers);
+    const headers = record4(gateway.headers);
     for (const name of REQUIRED_AUTHORITY_HEADERS2) nonEmpty2(headers[name], `headers.${name}`);
     const allowedHeaderNames = /* @__PURE__ */ new Set([...REQUIRED_AUTHORITY_HEADERS2, ...runtimeAuth.issueId ? ["x-amaster-issue-id"] : []]);
     if (Object.keys(headers).some((name) => !allowedHeaderNames.has(name)) || Object.keys(headers).length !== allowedHeaderNames.size) {
@@ -2028,7 +2028,7 @@ var piManagedMcpProfileApi = (() => {
     return output;
   }
   function assertInvocationIsolation2(input) {
-    for (const name of Object.keys(record3(input.commandEnv))) {
+    for (const name of Object.keys(record4(input.commandEnv))) {
       if (FORBIDDEN_COMMAND_ENV2.has(name)) throw new Error(`pi_managed_mcp_env_override_blocked: ${name}`);
       if (!ALLOWED_COMMAND_ENV2.has(name)) throw new Error(`pi_managed_mcp_env_injection_blocked: ${name}`);
     }
@@ -2060,7 +2060,7 @@ var piManagedMcpProfileApi = (() => {
       const value = safeProxyValue2(baseEnv?.[name], name);
       if (value) env[name] = value;
     }
-    return { ...env, ...record3(commandEnv) };
+    return { ...env, ...record4(commandEnv) };
   }
   function projectMcpConfigHasContent(filePath) {
     if (!existsSync3(filePath)) return false;
@@ -2070,14 +2070,14 @@ var piManagedMcpProfileApi = (() => {
     } catch {
       return true;
     }
-    const config = record3(parsed);
-    return Object.keys(record3(config.mcpServers)).length > 0 || Object.keys(record3(config.servers)).length > 0 || Array.isArray(config.imports) && config.imports.length > 0;
+    const config = record4(parsed);
+    return Object.keys(record4(config.mcpServers)).length > 0 || Object.keys(record4(config.servers)).length > 0 || Array.isArray(config.imports) && config.imports.length > 0;
   }
   function assertNoProjectMcpOverride(cwd, runDir) {
     let cursor = resolve2(cwd);
     const boundary = resolve2(runDir);
-    if (!within3(cursor, boundary)) throw new Error("pi_managed_mcp_owner_mismatch: cwd is outside the managed run");
-    while (within3(cursor, boundary)) {
+    if (!within4(cursor, boundary)) throw new Error("pi_managed_mcp_owner_mismatch: cwd is outside the managed run");
+    while (within4(cursor, boundary)) {
       for (const relativePath of [".mcp.json", join4(".pi", "mcp.json")]) {
         const configPath = join4(cursor, relativePath);
         if (projectMcpConfigHasContent(configPath)) throw new Error(`pi_managed_mcp_project_override_blocked: ${configPath}`);
@@ -2087,7 +2087,7 @@ var piManagedMcpProfileApi = (() => {
     }
   }
   function selectManagedBrowserUse(sourceSettings, npmSource) {
-    const plugin = record3(record3(sourceSettings.plugins)[MANAGED_BROWSER_USE_PLUGIN]);
+    const plugin = record4(record4(sourceSettings.plugins)[MANAGED_BROWSER_USE_PLUGIN]);
     if (plugin.enabled !== true || plugin.package !== MANAGED_BROWSER_USE_PACKAGE) return null;
     const packageSpec = Array.isArray(sourceSettings.packages) ? sourceSettings.packages.find((entry) => npmPackageName(entry) === MANAGED_BROWSER_USE_PACKAGE) : null;
     if (typeof packageSpec !== "string") return null;
@@ -2104,7 +2104,7 @@ var piManagedMcpProfileApi = (() => {
     if (packageMetadata.name !== MANAGED_BROWSER_USE_PACKAGE) {
       throw new Error(`pi_managed_mcp_attestation_failed: enabled ${MANAGED_BROWSER_USE_PACKAGE} package identity mismatch`);
     }
-    const sourceConfig = record3(sourceSettings["pi-browser-use"]);
+    const sourceConfig = record4(sourceSettings["pi-browser-use"]);
     const config = {};
     for (const key of MANAGED_BROWSER_USE_BOOLEAN_SETTINGS) {
       if (typeof sourceConfig[key] === "boolean") config[key] = sourceConfig[key];
@@ -2148,7 +2148,7 @@ var piManagedMcpProfileApi = (() => {
     }
     return {
       packageSpec,
-      config: record3(sourceSettings["pi-telemetry"])
+      config: record4(sourceSettings["pi-telemetry"])
     };
   }
   function seedPiRuntime(sourceHome, agentDir) {
@@ -2169,7 +2169,7 @@ var piManagedMcpProfileApi = (() => {
     let sourceSettings = {};
     if (existsSync3(settingsSource)) {
       try {
-        sourceSettings = record3(JSON.parse(readFileSync3(settingsSource, "utf8")));
+        sourceSettings = record4(JSON.parse(readFileSync3(settingsSource, "utf8")));
       } catch {
         throw new Error("pi_managed_mcp_attestation_failed: source Pi settings are invalid");
       }
@@ -2238,7 +2238,7 @@ ${result2.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
     const { gateway, gatewayUrl, sessionToken, headers, runId } = validateAuthority2(input);
     const runDir = resolve2(nonEmpty2(input.runDir, "runDir"));
     const executorHome = resolve2(nonEmpty2(input.executorHome, "executorHome"));
-    if (!within3(executorHome, join4(runDir, "executors"))) throw new Error("pi_managed_mcp_owner_mismatch: executorHome is outside the managed run");
+    if (!within4(executorHome, join4(runDir, "executors"))) throw new Error("pi_managed_mcp_owner_mismatch: executorHome is outside the managed run");
     assertNoProjectMcpOverride(nonEmpty2(input.cwd, "cwd"), runDir);
     const profileRoot = join4(executorHome, "managed-mcp");
     if (existsSync3(profileRoot)) throw new Error(`pi_managed_mcp_profile_exists: ${profileRoot}`);
@@ -2253,7 +2253,7 @@ ${result2.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
       const owner = Object.freeze({ commandId: input.commandId, runId });
       writePrivateFile2(markerPath, `${JSON.stringify({ version: 1, ...owner, profileRoot })}
 `);
-      const runtimeAuth = record3(input.runtimeAuth);
+      const runtimeAuth = record4(input.runtimeAuth);
       const authority = Object.freeze({
         companyId: nonEmpty2(runtimeAuth.companyId, "runtimeAuth.companyId"),
         agentId: nonEmpty2(runtimeAuth.agentId, "runtimeAuth.agentId"),
@@ -2408,7 +2408,7 @@ ${result2.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
       const profileRoot = dirname3(markerPath);
       try {
         const marker = JSON.parse(readFileSync3(markerPath, "utf8"));
-        if (!within3(profileRoot, root) || marker?.profileRoot !== profileRoot) throw new Error("ownership marker root mismatch");
+        if (!within4(profileRoot, root) || marker?.profileRoot !== profileRoot) throw new Error("ownership marker root mismatch");
         cleanupManagedPiMcpProfile2({ profileRoot }, { commandId: marker.commandId, runId: marker.runId });
         removedProfiles += 1;
       } catch (error) {
@@ -2423,7 +2423,7 @@ ${result2.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
         const markerStat = lstatSync2(markerPath);
         const cacheStat = lstatSync2(cacheRoot);
         const marker = JSON.parse(readFileSync3(markerPath, "utf8"));
-        if (!within3(cacheRoot, root) || basename2(cacheRoot) !== "session-rollout" || markerStat.isSymbolicLink() || !markerStat.isFile() || cacheStat.isSymbolicLink() || !cacheStat.isDirectory() || marker?.version !== 1 || typeof marker?.companyId !== "string" || typeof marker?.agentId !== "string" || typeof marker?.sourceRunId !== "string" || typeof marker?.sourceCommandId !== "string" || typeof marker?.sessionId !== "string" || marker?.cacheRoot !== cacheRoot) throw new Error("session rollout ownership marker mismatch");
+        if (!within4(cacheRoot, root) || basename2(cacheRoot) !== "session-rollout" || markerStat.isSymbolicLink() || !markerStat.isFile() || cacheStat.isSymbolicLink() || !cacheStat.isDirectory() || marker?.version !== 1 || typeof marker?.companyId !== "string" || typeof marker?.agentId !== "string" || typeof marker?.sourceRunId !== "string" || typeof marker?.sourceCommandId !== "string" || typeof marker?.sessionId !== "string" || marker?.cacheRoot !== cacheRoot) throw new Error("session rollout ownership marker mismatch");
         const preservedAtMs = typeof marker.preservedAt === "string" ? Date.parse(marker.preservedAt) : Number.NaN;
         const markerAgeMs = nowMs - (Number.isFinite(preservedAtMs) ? preservedAtMs : markerStat.mtimeMs);
         if (markerAgeMs < rolloutTtlMs) continue;
@@ -2511,14 +2511,42 @@ function signalExecutorProcess(child, signal, processGroupId = processGroupIdFor
   return false;
 }
 
+// src/amaster-runtime-daemon/executor-spawn.mjs
+function record2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function managedChildSpawnInvocation(command, args, requestedIdentity) {
+  const identity = record2(requestedIdentity);
+  const childUmask = identity.umask;
+  if (childUmask !== void 0 && (!Number.isInteger(childUmask) || childUmask < 0 || childUmask > 511)) {
+    throw new Error("executor_spawn_umask_invalid");
+  }
+  const spawnIdentity = { ...identity };
+  delete spawnIdentity.umask;
+  if (childUmask === void 0) {
+    return { command, args, spawnIdentity };
+  }
+  return {
+    command: "/bin/sh",
+    args: [
+      "-c",
+      `umask ${childUmask.toString(8).padStart(4, "0")}; exec "$@"`,
+      "amaster-managed-child",
+      command,
+      ...args
+    ],
+    spawnIdentity
+  };
+}
+
 // src/amaster-runtime-daemon/durability.mjs
 function resultOutboxFileName(commandId, now = Date.now()) {
   const safeCommandId = String(commandId ?? "command").replace(/[^a-zA-Z0-9._-]/g, "_");
   return `${now}-${safeCommandId}.json`;
 }
 function isValidResultOutboxEntry(entry) {
-  const record3 = asRecord(entry);
-  return record3.version === 1 && Boolean(readString(record3.path)) && Object.keys(asRecord(record3.payload)).length > 0;
+  const record4 = asRecord(entry);
+  return record4.version === 1 && Boolean(readString(record4.path)) && Object.keys(asRecord(record4.payload)).length > 0;
 }
 function resultOutboxEntryAgeMs(entry, nowMs) {
   const createdAt = Date.parse(readString(entry.createdAt) ?? "");
@@ -2539,6 +2567,15 @@ var RECOVERY_WAKE_REASONS = /* @__PURE__ */ new Set([
 function isRecoveryWakeReason(wakeReason) {
   return RECOVERY_WAKE_REASONS.has(wakeReason);
 }
+function stringifyBoundedJson(value, maxChars = 24e3) {
+  let text = "";
+  try {
+    text = JSON.stringify(value, null, 2);
+  } catch {
+    text = String(value);
+  }
+  return truncateText(text, maxChars);
+}
 function jsonText(value) {
   return JSON.stringify(value, null, 2);
 }
@@ -2596,8 +2633,8 @@ function governedReadSection(context) {
   const reads = Array.isArray(context.governedReadResults) ? context.governedReadResults : [];
   if (reads.length === 0) return { content: "", provenance: [] };
   const normalized = reads.map((entry, index) => {
-    const record3 = asRecord(entry);
-    const receipt = asRecord(record3.receipt);
+    const record4 = asRecord(entry);
+    const receipt = asRecord(record4.receipt);
     const provider = readString(receipt.provider) ?? readString(receipt.transport);
     const operation = readString(receipt.operation);
     const observedAt = readString(receipt.retrievedAt) ?? readString(receipt.observedAt);
@@ -2607,7 +2644,7 @@ function governedReadSection(context) {
       throw new Error(`governed_read_context_provenance_invalid: entry ${index} requires provider, operation, observedAt, and source`);
     }
     return {
-      content: record3.content,
+      content: record4.content,
       receipt: {
         provider,
         operation,
@@ -2640,6 +2677,7 @@ function fixedRules(input, includeIssueLine) {
     `- command id: ${input.commandId}`,
     `- run id: ${input.runId ?? "unknown"}`,
     `- issue id: ${input.issueId ?? "unknown"}`,
+    input.currentDate ? `- current date: ${input.currentDate}` : "",
     includeIssueLine && input.issueLine ? `- issue: ${input.issueLine}` : "",
     `- workspace: ${input.cwd}`,
     input.managed ? `- source workspace: ${input.sourceWorkspacePath}` : "",
@@ -2656,6 +2694,17 @@ function approvalContinuationText(input) {
     "Do not advance to another write action until that exact call returns status succeeded."
   ].join("\n");
 }
+function interactionResolutionText(context) {
+  const direct = asRecord(context.interactionResolution);
+  const wakeResolution = asRecord(asRecord(context.paperclipWake).interactionResolution);
+  const resolution = Object.keys(direct).length > 0 ? direct : wakeResolution;
+  if (Object.keys(resolution).length === 0) return "";
+  return [
+    "Treat this resolved interaction as the authoritative delta for this run.",
+    readString(resolution.status) === "changes_requested" ? "Apply every requested change before creating a replacement review." : "",
+    stringifyBoundedJson(resolution, 8e3)
+  ].filter(Boolean).join("\n");
+}
 function recoveryInstructionText(input) {
   const context = asRecord(input.context);
   if (input.wakeReason === "finish_successful_run_handoff" && context.handoffRequired === true) {
@@ -2663,6 +2712,8 @@ function recoveryInstructionText(input) {
       "The prior successful run did not leave a terminal task disposition.",
       "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: done, in_review, input, blocked, delegated, or queued.",
+      "If more work remains on this issue, call `update_parent` with `status: todo`, preserve the current agent owner, and record the concrete next action.",
+      "Do not keep or write `in_progress`: only the actual `todo` issue update is a recognized resume disposition and lets the control plane queue a normal-model continuation.",
       "Record the disposition with its concrete owner or next action and update the task accordingly."
     ].join("\n");
   }
@@ -2697,6 +2748,28 @@ function runtimeAuthorizationText(context) {
     "Never use request_confirmation to authorize a runtime action class."
   ].join("\n");
 }
+function runtimeDecompositionRequirementText(context) {
+  const issue = asRecord(context.paperclipIssue);
+  const requirements = asRecord(issue.taskRequirements);
+  const decomposition = asRecord(requirements.decomposition);
+  if (decomposition.mode !== "required") return "";
+  const children = Array.isArray(context.childIssueSummaries) ? context.childIssueSummaries : [];
+  if (children.length > 0) return "";
+  const source = asRecord(decomposition.source);
+  const sourceType = readString(source.type);
+  const sourceId = readString(source.id);
+  const sourceRevision = readString(source.revision);
+  if (!sourceType || !sourceId || !sourceRevision) {
+    throw new Error("runtime_decomposition_requirement_invalid: required mode needs typed source provenance");
+  }
+  return [
+    "This issue has a server-enforced typed decomposition requirement.",
+    "Create real direct child tasks before continuing substantial source work.",
+    "Each executable child must have an owner, dependencies where needed, and acceptance criteria. Do not create probe or test children.",
+    "Preserve every parent safety and approval boundary in each child title, description, and acceptance criteria. If the parent prohibits registration, payment, booking, or external contact without later explicit authorization, create preparation or approval only children and do not assign the prohibited action.",
+    `Requirement source: ${sourceType}:${sourceId}@${sourceRevision}`
+  ].join("\n");
+}
 function sectionText(section) {
   if (!section.content) return "";
   return section.title ? `## ${section.title}
@@ -2766,6 +2839,15 @@ function compileCommandPromptWithManifest(input, options = {}) {
   const wakeBodies = commentBodies(context);
   const commentsDuplicatedByTask = hasTask && wakeBodies.length > 0 && wakeBodies.every((body) => taskText.includes(body));
   const commentsSelected = mode !== "cold" || !commentsDuplicatedByTask;
+  const interactionResolution = interactionResolutionText(context);
+  const selectedComments = commentsSelected ? readString(input.comments) ?? "" : "";
+  const wakeDeltaContent = [interactionResolution, selectedComments].filter(Boolean).join("\n\n");
+  const wakeDeltaOriginal = [interactionResolution, readString(input.comments) ?? ""].filter(Boolean).join("\n\n");
+  const wakeDeltaTitle = interactionResolution ? selectedComments ? "Wake Delta" : "Resolved Interaction Input" : "Wake Comment Delta";
+  const wakeDeltaSourceRefs = [
+    ...readString(context.interactionId) ? [`interaction:${readString(context.interactionId)}`] : [],
+    ...commentRefs(context).map((id) => `comment:${id}`)
+  ];
   const contextScope = {
     companyId: readString(asRecord(context.paperclipCompany).id),
     issueId: input.issueId ?? null
@@ -2776,8 +2858,9 @@ function compileCommandPromptWithManifest(input, options = {}) {
     { name: "recovery_instruction", title: "Recovery Instruction", priority: 99, sourceRef: `run:${input.runId ?? "unknown"}`, content: recoveryInstructionText(input), truncationReason: isRecoveryWakeReason(input.wakeReason) ? null : "mode_selection" },
     { 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: "runtime_authorization", title: "Runtime Action Authorization", priority: 98, sourceRef: `run:${input.runId ?? "unknown"}`, content: runtimeAuthorizationText(context) },
+    { name: "runtime_decomposition_requirement", title: "Required Task Decomposition", priority: 98, sourceRef: `issue:${input.issueId ?? "unknown"}`, content: runtimeDecompositionRequirementText(context) },
     { 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: "wake_comments", title: wakeDeltaTitle, priority: interactionResolution ? 99 : 95, sourceRef: wakeDeltaSourceRefs, originalContent: wakeDeltaOriginal, content: wakeDeltaContent, truncationReason: commentsSelected ? null : "duplicate_task_context" },
     { 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) ?? "" },
@@ -3147,10 +3230,10 @@ function compactExecutorJsonlForTranscript(event) {
     const text = JSON.stringify(compactExecutorJsonValue(event, stringMaxChars));
     if (text.length <= 15e3) return text;
   }
-  const record3 = tcAsRecord(event);
-  const item = tcAsRecord(record3.item);
+  const record4 = tcAsRecord(event);
+  const item = tcAsRecord(record4.item);
   return JSON.stringify({
-    type: tcReadString(record3.type) ?? "executor.event",
+    type: tcReadString(record4.type) ?? "executor.event",
     item: item.type ? {
       id: tcReadString(item.id),
       type: tcReadString(item.type),
@@ -3163,10 +3246,10 @@ function compactExecutorJsonlForTranscript(event) {
   });
 }
 function summarizeTokenUsage(usage) {
-  const record3 = tcAsRecord(usage);
-  const inputTokens = tcReadNumber(record3.input_tokens ?? record3.inputTokens, 0);
-  const cachedInputTokens = tcReadNumber(record3.cached_input_tokens ?? record3.cachedInputTokens, 0);
-  const outputTokens = tcReadNumber(record3.output_tokens ?? record3.outputTokens, 0);
+  const record4 = tcAsRecord(usage);
+  const inputTokens = tcReadNumber(record4.input_tokens ?? record4.inputTokens, 0);
+  const cachedInputTokens = tcReadNumber(record4.cached_input_tokens ?? record4.cachedInputTokens, 0);
+  const outputTokens = tcReadNumber(record4.output_tokens ?? record4.outputTokens, 0);
   const parts = [];
   if (inputTokens > 0) parts.push(`\u8F93\u5165 ${inputTokens}`);
   if (cachedInputTokens > 0) parts.push(`\u7F13\u5B58 ${cachedInputTokens}`);
@@ -3421,8 +3504,8 @@ function summarizeClaudeEvent(event) {
   return null;
 }
 function tcPiMessageText(message) {
-  const record3 = tcAsRecord(message);
-  const content = record3.content;
+  const record4 = tcAsRecord(message);
+  const content = record4.content;
   if (typeof content === "string" && content.trim().length > 0) return content.trim();
   if (!Array.isArray(content)) return "";
   return content.map((entry) => {
@@ -3436,14 +3519,14 @@ function tcPiAssistantMessageEventText(assistantMessageEvent) {
   return tcReadString(event.content) ?? "";
 }
 function tcPiMessageStopReason(message) {
-  const record3 = tcAsRecord(message);
-  return tcReadString(record3.stopReason ?? record3.stop_reason);
+  const record4 = tcAsRecord(message);
+  return tcReadString(record4.stopReason ?? record4.stop_reason);
 }
 function tcPiMessageErrorText(message) {
-  const record3 = tcAsRecord(message);
-  const explicitError = tcReadString(record3.errorMessage ?? record3.error_message)?.trim();
+  const record4 = tcAsRecord(message);
+  const explicitError = tcReadString(record4.errorMessage ?? record4.error_message)?.trim();
   if (explicitError) return explicitError;
-  const stopReason = tcPiMessageStopReason(record3);
+  const stopReason = tcPiMessageStopReason(record4);
   if (stopReason === "error" || stopReason === "failed" || stopReason === "exception") {
     return `Pi Agent message ended with stopReason=${stopReason}`;
   }
@@ -3603,6 +3686,10 @@ 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;
+var PI_PROVIDER_AUTH_RE = /(?:(?:\b401\b|\b403\b)[^\n]*(?:unauthorized|forbidden|auth(?:entication|orization)?|api[_\s-]?key)|(?:invalid|missing|expired|revoked)\s+(?:provider\s+)?api[_\s-]?key|provider\s+authentication\s+required)/i;
+var PI_PROVIDER_TRANSIENT_RE = /(?:\b(?:429|5\d{2})\b|rate[-\s]?limit(?:ed)?|too\s+many\s+requests|billing\s+admission\s+failed|service\s+unavailable|upstream[^\n]*(?:unavailable|failed|timeout)|connect(?:ion)?[^\n]*refused|temporar(?:y|ily)[^\n]*(?:unavailable|failed)|try\s+again\s+later)/i;
+var PI_PROVIDER_RETRY_AFTER_SECONDS_RE = /retry[-\s]?after\s*[:=]?\s*(\d{1,6})\s*(?:seconds?|secs?|s)\b/i;
+var MAX_PI_PROVIDER_RETRY_AFTER_SECONDS = 7 * 24 * 60 * 60;
 function approvedMcpInvocationSucceeded(results, invocationId) {
   const approvedInvocationId = readString(invocationId);
   return Boolean(approvedInvocationId && (Array.isArray(results) ? results : []).some((rawResult) => {
@@ -3817,6 +3904,32 @@ function classifyCodexTransientUpstreamError(input, now = /* @__PURE__ */ new Da
     ...retryNotBefore ? { retryNotBefore: retryNotBefore.toISOString() } : {}
   };
 }
+function extractPiProviderRetryNotBefore(errorMessage, now) {
+  const retryAfter = errorMessage.match(PI_PROVIDER_RETRY_AFTER_SECONDS_RE);
+  if (!retryAfter) return null;
+  const seconds = Number.parseInt(retryAfter[1] ?? "", 10);
+  if (!Number.isSafeInteger(seconds) || seconds < 0 || seconds > MAX_PI_PROVIDER_RETRY_AFTER_SECONDS) {
+    return null;
+  }
+  return new Date(now.getTime() + seconds * 1e3);
+}
+function classifyPiProviderError(input, now = /* @__PURE__ */ new Date()) {
+  const errorMessage = readString(asRecord(input).errorMessage);
+  if (!errorMessage) return null;
+  if (PI_PROVIDER_AUTH_RE.test(errorMessage)) {
+    return {
+      errorCode: "pi_provider_auth_required",
+      errorFamily: "configuration"
+    };
+  }
+  if (!PI_PROVIDER_TRANSIENT_RE.test(errorMessage)) return null;
+  const retryNotBefore = extractPiProviderRetryNotBefore(errorMessage, now);
+  return {
+    errorCode: "pi_transient_upstream",
+    errorFamily: "transient_upstream",
+    ...retryNotBefore ? { retryNotBefore: retryNotBefore.toISOString() } : {}
+  };
+}
 function parseClaudeStreamJson(stdout) {
   let sessionId = null;
   let summary = "";
@@ -3863,13 +3976,13 @@ function parseClaudeStreamJson(stdout) {
 }
 function openCodeErrorText(value) {
   if (typeof value === "string") return value;
-  const record3 = asRecord(value);
-  const message = readString(record3.message);
+  const record4 = asRecord(value);
+  const message = readString(record4.message);
   if (message) return message;
-  const data = asRecord(record3.data);
+  const data = asRecord(record4.data);
   const nestedMessage = readString(data.message);
   if (nestedMessage) return nestedMessage;
-  return readString(record3.name) ?? readString(record3.code) ?? "";
+  return readString(record4.name) ?? readString(record4.code) ?? "";
 }
 function parseOpenCodeJsonl(stdout) {
   let sessionId = null;
@@ -3907,8 +4020,8 @@ function parseOpenCodeJsonl(stdout) {
   return { sessionId, summary, usage, errorMessage };
 }
 function piMessageText(message) {
-  const record3 = asRecord(message);
-  const content = record3.content;
+  const record4 = asRecord(message);
+  const content = record4.content;
   if (typeof content === "string") return content.trim();
   if (!Array.isArray(content)) return "";
   return content.map((entry) => {
@@ -3933,10 +4046,10 @@ function piTextValue(value) {
   return typeof value === "string" && value.length > 0 ? value : "";
 }
 function piAssistantEventText(assistantEvent) {
-  const record3 = asRecord(assistantEvent);
-  const type = readString(record3.type);
-  if (type === "text_delta") return piTextValue(record3.delta);
-  if (type === "text_end") return piTextValue(record3.content);
+  const record4 = asRecord(assistantEvent);
+  const type = readString(record4.type);
+  if (type === "text_delta") return piTextValue(record4.delta);
+  if (type === "text_end") return piTextValue(record4.content);
   return "";
 }
 function piMessageUsage(message) {
@@ -3957,14 +4070,14 @@ function assignPiUsage(target, source) {
   if (source.costUsd > 0) target.costUsd = source.costUsd;
 }
 function piMessageStopReason(message) {
-  const record3 = asRecord(message);
-  return readString(record3.stopReason ?? record3.stop_reason);
+  const record4 = asRecord(message);
+  return readString(record4.stopReason ?? record4.stop_reason);
 }
 function piMessageErrorText(message) {
-  const record3 = asRecord(message);
-  const explicitError = readString(record3.errorMessage ?? record3.error_message)?.trim();
+  const record4 = asRecord(message);
+  const explicitError = readString(record4.errorMessage ?? record4.error_message)?.trim();
   if (explicitError) return explicitError;
-  const stopReason = piMessageStopReason(record3);
+  const stopReason = piMessageStopReason(record4);
   if (stopReason === "error" || stopReason === "failed" || stopReason === "exception") {
     return `Pi Agent message ended with stopReason=${stopReason}`;
   }
@@ -4256,7 +4369,7 @@ async function postRuntimeConnectorJsonWithRetry(config, path, payload, options
     } catch (error) {
       lastError = error;
       if (attempt >= maxAttempts || !retryableRuntimeConnectorPost(error)) throw error;
-      if (delayMs > 0) await new Promise((resolve11) => setTimeout(resolve11, delayMs));
+      if (delayMs > 0) await new Promise((resolve12) => setTimeout(resolve12, delayMs));
     }
   }
   throw lastError;
@@ -4340,14 +4453,25 @@ function prepareRuntimeArtifactUploads(cwd, mcpToolResults) {
 }
 
 // src/amaster-runtime-daemon/runtime-artifact-ingest-queue.mjs
+function normalizedError(caught) {
+  return caught instanceof Error ? caught : new Error(String(caught));
+}
+var RuntimeArtifactIngestAggregateError = class extends AggregateError {
+  constructor(errors, receipts) {
+    super(errors, `${errors.length} Runtime Artifact ingest operation(s) failed`);
+    this.name = "RuntimeArtifactIngestAggregateError";
+    this.code = errors.some((error) => error.code === "runtime_artifact_rejected") ? "runtime_artifact_rejected" : "runtime_artifact_ingest_failed";
+    this.failures = [...errors];
+    this.receipts = [...receipts];
+  }
+};
 function createRuntimeArtifactIngestQueue({ ingest, onError }) {
   const handledIntentIds = /* @__PURE__ */ new Set();
   const artifacts = [];
-  let error = null;
+  const errors = [];
   let queue = Promise.resolve();
   return {
     enqueue(results) {
-      if (error) return;
       const pending = results.filter((result2) => {
         const intentId = readString(asRecord(result2).artifactIntent?.intentId);
         if (!intentId || handledIntentIds.has(intentId)) return false;
@@ -4356,8 +4480,12 @@ function createRuntimeArtifactIngestQueue({ ingest, onError }) {
       });
       if (pending.length === 0) return;
       queue = queue.then(async () => artifacts.push(...await ingest(pending))).catch((caught) => {
-        error ??= caught;
-        onError?.(caught);
+        const aggregate = caught instanceof RuntimeArtifactIngestAggregateError ? caught : null;
+        artifacts.push(...aggregate?.receipts ?? []);
+        for (const error of aggregate?.failures ?? [normalizedError(caught)]) {
+          errors.push(error);
+          onError?.(error);
+        }
       });
     },
     hasHandled(intentId) {
@@ -4365,7 +4493,9 @@ function createRuntimeArtifactIngestQueue({ ingest, onError }) {
     },
     async flush() {
       await queue;
-      if (error) throw error;
+      if (errors.length > 0) {
+        throw new RuntimeArtifactIngestAggregateError(errors, artifacts);
+      }
       return [...artifacts];
     }
   };
@@ -4895,18 +5025,24 @@ function createPiChildIdentityAllocator(input = {}) {
   const runAssignments = /* @__PURE__ */ new Map();
   const uidAssignments = /* @__PURE__ */ new Map();
   return {
-    acquire(runId) {
+    acquire(runId, options = {}) {
       if (typeof runId !== "string" || runId.trim().length === 0) {
         throw new Error("pi_child_isolation_run_id_required");
       }
       const normalizedRunId = runId.trim();
       const existing = runAssignments.get(normalizedRunId);
-      if (existing) return { ...existing };
+      const requestedGid = options.gid === void 0 ? null : positiveInteger(options.gid, "gid");
+      if (existing) {
+        if (requestedGid !== null && existing.gid !== requestedGid) {
+          throw new Error("pi_child_isolation_run_gid_mismatch");
+        }
+        return { ...existing };
+      }
       const initialOffset = Math.abs(hashRunId(normalizedRunId)) % uidSpan;
       for (let attempt = 0; attempt < uidSpan; attempt += 1) {
         const uid = uidBase + (initialOffset + attempt) % uidSpan;
         if (uidAssignments.has(uid)) continue;
-        const assignment = { uid, gid: uid };
+        const assignment = { uid, gid: requestedGid ?? uid };
         runAssignments.set(normalizedRunId, assignment);
         uidAssignments.set(uid, normalizedRunId);
         return { ...assignment };
@@ -4945,7 +5081,9 @@ function preparePiChildIsolation(input) {
   if (!isWithin(input.profileRoot, input.allowedRoot) || !isWithin(input.workspaceRoot, input.allowedRoot)) {
     throw new Error("pi_child_isolation_path_outside_run_root");
   }
-  const assignment = input.allocator.acquire(input.runId);
+  const assignment = input.allocator.acquire(input.runId, {
+    ...input.gid === void 0 ? {} : { gid: input.gid }
+  });
   const isolatePath = input.isolatePath ?? isolatePiChildPath;
   try {
     for (const path of [resolve7(input.profileRoot), resolve7(input.workspaceRoot)]) {
@@ -4956,7 +5094,7 @@ function preparePiChildIsolation(input) {
     throw error;
   }
   return {
-    spawn: { uid: assignment.uid, gid: assignment.gid },
+    spawn: { uid: assignment.uid, gid: assignment.gid, umask: 7 },
     attestation: {
       schemaVersion: "amaster.pi-child-isolation.v1",
       commandId: input.commandId,
@@ -4969,21 +5107,248 @@ function preparePiChildIsolation(input) {
   };
 }
 
-// src/amaster-runtime-daemon/pi-trusted-runtime-profile.mjs
+// src/amaster-runtime-daemon/pi-company-memory.mjs
 import { createHash as createHash6 } from "node:crypto";
 import {
   chmodSync as chmodSync4,
-  copyFileSync as copyFileSync2,
+  chownSync as chownSync2,
   existsSync as existsSync9,
+  lchownSync as lchownSync2,
   lstatSync as lstatSync5,
   mkdirSync as mkdirSync6,
   readFileSync as readFileSync7,
-  readdirSync as readdirSync6,
+  renameSync as renameSync4,
   rmSync as rmSync5,
   symlinkSync as symlinkSync2,
   writeFileSync as writeFileSync6
 } from "node:fs";
 import { dirname as dirname7, isAbsolute as isAbsolute5, join as join10, relative as relative5, resolve as resolve8 } from "node:path";
+var REGISTRY_FILENAME = ".amaster-company-memory-groups.json";
+var COMPANY_MARKER_FILENAME = ".amaster-company-memory.json";
+var REGISTRY_VERSION = 1;
+var COMPANY_MARKER_VERSION = 1;
+var DEFAULT_GID_BASE = 1e5;
+var DEFAULT_GID_SPAN = 1e6;
+var defaultFs2 = {
+  chmodSync: chmodSync4,
+  chownSync: chownSync2,
+  existsSync: existsSync9,
+  lchownSync: lchownSync2,
+  lstatSync: lstatSync5,
+  mkdirSync: mkdirSync6,
+  readFileSync: readFileSync7,
+  renameSync: renameSync4,
+  rmSync: rmSync5,
+  symlinkSync: symlinkSync2,
+  writeFileSync: writeFileSync6
+};
+function requiredString2(value, label) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new Error(`pi_company_memory_invalid:${label}`);
+  }
+  return value.trim();
+}
+function positiveInteger2(value, label) {
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new Error(`pi_company_memory_invalid:${label}`);
+  }
+  return value;
+}
+function within2(candidate, root) {
+  const rel = relative5(root, candidate);
+  return rel === "" || !rel.startsWith("..") && !isAbsolute5(rel);
+}
+function assertDirectory(path, label, fs) {
+  const stat = fs.lstatSync(path);
+  if (!stat.isDirectory() || stat.isSymbolicLink()) {
+    throw new Error(`pi_company_memory_unsafe:${label}`);
+  }
+}
+function readJson(path, label, fs) {
+  try {
+    const value = JSON.parse(fs.readFileSync(path, "utf8"));
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      throw new Error("not an object");
+    }
+    return value;
+  } catch {
+    throw new Error(`pi_company_memory_invalid:${label}`);
+  }
+}
+function writeJsonAtomic(path, value, mode, fs) {
+  const tempPath = `${path}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  try {
+    fs.writeFileSync(tempPath, `${JSON.stringify(value, null, 2)}
+`, {
+      mode,
+      flag: "wx"
+    });
+    fs.chmodSync(tempPath, mode);
+    fs.renameSync(tempPath, path);
+  } catch (error) {
+    fs.rmSync(tempPath, { force: true });
+    throw error;
+  }
+}
+function safeCompanyPiHomeSegment(companyId) {
+  const raw = requiredString2(companyId, "companyId");
+  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 = createHash6("sha256").update(raw).digest("hex").slice(0, 12);
+  return normalized ? `${normalized}-${hash}` : `company-${hash}`;
+}
+function ensureMemoryRoot(root, fs) {
+  if (!fs.existsSync(root)) fs.mkdirSync(root, { recursive: true, mode: 457 });
+  assertDirectory(root, "root", fs);
+  fs.chownSync(root, 0, 0);
+  fs.chmodSync(root, 457);
+}
+function readGroupRegistry(root, fs) {
+  const path = join10(root, REGISTRY_FILENAME);
+  if (!fs.existsSync(path)) {
+    return { path, groups: {} };
+  }
+  const registryStat = fs.lstatSync(path);
+  if (!registryStat.isFile() || registryStat.isSymbolicLink()) {
+    throw new Error("pi_company_memory_unsafe:group_registry");
+  }
+  const registry = readJson(path, "group_registry", fs);
+  if (registry.version !== REGISTRY_VERSION || !registry.groups || typeof registry.groups !== "object" || Array.isArray(registry.groups)) {
+    throw new Error("pi_company_memory_invalid:group_registry");
+  }
+  const groups = {};
+  const used = /* @__PURE__ */ new Set();
+  for (const [companyId, rawGid] of Object.entries(registry.groups)) {
+    const gid = positiveInteger2(rawGid, "registeredGid");
+    if (used.has(gid)) throw new Error("pi_company_memory_invalid:duplicate_registered_gid");
+    groups[requiredString2(companyId, "registeredCompanyId")] = gid;
+    used.add(gid);
+  }
+  return { path, groups };
+}
+function allocateCompanyGid(root, companyId, input, fs) {
+  const gidBase = positiveInteger2(input.gidBase ?? DEFAULT_GID_BASE, "gidBase");
+  const gidSpan = positiveInteger2(input.gidSpan ?? DEFAULT_GID_SPAN, "gidSpan");
+  const { path, groups } = readGroupRegistry(root, fs);
+  if (groups[companyId]) return groups[companyId];
+  const used = new Set(Object.values(groups));
+  const initialOffset = Number.parseInt(
+    createHash6("sha256").update(companyId).digest("hex").slice(0, 12),
+    16
+  ) % gidSpan;
+  let gid = null;
+  for (let attempt = 0; attempt < gidSpan; attempt += 1) {
+    const candidate = gidBase + (initialOffset + attempt) % gidSpan;
+    if (!used.has(candidate)) {
+      gid = candidate;
+      break;
+    }
+  }
+  if (!gid) throw new Error("pi_company_memory_gid_pool_exhausted");
+  writeJsonAtomic(path, {
+    version: REGISTRY_VERSION,
+    groups: {
+      ...groups,
+      [companyId]: gid
+    }
+  }, 384, fs);
+  return gid;
+}
+function resolveCompanyPiMemoryGroup(input, fs = defaultFs2) {
+  const root = resolve8(requiredString2(input.root, "root"));
+  const companyId = requiredString2(input.companyId, "companyId");
+  ensureMemoryRoot(root, fs);
+  return {
+    root,
+    companyId,
+    gid: allocateCompanyGid(root, companyId, input, fs)
+  };
+}
+function ensurePrivateDirectory(path, mode, uid, gid, fs) {
+  if (!fs.existsSync(path)) fs.mkdirSync(path, { recursive: false, mode });
+  assertDirectory(path, "directory", fs);
+  fs.chownSync(path, uid, gid);
+  fs.chmodSync(path, mode);
+}
+function prepareCompanyPiMemory(input, fs = defaultFs2) {
+  const root = resolve8(requiredString2(input.root, "root"));
+  const profileRoot = resolve8(requiredString2(input.profileRoot, "profileRoot"));
+  const profileHome = resolve8(requiredString2(input.profileHome, "profileHome"));
+  const companyId = requiredString2(input.companyId, "companyId");
+  const childUid = positiveInteger2(input.childUid, "childUid");
+  if (!within2(profileHome, profileRoot)) {
+    throw new Error("pi_company_memory_profile_path_escape");
+  }
+  assertDirectory(profileRoot, "profile_root", fs);
+  assertDirectory(profileHome, "profile_home", fs);
+  const group = resolveCompanyPiMemoryGroup({ ...input, root, companyId }, fs);
+  const gid = group.gid;
+  if (input.gid !== void 0 && positiveInteger2(input.gid, "gid") !== gid) {
+    throw new Error("pi_company_memory_gid_mismatch");
+  }
+  const companyDir = join10(root, safeCompanyPiHomeSegment(companyId));
+  const companyPiHome = join10(companyDir, ".pi");
+  const memoryDir = join10(companyPiHome, "memories");
+  ensurePrivateDirectory(companyDir, 456, 0, gid, fs);
+  const markerPath = join10(companyDir, COMPANY_MARKER_FILENAME);
+  if (fs.existsSync(markerPath)) {
+    const markerStat = fs.lstatSync(markerPath);
+    if (!markerStat.isFile() || markerStat.isSymbolicLink()) {
+      throw new Error("pi_company_memory_unsafe:company_marker");
+    }
+    const marker = readJson(markerPath, "company_marker", fs);
+    if (marker.version !== COMPANY_MARKER_VERSION || marker.companyId !== companyId || marker.gid !== gid) {
+      throw new Error("pi_company_memory_authority_mismatch");
+    }
+  } else {
+    writeJsonAtomic(markerPath, {
+      version: COMPANY_MARKER_VERSION,
+      companyId,
+      gid,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    }, 384, fs);
+  }
+  fs.chownSync(markerPath, 0, 0);
+  fs.chmodSync(markerPath, 384);
+  ensurePrivateDirectory(companyPiHome, 456, 0, gid, fs);
+  if (!fs.existsSync(memoryDir)) fs.mkdirSync(memoryDir, { recursive: false, mode: 1528 });
+  assertDirectory(memoryDir, "memories", fs);
+  fs.chownSync(memoryDir, 0, gid);
+  fs.chmodSync(memoryDir, 1528);
+  const memoryLink = join10(profileHome, "memories");
+  if (fs.existsSync(memoryLink)) {
+    throw new Error("pi_company_memory_profile_link_exists");
+  }
+  fs.symlinkSync(memoryDir, memoryLink, "dir");
+  fs.lchownSync(memoryLink, childUid, gid);
+  return {
+    gid,
+    memoryDir,
+    memoryLink,
+    attestation: {
+      schemaVersion: "amaster.company-pi-memory.v1",
+      companyId,
+      gid,
+      mode: "run_scoped_home_company_memory"
+    }
+  };
+}
+
+// src/amaster-runtime-daemon/pi-trusted-runtime-profile.mjs
+import { createHash as createHash7 } from "node:crypto";
+import {
+  chmodSync as chmodSync5,
+  copyFileSync as copyFileSync2,
+  existsSync as existsSync10,
+  lstatSync as lstatSync6,
+  mkdirSync as mkdirSync7,
+  readFileSync as readFileSync8,
+  readdirSync as readdirSync6,
+  rmSync as rmSync6,
+  symlinkSync as symlinkSync3,
+  writeFileSync as writeFileSync7
+} from "node:fs";
+import { dirname as dirname8, isAbsolute as isAbsolute6, join as join11, relative as relative6, resolve as resolve9 } from "node:path";
 var ASSERTION_VERSION = "2026-07-25.v1";
 var SHA256 = /^[a-f0-9]{64}$/;
 var COPY_ENTRIES = ["SYSTEM.md", "policy", "skills", "agents", "bundles", "extensions"];
@@ -4992,23 +5357,23 @@ var SECRET_KEY = /(authorization|cookie|api[_-]?key|password|secret|token)$/i;
 var SECRET_VALUE = /(?:authorization|cookie|api[_-]?key|password|secret|token)\s*[:=]\s*(?:bearer\s+)?[^\s"',;]+|bearer\s+[^\s"',;]+/i;
 var MAX_AUDIT_BYTES = 1024 * 1024;
 var MAX_AUDIT_EVENTS = 2e3;
-function requiredString2(value, field) {
+function requiredString3(value, field) {
   if (typeof value !== "string" || value.trim() === "") {
     throw new Error(`pi_trusted_runtime_assertion_invalid:${field}`);
   }
   return value.trim();
 }
 function requiredDigest(value, field) {
-  const digest = requiredString2(value, field);
+  const digest = requiredString3(value, field);
   if (!SHA256.test(digest)) throw new Error(`pi_trusted_runtime_assertion_invalid:${field}`);
   return digest;
 }
 function sha256File(path, label) {
-  const stat = lstatSync5(path);
+  const stat = lstatSync6(path);
   if (!stat.isFile() || stat.isSymbolicLink()) {
     throw new Error(`pi_trusted_runtime_source_unsafe:${label}`);
   }
-  return createHash6("sha256").update(readFileSync7(path)).digest("hex");
+  return createHash7("sha256").update(readFileSync8(path)).digest("hex");
 }
 function verifyDeclaredFiles(manifest, root, label, ignoredPaths = [], enforceComplete = true) {
   if (!Array.isArray(manifest.files) || manifest.files.length === 0) {
@@ -5016,10 +5381,10 @@ function verifyDeclaredFiles(manifest, root, label, ignoredPaths = [], enforceCo
   }
   const seen = /* @__PURE__ */ new Set();
   for (const entry of manifest.files) {
-    const relativePath = requiredString2(entry?.path, `${label}.files.path`);
+    const relativePath = requiredString3(entry?.path, `${label}.files.path`);
     const expectedDigest = requiredDigest(entry?.sha256, `${label}.files.sha256`);
-    const filePath = resolve8(root, relativePath);
-    if (!within2(filePath, root) || seen.has(relativePath)) {
+    const filePath = resolve9(root, relativePath);
+    if (!within3(filePath, root) || seen.has(relativePath)) {
       throw new Error(`pi_trusted_runtime_source_invalid:${label}_files`);
     }
     seen.add(relativePath);
@@ -5031,9 +5396,9 @@ function verifyDeclaredFiles(manifest, root, label, ignoredPaths = [], enforceCo
   const ignored = ignoredPaths.map((path) => path.split("\\").join("/"));
   const visit = (directory) => {
     for (const entry of readdirSync6(directory)) {
-      const filePath = join10(directory, entry);
-      const relativePath = relative5(root, filePath).split("\\").join("/");
-      const stat = lstatSync5(filePath);
+      const filePath = join11(directory, entry);
+      const relativePath = relative6(root, filePath).split("\\").join("/");
+      const stat = lstatSync6(filePath);
       if (stat.isSymbolicLink()) {
         throw new Error(`pi_trusted_runtime_source_unsafe:${label}_file`);
       }
@@ -5049,21 +5414,21 @@ function verifyDeclaredFiles(manifest, root, label, ignoredPaths = [], enforceCo
   };
   visit(root);
 }
-function record2(value) {
+function record3(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
-function within2(candidate, root) {
-  const rel = relative5(root, candidate);
-  return rel === "" || !rel.startsWith("..") && !isAbsolute5(rel);
+function within3(candidate, root) {
+  const rel = relative6(root, candidate);
+  return rel === "" || !rel.startsWith("..") && !isAbsolute6(rel);
 }
 function readJsonFile2(path, label, fallback = {}) {
-  if (!existsSync9(path)) return fallback;
-  const stat = lstatSync5(path);
+  if (!existsSync10(path)) return fallback;
+  const stat = lstatSync6(path);
   if (!stat.isFile() || stat.isSymbolicLink()) {
     throw new Error(`pi_trusted_runtime_source_unsafe:${label}`);
   }
   try {
-    return JSON.parse(readFileSync7(path, "utf8"));
+    return JSON.parse(readFileSync8(path, "utf8"));
   } catch {
     throw new Error(`pi_trusted_runtime_source_invalid:${label}`);
   }
@@ -5091,32 +5456,32 @@ function assertNoPersistentSecrets(value, path = []) {
   }
 }
 function copyTreeNoLinks(source, target) {
-  const stat = lstatSync5(source);
+  const stat = lstatSync6(source);
   if (stat.isSymbolicLink()) throw new Error("pi_trusted_runtime_source_symlink_blocked");
   if (stat.isDirectory()) {
-    mkdirSync6(target, { recursive: true, mode: 448 });
-    chmodSync4(target, 448);
+    mkdirSync7(target, { recursive: true, mode: 448 });
+    chmodSync5(target, 448);
     for (const entry of readdirSync6(source)) {
-      copyTreeNoLinks(join10(source, entry), join10(target, entry));
+      copyTreeNoLinks(join11(source, entry), join11(target, entry));
     }
     return;
   }
   if (!stat.isFile()) throw new Error("pi_trusted_runtime_source_type_blocked");
-  mkdirSync6(dirname7(target), { recursive: true, mode: 448 });
+  mkdirSync7(dirname8(target), { recursive: true, mode: 448 });
   copyFileSync2(source, target);
-  chmodSync4(target, 384 | stat.mode & 73);
+  chmodSync5(target, 384 | stat.mode & 73);
 }
 function mergeMcp(seedRoot, overlayRoot, governedConfig) {
-  const seed = record2(readJsonFile2(join10(seedRoot, "mcp.json"), "seed_mcp", { mcpServers: {} }));
-  const overlay = record2(readJsonFile2(join10(overlayRoot, "mcp.json"), "overlay_mcp", { mcpServers: {} }));
+  const seed = record3(readJsonFile2(join11(seedRoot, "mcp.json"), "seed_mcp", { mcpServers: {} }));
+  const overlay = record3(readJsonFile2(join11(overlayRoot, "mcp.json"), "overlay_mcp", { mcpServers: {} }));
   assertNoPersistentSecrets(seed, ["seed", "mcp.json"]);
   assertNoPersistentSecrets(overlay, ["overlay", "mcp.json"]);
-  const seedServers = record2(seed.mcpServers);
-  const overlayServers = record2(overlay.mcpServers);
+  const seedServers = record3(seed.mcpServers);
+  const overlayServers = record3(overlay.mcpServers);
   if ("amaster" in seedServers || "amaster" in overlayServers) {
     throw new Error("pi_trusted_runtime_reserved_mcp_override:amaster");
   }
-  const governed = record2(record2(governedConfig).mcpServers).amaster;
+  const governed = record3(record3(governedConfig).mcpServers).amaster;
   if (!governed) throw new Error("pi_trusted_runtime_governed_mcp_missing");
   return {
     ...deepMerge(seed, overlay),
@@ -5136,14 +5501,14 @@ function assertEnabledPackagesAvailable(settings, npmRoot) {
   const requiredNames = new Set(
     (Array.isArray(settings.packages) ? settings.packages : []).map(packageName).filter(Boolean)
   );
-  for (const plugin of Object.values(record2(settings.plugins))) {
-    const config = record2(plugin);
+  for (const plugin of Object.values(record3(settings.plugins))) {
+    const config = record3(plugin);
     if (config.enabled === true && typeof config.package === "string") {
       requiredNames.add(config.package);
     }
   }
   for (const name of requiredNames) {
-    const metadataPath = join10(npmRoot, "node_modules", ...name.split("/"), "package.json");
+    const metadataPath = join11(npmRoot, "node_modules", ...name.split("/"), "package.json");
     const metadata = readJsonFile2(metadataPath, `package:${name}`, null);
     if (!metadata || metadata.name !== name) {
       throw new Error(`pi_trusted_runtime_package_unavailable:${name}`);
@@ -5151,62 +5516,62 @@ function assertEnabledPackagesAvailable(settings, npmRoot) {
   }
 }
 function materializeTrustedPiRuntimeProfile(input) {
-  const seedRoot = resolve8(requiredString2(input.seedRoot, "seedRoot"));
-  const overlayRoot = resolve8(requiredString2(input.overlayRoot, "overlayRoot"));
-  const profileRoot = resolve8(requiredString2(input.profileRoot, "profileRoot"));
-  const agentDir = resolve8(requiredString2(input.agentDir, "agentDir"));
-  if (!within2(agentDir, profileRoot)) throw new Error("pi_trusted_runtime_profile_path_escape");
+  const seedRoot = resolve9(requiredString3(input.seedRoot, "seedRoot"));
+  const overlayRoot = resolve9(requiredString3(input.overlayRoot, "overlayRoot"));
+  const profileRoot = resolve9(requiredString3(input.profileRoot, "profileRoot"));
+  const agentDir = resolve9(requiredString3(input.agentDir, "agentDir"));
+  if (!within3(agentDir, profileRoot)) throw new Error("pi_trusted_runtime_profile_path_escape");
   for (const [root, label] of [[seedRoot, "seed_root"], [overlayRoot, "overlay_root"]]) {
-    const stat = lstatSync5(root);
+    const stat = lstatSync6(root);
     if (!stat.isDirectory() || stat.isSymbolicLink()) {
       throw new Error(`pi_trusted_runtime_source_unsafe:${label}`);
     }
   }
   for (const entry of COPY_ENTRIES) {
-    const target = join10(agentDir, entry);
-    rmSync5(target, { recursive: true, force: true });
+    const target = join11(agentDir, entry);
+    rmSync6(target, { recursive: true, force: true });
     for (const sourceRoot of [seedRoot, overlayRoot]) {
-      const source = join10(sourceRoot, entry);
-      if (existsSync9(source)) copyTreeNoLinks(source, target);
+      const source = join11(sourceRoot, entry);
+      if (existsSync10(source)) copyTreeNoLinks(source, target);
     }
   }
   const mergedJson = {};
   for (const entry of JSON_ENTRIES) {
-    const seed = readJsonFile2(join10(seedRoot, entry), `seed_${entry}`, {});
-    const overlay = readJsonFile2(join10(overlayRoot, entry), `overlay_${entry}`, {});
+    const seed = readJsonFile2(join11(seedRoot, entry), `seed_${entry}`, {});
+    const overlay = readJsonFile2(join11(overlayRoot, entry), `overlay_${entry}`, {});
     const merged = deepMerge(seed, overlay);
     if (entry === "settings.json") {
       merged["pi-security"] = {
-        ...record2(merged["pi-security"]),
+        ...record3(merged["pi-security"]),
         enabled: true,
         approvals: {
-          ...record2(record2(merged["pi-security"]).approvals),
+          ...record3(record3(merged["pi-security"]).approvals),
           allowSessionGrants: false
         }
       };
     }
     assertNoPersistentSecrets(merged, [entry]);
-    writeFileSync6(join10(agentDir, entry), `${JSON.stringify(merged, null, 2)}
+    writeFileSync7(join11(agentDir, entry), `${JSON.stringify(merged, null, 2)}
 `, {
       mode: 384
     });
-    chmodSync4(join10(agentDir, entry), 384);
+    chmodSync5(join11(agentDir, entry), 384);
     mergedJson[entry] = merged;
   }
   const governedConfig = readJsonFile2(input.governedMcpConfigPath, "governed_mcp");
   const mcp = mergeMcp(seedRoot, overlayRoot, governedConfig);
-  writeFileSync6(input.governedMcpConfigPath, `${JSON.stringify(mcp, null, 2)}
+  writeFileSync7(input.governedMcpConfigPath, `${JSON.stringify(mcp, null, 2)}
 `, { mode: 384 });
-  chmodSync4(input.governedMcpConfigPath, 384);
-  const npmRoot = join10(seedRoot, "npm");
+  chmodSync5(input.governedMcpConfigPath, 384);
+  const npmRoot = join11(seedRoot, "npm");
   assertEnabledPackagesAvailable(mergedJson["settings.json"], npmRoot);
-  const npmTarget = join10(agentDir, "npm");
-  rmSync5(npmTarget, { recursive: true, force: true });
-  const npmStat = lstatSync5(npmRoot);
+  const npmTarget = join11(agentDir, "npm");
+  rmSync6(npmTarget, { recursive: true, force: true });
+  const npmStat = lstatSync6(npmRoot);
   if (!npmStat.isDirectory() || npmStat.isSymbolicLink()) {
     throw new Error("pi_trusted_runtime_source_unsafe:seed_npm");
   }
-  symlinkSync2(npmRoot, npmTarget, "dir");
+  symlinkSync3(npmRoot, npmTarget, "dir");
   const facts = {
     schemaVersion: "amaster.trusted-pi-profile.v1",
     seedManifestDigest: input.verifiedAssertion.digests.seedManifestDigest,
@@ -5219,7 +5584,7 @@ function materializeTrustedPiRuntimeProfile(input) {
   };
   return {
     facts,
-    attestationId: createHash6("sha256").update(JSON.stringify(facts)).digest("hex")
+    attestationId: createHash7("sha256").update(JSON.stringify(facts)).digest("hex")
   };
 }
 function assertAuditArgsRedacted(value) {
@@ -5242,16 +5607,16 @@ function assertAuditArgsRedacted(value) {
   }
 }
 function readTrustedPiRuntimeAudit(input) {
-  const profileRoot = resolve8(requiredString2(input.profileRoot, "profileRoot"));
-  const auditFile = resolve8(requiredString2(input.auditFile, "auditFile"));
-  if (!within2(auditFile, profileRoot)) throw new Error("pi_trusted_runtime_audit_path_escape");
-  if (!existsSync9(auditFile)) throw new Error("pi_trusted_runtime_audit_startup_missing");
-  const stat = lstatSync5(auditFile);
+  const profileRoot = resolve9(requiredString3(input.profileRoot, "profileRoot"));
+  const auditFile = resolve9(requiredString3(input.auditFile, "auditFile"));
+  if (!within3(auditFile, profileRoot)) throw new Error("pi_trusted_runtime_audit_path_escape");
+  if (!existsSync10(auditFile)) throw new Error("pi_trusted_runtime_audit_startup_missing");
+  const stat = lstatSync6(auditFile);
   if (!stat.isFile() || stat.isSymbolicLink()) {
     throw new Error("pi_trusted_runtime_audit_unsafe");
   }
   if (stat.size > MAX_AUDIT_BYTES) throw new Error("pi_trusted_runtime_audit_too_large");
-  const lines = readFileSync7(auditFile, "utf8").split("\n").filter(Boolean);
+  const lines = readFileSync8(auditFile, "utf8").split("\n").filter(Boolean);
   if (lines.length === 0 || lines.length > MAX_AUDIT_EVENTS) {
     throw new Error("pi_trusted_runtime_audit_event_count_invalid");
   }
@@ -5299,20 +5664,20 @@ function readTrustedPiRuntimeAudit(input) {
   };
 }
 function readTrustedPiRuntimeLocalDigests(input) {
-  const seedRoot = resolve8(requiredString2(input.seedRoot, "seedRoot"));
-  const overlayRoot = resolve8(requiredString2(input.overlayRoot, "overlayRoot"));
-  const policyFile = resolve8(requiredString2(input.policyFile, "policyFile"));
+  const seedRoot = resolve9(requiredString3(input.seedRoot, "seedRoot"));
+  const overlayRoot = resolve9(requiredString3(input.overlayRoot, "overlayRoot"));
+  const policyFile = resolve9(requiredString3(input.policyFile, "policyFile"));
   for (const [path, label] of [[seedRoot, "seed_root"], [overlayRoot, "overlay_root"]]) {
-    const stat = lstatSync5(path);
+    const stat = lstatSync6(path);
     if (!stat.isDirectory() || stat.isSymbolicLink()) {
       throw new Error(`pi_trusted_runtime_source_unsafe:${label}`);
     }
   }
-  const seedManifestFile = join10(seedRoot, "seed-manifest.json");
-  const overlayManifestFile = join10(overlayRoot, "runtime-overlay-manifest.json");
-  const seedManifest = JSON.parse(readFileSync7(seedManifestFile, "utf8"));
-  const overlayManifest = JSON.parse(readFileSync7(overlayManifestFile, "utf8"));
-  const policyManifest = JSON.parse(readFileSync7(policyFile, "utf8"));
+  const seedManifestFile = join11(seedRoot, "seed-manifest.json");
+  const overlayManifestFile = join11(overlayRoot, "runtime-overlay-manifest.json");
+  const seedManifest = JSON.parse(readFileSync8(seedManifestFile, "utf8"));
+  const overlayManifest = JSON.parse(readFileSync8(overlayManifestFile, "utf8"));
+  const policyManifest = JSON.parse(readFileSync8(policyFile, "utf8"));
   verifyDeclaredFiles(seedManifest, seedRoot, "seed", [
     "seed-manifest.json",
     "npm/package-lock.json",
@@ -5321,9 +5686,9 @@ function readTrustedPiRuntimeLocalDigests(input) {
   verifyDeclaredFiles(overlayManifest, overlayRoot, "overlay", ["runtime-overlay-manifest.json"]);
   verifyDeclaredFiles(
     policyManifest,
-    dirname7(policyFile),
+    dirname8(policyFile),
     "policy",
-    [relative5(dirname7(policyFile), policyFile)],
+    [relative6(dirname8(policyFile), policyFile)],
     false
   );
   return {
@@ -5369,16 +5734,16 @@ function verifyTrustedPiRuntimeAssertion(input) {
     leaseId: input.leaseId,
     executorKind: input.executorKind
   };
-  requiredString2(assertion.attestationId, "attestationId");
+  requiredString3(assertion.attestationId, "attestationId");
   for (const [field, expected] of Object.entries(bindings)) {
-    if (requiredString2(assertion[field], field) !== expected) {
+    if (requiredString3(assertion[field], field) !== expected) {
       throw new Error(`pi_trusted_runtime_assertion_binding_mismatch:${field}`);
     }
   }
   if (assertion.executorKind !== "pi") {
     throw new Error("pi_trusted_runtime_assertion_binding_mismatch:executorKind");
   }
-  const expiresAt = Date.parse(requiredString2(assertion.expiresAt, "expiresAt"));
+  const expiresAt = Date.parse(requiredString3(assertion.expiresAt, "expiresAt"));
   const now = input.now instanceof Date ? input.now : new Date(input.now ?? Date.now());
   if (!Number.isFinite(expiresAt) || input.verifyExpiry !== false && expiresAt <= now.getTime()) {
     throw new Error("pi_trusted_runtime_assertion_expired");
@@ -5415,9 +5780,9 @@ function verifyTrustedPiRuntimeAssertion(input) {
 
 // src/amaster-runtime-daemon/workspace-status.mjs
 import { spawnSync as spawnSync4 } from "node:child_process";
-import { createHash as createHash7 } from "node:crypto";
-import { existsSync as existsSync10, readdirSync as readdirSync7, readFileSync as readFileSync8, statSync as statSync6 } from "node:fs";
-import { basename as basename5, extname, isAbsolute as isAbsolute6, join as join11, relative as relative6, resolve as resolve9 } from "node:path";
+import { createHash as createHash8 } from "node:crypto";
+import { existsSync as existsSync11, readdirSync as readdirSync7, readFileSync as readFileSync9, statSync as statSync6 } from "node:fs";
+import { basename as basename5, extname, isAbsolute as isAbsolute7, join as join12, relative as relative7, resolve as resolve10 } from "node:path";
 var WORKSPACE_RUNTIME_SERVICES_FILENAME = ".amaster-runtime-services.json";
 var ARTIFACT_EXTENSIONS = /* @__PURE__ */ new Map([
   [".md", "markdown"],
@@ -5462,11 +5827,11 @@ 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 = relative6(root, candidate);
-  return rel === "" || !rel.startsWith("..") && !isAbsolute6(rel);
+  const rel = relative7(root, candidate);
+  return rel === "" || !rel.startsWith("..") && !isAbsolute7(rel);
 }
 function normalizeRelativePath(root, filePath) {
-  return relative6(root, filePath).split(/[\\/]+/).join("/");
+  return relative7(root, filePath).split(/[\\/]+/).join("/");
 }
 function isSafeRelativePath(value) {
   const text = String(value ?? "").trim().split(/[\\/]+/).join("/");
@@ -5486,7 +5851,7 @@ function sanitizeTrackedChange(line) {
   return isSafeRelativePath(path) ? line : null;
 }
 function sha256File2(filePath) {
-  return createHash7("sha256").update(readFileSync8(filePath)).digest("hex");
+  return createHash8("sha256").update(readFileSync9(filePath)).digest("hex");
 }
 function artifactHashCacheKey(relativePath, stat) {
   return `${relativePath}\0${stat.size}\0${stat.mtimeMs}`;
@@ -5514,7 +5879,7 @@ function artifactSha256(filePath, relativePath, stat, opts = {}) {
   return hash;
 }
 function scanArtifactCandidates(cwd, opts = {}) {
-  const root = resolve9(cwd);
+  const root = resolve10(cwd);
   const maxCandidates = opts.maxCandidates ?? MAX_CANDIDATES;
   const maxEntries = opts.maxEntries ?? MAX_SCAN_ENTRIES;
   const candidates = [];
@@ -5535,7 +5900,7 @@ function scanArtifactCandidates(cwd, opts = {}) {
       if (entry.name.startsWith(".") && entry.name !== ".amaster-runtime.json") {
         if (entry.name === ".git") continue;
       }
-      const fullPath = join11(current, entry.name);
+      const fullPath = join12(current, entry.name);
       const relativePath = normalizeRelativePath(root, fullPath);
       if (!isSafeRelativePath(relativePath)) continue;
       if (basename5(relativePath) === ".amaster-runtime.json") continue;
@@ -5554,7 +5919,7 @@ function scanArtifactCandidates(cwd, opts = {}) {
       } catch {
         continue;
       }
-      if (!statusPathWithin(resolve9(fullPath), root) || stat.size > MAX_HASH_BYTES) continue;
+      if (!statusPathWithin(resolve10(fullPath), root) || stat.size > MAX_HASH_BYTES) continue;
       candidates.push({
         relativePath,
         name: basename5(fullPath),
@@ -5614,10 +5979,10 @@ function sanitizeRuntimeService(entry) {
   };
 }
 function readRuntimeServicesSnapshot(cwd) {
-  const snapshotPath = join11(resolve9(cwd), WORKSPACE_RUNTIME_SERVICES_FILENAME);
-  if (!existsSync10(snapshotPath)) return [];
+  const snapshotPath = join12(resolve10(cwd), WORKSPACE_RUNTIME_SERVICES_FILENAME);
+  if (!existsSync11(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 {
@@ -5688,7 +6053,7 @@ function readWorkspaceStatus(cwd, opts = {}) {
 }
 
 // src/amaster-runtime-daemon.mjs
-var CONNECTOR_VERSION = "0.1.0-beta.41";
+var CONNECTOR_VERSION = "0.1.0-beta.42";
 var CONNECTOR_CONTRACT_VERSION = "2026-06-04.v1";
 var MAX_CHECKPOINT_BYTES = 20 * 1024 * 1024;
 var CHECKPOINT_TTL_MS = 24 * 60 * 60 * 1e3;
@@ -5736,11 +6101,11 @@ function updateActiveRunWorkspaceManifest(commandId, manifestPath, patch = {}) {
 }
 function resultOutboxPendingCount(config) {
   const dir = resultOutboxDir(config);
-  if (!existsSync11(dir)) return 0;
+  if (!existsSync12(dir)) return 0;
   try {
     let pending = 0;
     for (const file of readdirSync8(dir).filter((name) => name.endsWith(".json"))) {
-      if (readValidResultOutboxEntryOrQuarantine(config, file, join12(dir, file))) {
+      if (readValidResultOutboxEntryOrQuarantine(config, file, join13(dir, file))) {
         pending += 1;
       }
     }
@@ -5756,11 +6121,11 @@ function piCompletionOutputType(event) {
 }
 function resultOutboxActiveRunCommands(config) {
   const dir = resultOutboxDir(config);
-  if (!existsSync11(dir)) return [];
+  if (!existsSync12(dir)) return [];
   const outboxPending = resultOutboxPendingCount(config);
   const entries = [];
   for (const file of readdirSync8(dir).filter((name) => name.endsWith(".json")).sort()) {
-    const entry = readValidResultOutboxEntryOrQuarantine(config, file, join12(dir, file));
+    const entry = readValidResultOutboxEntryOrQuarantine(config, file, join13(dir, file));
     if (!entry) continue;
     const activeRun = asRecord(entry.activeRun);
     const commandId = readString(activeRun.commandId) ?? readString(entry.commandId);
@@ -5790,12 +6155,12 @@ function resultOutboxActiveRunCommands(config) {
 }
 function resultOutboxFailedRunCommands(config) {
   const dir = resultOutboxInvalidDir(config);
-  if (!existsSync11(dir)) return [];
+  if (!existsSync12(dir)) return [];
   const entries = [];
   for (const file of readdirSync8(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(join13(dir, file), "utf8")));
     } catch {
       continue;
     }
@@ -5855,11 +6220,11 @@ function piExtraArgsDiagnostics(value) {
 }
 function safeExpandPath(value) {
   const text = readString(value);
-  return text ? resolve10(expandHomePath(text)) : null;
+  return text ? resolve11(expandHomePath(text)) : null;
 }
 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;
@@ -5902,10 +6267,10 @@ function safeSkillRootSummary(kind, source, pathValue) {
     try {
       for (const name of readdirSync8(pathValue)) {
         if (name.startsWith(".")) continue;
-        const skillDir = join12(pathValue, name);
+        const skillDir = join13(pathValue, name);
         try {
           if (!statSync7(skillDir).isDirectory()) continue;
-          if (!existsSync11(join12(skillDir, "SKILL.md"))) continue;
+          if (!existsSync12(join13(skillDir, "SKILL.md"))) continue;
           skillCount += 1;
           if (skillCount >= MAX_PI_CAPABILITY_SOURCE_ENTRIES) {
             truncated = true;
@@ -5956,7 +6321,7 @@ function objectKeyCount(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? Object.keys(value).length : 0;
 }
 function defaultPiCodingAgentDir() {
-  return join12(homedir3(), ".pi", "agent");
+  return join13(homedir3(), ".pi", "agent");
 }
 function piCapabilitySourcesDiagnostics() {
   const configuredPiCodingAgentDir = safeExpandPath(process.env.PI_CODING_AGENT_DIR);
@@ -5965,11 +6330,11 @@ function piCapabilitySourcesDiagnostics() {
   const configuredPiAgentHome = safeExpandPath(process.env.PI_AGENT_HOME);
   const piAgentHome = configuredPiAgentHome ?? piCodingAgentDir;
   const piAgentHomeSource = configuredPiAgentHome ? "PI_AGENT_HOME" : piCodingAgentDirSource;
-  const userSkillsPath = piAgentHome ? join12(piAgentHome, "skills") : null;
-  const marketplaceSkillsPath = safeExpandPath(process.env.PI_AGENT_MARKETPLACE_SKILLS_DIR) ?? (piAgentHome ? join12(piAgentHome, "marketplace", "skills") : null);
+  const userSkillsPath = piAgentHome ? join13(piAgentHome, "skills") : null;
+  const marketplaceSkillsPath = safeExpandPath(process.env.PI_AGENT_MARKETPLACE_SKILLS_DIR) ?? (piAgentHome ? join13(piAgentHome, "marketplace", "skills") : null);
   const builtinSkillsPath = safeExpandPath(process.env.PI_AGENT_BUILTIN_SKILLS_DIR) ?? safeExpandPath(process.env.AMASTER_BUILTIN_SKILLS);
-  const mcpConfigPath = safeExpandPath(process.env.PI_AGENT_MCP_SERVERS_FILE) ?? (piAgentHome ? join12(piAgentHome, "mcp.json") : null);
-  const settingsConfigPath = piCodingAgentDir ? join12(piCodingAgentDir, "settings.json") : null;
+  const mcpConfigPath = safeExpandPath(process.env.PI_AGENT_MCP_SERVERS_FILE) ?? (piAgentHome ? join13(piAgentHome, "mcp.json") : null);
+  const settingsConfigPath = piCodingAgentDir ? join13(piCodingAgentDir, "settings.json") : null;
   const skillRoots = [
     safeSkillRootSummary("user", `${piAgentHomeSource}/skills`, userSkillsPath),
     safeSkillRootSummary(
@@ -6200,13 +6565,13 @@ function piAgentLocalPlatformRunnerEnabled(config) {
 }
 function piAgentSystemDataDir(config) {
   const configured = readString(config.AMASTER_PI_AGENT_SYSTEM_DATA_DIR ?? process.env.AMASTER_PI_AGENT_SYSTEM_DATA_DIR);
-  return configured ? resolve10(expandHomePath(configured)) : null;
+  return configured ? resolve11(expandHomePath(configured)) : null;
 }
 function readPiAgentLocalPlatformCredential(credentialsDir) {
-  const pointer = readJsonFile3(join12(credentialsDir, "latest.json"));
+  const pointer = readJsonFile3(join13(credentialsDir, "latest.json"));
   const credentialRef = readString(pointer.credentialRef);
   if (!credentialRef || !/^[a-f0-9]{64}$/i.test(credentialRef)) return null;
-  const credential = readJsonFile3(join12(credentialsDir, `${credentialRef}.json`));
+  const credential = readJsonFile3(join13(credentialsDir, `${credentialRef}.json`));
   const organizationId = readString(credential.organizationId);
   const apiKey = readString(credential.apiKey);
   if (credential.version !== 1 || !organizationId || !apiKey) return null;
@@ -6222,7 +6587,7 @@ function piAgentLocalPlatformCredentials(config) {
   if (!piAgentLocalPlatformRunnerEnabled(config)) return [];
   const systemDataDir = piAgentSystemDataDir(config);
   if (!systemDataDir) return [];
-  const companiesDir = join12(systemDataDir, "companies");
+  const companiesDir = join13(systemDataDir, "companies");
   let entries = [];
   try {
     entries = readdirSync8(companiesDir, { withFileTypes: true });
@@ -6232,7 +6597,7 @@ function piAgentLocalPlatformCredentials(config) {
   const credentialsByOrganizationId = /* @__PURE__ */ new Map();
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const credential = readPiAgentLocalPlatformCredential(join12(companiesDir, entry.name, "model-credentials"));
+    const credential = readPiAgentLocalPlatformCredential(join13(companiesDir, entry.name, "model-credentials"));
     if (credential) credentialsByOrganizationId.set(credential.organizationId, credential);
   }
   return [...credentialsByOrganizationId.values()];
@@ -6406,7 +6771,7 @@ AMASTER_WORKSPACE_ALLOWLIST=${quoteShell(config.workspaceBindings.join(","))}
 AMASTER_EXECUTORS=${quoteShell(executorEnv)}
 AMASTER_CAPABILITIES=${quoteShell(config.capabilities.join(","))}
 AMASTER_NETWORK_DOMAINS=${quoteShell(config.networkDomains.join(","))}
-AMASTER_DAEMON_STATE_FILE=${quoteShell(join12(homedir3(), ".amaster-employee", "runtime-connector-state.json"))}
+AMASTER_DAEMON_STATE_FILE=${quoteShell(join13(homedir3(), ".amaster-employee", "runtime-connector-state.json"))}
 EOF
 
 set -a
@@ -6594,10 +6959,10 @@ function buildActiveRunCommandStatus(config, entry) {
   const base = {
     ...entry,
     phase: readString(entry.phase) ?? "executing",
-    managedWorkdirPresent: entry.workspacePath ? existsSync11(entry.workspacePath) : false,
+    managedWorkdirPresent: entry.workspacePath ? existsSync12(entry.workspacePath) : false,
     outboxPending: resultOutboxPendingCount(config)
   };
-  if (!entry.workspacePath || !existsSync11(entry.workspacePath)) return base;
+  if (!entry.workspacePath || !existsSync12(entry.workspacePath)) return base;
   const manifestPath = entry.manifestPath ?? workspaceManifestPath(entry.workspacePath);
   const status = readWorkspaceStatus(entry.workspacePath, { hashCache: workspaceStatusHashCache });
   const artifactCandidates = status.artifacts.slice(0, 20);
@@ -6778,7 +7143,7 @@ function trustedPiRuntimeSources(config) {
 }
 function readJsonFile3(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 {};
@@ -6847,11 +7212,11 @@ function safeAgentInstructionMaterializationTarget(workspace, filePath) {
   const raw = readString(filePath);
   if (!raw || raw.includes("\0")) return null;
   const normalized = raw.replace(/\\/g, "/");
-  if (isAbsolute7(normalized)) return null;
+  if (isAbsolute8(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 = resolve10(workspace.cwd, relativePath);
+  const targetPath = resolve11(workspace.cwd, relativePath);
   if (!pathWithin2(targetPath, workspace.cwd)) return null;
   return { relativePath, targetPath };
 }
@@ -6865,8 +7230,8 @@ async function materializeAgentInstructionsBundle(config, command, workspace) {
     if (!content) continue;
     const target = safeAgentInstructionMaterializationTarget(workspace, filePath);
     if (!target) continue;
-    mkdirSync7(dirname8(target.targetPath), { recursive: true });
-    writeFileSync7(target.targetPath, content, "utf8");
+    mkdirSync8(dirname9(target.targetPath), { recursive: true });
+    writeFileSync8(target.targetPath, content, "utf8");
     materialized.push({
       path: target.relativePath,
       byteSize: Buffer.byteLength(content, "utf8")
@@ -6916,6 +7281,7 @@ function buildCommandPrompt(command, workspace, materializedAttachments = [], op
     commandId: command.commandId,
     runId: commandRunId(command),
     issueId: commandIssueId(command),
+    currentDate: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
     issueLine,
     cwd,
     managed: workspaceContext.managed,
@@ -6930,25 +7296,18 @@ function buildCommandPrompt(command, workspace, materializedAttachments = [], op
     nativeSession: asRecord(payload.nativeSession)
   });
 }
-function safeCompanyPiHomeSegment(companyId) {
-  const raw = readString(companyId)?.trim();
-  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 = createHash8("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 resolve10(expandHomePath(explicitRoot));
+  if (explicitRoot) return resolve11(expandHomePath(explicitRoot));
   const configuredPiHome = readString(baseEnv.PI_AGENT_HOME) ?? readString(baseEnv.PI_CODING_AGENT_DIR);
-  if (configuredPiHome) return join12(dirname8(resolve10(expandHomePath(configuredPiHome))), "companies");
-  return join12(homedir3(), ".amaster-employee", "companies");
+  if (configuredPiHome) return join13(dirname9(resolve11(expandHomePath(configuredPiHome))), "companies");
+  return join13(homedir3(), ".amaster-employee", "companies");
 }
 function companyPiAgentHome(baseEnv, companyId) {
-  const segment = safeCompanyPiHomeSegment(companyId);
-  if (!segment) return null;
-  return join12(companyPiHomeRoot(baseEnv), segment, ".pi");
+  const rawCompanyId = readString(companyId);
+  if (!rawCompanyId) return null;
+  const segment = safeCompanyPiHomeSegment(rawCompanyId);
+  return join13(companyPiHomeRoot(baseEnv), segment, ".pi");
 }
 function commandUsesPiExecutor(command) {
   return readString(asRecord(command.payload).executorKind) === "pi";
@@ -7017,7 +7376,7 @@ function resolveNativeSessionRequest(command, workspace) {
     try {
       cwdMatched = realpathSync3(requestedCwd) === realpathSync3(sourceWorkspacePath);
     } catch {
-      cwdMatched = resolve10(requestedCwd) === resolve10(sourceWorkspacePath);
+      cwdMatched = resolve11(requestedCwd) === resolve11(sourceWorkspacePath);
     }
   }
   const used = Boolean(enabled && requested && sessionId && requestedCwd && cwdMatched);
@@ -7216,6 +7575,7 @@ function createLiveOutputLogger(config, command, executorKind, protectedValues =
   let nonProgressEventCount = 0;
   let unparsedLineCount = 0;
   let lastPiAgentMessage = null;
+  let piTerminalOutput = null;
   let executorSessionId = null;
   const liveMcpToolResults = [];
   let queue = Promise.resolve();
@@ -7299,9 +7659,20 @@ function createLiveOutputLogger(config, command, executorKind, protectedValues =
     const text = redactProtectedText(line, protectedValues).trim();
     if (!text) return;
     const event = stream === "stdout" ? parseJsonLine(text) : null;
-    if (executorKind === "pi" && readString(asRecord(event).type) === "session") {
+    const eventType = readString(asRecord(event).type);
+    if (executorKind === "pi" && eventType === "session") {
       executorSessionId = readString(asRecord(event).sessionId ?? asRecord(event).id) ?? executorSessionId;
     }
+    if (executorKind === "pi" && (["message_end", "turn_end", "agent_end"].includes(eventType ?? "") || eventType === "message_update" && readString(asRecord(asRecord(event).assistantMessageEvent).type) === "text_end")) {
+      const parsedTerminalOutput = parsePiJsonl(text);
+      if (parsedTerminalOutput.hasAssistantOutput && readString(parsedTerminalOutput.summary)) {
+        piTerminalOutput = {
+          summary: parsedTerminalOutput.summary,
+          usage: parsedTerminalOutput.usage,
+          hasAssistantOutput: true
+        };
+      }
+    }
     if (["codex", "pi"].includes(executorKind) && event) {
       const results = executorKind === "codex" ? codexMcpToolResults(event) : piMcpToolResults(event);
       liveMcpToolResults.push(...results);
@@ -7340,6 +7711,12 @@ function createLiveOutputLogger(config, command, executorKind, protectedValues =
     mcpToolResults() {
       return [...liveMcpToolResults];
     },
+    terminalOutput() {
+      return piTerminalOutput ? {
+        ...piTerminalOutput,
+        usage: { ...piTerminalOutput.usage }
+      } : null;
+    },
     write(stream, chunk) {
       const key = stream === "stderr" ? "stderr" : "stdout";
       sourceCounts[key] += 1;
@@ -7444,10 +7821,10 @@ function realOrResolvedPath(value) {
   try {
     return realpathSync3(value);
   } catch {
-    return resolve10(value);
+    return resolve11(value);
   }
 }
-var LSOF_COMMAND = process.platform === "darwin" && existsSync11("/usr/sbin/lsof") ? "/usr/sbin/lsof" : "lsof";
+var LSOF_COMMAND = process.platform === "darwin" && existsSync12("/usr/sbin/lsof") ? "/usr/sbin/lsof" : "lsof";
 function processCwdForPid(pid) {
   if (process.platform === "linux") {
     try {
@@ -7569,7 +7946,7 @@ function killWorkspaceResidentProcesses(cwd, processGroupId, options = {}) {
 }
 function walkManagedWorkdirs(root) {
   const workdirs = [];
-  if (!root || !existsSync11(root)) return workdirs;
+  if (!root || !existsSync12(root)) return workdirs;
   const stack = [root];
   while (stack.length > 0) {
     const current = stack.pop();
@@ -7582,8 +7959,8 @@ function walkManagedWorkdirs(root) {
     }
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const fullPath = join12(current, entry.name);
-      if (entry.name === "workdir" && existsSync11(workspaceManifestPath(fullPath))) {
+      const fullPath = join13(current, entry.name);
+      if (entry.name === "workdir" && existsSync12(workspaceManifestPath(fullPath))) {
         workdirs.push(fullPath);
         continue;
       }
@@ -7621,8 +7998,8 @@ function manifestMatchesActiveRuntimeRef(manifest, refs, workdir = null) {
 }
 function buildOrphanReaperSample(root, workdir, manifest, residents) {
   const relativeWorkdir = (() => {
-    const value = relative7(root, workdir);
-    return value && !value.startsWith("..") && !isAbsolute7(value) ? value : basename6(workdir);
+    const value = relative8(root, workdir);
+    return value && !value.startsWith("..") && !isAbsolute8(value) ? value : basename6(workdir);
   })();
   return {
     workdir: relativeWorkdir,
@@ -7725,12 +8102,13 @@ function runExecutor(command, args, options) {
     const maxOutputBytes = parsePositiveInteger(options.maxOutputBytes, 50 * 1024 * 1024);
     const maxRssMb = parsePositiveInteger(options.maxRssMb, 0);
     const maxRssBytes = maxRssMb * 1024 * 1024;
-    const child = spawn(command, args, {
+    const spawnInvocation = managedChildSpawnInvocation(command, args, options.spawnIdentity);
+    const child = spawn(spawnInvocation.command, spawnInvocation.args, {
       cwd: options.cwd,
       env: options.env,
       detached: process.platform !== "win32",
       stdio: options.managedInput ? ["pipe", "pipe", "pipe", "pipe"] : ["pipe", "pipe", "pipe"],
-      ...options.spawnIdentity ?? {}
+      ...spawnInvocation.spawnIdentity
     });
     const processGroupId = processGroupIdForChild(child);
     const finish = (result2) => {
@@ -8012,6 +8390,7 @@ async function ingestRuntimeArtifacts(config, command, cwd, mcpToolResults) {
   if (!runId) throw new Error("Runtime Artifact ingest requires a correlated runId");
   const uploads = prepareRuntimeArtifactUploads(cwd, mcpToolResults);
   const receipts = [];
+  const failures = [];
   for (const upload of uploads) {
     const path = `/api/amaster/runtime-connectors/${connectorId}/artifact-intents/${encodeURIComponent(upload.intentId)}/ingest`;
     const sourcePathHeaders = /^[\x20-\x7e]+$/.test(upload.sourceRelativePath) ? { "x-amaster-artifact-source-path": upload.sourceRelativePath } : {
@@ -8025,8 +8404,13 @@ async function ingestRuntimeArtifacts(config, command, cwd, mcpToolResults) {
         "x-amaster-artifact-manifest-id": upload.manifestId,
         ...sourcePathHeaders
       }));
-      if (readString(receipt.intentId) !== upload.intentId || readString(receipt.status) !== "finalized") {
-        throw new Error(`Runtime Artifact ${upload.intentId} was not finalized: ${JSON.stringify(receipt)}`);
+      const receiptStatus = readString(receipt.status);
+      if (readString(receipt.intentId) !== upload.intentId || receiptStatus !== "finalized") {
+        const error = new Error(`Runtime Artifact ${upload.intentId} was not finalized: ${JSON.stringify(receipt)}`);
+        if (receiptStatus === "rejected") {
+          error.code = "runtime_artifact_rejected";
+        }
+        throw error;
       }
       receipts.push(receipt);
       await ingestLog(config, command, "system", "info", `Finalized Runtime Artifact ${upload.sourceRelativePath}`, {
@@ -8042,7 +8426,12 @@ async function ingestRuntimeArtifacts(config, command, cwd, mcpToolResults) {
       });
     } catch (err) {
       const message = `Runtime Artifact ${upload.intentId} ingest failed: ${err instanceof Error ? err.message : String(err)}`;
+      const failure = new Error(message, err instanceof Error ? { cause: err } : void 0);
+      if (err instanceof Error && err.code === "runtime_artifact_rejected") {
+        failure.code = "runtime_artifact_rejected";
+      }
       await ingestLog(config, command, "system", "error", message, {
+        event: "runtime_artifact_ingest_failed",
         presentationKind: "runtime_artifact_ingest",
         intentId: upload.intentId,
         manifestId: upload.manifestId,
@@ -8051,9 +8440,12 @@ async function ingestRuntimeArtifacts(config, command, cwd, mcpToolResults) {
         byteSize: upload.byteSize,
         status: "failed"
       });
-      throw new Error(message);
+      failures.push(failure);
     }
   }
+  if (failures.length > 0) {
+    throw new RuntimeArtifactIngestAggregateError(failures, receipts);
+  }
   return receipts;
 }
 function resultOutboxActiveRunSnapshot(command) {
@@ -8106,15 +8498,15 @@ async function completeCommand(config, command, status, result2, error) {
 }
 function resultOutboxDir(config) {
   const explicit = readString(process.env.AMASTER_RESULT_OUTBOX_DIR);
-  if (explicit) return resolve10(expandHomePath(explicit));
-  return join12(dirname8(stateFilePath(process.env)), "result-outbox");
+  if (explicit) return resolve11(expandHomePath(explicit));
+  return join13(dirname9(stateFilePath(process.env)), "result-outbox");
 }
 function resultOutboxInvalidDir(config) {
-  return join12(resultOutboxDir(config), "invalid");
+  return join13(resultOutboxDir(config), "invalid");
 }
 function writeResultOutboxEntry(config, entry) {
   const dir = resultOutboxDir(config);
-  mkdirSync7(dir, { recursive: true });
+  mkdirSync8(dir, { recursive: true });
   const body = {
     version: 1,
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -8122,16 +8514,16 @@ function writeResultOutboxEntry(config, entry) {
     lastAttemptAt: null,
     ...entry
   };
-  writeFileSync7(join12(dir, resultOutboxFileName(entry.commandId)), `${JSON.stringify(body, null, 2)}
+  writeFileSync8(join13(dir, resultOutboxFileName(entry.commandId)), `${JSON.stringify(body, null, 2)}
 `, { mode: 384 });
 }
 function moveResultOutboxEntryToInvalid(config, file, fullPath, reason, detail, original) {
   const invalidDir = resultOutboxInvalidDir(config);
-  mkdirSync7(invalidDir, { recursive: true });
-  const invalidPath = join12(invalidDir, file);
+  mkdirSync8(invalidDir, { recursive: true });
+  const invalidPath = join13(invalidDir, file);
   if (original === void 0) {
     try {
-      renameSync4(fullPath, invalidPath);
+      renameSync5(fullPath, invalidPath);
     } catch {
       copyFileSync3(fullPath, invalidPath);
       unlinkSync(fullPath);
@@ -8144,14 +8536,14 @@ function moveResultOutboxEntryToInvalid(config, file, fullPath, reason, detail,
     ...detail ? { detail: truncateText(detail, 1e3) } : {},
     original
   };
-  writeFileSync7(invalidPath, `${JSON.stringify(evidence, null, 2)}
+  writeFileSync8(invalidPath, `${JSON.stringify(evidence, null, 2)}
 `, { mode: 384 });
   unlinkSync(fullPath);
 }
 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);
@@ -8181,13 +8573,13 @@ function updateResultOutboxAttempt(fullPath, entry, err) {
     ...typeof err?.httpStatus === "number" ? { httpStatus: err.httpStatus } : {},
     lastError: truncateText(err instanceof Error ? err.message : String(err), 1e3)
   };
-  writeFileSync7(fullPath, `${JSON.stringify(next, null, 2)}
+  writeFileSync8(fullPath, `${JSON.stringify(next, null, 2)}
 `, { mode: 384 });
   return next;
 }
 function quarantineResultOutboxEntry(config, fullPath, file, entry, reason, err) {
   const invalidDir = resultOutboxInvalidDir(config);
-  mkdirSync7(invalidDir, { recursive: true });
+  mkdirSync8(invalidDir, { recursive: true });
   const body = {
     ...entry,
     invalidReason: reason,
@@ -8195,8 +8587,8 @@ function quarantineResultOutboxEntry(config, fullPath, file, entry, reason, err)
     ...typeof err?.httpStatus === "number" ? { httpStatus: err.httpStatus } : {},
     lastError: truncateText(err instanceof Error ? err.message : String(err), 1e3)
   };
-  const invalidPath = join12(invalidDir, file);
-  writeFileSync7(invalidPath, `${JSON.stringify(body, null, 2)}
+  const invalidPath = join13(invalidDir, file);
+  writeFileSync8(invalidPath, `${JSON.stringify(body, null, 2)}
 `, { mode: 384 });
   try {
     unlinkSync(fullPath);
@@ -8209,11 +8601,11 @@ function quarantineResultOutboxEntry(config, fullPath, file, entry, reason, err)
 }
 async function flushResultOutbox(config) {
   const dir = resultOutboxDir(config);
-  if (!existsSync11(dir)) return { attempted: 0, completed: 0 };
+  if (!existsSync12(dir)) return { attempted: 0, completed: 0 };
   const files = readdirSync8(dir).filter((name) => name.endsWith(".json")).sort();
   let completed = 0;
   for (const file of files) {
-    const fullPath = join12(dir, file);
+    const fullPath = join13(dir, file);
     const entry = readValidResultOutboxEntryOrQuarantine(config, file, fullPath);
     if (!entry) continue;
     try {
@@ -8410,8 +8802,8 @@ async function materializeIssueAttachments(config, command, workspace) {
     runtimeAuth,
     issueId
   );
-  const targetDir = join12(workspace.cwd, "input-attachments");
-  mkdirSync7(targetDir, { recursive: true });
+  const targetDir = join13(workspace.cwd, "input-attachments");
+  mkdirSync8(targetDir, { recursive: true });
   const usedFilenames = /* @__PURE__ */ new Set();
   const materialized = [];
   for (const [index, rawAttachment] of attachments.entries()) {
@@ -8425,11 +8817,11 @@ async function materializeIssueAttachments(config, command, workspace) {
       filename = `${stem}-${index + 1}${ext}`;
     }
     usedFilenames.add(filename);
-    const targetPath = join12(targetDir, filename);
+    const targetPath = join13(targetDir, filename);
     const body = await runtimeApiBuffer(runtimeAuth, contentPath);
-    writeFileSync7(targetPath, body);
+    writeFileSync8(targetPath, body);
     const attachmentId = readString(attachment.id);
-    const actualSha256 = createHash8("sha256").update(body).digest("hex");
+    const actualSha256 = createHash9("sha256").update(body).digest("hex");
     const lineageCandidates = lineageCandidatesByAttachmentId.get(attachmentId) ?? [];
     const lineage = selectAttachmentLineage(lineageCandidates, actualSha256);
     if (lineageCandidates.length > 0 && !lineage) {
@@ -8452,7 +8844,7 @@ async function materializeIssueAttachments(config, command, workspace) {
       id: attachmentId,
       name: readString(attachment.originalFilename) ?? filename,
       path: targetPath,
-      relativePath: relative7(workspace.cwd, targetPath),
+      relativePath: relative8(workspace.cwd, targetPath),
       contentType: readString(attachment.contentType),
       byteSize: body.byteLength,
       contentPath,
@@ -8501,9 +8893,9 @@ async function materializeRequiredArtifactInputs(config, command, workspace) {
   if (manifest.version !== 1 || !Array.isArray(manifest.entries)) {
     throw new Error("artifact_input_manifest_invalid: expected version 1 entries array");
   }
-  const targetRoot = join12(workspace.cwd, "input-artifacts");
-  rmSync6(targetRoot, { recursive: true, force: true });
-  mkdirSync7(targetRoot, { recursive: true });
+  const targetRoot = join13(workspace.cwd, "input-artifacts");
+  rmSync7(targetRoot, { recursive: true, force: true });
+  mkdirSync8(targetRoot, { recursive: true });
   const usedPaths = /* @__PURE__ */ new Set();
   const materialized = [];
   for (const [index, rawEntry] of manifest.entries.entries()) {
@@ -8521,7 +8913,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 = createHash8("sha256").update(body).digest("hex");
+    const actualSha256 = createHash9("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}`
@@ -8532,18 +8924,18 @@ async function materializeRequiredArtifactInputs(config, command, workspace) {
       id: attachmentId,
       originalFilename: readString(entry.originalFilename)
     }, index);
-    let relativePath = join12("input-artifacts", sourceDir, filename).split(/[\\/]+/).join("/");
+    let relativePath = join13("input-artifacts", sourceDir, filename).split(/[\\/]+/).join("/");
     if (usedPaths.has(relativePath)) {
       const ext = extname2(filename);
       const stem = ext ? filename.slice(0, -ext.length) : filename;
       filename = `${stem}-${index + 1}${ext}`;
-      relativePath = join12("input-artifacts", sourceDir, filename).split(/[\\/]+/).join("/");
+      relativePath = join13("input-artifacts", sourceDir, filename).split(/[\\/]+/).join("/");
     }
     usedPaths.add(relativePath);
-    const targetPath = join12(workspace.cwd, relativePath);
-    mkdirSync7(dirname8(targetPath), { recursive: true });
-    writeFileSync7(targetPath, body);
-    chmodSync5(targetPath, 292);
+    const targetPath = join13(workspace.cwd, relativePath);
+    mkdirSync8(dirname9(targetPath), { recursive: true });
+    writeFileSync8(targetPath, body);
+    chmodSync6(targetPath, 292);
     materialized.push({
       id: attachmentId,
       workProductId,
@@ -8562,9 +8954,9 @@ async function materializeRequiredArtifactInputs(config, command, workspace) {
     version: 1,
     entries: materialized.map(({ path: _path, relativePath, ...entry }) => ({ ...entry, path: relativePath }))
   };
-  const manifestPath = join12(targetRoot, "artifact-input-manifest.json");
-  writeFileSync7(manifestPath, JSON.stringify(localManifest, null, 2) + "\n");
-  chmodSync5(manifestPath, 292);
+  const manifestPath = join13(targetRoot, "artifact-input-manifest.json");
+  writeFileSync8(manifestPath, JSON.stringify(localManifest, null, 2) + "\n");
+  chmodSync6(manifestPath, 292);
   updateWorkspaceManifest(workspaceManifestPath(workspace), { artifactInputManifest: localManifest });
   await ingestLog(config, command, "system", "info", `Materialized ${materialized.length} required artifact input(s) into the execution workspace`, {
     artifactInputCount: materialized.length,
@@ -8573,46 +8965,46 @@ async function materializeRequiredArtifactInputs(config, command, workspace) {
   return materialized;
 }
 function issueCheckpointDir(workspace) {
-  return join12(dirname8(workspace.runDir), "checkpoint");
+  return join13(dirname9(workspace.runDir), "checkpoint");
 }
 async function clearIssueCheckpoint(config, command, workspace, reason) {
   const checkpointDir = issueCheckpointDir(workspace);
-  if (!existsSync11(checkpointDir)) return false;
-  rmSync6(checkpointDir, { recursive: true, force: true });
+  if (!existsSync12(checkpointDir)) return false;
+  rmSync7(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 (isAbsolute7(raw) || /^[A-Za-z]:[\\/]/.test(raw)) return null;
+  if (isAbsolute8(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 createHash8("sha256").update(readFileSync9(filePath)).digest("hex");
+  return createHash9("sha256").update(readFileSync10(filePath)).digest("hex");
 }
 async function materializeIssueCheckpoint(config, command, workspace) {
   const checkpointDir = issueCheckpointDir(workspace);
-  const manifestPath = join12(checkpointDir, "manifest.json");
-  if (!existsSync11(manifestPath)) return [];
+  const manifestPath = join13(checkpointDir, "manifest.json");
+  if (!existsSync12(manifestPath)) return [];
   let manifest;
   try {
-    manifest = asRecord(JSON.parse(readFileSync9(manifestPath, "utf8")));
+    manifest = asRecord(JSON.parse(readFileSync10(manifestPath, "utf8")));
   } catch (err) {
-    rmSync6(checkpointDir, { recursive: true, force: true });
+    rmSync7(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)) {
-    rmSync6(checkpointDir, { recursive: true, force: true });
+    rmSync7(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 = realpathSync3(join12(checkpointDir, "files"));
+    const filesRoot = realpathSync3(join13(checkpointDir, "files"));
     const workspaceRoot = realpathSync3(workspace.cwd);
     const validated = [];
     let totalBytes = 0;
@@ -8620,12 +9012,12 @@ async function materializeIssueCheckpoint(config, command, workspace) {
       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 = resolve10(filesRoot, relativePath);
-      const target = resolve10(workspaceRoot, relativePath);
+      const sourceCandidate = resolve11(filesRoot, relativePath);
+      const target = resolve11(workspaceRoot, relativePath);
       if (!pathWithin2(sourceCandidate, filesRoot) || !pathWithin2(target, workspaceRoot)) {
         throw new Error(`issue checkpoint path escapes its workspace: ${relativePath}`);
       }
-      if (!existsSync11(sourceCandidate)) throw new Error(`issue checkpoint file is missing: ${relativePath}`);
+      if (!existsSync12(sourceCandidate)) throw new Error(`issue checkpoint file is missing: ${relativePath}`);
       const source = realpathSync3(sourceCandidate);
       if (!pathWithin2(source, filesRoot) || !statSync7(source).isFile()) {
         throw new Error(`issue checkpoint source escapes its storage root: ${relativePath}`);
@@ -8645,13 +9037,13 @@ async function materializeIssueCheckpoint(config, command, workspace) {
     const materialized = [];
     for (const { relativePath, source, target } of validated) {
       try {
-        lstatSync6(target);
+        lstatSync7(target);
         continue;
       } catch (err) {
         if (err?.code !== "ENOENT") throw err;
       }
-      mkdirSync7(dirname8(target), { recursive: true });
-      const targetParent = realpathSync3(dirname8(target));
+      mkdirSync8(dirname9(target), { recursive: true });
+      const targetParent = realpathSync3(dirname9(target));
       if (!pathWithin2(targetParent, workspaceRoot)) {
         throw new Error(`issue checkpoint target escapes its workspace: ${relativePath}`);
       }
@@ -8679,31 +9071,31 @@ async function materializeIssueCheckpoint(config, command, workspace) {
 }
 async function saveIssueCheckpoint(config, command, workspace, candidates) {
   const checkpointDir = issueCheckpointDir(workspace);
-  const filesDir = join12(checkpointDir, "files");
-  rmSync6(checkpointDir, { recursive: true, force: true });
-  mkdirSync7(filesDir, { recursive: true });
+  const filesDir = join13(checkpointDir, "files");
+  rmSync7(checkpointDir, { recursive: true, force: true });
+  mkdirSync8(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 || !existsSync11(source) || !statSync7(source).isFile()) continue;
+    if (!relativePath || !source || !existsSync12(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 = resolve10(filesDir, relativePath);
+    const target = resolve11(filesDir, relativePath);
     if (!pathWithin2(target, filesDir)) continue;
-    mkdirSync7(dirname8(target), { recursive: true });
+    mkdirSync8(dirname9(target), { recursive: true });
     copyFileSync3(ownedSource, target);
     totalBytes += byteSize;
     files.push({ path: relativePath, byteSize, sha256: hashFileSha256(ownedSource) });
   }
   if (files.length === 0) {
-    rmSync6(checkpointDir, { recursive: true, force: true });
+    rmSync7(checkpointDir, { recursive: true, force: true });
     return null;
   }
   const manifest = {
@@ -8715,7 +9107,7 @@ async function saveIssueCheckpoint(config, command, workspace, candidates) {
     totalBytes,
     files
   };
-  writeFileSync7(join12(checkpointDir, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
+  writeFileSync8(join13(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;
@@ -8789,44 +9181,20 @@ async function executeRunCommand(config, command) {
   let cleanupManagedMcpProfile = null;
   const providerProtectedValues = [];
   let piChildIsolation = null;
+  let piChildAssignmentAcquired = false;
+  let piCompanyMemory = null;
   let trustedPiRuntime = null;
   let trustedPiRuntimeSourcePaths = null;
   let trustedPiRuntimeProfile = null;
   let trustedPiRuntimeAudit = null;
   let piResolvedProviderConfig = null;
-  if (executor.kind === "codex" && Object.keys(governedMcp).length > 0) {
-    managedMcpProfile = prepareManagedCodexMcpProfile({
-      commandId: command.commandId,
-      runId: commandRunId(command),
-      connectorVersion: CONNECTOR_VERSION,
-      executorCommand: invocation.command,
-      executorHome: workspace.executorHome,
-      runDir: workspace.runDir,
-      cwd,
-      runtimeAuth: commandRuntimeAuth(command),
-      nativeSession: asRecord(asRecord(command.payload).nativeSession),
-      baseEnv: executorEnv,
-      commandEnv: commandExecutorEnv(command),
-      extraArgs: splitExtraArgs(process.env.AMASTER_CODEX_EXTRA_ARGS)
-    });
-    cleanupManagedMcpProfile = cleanupManagedCodexMcpProfile;
-  }
-  if (executor.kind === "pi") {
-    if (piAgentLocalPlatformRunnerEnabled(config)) {
-      delete executorEnv.AMASTER_API_KEY;
-      delete executorEnv.AMASTER_PROVIDER_BASE_URL;
-      delete executorEnv.AMASTER_PROVIDER_DEFAULT_MODEL;
-      delete executorEnv.AMASTER_PROVIDER_FLASH_MODEL;
-    }
-    piResolvedProviderConfig = resolvePiExecutorProviderConfig(config, command, executorEnv);
-    for (const envName of ["AMASTER_API_KEY", "AMASTER_PLATFORM_OAUTH_TOKEN"]) {
-      const protectedValue = readString(piResolvedProviderConfig.providerConfig[envName]);
-      if (protectedValue && !providerProtectedValues.includes(protectedValue)) {
-        providerProtectedValues.push(protectedValue);
-      }
-    }
-    if (Object.keys(governedMcp).length > 0) {
-      managedMcpProfile = prepareManagedPiMcpProfile({
+  let forgetActiveRunCommand = () => {
+  };
+  let stopActiveRunHeartbeats = () => {
+  };
+  try {
+    if (executor.kind === "codex" && Object.keys(governedMcp).length > 0) {
+      managedMcpProfile = prepareManagedCodexMcpProfile({
         commandId: command.commandId,
         runId: commandRunId(command),
         connectorVersion: CONNECTOR_VERSION,
@@ -8838,165 +9206,220 @@ async function executeRunCommand(config, command) {
         nativeSession: asRecord(asRecord(command.payload).nativeSession),
         baseEnv: executorEnv,
         commandEnv: commandExecutorEnv(command),
-        extraArgs: splitExtraArgs(process.env.AMASTER_PI_EXTRA_ARGS)
+        extraArgs: splitExtraArgs(process.env.AMASTER_CODEX_EXTRA_ARGS)
       });
-      cleanupManagedMcpProfile = cleanupManagedPiMcpProfile;
-      for (const protectedValue of providerProtectedValues) {
-        if (!managedMcpProfile.protectedValues.includes(protectedValue)) {
-          managedMcpProfile.protectedValues.push(protectedValue);
-        }
-      }
+      cleanupManagedMcpProfile = cleanupManagedCodexMcpProfile;
     }
-  }
-  if (managedMcpProfile) {
-    executorEnv = managedMcpProfile.env;
-    await ingestLog(config, command, "system", "info", `Attested isolated ${executor.kind} managed MCP profile`, {
-      presentationKind: "managed_mcp_attestation",
-      ...managedMcpProfile.attestation
-    });
-  }
-  const piChildAllocator = executor.kind === "pi" ? configuredPiChildIdentityAllocator(config) : null;
-  const trustedPiRuntimeAssertion = commandTrustedPiRuntimeAssertion(command);
-  if (Object.keys(trustedPiRuntimeAssertion).length > 0) {
-    try {
-      if (executor.kind !== "pi") {
-        throw new Error("pi_trusted_runtime_assertion_binding_mismatch:executorKind");
+    if (executor.kind === "pi") {
+      if (piAgentLocalPlatformRunnerEnabled(config)) {
+        delete executorEnv.AMASTER_API_KEY;
+        delete executorEnv.AMASTER_PROVIDER_BASE_URL;
+        delete executorEnv.AMASTER_PROVIDER_DEFAULT_MODEL;
+        delete executorEnv.AMASTER_PROVIDER_FLASH_MODEL;
       }
-      trustedPiRuntimeSourcePaths = trustedPiRuntimeSources(config);
-      trustedPiRuntime = verifyTrustedPiRuntimeAssertion({
-        assertion: trustedPiRuntimeAssertion,
-        connectorId: requireConnectorId(config),
-        commandId: command.commandId,
-        runId: commandRunId(command),
-        leaseId: command.leaseId,
-        executorKind: executor.kind,
-        localDigests: readTrustedPiRuntimeLocalDigests(trustedPiRuntimeSourcePaths)
-      });
-      if (!managedMcpProfile) {
-        throw new Error("pi_trusted_runtime_governed_profile_required");
+      piResolvedProviderConfig = resolvePiExecutorProviderConfig(config, command, executorEnv);
+      for (const envName of ["AMASTER_API_KEY", "AMASTER_PLATFORM_OAUTH_TOKEN"]) {
+        const protectedValue = readString(piResolvedProviderConfig.providerConfig[envName]);
+        if (protectedValue && !providerProtectedValues.includes(protectedValue)) {
+          providerProtectedValues.push(protectedValue);
+        }
       }
-      requireTrustedPiChildAllocator(piChildAllocator, true);
-      trustedPiRuntimeProfile = materializeTrustedPiRuntimeProfile({
-        seedRoot: trustedPiRuntimeSourcePaths.seedRoot,
-        overlayRoot: trustedPiRuntimeSourcePaths.overlayRoot,
-        profileRoot: managedMcpProfile.profileRoot,
-        agentDir: managedMcpProfile.env.PI_CODING_AGENT_DIR,
-        governedMcpConfigPath: managedMcpProfile.configPath,
-        verifiedAssertion: trustedPiRuntime
-      });
-      executorEnv = {
-        ...executorEnv,
-        AMASTER_MANAGED_RUNTIME_ASSERTION_FD: "3",
-        AMASTER_MANAGED_RUNTIME_AUDIT_FILE: join12(
-          managedMcpProfile.env.HOME,
-          ".amaster-managed-runtime-audit.jsonl"
-        ),
-        AMASTER_RUNTIME_LEASE_ID: command.leaseId
-      };
-    } catch (error) {
-      if (managedMcpProfile) {
-        cleanupManagedMcpProfile(managedMcpProfile, {
+      if (Object.keys(governedMcp).length > 0) {
+        managedMcpProfile = prepareManagedPiMcpProfile({
           commandId: command.commandId,
-          runId: commandRunId(command)
+          runId: commandRunId(command),
+          connectorVersion: CONNECTOR_VERSION,
+          executorCommand: invocation.command,
+          executorHome: workspace.executorHome,
+          runDir: workspace.runDir,
+          cwd,
+          runtimeAuth: commandRuntimeAuth(command),
+          nativeSession: asRecord(asRecord(command.payload).nativeSession),
+          baseEnv: executorEnv,
+          commandEnv: commandExecutorEnv(command),
+          extraArgs: splitExtraArgs(process.env.AMASTER_PI_EXTRA_ARGS)
         });
+        cleanupManagedMcpProfile = cleanupManagedPiMcpProfile;
+        for (const protectedValue of providerProtectedValues) {
+          if (!managedMcpProfile.protectedValues.includes(protectedValue)) {
+            managedMcpProfile.protectedValues.push(protectedValue);
+          }
+        }
       }
-      throw error;
     }
-    await ingestLog(config, command, "system", "info", "Verified trusted Pi runtime provenance", {
-      presentationKind: "trusted_pi_runtime_attestation",
-      attestationId: trustedPiRuntime.attestationId,
-      unknownToolMode: trustedPiRuntime.unknownToolMode,
-      directToolBudget: trustedPiRuntime.directToolBudget,
-      digests: trustedPiRuntime.digests,
-      profileAttestationId: trustedPiRuntimeProfile.attestationId,
-      inheritedEntries: trustedPiRuntimeProfile.facts.inheritedEntries
-    });
-  }
-  if (executor.kind === "pi" && piResolvedProviderConfig) {
-    const agentDir = managedMcpProfile ? readString(managedMcpProfile.env.PI_CODING_AGENT_DIR) ?? readString(managedMcpProfile.env.PI_AGENT_HOME) ?? null : piAgentLocalPlatformRunnerEnabled(config) ? readString(executorEnv.PI_AGENT_HOME) ?? readString(executorEnv.PI_CODING_AGENT_DIR) ?? null : readString(executorEnv.PI_CODING_AGENT_DIR) ?? readString(executorEnv.PI_AGENT_HOME) ?? null;
-    try {
-      await syncPiExecutorProviderConfig(
-        config,
-        command,
-        agentDir,
-        piResolvedProviderConfig
-      );
-    } catch (error) {
-      if (managedMcpProfile && cleanupManagedMcpProfile) {
-        cleanupManagedMcpProfile(managedMcpProfile, {
+    if (managedMcpProfile) {
+      executorEnv = managedMcpProfile.env;
+      await ingestLog(config, command, "system", "info", `Attested isolated ${executor.kind} managed MCP profile`, {
+        presentationKind: "managed_mcp_attestation",
+        ...managedMcpProfile.attestation
+      });
+    }
+    const piChildAllocator2 = executor.kind === "pi" ? configuredPiChildIdentityAllocator(config) : null;
+    const trustedPiRuntimeAssertion = commandTrustedPiRuntimeAssertion(command);
+    if (Object.keys(trustedPiRuntimeAssertion).length > 0) {
+      try {
+        if (executor.kind !== "pi") {
+          throw new Error("pi_trusted_runtime_assertion_binding_mismatch:executorKind");
+        }
+        trustedPiRuntimeSourcePaths = trustedPiRuntimeSources(config);
+        trustedPiRuntime = verifyTrustedPiRuntimeAssertion({
+          assertion: trustedPiRuntimeAssertion,
+          connectorId: requireConnectorId(config),
           commandId: command.commandId,
-          runId: commandRunId(command)
+          runId: commandRunId(command),
+          leaseId: command.leaseId,
+          executorKind: executor.kind,
+          localDigests: readTrustedPiRuntimeLocalDigests(trustedPiRuntimeSourcePaths)
         });
-        managedMcpProfile = null;
+        if (!managedMcpProfile) {
+          throw new Error("pi_trusted_runtime_governed_profile_required");
+        }
+        requireTrustedPiChildAllocator(piChildAllocator2, true);
+        trustedPiRuntimeProfile = materializeTrustedPiRuntimeProfile({
+          seedRoot: trustedPiRuntimeSourcePaths.seedRoot,
+          overlayRoot: trustedPiRuntimeSourcePaths.overlayRoot,
+          profileRoot: managedMcpProfile.profileRoot,
+          agentDir: managedMcpProfile.env.PI_CODING_AGENT_DIR,
+          governedMcpConfigPath: managedMcpProfile.configPath,
+          verifiedAssertion: trustedPiRuntime
+        });
+        executorEnv = {
+          ...executorEnv,
+          AMASTER_MANAGED_RUNTIME_ASSERTION_FD: "3",
+          AMASTER_MANAGED_RUNTIME_AUDIT_FILE: join13(
+            managedMcpProfile.env.HOME,
+            ".amaster-managed-runtime-audit.jsonl"
+          ),
+          AMASTER_RUNTIME_LEASE_ID: command.leaseId
+        };
+      } catch (error2) {
+        if (managedMcpProfile) {
+          cleanupManagedMcpProfile(managedMcpProfile, {
+            commandId: command.commandId,
+            runId: commandRunId(command)
+          });
+        }
+        throw error2;
       }
-      throw error;
-    }
-  }
-  if (piChildAllocator) {
-    try {
-      const profileRoot = piChildIsolationProfileRoot({
-        managedMcpProfile,
-        executorHome: workspace.executorHome
-      });
-      piChildIsolation = preparePiChildIsolation({
-        allocator: piChildAllocator,
-        effectiveUid: typeof process.geteuid === "function" ? process.geteuid() : null,
-        commandId: command.commandId,
-        runId: commandRunId(command),
-        profileRoot,
-        workspaceRoot: cwd,
-        allowedRoot: config.runtimeWorkspacesRoot
+      await ingestLog(config, command, "system", "info", "Verified trusted Pi runtime provenance", {
+        presentationKind: "trusted_pi_runtime_attestation",
+        attestationId: trustedPiRuntime.attestationId,
+        unknownToolMode: trustedPiRuntime.unknownToolMode,
+        directToolBudget: trustedPiRuntime.directToolBudget,
+        digests: trustedPiRuntime.digests,
+        profileAttestationId: trustedPiRuntimeProfile.attestationId,
+        inheritedEntries: trustedPiRuntimeProfile.facts.inheritedEntries
       });
-    } catch (error) {
-      if (managedMcpProfile) {
-        cleanupManagedMcpProfile(managedMcpProfile, {
+    }
+    if (executor.kind === "pi" && piResolvedProviderConfig) {
+      const agentDir = managedMcpProfile ? readString(managedMcpProfile.env.PI_CODING_AGENT_DIR) ?? readString(managedMcpProfile.env.PI_AGENT_HOME) ?? null : piAgentLocalPlatformRunnerEnabled(config) ? readString(executorEnv.PI_AGENT_HOME) ?? readString(executorEnv.PI_CODING_AGENT_DIR) ?? null : readString(executorEnv.PI_CODING_AGENT_DIR) ?? readString(executorEnv.PI_AGENT_HOME) ?? null;
+      try {
+        await syncPiExecutorProviderConfig(
+          config,
+          command,
+          agentDir,
+          piResolvedProviderConfig
+        );
+      } catch (error2) {
+        if (managedMcpProfile && cleanupManagedMcpProfile) {
+          cleanupManagedMcpProfile(managedMcpProfile, {
+            commandId: command.commandId,
+            runId: commandRunId(command)
+          });
+          managedMcpProfile = null;
+        }
+        throw error2;
+      }
+    }
+    if (piChildAllocator2) {
+      try {
+        const companyId = readString(commandRuntimeAuth(command).companyId) ?? readString(asRecord(command.payload).companyId);
+        if (!companyId) throw new Error("pi_company_memory_company_id_required");
+        const companyMemoryGroup = resolveCompanyPiMemoryGroup({
+          root: companyPiHomeRoot(process.env),
+          companyId
+        });
+        const assignment = piChildAllocator2.acquire(commandRunId(command), {
+          gid: companyMemoryGroup.gid
+        });
+        piChildAssignmentAcquired = true;
+        if (managedMcpProfile) {
+          piCompanyMemory = prepareCompanyPiMemory({
+            root: companyMemoryGroup.root,
+            companyId,
+            gid: companyMemoryGroup.gid,
+            profileRoot: managedMcpProfile.profileRoot,
+            profileHome: managedMcpProfile.env.PI_AGENT_HOME,
+            childUid: assignment.uid
+          });
+        }
+        const profileRoot = piChildIsolationProfileRoot({
+          managedMcpProfile,
+          executorHome: workspace.executorHome
+        });
+        piChildIsolation = preparePiChildIsolation({
+          allocator: piChildAllocator2,
+          effectiveUid: typeof process.geteuid === "function" ? process.geteuid() : null,
           commandId: command.commandId,
-          runId: commandRunId(command)
+          runId: commandRunId(command),
+          ...piCompanyMemory ? { gid: piCompanyMemory.gid } : {},
+          profileRoot,
+          workspaceRoot: cwd,
+          allowedRoot: config.runtimeWorkspacesRoot
         });
+      } catch (error2) {
+        if (piChildAssignmentAcquired) {
+          piChildAllocator2.release(commandRunId(command));
+          piChildAssignmentAcquired = false;
+        }
+        if (managedMcpProfile) {
+          cleanupManagedMcpProfile(managedMcpProfile, {
+            commandId: command.commandId,
+            runId: commandRunId(command)
+          });
+        }
+        throw error2;
       }
-      throw error;
+      await ingestLog(config, command, "system", "info", "Prepared isolated Pi child identity", {
+        presentationKind: "pi_child_isolation_attestation",
+        ...piChildIsolation.attestation,
+        ...piCompanyMemory ? { companyMemory: piCompanyMemory.attestation } : {}
+      });
     }
-    await ingestLog(config, command, "system", "info", "Prepared isolated Pi child identity", {
-      presentationKind: "pi_child_isolation_attestation",
-      ...piChildIsolation.attestation
+    await ingestLog(config, command, "system", "info", `Compiled ${contextManifest.mode} prompt using ${contextManifest.budget.usedChars}/${contextManifest.budget.totalChars} characters`, {
+      presentationKind: "context_manifest",
+      contextManifest
     });
-  }
-  await ingestLog(config, command, "system", "info", `Compiled ${contextManifest.mode} prompt using ${contextManifest.budget.usedChars}/${contextManifest.budget.totalChars} characters`, {
-    presentationKind: "context_manifest",
-    contextManifest
-  });
-  await ackCommand(config, command, "spawned");
-  await ingestLog(config, command, "system", "info", `Starting ${executor.kind} executor`, {
-    executorKind: executor.kind,
-    cwd,
-    args: invocation.args
-  });
-  const forgetActiveRunCommand = rememberActiveRunCommand(command, {
-    executorKind: executor.kind,
-    workspacePath: cwd,
-    sourceWorkspacePath: workspace.sourceWorkspacePath,
-    managedWorkdir: workspace.managed,
-    manifestPath: workspaceManifestPath(workspace),
-    outputFloodLimitBytesPerStream: config.executorMaxOutputBytes,
-    ...managedMcpProfile ? { managedMcpAttestation: managedMcpProfile.attestation } : {}
-  });
-  const abortController = new AbortController();
-  const stopActiveRunHeartbeats = startActiveRunHeartbeats(config, command, abortController);
-  const protectedExecutorValues = managedMcpProfile?.protectedValues ?? providerProtectedValues;
-  const runtimeArtifacts = [];
-  const runtimeArtifactIngest = createRuntimeArtifactIngestQueue({
-    ingest: (results) => ingestRuntimeArtifacts(config, command, cwd, results),
-    onError: () => abortController.abort()
-  });
-  const liveOutputLogger = createLiveOutputLogger(
-    config,
-    command,
-    executor.kind,
-    protectedExecutorValues,
-    (results) => runtimeArtifactIngest.enqueue(results)
-  );
-  let execution;
-  try {
+    await ackCommand(config, command, "spawned");
+    await ingestLog(config, command, "system", "info", `Starting ${executor.kind} executor`, {
+      executorKind: executor.kind,
+      cwd,
+      args: invocation.args
+    });
+    forgetActiveRunCommand = rememberActiveRunCommand(command, {
+      executorKind: executor.kind,
+      workspacePath: cwd,
+      sourceWorkspacePath: workspace.sourceWorkspacePath,
+      managedWorkdir: workspace.managed,
+      manifestPath: workspaceManifestPath(workspace),
+      outputFloodLimitBytesPerStream: config.executorMaxOutputBytes,
+      ...managedMcpProfile ? { managedMcpAttestation: managedMcpProfile.attestation } : {}
+    });
+    const abortController = new AbortController();
+    stopActiveRunHeartbeats = startActiveRunHeartbeats(config, command, abortController);
+    const protectedExecutorValues = managedMcpProfile?.protectedValues ?? providerProtectedValues;
+    const runtimeArtifacts = [];
+    const runtimeArtifactIngest = createRuntimeArtifactIngestQueue({
+      ingest: (results) => ingestRuntimeArtifacts(config, command, cwd, results)
+    });
+    const liveOutputLogger = createLiveOutputLogger(
+      config,
+      command,
+      executor.kind,
+      protectedExecutorValues,
+      (results) => runtimeArtifactIngest.enqueue(results)
+    );
+    let execution;
     try {
       execution = await runExecutor(invocation.command, invocation.args, {
         cwd,
@@ -9065,6 +9488,19 @@ async function executeRunCommand(config, command) {
       errorMessage: null
     } : executor.kind === "codex" ? parseCodexJsonl(execution.stdout) : executor.kind === "claude" ? parseClaudeStreamJson(execution.stdout) : executor.kind === "opencode" ? parseOpenCodeJsonl(execution.stdout) : executor.kind === "pi" ? parsePiJsonl(execution.stdout) : parseGenericOutput(execution.stdout, execution.stderr);
     parsed.sessionId ??= liveOutputLogger.sessionId();
+    const liveTerminalOutput = executor.kind === "pi" && !hasOutputFlood ? liveOutputLogger.terminalOutput() : null;
+    if (liveTerminalOutput) {
+      const parsedUsage = asRecord(parsed.usage);
+      const liveUsage = asRecord(liveTerminalOutput.usage);
+      parsed.summary = liveTerminalOutput.summary;
+      parsed.hasAssistantOutput = true;
+      parsed.usage = {
+        inputTokens: readNumber(liveUsage.inputTokens, 0) || readNumber(parsedUsage.inputTokens, 0),
+        cachedInputTokens: readNumber(liveUsage.cachedInputTokens, 0) || readNumber(parsedUsage.cachedInputTokens, 0),
+        outputTokens: readNumber(liveUsage.outputTokens, 0) || readNumber(parsedUsage.outputTokens, 0),
+        ...readNumber(liveUsage.costUsd, 0) > 0 || readNumber(parsedUsage.costUsd, 0) > 0 ? { costUsd: readNumber(liveUsage.costUsd, 0) || readNumber(parsedUsage.costUsd, 0) } : {}
+      };
+    }
     const outputTelemetry = liveOutputLogger.snapshot({
       outputBytes: execution.outputBytes,
       floodLimitBytes: config.executorMaxOutputBytes,
@@ -9119,7 +9555,7 @@ async function executeRunCommand(config, command) {
           workspace,
           workspaceStatus.artifacts.map((artifact) => ({
             rawPath: artifact.relativePath,
-            filePath: resolve10(cwd, artifact.relativePath)
+            filePath: resolve11(cwd, artifact.relativePath)
           }))
         );
         nativeSessionRollout = {
@@ -9171,6 +9607,7 @@ async function executeRunCommand(config, command) {
       allowMissingTurnEnd: completionOutputStopped,
       allowMissingAssistantOutput: execution.completionOutputType === "approval_required"
     }) : null;
+    const piProviderFailure = executor.kind === "pi" && !cancelled && !hasOutputFlood && !hasMemoryLimit && execution.timedOut !== true && !execution.spawnError ? classifyPiProviderError(parsed) : null;
     const parsedErrorMessage = outputFloodError ?? memoryLimitError ?? piInvalidOutputError ?? nativeSessionRolloutError ?? nativeSessionRolloutCleanupError ?? parsed.errorMessage;
     const codexTransientFailure = executor.kind === "codex" && (execution.exitCode ?? 0) !== 0 ? classifyCodexTransientUpstreamError({
       stdout: execution.stdout,
@@ -9246,10 +9683,11 @@ async function executeRunCommand(config, command) {
       ...Array.isArray(execution.killedWorkspaceResidents) && execution.killedWorkspaceResidents.length > 0 ? {
         killedWorkspaceResidents: execution.killedWorkspaceResidents
       } : {},
-      ...piInvalidOutputError && !hasOutputFlood ? {
+      ...piInvalidOutputError && !cancelled && !hasOutputFlood && !hasMemoryLimit && execution.timedOut !== true && !execution.spawnError && !piProviderFailure ? {
         errorCode: "pi_executor_invalid_output",
         errorFamily: "validation"
       } : {},
+      ...piProviderFailure ? piProviderFailure : {},
       ...codexTransientFailure ? codexTransientFailure : {},
       ...piUsageDiagnostic && !piInvalidOutputError ? {
         piDiagnostics: {
@@ -9267,6 +9705,9 @@ async function executeRunCommand(config, command) {
       ...piChildIsolation ? {
         piChildIsolation: piChildIsolation.attestation
       } : {},
+      ...piCompanyMemory ? {
+        companyMemory: piCompanyMemory.attestation
+      } : {},
       ...trustedPiRuntimeProfile ? {
         trustedPiRuntime: {
           attestationId: trustedPiRuntime.attestationId,
@@ -9297,6 +9738,9 @@ async function executeRunCommand(config, command) {
       });
     }
     piChildIsolation?.release();
+    if (!piChildIsolation && piChildAssignmentAcquired) {
+      piChildAllocator?.release(commandRunId(command));
+    }
     stopActiveRunHeartbeats();
     forgetActiveRunCommand();
   }
@@ -9325,10 +9769,14 @@ async function processCommand(config, command) {
     });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
+    const errorCode = readString(asRecord(err).code);
+    const runtimeArtifacts = Array.isArray(asRecord(err).receipts) ? asRecord(err).receipts.map(asRecord) : [];
     await ingestLog(config, command, "system", "error", message);
     await completeCommand(config, command, "failed", {
       summary: message,
-      commandType: command.commandType
+      commandType: command.commandType,
+      ...errorCode && /^[a-z][a-z0-9_]{0,127}$/.test(errorCode) ? { errorCode } : {},
+      ...runtimeArtifacts.length > 0 ? { runtimeArtifacts } : {}
     }, message);
   }
 }
@@ -9499,7 +9947,7 @@ async function runLoop(config) {
 ${message}
 `);
     }
-    await new Promise((resolve11) => setTimeout(resolve11, config.pollIntervalSeconds * 1e3));
+    await new Promise((resolve12) => setTimeout(resolve12, config.pollIntervalSeconds * 1e3));
   }
 }
 function help() {