threadnote 1.3.3 → 1.4.0

package/dist/mcp_server.cjs

@@ -39359,7 +39359,7 @@ function registerTools(server, config2) {
       }
     },
     async ({ recursive, uri }) => {
-      const checkedUri = requiredVikingUri(uri, "forget", "viking://agent/threadnote/memories/example.md");
+      const checkedUri = requiredVikingUri(uri, "forget", "viking://user/you/memories/example.md");
       if (!checkedUri.ok) {
         return checkedUri.error;
       }
@@ -39603,8 +39603,6 @@ function registerOpenVikingParityTools(server, config2) {
         limit: external_exports.number().int().positive().max(1e3).optional().describe("Maximum result count"),
         minScore: external_exports.number().min(0).max(1).optional().describe("Minimum score threshold"),
         min_score: external_exports.number().min(0).max(1).optional().describe("Minimum score threshold"),
-        peerId: external_exports.string().optional().describe("Optional native peer id"),
-        peer_id: external_exports.string().optional().describe("Optional native peer id"),
         query: external_exports.string().optional().describe("Required search query"),
         sessionId: external_exports.string().optional().describe("Optional native session id"),
         session_id: external_exports.string().optional().describe("Optional native session id"),
@@ -40081,7 +40079,7 @@ async function collectExactMemoryMatches(config2, query, includeArchived, projec
   return collectExactMatches(terms, scopes, async (term, scope) => {
     const result = await runCommand(
       ov,
-      withIdentity2(config2, ["grep", term, "--uri", scope, "--node-limit", "5", "--output", "json"]),
+      withIdentity(config2, ["grep", term, "--uri", scope, "--node-limit", "5", "--output", "json"]),
       { allowFailure: true }
     );
     return result.exitCode === 0 ? result.stdout : void 0;
@@ -40099,7 +40097,7 @@ function registerReadTool(server, config2, name, description) {
       }
     },
     async ({ uri, uris }) => {
-      const checkedUris = requiredVikingUriList(uris ?? uri, name, "viking://agent/threadnote/memories/.abstract.md");
+      const checkedUris = requiredVikingUriList(uris ?? uri, name, "viking://user/you/memories/.abstract.md");
       if (!checkedUris.ok) {
         return checkedUris.error;
       }
@@ -40526,11 +40524,11 @@ async function writeSharedMemoryReplacement(config2, ov, params, targetUri) {
   return { content: [{ type: "text", text: messages.join("\n") }] };
 }
 async function vikingResourceExists2(ov, config2, uri) {
-  const stat2 = await runCommand(ov, withIdentity2(config2, ["stat", uri]), { allowFailure: true });
+  const stat2 = await runCommand(ov, withIdentity(config2, ["stat", uri]), { allowFailure: true });
   return stat2.exitCode === 0;
 }
 async function removeVikingResourceWithRetry(ov, config2, uri, recursive = false) {
-  const args = withIdentity2(config2, ["rm", uri, ...recursive ? ["--recursive"] : []]);
+  const args = withIdentity(config2, ["rm", uri, ...recursive ? ["--recursive"] : []]);
   for (let attempt = 0; attempt < 4; attempt += 1) {
     const result = await runCommand(ov, args, { allowFailure: true });
     if (result.exitCode === 0) {
@@ -40570,13 +40568,13 @@ ${stdout2}`.toLowerCase();
 }
 async function ensureMemoryDirectory(ov, config2, directoryUri) {
   for (const uri of vikingDirectoryChain(directoryUri)) {
-    const statResult = await runCommand(ov, withIdentity2(config2, ["stat", uri]), { allowFailure: true });
+    const statResult = await runCommand(ov, withIdentity(config2, ["stat", uri]), { allowFailure: true });
     if (statResult.exitCode === 0) {
       continue;
     }
     await runCommand(
       ov,
-      withIdentity2(config2, ["mkdir", uri, "--description", "Threadnote lifecycle-aware local memories."])
+      withIdentity(config2, ["mkdir", uri, "--description", "Threadnote lifecycle-aware local memories."])
     );
   }
 }
@@ -40793,7 +40791,7 @@ ${text}`);
 async function runOpenVikingCliReadTool(config2, uri) {
   try {
     const ov = await requiredOpenVikingCli2();
-    const result = await runCommand(ov, withIdentity2(config2, ["read", uri]));
+    const result = await runCommand(ov, withIdentity(config2, ["read", uri]));
     const text = [result.stdout.trim(), result.stderr.trim()].filter(Boolean).join("\n");
     return { content: [{ type: "text", text: text || "OK" }] };
   } catch (err) {
@@ -40803,7 +40801,7 @@ async function runOpenVikingCliReadTool(config2, uri) {
 async function runOpenVikingTool(config2, args) {
   try {
     const ov = await requiredOpenVikingCli2();
-    const result = await runCommand(ov, withIdentity2(config2, args));
+    const result = await runCommand(ov, withIdentity(config2, args));
     const text = [result.stdout.trim(), result.stderr.trim()].filter(Boolean).join("\n");
     return { content: [{ type: "text", text: text || "OK" }] };
   } catch (err) {
@@ -41048,9 +41046,6 @@ function shareArtifactToolHeader(team, syncedTeams, warnings) {
   }
   return lines;
 }
-function withIdentity2(config2, args) {
-  return [...args, "--account", config2.account, "--user", config2.user, "--agent-id", config2.agentId];
-}
 async function requiredOpenVikingCli2() {
   const command2 = await findOpenVikingCli();
   if (!command2) {

package/dist/threadnote.cjs

@@ -3394,7 +3394,7 @@ var program = new Command();
 // src/constants.ts
 var DEFAULT_HOST = "127.0.0.1";
 var DEFAULT_PORT = 1933;
-var DEFAULT_OPENVIKING_VERSION = "0.3.24";
+var DEFAULT_OPENVIKING_VERSION = "0.4.4";
 var OPENVIKING_TOOL_PYTHON = "3.12";
 var DEFAULT_ACCOUNT = "local";
 var DEFAULT_AGENT_ID = "threadnote";
@@ -3412,6 +3412,7 @@ var USER_INSTRUCTIONS_START_MARKER = "<!-- BEGIN THREADNOTE USER INSTRUCTIONS --
 var USER_INSTRUCTIONS_END_MARKER = "<!-- END THREADNOTE USER INSTRUCTIONS -->";
 var USER_MANIFEST_NAME = "seed-manifest.yaml";
 var SEED_STATE_FILE = "seed-state.json";
+var SEED_WATCH_INTERVAL_ENV = "THREADNOTE_SEED_WATCH_INTERVAL";
 var USER_AGENT_INSTRUCTION_TARGETS = [
   { kind: "block", label: "codex user instructions", path: "~/.codex/AGENTS.md" },
   { kind: "block", label: "claude user instructions", path: "~/.claude/CLAUDE.md" },
@@ -3915,24 +3916,34 @@ function compareVersions(a, b) {
       return difference;
     }
   }
-  if (left.prerelease === right.prerelease) {
-    return 0;
+  const rankDelta = suffixRank(left.suffix) - suffixRank(right.suffix);
+  if (rankDelta !== 0) {
+    return rankDelta;
   }
-  if (left.prerelease === void 0) {
-    return 1;
+  if (left.suffix === right.suffix) {
+    return 0;
   }
-  if (right.prerelease === void 0) {
-    return -1;
+  return (left.suffix ?? "").localeCompare(right.suffix ?? "");
+}
+function suffixRank(suffix) {
+  if (suffix === void 0) {
+    return 0;
   }
-  return left.prerelease.localeCompare(right.prerelease);
+  return /^post/i.test(suffix) ? 1 : -1;
 }
 function parseVersion(version) {
-  const normalized = version.trim().replace(/^v/, "");
-  const [core, prerelease] = normalized.split("-", 2);
-  const parts = core.split(".").map((part) => Number(part));
+  const normalized = version.trim().replace(/^v/, "").split("+", 1)[0];
+  const core = normalized.match(/^\d+(?:\.\d+){0,2}/)?.[0] ?? "";
+  const rawSuffix = normalized.slice(core.length).replace(/^[-_.]/, "");
+  const suffix = core.length > 0 && rawSuffix.length > 0 ? rawSuffix : void 0;
+  const parts = core.split(".");
   return {
-    numbers: [safeVersionNumber(parts[0]), safeVersionNumber(parts[1]), safeVersionNumber(parts[2])],
-    prerelease
+    numbers: [
+      safeVersionNumber(Number.parseInt(parts[0] ?? "", 10)),
+      safeVersionNumber(Number.parseInt(parts[1] ?? "", 10)),
+      safeVersionNumber(Number.parseInt(parts[2] ?? "", 10))
+    ],
+    suffix
   };
 }
 function safeVersionNumber(value) {
@@ -12254,7 +12265,7 @@ async function checkForThreadnoteUpdate(args) {
   }
   const cached = await readUpdateCache(args.cachePath);
   if (cached && isCacheFresh(cached)) {
-    return compareVersions2(args.currentVersion, cached.latestVersion);
+    return toUpdateCheckResult(args.currentVersion, cached.latestVersion);
   }
   const fresh = await fetchLatestVersion();
   if (fresh) {
@@ -12263,10 +12274,10 @@ async function checkForThreadnoteUpdate(args) {
       latestVersion: fresh,
       version: 1
     });
-    return compareVersions2(args.currentVersion, fresh);
+    return toUpdateCheckResult(args.currentVersion, fresh);
   }
   if (cached) {
-    return compareVersions2(args.currentVersion, cached.latestVersion);
+    return toUpdateCheckResult(args.currentVersion, cached.latestVersion);
   }
   return void 0;
 }
@@ -12284,27 +12295,13 @@ function spawnDetachedAutoUpdate() {
   } catch {
   }
 }
-function compareVersions2(currentVersion, latestVersion) {
+function toUpdateCheckResult(currentVersion, latestVersion) {
   return {
     currentVersion,
     latestVersion,
-    outdated: isNewerVersion(latestVersion, currentVersion)
+    outdated: compareVersions(latestVersion, currentVersion) > 0
   };
 }
-function isNewerVersion(candidate, baseline) {
-  const candidateParts = parseVersion2(candidate);
-  const baselineParts = parseVersion2(baseline);
-  for (let index = 0; index < 3; index += 1) {
-    if (candidateParts[index] !== baselineParts[index]) {
-      return candidateParts[index] > baselineParts[index];
-    }
-  }
-  return false;
-}
-function parseVersion2(value) {
-  const parts = value.split(".").map((part) => parseInt(part, 10));
-  return [parts[0] || 0, parts[1] || 0, parts[2] || 0];
-}
 function isCacheFresh(cache) {
   const checkedAt = new Date(cache.checkedAt).getTime();
   return Number.isFinite(checkedAt) && Date.now() - checkedAt < CACHE_TTL_MS;
@@ -12584,10 +12581,24 @@ async function emitUpdateBannerIfOutdated(config) {
 // src/seeding.ts
 var import_promises9 = require("node:fs/promises");
 var import_node_path12 = require("node:path");
+function parseSeedWatchIntervalMinutes(rawValue) {
+  if (rawValue === void 0) {
+    return void 0;
+  }
+  const minutes = Number.parseInt(rawValue.trim(), 10);
+  return Number.isInteger(minutes) && minutes > 0 ? minutes : void 0;
+}
+function seedWatchArgs(params) {
+  if (params.watchIntervalMinutes === void 0 || !params.importedOriginal || params.redactionProne) {
+    return [];
+  }
+  return ["--watch-interval", String(params.watchIntervalMinutes)];
+}
 async function runSeed(config, options) {
   const manifest = await readSeedManifest(config.manifestPath);
   const ignorePatterns = await loadIgnorePatterns();
   const ov = await openVikingCliForMode(options.dryRun === true);
+  const watchIntervalMinutes = parseSeedWatchIntervalMinutes(process.env[SEED_WATCH_INTERVAL_ENV]);
   const statePath = (0, import_node_path12.join)(config.agentContextHome, SEED_STATE_FILE);
   const state = options.force === true ? { files: {}, version: 1 } : await readSeedState(statePath);
   const projects = filterProjects(manifest.projects, options.only);
@@ -12620,6 +12631,11 @@ async function runSeed(config, options) {
         candidate.destinationUri,
         "--reason",
         seedResourceReason(candidate),
+        ...seedWatchArgs({
+          watchIntervalMinutes,
+          importedOriginal: importPath === candidate.filePath,
+          redactionProne: shouldRedactPath(candidate.relativePath)
+        }),
         "--wait"
       ]);
       await maybeRun(options.dryRun === true, ov, args);
@@ -13701,6 +13717,8 @@ async function collectDoctorChecks(config, options = {}) {
   checks.push(await commandCheck("python3", ["--version"]));
   checks.push(await openVikingServerCheck());
   checks.push(await openVikingCliCheck());
+  checks.push(await openVikingVersionCheck(config));
+  checks.push(await recallShapeCheck(config));
   checks.push(await localEmbeddingCheck());
   checks.push(await pythonSystemCertificatesCheck());
   checks.push(await firstCommandCheck("python installer", ["pipx", "uv", "pip3"], ["--version"]));
@@ -13962,21 +13980,13 @@ async function configureOpenVikingCliLanguage(config, dryRun) {
   if (!ov) {
     return;
   }
-  const installedVersion = dryRun ? void 0 : await readOpenVikingCliVersion2(ov);
+  const installedVersion = dryRun ? void 0 : await readOpenVikingCliVersion(ov);
   const effectiveVersion = installedVersion ?? config.openVikingVersion;
   if (compareVersions(effectiveVersion, "0.3.23") < 0) {
     return;
   }
   await maybeRun(dryRun, ov, ["language", "en"], { allowFailure: true });
 }
-async function readOpenVikingCliVersion2(ov) {
-  const result = await runCommand(ov, ["version"], { allowFailure: true });
-  if (result.exitCode !== 0) {
-    return void 0;
-  }
-  const match = result.stdout.match(/^\s*CLI:\s*(\S+)/m);
-  return match ? match[1] : void 0;
-}
 async function findOpenVikingServer() {
   const onPath = await findExecutable([OPENVIKING_SERVER_COMMAND]);
   if (onPath) {
@@ -14213,6 +14223,59 @@ async function openVikingCliCheck() {
     detail: result.exitCode === 0 ? detail : firstLine(result.stderr || result.stdout) || detail
   };
 }
+async function openVikingVersionCheck(config) {
+  const executable = await findOpenVikingCli();
+  const pinned = config.openVikingVersion;
+  if (!executable) {
+    return { name: "openviking version", status: "warn", detail: `CLI not found; pinned ${pinned}` };
+  }
+  const installed = await readOpenVikingCliVersion(executable);
+  if (!installed) {
+    return {
+      name: "openviking version",
+      status: "warn",
+      detail: `could not detect via \`${executable} version\`; pinned ${pinned}`
+    };
+  }
+  if (compareVersions(installed, pinned) < 0) {
+    return {
+      name: "openviking version",
+      status: "warn",
+      detail: `installed ${installed} is older than pinned ${pinned}; run \`threadnote repair\` or \`threadnote update\` to upgrade`
+    };
+  }
+  return { name: "openviking version", status: "ok", detail: `${installed} (pinned ${pinned})` };
+}
+async function recallShapeCheck(config) {
+  const executable = await findOpenVikingCli();
+  if (!executable) {
+    return { name: "recall shape", status: "warn", detail: "CLI not found" };
+  }
+  const args = withIdentity(config, ["find", "threadnote", "--node-limit", "1", "--output", "json"]);
+  const result = await runCommand(executable, args, { allowFailure: true });
+  if (result.exitCode !== 0) {
+    return { name: "recall shape", status: "warn", detail: "search failed; run threadnote repair" };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(result.stdout.trim());
+  } catch {
+    return {
+      name: "recall shape",
+      status: "warn",
+      detail: "search output is not JSON; recall may silently return nothing"
+    };
+  }
+  const buckets = ["memories", "resources", "skills"];
+  if (!isJsonObject(parsed) || !buckets.some((key) => Array.isArray(parsed[key]))) {
+    return {
+      name: "recall shape",
+      status: "warn",
+      detail: `search JSON missing ${buckets.join("/")} buckets; recall parsing is out of sync with this OpenViking`
+    };
+  }
+  return { name: "recall shape", status: "ok", detail: "memories/resources/skills buckets present" };
+}
 async function localEmbeddingCheck() {
   const serverPath = await findOpenVikingServer();
   if (!serverPath) {

package/docs/agent-instructions.md

@@ -193,8 +193,8 @@ Use these only when MCP tools are not available:
 threadnote start
 threadnote recall --query "last handoff for this branch"
 threadnote recall --query "durable feature knowledge for this branch"
-threadnote read viking://agent/threadnote/memories/.abstract.md
-threadnote list viking://agent/threadnote/memories --all --recursive
+threadnote read viking://user/example/memories/.abstract.md
+threadnote list viking://user/example/memories --all --recursive
 threadnote remember --kind durable --project example --topic workflow --text "Durable engineering note..."
 threadnote remember --kind durable --project example --topic active-issue --text "Feature knowledge..."
 threadnote remember --replace viking://user/example/memories/durable/projects/example/workflow.md --text "Updated durable engineering note..."

package/docs/index.html

@@ -1147,7 +1147,7 @@
 <span class="out">--user`, which fails on PEP 668 setups.</span>
 <span class="out">Install uv now? [Y/n] </span><span class="out-strong">Y</span>
 <span class="out">Installing uv via Homebrew…</span>
-<span class="out-strong">OK   openviking 0.3.24 ready · server healthy</span></pre>
+<span class="out-strong">OK   openviking 0.4.4 ready · server healthy</span></pre>
               </div>
               <p class="muted" style="margin-top: 0.75rem; font-size: 0.9rem">
                 Or manually: <code>npm install -g threadnote && threadnote install</code>. On a fresh macOS / modern
@@ -1651,7 +1651,7 @@ threadnote doctor --dry-run</code></pre>
           </div>
 
           <p class="colophon">
-            threadnote · AGPL-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.4.4 · use <span class="kbd">↑</span>
             <span class="kbd">↓</span> / <span class="kbd">j</span> <span class="kbd">k</span> to navigate
           </p>
         </div>

package/docs/migration.md

@@ -108,6 +108,12 @@ paths.
    threadnote seed
    ```
 
+   Seeded docs refresh on the next `threadnote seed`/`repair`, which re-runs the
+   secret scan. To let OpenViking auto-refresh them between runs, opt in with
+   `THREADNOTE_SEED_WATCH_INTERVAL=<minutes> threadnote seed`. Watches attach
+   only to original, non-redaction-prone files, since an OpenViking-managed
+   refresh re-ingests the file without Threadnote's per-import secret scan.
+
 7. Inspect and seed shared skills:
 
    ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "threadnote",
-  "version": "1.3.3",
+  "version": "1.4.0",
   "type": "commonjs",
   "main": "dist/threadnote.cjs",
   "description": "Shared local context and handoffs for development agents",