threadroot 0.1.0 → 0.1.1

package/dist/index.js

@@ -36,7 +36,7 @@ var harnessManifestSchema = z2.object({
   name: z2.string().min(1),
   version: z2.literal(1),
   profile: profileIdSchema,
-  adapters: z2.array(adapterIdSchema).min(1),
+  adapters: z2.array(adapterIdSchema).default([]),
   references: z2.array(referenceSchema).default([]),
   memory: z2.object({
     budget: z2.record(memoryTypeSchema, z2.number().int().positive()).default({})
@@ -1042,13 +1042,13 @@ async function runDiff(repoRoot) {
     }
   }
   if (changed === 0) {
-    console.log("No drift: every vendor file matches the canonical harness.");
+    console.log("No drift: optional compiled outputs match the canonical harness.");
   }
 }
 
 // src/core/doctor.ts
-import { stat as stat4 } from "fs/promises";
-import path14 from "path";
+import { stat as stat5 } from "fs/promises";
+import path16 from "path";
 
 // src/core/install/lock.ts
 import { mkdir as mkdir3, readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
@@ -1711,6 +1711,407 @@ async function checkConnections(repoRoot, options = {}) {
   return Promise.all(harness.connections.map((connection) => checkConnection(repoRoot, connection)));
 }
 
+// src/core/setup.ts
+import { mkdir as mkdir5, readFile as readFile6, rm, stat as stat3, writeFile as writeFile5 } from "fs/promises";
+import { homedir } from "os";
+import path13 from "path";
+
+// src/core/agent-providers.ts
+import path12 from "path";
+var AGENT_PROVIDER_IDS = [
+  "antigravity",
+  "claude",
+  "codex",
+  "cursor",
+  "gemini",
+  "copilot",
+  "opencode",
+  "windsurf"
+];
+var AGENT_PROVIDERS = {
+  antigravity: {
+    id: "antigravity",
+    label: "Antigravity",
+    projectSkillDir: path12.join(".agent", "skills"),
+    globalSkillDir: path12.join(".gemini", "antigravity", "skills")
+  },
+  claude: {
+    id: "claude",
+    label: "Claude Code",
+    projectSkillDir: path12.join(".claude", "skills"),
+    globalSkillDir: path12.join(".claude", "skills")
+  },
+  codex: {
+    id: "codex",
+    label: "Codex",
+    projectSkillDir: path12.join(".agents", "skills"),
+    globalSkillDir: path12.join(".agents", "skills")
+  },
+  cursor: {
+    id: "cursor",
+    label: "Cursor",
+    projectSkillDir: path12.join(".cursor", "skills"),
+    globalSkillDir: path12.join(".cursor", "skills")
+  },
+  gemini: {
+    id: "gemini",
+    label: "Gemini CLI",
+    projectSkillDir: path12.join(".gemini", "skills"),
+    globalSkillDir: path12.join(".gemini", "skills")
+  },
+  copilot: {
+    id: "copilot",
+    label: "GitHub Copilot",
+    projectSkillDir: path12.join(".github", "skills"),
+    globalSkillDir: path12.join(".copilot", "skills")
+  },
+  opencode: {
+    id: "opencode",
+    label: "OpenCode",
+    projectSkillDir: path12.join(".opencode", "skills"),
+    globalSkillDir: path12.join(".config", "opencode", "skills")
+  },
+  windsurf: {
+    id: "windsurf",
+    label: "Windsurf",
+    projectSkillDir: path12.join(".windsurf", "skills"),
+    globalSkillDir: path12.join(".codeium", "windsurf", "skills")
+  }
+};
+var ALIASES = {
+  all: "all",
+  agent: "antigravity",
+  antigravity: "antigravity",
+  claude: "claude",
+  "claude-code": "claude",
+  codex: "codex",
+  cursor: "cursor",
+  gemini: "gemini",
+  "gemini-cli": "gemini",
+  copilot: "copilot",
+  github: "copilot",
+  "github-copilot": "copilot",
+  opencode: "opencode",
+  "open-code": "opencode",
+  windsurf: "windsurf"
+};
+function parseAgentProviderList(value, fallback = "all") {
+  const raw = value?.trim();
+  if (!raw) {
+    return fallback === "all" ? [...AGENT_PROVIDER_IDS] : fallback;
+  }
+  const ids = /* @__PURE__ */ new Set();
+  for (const entry of raw.split(",")) {
+    const key = entry.trim().toLowerCase();
+    if (!key) {
+      continue;
+    }
+    const resolved = ALIASES[key];
+    if (!resolved) {
+      throw new Error(`Unknown agent provider \`${entry}\`. Supported: ${AGENT_PROVIDER_IDS.join(", ")}, all.`);
+    }
+    if (resolved === "all") {
+      for (const id of AGENT_PROVIDER_IDS) {
+        ids.add(id);
+      }
+      continue;
+    }
+    ids.add(resolved);
+  }
+  return [...ids];
+}
+
+// src/core/managed-block.ts
+function hasManagedBlock(content, begin, end) {
+  return content.includes(begin) && content.includes(end);
+}
+function upsertManagedBlock(content, block, begin, end) {
+  const start = content.indexOf(begin);
+  const finish = content.indexOf(end);
+  const normalizedBlock = block.endsWith("\n") ? block : `${block}
+`;
+  if (start !== -1 && finish !== -1 && finish > start) {
+    const afterEnd = finish + end.length;
+    return `${content.slice(0, start)}${normalizedBlock}${content.slice(afterEnd).replace(/^\n+/, "")}`;
+  }
+  const prefix = content.trim().length > 0 ? `${content.trimEnd()}
+
+` : "";
+  return `${prefix}${normalizedBlock}`;
+}
+function removeManagedBlock(content, begin, end) {
+  const start = content.indexOf(begin);
+  const finish = content.indexOf(end);
+  if (start === -1 || finish === -1 || finish < start) {
+    return content;
+  }
+  const afterEnd = finish + end.length;
+  return `${content.slice(0, start).trimEnd()}${content.slice(afterEnd).replace(/^\n+/, "\n")}`.trimStart();
+}
+
+// src/core/threadroot-skill.ts
+var THREADROOT_SKILL_NAME = "threadroot";
+var THREADROOT_MANAGED_MARKER = "<!-- threadroot:managed skill -->";
+function threadrootSkillContent(provider, scope) {
+  const scopeLine = scope === "global" ? "This is a global machine-level skill. Use it only when the current repository contains `.threadroot/` or the user asks for Threadroot." : "This is a project-level skill for the current repository.";
+  return [
+    "---",
+    `name: ${THREADROOT_SKILL_NAME}`,
+    "description: Use when a repository contains .threadroot/ or the user asks to initialize, inspect, repair, or use Threadroot harness context, skills, tools, memory, connections, or agent setup.",
+    "---",
+    "",
+    THREADROOT_MANAGED_MARKER,
+    "",
+    "# Threadroot Harness",
+    "",
+    scopeLine,
+    "",
+    "Threadroot keeps agent-facing project context in `.threadroot/` and exposes it through deterministic CLI commands. Keep broad context out of the chat until it is task-relevant.",
+    "",
+    "## Workflow",
+    "",
+    "1. If `threadroot --version` works, use `threadroot`. Otherwise use `npx --yes threadroot@latest` for one-off commands.",
+    "2. If `.threadroot/harness.yaml` is missing and the user wants setup, run `threadroot init` or `npx --yes threadroot@latest init`.",
+    "3. Before coding in a Threadroot repo, run `threadroot doctor` and resolve errors. Treat warnings as review items, not automatic blockers.",
+    '4. For the current task, run `threadroot context "<task>"` and use the returned skills, rules, tools, memory, and references before doing broad file reads.',
+    "5. Use `threadroot status` to inspect harness state and `threadroot diff` only when compiled adapter outputs are enabled.",
+    "6. Use `threadroot tools list`, `threadroot tools check`, and `threadroot run <tool>` for explicit local capabilities. Confirm risky tools when required.",
+    "7. Do not create provider-specific files unless the user asks. Use `threadroot expose <agent>` when native project skill shims are desired.",
+    "",
+    "## Useful Commands",
+    "",
+    "```bash",
+    "threadroot doctor",
+    "threadroot status",
+    'threadroot context "<task>"',
+    "threadroot skills list",
+    "threadroot tools list",
+    "threadroot packs list",
+    "```",
+    "",
+    "## Boundaries",
+    "",
+    "- `.threadroot/` is the source of truth.",
+    "- Keep generated or exposed provider files thin.",
+    "- Never store secrets in Threadroot. Connections should wrap locally authenticated CLIs.",
+    "- Inspect external skills, scripts, tools, and MCP servers before trusting them.",
+    "",
+    `Provider target: ${provider.label}.`,
+    ""
+  ].join("\n");
+}
+
+// src/core/setup.ts
+var CODEX_AGENTS_BEGIN = "<!-- threadroot:begin global-codex -->";
+var CODEX_AGENTS_END = "<!-- threadroot:end global-codex -->";
+var CODEX_MCP_BEGIN = "# threadroot:begin codex-mcp";
+var CODEX_MCP_END = "# threadroot:end codex-mcp";
+async function readMaybe(filePath) {
+  try {
+    return await readFile6(filePath, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return void 0;
+    }
+    throw error;
+  }
+}
+async function fileExists(filePath) {
+  try {
+    const info = await stat3(filePath);
+    return info.isFile();
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+function displayPath(home, filePath) {
+  const relative = path13.relative(home, filePath);
+  return relative && !relative.startsWith("..") ? path13.join("~", relative) : filePath;
+}
+function globalSkillPath(home, provider) {
+  return path13.join(home, provider.globalSkillDir, THREADROOT_SKILL_NAME, "SKILL.md");
+}
+function codexAgentsPath(home) {
+  return path13.join(home, ".codex", "AGENTS.md");
+}
+function codexConfigPath(home) {
+  return path13.join(home, ".codex", "config.toml");
+}
+function codexAgentsBlock() {
+  return [
+    CODEX_AGENTS_BEGIN,
+    "## Threadroot",
+    "",
+    "When a repository contains `.threadroot/`, treat it as the source of truth for agent harness context.",
+    'Before coding, prefer `threadroot doctor` and `threadroot context "<task>"` over broad, unfocused file reads.',
+    "Do not create provider-specific project files unless the user asks; use `threadroot expose <agent>` for that.",
+    CODEX_AGENTS_END,
+    ""
+  ].join("\n");
+}
+function codexMcpBlock() {
+  return [
+    CODEX_MCP_BEGIN,
+    "[mcp_servers.threadroot]",
+    'command = "threadroot"',
+    'args = ["mcp"]',
+    CODEX_MCP_END,
+    ""
+  ].join("\n");
+}
+async function setupGlobalSkill(home, provider, mode, force) {
+  const filePath = globalSkillPath(home, provider);
+  const shown = displayPath(home, filePath);
+  const desired = threadrootSkillContent(provider, "global");
+  const existing = await readMaybe(filePath);
+  if (mode === "check") {
+    if (existing === void 0) {
+      return { kind: "skill", agent: provider.id, label: provider.label, path: shown, status: "missing" };
+    }
+    return {
+      kind: "skill",
+      agent: provider.id,
+      label: provider.label,
+      path: shown,
+      status: existing === desired ? "unchanged" : "present",
+      message: existing === desired ? void 0 : "Existing global skill differs from the current Threadroot template."
+    };
+  }
+  if (mode === "undo") {
+    if (existing === void 0) {
+      return { kind: "skill", agent: provider.id, label: provider.label, path: shown, status: "missing" };
+    }
+    if (!existing.includes(THREADROOT_MANAGED_MARKER)) {
+      return {
+        kind: "skill",
+        agent: provider.id,
+        label: provider.label,
+        path: shown,
+        status: "skipped",
+        message: "Existing skill is not Threadroot-managed."
+      };
+    }
+    await rm(path13.dirname(filePath), { recursive: true, force: true });
+    return { kind: "skill", agent: provider.id, label: provider.label, path: shown, status: "removed" };
+  }
+  if (existing === desired) {
+    return { kind: "skill", agent: provider.id, label: provider.label, path: shown, status: "unchanged" };
+  }
+  if (existing !== void 0 && !existing.includes(THREADROOT_MANAGED_MARKER) && !force) {
+    return {
+      kind: "skill",
+      agent: provider.id,
+      label: provider.label,
+      path: shown,
+      status: "skipped",
+      message: "Existing skill is not Threadroot-managed. Re-run with --force to replace it."
+    };
+  }
+  const status = existing === void 0 ? "create" : "update";
+  if (mode === "dry-run") {
+    return { kind: "skill", agent: provider.id, label: provider.label, path: shown, status };
+  }
+  await mkdir5(path13.dirname(filePath), { recursive: true });
+  await writeFile5(filePath, desired, "utf8");
+  return { kind: "skill", agent: provider.id, label: provider.label, path: shown, status };
+}
+async function setupCodexAgents(home, mode) {
+  const filePath = codexAgentsPath(home);
+  const shown = displayPath(home, filePath);
+  const existing = await readMaybe(filePath) ?? "";
+  const desired = upsertManagedBlock(existing, codexAgentsBlock(), CODEX_AGENTS_BEGIN, CODEX_AGENTS_END);
+  if (mode === "check") {
+    return {
+      kind: "codex-agents",
+      agent: "codex",
+      label: "Codex global AGENTS.md",
+      path: shown,
+      status: hasManagedBlock(existing, CODEX_AGENTS_BEGIN, CODEX_AGENTS_END) ? "present" : "missing"
+    };
+  }
+  if (mode === "undo") {
+    if (!hasManagedBlock(existing, CODEX_AGENTS_BEGIN, CODEX_AGENTS_END)) {
+      return { kind: "codex-agents", agent: "codex", label: "Codex global AGENTS.md", path: shown, status: "missing" };
+    }
+    await writeFile5(filePath, removeManagedBlock(existing, CODEX_AGENTS_BEGIN, CODEX_AGENTS_END), "utf8");
+    return { kind: "codex-agents", agent: "codex", label: "Codex global AGENTS.md", path: shown, status: "removed" };
+  }
+  if (existing === desired) {
+    return { kind: "codex-agents", agent: "codex", label: "Codex global AGENTS.md", path: shown, status: "unchanged" };
+  }
+  const status = existing.trim() ? "update" : "create";
+  if (mode === "dry-run") {
+    return { kind: "codex-agents", agent: "codex", label: "Codex global AGENTS.md", path: shown, status };
+  }
+  await mkdir5(path13.dirname(filePath), { recursive: true });
+  await writeFile5(filePath, desired, "utf8");
+  return { kind: "codex-agents", agent: "codex", label: "Codex global AGENTS.md", path: shown, status };
+}
+async function setupCodexMcp(home, mode) {
+  const filePath = codexConfigPath(home);
+  const shown = displayPath(home, filePath);
+  const existing = await readMaybe(filePath) ?? "";
+  if (existing.includes("[mcp_servers.threadroot]") && !hasManagedBlock(existing, CODEX_MCP_BEGIN, CODEX_MCP_END)) {
+    return {
+      kind: "codex-mcp",
+      agent: "codex",
+      label: "Codex MCP config",
+      path: shown,
+      status: "skipped",
+      message: "Existing unmanaged [mcp_servers.threadroot] table found. Leaving it untouched."
+    };
+  }
+  const desired = upsertManagedBlock(existing, codexMcpBlock(), CODEX_MCP_BEGIN, CODEX_MCP_END);
+  if (mode === "check") {
+    return {
+      kind: "codex-mcp",
+      agent: "codex",
+      label: "Codex MCP config",
+      path: shown,
+      status: hasManagedBlock(existing, CODEX_MCP_BEGIN, CODEX_MCP_END) ? "present" : "missing"
+    };
+  }
+  if (mode === "undo") {
+    if (!hasManagedBlock(existing, CODEX_MCP_BEGIN, CODEX_MCP_END)) {
+      return { kind: "codex-mcp", agent: "codex", label: "Codex MCP config", path: shown, status: "missing" };
+    }
+    await writeFile5(filePath, removeManagedBlock(existing, CODEX_MCP_BEGIN, CODEX_MCP_END), "utf8");
+    return { kind: "codex-mcp", agent: "codex", label: "Codex MCP config", path: shown, status: "removed" };
+  }
+  if (existing === desired) {
+    return { kind: "codex-mcp", agent: "codex", label: "Codex MCP config", path: shown, status: "unchanged" };
+  }
+  const status = existing.trim() ? "update" : "create";
+  if (mode === "dry-run") {
+    return { kind: "codex-mcp", agent: "codex", label: "Codex MCP config", path: shown, status };
+  }
+  await mkdir5(path13.dirname(filePath), { recursive: true });
+  await writeFile5(filePath, desired, "utf8");
+  return { kind: "codex-mcp", agent: "codex", label: "Codex MCP config", path: shown, status };
+}
+async function setupGlobal(options = {}) {
+  const home = options.home ?? homedir();
+  const mode = options.mode ?? "write";
+  const providerIds = parseAgentProviderList(options.agents, "all");
+  const entries = [];
+  for (const id of providerIds) {
+    entries.push(await setupGlobalSkill(home, AGENT_PROVIDERS[id], mode, options.force ?? false));
+  }
+  if (providerIds.includes("codex")) {
+    entries.push(await setupCodexAgents(home, mode));
+    if (options.mcp) {
+      entries.push(await setupCodexMcp(home, mode));
+    }
+  }
+  return { entries };
+}
+async function hasGlobalThreadrootSkill(home, agent) {
+  return fileExists(globalSkillPath(home ?? homedir(), AGENT_PROVIDERS[agent]));
+}
+
 // src/core/tools/authorize.ts
 function authorizeTool(tool, options) {
   const trusted = options.trusted ?? true;
@@ -1834,8 +2235,8 @@ function inputEnv(values) {
 }
 
 // src/core/tools/create.ts
-import { mkdir as mkdir5, writeFile as writeFile5 } from "fs/promises";
-import path12 from "path";
+import { mkdir as mkdir6, writeFile as writeFile6 } from "fs/promises";
+import path14 from "path";
 import { stringify as stringifyYaml3 } from "yaml";
 var ToolCreateError = class extends Error {
   constructor(message) {
@@ -1852,7 +2253,7 @@ function assertSafeName(name) {
   }
 }
 function assertSafeScript(script) {
-  if (path12.isAbsolute(script) || script.split(/[\\/]/).includes("..")) {
+  if (path14.isAbsolute(script) || script.split(/[\\/]/).includes("..")) {
     throw new ToolCreateError(`Script path must be inside the harness directory: ${script}`);
   }
 }
@@ -1881,9 +2282,9 @@ async function createTool(repoRoot, input2, options) {
     throw new ToolCreateError(`Invalid tool definition: ${detail}`);
   }
   const dir = scope === "project" ? projectObjectDir(repoRoot, "tools") : userObjectDir("tools", options.home);
-  const filePath = path12.join(dir, `${input2.name}.yaml`);
-  await mkdir5(dir, { recursive: true });
-  await writeFile5(filePath, stringifyYaml3(parsed.data), { encoding: "utf8", flag: options.force ? "w" : "wx" }).catch(
+  const filePath = path14.join(dir, `${input2.name}.yaml`);
+  await mkdir6(dir, { recursive: true });
+  await writeFile6(filePath, stringifyYaml3(parsed.data), { encoding: "utf8", flag: options.force ? "w" : "wx" }).catch(
     (error) => {
       if (error.code === "EEXIST") {
         throw new ToolCreateError(`Tool \`${input2.name}\` already exists at ${filePath}. Pass force to overwrite.`);
@@ -1895,8 +2296,8 @@ async function createTool(repoRoot, input2, options) {
 }
 
 // src/core/tools/catalog.ts
-import { readFile as readFile6, stat as stat3 } from "fs/promises";
-import path13 from "path";
+import { readFile as readFile7, stat as stat4 } from "fs/promises";
+import path15 from "path";
 var NAME_RE3 = /^[a-z0-9][a-z0-9-]*$/;
 var DESTRUCTIVE_RE = /\b(migrate|deploy|publish|release|prune|reset|destroy|drop|delete|rm|push|seed|wipe)\b/i;
 function looksDestructive(name, command) {
@@ -1908,20 +2309,20 @@ function sanitize(name) {
 }
 async function exists2(file) {
   try {
-    await stat3(file);
+    await stat4(file);
     return true;
   } catch {
     return false;
   }
 }
 async function detectPackageManager(repoRoot) {
-  if (await exists2(path13.join(repoRoot, "pnpm-lock.yaml"))) {
+  if (await exists2(path15.join(repoRoot, "pnpm-lock.yaml"))) {
     return "pnpm";
   }
-  if (await exists2(path13.join(repoRoot, "yarn.lock"))) {
+  if (await exists2(path15.join(repoRoot, "yarn.lock"))) {
     return "yarn";
   }
-  if (await exists2(path13.join(repoRoot, "bun.lockb"))) {
+  if (await exists2(path15.join(repoRoot, "bun.lockb"))) {
     return "bun";
   }
   return "npm";
@@ -1942,10 +2343,10 @@ function orderScripts(names) {
   });
 }
 async function fromPackageJson(repoRoot) {
-  const file = path13.join(repoRoot, "package.json");
+  const file = path15.join(repoRoot, "package.json");
   let raw;
   try {
-    raw = await readFile6(file, "utf8");
+    raw = await readFile7(file, "utf8");
   } catch {
     return [];
   }
@@ -1979,7 +2380,7 @@ async function fromPackageJson(repoRoot) {
 async function fromTargets(repoRoot, fileName, runner, source) {
   let raw;
   try {
-    raw = await readFile6(path13.join(repoRoot, fileName), "utf8");
+    raw = await readFile7(path15.join(repoRoot, fileName), "utf8");
   } catch {
     return [];
   }
@@ -2145,7 +2546,7 @@ async function checkToolHealth(repoRoot, tool) {
 // src/core/doctor.ts
 async function exists3(filePath) {
   try {
-    await stat4(filePath);
+    await stat5(filePath);
     return true;
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -2157,17 +2558,29 @@ async function exists3(filePath) {
 function finding2(severity, code, message, pathValue) {
   return pathValue ? { severity, code, message, path: pathValue } : { severity, code, message };
 }
-async function mcpConfigWarnings(repoRoot) {
+async function mcpConfigHints(repoRoot) {
   const configs = [".vscode/mcp.json", ".cursor/mcp.json", ".mcp.json"];
-  const present = await Promise.all(configs.map((config) => exists3(path14.join(repoRoot, config))));
+  const present = await Promise.all(configs.map((config) => exists3(path16.join(repoRoot, config))));
   if (present.some(Boolean)) {
     return [];
   }
   return [
     finding2(
-      "warning",
+      "info",
       "mcp_config_missing",
-      "No project-local MCP config found. Run `threadroot mcp setup --write` if this repo should expose Threadroot tools to local agents."
+      "No project-local MCP config found. This is fine for local-only harnesses; run `threadroot mcp setup --write` only when this repo should expose MCP tools to local agents."
+    )
+  ];
+}
+async function globalSetupHints(home) {
+  if (await hasGlobalThreadrootSkill(home, "codex")) {
+    return [];
+  }
+  return [
+    finding2(
+      "info",
+      "global_setup_missing",
+      "Codex global Threadroot setup was not detected. Run `threadroot setup --global --agent codex` for one-time machine setup."
     )
   ];
 }
@@ -2321,7 +2734,7 @@ async function doctor(repoRoot, options = {}) {
         )
       );
     }
-    const scriptsDir = path14.join(path14.dirname(skill.sourcePath), "scripts");
+    const scriptsDir = path16.join(path16.dirname(skill.sourcePath), "scripts");
     if (await exists3(scriptsDir)) {
       findings.push(
         finding2(
@@ -2333,25 +2746,35 @@ async function doctor(repoRoot, options = {}) {
       );
     }
   }
-  findings.push(...await mcpConfigWarnings(repoRoot));
+  findings.push(...await globalSetupHints(options.home));
+  findings.push(...await mcpConfigHints(repoRoot));
   return summarize(findings);
 }
 function summarize(findings) {
   const errors = findings.filter((entry) => entry.severity === "error").length;
   const warnings = findings.filter((entry) => entry.severity === "warning").length;
-  return { ok: errors === 0, findings, summary: { errors, warnings } };
+  const info = findings.filter((entry) => entry.severity === "info").length;
+  return { ok: errors === 0, findings, summary: { errors, warnings, info } };
 }
 
 // src/commands/doctor.ts
 async function runDoctor(repoRoot) {
   const report = await doctor(repoRoot);
-  if (report.findings.length === 0) {
+  const actionable = report.findings.filter((finding3) => finding3.severity !== "info");
+  const hints = report.findings.filter((finding3) => finding3.severity === "info");
+  if (actionable.length === 0) {
     console.log("Threadroot doctor: clean");
+    for (const finding3 of hints) {
+      const suffix = finding3.path ? ` (${finding3.path})` : "";
+      console.log(`- hint ${finding3.code}: ${finding3.message}${suffix}`);
+    }
     return;
   }
-  console.log(`Threadroot doctor: ${report.summary.errors} error(s), ${report.summary.warnings} warning(s)`);
+  console.log(
+    `Threadroot doctor: ${report.summary.errors} error(s), ${report.summary.warnings} warning(s)`
+  );
   for (const finding3 of report.findings) {
-    const label = finding3.severity === "error" ? "error" : "warning";
+    const label = finding3.severity === "error" ? "error" : finding3.severity === "warning" ? "warning" : "hint";
     const suffix = finding3.path ? ` (${finding3.path})` : "";
     console.log(`- ${label} ${finding3.code}: ${finding3.message}${suffix}`);
   }
@@ -2360,13 +2783,117 @@ async function runDoctor(repoRoot) {
   }
 }
 
+// src/core/expose.ts
+import { mkdir as mkdir7, readFile as readFile8, rm as rm2, stat as stat6, writeFile as writeFile7 } from "fs/promises";
+import path17 from "path";
+async function readMaybe2(filePath) {
+  try {
+    return await readFile8(filePath, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return void 0;
+    }
+    throw error;
+  }
+}
+function projectSkillPath(repoRoot, provider) {
+  return path17.join(repoRoot, provider.projectSkillDir, THREADROOT_SKILL_NAME, "SKILL.md");
+}
+function relSkillPath(provider) {
+  return path17.join(provider.projectSkillDir, THREADROOT_SKILL_NAME, "SKILL.md");
+}
+async function exposeOne(repoRoot, provider, mode, force) {
+  const relativePath = relSkillPath(provider);
+  const absolutePath = projectSkillPath(repoRoot, provider);
+  const desired = threadrootSkillContent(provider, "project");
+  const existing = await readMaybe2(absolutePath);
+  if (mode === "check") {
+    if (existing === void 0) {
+      return { agent: provider.id, label: provider.label, path: relativePath, status: "missing" };
+    }
+    return {
+      agent: provider.id,
+      label: provider.label,
+      path: relativePath,
+      status: existing === desired ? "unchanged" : "present",
+      message: existing === desired ? void 0 : "Existing project skill differs from the current Threadroot template."
+    };
+  }
+  if (mode === "undo") {
+    if (existing === void 0) {
+      return { agent: provider.id, label: provider.label, path: relativePath, status: "missing" };
+    }
+    if (!existing.includes(THREADROOT_MANAGED_MARKER)) {
+      return {
+        agent: provider.id,
+        label: provider.label,
+        path: relativePath,
+        status: "skipped",
+        message: "Existing skill is not Threadroot-managed."
+      };
+    }
+    await rm2(path17.dirname(absolutePath), { recursive: true, force: true });
+    return { agent: provider.id, label: provider.label, path: relativePath, status: "removed" };
+  }
+  if (existing === desired) {
+    return { agent: provider.id, label: provider.label, path: relativePath, status: "unchanged" };
+  }
+  if (existing !== void 0 && !existing.includes(THREADROOT_MANAGED_MARKER) && !force) {
+    return {
+      agent: provider.id,
+      label: provider.label,
+      path: relativePath,
+      status: "skipped",
+      message: "Existing skill is not Threadroot-managed. Re-run with --force to replace it."
+    };
+  }
+  const status = existing === void 0 ? "create" : "update";
+  if (mode === "dry-run") {
+    return { agent: provider.id, label: provider.label, path: relativePath, status };
+  }
+  await mkdir7(path17.dirname(absolutePath), { recursive: true });
+  await writeFile7(absolutePath, desired, "utf8");
+  return { agent: provider.id, label: provider.label, path: relativePath, status };
+}
+async function exposeProject(repoRoot, options = {}) {
+  const providerIds = parseAgentProviderList(options.agents, ["codex"]);
+  const mode = options.mode ?? "write";
+  const entries = [];
+  for (const id of providerIds) {
+    entries.push(await exposeOne(repoRoot, AGENT_PROVIDERS[id], mode, options.force ?? false));
+  }
+  return { entries };
+}
+
+// src/commands/expose.ts
+function modeFromOptions(options) {
+  if (options.undo) return "undo";
+  if (options.check) return "check";
+  if (options.dryRun) return "dry-run";
+  return "write";
+}
+async function runExpose(repoRoot, agent, options) {
+  const mode = modeFromOptions(options);
+  const result = await exposeProject(repoRoot, {
+    agents: agent,
+    mode,
+    force: options.force
+  });
+  const verb = mode === "dry-run" ? "Project exposure plan" : mode === "check" ? "Project exposure check" : mode === "undo" ? "Removed project exposure" : "Exposed Threadroot project skills";
+  console.log(`${verb}:`);
+  for (const entry of result.entries) {
+    const suffix = entry.message ? ` - ${entry.message}` : "";
+    console.log(`- ${entry.label}: ${entry.status} ${entry.path}${suffix}`);
+  }
+}
+
 // src/core/init/index.ts
-import { mkdir as mkdir7, stat as stat6, writeFile as writeFile6 } from "fs/promises";
-import path19 from "path";
+import { mkdir as mkdir9, stat as stat8, writeFile as writeFile8 } from "fs/promises";
+import path22 from "path";
 
 // src/core/scan/package.ts
 import fs2 from "fs/promises";
-import path15 from "path";
+import path18 from "path";
 
 // src/core/scan/rules.ts
 var ignoredDirectories = /* @__PURE__ */ new Set([
@@ -2384,13 +2911,13 @@ var ignoredDirectories = /* @__PURE__ */ new Set([
 // src/core/scan/package.ts
 async function readJson(repoRoot, relativePath) {
   try {
-    return JSON.parse(await fs2.readFile(path15.join(repoRoot, relativePath), "utf8"));
+    return JSON.parse(await fs2.readFile(path18.join(repoRoot, relativePath), "utf8"));
   } catch {
     return void 0;
   }
 }
 function inferProfile(files, packageJson) {
-  if (files.some((file) => path15.basename(file) === "dbt_project.yml" || path15.basename(file) === "dbt_project.yaml")) {
+  if (files.some((file) => path18.basename(file) === "dbt_project.yml" || path18.basename(file) === "dbt_project.yaml")) {
     return "dbt";
   }
   const packageMeta = packageJson && typeof packageJson === "object" ? packageJson : void 0;
@@ -2415,9 +2942,9 @@ function inferProfile(files, packageJson) {
 
 // src/core/scan/walk.ts
 import fs3 from "fs/promises";
-import path16 from "path";
+import path19 from "path";
 function toPosix(relativePath) {
-  return relativePath.split(path16.sep).join("/");
+  return relativePath.split(path19.sep).join("/");
 }
 async function walkRepo(repoRoot, directory = repoRoot) {
   let entries;
@@ -2428,8 +2955,8 @@ async function walkRepo(repoRoot, directory = repoRoot) {
   }
   const files = [];
   for (const entry of entries) {
-    const absolutePath = path16.join(directory, entry.name);
-    const relativePath = toPosix(path16.relative(repoRoot, absolutePath));
+    const absolutePath = path19.join(directory, entry.name);
+    const relativePath = toPosix(path19.relative(repoRoot, absolutePath));
     if (entry.isDirectory()) {
       if (!ignoredDirectories.has(entry.name)) {
         files.push(...await walkRepo(repoRoot, absolutePath));
@@ -2447,17 +2974,17 @@ async function walkRepo(repoRoot, directory = repoRoot) {
 import { stringify as stringifyYaml4 } from "yaml";
 
 // src/core/init/builtins.ts
-import { cp, mkdir as mkdir6, readdir as readdir3, stat as stat5 } from "fs/promises";
-import path17 from "path";
+import { cp, mkdir as mkdir8, readdir as readdir3, stat as stat7 } from "fs/promises";
+import path20 from "path";
 import { fileURLToPath } from "url";
-var DIST_DIR = path17.dirname(fileURLToPath(import.meta.url));
-var PACKAGE_ROOT_FROM_BUNDLE = path17.resolve(DIST_DIR, "..");
-var PACKAGE_ROOT_FROM_DIST = path17.resolve(DIST_DIR, "../../..");
-var PACKAGE_ROOT_FROM_SRC = path17.resolve(DIST_DIR, "../../../..");
+var DIST_DIR = path20.dirname(fileURLToPath(import.meta.url));
+var PACKAGE_ROOT_FROM_BUNDLE = path20.resolve(DIST_DIR, "..");
+var PACKAGE_ROOT_FROM_DIST = path20.resolve(DIST_DIR, "../../..");
+var PACKAGE_ROOT_FROM_SRC = path20.resolve(DIST_DIR, "../../../..");
 var SKILL_PACK_CANDIDATES = [
-  path17.join(PACKAGE_ROOT_FROM_BUNDLE, "skills"),
-  path17.join(PACKAGE_ROOT_FROM_DIST, "skills"),
-  path17.join(PACKAGE_ROOT_FROM_SRC, "skills")
+  path20.join(PACKAGE_ROOT_FROM_BUNDLE, "skills"),
+  path20.join(PACKAGE_ROOT_FROM_DIST, "skills"),
+  path20.join(PACKAGE_ROOT_FROM_SRC, "skills")
 ];
 var PROJECT_MEMORY_TEMPLATE = [
   "# Project",
@@ -2470,7 +2997,7 @@ var PROJECT_MEMORY_TEMPLATE = [
 ].join("\n");
 async function exists4(target) {
   try {
-    const info = await stat5(target);
+    const info = await stat7(target);
     return info.isDirectory();
   } catch {
     return false;
@@ -2487,20 +3014,20 @@ async function bundledSkillsDir() {
 async function writeBuiltinSkills(repoRoot) {
   const sourceDir = await bundledSkillsDir();
   const targetDir = projectObjectDir(repoRoot, "skills");
-  await mkdir6(targetDir, { recursive: true });
+  await mkdir8(targetDir, { recursive: true });
   const written = [];
   const entries = await readdir3(sourceDir, { withFileTypes: true });
   for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
     if (!entry.isDirectory()) {
       continue;
     }
-    const sourceSkill = path17.join(sourceDir, entry.name);
-    const sourceSkillFile = path17.join(sourceSkill, "SKILL.md");
-    if (!await exists4(sourceSkill) || !await stat5(sourceSkillFile).then((info) => info.isFile()).catch(() => false)) {
+    const sourceSkill = path20.join(sourceDir, entry.name);
+    const sourceSkillFile = path20.join(sourceSkill, "SKILL.md");
+    if (!await exists4(sourceSkill) || !await stat7(sourceSkillFile).then((info) => info.isFile()).catch(() => false)) {
       continue;
     }
-    const targetSkill = path17.join(targetDir, entry.name);
-    const targetSkillFile = path17.join(targetSkill, "SKILL.md");
+    const targetSkill = path20.join(targetDir, entry.name);
+    const targetSkillFile = path20.join(targetSkill, "SKILL.md");
     try {
       await cp(sourceSkill, targetSkill, { recursive: true, force: false, errorOnExist: true });
       written.push(targetSkillFile);
@@ -2514,14 +3041,14 @@ async function writeBuiltinSkills(repoRoot) {
 }
 
 // src/core/init/import.ts
-import { readFile as readFile7, readdir as readdir4 } from "fs/promises";
-import path18 from "path";
+import { readFile as readFile9, readdir as readdir4 } from "fs/promises";
+import path21 from "path";
 var PROSE_PRECEDENCE = ["AGENTS.md", "CLAUDE.md", ".github/copilot-instructions.md"];
 var CURSOR_RULES_DIR = ".cursor/rules";
 var NAME_RE4 = /^[a-z0-9][a-z0-9-]*$/;
 async function readIfExists3(filePath) {
   try {
-    return await readFile7(filePath, "utf8");
+    return await readFile9(filePath, "utf8");
   } catch (error) {
     if (error.code === "ENOENT") {
       return void 0;
@@ -2565,7 +3092,7 @@ function novelSections(canonical, other) {
   });
 }
 async function listCursorRules(repoRoot) {
-  const dir = path18.join(repoRoot, CURSOR_RULES_DIR);
+  const dir = path21.join(repoRoot, CURSOR_RULES_DIR);
   let entries;
   try {
     entries = await readdir4(dir);
@@ -2579,7 +3106,7 @@ async function listCursorRules(repoRoot) {
   return Promise.all(
     files.map(async (name) => ({
       file: `${CURSOR_RULES_DIR}/${name}`,
-      content: await readFile7(path18.join(dir, name), "utf8")
+      content: await readFile9(path21.join(dir, name), "utf8")
     }))
   );
 }
@@ -2594,7 +3121,7 @@ function globsToApplyTo(value) {
   return void 0;
 }
 function ruleName(fileName) {
-  const base = path18.basename(fileName, ".mdc").toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "");
+  const base = path21.basename(fileName, ".mdc").toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "");
   return NAME_RE4.test(base) ? base : "imported-rule";
 }
 async function importVendorFiles(repoRoot, options = {}) {
@@ -2605,7 +3132,7 @@ async function importVendorFiles(repoRoot, options = {}) {
     if (!wanted(file)) {
       continue;
     }
-    const content = await readIfExists3(path18.join(repoRoot, file));
+    const content = await readIfExists3(path21.join(repoRoot, file));
     if (content && content.trim()) {
       prose.push({ file, content });
     }
@@ -2650,7 +3177,7 @@ ${novel.map((section) => section.text).join("\n\n")}`.trim();
 }
 
 // src/core/init/index.ts
-var DEFAULT_ADAPTERS = ["agents", "claude", "copilot", "cursor"];
+var DEFAULT_ADAPTERS = [];
 var AGENTS_FILE2 = "AGENTS.md";
 var InitError = class extends Error {
   constructor(message) {
@@ -2660,7 +3187,7 @@ var InitError = class extends Error {
 };
 async function pathExists(target) {
   try {
-    await stat6(target);
+    await stat8(target);
     return true;
   } catch {
     return false;
@@ -2680,7 +3207,7 @@ async function detectName(repoRoot) {
   if (packageJson && typeof packageJson.name === "string" && packageJson.name.trim()) {
     return packageJson.name.trim();
   }
-  return path19.basename(repoRoot);
+  return path22.basename(repoRoot);
 }
 async function writeManifest(repoRoot, manifest) {
   const body = {
@@ -2692,15 +3219,15 @@ async function writeManifest(repoRoot, manifest) {
   if (manifest.tools.allow.length > 0) {
     body.tools = { allow: manifest.tools.allow };
   }
-  await mkdir7(projectHarnessDir(repoRoot), { recursive: true });
-  await writeFile6(projectManifestPath(repoRoot), stringifyYaml4(body), "utf8");
+  await mkdir9(projectHarnessDir(repoRoot), { recursive: true });
+  await writeFile8(projectManifestPath(repoRoot), stringifyYaml4(body), "utf8");
 }
 async function writeProjectMemory(repoRoot) {
   const dir = projectObjectDir(repoRoot, "memory");
-  await mkdir7(dir, { recursive: true });
-  const filePath = path19.join(dir, "project.md");
+  await mkdir9(dir, { recursive: true });
+  const filePath = path22.join(dir, "project.md");
   try {
-    await writeFile6(filePath, `${PROJECT_MEMORY_TEMPLATE}
+    await writeFile8(filePath, `${PROJECT_MEMORY_TEMPLATE}
 `, { encoding: "utf8", flag: "wx" });
     return [filePath];
   } catch (error) {
@@ -2715,16 +3242,16 @@ async function writeImportedRules(repoRoot, report) {
     return [];
   }
   const dir = projectObjectDir(repoRoot, "rules");
-  await mkdir7(dir, { recursive: true });
+  await mkdir9(dir, { recursive: true });
   const written = [];
   for (const rule of report.importedRules) {
-    const filePath = path19.join(dir, `${rule.name}.md`);
+    const filePath = path22.join(dir, `${rule.name}.md`);
     const data = { name: rule.name, scope: "project" };
     if (rule.applyTo) {
       data.applyTo = rule.applyTo;
     }
     try {
-      await writeFile6(filePath, serializeFrontmatter(data, rule.body), { encoding: "utf8", flag: "wx" });
+      await writeFile8(filePath, serializeFrontmatter(data, rule.body), { encoding: "utf8", flag: "wx" });
       written.push(filePath);
     } catch (error) {
       if (error.code !== "EEXIST") {
@@ -2763,7 +3290,7 @@ async function writeStarterTools(repoRoot, profile, force) {
 async function initHarness(repoRoot, options = {}) {
   if (!options.force && await pathExists(projectManifestPath(repoRoot))) {
     throw new InitError(
-      `A harness already exists at ${path19.join(".threadroot", "harness.yaml")}. Re-run with --force to overwrite.`
+      `A harness already exists at ${path22.join(".threadroot", "harness.yaml")}. Re-run with --force to overwrite.`
     );
   }
   const profile = await detectProfile(repoRoot, options.profile);
@@ -2785,13 +3312,14 @@ async function initHarness(repoRoot, options = {}) {
   if (options.import !== false) {
     report = await importVendorFiles(repoRoot, { include: options.importFiles });
     if (report.canonicalBody.trim()) {
-      await writeFile6(path19.join(repoRoot, AGENTS_FILE2), `${report.canonicalBody.trim()}
+      await writeFile8(path22.join(repoRoot, AGENTS_FILE2), `${report.canonicalBody.trim()}
 `, "utf8");
     }
     rules = await writeImportedRules(repoRoot, report);
   }
   const { written } = await runCompile(repoRoot, { home: options.home });
-  return { name, profile, adapters, skills, tools: tools2, memory, rules, import: report, compiled: written };
+  const exposed = options.expose ? (await exposeProject(repoRoot, { agents: options.expose })).entries.filter((entry) => entry.status !== "missing" && entry.status !== "skipped").map((entry) => entry.path) : [];
+  return { name, profile, adapters, skills, tools: tools2, memory, rules, import: report, compiled: written, exposed };
 }
 
 // src/commands/init.ts
@@ -2806,12 +3334,13 @@ async function runInit(repoRoot, options) {
     force: options.force,
     import: options.import,
     profile: options.profile ? profileIdSchema.parse(options.profile) : void 0,
-    adapters: parseAdapters(options.adapters)
+    adapters: parseAdapters(options.adapters),
+    expose: options.expose
   };
   try {
     const report = await initHarness(repoRoot, initOptions);
     console.log(`Initialized harness \`${report.name}\` (profile: ${report.profile}).`);
-    console.log(`adapters: ${report.adapters.join(", ")}`);
+    console.log(`adapters: ${report.adapters.length > 0 ? report.adapters.join(", ") : "none (local-only)"}`);
     console.log(`skills: ${report.skills.length}, tools: ${report.tools.length}, memory: ${report.memory.length}`);
     if (report.import?.canonicalSource) {
       console.log(`imported canonical prose from ${report.import.canonicalSource}`);
@@ -2826,6 +3355,9 @@ async function runInit(repoRoot, options) {
       console.log(`imported ${report.rules.length} cursor rule(s)`);
     }
     console.log(`compiled ${report.compiled.length} vendor file(s).`);
+    if (report.exposed.length > 0) {
+      console.log(`exposed ${report.exposed.length} provider skill shim(s).`);
+    }
   } catch (error) {
     if (error instanceof InitError) {
       console.error(error.message);
@@ -2837,13 +3369,13 @@ async function runInit(repoRoot, options) {
 }
 
 // src/commands/install.ts
-import path22 from "path";
+import path25 from "path";
 
 // src/core/install/fetch.ts
 import { execFile } from "child_process";
-import { mkdtemp, rm } from "fs/promises";
+import { mkdtemp, rm as rm3 } from "fs/promises";
 import os2 from "os";
-import path20 from "path";
+import path23 from "path";
 import { promisify } from "util";
 var run = promisify(execFile);
 function cloneUrl(ref) {
@@ -2864,8 +3396,8 @@ async function git(cwd, args) {
 }
 async function fetchGitSource(ref) {
   const url = cloneUrl(ref);
-  const dir = await mkdtemp(path20.join(os2.tmpdir(), "threadroot-fetch-"));
-  const cleanup = () => rm(dir, { recursive: true, force: true });
+  const dir = await mkdtemp(path23.join(os2.tmpdir(), "threadroot-fetch-"));
+  const cleanup = () => rm3(dir, { recursive: true, force: true });
   try {
     if (ref.ref) {
       try {
@@ -2886,9 +3418,9 @@ async function fetchGitSource(ref) {
 }
 
 // src/core/install/install.ts
-import { cp as cp2, mkdir as mkdir8, readFile as readFile8, readdir as readdir5, stat as stat7, writeFile as writeFile7 } from "fs/promises";
+import { cp as cp2, mkdir as mkdir10, readFile as readFile10, readdir as readdir5, stat as stat9, writeFile as writeFile9 } from "fs/promises";
 import { createHash as createHash2 } from "crypto";
-import path21 from "path";
+import path24 from "path";
 var NAME_RE5 = /^[a-z0-9][a-z0-9-]*$/;
 var KIND_DIR = {
   skill: "skills",
@@ -2900,8 +3432,8 @@ function objectExt(kind) {
   return kind === "tool" || kind === "connection" ? ".yaml" : ".md";
 }
 function safeRepoPath(objectPath) {
-  const normalized = path21.normalize(objectPath);
-  if (path21.isAbsolute(normalized) || normalized === ".." || normalized.startsWith(`..${path21.sep}`)) {
+  const normalized = path24.normalize(objectPath);
+  if (path24.isAbsolute(normalized) || normalized === ".." || normalized.startsWith(`..${path24.sep}`)) {
     throw new Error(`Unsafe object path: ${objectPath}`);
   }
   return normalized;
@@ -2915,7 +3447,7 @@ function inferKind(objectPath, override) {
   if (segments.includes("tools")) return "tool";
   if (segments.includes("connections")) return "connection";
   if (segments.includes("rules")) return "rule";
-  const ext = path21.extname(objectPath).toLowerCase();
+  const ext = path24.extname(objectPath).toLowerCase();
   if (ext === ".yaml" || ext === ".yml") return "tool";
   if (ext === ".md") return "skill";
   throw new Error(
@@ -2923,7 +3455,7 @@ function inferKind(objectPath, override) {
   );
 }
 function deriveName(objectPath) {
-  const base = path21.basename(objectPath, path21.extname(objectPath));
+  const base = path24.basename(objectPath, path24.extname(objectPath));
   if (!NAME_RE5.test(base)) {
     throw new Error(`Invalid object name \`${base}\` (use lowercase letters, digits, and dashes).`);
   }
@@ -2935,8 +3467,8 @@ async function hashDirectory(root) {
   async function walk(dir) {
     const entries = (await readdir5(dir, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of entries) {
-      const full = path21.join(dir, entry.name);
-      const rel = path21.relative(root, full).split(path21.sep).join("/");
+      const full = path24.join(dir, entry.name);
+      const rel = path24.relative(root, full).split(path24.sep).join("/");
       if (entry.isSymbolicLink()) {
         throw new Error(`Refusing to install skill directory with symlink: ${rel}`);
       }
@@ -2947,7 +3479,7 @@ async function hashDirectory(root) {
       if (entry.isFile()) {
         hash.update(`file:${rel}
 `);
-        hash.update(await readFile8(full));
+        hash.update(await readFile10(full));
         hash.update("\n");
       }
     }
@@ -2956,8 +3488,8 @@ async function hashDirectory(root) {
   return hash.digest("hex");
 }
 async function validateSkillDirectory2(sourcePath, expectedName) {
-  const skillPath = path21.join(sourcePath, "SKILL.md");
-  const parsed = parseFrontmatter(await readFile8(skillPath, "utf8"));
+  const skillPath = path24.join(sourcePath, "SKILL.md");
+  const parsed = parseFrontmatter(await readFile10(skillPath, "utf8"));
   const result = skillFrontmatterSchema.safeParse(parsed.data);
   if (!result.success) {
     const detail = result.error.issues.map((issue) => issue.message).join("; ");
@@ -2986,7 +3518,7 @@ async function installObject(repoRoot, rawSource, options = {}) {
     objectPath = safeRepoPath(within);
     refLabel = ref.ref;
     const fetched = await fetchGitSource(ref);
-    sourcePath = path21.join(fetched.dir, objectPath);
+    sourcePath = path24.join(fetched.dir, objectPath);
     resolved = fetched.sha;
     cleanup = fetched.cleanup;
   } else {
@@ -3001,20 +3533,20 @@ async function installObject(repoRoot, rawSource, options = {}) {
     const destDir = scope === "user" ? userObjectDir(dirKey, options.home) : projectObjectDir(repoRoot, dirKey);
     let destPath;
     let integrity;
-    const info = await stat7(sourcePath);
+    const info = await stat9(sourcePath);
     if (info.isDirectory()) {
       if (kind !== "skill") {
         throw new Error("Only skill objects may be installed from a directory.");
       }
       integrity = `sha256:${await validateSkillDirectory2(sourcePath, name)}`;
-      destPath = path21.join(destDir, name);
-      await mkdir8(destDir, { recursive: true });
+      destPath = path24.join(destDir, name);
+      await mkdir10(destDir, { recursive: true });
       await cp2(sourcePath, destPath, { recursive: true, force: true });
     } else {
-      const content = await readFile8(sourcePath, "utf8");
-      destPath = path21.join(destDir, `${name}${objectExt(kind)}`);
-      await mkdir8(destDir, { recursive: true });
-      await writeFile7(destPath, content, "utf8");
+      const content = await readFile10(sourcePath, "utf8");
+      destPath = path24.join(destDir, `${name}${objectExt(kind)}`);
+      await mkdir10(destDir, { recursive: true });
+      await writeFile9(destPath, content, "utf8");
       integrity = `sha256:${hashContent(content)}`;
     }
     const entry = {
@@ -3066,7 +3598,7 @@ async function runInstall(repoRoot, source, options) {
     if (installed.kind === "skill" && installed.entry.sourceKind !== "local") {
       console.log("  note: inspect external skills before trusting bundled scripts, assets, or allowed tools.");
       if (scope === "project") {
-        console.log(`  inspect: threadroot skills inspect ${path22.relative(repoRoot, installed.path)}`);
+        console.log(`  inspect: threadroot skills inspect ${path25.relative(repoRoot, installed.path)}`);
       }
     }
   } catch (error) {
@@ -3390,7 +3922,7 @@ async function handleMessage(repoRoot, request) {
     if (request.method === "initialize") {
       return resultResponse(request, {
         protocolVersion: "2024-11-05",
-        serverInfo: { name: "threadroot", version: "0.1.0" },
+        serverInfo: { name: "threadroot", version: "0.1.1" },
         capabilities: { tools: {} }
       });
     }
@@ -3532,7 +4064,7 @@ Repository:
 ${repoRoot}
 
 Goal:
-Initialize Threadroot so this repo has portable AI-agent instructions, durable memory, curated skills, executable tools, and vendor-specific adapter files generated from one canonical harness.
+Initialize Threadroot so this repo has a portable AI-agent harness in one canonical \`.threadroot/\` directory.
 
 Rules:
 - Prefer deterministic CLI commands.
@@ -3545,9 +4077,9 @@ Steps:
 3. Run \`threadroot status\` to check whether a harness already exists.
 4. If no harness exists, run \`threadroot init\`. Use \`--no-import\` only when the user explicitly wants a blank-slate harness.
 5. Run \`threadroot status\` again.
-6. If status reports drift, run \`threadroot diff\` and summarize the drift before changing generated files.
+6. If the user asks for provider-native project skill files, run \`threadroot expose <agent>\` or \`threadroot expose all\`.
 7. Run \`threadroot context "current task"\` with the user's actual task to find relevant skills, rules, tools, and memory.
-8. If project-local MCP config is useful, run \`threadroot mcp setup --write\` and tell the user to reload their agent surface.
+8. If project-local MCP config is useful, ask before running \`threadroot mcp setup --write\`, then tell the user to reload their agent surface.
 
 Final response:
 Say exactly:
@@ -3614,11 +4146,11 @@ function agentNotes(agent) {
 }
 
 // src/core/mcp-config.ts
-import { mkdir as mkdir9, readFile as readFile9, writeFile as writeFile8 } from "fs/promises";
-import path23 from "path";
+import { mkdir as mkdir11, readFile as readFile11, writeFile as writeFile10 } from "fs/promises";
+import path26 from "path";
 var TARGETS = [
-  { agent: "copilot", file: path23.join(".vscode", "mcp.json"), key: "servers" },
-  { agent: "cursor", file: path23.join(".cursor", "mcp.json"), key: "mcpServers" },
+  { agent: "copilot", file: path26.join(".vscode", "mcp.json"), key: "servers" },
+  { agent: "cursor", file: path26.join(".cursor", "mcp.json"), key: "mcpServers" },
   { agent: "claude", file: ".mcp.json", key: "mcpServers" }
 ];
 function mcpServerEntry(command, scriptPath) {
@@ -3627,7 +4159,7 @@ function mcpServerEntry(command, scriptPath) {
 async function mergeConfig(filePath, key, entry) {
   let config = {};
   try {
-    const raw = await readFile9(filePath, "utf8");
+    const raw = await readFile11(filePath, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object") {
       config = parsed;
@@ -3640,8 +4172,8 @@ async function mergeConfig(filePath, key, entry) {
   const servers = config[key] && typeof config[key] === "object" ? config[key] : {};
   servers.threadroot = { ...entry };
   config[key] = servers;
-  await mkdir9(path23.dirname(filePath), { recursive: true });
-  await writeFile8(filePath, `${JSON.stringify(config, null, 2)}
+  await mkdir11(path26.dirname(filePath), { recursive: true });
+  await writeFile10(filePath, `${JSON.stringify(config, null, 2)}
 `, "utf8");
 }
 async function writeProjectMcpConfigs(input2) {
@@ -3649,7 +4181,7 @@ async function writeProjectMcpConfigs(input2) {
   const targets = agents ? TARGETS.filter((target) => agents.includes(target.agent)) : TARGETS;
   const written = [];
   for (const target of targets) {
-    const filePath = path23.join(input2.repoRoot, target.file);
+    const filePath = path26.join(input2.repoRoot, target.file);
     await mergeConfig(filePath, target.key, input2.entry);
     written.push(target.file);
   }
@@ -3751,6 +4283,37 @@ async function runSkillsInspect(repoRoot, targetPath) {
   }
 }
 
+// src/commands/setup.ts
+function modeFromOptions2(options) {
+  if (options.undo) return "undo";
+  if (options.check) return "check";
+  if (options.dryRun) return "dry-run";
+  return "write";
+}
+async function runSetup(_repoRoot, options) {
+  if (!options.global) {
+    console.error("Only global setup is supported right now. Run `threadroot setup --global`.");
+    process.exitCode = 1;
+    return;
+  }
+  const mode = modeFromOptions2(options);
+  const result = await setupGlobal({
+    agents: options.agent,
+    mode,
+    force: options.force,
+    mcp: options.mcp
+  });
+  const title = mode === "dry-run" ? "Global setup plan" : mode === "check" ? "Global setup check" : mode === "undo" ? "Global setup undo" : "Global setup complete";
+  console.log(`${title}:`);
+  for (const entry of result.entries) {
+    const suffix = entry.message ? ` - ${entry.message}` : "";
+    console.log(`- ${entry.label}: ${entry.status} ${entry.path}${suffix}`);
+  }
+  if (mode === "write") {
+    console.log("Reload or restart open agent sessions so new global skills/config are discovered.");
+  }
+}
+
 // src/commands/status.ts
 async function runStatus(repoRoot) {
   const status = await harnessStatus(repoRoot);
@@ -3759,7 +4322,7 @@ async function runStatus(repoRoot) {
     return;
   }
   console.log(`harness: ${status.manifest.name} (${status.manifest.profile})`);
-  console.log(`adapters: ${status.manifest.adapters.join(", ")}`);
+  console.log(`adapters: ${status.manifest.adapters.length > 0 ? status.manifest.adapters.join(", ") : "none (local-only)"}`);
   console.log(
     `objects: ${status.counts.skills} skills, ${status.counts.rules} rules, ${status.counts.tools} tools, ${status.counts.memory} memory`
   );
@@ -3775,8 +4338,8 @@ async function runStatus(repoRoot) {
 }
 
 // src/core/packs/index.ts
-import { cp as cp3, mkdir as mkdir10, readFile as readFile10, readdir as readdir6, stat as stat8 } from "fs/promises";
-import path24 from "path";
+import { cp as cp3, mkdir as mkdir12, readFile as readFile12, readdir as readdir6, stat as stat10 } from "fs/promises";
+import path27 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { parse as parseYaml3 } from "yaml";
 import { z as z5 } from "zod";
@@ -3789,18 +4352,18 @@ var packManifestSchema = z5.object({
   rules: z5.array(z5.string()).default([]),
   connections: z5.array(z5.string()).default([])
 });
-var DIST_DIR2 = path24.dirname(fileURLToPath2(import.meta.url));
-var PACKAGE_ROOT_FROM_BUNDLE2 = path24.resolve(DIST_DIR2, "..");
-var PACKAGE_ROOT_FROM_DIST2 = path24.resolve(DIST_DIR2, "../../..");
-var PACKAGE_ROOT_FROM_SRC2 = path24.resolve(DIST_DIR2, "../../../..");
+var DIST_DIR2 = path27.dirname(fileURLToPath2(import.meta.url));
+var PACKAGE_ROOT_FROM_BUNDLE2 = path27.resolve(DIST_DIR2, "..");
+var PACKAGE_ROOT_FROM_DIST2 = path27.resolve(DIST_DIR2, "../../..");
+var PACKAGE_ROOT_FROM_SRC2 = path27.resolve(DIST_DIR2, "../../../..");
 var PACK_CANDIDATES = [
-  path24.join(PACKAGE_ROOT_FROM_BUNDLE2, "packs"),
-  path24.join(PACKAGE_ROOT_FROM_DIST2, "packs"),
-  path24.join(PACKAGE_ROOT_FROM_SRC2, "packs")
+  path27.join(PACKAGE_ROOT_FROM_BUNDLE2, "packs"),
+  path27.join(PACKAGE_ROOT_FROM_DIST2, "packs"),
+  path27.join(PACKAGE_ROOT_FROM_SRC2, "packs")
 ];
 async function exists5(target) {
   try {
-    await stat8(target);
+    await stat10(target);
     return true;
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -3828,22 +4391,22 @@ async function isPackRoot(candidate) {
     return false;
   }
   for (const entry of entries) {
-    if (entry.isDirectory() && await exists5(path24.join(candidate, entry.name, "pack.yaml"))) {
+    if (entry.isDirectory() && await exists5(path27.join(candidate, entry.name, "pack.yaml"))) {
       return true;
     }
   }
   return false;
 }
 function safeRelative(ref) {
-  const normalized = path24.normalize(ref);
-  if (path24.isAbsolute(normalized) || normalized === ".." || normalized.startsWith(`..${path24.sep}`)) {
+  const normalized = path27.normalize(ref);
+  if (path27.isAbsolute(normalized) || normalized === ".." || normalized.startsWith(`..${path27.sep}`)) {
     throw new Error(`Unsafe pack reference: ${ref}`);
   }
   return normalized;
 }
 async function readPackManifest(packDir) {
-  const file = path24.join(packDir, "pack.yaml");
-  const parsed = packManifestSchema.safeParse(parseYaml3(await readFile10(file, "utf8")));
+  const file = path27.join(packDir, "pack.yaml");
+  const parsed = packManifestSchema.safeParse(parseYaml3(await readFile12(file, "utf8")));
   if (!parsed.success) {
     const detail = parsed.error.issues.map((issue) => issue.message).join("; ");
     throw new Error(`Invalid pack manifest ${file}: ${detail}`);
@@ -3851,7 +4414,7 @@ async function readPackManifest(packDir) {
   return parsed.data;
 }
 async function packDirFor(repoRoot, nameOrPath) {
-  if (path24.isAbsolute(nameOrPath)) {
+  if (path27.isAbsolute(nameOrPath)) {
     return nameOrPath;
   }
   if (nameOrPath.startsWith(".") || nameOrPath.includes("/") || nameOrPath.includes("\\")) {
@@ -3859,14 +4422,14 @@ async function packDirFor(repoRoot, nameOrPath) {
   }
   const bundled = await bundledPacksDir();
   if (bundled) {
-    return path24.join(bundled, nameOrPath);
+    return path27.join(bundled, nameOrPath);
   }
-  return toRepoPath(repoRoot, path24.join("packs", nameOrPath));
+  return toRepoPath(repoRoot, path27.join("packs", nameOrPath));
 }
 async function directFiles(dir, ext) {
   try {
     const entries = await readdir6(dir, { withFileTypes: true });
-    return entries.filter((entry) => entry.isFile() && entry.name.endsWith(ext)).map((entry) => path24.join(dir, entry.name)).sort();
+    return entries.filter((entry) => entry.isFile() && entry.name.endsWith(ext)).map((entry) => path27.join(dir, entry.name)).sort();
   } catch (error) {
     if (error.code === "ENOENT") {
       return [];
@@ -3879,11 +4442,11 @@ async function skillEntries(dir) {
     const entries = await readdir6(dir, { withFileTypes: true });
     const result = [];
     for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
-      const full = path24.join(dir, entry.name);
+      const full = path27.join(dir, entry.name);
       if (entry.isFile() && entry.name.endsWith(".md")) {
         result.push(full);
       }
-      if (entry.isDirectory() && await exists5(path24.join(full, "SKILL.md"))) {
+      if (entry.isDirectory() && await exists5(path27.join(full, "SKILL.md"))) {
         result.push(full);
       }
     }
@@ -3898,34 +4461,34 @@ async function skillEntries(dir) {
 async function collectObjects(packDir, manifest) {
   async function resolveRef(ref) {
     const safe = safeRelative(ref);
-    const local = path24.resolve(packDir, safe);
+    const local = path27.resolve(packDir, safe);
     if (await exists5(local)) {
       return local;
     }
-    return path24.resolve(packDir, "..", "..", safe);
+    return path27.resolve(packDir, "..", "..", safe);
   }
   return {
     skills: [
       ...await Promise.all(manifest.skills.map(resolveRef)),
-      ...await skillEntries(path24.join(packDir, "skills"))
+      ...await skillEntries(path27.join(packDir, "skills"))
     ],
     tools: [
       ...await Promise.all(manifest.tools.map(resolveRef)),
-      ...await directFiles(path24.join(packDir, "tools"), ".yaml")
+      ...await directFiles(path27.join(packDir, "tools"), ".yaml")
     ],
     rules: [
       ...await Promise.all(manifest.rules.map(resolveRef)),
-      ...await directFiles(path24.join(packDir, "rules"), ".md")
+      ...await directFiles(path27.join(packDir, "rules"), ".md")
     ],
     connections: [
       ...await Promise.all(manifest.connections.map(resolveRef)),
-      ...await directFiles(path24.join(packDir, "connections"), ".yaml")
+      ...await directFiles(path27.join(packDir, "connections"), ".yaml")
     ]
   };
 }
 function baseName(source) {
-  const parsed = path24.basename(source) === "SKILL.md" ? path24.dirname(source) : source;
-  return path24.basename(parsed, path24.extname(parsed));
+  const parsed = path27.basename(source) === "SKILL.md" ? path27.dirname(source) : source;
+  return path27.basename(parsed, path27.extname(parsed));
 }
 async function listPacks(repoRoot) {
   const dirs = [toRepoPath(repoRoot, "packs"), await bundledPacksDir()].filter((dir) => Boolean(dir));
@@ -3942,8 +4505,8 @@ async function listPacks(repoRoot) {
       if (!entry.isDirectory() || seen.has(entry.name)) {
         continue;
       }
-      const packDir = path24.join(root, entry.name);
-      if (!await exists5(path24.join(packDir, "pack.yaml"))) {
+      const packDir = path27.join(root, entry.name);
+      if (!await exists5(path27.join(packDir, "pack.yaml"))) {
         continue;
       }
       seen.add(entry.name);
@@ -3967,14 +4530,14 @@ async function inspectPack(repoRoot, nameOrPath) {
   };
 }
 async function validateProse(file, kind) {
-  const target = path24.basename(file) === "SKILL.md" ? file : file;
-  const content = await readFile10(target, "utf8");
+  const target = path27.basename(file) === "SKILL.md" ? file : file;
+  const content = await readFile12(target, "utf8");
   const parsed = parseFrontmatter(content);
   const schema = kind === "skill" ? skillFrontmatterSchema : ruleFrontmatterSchema;
   schema.parse(parsed.data);
 }
 async function validateYaml(file, kind) {
-  const content = await readFile10(file, "utf8");
+  const content = await readFile12(file, "utf8");
   const schema = kind === "tool" ? toolManifestSchema : connectionManifestSchema;
   schema.parse(parseYaml3(content));
 }
@@ -3985,7 +4548,7 @@ async function validatePack(repoRoot, nameOrPath) {
     const manifest = await readPackManifest(packDir);
     const objects = await collectObjects(packDir, manifest);
     for (const skill of objects.skills) {
-      await validateProse(path24.basename(skill) === "SKILL.md" ? skill : path24.join(skill, "SKILL.md"), "skill");
+      await validateProse(path27.basename(skill) === "SKILL.md" ? skill : path27.join(skill, "SKILL.md"), "skill");
     }
     for (const rule of objects.rules) await validateProse(rule, "rule");
     for (const tool of objects.tools) await validateYaml(tool, "tool");
@@ -3999,10 +4562,10 @@ async function validatePack(repoRoot, nameOrPath) {
   return { ok: !findings.some((finding3) => finding3.severity === "error"), findings };
 }
 async function copyObject(source, destDir) {
-  const info = await stat8(source);
+  const info = await stat10(source);
   const name = baseName(source);
-  const dest = info.isDirectory() ? path24.join(destDir, name) : path24.join(destDir, path24.basename(source));
-  await mkdir10(destDir, { recursive: true });
+  const dest = info.isDirectory() ? path27.join(destDir, name) : path27.join(destDir, path27.basename(source));
+  await mkdir12(destDir, { recursive: true });
   await cp3(source, dest, { recursive: true, force: true });
   return dest;
 }
@@ -4290,8 +4853,10 @@ async function runConnectionsCheck(repoRoot) {
 // src/cli.ts
 function createProgram(repoRoot = process.cwd()) {
   const program = new Command();
-  program.name("threadroot").description("Git for your AI agent harness: one canonical source, compiled to every vendor format.").version("0.1.0");
-  program.command("init").description("Scaffold a Threadroot harness, import existing vendor files once, and compile.").option("--force", "Re-initialize over an existing harness.").option("--no-import", "Skip importing existing vendor files (blank-slate init).").option("--profile <profile>", "Override the detected project profile.").option("--adapters <list>", "Comma-separated adapters: agents,claude,copilot,cursor.").action((options) => runInit(repoRoot, options));
+  program.name("threadroot").description("Git for your AI agent harness: one canonical .threadroot source, optional provider exposure.").version("0.1.1");
+  program.command("init").description("Scaffold a local-only Threadroot harness and import existing vendor files once.").option("--force", "Re-initialize over an existing harness.").option("--no-import", "Skip importing existing vendor files (blank-slate init).").option("--profile <profile>", "Override the detected project profile.").option("--adapters <list>", "Comma-separated adapters: agents,claude,copilot,cursor.").option("--expose <list>", "Comma-separated provider skill shims to write: codex,claude,cursor,copilot,gemini,windsurf,antigravity,opencode,all.").action((options) => runInit(repoRoot, options));
+  program.command("expose").argument("[agent]", "Provider(s) to expose: codex,claude,cursor,copilot,gemini,windsurf,antigravity,opencode,all.").option("--dry-run", "Show project files that would be written.").option("--check", "Check current project exposure state.").option("--undo", "Remove Threadroot-managed project exposure files.").option("--force", "Replace an existing unmanaged threadroot skill.").description("Write thin provider project skills that point agents at `.threadroot/`.").action((agent, options) => runExpose(repoRoot, agent, options));
+  program.command("setup").option("--global", "Install machine-level Threadroot agent bootstrap skills/config.").option("--agent <list>", "Provider(s): codex,claude,cursor,copilot,gemini,windsurf,antigravity,opencode,all.").option("--dry-run", "Show global files that would be written.").option("--check", "Check global Threadroot setup state.").option("--undo", "Remove Threadroot-managed global setup files/blocks.").option("--force", "Replace an existing unmanaged threadroot skill.").option("--mcp", "Also add Threadroot MCP to Codex global config when Codex is selected.").description("Set up Threadroot once per machine for supported coding agents.").action((options) => runSetup(repoRoot, options));
   program.command("status").description("Show harness state, object counts, and compiled-output drift.").action(() => runStatus(repoRoot));
   program.command("diff").description("Show the diff between the canonical harness and each compiled vendor file.").action(() => runDiff(repoRoot));
   program.command("doctor").description("Check harness validity, compiled output health, MCP hints, and tool trust.").action(() => runDoctor(repoRoot));