impel-cli 0.18.15-beta.9 → 0.18.16

package/README.md

@@ -98,6 +98,12 @@ Names include the tenant, such as `Impel Claude (Acme)` and
 `Impel ChatGPT (Acme)`. The selected CLI tenant does not affect which tenant an
 app opens. Tenant variants can remain installed side by side.
 
+Impel-managed apps do not run the vendors' in-app auto-updaters. The generated
+Claude policy disables its updater, and the ChatGPT launcher disables Sparkle
+before starting the pinned app. Run `impel update` to move managed apps to the
+next exact vendor builds reviewed and shipped with the CLI. This does not
+change the update settings of native personal Claude or ChatGPT installations.
+
 Linux does not have managed desktop apps. Use the isolated CLI commands there.
 
 ## Experimental managed Cursor

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "impel-cli",
-  "version": "0.18.15-beta.9",
+  "version": "0.18.16",
   "description": "Prepare isolated Claude and Codex workspaces for every accessible Impel tenant",
   "type": "module",
   "bin": {

package/src/agents.js

@@ -21,6 +21,7 @@ export const NATIVE_AGENT_LIST_TOOL = "impel_specialists-list_native_agents";
 export const NATIVE_AGENT_START_TOOL = "impel_specialists-start_native_agent_run";
 export const NATIVE_AGENT_READ_TOOL = "impel_specialists-read_native_agent_run";
 export const MANAGED_AGENT_MCP_SERVER = "impel_agent";
+export const MANAGED_AGENT_MANIFEST_VERSION = 4;
 
 const NATIVE_AGENT_TOOL_NAMES = [
   NATIVE_AGENT_LIST_TOOL,
@@ -320,7 +321,7 @@ function generatedClientAgentNames(client, agents) {
   });
 }
 
-function adapterInstructions(tenantId, agent) {
+function claudeAdapterInstructions(tenantId, agent) {
   const toolName = nativeToolName;
   const contextRequirement = agent.requiredContext.length
     ? ` Required context keys are ${JSON.stringify(agent.requiredContext)}; if any are absent, ask for them before starting the run.`
@@ -333,7 +334,7 @@ function adapterInstructions(tenantId, agent) {
     `Do not perform the assigned task yourself and do not delegate to any other agent.`,
     `First call ${toolName(NATIVE_AGENT_LIST_TOOL)} and verify that the exact agentId is still available with sideEffects ${JSON.stringify(agent.sideEffects)}. If it is unavailable or its policy excludes the request, stop with that explicit error.`,
     sideEffectInstruction,
-    `Call ${toolName(NATIVE_AGENT_START_TOOL)} exactly once with agentId ${JSON.stringify(agent.agentId)}, scopeParam ${JSON.stringify(agent.scopeParam)}, task set to the complete assigned task, context and contextKeys containing all supplied context, confirmedSideEffects as directed above, and one stable idempotencyKey that you reuse for this logical task.${contextRequirement}`,
+    `Call ${toolName(NATIVE_AGENT_START_TOOL)} exactly once with agentId ${JSON.stringify(agent.agentId)}, scopeParam ${JSON.stringify(agent.scopeParam)}, task set to the complete assigned task, optional context set to one string containing all supplied context (omit it when no context was supplied), contextKeys naming the context fields present in that string, confirmedSideEffects as directed above, and one stable idempotencyKey that you reuse for this logical task.${contextRequirement}`,
     `Then call ${toolName(NATIVE_AGENT_READ_TOOL)} with the returned runId and waitSeconds 20 until the run reaches a terminal state.`,
     `When it succeeds, return result.finalText faithfully as the answer. When it fails, return the durable runId, preserved output, and error. Never invent or independently synthesize a replacement result.`,
   ].join(" ");
@@ -343,6 +344,170 @@ function nativeToolName(toolName) {
   return `mcp__${MANAGED_AGENT_MCP_SERVER}__${toolName}`;
 }
 
+const CODEX_TASK_PLACEHOLDER = "__IMPEL_COMPLETE_ASSIGNED_TASK_JSON__";
+const CODEX_CONTEXT_PLACEHOLDER = "__IMPEL_OPTIONAL_CONTEXT_STRING_OR_NULL_JSON__";
+const CODEX_CONTEXT_KEYS_PLACEHOLDER = "__IMPEL_SUPPLIED_CONTEXT_KEYS_JSON__";
+const CODEX_IDEMPOTENCY_KEY_PLACEHOLDER = "__IMPEL_LOGICAL_INVOCATION_IDEMPOTENCY_KEY_JSON__";
+
+export function renderCodexAdapterOrchestration(tenantId, agent) {
+  const expectedTenantId = normalizeTenantId(tenantId);
+  const nestedToolName = (toolName) => nativeToolName(toolName).replaceAll("-", "_");
+  const listTool = nestedToolName(NATIVE_AGENT_LIST_TOOL);
+  const startTool = nestedToolName(NATIVE_AGENT_START_TOOL);
+  const readTool = nestedToolName(NATIVE_AGENT_READ_TOOL);
+  return [
+    '// @exec: {"yield_time_ms": 30000, "max_output_tokens": 30000}',
+    `const assignedTask = ${CODEX_TASK_PLACEHOLDER};`,
+    `const suppliedContext = ${CODEX_CONTEXT_PLACEHOLDER};`,
+    `const suppliedContextKeys = ${CODEX_CONTEXT_KEYS_PLACEHOLDER};`,
+    `const idempotencyKey = ${CODEX_IDEMPOTENCY_KEY_PLACEHOLDER};`,
+    `const expectedTenantId = ${JSON.stringify(expectedTenantId)};`,
+    `const expectedAgent = ${JSON.stringify(agent)};`,
+    "const waitSeconds = 20; // Compatible fallback until the bound server advertises a larger ceiling.",
+    `const listToolName = ${JSON.stringify(listTool)};`,
+    `const startToolName = ${JSON.stringify(startTool)};`,
+    `const readToolName = ${JSON.stringify(readTool)};`,
+    "",
+    "function stableValue(value) {",
+    "  if (Array.isArray(value)) return value.map(stableValue);",
+    '  if (!value || typeof value !== "object") return value;',
+    "  const result = {};",
+    "  for (const key of Object.keys(value).sort()) result[key] = stableValue(value[key]);",
+    "  return result;",
+    "}",
+    "",
+    "function contentText(response) {",
+    '  return response?.content?.find((item) => item?.type === "text" && typeof item.text === "string")?.text;',
+    "}",
+    "",
+    "function toolPayload(response, label) {",
+    '  if (!response || typeof response !== "object") throw new Error(label + " returned no result");',
+    '  if (response.isError) throw new Error(contentText(response) || label + " failed");',
+    '  if (response.structuredContent && typeof response.structuredContent === "object") return response.structuredContent;',
+    "  const serialized = contentText(response);",
+    "  if (serialized !== undefined) {",
+    "    try {",
+    "      return JSON.parse(serialized);",
+    "    } catch {",
+    '      throw new Error(label + " returned invalid JSON");',
+    "    }",
+    "  }",
+    "  return response;",
+    "}",
+    "",
+    "function preservedOutput(run) {",
+    '  if (run && Object.prototype.hasOwnProperty.call(run, "output")) return run.output;',
+    '  if (run && Object.prototype.hasOwnProperty.call(run, "result")) return run.result;',
+    "  return null;",
+    "}",
+    "",
+    "function errorValue(error, fallback) {",
+    "  if (error === undefined || error === null) return fallback;",
+    '  if (error instanceof Error) return error.message;',
+    "  return error;",
+    "}",
+    "",
+    "async function orchestrate() {",
+    "  let runId = null;",
+    "  let latestRun = null;",
+    "  try {",
+    '    if (typeof assignedTask !== "string" || !assignedTask.trim()) throw new Error("the complete assigned task is required");',
+    '    if (suppliedContext !== null && typeof suppliedContext !== "string") throw new Error("supplied context must be a string or null");',
+    '    if (expectedAgent.requiredContext.length && (typeof suppliedContext !== "string" || !suppliedContext.trim())) {',
+    '      throw new Error("nonblank supplied context is required for required context keys");',
+    "    }",
+    '    if (!Array.isArray(suppliedContextKeys)) throw new Error("supplied context keys must be an array");',
+    '    if (typeof idempotencyKey !== "string" || !/^[A-Za-z0-9._:-]{16,160}$/u.test(idempotencyKey)) {',
+    '      throw new Error("a unique stable logical-invocation idempotencyKey is required");',
+    "    }",
+    "    const missingContext = expectedAgent.requiredContext.filter((key) =>",
+    "      !suppliedContextKeys.includes(key)",
+    "    );",
+    '    if (missingContext.length) throw new Error("missing required context: " + missingContext.join(", "));',
+    "",
+    "    const catalog = toolPayload(await tools[listToolName]({}), \"native-agent catalog\");",
+    '    if (catalog.orgId !== expectedTenantId) throw new Error("native-agent catalog tenant mismatch");',
+    '    if (!Array.isArray(catalog.agents)) throw new Error("native-agent catalog returned no agents");',
+    "    const matches = catalog.agents.filter((candidate) =>",
+    "      candidate?.agentId === expectedAgent.agentId && candidate?.scopeParam === expectedAgent.scopeParam",
+    "    );",
+    '    if (matches.length !== 1) throw new Error("exact native-agent binding is unavailable");',
+    "    const actualAgent = {};",
+    "    for (const key of Object.keys(expectedAgent)) actualAgent[key] = matches[0][key];",
+    "    if (JSON.stringify(stableValue(actualAgent)) !== JSON.stringify(stableValue(expectedAgent))) {",
+    '      throw new Error("native-agent catalog policy mismatch");',
+    "    }",
+    "",
+    "    const startArguments = {",
+    "      agentId: expectedAgent.agentId,",
+    "      scopeParam: expectedAgent.scopeParam,",
+    "      task: assignedTask,",
+    "      contextKeys: suppliedContextKeys,",
+    "      idempotencyKey,",
+    "    };",
+    "    if (suppliedContext !== null) startArguments.context = suppliedContext;",
+    '    if (expectedAgent.sideEffects === "writes") startArguments.confirmedSideEffects = true;',
+    "    latestRun = toolPayload(await tools[startToolName](startArguments), \"native-agent start\");",
+    '    if (typeof latestRun.runId !== "string" || !latestRun.runId) throw new Error("native-agent start returned no runId");',
+    "    runId = latestRun.runId;",
+    "",
+    "    for (;;) {",
+    "      const observed = toolPayload(",
+    "        await tools[readToolName]({ runId, waitSeconds }),",
+    '        "native-agent read",',
+    "      );",
+    '      if (observed.runId !== undefined && observed.runId !== runId) throw new Error("native-agent read returned a different runId");',
+    "      latestRun = observed;",
+    '      if (observed.status === "succeeded") {',
+    '        const finalText = observed.result?.finalText;',
+    '        if (typeof finalText !== "string") throw new Error("succeeded native-agent run returned no finalText");',
+    "        text(finalText);",
+    "        return;",
+    "      }",
+    '      if (observed.status === "failed") {',
+    "        text(JSON.stringify({",
+    "          runId,",
+    "          output: preservedOutput(observed),",
+    '          error: errorValue(observed.error, "native-agent run failed"),',
+    "        }));",
+    "        return;",
+    "      }",
+    "    }",
+    "  } catch (error) {",
+    "    text(JSON.stringify({",
+    "      runId,",
+    "      output: preservedOutput(latestRun),",
+    '      error: errorValue(error, "native-agent adapter failed"),',
+    "    }));",
+    "  }",
+    "}",
+    "",
+    "await orchestrate();",
+  ].join("\n");
+}
+
+function codexAdapterInstructions(tenantId, agent) {
+  const contextRequirement = agent.requiredContext.length
+    ? ` Required context keys are ${JSON.stringify(agent.requiredContext)}; if any are absent, ask for them before starting the run.`
+    : "";
+  const sideEffectInstruction = agent.sideEffects === "writes"
+    ? `The catalog declares that this agent writes user or workspace data. Use this adapter only when the user explicitly selected this exact agent for the current request; that explicit selection is the required side-effect confirmation. If the agent was chosen automatically or the selection is ambiguous, do not run the orchestration and ask the user to select this exact agent explicitly.`
+    : `The catalog declares that this agent is read-only; the orchestration omits confirmedSideEffects.`;
+  const source = renderCodexAdapterOrchestration(tenantId, agent);
+  return [
+    `You are a thin transport adapter for the exact Impel native agent ${JSON.stringify(agent.agentId)} in tenant ${JSON.stringify(tenantId)}.`,
+    `Callers must spawn this explicit custom Codex agent with fork_turns="none" and must relay your result verbatim; this is caller guidance and cannot enforce host spawn behavior.`,
+    `Do not perform the assigned task yourself, do not delegate to any other agent, and do not independently synthesize or rewrite the result.`,
+    `Confirm that the assigned request fits the cataloged capabilities ${JSON.stringify(agent.capabilities)} and none of the exclusions ${JSON.stringify(agent.exclusions)} before starting.${contextRequirement}`,
+    sideEffectInstruction,
+    `Invoke functions.exec exactly once for the orchestration below. Do not call the MCP tools directly or select a separate MCP call for any poll. Replace ${CODEX_TASK_PLACEHOLDER} with a JSON string literal for the complete assigned task. Replace ${CODEX_CONTEXT_PLACEHOLDER} with one JSON string literal containing all supplied caller context, or with null when no context was supplied; never use an object or array. Replace ${CODEX_CONTEXT_KEYS_PLACEHOLDER} with a JSON array naming the context fields present in that string, or [] when context is absent. Replace ${CODEX_IDEMPOTENCY_KEY_PLACEHOLDER} with one new opaque idempotency key for this logical invocation: choose it exactly once, reuse it unchanged for any retry of this invocation, and never reuse it for a separate request even when task and context are identical. Then pass the raw JavaScript without Markdown fences.`,
+    `The JavaScript validates the exact tenant, agent binding, and catalog policy; passes the one stable logical-invocation idempotencyKey; starts exactly once; and polls deterministically with the compatible 20-second server wait until status is succeeded or failed. If functions.exec yields a running cell, use functions.wait with max_tokens 30000 only to resume that same orchestration; never start another orchestration or poll the MCP tool yourself.`,
+    `After the orchestration completes, return its single text output verbatim with no preface, rewriting, Markdown changes, or independent synthesis. A successful output is result.finalText exactly. A failure output preserves the durable runId, output, and error.`,
+    "",
+    source,
+  ].join("\n\n");
+}
+
 function renderClaudeAgent({ tenantId, agent, name, invocation }) {
   const description = `Explicitly runs ${agent.title} for Impel tenant ${tenantId}${agent.sideEffects === "writes" ? " (may write user or workspace data)" : " (read-only)"}: ${agent.description}`.slice(0, 900);
   const lines = [
@@ -362,14 +527,14 @@ function renderClaudeAgent({ tenantId, agent, name, invocation }) {
     ...Object.entries(invocation.env || {}).map(([key, value]) => `        ${key}: ${JSON.stringify(value)}`),
     "---",
     "",
-    adapterInstructions(tenantId, agent),
+    claudeAdapterInstructions(tenantId, agent),
     "",
   ];
   return lines.join("\n");
 }
 
 function renderCodexAgent({ tenantId, agent, name, invocation }) {
-  const description = `Explicitly runs ${agent.title} for Impel tenant ${tenantId}${agent.sideEffects === "writes" ? " (may write user or workspace data)" : " (read-only)"}: ${agent.description}`.slice(0, 900);
+  const description = `Explicit custom agent: callers must use fork_turns="none" and relay its result verbatim. Runs ${agent.title} for Impel tenant ${tenantId}${agent.sideEffects === "writes" ? " (may write user or workspace data)" : " (read-only)"}: ${agent.description}`.slice(0, 900);
   const envEntries = Object.entries(invocation.env || {})
     .map(([key, value]) => `${JSON.stringify(key)} = ${JSON.stringify(value)}`)
     .join(", ");
@@ -377,7 +542,7 @@ function renderCodexAgent({ tenantId, agent, name, invocation }) {
     `name = ${JSON.stringify(name)}`,
     `description = ${JSON.stringify(description)}`,
     'sandbox_mode = "read-only"',
-    `developer_instructions = ${JSON.stringify(adapterInstructions(tenantId, agent))}`,
+    `developer_instructions = ${JSON.stringify(codexAdapterInstructions(tenantId, agent))}`,
     "",
     `[mcp_servers.${MANAGED_AGENT_MCP_SERVER}]`,
     `command = ${JSON.stringify(invocation.command)}`,
@@ -440,7 +605,7 @@ function readManifest(manifestPath) {
 
 function profileIsFresh(profile, tenantId, now, ttlMs) {
   const manifest = readManifest(path.join(profile.root, "agents", MANAGED_AGENT_DIRECTORY, MANAGED_AGENT_MANIFEST));
-  if (!manifest || manifest.version !== 3 || manifest.tenantId !== tenantId) return false;
+  if (!manifest || manifest.version !== MANAGED_AGENT_MANIFEST_VERSION || manifest.tenantId !== tenantId) return false;
   const syncedAt = Date.parse(manifest.syncedAt || "");
   if (!Number.isFinite(syncedAt) || now - syncedAt >= ttlMs) return false;
   return manifest.files.every((fileName) =>
@@ -463,7 +628,7 @@ export function syncAgentProfile({ client, root, label, tenantId, agents, now =
   const prior = readManifest(manifestPath);
   const rendered = renderManagedAgents(client, tenantId, agents);
   const priorFiles = new Set(prior?.files || []);
-  const priorUsesDiscoveryRoot = prior?.version === 2 || prior?.version === 3;
+  const priorUsesDiscoveryRoot = [2, 3, MANAGED_AGENT_MANIFEST_VERSION].includes(prior?.version);
 
   // Native clients discover standalone definitions directly under `agents/`.
   // Preflight every destination before writing so an unmanaged file with the
@@ -505,7 +670,7 @@ export function syncAgentProfile({ client, root, label, tenantId, agents, now =
     }
   }
   atomicPrivateWrite(manifestPath, `${JSON.stringify({
-    version: 3,
+    version: MANAGED_AGENT_MANIFEST_VERSION,
     tenantId,
     client,
     syncedAt: new Date(now).toISOString(),

package/src/apps.js

@@ -98,9 +98,11 @@ export const PINNED_VENDOR_APPS = Object.freeze({
     windows: Object.freeze({
       storeProductId: "9PLM9XGG6VKS",
       packageName: "OpenAI.Codex",
-      packageVersion: "26.721.11231.0",
-      advertisedPackageVersion: "26.727.4816.0",
-      codexVersion: "0.146.0-alpha.3.1",
+      // The Microsoft Store manifest identifies this exact reviewed build.
+      // Keep one Windows package version so the manifest contract and local
+      // AppX validation cannot silently drift apart again.
+      packageVersion: "26.727.6591.0",
+      codexVersion: "0.146.0-alpha.9.2",
       publisherId: "2p2nqsd0c76g0",
       executable: "app\\ChatGPT.exe",
       updateManifestUrl: "https://persistent.oaistatic.com/codex-app-prod/windows-store-update.json",

package/src/windowsApps.js

@@ -411,8 +411,9 @@ export function ensureWindowsChatGPTApp({ update = false } = {}, dependencies =
     return { binary: pinnedBefore, action: "existing", result: null };
   }
 
-  // `impel update` also repairs missing surfaces. A missing Store package must
-  // be installed, not sent to `winget upgrade` (which returns 0x8A150014).
+  // `impel update` converges an older official Store package to the current
+  // reviewed pin. A missing Store package must be installed, not sent to
+  // `winget upgrade` (which returns 0x8A150014).
   const shouldUpdate = Boolean(update && before);
   // The msstore source rejects its AppX package version as a winget --version
   // selector. Install the current Store package, then fail closed below unless