@amaster.ai/employee-runtime-connector 0.1.1-beta.266 → 0.1.1-beta.267

package/dist/amaster-runtime-daemon/capability-registry.mjs

@@ -18,9 +18,16 @@ export const BUILD_SUPPORTED_CAPABILITIES = Object.freeze([
   "logs_cost_workspace_status",
   "browser_credential_ref_fill_v1",
   "execution_lanes_v1",
+  "mirrorx_initialization_context_v1",
+  "mirrorx_initialization_completion_v1",
 ]);
 
 const DYNAMIC_READINESS = Object.freeze({
+  mirrorx_initialization_completion_v1: {
+    reasonCode: "managed_linux_pi_required",
+    ready: (input) => process.platform === "linux" && input.runnerKind === "cloud_managed"
+      && input.executors.some((executor) => executor.kind === "pi"),
+  },
   artifact_template_catalog_v1: {
     reasonCode: "artifact_template_catalog_not_ready",
     ready: (input) => {

package/dist/amaster-runtime-daemon.mjs

@@ -5114,7 +5114,9 @@ var AMASTER_RUNTIME_CONNECTOR_CAPABILITIES = [
   "continue_task_v1",
   "run_exit_live_path_closure_v1",
   "browser_credential_ref_fill_v1",
-  "execution_lanes_v1"
+  "execution_lanes_v1",
+  "mirrorx_initialization_context_v1",
+  "mirrorx_initialization_completion_v1"
 ];
 var RUNTIME_EXECUTION_LANES = ["business", "conversation"];
 var runtimeExecutionLaneSchema = external_exports.enum(RUNTIME_EXECUTION_LANES);
@@ -13795,7 +13797,11 @@ var governedBusinessTaskEnrollmentReadModelSchema = external_exports.object({
   discoverySource: governedBusinessTaskDiscoverySourceSchema.nullable(),
   finding: external_exports.object({
     code: external_exports.string().trim().min(1),
-    message: external_exports.string().trim().min(1)
+    message: external_exports.string().trim().min(1),
+    invalidFields: external_exports.array(external_exports.object({
+      path: external_exports.string().trim().min(1),
+      code: external_exports.string().trim().min(1)
+    }).strict()).max(20).optional()
   }).strict().nullable()
 }).strict();
 
@@ -16742,7 +16748,8 @@ var companyArtifactSchema = external_exports.object({
   issue: external_exports.object({
     id: external_exports.string().uuid(),
     identifier: external_exports.string(),
-    title: external_exports.string()
+    title: external_exports.string(),
+    status: external_exports.string().optional()
   }),
   project: external_exports.object({
     id: external_exports.string().uuid(),
@@ -16761,7 +16768,8 @@ var companyArtifactGroupSchema = external_exports.object({
   issue: external_exports.object({
     id: external_exports.string().uuid(),
     identifier: external_exports.string(),
-    title: external_exports.string()
+    title: external_exports.string(),
+    status: external_exports.string().optional()
   }),
   title: external_exports.string(),
   count: external_exports.number().int().min(0),
@@ -22066,6 +22074,343 @@ function reconcileManagedCodebuddyMcpProfiles(rootPath, options = {}) {
   };
 }
 
+// src/amaster-runtime-daemon/pi-initialization-completion.mjs
+async function runInitializationCompletion({ plan, authority, call, sleep, now, onReceipt = () => {
+}, timeoutMs = 12e4 }) {
+  const deadline = now() + timeoutMs;
+  const receipts = [];
+  let stage = "upload";
+  let callId;
+  const fail3 = (code, detail) => {
+    throw Object.assign(new Error(code), { detail });
+  };
+  async function invoke(name, args) {
+    if (now() >= deadline) fail3("initialization_completion_deadline");
+    let envelope;
+    for (let transportFailures = 0; ; ) {
+      if (now() >= deadline) fail3("initialization_completion_deadline");
+      try {
+        envelope = await call(name, args, Math.min(45e3, deadline - now()));
+        break;
+      } catch (error) {
+        if (error?.retryable !== true) throw error;
+        const leaseWait = error.code === "invocation_in_progress" && Number.isSafeInteger(error.retryAfterMs) && error.retryAfterMs >= 0;
+        if (!leaseWait && ++transportFailures >= 3) throw error;
+        const delay = leaseWait ? Math.max(1e3, error.retryAfterMs) : 1e3 * transportFailures;
+        await sleep(Math.min(delay, Math.max(0, deadline - now())));
+      }
+    }
+    const content = envelope?.content;
+    const provider = envelope?.providerReceipt;
+    if (!envelope?.invocationId || provider?.invocationId !== envelope.invocationId || provider?.provider !== "amaster_actions" || !["runId", "commandId", "issueId"].every((key) => authority[key] && provider[key] === authority[key]) || content?.schemaVersion !== "runtime-action-v1" || content?.toolName !== name.replace("runtime_action_", "runtime_action.")) {
+      fail3("initialization_completion_receipt_mismatch");
+    }
+    if (envelope.status !== "succeeded" || !["accepted", "pending_reconcile"].includes(content.status)) {
+      fail3("initialization_completion_action_not_accepted", content.error ?? { status: envelope.status });
+    }
+    const result2 = content.result;
+    await onReceipt(envelope);
+    receipts.push({
+      stage,
+      invocationId: envelope.invocationId,
+      callId: result2?.callId,
+      planId: result2?.planId,
+      status: result2?.status
+    });
+    if (!result2 || result2.error) fail3("initialization_completion_action_failed", result2?.error);
+    return result2;
+  }
+  async function settleCall(value, actionType) {
+    callId = value.callId;
+    if (!callId || value.actionType !== actionType) fail3("initialization_completion_call_mismatch");
+    for (let attempt = 0; ; attempt++) {
+      if (value.callId !== callId || value.actionType !== actionType) fail3("initialization_completion_call_mismatch");
+      if (value.status === "succeeded") return value;
+      if (!["pending_reconcile", "claimed", "executing"].includes(value.status)) {
+        fail3("initialization_completion_action_incomplete", { status: value.status, error: value.error });
+      }
+      if (now() >= deadline) fail3("initialization_completion_deadline");
+      await sleep(Math.min(1e3 * (attempt + 1), 5e3));
+      value = await invoke("runtime_action_status", { callId });
+    }
+  }
+  try {
+    const doc = plan.initializationDocument;
+    const materialized = plan.initializationDocumentMaterialization;
+    if (!plan.planId || !plan.revision || !["planned", "committing", "pending_reconcile", "completed"].includes(plan.status) || materialized?.status !== "materialized" || materialized.planId !== plan.planId || materialized.revision !== plan.revision || materialized.sha256 !== doc?.sha256 || materialized.byteSize !== doc?.byteSize || materialized.path !== doc?.path) {
+      fail3("initialization_completion_invalid_plan");
+    }
+    const prefix = "initialization-complete:" + plan.planId;
+    const { createHash: createHash19 } = await import("node:crypto");
+    const uploadKey = prefix + ":upload:" + createHash19("sha256").update(materialized.path).digest("hex");
+    const upload = await settleCall(await invoke("runtime_action_submit", {
+      idempotencyKey: uploadKey,
+      action: {
+        type: "upload_artifact",
+        idempotencyKey: uploadKey,
+        path: materialized.path,
+        title: "Organization Plan",
+        contentType: "text/markdown",
+        artifactPurpose: "initialization_organization_plan",
+        createWorkProduct: true,
+        evidenceRole: "source",
+        isPrimary: true,
+        status: "ready_for_review"
+      }
+    }), "upload_artifact");
+    if (upload.postcondition?.artifactFinalized !== true || upload.postcondition?.attachmentReadback !== true || upload.postcondition?.workProductReadback !== true || upload.effectResult?.sha256 !== doc.sha256 || upload.effectResult?.byteSize !== doc.byteSize || !upload.effectResult?.attachmentId || !upload.effectResult?.workProductId) {
+      fail3("initialization_completion_artifact_mismatch");
+    }
+    stage = "commit";
+    callId = void 0;
+    const committed = await invoke("runtime_action_commit", { planId: plan.planId, revision: plan.revision });
+    if (committed.planId !== plan.planId || committed.revision !== plan.revision || committed.status !== "completed" || committed.failure || committed.nextActionIndex !== committed.actionCount) {
+      fail3("initialization_completion_plan_incomplete", { status: committed.status, failure: committed.failure });
+    }
+    stage = "ready";
+    const completed = await settleCall(await invoke("runtime_action_submit", {
+      idempotencyKey: prefix + ":done",
+      action: { type: "update_parent", status: "done" }
+    }), "update_parent");
+    if (completed.effectResult?.issueId !== authority.issueId || completed.effectResult?.status !== "done" || completed.postcondition?.issuePersisted !== true || completed.postcondition?.status !== "done" || completed.postcondition?.issueTerminalizationDeferred === true) {
+      fail3("initialization_completion_ready_not_confirmed");
+    }
+    return {
+      status: "completed",
+      planId: plan.planId,
+      revision: plan.revision,
+      attachmentId: upload.effectResult.attachmentId,
+      workProductId: upload.effectResult.workProductId,
+      completionCallId: completed.callId,
+      receipts
+    };
+  } catch (error) {
+    return {
+      status: "incomplete",
+      stage,
+      planId: plan.planId,
+      revision: plan.revision,
+      callId,
+      code: error.message,
+      detail: error.detail,
+      receipts
+    };
+  }
+}
+function managedPiInitializationCompletionSource() {
+  return `const runInitializationCompletion = ${runInitializationCompletion.toString()};
+async function initializationCompletionCall(name, args, timeoutMs = 45000) {
+  const server = JSON.parse(fs.readFileSync(configPath, "utf8")).mcpServers.amaster;
+  const id = randomUUID();
+  const chunks = []; let size = 0; let status;
+  try {
+  const response = await fetch(server.url, { method: "POST", redirect: "error",
+    headers: { ...server.headers, "Content-Type": "application/json", Accept: "application/json" },
+    body: JSON.stringify({ jsonrpc: "2.0", id, method: "tools/call", params: { name, arguments: args } }),
+    signal: AbortSignal.timeout(timeoutMs) });
+  status = response.status;
+  if (!response.ok && status !== 409) {
+    await response.body?.cancel();
+    throw Object.assign(new Error("initialization_completion_http_" + response.status), {
+      retryable: [429, 500, 502, 503, 504].includes(response.status),
+    });
+  }
+  for await (const part of response.body) {
+    size += part.length;
+    if (size > 256 * 1024) throw new Error("initialization_completion_response_too_large");
+    chunks.push(part);
+  }
+  } catch (error) {
+    if (["TypeError", "TimeoutError", "AbortError"].includes(error?.name)) error.retryable = true;
+    throw error;
+  }
+  const rpc = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+  if (status === 409) {
+    const data = rpc?.error?.data;
+    const leaseWait = rpc?.jsonrpc === "2.0" && rpc.id === id
+      && data?.reasonCode === "invocation_in_progress"
+      && Number.isSafeInteger(data.retryAfterMs) && data.retryAfterMs >= 0;
+    throw Object.assign(new Error(leaseWait ? "invocation_in_progress" : "initialization_completion_http_409"), {
+      retryable: leaseWait, code: leaseWait ? "invocation_in_progress" : undefined,
+      retryAfterMs: leaseWait ? data.retryAfterMs : undefined,
+    });
+  }
+  if (rpc?.id !== id || rpc.error) throw new Error("initialization_completion_rpc_error");
+  return JSON.parse(rpc.result?.content?.[0]?.text);
+}`;
+}
+
+// src/amaster-runtime-daemon/pi-initialization-document.mjs
+function managedPiInitializationDocumentExtensionSource(cwd, configPath = `${cwd}/.pi/mcp.json`, completionAuthority = null) {
+  return `import fs from "node:fs";
+import { createHash, randomUUID } from "node:crypto";
+const cwd = ${JSON.stringify(cwd)};
+const configPath = ${JSON.stringify(configPath)};
+const completionAuthority = ${JSON.stringify(completionAuthority)};
+${managedPiInitializationCompletionSource()}
+export default function(pi) {
+  pi.on("tool_result", async (event) => {
+    // Linux dir-fd paths prevent a concurrent directory replacement redirecting writes.
+    // Other executors retain the original document workflow.
+    if (process.platform !== "linux" || event.isError || event.details?.server !== "amaster"
+      || !["runtime_action_plan", "runtime_action_status"].includes(event.toolName)) return;
+    if (!Array.isArray(event.content) || event.content.length !== 1 || event.content[0].type !== "text") return;
+    let envelope;
+    try { envelope = JSON.parse(event.content[0].text); } catch { return; }
+    const call = envelope?.content;
+    const result = call?.result;
+    const doc = result?.initializationDocument;
+    if (envelope?.status !== "succeeded" || call?.status !== "accepted"
+      || call?.schemaVersion !== "runtime-action-v1"
+      || !["runtime_action.plan", "runtime_action.status"].includes(call?.toolName) || !doc) return;
+    let root, parent, file, temp;
+    const canonicalName = "organization-plan-" + result.planId + ".md";
+    let targetName = canonicalName;
+    try {
+      if (doc.version !== 1 || (doc.path !== "deliverables/" + targetName
+          && !(typeof doc.markdown === "string" && doc.path === "deliverables/organization-plan.md"))
+        || doc.contentType !== "text/markdown" || !/^[0-9a-f]{64}$/.test(doc.sha256)
+        || !/^[0-9a-f-]{36}$/.test(result.planId) || !result.revision || !doc.initializationId
+        || !Number.isSafeInteger(doc.initializationRevision) || doc.initializationRevision < 1
+        || !Number.isSafeInteger(doc.byteSize) || doc.byteSize < 1 || doc.byteSize > 64 * 1024 * 1024) {
+        throw new Error("invalid_document_snapshot");
+      }
+      if (doc.contentRef && (doc.contentRef.kind !== "initialization_plan_document"
+        || doc.contentRef.planId !== result.planId || doc.contentRef.readTool !== "runtime_action.status")) {
+        throw new Error("invalid_document_reference");
+      }
+      // Pin the directory and verify existing bytes before loading credentials or reading chunks.
+      const flags = fs.constants.O_RDONLY | fs.constants.O_DIRECTORY | fs.constants.O_NOFOLLOW;
+      root = fs.openSync(cwd, flags);
+      const rootPath = "/proc/self/fd/" + root;
+      try { fs.mkdirSync(rootPath + "/deliverables", { mode: 0o700 }); }
+      catch (error) { if (error.code !== "EEXIST") throw error; }
+      parent = fs.openSync(rootPath + "/deliverables", flags);
+      const parentPath = "/proc/self/fd/" + parent;
+      let target;
+      // Preserve conflicts and select a stable alternate; replay verifies these same candidates.
+      function selectTarget() {
+        for (let attempt = 0; attempt < 32; attempt++) {
+          targetName = attempt === 0 ? canonicalName
+            : "organization-plan-" + result.planId + "-" + doc.sha256 + "-" + attempt + ".md";
+          target = parentPath + "/" + targetName;
+          let existing;
+          try {
+            existing = fs.openSync(target, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
+            const stat = fs.fstatSync(existing);
+            if (stat.isFile() && stat.size === doc.byteSize
+              && createHash("sha256").update(fs.readFileSync(existing)).digest("hex") === doc.sha256) return true;
+          } catch (error) {
+            if (error.code === "ENOENT") return false;
+            if (!["ELOOP", "EACCES", "EISDIR"].includes(error.code)) throw error;
+          } finally { if (existing !== undefined) fs.closeSync(existing); }
+        }
+        throw new Error("document_recovery_paths_exhausted");
+      }
+      let replayed = selectTarget();
+      if (!replayed) {
+        let bytes;
+        if (doc.contentRef) {
+          // Use this run's existing governed session; references cannot select an endpoint or credential.
+          const server = JSON.parse(fs.readFileSync(configPath, "utf8")).mcpServers.amaster;
+          const chunks = [];
+          let offset = 0;
+          while (offset < doc.byteSize) {
+            const id = randomUUID();
+            const response = await fetch(server.url, { method: "POST", redirect: "error",
+              headers: { ...server.headers, "Content-Type": "application/json", Accept: "application/json" },
+              body: JSON.stringify({ jsonrpc: "2.0", id, method: "tools/call", params: {
+                name: "runtime_action_status", arguments: { planId: result.planId, documentOffset: offset },
+              } }), signal: AbortSignal.timeout(30000) });
+            if (!response.ok) { await response.body?.cancel(); throw new Error("document_read_denied"); }
+            const parts = [];
+            let size = 0;
+            for await (const part of response.body) {
+              size += part.length;
+              if (size > 256 * 1024) throw new Error("document_chunk_response_too_large");
+              parts.push(part);
+            }
+            const rpc = JSON.parse(Buffer.concat(parts).toString("utf8"));
+            const readEnvelope = JSON.parse(rpc.result?.content?.[0]?.text);
+            const read = readEnvelope?.content;
+            const value = read?.result;
+            const chunk = value?.initializationDocumentChunk;
+            if (rpc.id !== id || readEnvelope.status !== "succeeded" || read?.status !== "accepted"
+              || value?.planId !== result.planId || value?.revision !== result.revision
+              || value?.initializationDocument?.sha256 !== doc.sha256
+              || value?.initializationDocument?.byteSize !== doc.byteSize
+              || chunk?.encoding !== "base64" || chunk.offset !== offset || typeof chunk.data !== "string") {
+              throw new Error("invalid_document_chunk");
+            }
+            const part = Buffer.from(chunk.data, "base64");
+            if (!part.length || part.length > 48 * 1024 || part.toString("base64") !== chunk.data
+              || offset + part.length > doc.byteSize
+              || chunk.nextOffset !== (offset + part.length < doc.byteSize ? offset + part.length : null)) {
+              throw new Error("invalid_document_chunk_range");
+            }
+            chunks.push(part);
+            offset += part.length;
+          }
+          bytes = Buffer.concat(chunks);
+        } else {
+          // Rolling-upgrade compatibility for inline receipts from an older Server.
+          if (typeof doc.markdown !== "string") throw new Error("missing_document_content");
+          bytes = Buffer.from(doc.markdown, "utf8");
+        }
+        if (bytes.length !== doc.byteSize || createHash("sha256").update(bytes).digest("hex") !== doc.sha256) {
+          throw new Error("invalid_document_snapshot");
+        }
+        temp = parentPath + "/.organization-plan-" + randomUUID();
+        file = fs.openSync(temp, "wx", 0o600);
+        fs.writeFileSync(file, bytes);
+        fs.fsyncSync(file);
+        // link is atomic and refuses replacement, including a raced-in symlink.
+        for (let attempt = 0; ; attempt++) {
+          try { fs.linkSync(temp, target); break; }
+          catch (error) {
+            if (error.code !== "EEXIST" || attempt >= 31) throw error;
+            if (selectTarget()) { replayed = true; break; }
+          }
+        }
+      }
+      doc.path = "deliverables/" + targetName;
+      result.initializationDocumentMaterialization = {
+        status: "materialized", path: doc.path, sha256: doc.sha256, byteSize: doc.byteSize,
+        planId: result.planId, revision: result.revision, replayed, uploaded: false,
+      };
+    } catch {
+      // Preserve the authoritative successful plan receipt; local failure is separate.
+      result.initializationDocumentMaterialization = { status: "failed", uploaded: false,
+        reason: "Runner document recovery could not complete within safe limits; retry through the governed runtime recovery path before publishing." };
+    } finally {
+      if (file !== undefined) fs.closeSync(file);
+      if (temp) { try { fs.unlinkSync(temp); } catch {} }
+      if (parent !== undefined) fs.closeSync(parent);
+      if (root !== undefined) fs.closeSync(root);
+    }
+    // Only an explicitly negotiated planning call starts effects. Status/document reads stay reads.
+    const provider = envelope.providerReceipt;
+    if (completionAuthority && event.toolName === "runtime_action_plan"
+      && result.initializationDocumentMaterialization?.status === "materialized"
+      && provider?.provider === "amaster_actions" && provider.invocationId === envelope.invocationId
+      && provider.planId === result.planId
+      && ["runId", "commandId", "issueId"].every((key) => completionAuthority[key] && provider[key] === completionAuthority[key])) {
+      result.initializationCompletion = await runInitializationCompletion({ plan: result, authority: completionAuthority,
+        call: initializationCompletionCall, sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)), now: Date.now,
+        // Pi redirects extension stdout.write to stderr. This is an explicit
+        // daemon JSON protocol event, so use fd 1 rather than extension logging.
+        onReceipt: (receipt) => fs.writeSync(1, JSON.stringify({ type: "mirrorx_initialization_action_receipt", receipt }) + "\\n"),
+      });
+      if (result.initializationCompletion.status === "completed") result.initializationDocumentMaterialization.uploaded = true;
+    }
+    // A completed issue is not a mustEndRun handoff. Let Pi emit its ordinary
+    // final summary; stopAfterTurn here is classified as exhausted tool work.
+    return { content: [{ type: "text", text: JSON.stringify(envelope) }] };
+  });
+}
+`;
+}
+
 // src/amaster-runtime-daemon/pi-managed-mcp-profile.mjs
 import { createHash as createHash8 } from "node:crypto";
 import {
@@ -23514,10 +23859,12 @@ function createManagedPiMcpProfileApi(options = {}) {
     const fullWikiCount = fullWikiReadCount + (hasWikiWrite ? 1 : 0);
     const fullConnectorCount = countIn(FULL_DIRECT_TYPED_V1_CONNECTOR_TOOL_NAMES);
     const fullCatalog = mcpToolMode === MANAGED_PI_DIRECT_TYPED_MCP_TOOL_MODE && tools.length === FULL_DIRECT_TYPED_V1_BASE_TOOL_NAMES.size + fullWikiCount + fullConnectorCount && covers(FULL_DIRECT_TYPED_V1_BASE_TOOL_NAMES) && (fullWikiReadCount === 0 && !hasWikiWrite || fullWikiReadCount === FULL_DIRECT_TYPED_V1_WIKI_READ_TOOL_NAMES.size) && (fullConnectorCount === 0 || fullConnectorCount === FULL_DIRECT_TYPED_V1_CONNECTOR_TOOL_NAMES.size) && tools.every((tool) => FULL_DIRECT_TYPED_V1_TOOL_NAMES.has(tool.name));
-    if (mcpToolMode === MANAGED_PI_DIRECT_TYPED_MCP_TOOL_MODE && !fullCatalog) {
+    const initializationNames = new Set([...FULL_DIRECT_TYPED_V1_BASE_TOOL_NAMES].filter((name) => name !== "runtime_action.list" && name !== "mirrorx.list_issues"));
+    const initializationCatalog = tools.length === initializationNames.size + fullWikiReadCount && covers(initializationNames) && !hasWikiWrite && fullConnectorCount === 0 && (fullWikiReadCount === 0 || fullWikiReadCount === FULL_DIRECT_TYPED_V1_WIKI_READ_TOOL_NAMES.size);
+    if (mcpToolMode === MANAGED_PI_DIRECT_TYPED_MCP_TOOL_MODE && !fullCatalog && !initializationCatalog) {
       throw new Error("pi_managed_mcp_invalid: direct tool catalog size mismatch");
     }
-    const catalogKind = "full";
+    const catalogKind = initializationCatalog ? "initialization" : "full";
     const admittedToolNames = FULL_DIRECT_TYPED_V1_TOOL_NAMES;
     const names = /* @__PURE__ */ new Set();
     const exposedNames = /* @__PURE__ */ new Set();
@@ -24650,6 +24997,14 @@ ${result2.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
           managedPiRunTerminationExtensionSource()
         );
       }
+      if (directCatalog?.tools.some((tool) => tool.name === "runtime_action.plan")) {
+        const automaticCompletion = directCatalog.tools.find((tool) => tool.name === "runtime_action.plan")?.inputSchema?.$comment === "mirrorx.initialization-completion.v1";
+        writeProfileExtension("amaster-initialization-document.js", managedPiInitializationDocumentExtensionSource(
+          cwd,
+          `${cwd}/.pi/mcp.json`,
+          automaticCompletion ? authority : null
+        ));
+      }
       const adapterVersion = piMcpAdapterVersion(sharedRuntime.home);
       if (directCatalog) assertPiMcpAdapterDirectCatalogSupport(adapterVersion);
       const {
@@ -28223,7 +28578,7 @@ function maybeCapturePiMessage(event, messages, usage) {
   }
   return capturedAssistantOutput;
 }
-function piMcpToolResults(event) {
+function piMcpToolResults(event, expectedAuthority = null) {
   const results = [];
   const seen = /* @__PURE__ */ new Set();
   const retain = (parsed) => {
@@ -28278,6 +28633,14 @@ function piMcpToolResults(event) {
   if (readString(event?.type) === "tool_execution_end") {
     retainMcpResult(event?.result);
   }
+  if (readString(event?.type) === "mirrorx_initialization_action_receipt" && expectedAuthority) {
+    const receipt = asRecord(event.receipt);
+    const provider = asRecord(receipt.providerReceipt);
+    const content = asRecord(receipt.content);
+    if (content.schemaVersion === "runtime-action-v1" && ["runtime_action.submit", "runtime_action.status", "runtime_action.commit"].includes(content.toolName) && ["runId", "commandId", "issueId"].every((key) => readString(expectedAuthority[key]) && provider[key] === expectedAuthority[key])) {
+      retainMcpResult({ details: { server: "amaster" }, content: [{ type: "text", text: JSON.stringify(receipt) }] });
+    }
+  }
   return results;
 }
 function piGovernedMcpUnavailableEvidence(event) {
@@ -30109,6 +30472,14 @@ function wikiAccessRuleLine(input) {
   const access = asRecord(input.wikiAccess);
   const tools = input.hasGovernedMcp === true && access.tools === true;
   const treePath = readString(access.treePath);
+  const catalogTools = asRecord(input.managedMcpToolCatalog).tools;
+  if (input.managedMcpToolMode === "direct_typed" && Array.isArray(catalogTools)) {
+    const wikiNames = tools ? catalogTools.map((tool) => readString(asRecord(tool).exposedName)).filter((name) => ["wiki_list", "wiki_search", "wiki_read", "wiki_write", "wiki_list_versions", "wiki_diff_versions"].includes(name)) : [];
+    if (wikiNames.length > 0) {
+      return `- Company wiki access in this run: ${wikiNames.join(" / ")} via the amaster MCP${treePath ? `, and the wiki tree at ${treePath}` : ""}. Use targeted reads for relevant evidence; only the listed tools are available.`;
+    }
+    return treePath ? `- Company wiki access in this run: the wiki tree at ${treePath}. Read wiki/index.md then the relevant pages; wiki_* tools are not available.` : "";
+  }
   if (tools && treePath) {
     return `- Company wiki access in this run: the six tools wiki_list / wiki_search / wiki_read / wiki_write / wiki_list_versions / wiki_diff_versions via the amaster MCP, and the wiki tree at ${treePath} (read wiki/index.md there first).`;
   }
@@ -31341,7 +31712,17 @@ ${resolvedDependencies.details.content}` : resolvedDependencies.details.content
   const taskContextAuthority = taskContextAuthoritySection(context);
   const continuationPostconditionGap = continuationPostconditionGapSection(context, input);
   const companyInitializationAuthority = companyInitializationAuthoritySection(context);
-  const runtimeTemplateCatalog = runtimeTemplateCatalogSection(input);
+  const rawManagedTools = asRecord(input.managedMcpToolCatalog).tools;
+  const managedTools = Array.isArray(rawManagedTools) ? rawManagedTools : [];
+  const planTool = managedTools.find((tool) => asRecord(tool).name === "runtime_action.plan");
+  const documentSchema = asRecord(asRecord(asRecord(asRecord(planTool).inputSchema).properties).initializationOrganization).properties;
+  const serverDocumentWorkflow = companyInitializationAuthority && asRecord(context.companyInitializationAuthority).organizationMutationAuthorityMode === "initialization_plan" && input.hasGovernedMcp && input.executorKind === "pi" && input.managedMcpToolMode === "direct_typed" && !managedTools.some((tool) => asRecord(tool).name === "runtime_action.list") && asRecord(documentSchema).documentReasoning;
+  const fallbackTemplateCatalog = runtimeTemplateCatalogSection(input);
+  const automaticCompletion = asRecord(asRecord(planTool).inputSchema).$comment === "mirrorx.initialization-completion.v1";
+  const runtimeTemplateCatalog = serverDocumentWorkflow ? {
+    sourceRef: "company_initialization_server_document_renderer",
+    content: (automaticCompletion ? "Submit your final company-specific organization decisions once through initializationOrganization with documentReasoning. This negotiated plan call requests automatic completion: Server renders the seven-section document; Runner materializes, uploads through Artifact Saga, waits for verified delivery, commits the exact plan and requests Server-validated ready completion. Do not queue upload/status/commit/done or filesystem template searches alongside the plan. The automatic sequence preserves all Server authorization, version, artifact and ready gates. A completed initializationCompletion receipt ends this run. An incomplete receipt identifies the exact stage and durable IDs for existing recovery; revise business decisions only when the error requires it. Explicit actions, omitted documentReasoning or missing initializationDocument retain the original document/upload/commit workflow." : "The initialization Organization Plan uses the Server-owned seven-section renderer. This satisfies the pre-draft template selection step for this artifact; do not search or copy filesystem templates. Submit company-specific decisions once through initializationOrganization.documentReasoning. The Runner verifies and materializes returned document bytes; a materialized receipt requires no extra file/hash inspection. Use the exact returned path in upload_artifact, then follow Artifact Saga, commit and the Server ready gates. If using explicit actions, omitting documentReasoning, or receiving no initializationDocument, use the original document workflow and configured template catalog; never claim materialization without its successful receipt.") + (fallbackTemplateCatalog ? ` Fallback-only exact catalog path: ${asRecord(input.runtimeTemplateCatalog).targetDir}` : "")
+  } : fallbackTemplateCatalog;
   const rawSections = [
     { name: "recovery_instruction", title: "Recovery Instruction", priority: 100, sourceRef: `run:${input.runId ?? "unknown"}`, content: completeRecoveryInstruction, truncationReason: completeRecoveryInstruction ? null : "mode_selection" },
     { name: "approval_continuation", title: "Approved Runtime Action Continuation", priority: 100, sourceRef: `run:${input.runId ?? "unknown"}`, content: approvalContinuationText(input), truncationReason: mode === "continuation" ? null : "mode_selection" },
@@ -31878,9 +32259,15 @@ var BUILD_SUPPORTED_CAPABILITIES = Object.freeze([
   "run_terminate",
   "logs_cost_workspace_status",
   "browser_credential_ref_fill_v1",
-  "execution_lanes_v1"
+  "execution_lanes_v1",
+  "mirrorx_initialization_context_v1",
+  "mirrorx_initialization_completion_v1"
 ]);
 var DYNAMIC_READINESS = Object.freeze({
+  mirrorx_initialization_completion_v1: {
+    reasonCode: "managed_linux_pi_required",
+    ready: (input) => process.platform === "linux" && input.runnerKind === "cloud_managed" && input.executors.some((executor) => executor.kind === "pi")
+  },
   artifact_template_catalog_v1: {
     reasonCode: "artifact_template_catalog_not_ready",
     ready: (input) => {
@@ -34017,7 +34404,7 @@ function assertRequiredTaskAttachmentMaterialized(input, materialized) {
 }
 
 // src/amaster-runtime-daemon.mjs
-var CONNECTOR_VERSION = "0.1.1-beta.266";
+var CONNECTOR_VERSION = "0.1.1-beta.267";
 var CONNECTOR_CONTRACT_VERSION = "2026-06-04.v1";
 var daemonRequire = createRequire2(import.meta.url);
 var MAX_CHECKPOINT_BYTES = 20 * 1024 * 1024;
@@ -36392,7 +36779,7 @@ function createLiveOutputLogger(config, command, executorKind, protectedValues =
       }
     }
     if (MIRRORX_FORMAL_TASK_EXECUTOR_KINDS.includes(executorKind) && event) {
-      const results = executorKind === "codex" ? codexMcpToolResults(event) : executorKind === "codebuddy" ? codebuddyMcpToolResults(event) : piMcpToolResults(event);
+      const results = executorKind === "codex" ? codexMcpToolResults(event) : executorKind === "codebuddy" ? codebuddyMcpToolResults(event) : piMcpToolResults(event, { runId: commandRunId(command), commandId: command.commandId, issueId: commandIssueId(command) });
       liveMcpToolResults.push(...results);
       if (results.length > 0) onMcpToolResults?.(results);
     }

package/dist/amaster-runtime.mjs

@@ -7,7 +7,7 @@ import { homedir, hostname } from "node:os";
 import { fileURLToPath } from "node:url";
 import { BUILD_SUPPORTED_CAPABILITIES } from "./amaster-runtime-daemon/capability-registry.mjs";
 
-const CONNECTOR_VERSION = "0.1.1-beta.266";
+const CONNECTOR_VERSION = "0.1.1-beta.267";
 
 const CONFIG_KEY_MAP = new Map([
   ["server_url", "AMASTER_EMPLOYEE_SERVER_URL"],

package/package.json

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