threadnote 1.1.2 → 1.1.4

package/dist/mcp_server.cjs

@@ -33081,7 +33081,6 @@ var StreamableHTTPClientTransport = class {
 
 // src/mcp_server.ts
 var import_promises5 = require("node:fs/promises");
-var import_node_os3 = require("node:os");
 var import_node_path5 = require("node:path");
 
 // src/constants.ts
@@ -35724,6 +35723,7 @@ var jsYaml = {
 // src/utils.ts
 var import_node_child_process = require("node:child_process");
 var import_node_crypto = require("node:crypto");
+var import_node_fs = require("node:fs");
 var import_promises = require("node:fs/promises");
 var import_node_os = require("node:os");
 var import_node_path = require("node:path");
@@ -35778,18 +35778,57 @@ function redactText(content) {
   ).replace(/Bearer\s+[A-Za-z0-9._~+/=-]+/gi, "Bearer [REDACTED]").replace(/sk-[A-Za-z0-9_-]{16,}/g, "sk-[REDACTED]").replace(/gh[pousr]_[A-Za-z0-9_]{16,}/g, "gh_[REDACTED]");
 }
 async function requiredOpenVikingCli() {
-  const command2 = await findExecutable(["ov", "openviking"]);
+  const command2 = await findOpenVikingCli();
   if (!command2) {
-    throw new Error("Neither ov nor openviking was found in PATH. Run threadnote install first.");
+    throw new Error(
+      "Neither ov nor openviking was found in PATH, uv tool bin dir, $UV_TOOL_BIN_DIR, or ~/.local/bin. Run threadnote install first."
+    );
   }
   return command2;
 }
 async function openVikingCliForMode(dryRun) {
   if (dryRun) {
-    return await findExecutable(["ov", "openviking"]) ?? "ov";
+    return await findOpenVikingCli() ?? "ov";
   }
   return requiredOpenVikingCli();
 }
+async function findOpenVikingCli() {
+  const override = process.env.THREADNOTE_OV?.trim();
+  if (override) {
+    return override;
+  }
+  const onPath = await findExecutable(["ov", "openviking"]);
+  if (onPath) {
+    return onPath;
+  }
+  for (const candidateDir of await openVikingToolCandidateDirs()) {
+    for (const command2 of ["ov", "openviking"]) {
+      const candidate = (0, import_node_path.join)(candidateDir, command2);
+      if (await isExecutable(candidate)) {
+        return candidate;
+      }
+    }
+  }
+  return void 0;
+}
+async function openVikingToolCandidateDirs() {
+  const dirs = [];
+  const uv = await findExecutable(["uv"]);
+  if (uv) {
+    const result = await runCommand(uv, ["tool", "dir", "--bin"], { allowFailure: true });
+    if (result.exitCode === 0) {
+      const dir = result.stdout.trim();
+      if (dir) {
+        dirs.push(dir);
+      }
+    }
+  }
+  if (process.env.UV_TOOL_BIN_DIR) {
+    dirs.push(process.env.UV_TOOL_BIN_DIR);
+  }
+  dirs.push((0, import_node_path.join)((0, import_node_os.homedir)(), ".local", "bin"));
+  return Array.from(new Set(dirs));
+}
 async function requiredExecutable(command2) {
   const executable = await findExecutable([command2]);
   if (!executable) {
@@ -35946,6 +35985,14 @@ async function exists(path) {
     return false;
   }
 }
+async function isExecutable(path) {
+  try {
+    await (0, import_promises.access)(path, import_node_fs.constants.X_OK);
+    return true;
+  } catch (_err) {
+    return false;
+  }
+}
 async function isFile(path) {
   try {
     return (await (0, import_promises.stat)(path)).isFile();
@@ -35953,6 +36000,13 @@ async function isFile(path) {
     return false;
   }
 }
+async function isDirectory(path) {
+  try {
+    return (await (0, import_promises.stat)(path)).isDirectory();
+  } catch (_err) {
+    return false;
+  }
+}
 async function readFileIfExists(path) {
   try {
     return await (0, import_promises.readFile)(path, "utf8");
@@ -35976,6 +36030,17 @@ function expandPath(path) {
   }
   return (0, import_node_path.isAbsolute)(path) ? path : (0, import_node_path.resolve)(getInvocationCwd(), path);
 }
+function portablePath(path) {
+  const home = (0, import_node_os.homedir)();
+  const resolvedPath = (0, import_node_path.resolve)(path);
+  if (resolvedPath === home) {
+    return "~";
+  }
+  if (resolvedPath.startsWith(`${home}${import_node_path.sep}`)) {
+    return `~/${resolvedPath.slice(home.length + 1).split(import_node_path.sep).join("/")}`;
+  }
+  return resolvedPath;
+}
 function getInvocationCwd() {
   return process.env.THREADNOTE_CALLER_CWD ?? process.cwd();
 }
@@ -37082,6 +37147,9 @@ var import_node_path4 = require("node:path");
 var TEAMS_FILE_VERSION = 1;
 var SHARED_SEGMENT = "shared";
 var SHAREABLE_MEMORY_KIND_DIRS = ["durable"];
+var SHAREABLE_ARTIFACT_DIR = "agent-artifacts";
+var SHAREABLE_TOP_LEVEL_DIRS = [...SHAREABLE_MEMORY_KIND_DIRS, SHAREABLE_ARTIFACT_DIR];
+var ARTIFACT_INSTALL_METADATA_VERSION = 1;
 var AUTO_SHARE_FETCH_INTERVAL_MS = 5 * 60 * 1e3;
 var DEFAULT_GIT_REMOTE_NAME = "origin";
 var SCRUBBER_PATTERNS = [
@@ -37401,6 +37469,155 @@ async function runGitCommand(dryRun, git, args, failureLabel) {
   }
   return result;
 }
+async function shareAgentArtifact(config2, sourcePath, options) {
+  const team = await resolveTeam(config2, options.team);
+  const dryRun = options.dryRun === true;
+  const preview = options.preview === true;
+  const resolvedSourcePath = expandPath(sourcePath);
+  if (!await isRegularFileNoSymlink(resolvedSourcePath)) {
+    throw new Error(`Agent artifact source is not a regular file: ${resolvedSourcePath}`);
+  }
+  const artifact = inferShareArtifact(resolvedSourcePath, options);
+  const rawContent = await (0, import_promises4.readFile)(resolvedSourcePath, "utf8");
+  if (!rawContent.trim()) {
+    throw new Error(`Refusing to share empty agent artifact: ${resolvedSourcePath}`);
+  }
+  const scrub = applyScrubber(rawContent, { redact: options.redact === true });
+  const relativePath = sharedArtifactRelativePath(artifact);
+  const targetPath = (0, import_node_path4.join)(team.config.worktree, ...relativePath.split("/"));
+  const targetUri = workfileToVikingUri(config2, team.config, targetPath);
+  const messages = [
+    `${preview ? "Previewing" : dryRun ? "Would share" : "Sharing"} ${artifact.kind} ${artifact.agent}/${artifact.name}`,
+    `Source: ${portablePath(resolvedSourcePath)}`,
+    `Destination: ${targetUri}`
+  ];
+  if (preview) {
+    if (scrub.blocker) {
+      messages.push(`PREVIEW BLOCKED: ${scrub.blocker}. Strip the sensitive value or pass --redact.`);
+      return {
+        artifact,
+        gitMessages: [],
+        messages,
+        sourcePath: resolvedSourcePath,
+        targetPath,
+        targetUri
+      };
+    }
+    for (const redaction of scrub.redactions) {
+      messages.push(`PREVIEW redact: ${redaction.count}\xD7 ${redaction.name}`);
+    }
+    return {
+      artifact,
+      gitMessages: [],
+      messages,
+      previewContent: scrub.cleaned,
+      sourcePath: resolvedSourcePath,
+      targetPath,
+      targetUri
+    };
+  }
+  if (scrub.blocker) {
+    throw new Error(
+      `Refusing to share ${resolvedSourcePath}: possible ${scrub.blocker}. Strip the sensitive value or pass --redact for soft-leak patterns.`
+    );
+  }
+  for (const redaction of scrub.redactions) {
+    messages.push(`Redacted ${redaction.count}\xD7 ${redaction.name} before sharing.`);
+  }
+  const content = scrub.cleaned;
+  const existingContent = await readFileIfExists(targetPath) ?? void 0;
+  if (existingContent !== void 0 && existingContent !== content && options.force !== true) {
+    throw new Error(
+      `Shared artifact already exists with different content: ${portablePath(targetPath)}. Pass --force to replace it.`
+    );
+  }
+  if (dryRun) {
+    messages.push(`Would write shared artifact: ${portablePath(targetPath)}`);
+  }
+  const ov = await openVikingCliForMode(dryRun);
+  const ovHasResource = !dryRun && await vikingResourceExists(ov, config2, targetUri);
+  await ensureSharedDirectoryChain(config2, ov, targetUri, dryRun, { quiet: true });
+  await writeMemoryFile(config2, ov, targetUri, content, ovHasResource ? "replace" : "create", dryRun, { quiet: true });
+  const message = options.message ?? `share: publish ${relativePath}`;
+  const gitMessages = await publishShareGitChange(team.config.worktree, relativePath, message, {
+    dryRun,
+    push: options.push
+  });
+  return { artifact, gitMessages, messages, sourcePath: resolvedSourcePath, targetPath, targetUri };
+}
+async function listSharedAgentArtifacts(config2, options = {}) {
+  const syncResult = await maybeSyncSharedArtifacts(config2, options);
+  const team = await resolveTeam(config2, options.team);
+  const artifacts = filterSharedArtifacts(await collectSharedArtifacts(team.config.worktree, team.name), options);
+  const summaries = [];
+  for (const artifact of artifacts) {
+    summaries.push({
+      ...artifact,
+      installStatus: await sharedArtifactInstallStatus(artifact),
+      metadataPath: sharedArtifactMetadataPath(artifact)
+    });
+  }
+  return { artifacts: summaries, syncedTeams: syncResult.syncedTeams, team: team.name, warnings: syncResult.warnings };
+}
+async function installSharedAgentArtifacts(config2, options) {
+  const syncResult = await maybeSyncSharedArtifacts(config2, options);
+  const team = await resolveTeam(config2, options.team);
+  const dryRun = options.dryRun === true || options.apply !== true;
+  const allArtifacts = await collectSharedArtifacts(team.config.worktree, team.name);
+  const artifacts = filterSharedArtifacts(allArtifacts, options);
+  const messages = [];
+  if (artifacts.length === 0) {
+    const filters = sharedArtifactFilterLabel(options);
+    if (filters) {
+      throw new Error(`No shared agent artifacts found for team "${team.name}" matching ${filters}.`);
+    }
+    return {
+      installedCount: 0,
+      messages: [`No shared agent artifacts found for team "${team.name}".`],
+      syncedTeams: syncResult.syncedTeams,
+      team: team.name,
+      warnings: syncResult.warnings
+    };
+  }
+  if (options.name !== void 0 && artifacts.length > 1 && (options.agent === void 0 || options.kind === void 0)) {
+    throw new Error(
+      `Shared artifact "${options.name}" is ambiguous. Specify agent and kind. Matches: ${artifacts.map((artifact) => sharedArtifactLabel(artifact.artifact)).join(", ")}`
+    );
+  }
+  let installedCount = 0;
+  for (const artifact of artifacts) {
+    const label = sharedArtifactLabel(artifact.artifact);
+    const state = await sharedArtifactInstallState(artifact);
+    if (dryRun) {
+      const verb = sharedArtifactDryRunVerb(state.status, options.force === true);
+      const suffix = sharedArtifactDryRunSuffix(state.status, options.force === true);
+      messages.push(`${verb} ${label}: ${portablePath(artifact.installPath)}${suffix}`);
+      continue;
+    }
+    if ((state.status === "local_modified" || state.status === "remote_changed_and_local_modified") && options.force !== true) {
+      throw new Error(`Refusing to overwrite ${portablePath(artifact.installPath)}. Pass force=true or --force.`);
+    }
+    if (state.status === "current") {
+      await writeSharedArtifactMetadata(artifact, state.sourceSha);
+      messages.push(`Already installed ${label}: ${portablePath(artifact.installPath)}`);
+      continue;
+    }
+    await ensureDirectory((0, import_node_path4.dirname)(artifact.installPath), false);
+    await (0, import_promises4.writeFile)(artifact.installPath, state.sourceContent, { encoding: "utf8", mode: 384 });
+    await writeSharedArtifactMetadata(artifact, state.sourceSha);
+    installedCount += 1;
+    messages.push(
+      `${sharedArtifactInstallVerb(state.status, options.force === true)} ${label}: ${portablePath(artifact.installPath)}`
+    );
+  }
+  return {
+    installedCount,
+    messages,
+    syncedTeams: syncResult.syncedTeams,
+    team: team.name,
+    warnings: syncResult.warnings
+  };
+}
 function normalizeTeamName(input) {
   const candidate = (input ?? "default").trim();
   if (!candidate) {
@@ -37535,6 +37752,254 @@ function vikingUriToWorktreeRelative(config2, uri, team) {
   }
   return uri.slice(prefix.length);
 }
+async function isRegularFileNoSymlink(path) {
+  try {
+    const stat2 = await (0, import_promises4.lstat)(path);
+    return stat2.isFile();
+  } catch (_err) {
+    return false;
+  }
+}
+function inferShareArtifact(path, options) {
+  const normalizedPath = path.split(import_node_path4.sep).join("/");
+  const fileName = (0, import_node_path4.basename)(path);
+  const lowerFileName = fileName.toLowerCase();
+  const lowerPath = normalizedPath.toLowerCase();
+  const inferredKind = lowerFileName === "skill.md" ? "skill" : lowerPath.includes("/.claude/commands/") && lowerFileName.endsWith(".md") ? "command" : void 0;
+  const inferredAgent = lowerPath.includes("/.codex/skills/") ? "codex" : lowerPath.includes("/.claude/skills/") || lowerPath.includes("/.claude/commands/") ? "claude" : void 0;
+  const extensionIndex = fileName.lastIndexOf(".");
+  const stem = extensionIndex > 0 ? fileName.slice(0, extensionIndex) : fileName;
+  const inferredName = lowerFileName === "skill.md" ? (0, import_node_path4.basename)((0, import_node_path4.dirname)(path)) : stem;
+  const kind = options.kind ?? inferredKind;
+  const agent = options.agent ?? inferredAgent;
+  const name = options.name ?? inferredName;
+  if (kind !== "skill" && kind !== "command") {
+    throw new Error("Could not infer artifact kind. Pass --kind skill or --kind command.");
+  }
+  if (agent !== "codex" && agent !== "claude") {
+    throw new Error("Could not infer artifact agent. Pass --agent codex or --agent claude.");
+  }
+  if (kind === "skill" && lowerFileName !== "skill.md") {
+    throw new Error("Skill artifacts must point at a SKILL.md file.");
+  }
+  if (kind === "command" && !lowerFileName.endsWith(".md")) {
+    throw new Error("Command artifacts must be Markdown files.");
+  }
+  if (kind === "command" && agent !== "claude") {
+    throw new Error("Only Claude command artifacts are supported.");
+  }
+  if (name.trim().length === 0) {
+    throw new Error("Artifact name cannot be empty.");
+  }
+  return { agent, kind, name: uriSegment(name) };
+}
+function sharedArtifactRelativePath(artifact) {
+  if (artifact.kind === "skill") {
+    return `${SHAREABLE_ARTIFACT_DIR}/skills/${artifact.agent}/${artifact.name}/SKILL.md`;
+  }
+  return `${SHAREABLE_ARTIFACT_DIR}/commands/${artifact.agent}/${artifact.name}.md`;
+}
+function sharedArtifactFromRelativePath(relativePath) {
+  const parts = relativePath.split("/");
+  if (parts[0] !== SHAREABLE_ARTIFACT_DIR) {
+    return void 0;
+  }
+  if (parts.length === 5 && parts[1] === "skills" && (parts[2] === "codex" || parts[2] === "claude") && parts[4] === "SKILL.md") {
+    return { agent: parts[2], kind: "skill", name: parts[3] };
+  }
+  if (parts.length === 4 && parts[1] === "commands" && parts[2] === "claude" && parts[3].endsWith(".md")) {
+    return { agent: "claude", kind: "command", name: parts[3].slice(0, -".md".length) };
+  }
+  return void 0;
+}
+async function collectSharedArtifacts(worktree, team) {
+  const root = (0, import_node_path4.join)(worktree, SHAREABLE_ARTIFACT_DIR);
+  if (!await isDirectory(root)) {
+    return [];
+  }
+  const out = [];
+  async function visit(path) {
+    const entries = await (0, import_promises4.readdir)(path, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = (0, import_node_path4.join)(path, entry.name);
+      if (entry.isDirectory()) {
+        await visit(full);
+        continue;
+      }
+      if (!entry.isFile() || !entry.name.endsWith(".md")) {
+        continue;
+      }
+      const relativePath = (0, import_node_path4.relative)(worktree, full).split(import_node_path4.sep).join("/");
+      const artifact = sharedArtifactFromRelativePath(relativePath);
+      if (artifact === void 0) {
+        continue;
+      }
+      out.push({
+        artifact,
+        installPath: sharedArtifactInstallPath(team, artifact),
+        sourcePath: full,
+        sourceRelativePath: relativePath,
+        team
+      });
+    }
+  }
+  await visit(root);
+  return out.sort((a, b) => a.sourcePath.localeCompare(b.sourcePath));
+}
+function filterSharedArtifacts(artifacts, options) {
+  const name = options.name === void 0 ? void 0 : uriSegment(options.name);
+  return artifacts.filter((artifact) => {
+    if (options.agent !== void 0 && artifact.artifact.agent !== options.agent) {
+      return false;
+    }
+    if (options.kind !== void 0 && artifact.artifact.kind !== options.kind) {
+      return false;
+    }
+    if (name !== void 0 && artifact.artifact.name !== name) {
+      return false;
+    }
+    return true;
+  });
+}
+async function maybeSyncSharedArtifacts(config2, options) {
+  if (options.sync === false) {
+    return { syncedTeams: [], warnings: [] };
+  }
+  return syncSharedReposBeforeAgentRead(config2);
+}
+async function sharedArtifactInstallStatus(artifact) {
+  return (await sharedArtifactInstallState(artifact)).status;
+}
+async function sharedArtifactInstallState(artifact) {
+  const sourceContent = await (0, import_promises4.readFile)(artifact.sourcePath, "utf8");
+  const sourceSha = sha256(sourceContent);
+  const existingContent = await readFileIfExists(artifact.installPath) ?? void 0;
+  if (existingContent === void 0) {
+    return { sourceContent, sourceSha, status: "not_installed" };
+  }
+  const existingSha = sha256(existingContent);
+  const metadata = await readSharedArtifactMetadata(artifact);
+  if (existingSha === sourceSha) {
+    return { existingContent, existingSha, metadata, sourceContent, sourceSha, status: "current" };
+  }
+  if (metadata === void 0) {
+    return { existingContent, existingSha, sourceContent, sourceSha, status: "local_modified" };
+  }
+  const remoteChanged = metadata.sourceSha256 !== sourceSha;
+  const localChanged = metadata.installedSha256 !== existingSha;
+  if (remoteChanged && localChanged) {
+    return {
+      existingContent,
+      existingSha,
+      metadata,
+      sourceContent,
+      sourceSha,
+      status: "remote_changed_and_local_modified"
+    };
+  }
+  if (remoteChanged) {
+    return { existingContent, existingSha, metadata, sourceContent, sourceSha, status: "update_available" };
+  }
+  return { existingContent, existingSha, metadata, sourceContent, sourceSha, status: "local_modified" };
+}
+async function readSharedArtifactMetadata(artifact) {
+  const raw = await readFileIfExists(sharedArtifactMetadataPath(artifact));
+  if (raw === void 0) {
+    return void 0;
+  }
+  const parsed = parseJsonConfigObject(raw);
+  if (parsed === void 0 || parsed.version !== ARTIFACT_INSTALL_METADATA_VERSION) {
+    return void 0;
+  }
+  const artifactValue = parsed.artifact;
+  if (typeof parsed.team !== "string" || typeof parsed.source !== "string" || typeof parsed.sourceSha256 !== "string" || typeof parsed.installedSha256 !== "string" || typeof parsed.installedAt !== "string" || typeof artifactValue !== "object" || artifactValue === null || Array.isArray(artifactValue)) {
+    return void 0;
+  }
+  const metadataArtifact = artifactValue;
+  if (metadataArtifact.agent !== artifact.artifact.agent || metadataArtifact.kind !== artifact.artifact.kind || metadataArtifact.name !== artifact.artifact.name) {
+    return void 0;
+  }
+  return {
+    artifact: artifact.artifact,
+    installedAt: parsed.installedAt,
+    installedSha256: parsed.installedSha256,
+    source: parsed.source,
+    sourceSha256: parsed.sourceSha256,
+    team: parsed.team,
+    version: ARTIFACT_INSTALL_METADATA_VERSION
+  };
+}
+async function writeSharedArtifactMetadata(artifact, sourceSha) {
+  const metadata = {
+    artifact: artifact.artifact,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    installedSha256: sourceSha,
+    source: artifact.sourceRelativePath,
+    sourceSha256: sourceSha,
+    team: artifact.team,
+    version: ARTIFACT_INSTALL_METADATA_VERSION
+  };
+  const metadataPath = sharedArtifactMetadataPath(artifact);
+  await ensureDirectory((0, import_node_path4.dirname)(metadataPath), false);
+  await (0, import_promises4.writeFile)(metadataPath, `${JSON.stringify(metadata, void 0, 2)}
+`, { encoding: "utf8", mode: 384 });
+}
+function sharedArtifactMetadataPath(artifact) {
+  return `${artifact.installPath}.threadnote-install.json`;
+}
+function sharedArtifactDryRunVerb(status, force) {
+  switch (status) {
+    case "not_installed":
+      return "Would install";
+    case "current":
+      return "Already installed";
+    case "update_available":
+      return "Would update";
+    case "local_modified":
+    case "remote_changed_and_local_modified":
+      return force ? "Would replace" : "Would skip modified";
+  }
+}
+function sharedArtifactDryRunSuffix(status, force) {
+  if ((status === "local_modified" || status === "remote_changed_and_local_modified") && !force) {
+    return " (pass --force to replace local changes)";
+  }
+  return "";
+}
+function sharedArtifactInstallVerb(status, force) {
+  if (force && (status === "local_modified" || status === "remote_changed_and_local_modified")) {
+    return "Replaced";
+  }
+  if (status === "update_available") {
+    return "Updated";
+  }
+  return "Installed";
+}
+function sharedArtifactFilterLabel(options) {
+  const filters = [];
+  if (options.kind !== void 0) {
+    filters.push(`kind=${options.kind}`);
+  }
+  if (options.agent !== void 0) {
+    filters.push(`agent=${options.agent}`);
+  }
+  if (options.name !== void 0) {
+    filters.push(`name=${uriSegment(options.name)}`);
+  }
+  return filters.join(", ");
+}
+function sharedArtifactLabel(artifact) {
+  return `${artifact.kind} ${artifact.agent}/${artifact.name}`;
+}
+function sharedArtifactInstallPath(team, artifact) {
+  if (artifact.kind === "skill" && artifact.agent === "codex") {
+    return (0, import_node_path4.join)((0, import_node_os2.homedir)(), ".codex", "skills", "threadnote", team, artifact.name, "SKILL.md");
+  }
+  if (artifact.kind === "skill" && artifact.agent === "claude") {
+    return (0, import_node_path4.join)((0, import_node_os2.homedir)(), ".claude", "skills", "threadnote", team, artifact.name, "SKILL.md");
+  }
+  return (0, import_node_path4.join)((0, import_node_os2.homedir)(), ".claude", "commands", "threadnote", team, `${artifact.name}.md`);
+}
 function stripPersonalProvenance(content) {
   const lines = content.split("\n");
   let headerEnd = lines.length;
@@ -37571,9 +38036,9 @@ async function ensureSharedDirectoryChain(config2, ov, memoryUri, dryRun, option
       continue;
     }
     if (options.quiet === true) {
-      await runCommand(ov, withIdentity(config2, ["mkdir", uri, "--description", "Threadnote shared memories."]));
+      await runCommand(ov, withIdentity(config2, ["mkdir", uri, "--description", "Threadnote shared context."]));
     } else {
-      await maybeRun(false, ov, withIdentity(config2, ["mkdir", uri, "--description", "Threadnote shared memories."]));
+      await maybeRun(false, ov, withIdentity(config2, ["mkdir", uri, "--description", "Threadnote shared context."]));
     }
   }
 }
@@ -37802,7 +38267,7 @@ async function applyChangesToOpenViking(config2, team, changes, options = {}) {
       continue;
     }
     const firstSegment = change.relativePath.split("/")[0];
-    if (!SHAREABLE_MEMORY_KIND_DIRS.includes(firstSegment)) {
+    if (!SHAREABLE_TOP_LEVEL_DIRS.includes(firstSegment)) {
       continue;
     }
     const uri = workfileToVikingUri(config2, team, change.path);
@@ -37879,6 +38344,8 @@ async function main() {
         "When updating the same active issue, pass project/topic or replaceUri to remember_context so duplicate durable memories or handoffs do not accumulate.",
         "Use compact_context with dryRun=true for scoped memory hygiene when recall surfaces overlapping active memories.",
         "To share a durable memory with teammates, call `share_publish` with its viking:// URI. share_publish scrubs for secrets, writes and pushes the shared copy first, then removes the personal copy after the push succeeds. Do not publish handoffs, preferences, or anything carrying machine-local paths or in-flight task context.",
+        "To share a local Codex/Claude skill or Claude command with teammates, call `share_skill` with the local file path. It publishes into the shared artifact catalog after the same scrubber checks.",
+        "To use a team shared skill as a native local skill, call `list_shared_skills` first, then `install_shared_skill` for the selected name/agent/kind.",
         "Do not store secrets, customer data, raw production logs, or credentials."
       ].join("\n")
     }
@@ -38079,6 +38546,80 @@ function registerTools(server, config2) {
       return runSharePublishTool(config2, checkedUri.value, { message, preview, push, redact, team });
     }
   );
+  server.registerTool(
+    "share_skill",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: true },
+      description: "Publish a local Codex/Claude skill or Claude command markdown file into a team's shared artifact catalog. Path inference handles ~/.codex/skills/**/SKILL.md, ~/.claude/skills/**/SKILL.md, and ~/.claude/commands/**/*.md; pass agent/kind/name when sharing from another path. Default team is used unless team is provided. Pass preview=true to inspect bytes without writing or committing.",
+      inputSchema: {
+        agent: external_exports.enum(["codex", "claude"]).optional().describe("Agent owner when path inference is ambiguous"),
+        force: external_exports.boolean().optional().describe("Replace an existing shared artifact with different content"),
+        kind: external_exports.enum(["skill", "command"]).optional().describe("Artifact kind when path inference is ambiguous"),
+        message: external_exports.string().optional().describe('Commit message override; defaults to "share: publish <path>"'),
+        name: external_exports.string().optional().describe("Shared artifact name; defaults to skill directory or command file stem"),
+        path: external_exports.string().optional().describe("Required local path to SKILL.md or a Claude command markdown file"),
+        preview: external_exports.boolean().optional().describe("Return the bytes that would land in the shared git repo"),
+        push: external_exports.boolean().optional().describe("Push to remote after committing; defaults to true"),
+        redact: external_exports.boolean().optional().describe("Replace soft-leak matches (local paths) with placeholders and continue; credentials still block."),
+        team: external_exports.string().optional().describe("Team name; defaults to the configured default team")
+      }
+    },
+    async ({ agent, force, kind, message, name, path, preview, push, redact, team }) => {
+      const checkedPath = requiredText(path, "share_skill", "path", {
+        path: "~/.codex/skills/example/SKILL.md"
+      });
+      if (!checkedPath.ok) {
+        return checkedPath.error;
+      }
+      return runShareSkillTool(config2, checkedPath.value, {
+        agent,
+        force,
+        kind,
+        message,
+        name,
+        preview,
+        push,
+        redact,
+        team
+      });
+    }
+  );
+  server.registerTool(
+    "list_shared_skills",
+    {
+      annotations: { readOnlyHint: true, destructiveHint: false },
+      description: "List shared Codex/Claude skills and Claude commands available in a configured Threadnote team repo, including whether each one is already installed locally.",
+      inputSchema: {
+        agent: external_exports.enum(["codex", "claude"]).optional().describe("Optional agent filter"),
+        kind: external_exports.enum(["skill", "command"]).optional().describe("Optional kind filter"),
+        name: external_exports.string().optional().describe("Optional shared artifact name filter"),
+        team: external_exports.string().optional().describe("Team name; defaults to the configured default team")
+      }
+    },
+    async ({ agent, kind, name, team }) => runListSharedSkillsTool(config2, { agent, kind, name, team })
+  );
+  server.registerTool(
+    "install_shared_skill",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: true },
+      description: "Install one shared Codex/Claude skill or Claude command from a configured Threadnote team repo into the local agent skill/command directory. Use list_shared_skills first to find names and disambiguate agent/kind.",
+      inputSchema: {
+        agent: external_exports.enum(["codex", "claude"]).optional().describe("Agent owner; required when name is ambiguous"),
+        dryRun: external_exports.boolean().optional().describe("Preview install without writing local files"),
+        force: external_exports.boolean().optional().describe("Replace an existing installed artifact with different content"),
+        kind: external_exports.enum(["skill", "command"]).optional().describe("Artifact kind; required when name is ambiguous"),
+        name: external_exports.string().optional().describe("Required shared artifact name to install"),
+        team: external_exports.string().optional().describe("Team name; defaults to the configured default team")
+      }
+    },
+    async ({ agent, dryRun, force, kind, name, team }) => {
+      const checkedName = requiredText(name, "install_shared_skill", "name", { name: "reviewer" });
+      if (!checkedName.ok) {
+        return checkedName.error;
+      }
+      return runInstallSharedSkillTool(config2, checkedName.value, { agent, dryRun, force, kind, team });
+    }
+  );
 }
 function registerOpenVikingParityTools(server, config2) {
   server.registerTool(
@@ -39439,27 +39980,85 @@ async function runSharePublishTool(config2, sourceUri, options) {
     return { content: [{ type: "text", text: errorMessage(err) }], isError: true };
   }
 }
+async function runShareSkillTool(config2, sourcePath, options) {
+  try {
+    const result = await shareAgentArtifact(config2, sourcePath, options);
+    const lines = [...result.messages, ...result.gitMessages];
+    if (result.previewContent !== void 0) {
+      lines.push("-----BEGIN PREVIEW-----");
+      lines.push(result.previewContent);
+      lines.push("-----END PREVIEW-----");
+    }
+    return { content: [{ type: "text", text: lines.join("\n") }], isError: false };
+  } catch (err) {
+    return { content: [{ type: "text", text: errorMessage(err) }], isError: true };
+  }
+}
+async function runListSharedSkillsTool(config2, options) {
+  try {
+    const result = await listSharedAgentArtifacts(config2, options);
+    if (result.artifacts.length === 0) {
+      const lines2 = shareArtifactToolHeader(result.team, result.syncedTeams, result.warnings);
+      lines2.push(`No shared skills or commands found for team "${result.team}".`);
+      return { content: [{ type: "text", text: lines2.join("\n") }] };
+    }
+    const lines = shareArtifactToolHeader(result.team, result.syncedTeams, result.warnings);
+    lines.push(`Shared skills and commands for team "${result.team}":`);
+    for (const artifact of result.artifacts) {
+      lines.push(
+        `- ${artifact.artifact.kind} ${artifact.artifact.agent}/${artifact.artifact.name} (${artifact.installStatus})`
+      );
+      lines.push(
+        `  install: install_shared_skill({"name":"${artifact.artifact.name}","agent":"${artifact.artifact.agent}","kind":"${artifact.artifact.kind}"})`
+      );
+    }
+    return { content: [{ type: "text", text: lines.join("\n") }], isError: false };
+  } catch (err) {
+    return { content: [{ type: "text", text: errorMessage(err) }], isError: true };
+  }
+}
+async function runInstallSharedSkillTool(config2, name, options) {
+  try {
+    const result = await installSharedAgentArtifacts(config2, {
+      ...options,
+      apply: options.dryRun !== true,
+      name
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: [...shareArtifactToolHeader(result.team, result.syncedTeams, result.warnings), ...result.messages].join(
+            "\n"
+          )
+        }
+      ],
+      isError: false
+    };
+  } catch (err) {
+    return { content: [{ type: "text", text: errorMessage(err) }], isError: true };
+  }
+}
+function shareArtifactToolHeader(team, syncedTeams, warnings) {
+  const lines = [`Team: ${team}`];
+  if (syncedTeams.length > 0) {
+    lines.push(`Synced shared teams: ${syncedTeams.join(", ")}`);
+  }
+  for (const warning2 of warnings) {
+    lines.push(`Warning: ${warning2}`);
+  }
+  return lines;
+}
 function withIdentity2(config2, args) {
   return [...args, "--account", config2.account, "--user", config2.user, "--agent-id", config2.agentId];
 }
 async function requiredOpenVikingCli2() {
-  const command2 = process.env.THREADNOTE_OV ?? await findExecutable(["ov", "openviking"]) ?? await firstExistingPath([(0, import_node_path5.join)((0, import_node_os3.homedir)(), ".local", "bin", "ov"), (0, import_node_path5.join)((0, import_node_os3.homedir)(), ".local", "bin", "openviking")]);
+  const command2 = await findOpenVikingCli();
   if (!command2) {
     throw new Error("Neither ov nor openviking was found. Run threadnote install first.");
   }
   return command2;
 }
-async function firstExistingPath(paths) {
-  for (const path of paths) {
-    try {
-      await (0, import_promises5.access)(path);
-      return await (0, import_promises5.realpath)(path);
-    } catch (_err) {
-      continue;
-    }
-  }
-  return void 0;
-}
 main().catch((err) => {
   process.stderr.write(`${errorMessage(err)}
 `);