@amaster.ai/employee-runtime-connector 0.1.1-beta.21 → 0.1.1-beta.23

package/README.md

@@ -13,7 +13,7 @@ For production images, install an exact version and invoke the package bin:
 ```sh
 npm install --omit=dev --prefix /opt/pi-cli-runtime @amaster.ai/employee-runtime-connector@0.1.0
 /opt/pi-cli-runtime/node_modules/.bin/amaster-runtime setup https://employee.example.com \
-  --capabilities remote_registration,heartbeat,executor_discovery,workspace_binding,run_wakeup,model_call,run_cancel,run_terminate,logs_cost_workspace_status
+  --capabilities remote_registration,heartbeat,executor_discovery,workspace_binding,run_wakeup,model_call,model_call_output_contract_v1,run_cancel,run_terminate,logs_cost_workspace_status
 /opt/pi-cli-runtime/node_modules/.bin/amaster-runtime daemon start --foreground
 ```
 
@@ -32,6 +32,20 @@ The source of truth lives under this package's `src/` directory. The package bui
 
 Runtime code belongs in the container image. Persist only connector state, the result outbox, and workspaces under the configured state directory.
 
+## Contracted Pi model calls
+
+Pi `model_call` commands with `model_call_output_contract_v1` keep provider and
+model selection paired with the output ceiling. Command target fields have the
+highest precedence, followed by `AMASTER_PI_PROVIDER` / `AMASTER_PI_MODEL`, then
+the Pi profile's `defaultProvider` / `defaultModel`. Each selected precedence
+layer must be a complete provider/model pair: a partial command or runtime
+override fails closed instead of silently falling through to a lower-precedence
+default. The daemon copies only the normalized default pair into the isolated
+one-shot profile, validates that the resolved model exists, applies
+`maxOutputTokens` to that exact model, and records the resolved target and source
+in command-result diagnostics. Missing or unknown targets also fail closed
+before Pi is spawned.
+
 ## Pi tool-argument transport guard
 
 `AMASTER_PI_TOOL_ARGUMENT_GUARD_MODE` defaults to `shadow`; supported values are

package/dist/amaster-runtime-daemon.mjs

@@ -2,7 +2,7 @@
 // MirrorX runtime connector daemon bundle.
 
 // src/amaster-runtime-daemon.mjs
-import { createHash as createHash14 } from "node:crypto";
+import { createHash as createHash15 } from "node:crypto";
 import { chmodSync as chmodSync6, copyFileSync as copyFileSync3, existsSync as existsSync14, lstatSync as lstatSync7, mkdirSync as mkdirSync9, mkdtempSync, readFileSync as readFileSync11, readdirSync as readdirSync9, realpathSync as realpathSync5, renameSync as renameSync6, rmSync as rmSync7, statSync as statSync8, symlinkSync as symlinkSync4, unlinkSync as unlinkSync2, writeFileSync as writeFileSync9 } from "node:fs";
 import { arch as arch3, homedir as homedir3, hostname as hostname2, platform as platform3, tmpdir } from "node:os";
 import { basename as basename6, delimiter as delimiter3, dirname as dirname9, extname as extname2, isAbsolute as isAbsolute8, join as join15, relative as relative9, resolve as resolve12 } from "node:path";
@@ -2005,6 +2005,73 @@ function syncAmasterProviderFiles(agentDir, executorEnv) {
     settingsSynced: syncAmasterProviderSettings(agentDir, executorEnv)
   };
 }
+function normalizePiModelId(modelId) {
+  return readString(modelId)?.replace(/:(?:off|minimal|low|medium|high|xhigh|max)$/i, "") ?? null;
+}
+function assertPiModelConfigured(agentDir, provider, model) {
+  const modelsPath = join3(agentDir, "models.json");
+  const config = readJsonFile(modelsPath);
+  const providers = asRecord(config.providers);
+  const providerConfig = asRecord(providers[provider]);
+  const configuredModels = Array.isArray(providerConfig.models) ? providerConfig.models : [];
+  const configuredModelExists = configuredModels.some((entry) => readString(asRecord(entry).id) === model);
+  const existingOverrides = asRecord(providerConfig.modelOverrides);
+  if (!configuredModelExists && !(model in existingOverrides)) {
+    throw new Error(`pi_model_call_model_missing: ${provider}/${model}`);
+  }
+  return { modelsPath, config, providers, providerConfig, existingOverrides };
+}
+function resolvePiModelCallTarget(agentDir, providerId, modelId, explicitSource = "command") {
+  const explicitProvider = readString(providerId);
+  const explicitModel = normalizePiModelId(modelId);
+  if (Boolean(explicitProvider) !== Boolean(explicitModel)) {
+    throw new Error("pi_model_call_target_partial");
+  }
+  let provider = explicitProvider;
+  let model = explicitModel;
+  let source = explicitSource;
+  if (!provider || !model) {
+    const settings = readJsonFile(join3(agentDir, "settings.json"));
+    const defaultProvider = readString(settings.defaultProvider);
+    const defaultModel = normalizePiModelId(settings.defaultModel);
+    if (Boolean(defaultProvider) !== Boolean(defaultModel)) {
+      throw new Error("pi_model_call_default_partial");
+    }
+    if (!defaultProvider || !defaultModel) {
+      throw new Error("pi_model_call_default_missing");
+    }
+    provider = defaultProvider;
+    model = defaultModel;
+    source = "pi_settings_default";
+  }
+  assertPiModelConfigured(agentDir, provider, model);
+  return { provider, model, source };
+}
+function applyModelCallOutputContract(agentDir, providerId, modelId, maxOutputTokens) {
+  const provider = readString(providerId);
+  const model = normalizePiModelId(modelId);
+  const tokenLimit = Number(maxOutputTokens);
+  if (!provider || !model || !Number.isSafeInteger(tokenLimit) || tokenLimit <= 0) {
+    throw new Error("pi_model_call_output_contract_invalid");
+  }
+  const { modelsPath, config, providers, providerConfig, existingOverrides } = assertPiModelConfigured(agentDir, provider, model);
+  writeJsonFileAtomic(modelsPath, {
+    ...config,
+    providers: {
+      ...providers,
+      [provider]: {
+        ...providerConfig,
+        modelOverrides: {
+          ...existingOverrides,
+          [model]: {
+            ...asRecord(existingOverrides[model]),
+            maxTokens: tokenLimit
+          }
+        }
+      }
+    }
+  });
+}
 
 // src/amaster-runtime-daemon/pi-mcp-args-normalizer.mjs
 function isJsonObject(value) {
@@ -2734,11 +2801,11 @@ function createManagedPiMcpProfileApi(options = {}) {
     if (!Number.isFinite(value)) throw new Error("pi_managed_mcp_attestation_failed: invalid attestation clock");
     return value;
   }
-  function sha256(value) {
+  function sha2562(value) {
     return createHash3("sha256").update(value).digest("hex");
   }
   function adapterServerConfigHash(definition) {
-    return sha256(stablePiJson({
+    return sha2562(stablePiJson({
       command: definition.command,
       args: definition.args,
       env: definition.env,
@@ -3278,17 +3345,17 @@ ${result3.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
     if (receipt.status !== "attested" || receipt.mode !== "probe" || receipt.proxyMode !== input.proxyMode || receipt.proxyPresent !== expectedProxyPresent || receipt.effectiveSetHash !== input.effectiveSetHash || receipt.attestorSourceSha256 !== input.attestorSourceSha256 || receipt.configSha256 !== input.configSha256 || receipt.cacheSha256 !== input.cacheSha256) {
       throw new Error("pi_managed_mcp_effective_tools_failed: probe receipt mismatch");
     }
-    if (sha256(readFileSync3(input.configPath)) !== input.configSha256) {
+    if (sha2562(readFileSync3(input.configPath)) !== input.configSha256) {
       throw new Error("pi_managed_mcp_effective_tools_failed: config drifted during probe");
     }
-    if (sha256(readFileSync3(input.cachePath)) !== input.cacheSha256) {
+    if (sha2562(readFileSync3(input.cachePath)) !== input.cacheSha256) {
       throw new Error("pi_managed_mcp_effective_tools_failed: cache drifted during probe");
     }
     return {
       effectiveToolProxyMode: receipt.proxyMode,
       effectiveToolProxyPresent: receipt.proxyPresent,
       effectiveToolSetHash: receipt.effectiveSetHash,
-      effectiveToolProbeDigest: sha256(stablePiJson(receipt)),
+      effectiveToolProbeDigest: sha2562(stablePiJson(receipt)),
       effectiveToolProbeAt: receipt.attestedAt,
       effectiveToolBindings: receipt.effectiveToolBindings
     };
@@ -3370,8 +3437,8 @@ ${result3.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
         };
         writePrivateFile2(cachePath, `${JSON.stringify(cache, null, 2)}
 `);
-        const cacheSha256 = sha256(readFileSync3(cachePath));
-        const attestorSourceSha256 = sha256(managedPiEffectiveToolsAttestorExtensionSource());
+        const cacheSha256 = sha2562(readFileSync3(cachePath));
+        const attestorSourceSha256 = sha2562(managedPiEffectiveToolsAttestorExtensionSource());
         const manifestPath = join4(piCodingAgentDir, "effective-tools-manifest.json");
         const receiptPath = join4(tmp, "effective-tools-receipt.json");
         const manifest = {
@@ -3389,7 +3456,7 @@ ${result3.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
           }))),
           proxyMode: mcpToolMode === MANAGED_PI_HYBRID_MCP_TOOL_MODE ? "required" : "forbidden",
           attestorSourceSha256,
-          configSha256: sha256(readFileSync3(configPath)),
+          configSha256: sha2562(readFileSync3(configPath)),
           cacheSha256
         };
         writePrivateFile2(manifestPath, `${JSON.stringify(manifest, null, 2)}
@@ -3400,7 +3467,7 @@ ${result3.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
           receiptPath,
           cacheSha256,
           configPath,
-          configSha256: sha256(readFileSync3(configPath)),
+          configSha256: sha2562(readFileSync3(configPath)),
           attestorSourceSha256,
           effectiveSetHash: manifest.effectiveSetHash,
           proxyMode: manifest.proxyMode
@@ -3563,7 +3630,7 @@ ${result3.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
         sessionId: gateway.sessionId,
         sourcePiHome,
         piCodingAgentDir,
-        configSha256: sha256(readFileSync3(configPath))
+        configSha256: sha2562(readFileSync3(configPath))
       };
       return {
         profileRoot,
@@ -4364,24 +4431,6 @@ function continuationText(context) {
   if (!body) return "";
   return [readString(summary.title), body].filter(Boolean).join("\n");
 }
-function onDemandRefs(input) {
-  const context = asRecord(input.context);
-  const issue = asRecord(context.paperclipIssue);
-  const wake = asRecord(context.paperclipWake);
-  const refs = [
-    readString(issue.id) ? `issue:${readString(issue.id)}` : null,
-    ...commentRefs(context).map((id) => `comment:${id}`),
-    ...(Array.isArray(context.childIssueSummaries) ? context.childIssueSummaries : []).map((entry) => readString(asRecord(entry).id)).filter(Boolean).map((id) => `child_issue:${id}`),
-    ...(Array.isArray(wake.workProducts) ? wake.workProducts : []).map((entry) => readString(asRecord(entry).id)).filter(Boolean).map((id) => `work_product:${id}`)
-  ];
-  const unique = [...new Set(refs.filter(Boolean))];
-  if (unique.length === 0) return "";
-  return [
-    "Large context objects are intentionally omitted from this prompt.",
-    "Use managed typed read tools when more detail is required; preserve returned source and freshness metadata.",
-    ...unique.map((ref) => `- ${ref}`)
-  ].join("\n");
-}
 function governedReadSection(context) {
   const reads = Array.isArray(context.governedReadResults) ? context.governedReadResults : [];
   if (reads.length === 0) return { content: "", provenance: [] };
@@ -4791,6 +4840,7 @@ function fixedRules(input, includeIssueLine) {
     "Before changing the task status to done, audit every explicit requirement in the task against the final evidence. A successful tool or document write proves delivery, not acceptance: inspect the delivered content for required sections, diagrams, tables, and factual constraints.",
     "Do not leave stale in-progress wording such as \u201Ccurrent run\u201D in a terminal deliverable; rewrite it to the final observed state. Do not list finalization itself as remaining or next work in a terminal deliverable.",
     serverOwnedBusinessOutcomeReview ? "If any requirement is missing or cannot be verified, do not mark done or request final completion or Business Outcome review. Keep the issue in_progress with the exact gap and next owner. An intermediate review remains available only for an exact document revision that must be approved before execution can continue: use create_interaction with kind request_confirmation, payload.resolutionMode review, and purposeCode review_document_revision; never use that interaction as final completion or Outcome acceptance." : "If anything is missing, do not mark done. `update_parent` cannot write `in_review` or `blocked`. Human review: create_interaction kind request_confirmation with payload.resolutionMode review. Required platform/provider/external action needs a typed interaction or first-class blocker; otherwise keep todo with the gap and owner.",
+    "A create_interaction result with status=pending or mustEndRun=true establishes human attention and is the final mutation of this run. End the run immediately: do not publish a Delivery Manifest, update a document or task, or submit any other mutation. Continue only in the new run created after the interaction is resolved.",
     DEADLINE_POSTURE_GUARD,
     "Do not install operating-system or user-global packages, and do not use host package managers such as brew, apt, yum, or global pip/npm installs. Use tools already available or workspace-local dependencies or virtual environments. If a required renderer or evaluator is unavailable, keep the source artifact, record the exact verification gap, and do not mutate the host.",
     `- command id: ${input.commandId}`,
@@ -5127,30 +5177,26 @@ function overflowDependencyRefsText(overflowRefs) {
     ...overflowRefs.map((ref) => `- issue ${JSON.stringify(ref.selector)}, key ${JSON.stringify(ref.key)}`)
   ].join("\n");
 }
-function taskCommentRefGuidance(input) {
+function taskCommentRefGuidance(input, taskText) {
   if (!input.hasGovernedMcp || !readString(input.issueId)) return "";
+  if (!/\[comment body (?:omitted|truncated)[^\]]*comment:[^\s\]]+\]/i.test(taskText)) return "";
   const call = readIssueEvidenceCommentCallText(input.issueId, "<id>", input);
   return `References like comment:<id> above mark truncated comment bodies. Fetch the full text before relying on them \u2014 ${call} (replace <id> with the referenced comment id).`;
 }
-function piMcpProxyExamplesText(input) {
+function piMcpUsageText(input) {
   if (!input.hasGovernedMcp || input.executorKind !== "pi" || !managedPiMcpProxyAvailable(input) || isRecoveryWakeReason(input.wakeReason)) return "";
-  const hybrid = input.managedMcpToolMode === "hybrid";
   const proxy = (tool, args) => JSON.stringify({
     server: "amaster",
     tool,
     args: JSON.stringify(args)
   });
   return [
-    hybrid ? "For governed tools not exposed in the direct typed list, use the outer `mcp` proxy. Before the first long-tail proxy call, describe that exact canonical tool; `args` is the stringified inner canonical object and must never be object-valued." : "The Pi native tool is the outer `mcp` proxy. Emit these as actual tool calls; `args` is the stringified inner canonical object. Pi validates this string schema before extension hooks, so never send object-valued `args`:",
+    "This run uses the outer `mcp` proxy for Governed MCP calls. Emit actual tool calls; `args` is the stringified inner canonical object. Pi validates this string schema before extension hooks, so never send object-valued `args`.",
+    "Before the first write, describe that exact canonical action and use the returned schema; do not infer write arguments from this example.",
     "Keep review payload strings short. Reference the exact document key and revision in `target`; do not duplicate the reviewed document body in `prompt` or `detailsMarkdown`.",
     "payload.supersedesInteractionId is invalid. provenance.supersedesInteractionId is only for replacing a currently pending governed interaction; after changes_requested or rejected resolution, do not send a supersession id.",
     "update_parent.comment creates a separate persistent issue comment. Omit it when add_comment already recorded the message.",
-    ...!hybrid ? [`- describe: ${proxy("runtime_action.describe", { schemaVersion: "runtime-action-v1", actionType: "update_parent" })}`] : [],
-    `- submit: ${proxy("runtime_action.submit", { schemaVersion: "runtime-action-v1", idempotencyKey: "task-123-progress", action: { type: "update_parent", status: "in_progress" } })}`,
-    `- submit intermediate document review interaction: ${proxy("runtime_action.submit", { schemaVersion: "runtime-action-v1", idempotencyKey: "task-123-review", action: { type: "create_interaction", kind: "request_confirmation", continuationPolicy: "wake_assignee_on_accept", provenance: { purposeCode: "review_document_revision", requirementRefs: ["acceptance:document_review"], attentionOwner: { kind: "board", id: "board" }, epochKey: "document_revision:22222222-2222-4222-8222-222222222222" }, payload: { version: 1, resolutionMode: "review", prompt: "Review `plan` revision 1.", target: { type: "issue_document", issueId: "11111111-1111-4111-8111-111111111111", documentId: "33333333-3333-4333-8333-333333333333", key: "plan", revisionId: "22222222-2222-4222-8222-222222222222", revisionNumber: 1 } } } })}`,
-    `- plan: ${proxy("runtime_action.plan", { schemaVersion: "runtime-action-v1", idempotencyKey: "task-123-plan", actions: [{ type: "update_parent", status: "in_progress" }] })}`,
-    `- commit the returned plan revision: ${proxy("runtime_action.commit", { schemaVersion: "runtime-action-v1", planId: "11111111-1111-4111-8111-111111111111", revision: "plan-revision-1" })}`,
-    ...!hybrid ? [`- read document: ${proxy("amaster.read_issue_document", { issueId: "AM-123", key: "plan" })}`] : []
+    `- minimal envelope example: ${proxy("runtime_action.describe", { schemaVersion: "runtime-action-v1", actionType: "update_parent" })}`
   ].join("\n");
 }
 function piDirectTypedToolsText(input) {
@@ -5161,9 +5207,8 @@ function piDirectTypedToolsText(input) {
     return "Direct typed governed tools are unavailable because the run catalog snapshot is empty. Do not guess a proxy or tool name.";
   }
   return [
-    input.managedMcpToolMode === "hybrid" ? "This run exposes the attested high-frequency Governed MCP tools below as direct typed tools. Call these exact names with object arguments and do not send them through the `mcp` proxy." : "This run uses the attested direct typed Governed MCP surface below. Call these exact names with object arguments; do not call the `mcp` proxy and do not stringify an inner argument envelope.",
-    ...tools.map((tool) => `- ${tool.name}${tool.description ? `: ${tool.description}` : ""}`),
-    input.managedMcpToolMode === "hybrid" ? "For a canonical tool not listed above, use the single managed `mcp` proxy only after exact describe. Never infer an alias, use REST, or bypass the governed Gateway." : "A tool not listed above is unavailable in this run. Do not infer a namespace or fall back to REST/bare MCP."
+    input.managedMcpToolMode === "hybrid" ? "Use the attested direct typed tools already present in the provider tool definitions with object arguments; do not duplicate them through the `mcp` proxy." : "Use only the attested direct typed tools already present in the provider tool definitions. Call their exact names with object arguments; do not call the `mcp` proxy and do not stringify an inner argument envelope.",
+    input.managedMcpToolMode === "hybrid" ? "For a canonical tool absent from those definitions, first use the direct typed `runtime_action_describe`, then call the single managed `mcp` proxy with stringified inner `args`. Never infer an alias, use REST, or bypass the governed Gateway." : "A tool absent from the provider tool definitions is unavailable in this run. Do not infer a namespace or fall back to REST/bare MCP."
   ].join("\n");
 }
 function sectionText(section) {
@@ -5217,7 +5262,7 @@ var CONTEXT_AVAILABILITY_SECTION_TITLES = Object.freeze({
   runtime_decomposition_requirement: "Required Task Decomposition",
   task_context_authority: "Task Context Authority",
   verified_company_context: "Verified Company Context",
-  pi_mcp_proxy_examples: "Pi MCP Proxy Examples",
+  pi_mcp_usage: "Pi Governed MCP Usage",
   governed_reads: "Governed External Reads",
   optional_task_wiki_context: "Optional Company Wiki Context",
   agent_instructions: "Agent Instructions",
@@ -5249,14 +5294,6 @@ function projectModelContextAvailability(manifestSections) {
     );
     coveredSections.push(...budgetOmissions);
   }
-  const rawSnapshot = bySection.get("raw_snapshot");
-  const onDemandRefs2 = bySection.get("on_demand_refs");
-  if (rawSnapshot?.omitted === true && rawSnapshot.truncationReason === "on_demand_large_object" && Number(rawSnapshot.originalChars ?? 0) > 0 && (!onDemandRefs2 || onDemandRefs2.omitted === true)) {
-    lines.push(
-      "Additional raw run context was intentionally not inlined and no managed on-demand reference was provided. Do not assume that omitted details are absent."
-    );
-    coveredSections.push("raw_snapshot");
-  }
   return {
     content: lines.join("\n"),
     coveredSections: [...new Set(coveredSections)]
@@ -5347,8 +5384,8 @@ function compileCommandPromptWithManifest(input, options = {}) {
 ${resolvedDependencies.details.content}` : ""
   ].filter(Boolean).join("\n\n") : "";
   const piDirectTypedTools = piDirectTypedToolsText(input);
-  const piMcpProxyExamples = [
-    resolvedDependencies.required.content ? "" : piMcpProxyExamplesText(input),
+  const piMcpUsage = [
+    input.managedMcpToolMode === "proxy_only" && !resolvedDependencies.required.content ? piMcpUsageText(input) : "",
     piDirectTypedTools
   ].filter(Boolean).join("\n");
   const deliveryReadinessContent = runtimeDeliveryReadinessText(context, input);
@@ -5358,7 +5395,7 @@ ${resolvedDependencies.details.content}` : ""
     { 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: 99, sourceRef: `run:${input.runId ?? "unknown"}`, content: approvalContinuationText(input), truncationReason: mode === "continuation" ? null : "mode_selection" },
     { 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, taskCommentRefGuidance(input)].filter(Boolean).join("\n"), content: includeTask ? [taskText, taskCommentRefGuidance(input)].filter(Boolean).join("\n") : "", truncationReason: includeTask ? null : "mode_selection" },
+    { name: "task", title: "Task Context", priority: 90, sourceRef: `issue:${input.issueId ?? "unknown"}`, originalContent: [taskText, taskCommentRefGuidance(input, taskText)].filter(Boolean).join("\n"), content: includeTask ? [taskText, taskCommentRefGuidance(input, taskText)].filter(Boolean).join("\n") : "", truncationReason: includeTask ? null : "mode_selection" },
     ...governedBusinessState ? [{ name: "governed_business_state", title: "Governed Business State", priority: 99, ...governedBusinessState }] : [],
     { 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 },
     ...resolvedDependencyContent ? [{
@@ -5375,18 +5412,18 @@ ${resolvedDependencies.details.content}` : ""
     { name: "runtime_decomposition_requirement", title: "Required Task Decomposition", priority: 98, sourceRef: `issue:${input.issueId ?? "unknown"}`, content: runtimeDecompositionRequirementText(context) },
     ...taskContextAuthority ? [{ name: "task_context_authority", title: "Task Context Authority", priority: 98, ...taskContextAuthority }] : [],
     ...verifiedCompanyContext.content ? [{ name: "verified_company_context", title: "Verified Company Context", priority: 96, sourceRef: verifiedCompanyContext.sourceRef, observedAt: verifiedCompanyContext.observedAt, freshness: { kind: "run_snapshot" }, content: verifiedCompanyContext.content }] : [],
-    ...piMcpProxyExamples ? [{
-      name: "pi_mcp_proxy_examples",
-      title: piDirectTypedTools ? "Pi Governed MCP Tools" : "Pi MCP Proxy Examples",
+    ...piMcpUsage ? [{
+      name: "pi_mcp_usage",
+      title: "Pi Governed MCP Usage",
       priority: 96,
       sourceRef: "amaster_governed_mcp_proxy_contract",
-      content: piMcpProxyExamples
+      content: piMcpUsage
     }] : [],
     { 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 },
     ...optionalTaskWikiContext ? [optionalTaskWikiContext] : [],
     { name: "agent_instructions", title: "Agent Instructions", priority: 100, sourceRef: "agent_instructions_bundle", content: readString(input.agentInstructions) ?? "" },
     { name: "attachments", title: "Materialized Inputs", priority: 80, sourceRef: "materialized_attachments", content: readString(input.attachmentsText) ?? "" },
-    { name: "on_demand_refs", title: "On-demand Context References", priority: 70, sourceRef: `issue:${input.issueId ?? "unknown"}`, content: [onDemandRefs(input), overflowDependencyRefsText(resolvedDependencies.overflowRefs)].filter(Boolean).join("\n") },
+    { name: "on_demand_refs", title: "On-demand Context References", priority: 70, sourceRef: `issue:${input.issueId ?? "unknown"}`, content: overflowDependencyRefsText(resolvedDependencies.overflowRefs) },
     { name: "raw_snapshot", title: "Raw Context Snapshot", priority: 0, sourceRef: `run:${input.runId ?? "unknown"}`, originalChars: jsonCharLength(context), content: "", truncationReason: "on_demand_large_object" }
   ];
   const seenContent = /* @__PURE__ */ new Set();
@@ -5492,10 +5529,7 @@ function renderAgentInstructionsBundle(bundle, delivery) {
     ].join("\n");
   }
   if (resolvedDelivery.mode === "executor_auto_load") {
-    return [
-      materialized,
-      "This executor has already loaded ./AGENTS.md through its project-instruction channel. Follow it for the whole run; do not read it again merely to initialize. Read sibling instruction files only when ./AGENTS.md references them or the current task requires them."
-    ].join("\n");
+    return "";
   }
   return [
     materialized,
@@ -5512,6 +5546,187 @@ function agentInstructionDeliveryAudit(bundle, delivery) {
   };
 }
 
+// src/amaster-runtime-daemon/agent-instruction-system-kernel-shadow.mjs
+import { createHash as createHash5 } from "node:crypto";
+var SHADOW_VERSION = 1;
+var TARGET_CHARS = 16e3;
+var USER_RESPONSE_START = "<user-facing-response>";
+var USER_RESPONSE_END = "</user-facing-response>";
+var RUNTIME_HEADING = "# AMaster Runtime Contract";
+var RUNTIME_KERNEL_SECTIONS = /* @__PURE__ */ new Set([
+  "Narrow recovery and terminalization",
+  "Secrets and Safety",
+  "Execution continuity"
+]);
+var ROLE_KERNEL_SECTIONS = /* @__PURE__ */ new Set([
+  "How you think",
+  "What you do",
+  "What you do not do",
+  "When you finish"
+]);
+function sha256(value) {
+  return createHash5("sha256").update(value, "utf8").digest("hex");
+}
+function normalizedText(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function sectionAudit(scope, section, disposition) {
+  return {
+    scope,
+    heading: section.heading,
+    disposition,
+    chars: section.content.length,
+    sha256: sha256(section.content)
+  };
+}
+function splitH2Sections(content, scope) {
+  const matches = [...content.matchAll(/^## (.+)$/gm)];
+  const sections = [];
+  const preambleEnd = matches[0]?.index ?? content.length;
+  const preamble = content.slice(0, preambleEnd).trim();
+  if (preamble) {
+    sections.push({
+      scope,
+      heading: `${scope}_preamble`,
+      content: preamble
+    });
+  }
+  for (let index = 0; index < matches.length; index += 1) {
+    const match = matches[index];
+    const start = match.index;
+    const end = matches[index + 1]?.index ?? content.length;
+    const sectionContent = content.slice(start, end).trim();
+    if (!sectionContent) continue;
+    sections.push({
+      scope,
+      heading: match[1].trim(),
+      content: sectionContent
+    });
+  }
+  return sections;
+}
+function extractUserResponseContract(content) {
+  const start = content.indexOf(USER_RESPONSE_START);
+  if (start === -1) return null;
+  const end = content.indexOf(USER_RESPONSE_END, start);
+  if (end === -1) return null;
+  const contentEnd = end + USER_RESPONSE_END.length;
+  return {
+    start,
+    end: contentEnd,
+    content: content.slice(start, contentEnd).trim()
+  };
+}
+function splitManagedLayout(content) {
+  const userResponse = extractUserResponseContract(content);
+  const runtimeStart = content.indexOf(RUNTIME_HEADING);
+  if (!userResponse || runtimeStart === -1 || runtimeStart < userResponse.end) return null;
+  const afterRuntime = content.slice(runtimeStart);
+  const parts = afterRuntime.split(/^---$/gm);
+  if (parts.length < 2) return null;
+  const rolePartIndex = parts.findIndex((part, index) => index > 0 && /^## (?:How you think|What you do|What you do not do|When you finish)$/m.test(part));
+  if (rolePartIndex === -1) return null;
+  const runtime = parts[0].trim();
+  const role = parts.slice(rolePartIndex).join("\n---\n").trim();
+  if (!runtime.startsWith(RUNTIME_HEADING) || !role) return null;
+  return { userResponse: userResponse.content, runtime, role };
+}
+function kernelProjection(content) {
+  const layout = splitManagedLayout(content);
+  if (!layout) return null;
+  const selected = [{
+    scope: "response",
+    heading: "User-Facing Response Contract",
+    content: layout.userResponse
+  }];
+  const onDemand = [];
+  for (const section of splitH2Sections(layout.runtime, "runtime")) {
+    if (section.heading === "runtime_preamble" || RUNTIME_KERNEL_SECTIONS.has(section.heading)) {
+      selected.push(section);
+    } else {
+      onDemand.push(section);
+    }
+  }
+  for (const section of splitH2Sections(layout.role, "role")) {
+    if (section.heading === "role_preamble" || ROLE_KERNEL_SECTIONS.has(section.heading)) {
+      selected.push(section);
+    } else {
+      onDemand.push(section);
+    }
+  }
+  return {
+    candidate: selected.map((section) => section.content).join("\n\n---\n\n"),
+    selected,
+    onDemand
+  };
+}
+function buildAgentInstructionSystemKernelShadow(bundle) {
+  const bundleMode = normalizedText(bundle?.mode).toLowerCase();
+  const source = normalizedText(bundle?.files?.["AGENTS.md"]);
+  const base = {
+    version: SHADOW_VERSION,
+    mode: "shadow_only",
+    activation: "disabled",
+    targetChars: TARGET_CHARS,
+    bundleMode: bundleMode || "unknown",
+    sourceFile: source ? "AGENTS.md" : null
+  };
+  if (!source) {
+    return {
+      candidate: "",
+      audit: {
+        ...base,
+        status: "not_applicable",
+        reason: "agents_entry_not_supplied"
+      }
+    };
+  }
+  if (bundleMode !== "managed") {
+    return {
+      candidate: "",
+      audit: {
+        ...base,
+        status: "not_applicable",
+        reason: bundleMode === "external" ? "external_instructions_are_user_owned" : "managed_bundle_not_attested",
+        sourceChars: source.length,
+        sourceSha256: sha256(source)
+      }
+    };
+  }
+  const projection = kernelProjection(source);
+  if (!projection) {
+    return {
+      candidate: "",
+      audit: {
+        ...base,
+        status: "unavailable",
+        reason: "managed_layout_not_recognized",
+        sourceChars: source.length,
+        sourceSha256: sha256(source)
+      }
+    };
+  }
+  const candidateChars = projection.candidate.length;
+  const reductionChars = source.length - candidateChars;
+  return {
+    candidate: projection.candidate,
+    audit: {
+      ...base,
+      status: "candidate_ready",
+      reason: "managed_sections_classified",
+      sourceChars: source.length,
+      sourceSha256: sha256(source),
+      candidateChars,
+      candidateSha256: sha256(projection.candidate),
+      reductionChars,
+      reductionRatio: source.length > 0 ? Number((reductionChars / source.length).toFixed(4)) : 0,
+      withinTarget: candidateChars <= TARGET_CHARS,
+      selectedSections: projection.selected.map((section) => sectionAudit(section.scope, section, "kernel_candidate")),
+      onDemandSections: projection.onDemand.map((section) => sectionAudit(section.scope, section, "on_demand_candidate"))
+    }
+  };
+}
+
 // src/amaster-runtime-daemon/config-state.mjs
 import { existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync5, renameSync as renameSync3, rmSync as rmSync3, writeFileSync as writeFileSync5 } from "node:fs";
 import { homedir as homedir2, hostname } from "node:os";
@@ -5597,6 +5812,7 @@ var CAPABILITIES = [
   "run_wakeup",
   "runtime_actions_v2",
   "model_call",
+  "model_call_output_contract_v1",
   "run_cancel",
   "run_terminate",
   "logs_cost_workspace_status"
@@ -6434,9 +6650,9 @@ function governedMcpToolResult(structuredContent) {
   const intentId = readString(effectResult.artifactIntentId);
   const manifestId = readString(effectResult.manifestId);
   const sourceRelativePath = readString(effectResult.sourceRelativePath);
-  const sha256 = readString(effectResult.sha256);
+  const sha2562 = readString(effectResult.sha256);
   const byteSize = readNumber(effectResult.byteSize, 0);
-  const artifactIntent = providerStatus === "pending_reconcile" && intentId && manifestId && sourceRelativePath && /^[a-f0-9]{64}$/.test(sha256 ?? "") && Number.isSafeInteger(byteSize) && byteSize > 0 ? { intentId, manifestId, sourceRelativePath, sha256, byteSize } : null;
+  const artifactIntent = providerStatus === "pending_reconcile" && intentId && manifestId && sourceRelativePath && /^[a-f0-9]{64}$/.test(sha2562 ?? "") && Number.isSafeInteger(byteSize) && byteSize > 0 ? { intentId, manifestId, sourceRelativePath, sha256: sha2562, byteSize } : null;
   const workspaceDocumentEffect = asRecord(effectResult.workspaceDocumentIntent);
   const workspaceDocumentCallId = readString(workspaceDocumentEffect.callId);
   const workspaceDocumentManifestId = readString(workspaceDocumentEffect.manifestId);
@@ -7391,7 +7607,7 @@ var postJsonWithRetry = postRuntimeConnectorJsonWithRetry;
 var bestEffortPostJson = bestEffortPostRuntimeConnectorJson;
 
 // src/amaster-runtime-daemon/runtime-artifact-upload.mjs
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 import { closeSync, constants, fstatSync, lstatSync as lstatSync3, openSync, readFileSync as readFileSync6, realpathSync as realpathSync3 } from "node:fs";
 import { isAbsolute as isAbsolute3, relative as relative3, resolve as resolve3 } from "node:path";
 var SHA256_PATTERN = /^[a-f0-9]{64}$/;
@@ -7481,7 +7697,7 @@ function prepareRuntimeArtifactUploads(cwd, mcpToolResults) {
       `Runtime Artifact ${intentId}`,
       { expectedByteSize }
     );
-    const actualSha256 = createHash5("sha256").update(body).digest("hex");
+    const actualSha256 = createHash6("sha256").update(body).digest("hex");
     if (body.length !== expectedByteSize || actualSha256 !== expectedSha256) {
       throw new Error(`Runtime Artifact ${intentId} bytes do not match the governed ownership manifest`);
     }
@@ -7498,7 +7714,7 @@ function prepareRuntimeArtifactUploads(cwd, mcpToolResults) {
 }
 
 // src/amaster-runtime-daemon/runtime-document-upload.mjs
-import { createHash as createHash6 } from "node:crypto";
+import { createHash as createHash7 } from "node:crypto";
 
 // src/amaster-runtime-daemon/workspace-sensitive-path.mjs
 var SENSITIVE_PATH_SEGMENTS = /* @__PURE__ */ new Set([
@@ -7573,7 +7789,7 @@ function prepareRuntimeDocumentUploads(cwd, mcpToolResults) {
         maxByteSize: MAX_WORKSPACE_DOCUMENT_BYTES
       }
     );
-    const actualSha256 = createHash6("sha256").update(body).digest("hex");
+    const actualSha256 = createHash7("sha256").update(body).digest("hex");
     if (body.length !== expectedByteSize || actualSha256 !== expectedSha256) {
       throw new Error(`Runtime Document ${callId} bytes do not match the governed ownership manifest`);
     }
@@ -7647,9 +7863,9 @@ function createRuntimeArtifactIngestQueue({ ingest, onError }) {
   let queue = Promise.resolve();
   const artifactIdentity = (intent) => {
     const sourceRelativePath = readString(asRecord(intent).sourceRelativePath);
-    const sha256 = readString(asRecord(intent).sha256);
+    const sha2562 = readString(asRecord(intent).sha256);
     const byteSize = asRecord(intent).byteSize;
-    return sourceRelativePath && sha256 && Number.isSafeInteger(byteSize) && byteSize > 0 ? `${sourceRelativePath}\0${sha256}\0${byteSize}` : null;
+    return sourceRelativePath && sha2562 && Number.isSafeInteger(byteSize) && byteSize > 0 ? `${sourceRelativePath}\0${sha2562}\0${byteSize}` : null;
   };
   const retainReceipts = (receipts) => {
     artifacts.push(...receipts);
@@ -7699,7 +7915,7 @@ function createRuntimeArtifactIngestQueue({ ingest, onError }) {
 }
 
 // src/amaster-runtime-daemon/workspace-guard.mjs
-import { createHash as createHash7 } from "node:crypto";
+import { createHash as createHash8 } from "node:crypto";
 import { existsSync as existsSync7, mkdirSync as mkdirSync6, realpathSync as realpathSync4, statSync as statSync4 } from "node:fs";
 import { basename as basename4, join as join8, isAbsolute as isAbsolute4, relative as relative4, resolve as resolve4 } from "node:path";
 
@@ -7825,7 +8041,7 @@ function resolveWorkspaceCwd(config, command) {
   return cwd;
 }
 function shortHash(value, length = 12) {
-  return createHash7("sha256").update(String(value)).digest("hex").slice(0, length);
+  return createHash8("sha256").update(String(value)).digest("hex").slice(0, length);
 }
 function safeSegment(value, fallback) {
   const raw = String(value ?? "").trim();
@@ -8269,7 +8485,7 @@ function summarizeAmasterRuntimeVersionDrift(input = {}) {
 }
 
 // src/amaster-runtime-daemon/pi-child-isolation.mjs
-import { createHash as createHash8 } from "node:crypto";
+import { createHash as createHash9 } from "node:crypto";
 import {
   chmodSync as chmodSync3,
   chownSync as chownSync2,
@@ -8280,7 +8496,7 @@ import {
 import { resolve as resolve7, sep } from "node:path";
 var defaultFs = { chmodSync: chmodSync3, chownSync: chownSync2, lchownSync, lstatSync: lstatSync4, readdirSync: readdirSync6 };
 function defaultHashRunId(runId) {
-  return Number.parseInt(createHash8("sha256").update(runId).digest("hex").slice(0, 8), 16);
+  return Number.parseInt(createHash9("sha256").update(runId).digest("hex").slice(0, 8), 16);
 }
 function positiveInteger(value, label) {
   if (!Number.isSafeInteger(value) || value <= 0) {
@@ -8404,7 +8620,7 @@ function preparePiChildIsolation(input) {
 }
 
 // src/amaster-runtime-daemon/pi-company-memory.mjs
-import { createHash as createHash9 } from "node:crypto";
+import { createHash as createHash10 } from "node:crypto";
 import {
   chmodSync as chmodSync4,
   chownSync as chownSync3,
@@ -8490,7 +8706,7 @@ function safeCompanyPiHomeSegment(companyId) {
   const raw = requiredString3(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 = createHash9("sha256").update(raw).digest("hex").slice(0, 12);
+  const hash = createHash10("sha256").update(raw).digest("hex").slice(0, 12);
   return normalized ? `${normalized}-${hash}` : `company-${hash}`;
 }
 function ensureMemoryRoot(root, fs) {
@@ -8529,7 +8745,7 @@ function allocateCompanyGid(root, companyId, input, fs) {
   if (groups[companyId]) return groups[companyId];
   const used = new Set(Object.values(groups));
   const initialOffset = Number.parseInt(
-    createHash9("sha256").update(companyId).digest("hex").slice(0, 12),
+    createHash10("sha256").update(companyId).digest("hex").slice(0, 12),
     16
   ) % gidSpan;
   let gid = null;
@@ -8631,7 +8847,7 @@ function prepareCompanyPiMemory(input, fs = defaultFs2) {
 }
 
 // src/amaster-runtime-daemon/pi-trusted-runtime-profile.mjs
-import { createHash as createHash10 } from "node:crypto";
+import { createHash as createHash11 } from "node:crypto";
 import {
   chmodSync as chmodSync5,
   copyFileSync as copyFileSync2,
@@ -8671,7 +8887,7 @@ function sha256File(path, label) {
   if (!stat.isFile() || stat.isSymbolicLink()) {
     throw new Error(`pi_trusted_runtime_source_unsafe:${label}`);
   }
-  return createHash10("sha256").update(readFileSync9(path)).digest("hex");
+  return createHash11("sha256").update(readFileSync9(path)).digest("hex");
 }
 function verifyDeclaredFiles(manifest, root, label, ignoredPaths = [], enforceComplete = true) {
   if (!Array.isArray(manifest.files) || manifest.files.length === 0) {
@@ -8939,12 +9155,12 @@ function materializeTrustedPiRuntimeProfile(input) {
     // bundle skills were enabled. Absent profile => main skills only.
     ...skillProfile ? {
       skillProfile,
-      enabledSkillsDigest: createHash10("sha256").update(JSON.stringify(enabledSkills)).digest("hex")
+      enabledSkillsDigest: createHash11("sha256").update(JSON.stringify(enabledSkills)).digest("hex")
     } : {}
   };
   return {
     facts,
-    attestationId: createHash10("sha256").update(JSON.stringify(facts)).digest("hex")
+    attestationId: createHash11("sha256").update(JSON.stringify(facts)).digest("hex")
   };
 }
 function assertAuditArgsRedacted(value) {
@@ -9140,7 +9356,7 @@ function verifyTrustedPiRuntimeAssertion(input) {
   if (hasSourceAssertion) {
     const exactTools = Array.isArray(record7(sourceProfile.tools).exactAllowlist) ? record7(sourceProfile.tools).exactAllowlist : [];
     const exactActions = Array.isArray(record7(sourceProfile.actions).exactAllowlist) ? record7(sourceProfile.actions).exactAllowlist : [];
-    const profileHash = createHash10("sha256").update(JSON.stringify(sourceProfile)).digest("hex");
+    const profileHash = createHash11("sha256").update(JSON.stringify(sourceProfile)).digest("hex");
     if (assertion.unknownToolMode !== "deny" || maxCalls !== 0 || sourceAssertion.profileVersion !== sourceProfile.purpose || sourceAssertion.profileHash !== profileHash || sourceAssertion.retentionVersion !== sourceProfile.retention || JSON.stringify(sourceAssertion.exactTools) !== JSON.stringify(exactTools) || JSON.stringify(sourceAssertion.exactActions) !== JSON.stringify(exactActions) || sourceAssertion.sourceId !== sourceProfile.sourceId || sourceAssertion.sourceRevisionId !== sourceProfile.sourceRevisionId || sourceAssertion.sourceRevision !== sourceProfile.sourceRevision || sourceAssertion.attemptId !== sourceProfile.attemptId || sourceAssertion.epoch !== sourceProfile.epoch) {
       throw new Error("pi_trusted_runtime_assertion_binding_mismatch:sourceAcquisition");
     }
@@ -9169,7 +9385,7 @@ function verifyTrustedPiRuntimeAssertion(input) {
 
 // src/amaster-runtime-daemon/workspace-status.mjs
 import { spawnSync as spawnSync4 } from "node:child_process";
-import { createHash as createHash11 } from "node:crypto";
+import { createHash as createHash12 } from "node:crypto";
 import { existsSync as existsSync12, readdirSync as readdirSync8, readFileSync as readFileSync10, statSync as statSync7 } from "node:fs";
 import { basename as basename5, extname, isAbsolute as isAbsolute7, join as join13, relative as relative7, resolve as resolve10 } from "node:path";
 var WORKSPACE_RUNTIME_SERVICES_FILENAME = ".amaster-runtime-services.json";
@@ -9240,7 +9456,7 @@ function sanitizeTrackedChange(line) {
   return isSafeRelativePath(path) ? line : null;
 }
 function sha256File2(filePath) {
-  return createHash11("sha256").update(readFileSync10(filePath)).digest("hex");
+  return createHash12("sha256").update(readFileSync10(filePath)).digest("hex");
 }
 function artifactHashCacheKey(relativePath, stat) {
   return `${relativePath}\0${stat.size}\0${stat.mtimeMs}`;
@@ -9441,7 +9657,7 @@ function readWorkspaceStatus(cwd, opts = {}) {
 }
 
 // src/amaster-runtime-daemon/pi-browser-session-adapter.mjs
-import { createHash as createHash12 } from "node:crypto";
+import { createHash as createHash13 } from "node:crypto";
 import { spawn, spawnSync as spawnSync5 } from "node:child_process";
 import { existsSync as existsSync13 } from "node:fs";
 import {
@@ -9564,7 +9780,7 @@ function fail(code) {
   throw Object.assign(new Error(code), { code });
 }
 function profileName(identity2) {
-  return createHash12("sha256").update(`${identity2.companyId}\0${identity2.bindingId}\0${identity2.localOpaqueRef}`).digest("hex");
+  return createHash13("sha256").update(`${identity2.companyId}\0${identity2.bindingId}\0${identity2.localOpaqueRef}`).digest("hex");
 }
 function expectedMarker(identity2) {
   return {
@@ -9963,7 +10179,7 @@ async function executeBrowserSessionCommand(command, dependencies = {}) {
 }
 
 // src/amaster-runtime-daemon/source-acquisition-invocation.mjs
-import { createHash as createHash13 } from "node:crypto";
+import { createHash as createHash14 } from "node:crypto";
 var SOURCE_ACQUISITION_PUBLIC_TOOLS = Object.freeze([
   "source_open",
   "source_snapshot",
@@ -10000,7 +10216,7 @@ function serializeSourceAcquisitionProfile(profile) {
   const input = Buffer.from(JSON.stringify(profile), "utf8");
   return {
     input,
-    sha256: createHash13("sha256").update(input).digest("hex")
+    sha256: createHash14("sha256").update(input).digest("hex")
   };
 }
 function sourceAcquisitionManagedInputs(options) {
@@ -10036,7 +10252,7 @@ function assertSourceAcquisitionRuntimeAuthority({
 }
 
 // src/amaster-runtime-daemon.mjs
-var CONNECTOR_VERSION = "0.1.1-beta.21";
+var CONNECTOR_VERSION = "0.1.1-beta.23";
 var CONNECTOR_CONTRACT_VERSION = "2026-06-04.v1";
 var SOURCE_ACQUISITION_CAPABILITY = "source_acquisition_v1";
 var SOURCE_ACQUISITION_PROFILE_VERSION = "source_acquisition_v1";
@@ -11370,7 +11586,7 @@ function sourceAcquisitionRuntimeProfile(config, command) {
   if (!companyId || !bindingId || !/^profile_[a-z0-9]{16,64}$/i.test(localOpaqueRef ?? "")) {
     throw new Error("source_acquisition_profile_invalid");
   }
-  const profileName2 = createHash14("sha256").update(`${companyId}\0${bindingId}\0${localOpaqueRef}`).digest("hex");
+  const profileName2 = createHash15("sha256").update(`${companyId}\0${bindingId}\0${localOpaqueRef}`).digest("hex");
   const stateRoot = resolve12(config.browserSessionStateRoot);
   const userDataDir = resolve12(stateRoot, profileName2);
   if (!pathWithin2(userDataDir, stateRoot)) throw new Error("source_acquisition_browser_profile_invalid");
@@ -11541,6 +11757,7 @@ function buildCommandPrompt(command, workspace, materializedAttachments = [], op
     suppliedFiles: agentInstructionFileNames(agentInstructionsBundle)
   });
   const agentInstructions = renderAgentInstructionsBundle(agentInstructionsBundle, agentInstructionDelivery);
+  const agentInstructionSystemKernelShadow = buildAgentInstructionSystemKernelShadow(agentInstructionsBundle);
   const runtimeAuth = commandRuntimeAuth(command);
   const hasGovernedMcp = Object.keys(asRecord(runtimeAuth.governedMcp)).length > 0;
   const attachmentsText = materializedAttachments.length > 0 ? [
@@ -11597,7 +11814,8 @@ function buildCommandPrompt(command, workspace, materializedAttachments = [], op
       agentInstructionDelivery: agentInstructionDeliveryAudit(
         agentInstructionsBundle,
         agentInstructionDelivery
-      )
+      ),
+      agentInstructionSystemKernelShadow: agentInstructionSystemKernelShadow.audit
     }
   };
 }
@@ -11668,7 +11886,30 @@ function copyPiModelCallConfig(sourceRoot, targetRoot, fileName, required) {
   copyFileSync3(source, target);
   chmodSync6(target, 384);
 }
-function preparePiModelCallProfile(commandId, baseEnv) {
+function copyPiModelCallDefaults(sourceRoot, targetRoot) {
+  const source = join15(sourceRoot, "settings.json");
+  if (!existsSync14(source)) return;
+  const sourceStat = lstatSync7(source);
+  if (!sourceStat.isFile() || sourceStat.isSymbolicLink()) {
+    throw new Error("pi_model_call_profile_unsafe: settings.json");
+  }
+  let settings;
+  try {
+    settings = asRecord(JSON.parse(readFileSync11(source, "utf8")));
+  } catch {
+    throw new Error("pi_model_call_profile_invalid: settings.json");
+  }
+  const defaultProvider = readString(settings.defaultProvider);
+  const defaultModel = normalizePiModelId(settings.defaultModel);
+  const target = join15(targetRoot, "settings.json");
+  writeFileSync9(target, `${JSON.stringify({
+    ...defaultProvider ? { defaultProvider } : {},
+    ...defaultModel ? { defaultModel } : {}
+  }, null, 2)}
+`, { mode: 384 });
+  chmodSync6(target, 384);
+}
+function preparePiModelCallProfile(commandId, baseEnv, options = {}) {
   const sourceRoot = readString(process.env.PI_CODING_AGENT_DIR) ?? readString(process.env.PI_AGENT_HOME) ?? readString(process.env["AMASTER-CLI_CODING_AGENT_DIR"]);
   if (!sourceRoot) throw new Error("pi_model_call_profile_missing: source Pi home");
   const sourceStat = lstatSync7(sourceRoot);
@@ -11686,6 +11927,7 @@ function preparePiModelCallProfile(commandId, baseEnv) {
   try {
     copyPiModelCallConfig(sourceRoot, agentDir, "models.json", true);
     copyPiModelCallConfig(sourceRoot, agentDir, "auth.json", false);
+    if (options.includeDefaults === true) copyPiModelCallDefaults(sourceRoot, agentDir);
     return {
       profileRoot,
       env: {
@@ -11721,6 +11963,16 @@ function sanitizePiExtraArgs(value) {
 function nativeSessionResumeEnabled(session) {
   return process.env.AMASTER_RUNTIME_ENABLE_NATIVE_SESSION_RESUME === "true" || readString(session.mode) === "governed_action_approval" && session.required === true;
 }
+function modelCallResponseContract(payload) {
+  if (payload.responseContract === void 0) return null;
+  const contract = asRecord(payload.responseContract);
+  const maxOutputTokens = Number(contract.maxOutputTokens);
+  const maxSemanticBytes = Number(contract.maxSemanticBytes);
+  if (readString(contract.format) !== "json" || readString(contract.thinking) !== "off" || !Number.isSafeInteger(maxOutputTokens) || maxOutputTokens < 1 || maxOutputTokens > 131072 || !Number.isSafeInteger(maxSemanticBytes) || maxSemanticBytes < 1024 || maxSemanticBytes > 256 * 1024) {
+    throw new Error("model_call_response_contract_invalid");
+  }
+  return { format: "json", thinking: "off", maxOutputTokens, maxSemanticBytes };
+}
 function resolveNativeSessionRequest(command, workspace) {
   const payload = asRecord(command.payload);
   const session = asRecord(payload.nativeSession);
@@ -11754,17 +12006,22 @@ function resolveNativeSessionRequest(command, workspace) {
     ...enabled && requested && sessionId && requestedCwd && !cwdMatched ? { skippedReason: "native_session_cwd_mismatch" } : {}
   };
 }
-function buildExecutorInvocation(executor, command = {}, workspace = null) {
+function buildExecutorInvocation(executor, command = {}, workspace = null, options = {}) {
   const payload = asRecord(command.payload);
   if (command.commandType === "model_call") {
     if (executor.kind === "pi") {
       const args = ["--mode", "json"];
-      const provider = readString(payload.provider) ?? readString(process.env.AMASTER_PI_PROVIDER);
-      const model = readString(payload.model) ?? readString(process.env.AMASTER_PI_MODEL);
+      const responseContract = options.responseContract ?? null;
+      const modelTarget = asRecord(options.modelTarget);
+      const provider = readString(modelTarget.provider) ?? readString(payload.provider) ?? readString(process.env.AMASTER_PI_PROVIDER);
+      const configuredModel = readString(modelTarget.model) ?? readString(payload.model) ?? readString(process.env.AMASTER_PI_MODEL);
+      const model = responseContract ? normalizePiModelId(configuredModel) : configuredModel;
       if (provider) args.push("--provider", provider);
       if (model) args.push("--model", model);
+      if (responseContract?.thinking) args.push("--thinking", responseContract.thinking);
       args.push(...sanitizePiExtraArgs(process.env.AMASTER_PI_EXTRA_ARGS));
       args.push("--no-extensions", "--no-skills", "--no-session", "--no-tools");
+      if (responseContract) args.push("--no-context-files");
       args.push("-p");
       return { command: executor.command, args, stdin: "prompt" };
     }
@@ -11852,7 +12109,7 @@ async function executeModelCallCommand(config, command, signal) {
   if (!prompt) {
     throw new Error("model_call command requires a prompt");
   }
-  const invocation = buildExecutorInvocation(executor, command);
+  const responseContract = modelCallResponseContract(payload);
   const timeoutSeconds = Math.max(1, Math.min(
     config.executorTimeoutSeconds,
     readNumber(payload.timeoutSeconds, Math.min(config.executorTimeoutSeconds, 60))
@@ -11861,14 +12118,9 @@ async function executeModelCallCommand(config, command, signal) {
     config.executorMaxOutputBytes,
     readNumber(payload.maxOutputBytes, 512 * 1024)
   ));
-  await ackCommand(config, command, "spawned");
-  await ingestLog(config, command, "system", "info", `Starting ${executor.kind} runtime model call`, {
-    executorKind: executor.kind,
-    args: invocation.args,
-    purpose: readString(payload.purpose) ?? null,
-    promptBytes: Buffer.byteLength(prompt, "utf8")
-  });
   let piModelCallProfile = null;
+  let modelTarget = null;
+  let invocation = null;
   let execution;
   try {
     const baseEnv = buildExecutorEnv(config, command, {
@@ -11876,7 +12128,16 @@ async function executeModelCallCommand(config, command, signal) {
       cwd: process.cwd(),
       sourceWorkspacePath: process.cwd()
     });
-    piModelCallProfile = executor.kind === "pi" ? preparePiModelCallProfile(command.commandId, baseEnv) : null;
+    const commandProvider = readString(payload.provider);
+    const commandModel = readString(payload.model);
+    const commandTargetRequested = Boolean(commandProvider || commandModel);
+    const envProvider = readString(process.env.AMASTER_PI_PROVIDER);
+    const envModel = readString(process.env.AMASTER_PI_MODEL);
+    const envTargetRequested = Boolean(envProvider || envModel);
+    const configuredTarget = commandTargetRequested ? { provider: commandProvider, model: commandModel, source: "command" } : { provider: envProvider, model: envModel, source: "runtime_env" };
+    piModelCallProfile = executor.kind === "pi" ? preparePiModelCallProfile(command.commandId, baseEnv, {
+      includeDefaults: Boolean(responseContract && !commandTargetRequested && !envTargetRequested)
+    }) : null;
     if (piModelCallProfile) {
       await syncPiExecutorProviderConfig(
         config,
@@ -11884,7 +12145,29 @@ async function executeModelCallCommand(config, command, signal) {
         piModelCallProfile.env.PI_CODING_AGENT_DIR,
         resolvePiExecutorProviderConfig(config, command, baseEnv)
       );
+      if (responseContract) {
+        modelTarget = resolvePiModelCallTarget(
+          piModelCallProfile.env.PI_CODING_AGENT_DIR,
+          configuredTarget.provider,
+          configuredTarget.model,
+          configuredTarget.source
+        );
+        applyModelCallOutputContract(
+          piModelCallProfile.env.PI_CODING_AGENT_DIR,
+          modelTarget.provider,
+          modelTarget.model,
+          responseContract.maxOutputTokens
+        );
+      }
     }
+    invocation = buildExecutorInvocation(executor, command, null, { responseContract, modelTarget });
+    await ackCommand(config, command, "spawned");
+    await ingestLog(config, command, "system", "info", `Starting ${executor.kind} runtime model call`, {
+      executorKind: executor.kind,
+      args: invocation.args,
+      purpose: readString(payload.purpose) ?? null,
+      promptBytes: Buffer.byteLength(prompt, "utf8")
+    });
     execution = await runExecutor(invocation.command, invocation.args, {
       cwd: process.cwd(),
       env: piModelCallProfile?.env ?? baseEnv,
@@ -11907,9 +12190,13 @@ async function executeModelCallCommand(config, command, signal) {
   const hasOutputFlood = Boolean(readString(outputFlood.stream) && readNumber(outputFlood.bytes, 0) > 0);
   const timedOut = execution.timedOut === true;
   const parsed = hasOutputFlood ? { summary: "", usage: null, errorMessage: null, messages: [] } : executor.kind === "pi" ? parsePiJsonl(execution.stdout) : parseGenericOutput(execution.stdout, execution.stderr);
-  const summary = truncateText(parsed.summary || parsed.finalMessage || parsed.messages?.join("\n\n") || "", 8e3);
-  const succeeded = !hasOutputFlood && !timedOut && !execution.spawnError && execution.exitCode === 0 && !parsed.errorMessage && Boolean(summary);
-  const error = timedOut ? `Runtime model call timed out after ${timeoutSeconds}s` : execution.spawnError ?? parsed.errorMessage ?? (hasOutputFlood ? `Runtime model call output flood: ${readString(outputFlood.stream)} exceeded ${readNumber(outputFlood.limitBytes, 0)} bytes` : succeeded ? null : `Runtime model call exited with code ${execution.exitCode ?? "unknown"}`);
+  const rawSummary = parsed.summary || parsed.finalMessage || parsed.messages?.join("\n\n") || "";
+  const semanticBytes = Buffer.byteLength(rawSummary, "utf8");
+  const semanticOutputExceeded = Boolean(responseContract && semanticBytes > responseContract.maxSemanticBytes);
+  const summary = semanticOutputExceeded ? "" : responseContract ? rawSummary : truncateText(rawSummary, 8e3);
+  const hasTerminalCompletion = !responseContract || executor.kind !== "pi" || Boolean(parsed.terminalEventType);
+  const succeeded = !hasOutputFlood && !timedOut && !semanticOutputExceeded && !execution.spawnError && execution.exitCode === 0 && hasTerminalCompletion && !parsed.errorMessage && Boolean(summary);
+  const error = timedOut ? `Runtime model call timed out after ${timeoutSeconds}s` : execution.spawnError ?? parsed.errorMessage ?? (hasOutputFlood ? `Runtime model call output flood: ${readString(outputFlood.stream)} exceeded ${readNumber(outputFlood.limitBytes, 0)} bytes` : semanticOutputExceeded ? `Runtime model call semantic output exceeded ${responseContract.maxSemanticBytes} bytes` : !hasTerminalCompletion ? "Runtime model call exited without a terminal provider response" : succeeded ? null : `Runtime model call exited with code ${execution.exitCode ?? "unknown"}`);
   await completeCommand(config, command, succeeded ? "succeeded" : "failed", {
     callType: "model_call",
     executorKind: executor.kind,
@@ -11920,7 +12207,26 @@ async function executeModelCallCommand(config, command, signal) {
     timedOut,
     summary,
     usage: parsed.usage,
-    stdout: truncateText(execution.stdout, 8e3),
+    ...responseContract ? {
+      driver: "pi_cli_json_v1",
+      responseContract,
+      ...modelTarget ? {
+        provider: modelTarget.provider,
+        model: modelTarget.model,
+        modelTargetSource: modelTarget.source
+      } : {},
+      stopReason: parsed.stopReason ?? null,
+      terminalEventType: parsed.terminalEventType ?? null,
+      semanticBytes,
+      outputBytes: Object.values(execution.outputBytes).reduce((total, bytes) => total + bytes, 0),
+      outputBytesByStream: execution.outputBytes,
+      retainedOutputBytes: Object.values(execution.retainedOutputBytes).reduce((total, bytes) => total + bytes, 0),
+      retainedOutputBytesByStream: execution.retainedOutputBytes
+    } : {},
+    // Contracted model calls persist semantic output and metadata only. Pi's
+    // JSONL stdout may contain provider reasoning/event content, so retaining
+    // even a bounded tail would violate the response-contract data boundary.
+    stdout: responseContract ? "" : truncateText(execution.stdout, 8e3),
     stderr: truncateText(filterExecutionStderrForResult(executor.kind, execution.stderr), 8e3),
     ...hasOutputFlood ? {
       errorCode: "model_call_output_flood",
@@ -11930,6 +12236,12 @@ async function executeModelCallCommand(config, command, signal) {
         bytes: readNumber(outputFlood.bytes, 0),
         limitBytes: readNumber(outputFlood.limitBytes, maxOutputBytes)
       }
+    } : semanticOutputExceeded ? {
+      errorCode: "model_call_semantic_output_exceeded",
+      errorFamily: "validation"
+    } : responseContract && !hasTerminalCompletion ? {
+      errorCode: "model_call_terminal_event_missing",
+      errorFamily: "provider_protocol"
     } : {}
   }, error ?? void 0);
 }
@@ -14202,7 +14514,7 @@ async function materializeIssueAttachments(config, command, workspace) {
     const body = await runtimeApiBuffer(runtimeAuth, contentPath);
     writeFileSync9(targetPath, body);
     const attachmentId = readString(attachment.id);
-    const actualSha256 = createHash14("sha256").update(body).digest("hex");
+    const actualSha256 = createHash15("sha256").update(body).digest("hex");
     const lineageCandidates = lineageCandidatesByAttachmentId.get(attachmentId) ?? [];
     const lineage = selectAttachmentLineage(lineageCandidates, actualSha256);
     if (lineageCandidates.length > 0 && !lineage) {
@@ -14283,10 +14595,10 @@ async function materializeRequiredArtifactInputs(config, command, workspace) {
     const entry = asRecord(rawEntry);
     const workProductId = readString(entry.workProductId);
     const attachmentId = readString(entry.attachmentId);
-    const sha256 = readString(entry.sha256);
+    const sha2562 = readString(entry.sha256);
     const contentPath = readString(entry.contentPath);
     const byteSize = readNumber(entry.byteSize, null);
-    if (!workProductId || !attachmentId || !/^[a-f0-9]{64}$/i.test(sha256 ?? "") || !contentPath || byteSize === null) {
+    if (!workProductId || !attachmentId || !/^[a-f0-9]{64}$/i.test(sha2562 ?? "") || !contentPath || byteSize === null) {
       throw new Error(`artifact_input_manifest_invalid: entry ${index} is incomplete`);
     }
     const expectedContentPath = `/api/attachments/${attachmentId}/content`;
@@ -14294,10 +14606,10 @@ 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 = createHash14("sha256").update(body).digest("hex");
-    if (body.byteLength !== byteSize || actualSha256 !== sha256) {
+    const actualSha256 = createHash15("sha256").update(body).digest("hex");
+    if (body.byteLength !== byteSize || actualSha256 !== sha2562) {
       throw new Error(
-        `artifact_input_integrity_mismatch: workProductId=${workProductId} expectedBytes=${byteSize} actualBytes=${body.byteLength} expectedSha256=${sha256} actualSha256=${actualSha256}`
+        `artifact_input_integrity_mismatch: workProductId=${workProductId} expectedBytes=${byteSize} actualBytes=${body.byteLength} expectedSha256=${sha2562} actualSha256=${actualSha256}`
       );
     }
     const sourceDir = safeArtifactInputSourceDir(entry, index);
@@ -14327,7 +14639,7 @@ async function materializeRequiredArtifactInputs(config, command, workspace) {
       relativePath,
       contentType: readString(entry.contentType),
       byteSize: body.byteLength,
-      sha256,
+      sha256: sha2562,
       contentPath
     });
   }
@@ -14364,7 +14676,7 @@ function safeCheckpointRelativePath(rawPath) {
   return normalized;
 }
 function hashFileSha256(filePath) {
-  return createHash14("sha256").update(readFileSync11(filePath)).digest("hex");
+  return createHash15("sha256").update(readFileSync11(filePath)).digest("hex");
 }
 async function materializeIssueCheckpoint(config, command, workspace) {
   const checkpointDir = issueCheckpointDir(workspace);

package/dist/amaster-runtime.mjs

@@ -6,7 +6,7 @@ import { basename, dirname, join, resolve } from "node:path";
 import { homedir, hostname } from "node:os";
 import { fileURLToPath } from "node:url";
 
-const CONNECTOR_VERSION = "0.1.1-beta.21";
+const CONNECTOR_VERSION = "0.1.1-beta.23";
 
 const CAPABILITIES = [
   "remote_registration",
@@ -16,6 +16,7 @@ const CAPABILITIES = [
   "run_wakeup",
   "runtime_actions_v2",
   "model_call",
+  "model_call_output_contract_v1",
   "run_cancel",
   "run_terminate",
   "logs_cost_workspace_status",

package/package.json

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