threadnote 1.1.2 → 1.1.3

package/dist/threadnote.cjs

@@ -8457,6 +8457,9 @@ var import_node_path6 = 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 = [
@@ -8548,7 +8551,7 @@ async function runShareInit(config, remoteUrl, options) {
   if (!dryRun) {
     await ensureSharedGitignore(worktree, git, options.push !== false);
     const ingested = await ingestWorktreeFiles(config, newConfig, "create");
-    console.log(`Ingested ${ingested} shared memory file(s) into OpenViking.`);
+    console.log(`Ingested ${ingested} shared file(s) into OpenViking.`);
   }
 }
 var SHARED_GITIGNORE_PATTERNS = ["**/.abstract.md", "**/.overview.md"];
@@ -8875,7 +8878,7 @@ async function runShareSyncQuiet(config, state, options) {
   return void 0;
 }
 async function stageShareableChanges(dryRun, git, worktree) {
-  const pathspecs = [":(top)README.md", ":(top).gitignore", ...SHAREABLE_MEMORY_KIND_DIRS.map((dir) => `:(top)${dir}`)];
+  const pathspecs = [":(top)README.md", ":(top).gitignore", ...SHAREABLE_TOP_LEVEL_DIRS.map((dir) => `:(top)${dir}`)];
   await maybeRun(dryRun, git, ["-C", worktree, "add", "--", ...pathspecs], { allowFailure: true });
 }
 async function publishShareGitChange(worktree, relativePath, commitMessage, options = {}) {
@@ -8997,6 +9000,157 @@ ${err instanceof Error ? err.message : String(err)}`,
   }
   console.log(`Published ${sourceUri} -> ${targetUri}`);
 }
+async function runSharePublishArtifact(config, sourcePath, options) {
+  const result = await shareAgentArtifact(config, sourcePath, options);
+  printShareArtifactResult(result, options.preview === true);
+}
+async function shareAgentArtifact(config, sourcePath, options) {
+  const team = await resolveTeam(config, 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_promises5.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_path6.join)(team.config.worktree, ...relativePath.split("/"));
+  const targetUri = workfileToVikingUri(config, 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, config, targetUri);
+  await ensureSharedDirectoryChain(config, ov, targetUri, dryRun, { quiet: true });
+  await writeMemoryFile(config, 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 runShareInstallArtifacts(config, options) {
+  const result = await installSharedAgentArtifacts(config, options);
+  if (result.syncedTeams.length > 0) {
+    console.log(`Synced shared teams: ${result.syncedTeams.join(", ")}`);
+  }
+  for (const warning2 of result.warnings) {
+    console.warn(`Warning: ${warning2}`);
+  }
+  for (const message of result.messages) {
+    console.log(message);
+  }
+}
+async function installSharedAgentArtifacts(config, options) {
+  const syncResult = await maybeSyncSharedArtifacts(config, options);
+  const team = await resolveTeam(config, 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_path6.dirname)(artifact.installPath), false);
+    await (0, import_promises5.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
+  };
+}
 async function runShareUnpublish(config, sourceUri, options) {
   assertVikingUri(sourceUri);
   const team = await resolveTeam(config, options.team);
@@ -9089,7 +9243,7 @@ async function runShareRename(config, options) {
     console.log(`Would rename worktree: ${portablePath(oldTeam.config.worktree)} -> ${portablePath(newWorktree)}`);
     console.log(`Would rename gitdir: ${portablePath(oldTeam.config.gitdir)} -> ${portablePath(newGitdir)}`);
     console.log(`Would update git core.worktree for team "${newName}".`);
-    console.log(`Would reindex shared memories under team "${newName}" and remove old shared URI tree.`);
+    console.log(`Would reindex shared context under team "${newName}" and remove old shared URI tree.`);
     console.log(`Would write teams file: ${teamsFilePath(config)}`);
     return;
   }
@@ -9107,7 +9261,7 @@ async function runShareRename(config, options) {
     false
   );
   console.log(`Renamed shared team "${oldTeam.name}" -> "${newName}".`);
-  console.log(`Reindexed ${ingested} shared memory file(s).`);
+  console.log(`Reindexed ${ingested} shared file(s).`);
 }
 async function runShareSetUrl(config, remoteUrl, options) {
   if (!remoteUrl.trim()) {
@@ -9350,7 +9504,7 @@ async function walkMemoryFiles(root) {
       }
       const full = (0, import_node_path6.join)(path, entry.name);
       if (entry.isDirectory()) {
-        if (depth === 0 && !SHAREABLE_MEMORY_KIND_DIRS.includes(entry.name)) {
+        if (depth === 0 && !SHAREABLE_TOP_LEVEL_DIRS.includes(entry.name)) {
           continue;
         }
         await visit(full, depth + 1);
@@ -9432,6 +9586,264 @@ function vikingUriToWorktreeRelative(config, uri, team) {
   }
   return uri.slice(prefix.length);
 }
+async function isRegularFileNoSymlink(path) {
+  try {
+    const stat5 = await (0, import_promises5.lstat)(path);
+    return stat5.isFile();
+  } catch (_err) {
+    return false;
+  }
+}
+function inferShareArtifact(path, options) {
+  const normalizedPath = path.split(import_node_path6.sep).join("/");
+  const fileName = (0, import_node_path6.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_path6.basename)((0, import_node_path6.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_path6.join)(worktree, SHAREABLE_ARTIFACT_DIR);
+  if (!await isDirectory(root)) {
+    return [];
+  }
+  const out = [];
+  async function visit(path) {
+    const entries = await (0, import_promises5.readdir)(path, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = (0, import_node_path6.join)(path, entry.name);
+      if (entry.isDirectory()) {
+        await visit(full);
+        continue;
+      }
+      if (!entry.isFile() || !entry.name.endsWith(".md")) {
+        continue;
+      }
+      const relativePath = (0, import_node_path6.relative)(worktree, full).split(import_node_path6.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(config, options) {
+  if (options.sync === false) {
+    return { syncedTeams: [], warnings: [] };
+  }
+  return syncSharedReposBeforeAgentRead(config);
+}
+async function sharedArtifactInstallState(artifact) {
+  const sourceContent = await (0, import_promises5.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_path6.dirname)(metadataPath), false);
+  await (0, import_promises5.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_path6.join)((0, import_node_os4.homedir)(), ".codex", "skills", "threadnote", team, artifact.name, "SKILL.md");
+  }
+  if (artifact.kind === "skill" && artifact.agent === "claude") {
+    return (0, import_node_path6.join)((0, import_node_os4.homedir)(), ".claude", "skills", "threadnote", team, artifact.name, "SKILL.md");
+  }
+  return (0, import_node_path6.join)((0, import_node_os4.homedir)(), ".claude", "commands", "threadnote", team, `${artifact.name}.md`);
+}
+function printShareArtifactResult(result, preview) {
+  for (const message of result.messages) {
+    console.log(message);
+  }
+  for (const gitMessage of result.gitMessages) {
+    console.log(gitMessage);
+  }
+  if (preview && result.previewContent !== void 0) {
+    console.log("-----BEGIN PREVIEW-----");
+    console.log(result.previewContent);
+    console.log("-----END PREVIEW-----");
+  }
+}
 function stripPersonalProvenance(content) {
   const lines = content.split("\n");
   let headerEnd = lines.length;
@@ -9480,9 +9892,9 @@ async function ensureSharedDirectoryChain(config, ov, memoryUri, dryRun, options
       continue;
     }
     if (options.quiet === true) {
-      await runCommand(ov, withIdentity(config, ["mkdir", uri, "--description", "Threadnote shared memories."]));
+      await runCommand(ov, withIdentity(config, ["mkdir", uri, "--description", "Threadnote shared context."]));
     } else {
-      await maybeRun(false, ov, withIdentity(config, ["mkdir", uri, "--description", "Threadnote shared memories."]));
+      await maybeRun(false, ov, withIdentity(config, ["mkdir", uri, "--description", "Threadnote shared context."]));
     }
   }
 }
@@ -9711,7 +10123,7 @@ async function applyChangesToOpenViking(config, 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(config, team, change.path);
@@ -14821,6 +15233,15 @@ async function main() {
   ).action(async (uri, options) => {
     await runSharePublish(getRuntimeConfig(program2), uri, options);
   });
+  share.command("publish-artifact").description("Publish a local Codex/Claude skill or Claude command into the shared team repo").argument("<path>", "Path to SKILL.md or a Claude command markdown file").option("--team <name>", "Team name; defaults to the configured default team").option("--agent <agent>", "Agent owner when path inference is ambiguous: codex or claude").option("--kind <kind>", "Artifact kind when path inference is ambiguous: skill or command").option("--name <name>", "Shared artifact name; defaults to skill directory or command file stem").option("--message <text>", "Commit message override").option("--force", "Replace an existing shared artifact with different content").option("--no-push", "Skip the push step").option("--dry-run", "Print actions without running them").option("--preview", "Print the exact artifact bytes that would land in the shared git repo").option(
+    "--redact",
+    "Replace soft-leak matches (local paths) with placeholders and continue; credentials still block"
+  ).action(async (path, options) => {
+    await runSharePublishArtifact(getRuntimeConfig(program2), path, options);
+  });
+  share.command("install-artifacts").description("Install shared Codex/Claude skills and Claude commands from a team repo").option("--team <name>", "Team name; defaults to the configured default team").option("--agent <agent>", "Install only artifacts for this agent: codex or claude").option("--kind <kind>", "Install only artifacts of this kind: skill or command").option("--name <name>", "Install only this shared artifact name").option("--apply", "Actually write files into local agent skill/command directories").option("--force", "Replace existing installed artifacts with different content").option("--no-sync", "Skip pulling shared team updates before listing/installing artifacts").option("--dry-run", "Preview install actions without writing files").action(async (options) => {
+    await runShareInstallArtifacts(getRuntimeConfig(program2), options);
+  });
   share.command("unpublish").description("Pull a shared memory back into the personal namespace, commit removal and push").argument("<viking-uri>", "viking:// memory URI inside a team shared subtree").option("--team <name>", "Team name; defaults to the configured default team").option("--message <text>", "Commit message override").option("--no-push", "Skip the push step").option("--dry-run", "Print actions without running them").action(async (uri, options) => {
     await runShareUnpublish(getRuntimeConfig(program2), uri, options);
   });

package/docs/agent-instructions.md

@@ -119,11 +119,12 @@ compact_context({"project":"my-repo","topic":"active-bug","dryRun":true})
 
 Never compact secrets, credentials, customer data, raw production logs, or checked-in canonical docs into memory.
 
-## Sharing memories with teammates
+## Sharing context with teammates
 
-Threadnote can publish a curated subset of durable memories into a team git repo so other engineers' agents can pull them.
-The mechanism lives under the `viking://user/<you>/memories/shared/<team>/...` subtree; only memories that are explicitly
-published leave the machine. Personal handoffs, preferences, and unpublished durable notes always stay local.
+Threadnote can publish a curated subset of durable memories and agent artifacts (Codex/Claude skills and Claude
+commands) into a team git repo so other engineers' agents can pull them. The mechanism lives under the
+`viking://user/<you>/memories/shared/<team>/...` subtree; only content that is explicitly published leaves the machine.
+Personal handoffs, preferences, and unpublished durable notes always stay local.
 
 Publish a durable memory when its content is useful to other engineers working on the same project (intended behavior,
 design decisions, API contracts, gotchas) and is safe to share. Do NOT publish:
@@ -136,6 +137,16 @@ The MCP tool `share_publish` runs the same scrubber as the CLI and refuses to pu
 patterns (PEM private keys, `sk-...`, `gh[pousr]_...`, `Bearer ...`, `AKIA...`, `xox[abprs]-...`). It writes and pushes
 the shared copy first, then removes the personal copy after the push succeeds.
 
+The MCP tool `share_skill` shares a local Codex/Claude `SKILL.md` file or Claude command markdown file into the team's
+`agent-artifacts/` catalog after the same scrubber checks. Shared artifacts are recallable after sync, but local
+installation remains opt-in with `threadnote share install-artifacts --apply`.
+
+When the user asks whether shared skills exist, call `list_shared_skills`. When the user asks to install one, call
+`install_shared_skill` with the selected `name`; include `agent` and `kind` from the list result when available.
+`list_shared_skills` syncs shared repos before listing and reports `not_installed`, `current`, `update_available`,
+`local_modified`, or `remote_changed_and_local_modified`. Install/update selected shared skills only when the user asks;
+use `force:true` only when the user explicitly accepts overwriting local modifications.
+
 Incoming shared memories are normally fetched and synced automatically before MCP `recall_context` / `read_context` and
 CLI `threadnote recall` / `threadnote read` return. If automatic sync reports a dirty worktree, a conflict, or another
 git issue, run `threadnote share sync` after resolving the local state to pull, reindex, and push explicitly.
@@ -144,9 +155,13 @@ git issue, run `threadnote share sync` after resolving the local state to pull,
 # MCP call shape
 share_publish({"uri":"viking://user/you/memories/durable/projects/foo/bar.md"})
 share_publish({"uri":"viking://user/you/memories/durable/projects/foo/bar.md","team":"friends","push":false})
+share_skill({"path":"~/.codex/skills/reviewer/SKILL.md"})
+list_shared_skills({})
+install_shared_skill({"name":"reviewer","agent":"codex","kind":"skill"})
 ```
 
-Before publishing, confirm with the user unless they have already instructed you to share durable memories autonomously.
+Before publishing, confirm with the user unless they have already instructed you to share durable memories or agent
+artifacts autonomously.
 
 ## Handoff
 
@@ -184,5 +199,7 @@ threadnote forget viking://user/example/memories/events/duplicate.md
 threadnote handoff --project example --topic active-issue --task "short task summary" --tests "checks run" --next-step "what to do next"
 threadnote share init git@github.com:org/team-memories.git
 threadnote share publish viking://user/example/memories/durable/projects/foo/bar.md
+threadnote share publish-artifact ~/.codex/skills/example/SKILL.md
+threadnote share install-artifacts --name example --agent codex --kind skill --apply
 threadnote share sync
 ```

package/docs/index.html

@@ -783,7 +783,7 @@
             team-shared decisions — recallable from any session, on any agent, in any worktree.
           </p>
           <div class="cta-row">
-            <span class="pill"><span id="version-tag">v0.6.1</span> · local-first · GPL-3.0-or-later</span>
+            <span class="pill"><span id="version-tag">v0.6.1</span> · local-first · AGPL-3.0-or-later</span>
           </div>
         </div>
         <div class="scroll-cue">scroll ↓ &nbsp;·&nbsp; <span class="kbd">↓</span> / <span class="kbd">j</span></div>
@@ -1585,7 +1585,7 @@ threadnote doctor --dry-run</code></pre>
           </div>
 
           <p class="colophon">
-            threadnote · GPL-3.0-or-later · built on OpenViking 0.3.24 · use <span class="kbd">↑</span>
+            threadnote · AGPL-3.0-or-later · built on OpenViking 0.3.24 · use <span class="kbd">↑</span>
             <span class="kbd">↓</span> / <span class="kbd">j</span> <span class="kbd">k</span> to navigate
           </p>
         </div>