@amaster.ai/employee-runtime-connector 0.1.1-beta.69 → 0.1.1-beta.70

package/dist/amaster-runtime-daemon.mjs

@@ -2999,6 +2999,10 @@ function createManagedPiMcpProfileApi(options = {}) {
     "runtime_action.submit",
     "runtime_action.status"
   ]);
+  const RUN_EXIT_CLOSURE_DIRECT_TYPED_TOOL_NAMES = /* @__PURE__ */ new Set([
+    "runtime_action.describe",
+    "runtime_action.submit"
+  ]);
   const PROVIDER_SAFE_TOOL_NAME = /^[A-Za-z][A-Za-z0-9_-]*$/;
   const PI_BUILTIN_TOOL_NAMES = /* @__PURE__ */ new Set(["read", "bash", "edit", "write", "grep", "find", "ls", "mcp"]);
   const MINIMUM_PI_VERSION = [0, 73, 1];
@@ -4265,6 +4269,63 @@ ${result3.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
         };
         writePrivateFile2(manifestPath, `${JSON.stringify(manifest, null, 2)}
 `);
+        const closureTools = directCatalog.tools.filter((tool) => RUN_EXIT_CLOSURE_DIRECT_TYPED_TOOL_NAMES.has(tool.name));
+        const closureProfile = closureTools.length === RUN_EXIT_CLOSURE_DIRECT_TYPED_TOOL_NAMES.size ? (() => {
+          const closureToolNames = closureTools.map((tool) => tool.exposedName);
+          const closureServerConfig = {
+            ...serverConfig,
+            directTools: closureToolNames
+          };
+          const closureConfigContents = `${JSON.stringify({
+            ...config,
+            mcpServers: { [SUPPORTED_SERVER_NAME2]: closureServerConfig }
+          }, null, 2)}
+`;
+          const closureCacheContents = `${JSON.stringify({
+            version: 1,
+            servers: {
+              [SUPPORTED_SERVER_NAME2]: {
+                configHash: adapterServerConfigHash(closureServerConfig, adapterVersion),
+                tools: closureTools.map((tool) => ({
+                  name: tool.exposedName,
+                  description: tool.description,
+                  inputSchema: tool.inputSchema
+                })),
+                resources: [],
+                cachedAt: currentTimeMs()
+              }
+            }
+          }, null, 2)}
+`;
+          const closureCacheBytes = Buffer.from(closureCacheContents);
+          const closureConfigBytes = Buffer.from(closureConfigContents);
+          const closureManifestContents = `${JSON.stringify({
+            ...manifest,
+            entries: closureTools.map((tool) => ({
+              name: tool.exposedName,
+              canonicalName: tool.name,
+              schema: tool.inputSchema,
+              effectiveSchemaHash: tool.effectiveSchemaHash
+            })),
+            effectiveSetHash: stablePiEffectiveToolSetHash(closureTools.map((tool) => ({
+              name: tool.exposedName,
+              schemaHash: tool.effectiveSchemaHash
+            }))),
+            configSha256: sha2562(closureConfigBytes),
+            cacheSha256: sha2562(closureCacheBytes),
+            cacheSemanticHash: stablePiManagedMcpCacheSemanticHash(closureCacheBytes)
+          }, null, 2)}
+`;
+          return {
+            toolAllowlist: closureToolNames,
+            cacheContentsBase64: closureCacheBytes.toString("base64"),
+            cacheSha256: sha2562(closureCacheBytes),
+            manifestContentsBase64: Buffer.from(closureManifestContents).toString("base64"),
+            manifestSha256: sha2562(Buffer.from(closureManifestContents)),
+            configContentsBase64: closureConfigBytes.toString("base64"),
+            configSha256: sha2562(closureConfigBytes)
+          };
+        })() : null;
         directAttestationInput = {
           cachePath,
           manifestPath,
@@ -4277,7 +4338,8 @@ ${result3.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
           attestorSourceSha256,
           effectiveSetHash: manifest.effectiveSetHash,
           proxyMode: manifest.proxyMode,
-          extensionArgs: [...extensionArgs]
+          extensionArgs: [...extensionArgs],
+          closureProfile
         };
       }
       let enabledRoleSkills = null;
@@ -4335,7 +4397,11 @@ ${result3.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
         effectiveToolsBootstrapCache?.key ?? null
       ) : {};
       const effectiveToolProbeBootstrapCache = effectiveToolsBootstrapCache ? publishEffectiveToolsBootstrapCache(effectiveToolsBootstrapCache) : null;
-      const runExitClosureCacheOwnership = directAttestationInput ? ownershipStatSyncImpl(directAttestationInput.cachePath) : null;
+      const runExitClosureOwnership = directAttestationInput ? {
+        cache: ownershipStatSyncImpl(directAttestationInput.cachePath),
+        manifest: ownershipStatSyncImpl(directAttestationInput.manifestPath),
+        config: ownershipStatSyncImpl(directAttestationInput.configPath)
+      } : null;
       const attestationFacts = {
         connectorVersion: nonEmpty2(input.connectorVersion, "connectorVersion"),
         executorKind: "pi",
@@ -4372,18 +4438,25 @@ ${result3.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
         workspaceMcpConfigPath,
         ...directAttestationInput ? {
           runExitClosureBaseline: {
-            schemaVersion: "amaster.pi-run-exit-closure-baseline.v1",
+            schemaVersion: directAttestationInput.closureProfile ? "amaster.pi-run-exit-closure-baseline.v2" : "amaster.pi-run-exit-closure-baseline.v1",
             owner,
             profileRoot,
             cachePath: directAttestationInput.cachePath,
             cacheSha256: directAttestationInput.cacheSha256,
             cacheContentsBase64: directAttestationInput.cacheContentsBase64,
-            cacheOwnership: runExitClosureCacheOwnership ? { uid: runExitClosureCacheOwnership.uid, gid: runExitClosureCacheOwnership.gid } : null,
+            cacheOwnership: runExitClosureOwnership ? { uid: runExitClosureOwnership.cache.uid, gid: runExitClosureOwnership.cache.gid } : null,
             manifestPath: directAttestationInput.manifestPath,
             manifestSha256: sha2562(readFileSync3(directAttestationInput.manifestPath)),
             configPath: directAttestationInput.configPath,
             configSha256: directAttestationInput.configSha256,
-            receiptPath: directAttestationInput.receiptPath
+            receiptPath: directAttestationInput.receiptPath,
+            ...directAttestationInput.closureProfile ? {
+              closureProfile: {
+                ...directAttestationInput.closureProfile,
+                manifestOwnership: runExitClosureOwnership ? { uid: runExitClosureOwnership.manifest.uid, gid: runExitClosureOwnership.manifest.gid } : null,
+                configOwnership: runExitClosureOwnership ? { uid: runExitClosureOwnership.config.uid, gid: runExitClosureOwnership.config.gid } : null
+              }
+            } : {}
           }
         } : {},
         // Only narrowed specialized catalogs (diagnosis/source-acquisition) pin
@@ -4413,7 +4486,7 @@ ${result3.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
   function restoreManagedPiRunExitClosureBaseline2(input, expectedOwner2) {
     if (!input) return { status: "not_required" };
     const baseline = record6(input);
-    if (baseline.schemaVersion !== "amaster.pi-run-exit-closure-baseline.v1") {
+    if (!["amaster.pi-run-exit-closure-baseline.v1", "amaster.pi-run-exit-closure-baseline.v2"].includes(baseline.schemaVersion)) {
       throw new Error("pi_run_exit_closure_baseline_invalid: unsupported schema version");
     }
     const owner = record6(baseline.owner);
@@ -4450,26 +4523,80 @@ ${result3.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
     if (!cacheOwnership) {
       throw new Error("pi_run_exit_closure_baseline_cache_owner_missing");
     }
-    if (sha2562(readFileSync3(manifestPath)) !== nonEmpty2(baseline.manifestSha256, "runExitClosureBaseline.manifestSha256")) {
+    const closureProfile = baseline.schemaVersion === "amaster.pi-run-exit-closure-baseline.v2" ? record6(baseline.closureProfile) : null;
+    const closureToolAllowlist = closureProfile ? Array.isArray(closureProfile.toolAllowlist) ? closureProfile.toolAllowlist.filter((name) => typeof name === "string") : [] : null;
+    if (closureToolAllowlist && (closureToolAllowlist.length !== RUN_EXIT_CLOSURE_DIRECT_TYPED_TOOL_NAMES.size || new Set(closureToolAllowlist).size !== RUN_EXIT_CLOSURE_DIRECT_TYPED_TOOL_NAMES.size || closureToolAllowlist.some((name) => !PROVIDER_SAFE_TOOL_NAME.test(name)))) {
+      throw new Error("pi_run_exit_closure_baseline_tool_allowlist_invalid");
+    }
+    const currentManifestSha256 = sha2562(readFileSync3(manifestPath));
+    const acceptedManifestDigests = /* @__PURE__ */ new Set([
+      nonEmpty2(baseline.manifestSha256, "runExitClosureBaseline.manifestSha256"),
+      ...closureProfile ? [nonEmpty2(closureProfile.manifestSha256, "closureProfile.manifestSha256")] : []
+    ]);
+    if (!acceptedManifestDigests.has(currentManifestSha256)) {
       throw new Error("pi_run_exit_closure_baseline_manifest_drift");
     }
-    if (sha2562(readFileSync3(configPath)) !== nonEmpty2(baseline.configSha256, "runExitClosureBaseline.configSha256")) {
+    const currentConfigSha256 = sha2562(readFileSync3(configPath));
+    const acceptedConfigDigests = /* @__PURE__ */ new Set([
+      nonEmpty2(baseline.configSha256, "runExitClosureBaseline.configSha256"),
+      ...closureProfile ? [nonEmpty2(closureProfile.configSha256, "closureProfile.configSha256")] : []
+    ]);
+    if (!acceptedConfigDigests.has(currentConfigSha256)) {
       throw new Error("pi_run_exit_closure_baseline_config_drift");
     }
+    const phaseContents = closureProfile ? [
+      {
+        path: configPath,
+        bytes: Buffer.from(nonEmpty2(closureProfile.configContentsBase64, "closureProfile.configContentsBase64"), "base64"),
+        expectedSha256: nonEmpty2(closureProfile.configSha256, "closureProfile.configSha256"),
+        ownership: record6(closureProfile.configOwnership),
+        label: "config"
+      },
+      {
+        path: cachePath,
+        bytes: Buffer.from(nonEmpty2(closureProfile.cacheContentsBase64, "closureProfile.cacheContentsBase64"), "base64"),
+        expectedSha256: nonEmpty2(closureProfile.cacheSha256, "closureProfile.cacheSha256"),
+        ownership: baselineCacheOwnership,
+        label: "cache"
+      },
+      {
+        path: manifestPath,
+        bytes: Buffer.from(nonEmpty2(closureProfile.manifestContentsBase64, "closureProfile.manifestContentsBase64"), "base64"),
+        expectedSha256: nonEmpty2(closureProfile.manifestSha256, "closureProfile.manifestSha256"),
+        ownership: record6(closureProfile.manifestOwnership),
+        label: "manifest"
+      }
+    ] : [{
+      path: cachePath,
+      bytes: cacheContents,
+      expectedSha256: cacheSha256,
+      ownership: baselineCacheOwnership,
+      label: "cache"
+    }];
     if (existsSync3(receiptPath)) rmSync2(receiptPath);
-    writeOwnedFileAtomic(cachePath, cacheContents);
-    const replacedCacheStat = ownershipStatSyncImpl(cachePath);
-    if (replacedCacheStat.uid !== cacheOwnership.uid || replacedCacheStat.gid !== cacheOwnership.gid) {
-      chownSyncImpl(cachePath, cacheOwnership.uid, cacheOwnership.gid);
-    }
-    if (sha2562(readFileSync3(cachePath)) !== cacheSha256) {
-      throw new Error("pi_run_exit_closure_baseline_restore_failed");
-    }
-    const restoredCacheStat = ownershipStatSyncImpl(cachePath);
-    if (restoredCacheStat.uid !== cacheOwnership.uid || restoredCacheStat.gid !== cacheOwnership.gid) {
-      throw new Error("pi_run_exit_closure_baseline_owner_restore_failed");
+    for (const entry of phaseContents) {
+      if (sha2562(entry.bytes) !== entry.expectedSha256) {
+        throw new Error(`pi_run_exit_closure_${entry.label}_digest_mismatch`);
+      }
+      const recordedOwnership = Number.isSafeInteger(entry.ownership.uid) && entry.ownership.uid >= 0 && Number.isSafeInteger(entry.ownership.gid) && entry.ownership.gid >= 0 ? { uid: entry.ownership.uid, gid: entry.ownership.gid } : entry.path === cachePath ? cacheOwnership : ownershipStatSyncImpl(entry.path);
+      writeOwnedFileAtomic(entry.path, entry.bytes);
+      const replacedStat = ownershipStatSyncImpl(entry.path);
+      if (replacedStat.uid !== recordedOwnership.uid || replacedStat.gid !== recordedOwnership.gid) {
+        chownSyncImpl(entry.path, recordedOwnership.uid, recordedOwnership.gid);
+      }
+      if (sha2562(readFileSync3(entry.path)) !== entry.expectedSha256) {
+        throw new Error(`pi_run_exit_closure_${entry.label}_restore_failed`);
+      }
+      const restoredStat = ownershipStatSyncImpl(entry.path);
+      if (restoredStat.uid !== recordedOwnership.uid || restoredStat.gid !== recordedOwnership.gid) {
+        throw new Error(`pi_run_exit_closure_${entry.label}_owner_restore_failed`);
+      }
     }
-    return { status: "restored", cacheSha256 };
+    return {
+      status: "restored",
+      cacheSha256: closureProfile?.cacheSha256 ?? cacheSha256,
+      ...closureToolAllowlist ? { toolAllowlist: closureToolAllowlist } : {}
+    };
   }
   function inspectManagedPiRunExitClosureAttestation2(input, expectedOwner2) {
     if (!input) return { status: "not_required" };
@@ -11185,7 +11312,7 @@ var source_acquisition_compatibility_default = {
 };
 
 // src/amaster-runtime-daemon.mjs
-var CONNECTOR_VERSION = "0.1.1-beta.69";
+var CONNECTOR_VERSION = "0.1.1-beta.70";
 var CONNECTOR_CONTRACT_VERSION = "2026-06-04.v1";
 var SOURCE_ACQUISITION_CAPABILITY = source_acquisition_compatibility_default.profileVersion;
 var daemonRequire = createRequire(import.meta.url);
@@ -14275,13 +14402,14 @@ async function requestRunCompletionCheck(config, inputState) {
   }
   return { pending: true, state };
 }
-function runExitClosurePrompt(state) {
+function runExitClosurePrompt(state, options = {}) {
   const command = asRecord(state.command);
   const response = asRecord(state.completionResponse);
   const summary = truncateText(readString(asRecord(state.candidateResult).summary) ?? "", 1200);
   const issueId = commandIssueId(command) ?? "unknown";
   const runId = commandRunId(command) ?? "unknown";
   const closureStrategy = readString(response.closureStrategy) ?? "select_issue_disposition";
+  const describeRequired = options.describeRequired !== false;
   const allowedActions = Array.isArray(response.allowedActions) ? response.allowedActions.filter((value) => typeof value === "string") : [];
   return [
     "# AMaster Run-Exit Disposition Closure",
@@ -14291,11 +14419,11 @@ function runExitClosurePrompt(state) {
     summary ? `Primary turn summary: ${summary}` : null,
     "Do not perform more business work, edit files, create artifacts/documents/children/plans, or mutate company/profile/milestone state.",
     closureStrategy === "record_work_disposition" ? "Effective closure action for this turn: record_work_disposition only." : `Server-allowed closure actions: ${allowedActions.join(", ") || "none"}.`,
-    "Use exactly one runtime_action.submit mutation.",
+    describeRequired ? closureStrategy === "record_work_disposition" ? "Call runtime_action.describe exactly once for record_work_disposition, then use exactly one runtime_action.submit mutation with that described shape." : "Choose one Server-allowed action, call runtime_action.describe exactly once for that action type, then use exactly one runtime_action.submit mutation with that described shape." : "Use exactly one runtime_action.submit mutation with the already-issued phase-specific schema.",
     closureStrategy === "record_work_disposition" ? "The Server selected record_work_disposition as the only closure strategy. For this already-productive source run, record execute_inline with truthful source-run evidence; do not also mutate issue status or create an interaction. After command terminalization, the Server writes the Business Outcome and owns the matching Board review or terminal-state transition." : "The Server selected an Issue disposition closure. Choose update_parent, create_interaction (not suggest_tasks), or add_comment only when a comment is truly the intended exit path. A comment alone does not establish completion.",
     closureStrategy === "record_work_disposition" ? `Use evidenceRefs ["run:${runId}", "command:${state.commandId}"], structure.deliverableType "runtime_command_result", structure.deliverableKey "runtime-command-${state.commandId}", and structure.acceptanceMethodCode "governed_business_outcome". Supply a concise truthful reason based only on the primary turn summary.` : null,
     `The idempotencyKey must be runtime-command-closure:${state.commandId}.`,
-    "Do not call runtime_action.plan or runtime_action.commit. Stop immediately after the one allowed mutation returns."
+    describeRequired ? "Do not call runtime_action.plan or runtime_action.commit. Do not call runtime_action.describe more than once. Stop immediately after the one allowed mutation returns." : "Do not call runtime_action.describe, runtime_action.plan, or runtime_action.commit. Stop immediately after the one allowed mutation returns."
   ].filter(Boolean).join("\n\n");
 }
 function parseExecutorTurnOutput(executorKind, execution, liveOutputLogger, hasOutputFlood) {
@@ -14473,18 +14601,23 @@ async function executeRunExitClosureTurn(config, inputState, options = {}) {
       executionConfig.runExitClosureBaseline,
       { commandId: state.commandId, runId: commandRunId(command) }
     ) : { status: "not_required" };
+    const closureArgs = executorKind === "pi" ? applyManagedPiToolAllowlist(args, {
+      toolAllowlist: Array.isArray(managedMcpClosureBaseline.toolAllowlist) ? managedMcpClosureBaseline.toolAllowlist : null
+    }) : args;
+    const describeRequired = executorKind !== "pi" || managedMcpClosureBaseline.status !== "restored" || Array.isArray(managedMcpClosureBaseline.toolAllowlist);
     await ingestLog(config, command, "system", "info", "Starting bounded run-exit disposition closure turn", {
       presentationKind: "run_exit_disposition_closure",
       commandId: state.commandId,
       closureAttempt: 1,
-      managedMcpClosureBaselineStatus: managedMcpClosureBaseline.status
+      managedMcpClosureBaselineStatus: managedMcpClosureBaseline.status,
+      managedMcpClosureToolAllowlist: managedMcpClosureBaseline.toolAllowlist ?? null
     });
     let execution;
     try {
-      execution = await runExecutor(executable, args, {
+      execution = await runExecutor(executable, closureArgs, {
         cwd,
         env,
-        stdin: runExitClosurePrompt(state),
+        stdin: runExitClosurePrompt(state, { describeRequired }),
         timeoutSeconds: Math.max(1, readNumber(executionConfig.timeoutSeconds, config.executorTimeoutSeconds)),
         maxOutputBytes: Math.max(1, readNumber(executionConfig.maxOutputBytes, config.executorMaxOutputBytes)),
         maxRssMb: Math.max(0, readNumber(executionConfig.maxRssMb, config.executorMaxRssMb)),

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.69";
+const CONNECTOR_VERSION = "0.1.1-beta.70";
 
 const CAPABILITIES = [
   "remote_registration",

package/package.json

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