totemlayer 0.1.77 → 0.1.88

package/README.md

@@ -6,7 +6,7 @@ Wavelength keeps requests, replies, files, and work updates in persistent conver
 
 Start with the [two-agent quickstart](https://totemlayer.com/docs/quickstart) and [collaboration examples](https://totemlayer.com/docs/examples). Messages can wait in an offline agent’s inbox; processing and replies require a running, supported host. Protected actions require separate permission.
 
-Version 0.1.77 updates the package description, search keywords, and this introduction. Its executable files are unchanged from 0.1.76.
+The 0.1.78 source candidate includes receiver startup repairs and the restricted Claude endpoint. It has not been published. Consumer setup instructions remain pinned to the tested 0.1.76 release until a new release is published and verified.
 
 ## Automatic MCP connection
 

package/bin/agent-runner.mjs

@@ -672,22 +672,38 @@ export async function agentStartMain(args, options = {}) {
   const environment = options.env ?? process.env;
   const output = options.stdout ?? process.stdout;
   const parsed = runnerOptions(args);
+  const automatic = options.automatic === true || Boolean(parsed["run-id"]);
   if (parsed.help) {
     output.write(AGENT_START_HELP);
     return 0;
   }
-  const profile = await readAgentProfile(parsed.profile, { environment });
+  let profile = await readAgentProfile(parsed.profile, { environment });
   assertExecutorConfigured(profile);
   if (
     profile.interactiveRequired &&
     (!profile.codexThreadId ||
       !(await (await import("./harness-bootstrap.mjs")).harnessStartupReady(profile)))
-  )
+  ) {
+    if (!automatic && profile.codexThreadId) {
+      // Explicit start can finish this selected binding; passive recovery cannot unpause it.
+      const { setAutomaticEnabled } = await import("./automatic-runtime.mjs");
+      const { ensureInteractiveHarness } = await import("./harness-bootstrap.mjs");
+      await setAutomaticEnabled(profile, true);
+      profile = await (options.ensureHarness ?? ensureInteractiveHarness)(profile, environment);
+      const activate =
+        options.activateConnection ?? (await import("./installation.mjs")).activateConnection;
+      const status = await activate(profile, environment);
+      output.write(
+        `${parsed.json ? JSON.stringify(status) : (status.message ?? status.recovery ?? `Listener state: ${status.state ?? "needs_attention"}`)}\n`,
+      );
+      return status.ready && status.persistent && status.running ? 0 : 1;
+    }
     throw Object.assign(
       new Error("This listener is waiting for its owner-bound interactive harness."),
       { code: "HARNESS_SETUP_REQUIRED" },
     );
-  if (!options.automatic) {
+  }
+  if (!automatic) {
     const { setAutomaticEnabled } = await import("./automatic-runtime.mjs");
     await setAutomaticEnabled(profile, true);
   }

package/bin/claude-directory-profile.mjs

@@ -0,0 +1,222 @@
+// An explicit endpoint profile, applied equally to every client and reviewer.
+export const CLAUDE_DIRECTORY_INSTRUCTIONS =
+  "Totem provides authenticated access to operational messages, owner chats, tasks, repositories, and Missions for the selected agent. This endpoint excludes aggregate profile memory and profile creation. It does not query Claude's native memory, conversation history, summaries, or uploaded-file systems. Its operations do not automatically add operational text to aggregate profile memory. Totem records contain operational content supplied to its services. Existing owner authorization, connection rules, execution leases, and action approval checks apply to every operation. A persisted record does not establish completed external execution.";
+
+// New tools remain unavailable here until their operational scope is reviewed.
+export const CLAUDE_DIRECTORY_TOOLS = Object.freeze({
+  totem_get_identity:
+    "Returns the selected agent's identity and operational connection status without aggregate profile memory or personalization.",
+  totem_list_chat_commands:
+    "Lists queued Totem website chat requests for the authenticated agent, including requests with expired leases.",
+  totem_get_chat: "Reads an authorized Totem website chat and its paginated operational messages.",
+  totem_claim_chat_command:
+    "Claims one queued Totem website chat request and returns its execution lease.",
+  totem_renew_chat_command:
+    "Renews the current credential's existing lease on a Totem website chat request.",
+  totem_complete_chat_command:
+    "Publishes a reply in the original Totem website chat and completes its leased request with idempotency protection.",
+  totem_fail_chat_command:
+    "Records a failure in the original Totem website chat for the current credential's leased request.",
+  totem_start_listener:
+    "Resumes this agent's paused MCP listener and returns connection readiness state. This does not install a host process or grant action authority.",
+  totem_listen:
+    "Waits for authorized Totem activity and messages while renewing the existing manual listener lease.",
+  totem_stop_listener:
+    "Pauses this agent's listener while preserving a supervised runtime owned by another provider.",
+  totem_get_activity:
+    "Reads authorized Totem activity, approval decisions, operational messages, and pagination cursors.",
+  totem_wait_for_activity:
+    "Waits for new authorized Totem activity or operational messages after the supplied cursors.",
+  totem_list_missions:
+    "Lists the authenticated agent's accessible Missions and recorded participation state.",
+  totem_get_mission:
+    "Reads an accessible Totem Mission, its team, dependencies, work items, artifacts, and execution receipts.",
+  totem_delegate_mission_task:
+    "Assigns a child work item to a consented member of a Mission coordinated by this agent, subject to existing infrastructure review dependencies.",
+  totem_claim_mission_work:
+    "Claims an available Mission work item assigned to this agent and returns its execution lease.",
+  totem_renew_mission_work: "Renews this agent's existing lease on a Mission work item.",
+  totem_complete_mission_work:
+    "Records an outcome and artifacts for this agent's leased Mission work item with idempotency protection.",
+  totem_get_repo_coordination:
+    "Reads a shared coding task's recorded repository, base commit, branches, and file claims.",
+  totem_list_github_repositories:
+    "Lists GitHub repositories assigned by this credential's owner to this agent without returning access tokens.",
+  totem_open_github_pull_request:
+    "Opens a GitHub pull request from this agent's already pushed and submitted branch after repository, commit, and scope checks. Target API: https://docs.github.com/en/rest/pulls/pulls#create-a-pull-request.",
+  totem_claim_repo_scope:
+    "Reserves this agent's branch and repository-relative file scope for a shared task, rejecting overlapping active claims.",
+  totem_set_repo_claim_state:
+    "Updates this agent's existing repository claim using its recorded version.",
+  totem_submit_repo_work:
+    "Records a full commit reference and optional pull request URL for a shared coding task. Hosted commit references are self-reported.",
+  totem_find_agents:
+    "Searches addressable Totem agents by directory filters and returns their public operational profiles.",
+  totem_list_messages:
+    "Lists authorized durable Totem messages with direction, unread, and pagination filters.",
+  totem_wait_for_message:
+    "Waits for new authorized messages after a known sequence in one Totem conversation or task.",
+  totem_get_message: "Reads one durable Totem message visible to the authenticated agent.",
+  totem_upload_attachment:
+    "Uploads one operational message attachment of at most 2 MiB under this agent's identity.",
+  totem_get_attachment: "Downloads one image or file attached to an authorized Totem message.",
+  totem_request_action:
+    "Creates an exact protected-action request under the receiving owner's connection and permission rules. Creating the request grants no execution authority.",
+  totem_list_actions:
+    "Lists protected-action requests visible to this agent with their recorded approval and execution state.",
+  totem_get_action:
+    "Reads one protected-action request and its current approval and execution state.",
+  totem_dispatch_action:
+    "Consumes one exact owner-approved protected-action grant and returns its checked execution parameters. This operation does not execute an external action.",
+  totem_report_action_outcome:
+    "Records the observed outcome of an existing protected-action execution.",
+  totem_cancel_action: "Cancels an eligible protected-action request created by this agent.",
+  totem_request_tool_setup:
+    "Creates a protected request for a specified peer tool or session setup under the receiving owner's permissions. This does not install or enable software.",
+  totem_send_message:
+    "Persists a message from this authenticated agent to an exact Totem address with idempotency protection.",
+  totem_reply_to_message:
+    "Persists a reply to one authorized inbound Totem message while retaining its conversation linkage.",
+  totem_acknowledge_message:
+    "Marks one inbound Totem message as handled by this authenticated agent.",
+  totem_get_conversation:
+    "Reads an authorized Totem conversation and its paginated durable operational messages.",
+  totem_collaborate:
+    "Creates one shared coding task for an exact peer address and records its repository coordination plan.",
+  totem_create_task:
+    "Creates a durable task for another Totem agent without granting external-action authority.",
+  totem_list_tasks: "Lists durable tasks assigned to or requested by the authenticated agent.",
+  totem_get_task: "Reads an authorized Totem task, its recorded state, artifacts, and events.",
+  totem_update_task: "Updates an assigned task's state using its expected version.",
+  totem_post_task_update:
+    "Persists an operational update in an authorized shared task conversation.",
+  totem_cancel_task: "Cancels an eligible durable task created by this authenticated agent.",
+});
+
+const pick = (value, fields) =>
+  Object.fromEntries(
+    fields.filter((field) => value?.[field] !== undefined).map((field) => [field, value[field]]),
+  );
+const runtimeFields = [
+  "state",
+  "scope",
+  "configured",
+  "connectionState",
+  "connected",
+  "ready",
+  "listenerReady",
+];
+
+export function claudeDirectoryIdentity(agent) {
+  return {
+    ...pick(agent, [
+      "id",
+      "address",
+      "name",
+      "environment",
+      "status",
+      "verified",
+      "actionMode",
+      "actionModeVersion",
+    ]),
+    ...(agent.organization
+      ? { organization: pick(agent.organization, ["id", "name", "kind"]) }
+      : {}),
+    ...(agent.runtime
+      ? {
+          runtime: {
+            ...pick(agent.runtime, runtimeFields),
+            ...(agent.runtime.currentConnection
+              ? { currentConnection: pick(agent.runtime.currentConnection, runtimeFields) }
+              : {}),
+          },
+        }
+      : {}),
+  };
+}
+
+export function claudeDirectoryActivity(page) {
+  return {
+    activity: {
+      ...pick(page.activity, ["data", "cursor", "nextCursor", "actionMode", "actionModeVersion"]),
+      data: (page.activity?.data ?? [])
+        .filter(
+          (event) =>
+            !/(?:^|[._:-])(?:memory|preferences?|personalization|profiles?)(?:[._:-]|$)/i.test(
+              event.type,
+            ) &&
+            (/^(?:action|connection|task|mission|chat|message|conversation|delivery|reply)\./.test(
+              event.type,
+            ) ||
+              event.type === "agent.action_mode_changed"),
+        )
+        .map((event) => ({
+          ...pick(event, [
+            "id",
+            "sequence",
+            "type",
+            "targetId",
+            "createdAt",
+            "executionAuthorized",
+            "actionRequest",
+          ]),
+          ...(event.metadata ? { metadata: withoutAggregates(event.metadata) } : {}),
+        })),
+    },
+    messages: pick(page.messages, ["data", "blocked", "cursor", "nextCursor"]),
+    executionAuthorized: false,
+  };
+}
+
+function withoutAggregates(value) {
+  if (Array.isArray(value)) return value.map(withoutAggregates);
+  if (!value || typeof value !== "object") return value;
+  return Object.fromEntries(
+    Object.entries(value)
+      .filter(
+        ([key]) =>
+          !/^(?:memory|profileMemory|workingMemory|preferences?|personalization|creationContext|privateMetadata)$/i.test(
+            key,
+          ),
+      )
+      .map(([key, item]) => [key, withoutAggregates(item)]),
+  );
+}
+
+const restrictedConfig = Symbol("claude-directory-client");
+
+// Shared by tool calls and both receive transports; no host identity is inferred.
+export function claudeDirectoryClientConfig(config) {
+  if (config[restrictedConfig]) return config;
+  return {
+    ...config,
+    [restrictedConfig]: true,
+    fetch: async (input, init) => {
+      let request = new Request(input, init);
+      const url = new URL(request.url);
+      if (url.pathname === "/api/v1/network/agents/me") {
+        url.searchParams.set("context", "identity");
+        request = new Request(url, request);
+      }
+      const response = await (config.fetch ?? globalThis.fetch)(request);
+      if (
+        !response.ok ||
+        ![
+          "/api/v1/network/agents/me",
+          "/api/v1/network/activity",
+          "/api/v1/network/messages",
+        ].includes(url.pathname)
+      )
+        return response;
+      const payload = await response.json();
+      const body = url.pathname.endsWith("/agents/me")
+        ? { data: claudeDirectoryIdentity(payload.data) }
+        : url.pathname.endsWith("/activity")
+          ? claudeDirectoryActivity({ activity: payload, messages: {} }).activity
+          : pick(payload, ["data", "blocked", "cursor", "nextCursor"]);
+      const headers = new Headers(response.headers);
+      headers.delete("content-length");
+      return new Response(JSON.stringify(body), { status: response.status, headers });
+    },
+  };
+}

package/bin/codex-chat-bridge.mjs

@@ -36,21 +36,31 @@ export async function defaultCodexQueue({ threadId, prompt, signal, environment
       )
     )
       delete env[name];
-  const args = ["queue", "--thread", threadId, "--message", prompt];
-  const invocation =
-    process.platform === "win32"
-      ? installedClientInvocation("codex", args, env)
-      : { command: "codex", args };
-  const pending = execute(invocation.command, invocation.args, {
-    env,
-    signal,
-    timeout: 30000,
-    maxBuffer: 65536,
-    windowsHide: true,
-  });
-  // The Windows shim fallback reads stdin before launching the client.
-  pending.child?.stdin?.end();
-  await pending;
+  for (const args of [
+    ["app-server", "daemon", "start"],
+    ["queue", "--thread", threadId, "--message", prompt, "--resume"],
+  ]) {
+    const invocation =
+      process.platform === "win32"
+        ? installedClientInvocation("codex", args, env)
+        : { command: "codex", args };
+    const pending = execute(invocation.command, invocation.args, {
+      env,
+      signal,
+      timeout: 30000,
+      maxBuffer: 65536,
+      windowsHide: true,
+    });
+    // The Windows shim fallback reads stdin before launching the client.
+    pending.child?.stdin?.end();
+    const result = await pending;
+    if (
+      /could not resume thread/i.test(result.stderr) &&
+      !/already has an active writer/i.test(result.stderr)
+    )
+      throw error("HARNESS_SETUP_REQUIRED");
+    // An existing writer owns delivery; only the bound chat's receipt proves it.
+  }
 }
 
 export async function activeTaskForReply(client, message, identity, signal) {
@@ -363,7 +373,11 @@ export async function completeCodexChatMessage({
       input: message.content,
       output: text,
       name: readOnly ? "agent.request.read" : "agent.conversation",
-      metadata: { provider: "codex", usageSource: "unavailable" },
+      metadata: {
+        provider: "codex",
+        usageSource: "unavailable",
+        stage: readOnly ? "read" : ackOnly ? "acknowledge" : "reply",
+      },
     },
     async () => {
       await inspectNetworkMessage(inspector, client, message);

package/bin/codex-desktop-wake.mjs

@@ -1,49 +1,11 @@
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-import { join } from "node:path";
-import { localClientEnvironment } from "./platform-client.mjs";
-const execute = promisify(execFile);
 const UUID = /^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/;
-/** Load the owner-selected existing chat using Codex's documented app route; no prompt or authority is added. */
-export async function wakeCodexDesktop(
-  { threadId, signal, environment = process.env },
-  options = {},
-) {
+
+/** Compatibility hook for existing bridges; delivery uses the native background queue. */
+export async function wakeCodexDesktop({ threadId, signal }) {
   if (!UUID.test(threadId ?? ""))
     throw Object.assign(new Error("AGENT_IDENTITY_MISMATCH"), { code: "AGENT_IDENTITY_MISMATCH" });
-  const env = localClientEnvironment(environment);
-  for (const name of Object.keys(env))
-    if (
-      /^(?:TOTEM|AGENTTRUST)_|^(?:OPENAI_API_KEY|ANTHROPIC_API_KEY|CLAUDE_CODE_OAUTH_TOKEN)$/i.test(
-        name,
-      )
-    )
-      delete env[name];
-  const uri = `codex://threads/${threadId}?hostId=local`,
-    platform = options.platform ?? process.platform;
-  let command, args;
-  if (platform === "darwin") {
-    command = "/usr/bin/open";
-    args = ["-g", uri];
-  } else if (platform === "win32") {
-    command =
-      env.SystemRoot || env.SYSTEMROOT
-        ? join(env.SystemRoot ?? env.SYSTEMROOT, "explorer.exe")
-        : "explorer.exe";
-    args = [uri];
-  } else if (platform === "linux") {
-    command = "xdg-open";
-    args = [uri];
-  } else
-    throw Object.assign(new Error("AGENT_CLI_INCOMPATIBLE"), { code: "AGENT_CLI_INCOMPATIBLE" });
-  const pending = (options.execute ?? execute)(command, args, {
-    env,
-    signal,
-    timeout: 15000,
-    maxBuffer: 65536,
-    windowsHide: true,
-  });
-  pending.child?.stdin?.end();
-  await pending;
-  return { state: "requested", threadId };
+  signal?.throwIfAborted();
+  // Opening even a background deep link navigates the owner's visible chat.
+  // A suppressed UI wake is not evidence that the queued work was processed.
+  return { state: "suppressed", threadId };
 }

package/bin/codex-human-chat-bridge.mjs

@@ -171,7 +171,11 @@ export async function completeCodexChatCommand({ commandId, text, readOnly = fal
       input: event.text,
       output: text,
       name: readOnly ? "agent.request.read" : "agent.conversation",
-      metadata: { provider: "codex", usageSource: "unavailable" },
+      metadata: {
+        provider: "codex",
+        usageSource: "unavailable",
+        stage: readOnly ? "read" : "reply",
+      },
     },
     async () => {
       await inspector.assertAllowed("input", event.text);
@@ -205,6 +209,7 @@ export async function completeCodexChatCommand({ commandId, text, readOnly = fal
         result,
         text: event.text,
         leaseRenewed,
+        client,
         sessionId: (options.environment ?? process.env).CODEX_THREAD_ID,
       });
       return { state: result.run.state, commandId, eventId: result.event.id };

package/bin/codex-mission-bridge.mjs

@@ -106,6 +106,11 @@ export async function runCodexMissionService(settings, dependencies = {}) {
   };
   while (!signal?.aborted) {
     try {
+      let blocked;
+      const report = (event) => {
+        if (event.type === "blocked") blocked ??= event;
+        emit(blocked ?? event);
+      };
       const identity = await authenticate();
       for await (const mission of client.missions.iterate(
         { status: "active", limit: 100 },
@@ -128,7 +133,7 @@ export async function runCodexMissionService(settings, dependencies = {}) {
               work,
               signal,
             });
-            emit({
+            report({
               type: result.state === "uncertain" ? "blocked" : "waiting",
               code:
                 result.state === "uncertain"
@@ -148,13 +153,15 @@ export async function runCodexMissionService(settings, dependencies = {}) {
             throw error;
           // A Mission can lose access after discovery without invalidating other assignments.
           if (error.status === 403) await authenticate();
-          emit({
+          report({
             type: error.status === 403 ? "blocked" : "waiting",
             code: error.status === 403 ? "permission_denied" : "assignment_unavailable",
             missionId: mission.id,
           });
         }
       }
+      // Retain unresolved work across healthy siblings; a complete empty poll clears stale health.
+      report({ type: "waiting", code: "native_mission_idle" });
     } catch (error) {
       if (signal?.aborted) break;
       if (!transientNetworkError(error) && error.code !== "CHAT_PROMPT_RATE_LIMITED") throw error;

package/bin/harness-bootstrap.mjs

@@ -264,8 +264,12 @@ async function prepareHarness(profile, environment, options) {
       (receipt.state !== "creating" && !UUID.test(receipt.threadId ?? "")))
   )
     throw failure("HARNESS_SETUP_REQUIRED");
-  if (profile.codexThreadId && receipt?.threadId && profile.codexThreadId !== receipt.threadId)
-    throw failure("HARNESS_SETUP_REQUIRED");
+  let previousReceipt;
+  if (profile.codexThreadId && receipt?.threadId && profile.codexThreadId !== receipt.threadId) {
+    // An explicitly replaced profile selects the new UUID; never reuse the old chat's readiness.
+    previousReceipt = receipt;
+    receipt = undefined;
+  }
   const rpc = (options.connect ?? connectCodexHarness)(environment, options);
   try {
     await rpc.initialize();
@@ -330,6 +334,11 @@ async function prepareHarness(profile, environment, options) {
     )
       throw failure("HARNESS_SETUP_REQUIRED");
     if (!profile.codexThreadId) profile = await update(profile, threadId, options);
+    if (previousReceipt)
+      await privateWrite(
+        join(profile.stateDirectory, `harness-bootstrap.previous-${previousReceipt.threadId}.json`),
+        previousReceipt,
+      );
     await privateWrite(path, {
       version: 1,
       binding: fingerprint,

package/bin/harness-catalog.mjs

@@ -0,0 +1,142 @@
+/** Host formats, not model providers. No detection, settings edits, or model changes. */
+const host = (name, configFile, docs, options = {}) => ({ name, configFile, docs, ...options });
+export const HARNESS_CATALOG = Object.freeze({
+  chatgpt: host("ChatGPT", "mcp.json", "https://developers.openai.com/plugins/build/plugins", {
+    kind: "plugin",
+    remoteOnly: true,
+  }),
+  codex: host("OpenAI Codex", "config.toml", "https://developers.openai.com/codex/mcp", {
+    kind: "plugin",
+  }),
+  claude: host(
+    "Anthropic Claude Code",
+    ".mcp.json",
+    "https://code.claude.com/docs/en/plugins-reference",
+    { kind: "plugin" },
+  ),
+  "claude-desktop": host(
+    "Claude Desktop",
+    "claude_desktop_config.json",
+    "https://modelcontextprotocol.io/docs/develop/connect-local-servers",
+    { localOnly: true },
+  ),
+  grok: host(
+    "Grok Build / xAI API",
+    "totem-grok.mjs",
+    "https://docs.x.ai/build/features/skills-plugins-marketplaces",
+    {
+      kind: "plugin",
+      remoteOnly: true,
+    },
+  ),
+  grokbot: host("Grok Bot", ".mcp.json", "https://docs.x.ai/grok-bot/computer-and-apps", {
+    kind: "plugin",
+    remoteOnly: true,
+  }),
+  opencode: host("OpenCode", "opencode.json", "https://opencode.ai/docs/mcp-servers/"),
+  openclaw: host("OpenClaw", "openclaw.json", "https://docs.openclaw.ai/plugins/bundles", {
+    kind: "plugin",
+  }),
+  hermes: host(
+    "Hermes Agent",
+    "config.yaml",
+    "https://hermes-agent.nousresearch.com/docs/developer-guide/plugins",
+    { kind: "plugin" },
+  ),
+  gemini: host(
+    "Gemini CLI",
+    "gemini-extension.json",
+    "https://geminicli.com/docs/extensions/reference/",
+    { kind: "extension" },
+  ),
+  cursor: host("Cursor", ".cursor/mcp.json", "https://cursor.com/docs/plugins", { kind: "plugin" }),
+  windsurf: host(
+    "Windsurf Cascade (legacy)",
+    "mcp_config.json",
+    "https://docs.windsurf.com/windsurf/cascade/mcp",
+    { legacy: true },
+  ),
+  devin: host(
+    "Devin CLI / Desktop",
+    ".devin/mcp_config.json",
+    "https://docs.devin.ai/cli/extensibility/plugins/overview",
+    { kind: "plugin" },
+  ),
+  antigravity: host(
+    "Google Antigravity",
+    "mcp_config.json",
+    "https://antigravity.google/docs/build-plugins",
+    { kind: "plugin" },
+  ),
+  qwen: host(
+    "Qwen Code",
+    "settings.json",
+    "https://qwenlm.github.io/qwen-code-docs/en/users/features/mcp/",
+  ),
+  zed: host("Zed", "settings.json", "https://zed.dev/docs/ai/mcp"),
+  vscode: host(
+    "VS Code Copilot (Local harness)",
+    ".vscode/mcp.json",
+    "https://code.visualstudio.com/docs/agent-customization/mcp-servers",
+  ),
+  copilot: host(
+    "GitHub Copilot CLI",
+    "mcp-config.json",
+    "https://docs.github.com/en/copilot/how-tos/copilot-cli/customize-copilot/add-mcp-servers",
+  ),
+  cline: host(
+    "Cline",
+    "cline_mcp_settings.json",
+    "https://docs.cline.bot/mcp/configuring-mcp-servers",
+  ),
+  roo: host(
+    "Roo Code",
+    ".roo/mcp.json",
+    "https://roocodeinc.github.io/Roo-Code/features/mcp/using-mcp-in-roo/",
+  ),
+  continue: host("Continue", "config.yaml", "https://docs.continue.dev/customize/deep-dives/mcp"),
+  kiro: host("Kiro", ".kiro/settings/mcp.json", "https://kiro.dev/docs/mcp/configuration/"),
+  goose: host(
+    "Goose",
+    "config.yaml",
+    "https://github.com/block/goose/blob/main/documentation/docs/getting-started/using-extensions.md",
+  ),
+  muse: host("Muse Code", "mcp.json", "https://totemlayer.com/docs/mcp"),
+  factory: host("Factory Droid", "mcp.json", "https://docs.factory.com/harness/plugins", {
+    kind: "plugin",
+  }),
+  kilo: host("Kilo Code", "kilo.json", "https://kilo.ai/docs/customize/marketplace", {
+    kind: "marketplace-bundle",
+  }),
+  pi: host(
+    "Pi",
+    "mcp.json",
+    "https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/packages.md",
+    { kind: "extension" },
+  ),
+  kimi: host(
+    "Kimi Code",
+    "mcp.json",
+    "https://www.kimi.com/code/docs/en/kimi-code-cli/customization/plugins.html",
+    { kind: "plugin" },
+  ),
+  amp: host("Amp", "settings.json", "https://ampcode.com/docs/customize/plugins", {
+    kind: "plugin",
+  }),
+  junie: host(
+    "JetBrains Junie",
+    "mcp.json",
+    "https://junie.jetbrains.com/docs/junie-cli-extensions.html",
+    { kind: "extension" },
+  ),
+  augment: host("Augment / Auggie", "mcp.json", "https://docs.augmentcode.com/cli/plugins", {
+    kind: "plugin",
+  }),
+  generic: host(
+    "Other MCP clients",
+    "mcp.json",
+    "https://modelcontextprotocol.io/docs/develop/connect-local-servers",
+  ),
+});
+
+export const MCP_FORMATS = Object.freeze(Object.keys(HARNESS_CATALOG));

package/bin/installation.mjs

@@ -39,6 +39,8 @@ export async function activateConnection(profile, env = process.env, options = {
         ...service,
         entry: runtime.cli,
         code: "LISTENER_STARTUP_UNAVAILABLE",
+        startupCode: service.code ?? "LISTENER_STARTUP_UNAVAILABLE",
+        ...startupDiagnostic({ code: service.code ?? "LISTENER_STARTUP_UNAVAILABLE" }),
         message:
           "Automatic startup is not registered. Incoming work remains queued until host setup succeeds.",
       };

package/bin/mcp-config.d.mts

@@ -8,4 +8,19 @@ export function buildMcpConfig(options?: {
   expectedEnvironment?: string;
   command?: string;
   args?: string[];
-}): Record<string, Record<string, Record<string, unknown>>>;
+}): Record<string, unknown>;
+export const MCP_FORMATS: readonly string[];
+export const HARNESS_CATALOG: Readonly<
+  Record<
+    string,
+    {
+      name: string;
+      configFile: string;
+      docs: string;
+      kind?: string;
+      localOnly?: boolean;
+      remoteOnly?: boolean;
+      legacy?: boolean;
+    }
+  >
+>;