threadnote 1.1.1 → 1.1.3

package/dist/threadnote.cjs

@@ -3473,6 +3473,7 @@ var {
 var DEFAULT_HOST = "127.0.0.1";
 var DEFAULT_PORT = 1933;
 var DEFAULT_OPENVIKING_VERSION = "0.3.24";
+var OPENVIKING_TOOL_PYTHON = "3.12";
 var DEFAULT_ACCOUNT = "local";
 var DEFAULT_AGENT_ID = "threadnote";
 var OPENVIKING_PACKAGE_NAME = "openviking[local-embed]";
@@ -4315,7 +4316,13 @@ function recallSnippet(value) {
   const oneLine = value.replace(/\s+/g, " ").trim();
   return oneLine.length > 180 ? `${oneLine.slice(0, 180)}\u2026` : oneLine;
 }
-function parseRecallHits(output2) {
+function isArchivedMemoryUri(uri) {
+  const documentUri = uri.replace(/#.*$/, "");
+  return /^viking:\/\/user\/[^/]+\/memories\/(?:durable|handoffs|incidents|preferences|smoke)\/archived(?:\/|$)/.test(
+    documentUri
+  );
+}
+function parseRecallHits(output2, options = {}) {
   const start = output2.search(/^\{/m);
   if (start < 0) {
     return [];
@@ -4336,6 +4343,9 @@ function parseRecallHits(output2) {
         if (!isJsonObject(item) || typeof item.uri !== "string" || isSummarySidecarUri(item.uri)) {
           continue;
         }
+        if (options.includeArchived !== true && isArchivedMemoryUri(item.uri)) {
+          continue;
+        }
         hits.push({
           contextType: typeof item.context_type === "string" ? item.context_type : "result",
           score: typeof item.score === "number" ? item.score : 0,
@@ -8447,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 = [
@@ -8538,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"];
@@ -8865,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 = {}) {
@@ -8987,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);
@@ -9079,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;
   }
@@ -9097,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()) {
@@ -9340,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);
@@ -9422,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;
@@ -9470,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."]));
     }
   }
 }
@@ -9701,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);
@@ -9960,14 +10382,17 @@ async function runRecall(config, options) {
   if (inferredUri) {
     console.log(`Recall scope: ${inferredUri}`);
   }
-  const passes = [await recallSearchHits(config, ov, searchArgs(inferredUri), { dryRun })];
+  const includeArchived = options.includeArchived === true;
+  const passes = [
+    await recallSearchHits(config, ov, searchArgs(inferredUri), { dryRun, includeArchived })
+  ];
   if (options.project && project) {
     const projectMemoryUri = `viking://user/${uriSegment(config.user)}/memories/durable/projects/${uriSegment(project.name)}`;
-    passes.push(await recallSearchHits(config, ov, searchArgs(projectMemoryUri), { dryRun }));
+    passes.push(await recallSearchHits(config, ov, searchArgs(projectMemoryUri), { dryRun, includeArchived }));
   }
   const seededUri = project ? trimTrailingSlash(project.uri) : void 0;
   if (seededUri?.startsWith("viking://") && seededUri !== inferredUri && !options.uri && options.inferScope !== false) {
-    passes.push(await recallSearchHits(config, ov, searchArgs(seededUri), { dryRun }));
+    passes.push(await recallSearchHits(config, ov, searchArgs(seededUri), { dryRun, includeArchived }));
   }
   const recallOutputs = [];
   const semanticSection = formatRecallHits(mergeRecallHits(passes), nodeLimit ?? 12);
@@ -9978,7 +10403,7 @@ ${semanticSection}`);
   }
   const exactOutput = await printExactMemoryMatches(config, ov, query, {
     dryRun,
-    includeArchived: options.includeArchived === true,
+    includeArchived,
     project
   });
   if (exactOutput) {
@@ -10002,7 +10427,7 @@ async function recallSearchHits(config, ov, args, options) {
     console.log(`WARN recall search failed: ${result.stderr.trim() || result.stdout.trim() || "ov search error"}`);
     return [];
   }
-  return parseRecallHits(result.stdout);
+  return parseRecallHits(result.stdout, { includeArchived: options.includeArchived });
 }
 function stripAdvancedSearchFlags(args) {
   const stripped = [];
@@ -12442,6 +12867,14 @@ async function runInstall(config, options) {
     serverInstallRan = true;
   }
   const resolvedServerPath = serverInstallRan ? await findOpenVikingServer() : serverPath;
+  if (serverInstallRan && !resolvedServerPath && !dryRun) {
+    const message = `OpenViking install ran but ${OPENVIKING_SERVER_COMMAND} was not found on PATH, in the uv tool bin dir, or ~/.local/bin. Re-run \`threadnote install --force\` (it streams the full build), then \`threadnote doctor\`.`;
+    if (options.requireServerBinary === false) {
+      console.warn(`WARN ${message}`);
+    } else {
+      throw new Error(message);
+    }
+  }
   if (resolvedServerPath && !dryRun) {
     await maybePrintOpenVikingPathHint(resolvedServerPath);
   }
@@ -12478,6 +12911,7 @@ async function runRepair(config, options) {
     packageManager: options.packageManager,
     printNextSteps: false,
     repairInvalidConfigs: true,
+    requireServerBinary: false,
     start: false
   });
   await repairManifest(config, dryRun);
@@ -12832,7 +13266,11 @@ async function openVikingServerCheck() {
   const name = OPENVIKING_SERVER_COMMAND;
   const executable = await findOpenVikingServer();
   if (!executable) {
-    return { name, status: "fail", detail: "missing; install will fetch it via uv or pipx" };
+    return {
+      name,
+      status: "fail",
+      detail: "missing; run `threadnote install` to fetch it via uv or pipx (local-embed may compile from source on first install)"
+    };
   }
   const result = await runCommand(executable, ["--help"], { allowFailure: true });
   const onPath = await findExecutable([OPENVIKING_SERVER_COMMAND]);
@@ -13066,7 +13504,36 @@ async function runInstallCommands(config, preferred, force, dryRun) {
   }
   const installCommands = await getInstallCommands(config, manager, force);
   for (const installCommand of installCommands) {
-    await maybeRun(dryRun, installCommand.executable, installCommand.args);
+    if (dryRun) {
+      await maybeRun(true, installCommand.executable, installCommand.args);
+      continue;
+    }
+    console.log(`Running: ${formatShellCommand(installCommand.executable, installCommand.args)}`);
+    const exitCode = await runInteractive(installCommand.executable, installCommand.args);
+    if (exitCode !== 0) {
+      printOpenVikingInstallFailureHelp(installCommand);
+      throw new Error(`${formatShellCommand(installCommand.executable, installCommand.args)} exited with ${exitCode}.`);
+    }
+  }
+}
+function printOpenVikingInstallFailureHelp(failedCommand) {
+  console.error("");
+  console.error("OpenViking install did not complete.");
+  console.error(
+    "openviking[local-embed] includes llama-cpp-python, which compiles from source when no prebuilt wheel matches your Python/platform \u2014 that build can run 10-20 minutes and is memory-heavy, so it may be killed by the OS (out of memory) or look stuck."
+  );
+  console.error("Re-run it directly to see full output without any wrapper timeout:");
+  console.error(`  ${formatShellCommand(failedCommand.executable, failedCommand.args)}`);
+  console.error("Cap memory use during the compile with: CMAKE_BUILD_PARALLEL_LEVEL=2 <command above>");
+  if (failedCommand.executable === "uv") {
+    if (failedCommand.args.includes("--python")) {
+      console.error(
+        "If uv could not fetch a managed CPython (offline or restricted network), drop the version pin and retry: THREADNOTE_OPENVIKING_PYTHON= threadnote install --force"
+      );
+    }
+    console.error("If it was killed mid-build, clear the partial install first, then retry:");
+    console.error("  uv cache clean");
+    console.error('  rm -rf "$(uv tool dir)/openviking"');
   }
 }
 async function offerToInstallUv() {
@@ -13147,12 +13614,33 @@ async function getPythonSystemCertificatesInstallCommand(serverPath) {
   }
   return { executable: pythonPath, args: ["-m", "pip", "install", PYTHON_SYSTEM_CERTS_PACKAGE] };
 }
+function localEmbedWheelIndexUrl() {
+  const override = process.env.THREADNOTE_LLAMA_WHEEL_INDEX;
+  if (override !== void 0) {
+    return override.trim() === "" ? void 0 : override.trim();
+  }
+  const base = "https://abetlen.github.io/llama-cpp-python/whl";
+  return (0, import_node_os6.platform)() === "darwin" ? `${base}/metal` : `${base}/cpu`;
+}
+function openVikingToolPython() {
+  const override = process.env.THREADNOTE_OPENVIKING_PYTHON;
+  if (override !== void 0) {
+    return override.trim() === "" ? void 0 : override.trim();
+  }
+  return OPENVIKING_TOOL_PYTHON;
+}
 async function getInstallCommands(config, preferred, force) {
   const packageSpec = `${OPENVIKING_PACKAGE_NAME}==${config.openVikingVersion}`;
+  const wheelIndex = localEmbedWheelIndexUrl();
   const manager = preferred ?? await detectPackageManager();
   if (manager === "pipx") {
+    const installArgs = force ? ["install", "--force"] : ["install"];
+    if (wheelIndex) {
+      installArgs.push("--pip-args", `--extra-index-url ${wheelIndex}`);
+    }
+    installArgs.push(packageSpec);
     return [
-      { executable: "pipx", args: force ? ["install", "--force", packageSpec] : ["install", packageSpec] },
+      { executable: "pipx", args: installArgs },
       {
         executable: "pipx",
         args: force ? ["inject", "--force", "openviking", PYTHON_SYSTEM_CERTS_PACKAGE] : ["inject", "openviking", PYTHON_SYSTEM_CERTS_PACKAGE]
@@ -13160,7 +13648,16 @@ async function getInstallCommands(config, preferred, force) {
     ];
   }
   if (manager === "uv") {
-    const uvArgs = ["tool", "install", "--native-tls", "--with", PYTHON_SYSTEM_CERTS_PACKAGE];
+    const toolPython = openVikingToolPython();
+    const uvArgs = [
+      "tool",
+      "install",
+      "--native-tls",
+      ...toolPython ? ["--python", toolPython] : [],
+      "--with",
+      PYTHON_SYSTEM_CERTS_PACKAGE,
+      ...wheelIndex ? ["--extra-index-url", wheelIndex] : []
+    ];
     return [
       {
         executable: "uv",
@@ -13172,6 +13669,9 @@ async function getInstallCommands(config, preferred, force) {
   if (force) {
     pipArgs.push("--upgrade", "--force-reinstall");
   }
+  if (wheelIndex) {
+    pipArgs.push("--extra-index-url", wheelIndex);
+  }
   pipArgs.push(PYTHON_SYSTEM_CERTS_PACKAGE);
   pipArgs.push(packageSpec);
   return [{ executable: "python3", args: pipArgs }];
@@ -14690,7 +15190,7 @@ async function main() {
   program2.command("migrate-lifecycle").description("Move clear legacy handoff memories into lifecycle-aware archive paths").option("--apply", "Perform the migration; without this, prints a dry run").option("--dry-run", "Print migration actions without writing or removing memories").option("--limit <count>", "Maximum number of legacy handoffs to migrate").action(async (options) => {
     await runMigrateLifecycle(getRuntimeConfig(program2), options);
   });
-  program2.command("recall").description("Search shared OpenViking context").requiredOption("--query <query>", "Search query").option("--dry-run", "Print ov command without searching").option("--include-archived", "Include archived memories in exact memory/resource matches").option("-n, --node-limit <count>", "Maximum number of search results").option("--no-infer-scope", "Disable query-based scope inference").option("--project <name>", "Prioritize a project: add a scoped pass over its memories alongside the global search").option("--threshold <score>", "Minimum relevance score 0-1 (default 0.45); lower to broaden when recall is empty").option("--uri <uri>", "Restrict search to a viking:// URI").action(async (options) => {
+  program2.command("recall").description("Search shared OpenViking context").requiredOption("--query <query>", "Search query").option("--dry-run", "Print ov command without searching").option("--include-archived", "Include archived memories in recall results").option("-n, --node-limit <count>", "Maximum number of search results").option("--no-infer-scope", "Disable query-based scope inference").option("--project <name>", "Prioritize a project: add a scoped pass over its memories alongside the global search").option("--threshold <score>", "Minimum relevance score 0-1 (default 0.45); lower to broaden when recall is empty").option("--uri <uri>", "Restrict search to a viking:// URI").action(async (options) => {
     await runRecall(getRuntimeConfig(program2), options);
   });
   program2.command("compact").description("Plan or apply scoped memory hygiene for active personal memories").requiredOption("--project <name>", "Project/repo namespace to inspect").option("--apply", "Apply the compact plan; without this, prints a dry run").option("--dry-run", "Print the compact plan without changing anything").option("--kind <kind>", "durable, handoff, or incident", parseCompactKind).option("--topic <name>", "Stable topic name to inspect").action(async (options) => {
@@ -14733,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);
   });