zam-core 0.10.3 → 0.10.4

package/dist/cli/app.js

@@ -5946,6 +5946,18 @@ function saveMachineAiConfig(ai, path = defaultConfigPath()) {
   config.ai = ai;
   saveInstallConfig(config, path);
 }
+function getAgentConnectAutoDone(path = defaultConfigPath()) {
+  return loadInstallConfig(path).agent?.connectAutoDone === true;
+}
+function setAgentConnectAutoDone(done, path = defaultConfigPath()) {
+  const config = loadInstallConfig(path);
+  if (done) {
+    config.agent = { ...config.agent ?? {}, connectAutoDone: true };
+  } else if (config.agent) {
+    delete config.agent.connectAutoDone;
+  }
+  saveInstallConfig(config, path);
+}
 function getConfiguredWorkspaces(path = defaultConfigPath()) {
   return loadInstallConfig(path).workspaces ?? [];
 }
@@ -6622,6 +6634,7 @@ __export(kernel_exports, {
   getActiveWorkspace: () => getActiveWorkspace,
   getActiveWorkspaceContext: () => getActiveWorkspaceContext,
   getActiveWorkspaceId: () => getActiveWorkspaceId,
+  getAgentConnectAutoDone: () => getAgentConnectAutoDone,
   getAgentSkill: () => getAgentSkill,
   getAllSettings: () => getAllSettings,
   getAllSettingsDetailed: () => getAllSettingsDetailed,
@@ -6731,6 +6744,7 @@ __export(kernel_exports, {
   setADOCredentials: () => setADOCredentials,
   setActiveWorkspaceContext: () => setActiveWorkspaceContext,
   setActiveWorkspaceId: () => setActiveWorkspaceId,
+  setAgentConnectAutoDone: () => setAgentConnectAutoDone,
   setInstallChannel: () => setInstallChannel,
   setInstallMode: () => setInstallMode,
   setProviderApiKey: () => setProviderApiKey,
@@ -6815,11 +6829,16 @@ import { Command as Command27 } from "commander";
 
 // src/cli/commands/agent.ts
 init_kernel();
-import { existsSync as existsSync15, mkdirSync as mkdirSync10, writeFileSync as writeFileSync9 } from "fs";
-import { homedir as homedir11 } from "os";
-import { dirname as dirname7, join as join15 } from "path";
+import { existsSync as existsSync15 } from "fs";
+import { join as join15 } from "path";
 import { Command } from "commander";
 
+// src/cli/agent-connect.ts
+init_kernel();
+import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync9 } from "fs";
+import { homedir as homedir11 } from "os";
+import { dirname as dirname7 } from "path";
+
 // src/cli/agent-harness.ts
 import { spawn } from "child_process";
 import { existsSync as existsSync12, readFileSync as readFileSync9 } from "fs";
@@ -7673,16 +7692,7 @@ function installVscodeExtension(options) {
   };
 }
 
-// src/cli/commands/agent.ts
-var C = {
-  reset: "\x1B[0m",
-  bold: "\x1B[1m",
-  cyan: "\x1B[36m",
-  dim: "\x1B[2m",
-  green: "\x1B[32m",
-  yellow: "\x1B[33m"
-};
-var SUPPORTED_AGENTS = ["opencode"];
+// src/cli/agent-connect.ts
 var CONNECT_HARNESSES = [
   "claude-code",
   "claude-desktop",
@@ -7693,9 +7703,189 @@ var CONNECT_HARNESSES = [
   "goose",
   "copilot"
 ];
+var USER_SCOPED_CONNECT_HARNESSES = [
+  "claude-desktop",
+  "antigravity",
+  "codex",
+  "vscode",
+  "opencode",
+  "goose",
+  "copilot"
+];
+var CONNECT_HARNESS_LABELS = {
+  "claude-code": "Claude Code",
+  "claude-desktop": "Claude Desktop",
+  antigravity: "Antigravity",
+  codex: "Codex",
+  vscode: "VS Code",
+  opencode: "OpenCode",
+  goose: "Goose",
+  copilot: "GitHub Copilot"
+};
 function isConnectHarnessId(value) {
   return CONNECT_HARNESSES.includes(value);
 }
+function resolveDeps(deps) {
+  const home = deps.home ?? homedir11();
+  const cwd = deps.cwd ?? process.cwd();
+  const copilotHome = deps.copilotHome ?? process.env.COPILOT_HOME;
+  return {
+    home,
+    cwd,
+    copilotHome,
+    findZam: deps.findZam ?? (() => findExecutable("zam")),
+    detect: deps.detect ?? (() => detectInstalledConnectHarnesses({ home, copilotHome })),
+    connectMcp: deps.connectMcp ?? connectHarnessMcp,
+    writeConfig: deps.writeConfig ?? ((path, content) => {
+      mkdirSync10(dirname7(path), { recursive: true });
+      writeFileSync9(path, content, "utf-8");
+    }),
+    installCopilot: deps.installCopilot ?? installCopilotExtension,
+    installVscode: deps.installVscode ?? installVscodeExtension,
+    resolveAntigravity: deps.resolveAntigravity ?? resolveAntigravityIdeExecutable,
+    refreshSkills: deps.refreshSkills ?? distributeGlobalSkills
+  };
+}
+function performAgentConnect(opts = {}, deps = {}) {
+  const d = resolveDeps(deps);
+  const dryRun = Boolean(opts.dryRun);
+  const detected = opts.harness ? [opts.harness] : d.detect();
+  const foundZam = d.findZam();
+  const zamPath = foundZam ?? "zam";
+  const results = [];
+  for (const harness of detected) {
+    const label = CONNECT_HARNESS_LABELS[harness];
+    try {
+      const prepared = d.connectMcp(harness, {
+        zamPath,
+        cwd: d.cwd,
+        home: d.home,
+        copilotHome: d.copilotHome
+      });
+      let extension = null;
+      if (harness === "copilot") {
+        const installed = d.installCopilot({
+          home: d.home,
+          zamPath,
+          dryRun
+        });
+        extension = {
+          kind: "copilot",
+          action: installed.action,
+          location: installed.destinationDir,
+          detail: `${installed.launch.command} ${installed.launch.args.join(" ")}`
+        };
+      } else if (harness === "vscode") {
+        const installed = d.installVscode({ home: d.home, zamPath, dryRun });
+        extension = {
+          kind: "vscode",
+          action: installed.action,
+          location: installed.vsixPath,
+          detail: installed.launchConfigPath
+        };
+      } else if (harness === "antigravity") {
+        const antigravityPath = d.resolveAntigravity();
+        if (antigravityPath) {
+          const installed = d.installVscode({
+            home: d.home,
+            zamPath,
+            codePath: antigravityPath,
+            dryRun
+          });
+          extension = {
+            kind: "vscode",
+            action: installed.action,
+            location: installed.vsixPath,
+            detail: installed.launchConfigPath
+          };
+        }
+      }
+      let wrote = false;
+      if (!prepared.alreadyConfigured && !dryRun) {
+        d.writeConfig(prepared.path, prepared.content);
+        wrote = true;
+      }
+      results.push({
+        harness,
+        label,
+        path: prepared.path,
+        content: prepared.content,
+        alreadyConfigured: prepared.alreadyConfigured,
+        wrote,
+        hint: prepared.hint,
+        extension
+      });
+    } catch (error) {
+      results.push({
+        harness,
+        label,
+        path: "",
+        content: "",
+        alreadyConfigured: false,
+        wrote: false,
+        hint: "",
+        extension: null,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  let skills = null;
+  if (!dryRun && detected.length > 0) {
+    const skillResults = d.refreshSkills(d.home);
+    skills = {
+      refreshed: skillResults.filter((result) => result.success).length,
+      total: skillResults.length
+    };
+  }
+  return {
+    success: results.every((result) => !result.error),
+    detected,
+    zamPath,
+    zamOnPath: Boolean(foundZam),
+    results,
+    skills
+  };
+}
+function inspectConnectHarnesses(deps = {}) {
+  const d = resolveDeps(deps);
+  const foundZam = d.findZam();
+  const zamPath = foundZam ?? "zam";
+  const installed = new Set(d.detect());
+  const harnesses = USER_SCOPED_CONNECT_HARNESSES.map((harness) => {
+    const status = {
+      harness,
+      label: CONNECT_HARNESS_LABELS[harness],
+      installed: installed.has(harness),
+      configured: false,
+      configPath: ""
+    };
+    try {
+      const probe = d.connectMcp(harness, {
+        zamPath,
+        cwd: d.cwd,
+        home: d.home,
+        copilotHome: d.copilotHome
+      });
+      status.configured = probe.alreadyConfigured;
+      status.configPath = probe.path;
+    } catch (error) {
+      status.note = error instanceof Error ? error.message : String(error);
+    }
+    return status;
+  });
+  return { zamOnPath: Boolean(foundZam), harnesses };
+}
+
+// src/cli/commands/agent.ts
+var C = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  cyan: "\x1B[36m",
+  dim: "\x1B[2m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m"
+};
+var SUPPORTED_AGENTS = ["opencode"];
 function agentsMdPresent(cwd = process.cwd()) {
   return existsSync15(join15(cwd, "AGENTS.md"));
 }
@@ -7823,125 +8013,69 @@ var connectCmd = new Command("connect").description(
       explicitHarness = harnessArg;
     }
   }
-  const home = homedir11();
-  const harnesses = explicitHarness ? [explicitHarness] : detectInstalledConnectHarnesses({
-    home,
-    copilotHome: process.env.COPILOT_HOME
+  const report = performAgentConnect({
+    harness: explicitHarness,
+    dryRun: Boolean(opts.print)
   });
-  if (harnesses.length === 0) {
+  if (report.detected.length === 0) {
     console.error(
       "No supported user-scoped agent harness was detected. Install Codex, VS Code, or another supported host, or pass a harness explicitly."
     );
     process.exit(1);
   }
-  let zamPath = findExecutable("zam");
-  if (!zamPath) {
+  if (!report.zamOnPath) {
     console.warn(
       `${C.yellow}Warning: 'zam' executable was not found on your PATH. Falling back to literal 'zam'.${C.reset}`
     );
-    zamPath = "zam";
   }
-  for (const harness of harnesses) {
-    let result;
-    try {
-      result = connectHarnessMcp(harness, {
-        zamPath,
-        cwd: process.cwd(),
-        home,
-        copilotHome: process.env.COPILOT_HOME
-      });
-    } catch (error) {
-      console.error(
-        `Error preparing ${harness} MCP configuration: ${error instanceof Error ? error.message : String(error)}`
-      );
-      process.exit(1);
-    }
-    let copilotExtension;
-    let vscodeExtension;
-    try {
-      if (harness === "copilot") {
-        copilotExtension = installCopilotExtension({
-          home,
-          zamPath,
-          dryRun: Boolean(opts.print)
-        });
-      } else if (harness === "vscode") {
-        vscodeExtension = installVscodeExtension({
-          home,
-          zamPath,
-          dryRun: Boolean(opts.print)
-        });
-      } else if (harness === "antigravity") {
-        const antigravityPath = resolveAntigravityIdeExecutable();
-        if (antigravityPath) {
-          vscodeExtension = installVscodeExtension({
-            home,
-            zamPath,
-            codePath: antigravityPath,
-            dryRun: Boolean(opts.print)
-          });
-        }
-      }
-    } catch (error) {
-      console.error(
-        `Error preparing ${harness} companion extension: ${error instanceof Error ? error.message : String(error)}`
-      );
-      process.exit(1);
+  for (const result of report.results) {
+    if (result.error) {
+      console.error(`Error connecting ${result.harness}: ${result.error}`);
+      continue;
     }
     if (opts.print) {
-      if (harnesses.length > 1) console.log(`${C.bold}${harness}${C.reset}`);
+      if (report.results.length > 1)
+        console.log(`${C.bold}${result.harness}${C.reset}`);
       console.log(`Path: ${result.path}`);
       console.log(`Content:
 ${result.content}`);
-      if (copilotExtension) {
-        console.log(`Extension: ${copilotExtension.destinationDir}`);
-        console.log(
-          `Launch: ${copilotExtension.launch.command} ${copilotExtension.launch.args.join(" ")}`
-        );
-      }
-      if (vscodeExtension) {
-        console.log(`Extension: ${vscodeExtension.vsixPath}`);
-        console.log(`Launch config: ${vscodeExtension.launchConfigPath}`);
+      if (result.extension?.kind === "copilot") {
+        console.log(`Extension: ${result.extension.location}`);
+        console.log(`Launch: ${result.extension.detail}`);
+      } else if (result.extension) {
+        console.log(`Extension: ${result.extension.location}`);
+        console.log(`Launch config: ${result.extension.detail}`);
       }
       continue;
     }
     if (result.alreadyConfigured) {
       console.log(
-        `${C.green}\u2713${C.reset} ${harness}: MCP server 'zam' already configured in ${result.path}`
+        `${C.green}\u2713${C.reset} ${result.harness}: MCP server 'zam' already configured in ${result.path}`
       );
     } else {
-      try {
-        mkdirSync10(dirname7(result.path), { recursive: true });
-        writeFileSync9(result.path, result.content, "utf-8");
-        console.log(
-          `${C.green}\u2713${C.reset} ${harness}: wrote MCP configuration to ${result.path}`
-        );
-      } catch (error) {
-        console.error(
-          `Error writing ${harness} MCP configuration: ${error instanceof Error ? error.message : String(error)}`
-        );
-        process.exit(1);
-      }
-    }
-    if (copilotExtension) {
       console.log(
-        `${C.green}\u2713${C.reset} Copilot MCP Apps extension ${copilotExtension.action} at ${copilotExtension.destinationDir}`
+        `${C.green}\u2713${C.reset} ${result.harness}: wrote MCP configuration to ${result.path}`
       );
     }
-    if (vscodeExtension) {
+    if (result.extension?.kind === "copilot") {
+      console.log(
+        `${C.green}\u2713${C.reset} Copilot MCP Apps extension ${result.extension.action} at ${result.extension.location}`
+      );
+    } else if (result.extension) {
       console.log(
-        `${C.green}\u2713${C.reset} ZAM Companion ${vscodeExtension.action} from ${vscodeExtension.vsixPath}`
+        `${C.green}\u2713${C.reset} ZAM Companion ${result.extension.action} from ${result.extension.location}`
       );
     }
     console.log(`  ${C.dim}${result.hint}${C.reset}`);
   }
-  if (!opts.print) {
-    const skills = distributeGlobalSkills(home);
-    const installed = skills.filter((result) => result.success).length;
+  if (report.skills) {
     console.log(
-      `${C.green}\u2713${C.reset} Refreshed ${installed}/${skills.length} global ZAM skill installations`
+      `${C.green}\u2713${C.reset} Refreshed ${report.skills.refreshed}/${report.skills.total} global ZAM skill installations`
     );
   }
+  if (!report.success) {
+    process.exit(1);
+  }
 });
 var agentCommand = new Command("agent").description("Provision and inspect the agent that drives ZAM sessions").addCommand(installCmd).addCommand(statusCmd).addCommand(openCmd).addCommand(listCmd).addCommand(connectCmd).action(printStatus);
 
@@ -7967,6 +8101,7 @@ var DEFAULT_LLM_URL = "http://localhost:8000/v1";
 var DEFAULT_LLM_MAX_TOKENS = 1e4;
 var RECALL_QUESTION_MAX_OUTPUT_TOKENS = 400;
 var RECALL_EVALUATION_MAX_OUTPUT_TOKENS = 1200;
+var RECALL_DISCUSSION_MAX_OUTPUT_TOKENS = 1200;
 var RECALL_ENDPOINT_CACHE_MS = 6e4;
 var cachedRecallEndpoint = null;
 function recallEndpointSignature(cfg) {
@@ -8329,6 +8464,64 @@ Evaluation:`;
     providerName: endpoint.providerName
   };
 }
+async function discussReviewViaLLM(db, input8) {
+  const cfg = await getProviderForRole(db, "recall");
+  const endpoint = await resolveUsableRecallEndpoint(db);
+  const langName = LANGUAGE_NAMES[cfg.locale] || "English";
+  const systemPrompt = `You are ZAM, a warm, precise, and encouraging skills trainer in a follow-up discussion about one flashcard.
+The learner has already answered, the reference answer is revealed, and your evaluation feedback was shown \u2014 nothing about this card is a spoiler anymore.
+
+Guidelines:
+1. Answer the learner's follow-up directly and concretely in ${langName}, grounded in the card's target concept, context, and source reference.
+2. Stay scoped to this card and its concept. If the learner drifts to unrelated territory, answer briefly and steer back to the concept.
+3. Keep replies conversational and short (a few sentences) unless the learner explicitly asks for depth. Plain text only \u2014 no markdown wrapper, headers, or bullet lists.
+4. The self-rating is the learner's own choice. If asked, explain the FSRS scale (1 forgot, 2 hard, 3 good, 4 easy) but never pressure them toward a specific rating.`;
+  const cardFrame = `The card under discussion:
+Domain: ${input8.domain}
+Slug: ${input8.slug}
+Recall Question: ${input8.question}
+Learner's Answer: ${input8.userAnswer}
+
+Target Concept (Correct Answer): ${input8.concept}
+Target Context: ${input8.context || "(none)"}
+${input8.sourceLinkContent ? `Source Code Reference:
+${input8.sourceLinkContent}` : ""}`;
+  const messages = [
+    { role: "system", content: systemPrompt },
+    { role: "user", content: cardFrame }
+  ];
+  const feedback = input8.feedback?.trim();
+  if (feedback) {
+    messages.push({ role: "assistant", content: feedback });
+  }
+  for (const turn of input8.thread) {
+    messages.push({ role: turn.role, content: turn.content });
+  }
+  messages.push({ role: "user", content: input8.message });
+  const res = await fetchWithInteractiveTimeout(
+    `${endpoint.url}/chat/completions`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${endpoint.apiKey}`
+      },
+      body: JSON.stringify({
+        model: endpoint.model,
+        messages,
+        temperature: 0.3,
+        max_tokens: RECALL_DISCUSSION_MAX_OUTPUT_TOKENS
+      }),
+      locale: cfg.locale
+    }
+  );
+  const text = await readChatContent(res, "LLM discussion");
+  return {
+    text,
+    model: endpoint.model,
+    providerName: endpoint.providerName
+  };
+}
 var MAX_IMPORT_TEXT_CHARS = 2e5;
 var VALID_GENERATED_MODES = /* @__PURE__ */ new Set(["shadowing", "copilot", "autonomy"]);
 function parseGeneratedCardArray(responseText, label, limits) {
@@ -9566,7 +9759,7 @@ async function readWebLink(url) {
         redirect: "manual",
         signal: controller.signal,
         headers: {
-          "User-Agent": "ZAM-Content-Studio/0.10.0"
+          "User-Agent": "ZAM-Content-Studio/0.10.4"
         }
       });
       if (res.status >= 300 && res.status < 400) {
@@ -16224,6 +16417,93 @@ bridgeCommand.command("evaluate-answer").description(
     }
   });
 });
+function parseDiscussionThread(raw) {
+  if (!raw) return [];
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error("Invalid --thread: not valid JSON");
+  }
+  if (!Array.isArray(parsed)) {
+    throw new Error("Invalid --thread: expected a JSON array of turns");
+  }
+  return parsed.map((turn, index) => {
+    const candidate = turn;
+    if (candidate?.role !== "user" && candidate?.role !== "assistant" || typeof candidate?.content !== "string") {
+      throw new Error(
+        `Invalid --thread: turn ${index} must be {"role": "user"|"assistant", "content": string}`
+      );
+    }
+    return { role: candidate.role, content: candidate.content };
+  });
+}
+bridgeCommand.command("discuss-review").description(
+  "Answer one turn of the post-reveal follow-up discussion about a card (JSON)"
+).requiredOption("--slug <slug>", "Token slug").requiredOption("--concept <concept>", "Target concept text").requiredOption("--domain <domain>", "Token domain").requiredOption("--bloom-level <level>", "Bloom taxonomy level").requiredOption("--question <question>", "Question prompt presented").requiredOption("--user-answer <answer>", "User's typed answer").requiredOption("--message <text>", "The learner's newest discussion turn").option("--feedback <text>", "AI feedback already shown for this answer").option(
+  "--thread <json>",
+  'Prior turns, oldest first, as JSON: [{"role":"user"|"assistant","content":"\u2026"},\u2026]'
+).option("--context <context>", "Optional token context details").option("--source-link <link>", "Optional source link").option(
+  "--source-content <content>",
+  "Pre-resolved source reference content (skips re-fetch when set)"
+).action(async (opts) => {
+  await withDb2(async (db) => {
+    const isEnabled = await getSetting(db, "llm.enabled") === "true";
+    if (!isEnabled) {
+      jsonOut2({
+        success: false,
+        error: "LLM integration is disabled",
+        reply: ""
+      });
+      return;
+    }
+    let thread;
+    try {
+      thread = parseDiscussionThread(opts.thread);
+    } catch (err) {
+      jsonOut2({
+        success: false,
+        error: err.message,
+        reply: ""
+      });
+      return;
+    }
+    let resolvedContextContent = opts.sourceContent ?? null;
+    if (resolvedContextContent == null && opts.sourceLink) {
+      try {
+        const resolved = await resolveReviewContext(opts.sourceLink);
+        resolvedContextContent = resolved?.content ?? null;
+      } catch {
+      }
+    }
+    try {
+      const result = await discussReviewViaLLM(db, {
+        slug: opts.slug,
+        concept: opts.concept,
+        domain: opts.domain,
+        bloomLevel: Number(opts.bloomLevel),
+        context: opts.context,
+        question: opts.question,
+        userAnswer: opts.userAnswer,
+        sourceLinkContent: resolvedContextContent,
+        feedback: opts.feedback ?? null,
+        thread,
+        message: opts.message
+      });
+      jsonOut2({
+        success: true,
+        reply: result.text,
+        replyModel: result.model
+      });
+    } catch (err) {
+      jsonOut2({
+        success: false,
+        error: err.message,
+        reply: ""
+      });
+    }
+  });
+});
 bridgeCommand.command("desktop-bootstrap").description("Initialize first-run desktop state (JSON)").option("--user <id>", "Preferred user ID when none is configured").action(async (opts) => {
   await withDb2(async (db) => {
     const userId = await ensureDefaultUser(db, opts.user);
@@ -16252,6 +16532,54 @@ bridgeCommand.command("get-settings").description("Get active ZAM settings (JSON
     });
   });
 });
+bridgeCommand.command("agent-harness-status").description(
+  "Detect installed agent harnesses and their ZAM MCP configuration state (JSON)"
+).action(() => {
+  const report = inspectConnectHarnesses();
+  jsonOut2({
+    success: true,
+    zamOnPath: report.zamOnPath,
+    harnesses: report.harnesses
+  });
+});
+bridgeCommand.command("agent-connect").description(
+  "Run the idempotent agent-connect flow for one or all detected harnesses (JSON)"
+).option("--harness <id>", "Explicit harness id (default: all detected)").option(
+  "--auto-once",
+  "First-run mode: skip when the auto-connect marker is already set; set the marker after a run that detected at least one harness"
+).action(async (opts) => {
+  if (opts.harness && !isConnectHarnessId(opts.harness)) {
+    jsonOut2({
+      success: false,
+      error: `Unsupported harness: ${opts.harness}`
+    });
+    return;
+  }
+  const harness = opts.harness;
+  const run = () => {
+    const report = performAgentConnect({ harness });
+    return {
+      success: report.success,
+      detected: report.detected,
+      zamOnPath: report.zamOnPath,
+      results: report.results.map(({ content: _content, ...rest }) => rest),
+      skills: report.skills
+    };
+  };
+  if (opts.autoOnce) {
+    if (getAgentConnectAutoDone()) {
+      jsonOut2({ success: true, skipped: true });
+      return;
+    }
+    const payload = run();
+    if (payload.detected.length > 0) {
+      setAgentConnectAutoDone(true);
+    }
+    jsonOut2(payload);
+    return;
+  }
+  jsonOut2(run());
+});
 async function readDatabaseUserSummaries(db) {
   return await db.prepare(
     `SELECT user_id AS id, COUNT(*) AS cardCount
@@ -21227,9 +21555,49 @@ async function activateMachineProviderConfig(db) {
     `  activate  ${providerCount} machine-local provider(s) from ~/.zam/config.json`
   );
 }
+function connectDetectedAgentHarnesses(skip, dryRun) {
+  if (skip) return;
+  try {
+    const report = performAgentConnect({ dryRun });
+    if (report.detected.length === 0) {
+      console.log(
+        "  skip  no supported agent harness detected (zam agent connect <harness> configures one explicitly)"
+      );
+      return;
+    }
+    for (const result of report.results) {
+      if (result.error) {
+        console.warn(`  warn  ${result.harness}: ${result.error}`);
+      } else if (dryRun) {
+        console.log(
+          `  plan  ${result.harness}: would ensure MCP config at ${result.path}`
+        );
+      } else if (result.alreadyConfigured) {
+        console.log(
+          `  skip  ${result.harness}: MCP already configured (${result.path})`
+        );
+      } else {
+        console.log(
+          `  wire  ${result.harness}: MCP configured (${result.path})`
+        );
+      }
+    }
+    if (report.skills) {
+      console.log(
+        `  wire  global ZAM skill: ${report.skills.refreshed}/${report.skills.total} locations`
+      );
+    }
+  } catch (err) {
+    console.warn(`  warn  agent connect: ${err.message}`);
+  }
+}
 var setupCommand = new Command18("setup").description(
   "Link ZAM skill directories into this workspace and initialize the database"
-).option("--force", "replace an unmanaged existing ZAM skill directory", false).option("--skip-init", "skip database initialization", false).option("--skip-claude-md", "skip CLAUDE.md generation", false).option("--skip-agents-md", "skip AGENTS.md generation", false).option("--target <path>", "repository/workspace directory to set up").option(
+).option("--force", "replace an unmanaged existing ZAM skill directory", false).option("--skip-init", "skip database initialization", false).option("--skip-claude-md", "skip CLAUDE.md generation", false).option("--skip-agents-md", "skip AGENTS.md generation", false).option(
+  "--skip-agent-connect",
+  "skip wiring detected agent harnesses via MCP",
+  false
+).option("--target <path>", "repository/workspace directory to set up").option(
   "--agents <list>",
   "comma-separated agents to wire: all, claude, copilot, codex, agent"
 ).option(
@@ -21256,6 +21624,7 @@ var setupCommand = new Command18("setup").description(
       dryRun: opts.dryRun
     });
     await initDatabase(opts.skipInit || opts.dryRun);
+    connectDetectedAgentHarnesses(opts.skipAgentConnect, opts.dryRun);
     if (agents.has("claude")) {
       writeClaudeMd(opts.skipClaudeMd, target, {
         dryRun: opts.dryRun,