impel-cli 0.20.0-beta.0 → 0.20.1

package/package.json

@@ -1,9 +1,8 @@
 {
   "name": "impel-cli",
-  "version": "0.20.0-beta.0",
+  "version": "0.20.1",
   "description": "Prepare isolated Claude and Codex workspaces for every accessible Impel tenant",
   "type": "module",
-  "packageManager": "pnpm@11.17.0",
   "bin": {
     "impel": "bin/impel.js"
   },
@@ -20,9 +19,6 @@
   "engines": {
     "node": ">=18.0.0"
   },
-  "scripts": {
-    "test": "node --test"
-  },
   "license": "UNLICENSED",
   "publishConfig": {
     "access": "public",
@@ -31,5 +27,8 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/UseImpel/impel-cli.git"
+  },
+  "scripts": {
+    "test": "node --test"
   }
-}
+}

package/src/agents.js

@@ -10,24 +10,8 @@ import os from "node:os";
 import path from "node:path";
 
 import { normalizeGatewayUrl, redactSecretText } from "./config.js";
-import {
-  adapterAnswerHardCompletionGuidance,
-  adapterAnswerSoftCompletionGuidance,
-  claudeAnswerHardCompletionGuidance,
-  claudeAnswerSoftCompletionGuidance,
-  usesDirectAnswer,
-} from "./directAnswer.js";
 import { impelMcpInvocation } from "./selfInvocation.js";
 import { normalizeTenantId } from "./tenants.js";
-import {
-  adapterCallerSpawnGuidance,
-  adapterHardCompletionGuidance,
-  adapterSoftCompletionGuidance,
-  claudeHardCompletionGuidance,
-  claudeSoftCompletionGuidance,
-  customAgentVerbatimDescriptionLead,
-  usesVerbatimRelay,
-} from "./verbatimRelay.js";
 import { renameWithWindowsRetry } from "./windowsFs.js";
 
 export const AGENT_SYNC_TTL_MS = 6 * 60 * 60 * 1000;
@@ -36,22 +20,14 @@ export const MANAGED_AGENT_MANIFEST = ".manifest.json";
 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 NATIVE_AGENT_ANSWER_TOOL = "impel_specialists-answer_native_agent";
 export const MANAGED_AGENT_MCP_SERVER = "impel_agent";
-export const MANAGED_AGENT_MANIFEST_VERSION = 6;
+export const MANAGED_AGENT_MANIFEST_VERSION = 4;
 
-const NATIVE_AGENT_SESSION_TOOL_NAMES = [
+const NATIVE_AGENT_TOOL_NAMES = [
   NATIVE_AGENT_LIST_TOOL,
   NATIVE_AGENT_START_TOOL,
   NATIVE_AGENT_READ_TOOL,
 ];
-
-function nativeAgentToolNames(agent) {
-  return usesDirectAnswer(agent)
-    ? [NATIVE_AGENT_ANSWER_TOOL]
-    : NATIVE_AGENT_SESSION_TOOL_NAMES;
-}
-
 const SAFE_AGENT_ID_RE = /^[A-Za-z0-9_.:-]{1,160}$/u;
 const SAFE_SCOPE_PARAM_RE = /^[A-Za-z0-9_.:-]{1,160}$/u;
 const MAX_CATALOG_ITEMS = 500;
@@ -149,12 +125,6 @@ export function normalizeNativeAgentCatalog(payload, expectedTenantId) {
       throw new Error(`native-agent catalog returned duplicate binding ${binding}`);
     }
     seenBindings.add(binding);
-    if (agent.verbatimRelay !== undefined && typeof agent.verbatimRelay !== "boolean") {
-      throw new Error("native-agent catalog returned an invalid verbatimRelay");
-    }
-    if (agent.directAnswer !== undefined && typeof agent.directAnswer !== "boolean") {
-      throw new Error("native-agent catalog returned an invalid directAnswer");
-    }
     return {
       agentId,
       title: boundedString(agent.title, "title", { max: 160 }),
@@ -165,8 +135,6 @@ export function normalizeNativeAgentCatalog(payload, expectedTenantId) {
       exclusions: stringList(agent.exclusions, "exclusions"),
       requiredContext: stringList(agent.requiredContext, "requiredContext"),
       sideEffects: enumString(agent.sideEffects, "sideEffects", ["read-only", "writes"]),
-      ...(agent.verbatimRelay === true ? { verbatimRelay: true } : {}),
-      ...(agent.directAnswer === true ? { directAnswer: true } : {}),
     };
   });
   return { orgId: tenantId, agents };
@@ -361,35 +329,14 @@ function claudeAdapterInstructions(tenantId, agent) {
   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, so pass confirmedSideEffects true. If the agent was chosen automatically or the selection is ambiguous, do not start it and ask the user to select it explicitly.`
     : `The catalog declares that this agent is read-only; omit confirmedSideEffects.`;
-  const callerSpawnGuidance = usesVerbatimRelay(agent)
-    ? adapterCallerSpawnGuidance("Claude")
-    : null;
-  if (usesDirectAnswer(agent)) {
-    const completionGuidance = usesVerbatimRelay(agent)
-      ? claudeAnswerHardCompletionGuidance()
-      : claudeAnswerSoftCompletionGuidance();
-    return [
-      `You are a thin transport adapter for the exact Impel native agent ${JSON.stringify(agent.agentId)} in tenant ${JSON.stringify(tenantId)}.`,
-      ...(callerSpawnGuidance ? [callerSpawnGuidance] : []),
-      `Do not perform the assigned task yourself, do not delegate to any other agent, and do not call Impel start_native_agent_run or read_native_agent_run.`,
-      `Confirm that the assigned request fits the cataloged capabilities ${JSON.stringify(agent.capabilities)} and none of the exclusions ${JSON.stringify(agent.exclusions)} before answering.${contextRequirement}`,
-      sideEffectInstruction,
-      `Call ${toolName(NATIVE_AGENT_ANSWER_TOOL)} exactly once with agentId ${JSON.stringify(agent.agentId)}, scopeParam ${JSON.stringify(agent.scopeParam)}, question 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, and confirmedSideEffects as directed above.`,
-      completionGuidance,
-    ].join(" ");
-  }
-  const completionGuidance = usesVerbatimRelay(agent)
-    ? claudeHardCompletionGuidance()
-    : claudeSoftCompletionGuidance();
   return [
     `You are a thin transport adapter for the exact Impel native agent ${JSON.stringify(agent.agentId)} in tenant ${JSON.stringify(tenantId)}.`,
-    ...(callerSpawnGuidance ? [callerSpawnGuidance] : []),
     `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, 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.`,
-    completionGuidance,
+    `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(" ");
 }
 
@@ -402,96 +349,7 @@ 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__";
 
-function renderCodexDirectAnswerOrchestration(tenantId, agent) {
-  const expectedTenantId = normalizeTenantId(tenantId);
-  const nestedToolName = (toolName) => nativeToolName(toolName).replaceAll("-", "_");
-  const answerTool = nestedToolName(NATIVE_AGENT_ANSWER_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 answerToolName = ${JSON.stringify(answerTool)};`,
-    "",
-    "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 extractAnswerFinalText(payload) {",
-    '  if (!payload || typeof payload !== "object" || Array.isArray(payload)) return null;',
-    '  for (const key of ["forUser", "answer"]) {',
-    "    const value = payload[key];",
-    '    if (typeof value === "string" && value.trim()) return value;',
-    "  }",
-    "  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() {",
-    "  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");',
-    "    const missingContext = expectedAgent.requiredContext.filter((key) =>",
-    "      !suppliedContextKeys.includes(key)",
-    "    );",
-    '    if (missingContext.length) throw new Error("missing required context: " + missingContext.join(", "));',
-    "",
-    "    const answerArguments = {",
-    "      agentId: expectedAgent.agentId,",
-    "      scopeParam: expectedAgent.scopeParam,",
-    "      question: assignedTask,",
-    "      contextKeys: suppliedContextKeys,",
-    "    };",
-    "    if (suppliedContext !== null) answerArguments.context = suppliedContext;",
-    '    if (expectedAgent.sideEffects === "writes") answerArguments.confirmedSideEffects = true;',
-    "    const answered = toolPayload(await tools[answerToolName](answerArguments), \"native-agent answer\");",
-    "    const finalText = extractAnswerFinalText(answered);",
-    '    if (typeof finalText !== "string") throw new Error("native-agent answer returned no forUser/answer");',
-    "    text(finalText);",
-    "  } catch (error) {",
-    "    text(JSON.stringify({",
-    '      error: errorValue(error, "native-agent answer adapter failed"),',
-    "      tenantId: expectedTenantId,",
-    "      agentId: expectedAgent.agentId,",
-    "    }));",
-    "  }",
-    "}",
-    "",
-    "await orchestrate();",
-  ].join("\n");
-}
-
 export function renderCodexAdapterOrchestration(tenantId, agent) {
-  if (usesDirectAnswer(agent)) {
-    return renderCodexDirectAnswerOrchestration(tenantId, agent);
-  }
   const expectedTenantId = normalizeTenantId(tenantId);
   const nestedToolName = (toolName) => nativeToolName(toolName).replaceAll("-", "_");
   const listTool = nestedToolName(NATIVE_AGENT_LIST_TOOL);
@@ -636,61 +494,29 @@ function codexAdapterInstructions(tenantId, agent) {
     ? `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);
-  const callerSpawnGuidance = usesVerbatimRelay(agent)
-    ? adapterCallerSpawnGuidance("Codex")
-    : null;
-  if (usesDirectAnswer(agent)) {
-    const completionGuidance = usesVerbatimRelay(agent)
-      ? adapterAnswerHardCompletionGuidance()
-      : adapterAnswerSoftCompletionGuidance();
-    return [
-      `You are a thin transport adapter for the exact Impel native agent ${JSON.stringify(agent.agentId)} in tenant ${JSON.stringify(tenantId)}.`,
-      ...(callerSpawnGuidance ? [callerSpawnGuidance] : []),
-      `Do not perform the assigned task yourself, do not delegate to any other agent, do not independently synthesize or rewrite the result, and do not call Impel start_native_agent_run or read_native_agent_run.`,
-      `Confirm that the assigned request fits the cataloged capabilities ${JSON.stringify(agent.capabilities)} and none of the exclusions ${JSON.stringify(agent.exclusions)} before answering.${contextRequirement}`,
-      sideEffectInstruction,
-      `Invoke functions.exec exactly once for the orchestration below. Do not call the MCP tools directly. 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 (unused by the answer tool but kept for adapter parity): choose it exactly once. Then pass the raw JavaScript without Markdown fences.`,
-      `The JavaScript validates required context and calls Impel answer_native_agent exactly once, returning forUser (else answer). 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 open an Impel/Eve session.`,
-      completionGuidance,
-      "",
-      source,
-    ].join("\n\n");
-  }
-  const completionGuidance = usesVerbatimRelay(agent)
-    ? adapterHardCompletionGuidance()
-    : adapterSoftCompletionGuidance();
   return [
     `You are a thin transport adapter for the exact Impel native agent ${JSON.stringify(agent.agentId)} in tenant ${JSON.stringify(tenantId)}.`,
-    ...(callerSpawnGuidance ? [callerSpawnGuidance] : []),
+    `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.`,
-    completionGuidance,
+    `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 customAgentDescription(tenantId, agent) {
-  const sideEffectsLabel = agent.sideEffects === "writes" ? " (may write user or workspace data)" : " (read-only)";
-  return (usesVerbatimRelay(agent)
-    ? `${customAgentVerbatimDescriptionLead()}. Runs ${agent.title} for Impel tenant ${tenantId}${sideEffectsLabel}: ${agent.description}`
-    : `Explicitly runs ${agent.title} for Impel tenant ${tenantId}${sideEffectsLabel}: ${agent.description}`
-  ).slice(0, 900);
-}
-
 function renderClaudeAgent({ tenantId, agent, name, invocation }) {
-  const description = customAgentDescription(tenantId, agent);
-  const toolNames = nativeAgentToolNames(agent);
+  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 = [
     "---",
     `name: ${JSON.stringify(name)}`,
     `description: ${JSON.stringify(description)}`,
     "model: inherit",
     "tools:",
-    ...toolNames.map((tool) => `  - ${JSON.stringify(nativeToolName(tool))}`),
+    ...NATIVE_AGENT_TOOL_NAMES.map((tool) => `  - ${JSON.stringify(nativeToolName(tool))}`),
     "mcpServers:",
     `  - ${MANAGED_AGENT_MCP_SERVER}:`,
     "      type: stdio",
@@ -708,8 +534,7 @@ function renderClaudeAgent({ tenantId, agent, name, invocation }) {
 }
 
 function renderCodexAgent({ tenantId, agent, name, invocation }) {
-  const description = customAgentDescription(tenantId, agent);
-  const toolNames = nativeAgentToolNames(agent);
+  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(", ");
@@ -722,11 +547,11 @@ function renderCodexAgent({ tenantId, agent, name, invocation }) {
     `[mcp_servers.${MANAGED_AGENT_MCP_SERVER}]`,
     `command = ${JSON.stringify(invocation.command)}`,
     `args = [${invocation.args.map((argument) => JSON.stringify(argument)).join(", ")}]`,
-    `enabled_tools = [${toolNames.map((tool) => JSON.stringify(tool)).join(", ")}]`,
+    `enabled_tools = [${NATIVE_AGENT_TOOL_NAMES.map((tool) => JSON.stringify(tool)).join(", ")}]`,
     ...(envEntries ? [`env = { ${envEntries} }`] : []),
     "",
   ];
-  for (const tool of toolNames) {
+  for (const tool of NATIVE_AGENT_TOOL_NAMES) {
     lines.push(`[mcp_servers.${MANAGED_AGENT_MCP_SERVER}.tools.${JSON.stringify(tool)}]`, 'approval_mode = "approve"', "");
   }
   return lines.join("\n");
@@ -803,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 = [2, 3, 4, 5, MANAGED_AGENT_MANIFEST_VERSION].includes(prior?.version);
+  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

package/src/apps.js

@@ -22,7 +22,6 @@ import { ensureClaudeSessionHooks, ensureCodexSessionHooks } from "./sessionHook
 import { ADHOC_IDENTITY, codesignIdentityArgs, desiredSigningMode, resolveSigningIdentity } from "./codesign.js";
 import { applyImpelClaudeSandbox } from "./claudeSandbox.js";
 import { brandedEnvironmentName, RUNTIME_BRAND } from "./runtimeBrand.js";
-import { IMPEL_CODEX_PARENT_DELEGATION_INSTRUCTIONS } from "./commands/launch.js";
 
 export const CLAUDE_CONFIG_ID = "1ced0000-0000-4000-8000-000000000001";
 const CHATGPT_CONFIG_START = `# >>> ${RUNTIME_BRAND.cli.command} app managed gateway >>>`;
@@ -275,9 +274,7 @@ export function managedAppIdentity(target, tenantId = null, tenantName = null) {
 // unsupported-selection "Reset to default" treatment.
 // 27: register the separate tenant-bound Tasks MCP server in managed Claude
 // and ChatGPT/Codex profiles without changing the specialist MCP server.
-// 28: add managed ChatGPT parent delegation instructions, including custom-agent
-// verbatim relay opt-in and directAnswer one-shot MCP answer routing.
-export const CURRENT_CONFIG_VERSION = 28;
+export const CURRENT_CONFIG_VERSION = 27;
 
 // Identifies the bundle-BUILDING logic — the asar patches, plist rewrites,
 // helper rebranding, and signing. A vendored bundle is rebuilt only when this
@@ -1348,9 +1345,6 @@ function writeChatGPTConfig(
     `model_catalog_json = ${tomlString(paths.chatgpt.catalog)}`,
     ...(selectedEffort ? [`model_reasoning_effort = ${tomlString(selectedEffort)}`] : []),
     ...(selectedTier ? [`service_tier = ${tomlString(selectedTier)}`] : []),
-    ...(RUNTIME_BRAND.features.agents
-      ? [`developer_instructions = ${tomlString(IMPEL_CODEX_PARENT_DELEGATION_INSTRUCTIONS)}`]
-      : []),
     "",
     // The built-in ChatGPT provider derives its inference endpoint from
     // chatgpt.com even when chatgpt_base_url points at the gateway. Keep the

package/src/commands/launch.js

@@ -14,7 +14,6 @@ import {
   resolveDefaultGateway,
   saveConfig,
 } from "../config.js";
-import { parentVerbatimRelayAppendix } from "../verbatimRelay.js";
 import { impelClaudeBaseUrl, impelCrossAppClaudeBaseUrl } from "../claudeSetup.js";
 import { withGitEnvironment } from "../skills.js";
 import { assertProviderScopes, ensureTenantSelection, tenantCredential } from "../tenants.js";
@@ -50,18 +49,10 @@ export {
 
 export const IMPEL_SPECIALIST_DELEGATION_INSTRUCTIONS = `You are running in an Impel tenant-scoped session. Before starting any non-trivial task, call the Impel MCP tool list_specialists. If exactly one available specialist clearly matches the user's request, its capabilities and its exclusions, delegate the complete request by calling start_specialist_run exactly once with a stable idempotency key, then call read_specialist_run until it reaches a terminal state. When the run succeeds, use the specialist's result as your response instead of redoing the work. If no specialist clearly matches, the tools are unavailable, or the run fails, continue normally yourself. Do not delegate trivial requests, do not call a specialist excluded from the request, and never invent a specialist result.`;
 
-export const IMPEL_CUSTOM_AGENT_VERBATIM_RELAY_APPENDIX = parentVerbatimRelayAppendix();
-
-export const IMPEL_CLAUDE_PARENT_DELEGATION_INSTRUCTIONS =
-  `${IMPEL_SPECIALIST_DELEGATION_INSTRUCTIONS} ${IMPEL_CUSTOM_AGENT_VERBATIM_RELAY_APPENDIX}`;
-
 export const IMPEL_CODEX_SPECIALIST_DELEGATION_INSTRUCTIONS =
   `${IMPEL_SPECIALIST_DELEGATION_INSTRUCTIONS} ` +
   `Codex can defer MCP tools behind tool_search. If an Impel specialist tool is not directly visible, call tool_search for its exact name before treating it as unavailable: impel_specialists-list_specialists for discovery, impel_specialists-start_specialist_run to delegate, and impel_specialists-read_specialist_run to poll the result. Use the returned tool for the same one-run delegation flow.`;
 
-export const IMPEL_CODEX_PARENT_DELEGATION_INSTRUCTIONS =
-  `${IMPEL_CODEX_SPECIALIST_DELEGATION_INSTRUCTIONS} ${IMPEL_CUSTOM_AGENT_VERBATIM_RELAY_APPENDIX}`;
-
 const IMPEL_CODEX_RUNTIME_OVERRIDES = [
   // Codex models may select code mode even when the standalone
   // `codex-code-mode-host` companion is not present in the vendor install.
@@ -73,14 +64,14 @@ const IMPEL_CODEX_RUNTIME_OVERRIDES = [
 export function impelLaunchArguments(tool, argv) {
   if (!RUNTIME_BRAND.features.agents) return [...argv];
   if (tool === "claude") {
-    return ["--append-system-prompt", IMPEL_CLAUDE_PARENT_DELEGATION_INSTRUCTIONS, ...argv];
+    return ["--append-system-prompt", IMPEL_SPECIALIST_DELEGATION_INSTRUCTIONS, ...argv];
   }
   if (tool === "codex") {
     // `-c` is a Codex global option, so it must precede subcommands such as
     // `exec`, `resume`, and `mcp`. JSON strings are valid TOML basic strings.
     return [
       "-c",
-      `developer_instructions=${JSON.stringify(IMPEL_CODEX_PARENT_DELEGATION_INSTRUCTIONS)}`,
+      `developer_instructions=${JSON.stringify(IMPEL_CODEX_SPECIALIST_DELEGATION_INSTRUCTIONS)}`,
       ...IMPEL_CODEX_RUNTIME_OVERRIDES.flatMap((override) => ["-c", override]),
       ...argv,
     ];

package/src/selfInvocation.js

@@ -91,7 +91,11 @@ export function impelTasksMcpInvocation(tenantId, options = {}) {
 export function isImpelTasksMcpInvocation(value) {
   if (!value || typeof value !== "object" || !Array.isArray(value.args)) return false;
   const suffix = value.args.slice(-5);
-  return value.type === "stdio"
+  // Claude Desktop persists stdio servers without the optional `type` field.
+  // Accept that vendor-normalized form so the next Impel update can still
+  // recognize, re-pin, and repair its own tenant-bound entry. Any explicit
+  // non-stdio type remains foreign and fails closed.
+  return (value.type === undefined || value.type === "stdio")
     && value.env?.[IMPEL_MANAGED_MCP_ENV] === "1"
     && suffix[0] === "mcp"
     && suffix[1] === "--target"

package/src/directAnswer.js

@@ -1,59 +0,0 @@
-/**
- * Catalog opt-in for Impel MCP `answer_native_agent`.
- *
- * When `directAnswer` is true, managed Claude/Codex adapters call that one-shot
- * tool (Impel auth → Eve `/eve/v1/answer`) and return forUser/answer instead of
- * list → start → poll. Distinct from agent-internal retrieve shortcuts.
- *
- * Does not replace the verbatimRelay description / fork_turns override: when an
- * agent also sets verbatimRelay, keep that marker and spawn guidance so parents
- * still use fork_turns="none" and relay the adapter result verbatim.
- */
-
-import {
-  VERBATIM_FINAL_TEXT_CONSTRAINTS,
-} from "./verbatimRelay.js";
-
-export function usesDirectAnswer(agent) {
-  return agent?.directAnswer === true;
-}
-
-export function extractAnswerFinalText(payload) {
-  if (!payload || typeof payload !== "object" || Array.isArray(payload)) return null;
-  for (const key of ["forUser", "answer"]) {
-    const text = payload[key];
-    if (typeof text === "string" && text.trim()) return text;
-  }
-  return null;
-}
-
-export function claudeAnswerHardCompletionGuidance() {
-  return (
-    `When it succeeds, return forUser if present, otherwise answer, exactly with ${VERBATIM_FINAL_TEXT_CONSTRAINTS}. ` +
-    "When it fails, return the tool error without inventing a replacement result. " +
-    "Never invent or independently synthesize a replacement result."
-  );
-}
-
-export function claudeAnswerSoftCompletionGuidance() {
-  return (
-    "When it succeeds, return forUser if present, otherwise answer, faithfully as the answer. " +
-    "When it fails, return the tool error without inventing a replacement result. " +
-    "Never invent or independently synthesize a replacement result."
-  );
-}
-
-export function adapterAnswerHardCompletionGuidance() {
-  return (
-    `After the orchestration completes, return its single text output verbatim with ${VERBATIM_FINAL_TEXT_CONSTRAINTS}. ` +
-    "A successful output is forUser (else answer) exactly. A failure output preserves the error payload."
-  );
-}
-
-export function adapterAnswerSoftCompletionGuidance() {
-  return (
-    "After the orchestration completes, return its single text output as the answer. " +
-    "A successful output is forUser (else answer). A failure output preserves the error payload. " +
-    "Never invent or independently synthesize a replacement result."
-  );
-}

package/src/verbatimRelay.js

@@ -1,64 +0,0 @@
-export const VERBATIM_RELAY_OPT_IN_MARKER = "verbatimRelay enabled";
-
-export const VERBATIM_SPAWN_REQUIREMENT = 'fork_turns="none"';
-
-export const VERBATIM_FINAL_TEXT_CONSTRAINTS =
-  "no preface, rewriting, Markdown changes, or independent synthesis";
-
-export function usesVerbatimRelay(agent) {
-  return agent?.verbatimRelay === true;
-}
-
-export function parentVerbatimRelayAppendix() {
-  return (
-    `When an explicit custom agent's catalog-derived description declares ${VERBATIM_RELAY_OPT_IN_MARKER}, ` +
-    `spawn it with ${VERBATIM_SPAWN_REQUIREMENT} and relay its finalText verbatim with ${VERBATIM_FINAL_TEXT_CONSTRAINTS}; ` +
-    "preserve Sources sections and citations exactly. " +
-    "Custom agents without that declaration keep the default delegation behavior."
-  );
-}
-
-export function customAgentVerbatimDescriptionLead() {
-  return (
-    `Explicit custom agent with ${VERBATIM_RELAY_OPT_IN_MARKER}: ` +
-    `callers must use ${VERBATIM_SPAWN_REQUIREMENT} and relay its result verbatim`
-  );
-}
-
-export function adapterCallerSpawnGuidance(clientLabel) {
-  return (
-    `Callers must spawn this explicit custom ${clientLabel} agent with ${VERBATIM_SPAWN_REQUIREMENT} ` +
-    "and must relay your result verbatim; this is caller guidance and cannot enforce host spawn behavior."
-  );
-}
-
-export function adapterHardCompletionGuidance() {
-  return (
-    `After the orchestration completes, return its single text output verbatim with ${VERBATIM_FINAL_TEXT_CONSTRAINTS}. ` +
-    "A successful output is result.finalText exactly. A failure output preserves the durable runId, output, and error."
-  );
-}
-
-export function adapterSoftCompletionGuidance() {
-  return (
-    "After the orchestration completes, return its single text output as the answer. " +
-    "A successful output is result.finalText. A failure output preserves the durable runId, output, and error. " +
-    "Never invent or independently synthesize a replacement result."
-  );
-}
-
-export function claudeHardCompletionGuidance() {
-  return (
-    `When it succeeds, return result.finalText exactly with ${VERBATIM_FINAL_TEXT_CONSTRAINTS}. ` +
-    "When it fails, return the durable runId, preserved output, and error. " +
-    "Never invent or independently synthesize a replacement result."
-  );
-}
-
-export function claudeSoftCompletionGuidance() {
-  return (
-    "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."
-  );
-}