threadnote 0.3.7 → 0.3.8

package/README.md

@@ -7,12 +7,17 @@ and it does not index whole repositories by default.
 ## Real-World Uses
 
 **Want to continue work in a fresh agent session?**  
-`threadnote install` adds user-level Codex, Claude, and Cursor instructions so new agents automatically recall recent handoffs and relevant memories before they start changing code.
+`threadnote install` adds user-level Codex, Claude, Cursor, and Copilot instructions so new agents automatically recall recent handoffs and relevant memories before they start changing code.
+
+**Working on a feature branch over several sessions?**
+Agents recall the branch handoff for current status, then recall durable feature memories for the design, decisions,
+interfaces, and gotchas behind the feature. As useful implementation knowledge appears, agents update the durable feature
+memory instead of leaving everything buried in transient handoffs.
 
 **Implemented a feature a while ago and need to pick it up again?**  
 Ask the agent to recall the feature, branch, or repo. Threadnote returns auditable `viking://` pointers that the agent can read before deciding what still matters.
 
-**Switching between Codex, Claude, and Cursor?**\
+**Switching between Codex, Claude, Cursor, and Copilot?**\
 Install the MCP adapter for each agent you use. The user-level instructions tell agents to store a handoff before they pause, so the next agent can search the same local memory layer instead of reconstructing context
 from chat history.
 
@@ -49,6 +54,16 @@ Active memories with the same project/topic write to a stable lifecycle path, so
 version instead of creating another timestamped note. Untagged memories still use timestamped files when you want a
 historical trail.
 
+For feature branches, keep a durable feature memory and an active handoff side by side with the same project/topic:
+
+```bash
+threadnote remember --kind durable --project my-repo --topic feature-x --text "Feature knowledge: ..."
+threadnote handoff --project my-repo --topic feature-x --task "Current status for feature X"
+```
+
+Agents should update the durable feature memory when valuable implementation knowledge changes, and update the handoff
+when current status, tests, blockers, or next steps change.
+
 Use `archive` when an old handoff is useful for provenance but should stop being treated as current working context:
 
 ```bash
@@ -72,11 +87,12 @@ refactor, what an on-call investigation concluded, which workaround was verified
 memories should be compacted. Putting that history into instruction files makes them noisy, stale, and expensive to load
 into every context window.
 
-Threadnote keeps that moving layer local, searchable, and shared across agents. Agents recall only the relevant memories,
-handoffs, and skill/resource pointers when they need them, while the source files stay authoritative for project rules.
+Threadnote keeps that moving layer local, searchable, and shared across agents. Agents recall only the relevant durable
+feature memories, handoffs, and skill/resource pointers when they need them, while the source files stay authoritative
+for project rules.
 
-The split is simple: put durable repo policy in `CLAUDE.md`/`AGENTS.md`; put task history, handoffs, personal workflow
-facts, and local cross-agent memory in Threadnote.
+The split is simple: put durable repo policy in `CLAUDE.md`/`AGENTS.md`; put feature knowledge, task history, handoffs,
+personal workflow facts, and local cross-agent memory in Threadnote.
 
 ## Safety Model
 
@@ -87,8 +103,9 @@ facts, and local cross-agent memory in Threadnote.
 - Redaction: known config files such as `.mcp.json`, `config.toml`, and settings JSON are copied through a redactor
   before import.
 - Secret scanning: candidate files are skipped if common token or private-key patterns remain after redaction.
-- User instructions: `install` upserts a managed Threadnote block in `~/.codex/AGENTS.md`, `~/.claude/CLAUDE.md`, and
-  `~/.cursor/rules/threadnote.md` without replacing existing personal instructions.
+- User instructions: `install` upserts managed Threadnote guidance in `~/.codex/AGENTS.md`, `~/.claude/CLAUDE.md`,
+  `~/.cursor/rules/threadnote.md`, and `~/.copilot/instructions/threadnote.instructions.md` without replacing existing
+  personal instructions.
 - Agent config changes are explicit: `mcp-install` prints commands and snippets by default; use `--apply` to run them.
 
 ## Install
@@ -145,7 +162,7 @@ threadnote update --check
 threadnote update --dry-run
 ```
 
-After updating, restart Cursor, Codex, Claude, or open a fresh agent session so MCP tools reload.
+After updating, restart Cursor, Copilot, Codex, Claude, or open a fresh agent session so MCP tools reload.
 
 Some releases include post-update memory migrations. `threadnote update` runs the new package's migration prompt after
 repair, explains what will change, and asks before applying it. Use `threadnote update --yes` for unattended local
@@ -167,6 +184,7 @@ Dry-run examples:
 threadnote mcp-install codex
 threadnote mcp-install claude
 threadnote mcp-install cursor
+threadnote mcp-install copilot
 ```
 
 Apply after review:
@@ -175,11 +193,14 @@ Apply after review:
 threadnote mcp-install codex --apply
 threadnote mcp-install claude --apply
 threadnote mcp-install cursor --apply
+threadnote mcp-install copilot --apply
 ```
 
 Claude installs at `user` scope by default so the same OpenViking MCP server is available from any repo or worktree.
 Use `--scope local` or `--scope project` only when you intentionally want repo-scoped Claude MCP config.
 Cursor installs by updating the global `~/.cursor/mcp.json` file.
+Copilot installs by updating the VS Code user-profile `mcp.json` file. Set `THREADNOTE_COPILOT_MCP_CONFIG` if you use a
+custom VS Code profile or want to test against a temporary file.
 
 If the package or checkout that originally installed `threadnote` has moved, run repair:
 
@@ -199,6 +220,7 @@ claude mcp add threadnote -- threadnote-mcp-server
 ```
 
 Cursor uses the equivalent entry in `~/.cursor/mcp.json`.
+Copilot uses the VS Code MCP `servers` entry in the user-profile `mcp.json`.
 
 If a future OpenViking build exposes a healthy native endpoint, install it explicitly:
 
@@ -255,8 +277,8 @@ This is it! Start working with your agents as usual. The agent will automaticall
   `--no-start` to skip the health check.
 - `update`: updates the published Threadnote package, then runs `repair` so shims and MCP config point at the new
   version.
-- `repair`: fixes install/config/shim/manifest/server health issues and rewrites Codex/Claude/Cursor MCP configs from the
-  current checkout.
+- `repair`: fixes install/config/shim/manifest/server health issues and rewrites Codex/Claude/Cursor/Copilot MCP configs
+  from the current checkout.
 - `start`: starts `openviking-server` on `127.0.0.1:1933`.
 - `stop`: stops the detached server pid or macOS LaunchAgent.
 - `uninstall`: removes Threadnote shims, MCP config, launchd config, and managed user instructions. Memories are
@@ -265,7 +287,8 @@ This is it! Start working with your agents as usual. The agent will automaticall
 - `seed`: imports curated repo guidance and docs from the manifest.
 - `seed-skills`: imports global and repo-local `SKILL.md` files as a searchable resource catalog so agents can discover
   reusable workflow guidance. Use `seed-skills --native` only after configuring a working VLM provider.
-- `mcp-install codex|claude|cursor`: installs or prints OpenViking MCP configuration for Codex, Claude, or Cursor.
+- `mcp-install codex|claude|cursor|copilot`: installs or prints OpenViking MCP configuration for Codex, Claude, Cursor,
+  or GitHub Copilot in VS Code.
 - `remember`: stores a durable memory. Use `--replace <uri>` to store an updated memory and remove a superseded one
   after the new memory succeeds. Use `--kind`, `--project`, and `--topic` to store lifecycle-aware current knowledge.
 - `migrate-memories`: migrates legacy session-only `MEMORY` and `HANDOFF` records into durable memory files. Run
@@ -299,8 +322,9 @@ npm run threadnote -- install
 ```
 
 `install` writes a small command shim to `~/.local/bin/threadnote` by default and upserts user-level agent guidance in
-`~/.codex/AGENTS.md`, `~/.claude/CLAUDE.md`, and `~/.cursor/rules/threadnote.md`. After that, use the short command from
-any repo or working directory:
+`~/.codex/AGENTS.md`, `~/.claude/CLAUDE.md`, `~/.cursor/rules/threadnote.md`, and
+`~/.copilot/instructions/threadnote.instructions.md`. After that, use the short command from any repo or working
+directory:
 
 ```bash
 threadnote doctor --dry-run
@@ -329,6 +353,7 @@ Environment variables:
 - `THREADNOTE_NPM_REGISTRY`: npm registry used by the installer and updater, default `https://registry.npmjs.org/`.
 - `THREADNOTE_NO_UPDATE_CHECK`: disables opportunistic update notifications.
 - `THREADNOTE_BIN_DIR`: directory for the `threadnote` shim, default `~/.local/bin`.
+- `THREADNOTE_COPILOT_MCP_CONFIG`: explicit VS Code/Copilot `mcp.json` path for `mcp-install copilot`.
 - `THREADNOTE_HOST`: local bind host, default `127.0.0.1`.
 - `THREADNOTE_PORT`: local bind port, default `1933`.
 

package/dist/mcp_server.cjs

@@ -31096,7 +31096,9 @@ async function main() {
         'Always pass JSON arguments. Example: recall_context({"query":"current repo latest handoff"}).',
         "Older clients may use the compatibility aliases `search`, `read`, and `list`.",
         'For durable facts, store kind="durable"; for current work logs, store kind="handoff" with project/topic so Threadnote keeps one active memory updated.',
-        "When updating the same active issue, pass project/topic or replaceUri to remember_context so duplicate handoffs do not accumulate.",
+        "When a handoff describes an active branch or feature, recall durable feature memories for the same branch/topic before coding.",
+        "During feature work, update durable feature knowledge when valuable implementation details, decisions, interfaces, or gotchas change.",
+        "When updating the same active issue, pass project/topic or replaceUri to remember_context so duplicate durable memories or handoffs do not accumulate.",
         "Do not store secrets, customer data, raw production logs, or credentials."
       ].join("\n")
     }
@@ -31411,7 +31413,7 @@ function registerStoreTool(server, config2, name, description) {
         project: external_exports.string().optional().describe("Project/repo namespace, for example threadnote or mobile-native"),
         replaceUri: external_exports.string().optional().describe("Optional viking:// memory URI to forget after the new memory is safely stored"),
         text: external_exports.string().optional().describe("Required memory text to store"),
-        sourceAgentClient: external_exports.string().optional().describe("Originating client, for example cursor, codex, or claude"),
+        sourceAgentClient: external_exports.string().optional().describe("Originating client, for example cursor, copilot, codex, or claude"),
         status: external_exports.enum(["active", "archived", "superseded"]).optional().describe("Memory lifecycle status"),
         topic: external_exports.string().optional().describe("Stable topic; active project/topic memories update one file")
       }

package/dist/threadnote.cjs

@@ -3489,9 +3489,14 @@ 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 USER_AGENT_INSTRUCTION_TARGETS = [
-  { label: "codex user instructions", path: "~/.codex/AGENTS.md" },
-  { label: "claude user instructions", path: "~/.claude/CLAUDE.md" },
-  { label: "cursor user rule", path: "~/.cursor/rules/threadnote.md" }
+  { kind: "block", label: "codex user instructions", path: "~/.codex/AGENTS.md" },
+  { kind: "block", label: "claude user instructions", path: "~/.claude/CLAUDE.md" },
+  { kind: "block", label: "cursor user rule", path: "~/.cursor/rules/threadnote.md" },
+  {
+    kind: "file",
+    label: "copilot user instructions",
+    path: "~/.copilot/instructions/threadnote.instructions.md"
+  }
 ];
 var DEFAULT_SEED_PATTERNS = [
   "AGENTS.md",
@@ -3981,6 +3986,7 @@ function errorMessage(err) {
 }
 
 // src/mcp.ts
+var import_node_fs2 = require("node:fs");
 var import_promises2 = require("node:fs/promises");
 var import_node_path2 = require("node:path");
 var import_node_os2 = require("node:os");
@@ -4010,6 +4016,15 @@ async function runMcpInstall(config, agent, options) {
     });
     return;
   }
+  if (agent === "copilot") {
+    await runCopilotMcpInstall(config, name, {
+      apply,
+      bearerTokenEnvVar: options.bearerTokenEnvVar,
+      nativeHttp,
+      url
+    });
+    return;
+  }
   const command = buildMcpInstallCommand(config, agent, name, {
     bearerTokenEnvVar: options.bearerTokenEnvVar,
     nativeHttp,
@@ -4059,6 +4074,34 @@ async function runCursorMcpInstall(config, name, options) {
   await (0, import_promises2.writeFile)(path, nextContent, { encoding: "utf8", mode: 420 });
   console.log(currentContent === void 0 ? `Wrote Cursor MCP config: ${path}` : `Updated Cursor MCP config: ${path}`);
 }
+async function runCopilotMcpInstall(config, name, options) {
+  const path = copilotMcpConfigPath();
+  const serverConfig = buildCopilotMcpServerConfig(config, {
+    bearerTokenEnvVar: options.bearerTokenEnvVar,
+    nativeHttp: options.nativeHttp,
+    url: options.url
+  });
+  const currentContent = await readFileIfExists(path);
+  const nextContent = renderCopilotMcpConfig(currentContent, name, serverConfig);
+  if (!options.apply) {
+    console.log("Dry run. Re-run with --apply to modify GitHub Copilot MCP config.");
+    printCopilotMcpSnippet(config, name, {
+      bearerTokenEnvVar: options.bearerTokenEnvVar,
+      nativeHttp: options.nativeHttp,
+      url: options.url
+    });
+    return;
+  }
+  if (currentContent === nextContent) {
+    console.log(`Already configured: ${path}`);
+    return;
+  }
+  await ensureDirectory((0, import_node_path2.dirname)(path), false);
+  await (0, import_promises2.writeFile)(path, nextContent, { encoding: "utf8", mode: 420 });
+  console.log(
+    currentContent === void 0 ? `Wrote GitHub Copilot MCP config: ${path}` : `Updated GitHub Copilot MCP config: ${path}`
+  );
+}
 async function removeMcpConfigs(value, dryRun) {
   const clients = await resolveMcpClients(value, "remove");
   if (clients.length === 0) {
@@ -4070,6 +4113,10 @@ async function removeMcpConfigs(value, dryRun) {
       await removeCursorMcpConfig(OPENVIKING_MCP_NAME, dryRun);
       continue;
     }
+    if (client === "copilot") {
+      await removeCopilotMcpConfig(OPENVIKING_MCP_NAME, dryRun);
+      continue;
+    }
     const command = buildMcpRemoveCommand(client, OPENVIKING_MCP_NAME);
     await maybeRun(dryRun, command.executable, command.args, { allowFailure: true, cwd: command.cwd });
   }
@@ -4090,11 +4137,19 @@ async function removeMcpSnippets(config, dryRun) {
     "MCP snippet",
     dryRun
   );
+  await removePathIfExists(
+    (0, import_node_path2.join)(config.agentContextHome, "mcp", `${OPENVIKING_MCP_NAME}.copilot.json`),
+    "MCP snippet",
+    dryRun
+  );
 }
 function buildMcpInstallCommand(config, agent, name, options) {
   if (agent === "cursor") {
     throw new Error("Cursor MCP config is written directly to ~/.cursor/mcp.json.");
   }
+  if (agent === "copilot") {
+    throw new Error("GitHub Copilot MCP config is written directly to the VS Code user mcp.json file.");
+  }
   const claudeCwd = getInvocationCwd();
   const claudeScope = options.scope ?? "user";
   if (!options.nativeHttp) {
@@ -4139,6 +4194,9 @@ function buildMcpRemoveCommand(agent, name) {
   if (agent === "cursor") {
     throw new Error("Cursor MCP config is removed directly from ~/.cursor/mcp.json.");
   }
+  if (agent === "copilot") {
+    throw new Error("GitHub Copilot MCP config is removed directly from the VS Code user mcp.json file.");
+  }
   return agent === "codex" ? { executable: "codex", args: ["mcp", "remove", name] } : { executable: "claude", args: ["mcp", "remove", name], cwd: getInvocationCwd() };
 }
 function mcpEnvironment(config) {
@@ -4171,6 +4229,21 @@ function buildCursorMcpServerConfig(config, options) {
     env: mcpEnvironmentObject(config)
   };
 }
+function buildCopilotMcpServerConfig(config, options) {
+  if (options.nativeHttp) {
+    const server = { type: "http", url: options.url };
+    if (options.bearerTokenEnvVar) {
+      server.headers = { Authorization: `Bearer \${env:${options.bearerTokenEnvVar}}` };
+    }
+    return server;
+  }
+  return {
+    args: [mcpAdapterCommand()[0]],
+    command: "/usr/bin/env",
+    env: mcpEnvironmentObject(config),
+    type: "stdio"
+  };
+}
 function renderCursorMcpConfig(currentContent, name, serverConfig) {
   const parsed = currentContent === void 0 ? {} : parseJsonConfigObject(currentContent);
   if (parsed === void 0) {
@@ -4186,6 +4259,21 @@ function renderCursorMcpConfig(currentContent, name, serverConfig) {
   return `${JSON.stringify(nextConfig, null, 2)}
 `;
 }
+function renderCopilotMcpConfig(currentContent, name, serverConfig) {
+  const parsed = currentContent === void 0 ? {} : parseJsonConfigObject(currentContent);
+  if (parsed === void 0) {
+    throw new Error(`${copilotMcpConfigPath()} exists but is not a JSON object; not modifying it.`);
+  }
+  if (parsed.servers !== void 0 && !isJsonObject(parsed.servers)) {
+    throw new Error(`${copilotMcpConfigPath()} has a non-object servers field; not modifying it.`);
+  }
+  const nextConfig = { ...parsed };
+  const servers = isJsonObject(parsed.servers) ? { ...parsed.servers } : {};
+  servers[name] = serverConfig;
+  nextConfig.servers = servers;
+  return `${JSON.stringify(nextConfig, null, 2)}
+`;
+}
 async function removeCursorMcpConfig(name, dryRun) {
   const path = cursorMcpConfigPath();
   const currentContent = await readFileIfExists(path);
@@ -4215,11 +4303,44 @@ async function removeCursorMcpConfig(name, dryRun) {
   await (0, import_promises2.writeFile)(path, nextContent, { encoding: "utf8", mode: 420 });
   console.log(`Updated Cursor MCP config: ${path}`);
 }
+async function removeCopilotMcpConfig(name, dryRun) {
+  const path = copilotMcpConfigPath();
+  const currentContent = await readFileIfExists(path);
+  if (currentContent === void 0) {
+    console.log(`Already absent: ${path}`);
+    return;
+  }
+  const parsed = parseJsonConfigObject(currentContent);
+  if (parsed === void 0) {
+    console.log(`WARN ${path} exists but is not a JSON object; not modifying it.`);
+    return;
+  }
+  if (!isJsonObject(parsed.servers) || parsed.servers[name] === void 0) {
+    console.log(`No GitHub Copilot MCP config found: ${path}`);
+    return;
+  }
+  const nextConfig = { ...parsed };
+  const servers = { ...parsed.servers };
+  delete servers[name];
+  nextConfig.servers = servers;
+  const nextContent = `${JSON.stringify(nextConfig, null, 2)}
+`;
+  if (dryRun) {
+    console.log(`Would update GitHub Copilot MCP config: ${path}`);
+    return;
+  }
+  await (0, import_promises2.writeFile)(path, nextContent, { encoding: "utf8", mode: 420 });
+  console.log(`Updated GitHub Copilot MCP config: ${path}`);
+}
 function printMcpSnippet(config, agent, name, options) {
   if (agent === "cursor") {
     printCursorMcpSnippet(config, name, { nativeHttp: options.nativeHttp, url: options.url });
     return;
   }
+  if (agent === "copilot") {
+    printCopilotMcpSnippet(config, name, { nativeHttp: options.nativeHttp, url: options.url });
+    return;
+  }
   const snippetPath = (0, import_node_path2.join)(config.agentContextHome, "mcp", `${name}.${agent}.${agent === "codex" ? "toml" : "txt"}`);
   const command = buildMcpInstallCommand(config, agent, name, {
     nativeHttp: options.nativeHttp,
@@ -4239,14 +4360,37 @@ function printCursorMcpSnippet(config, name, options) {
 Snippet (${snippetPath}; merge into ${cursorMcpConfigPath()}):
 ${snippet2}`);
 }
+function printCopilotMcpSnippet(config, name, options) {
+  const snippetPath = (0, import_node_path2.join)(config.agentContextHome, "mcp", `${name}.copilot.json`);
+  const snippet2 = JSON.stringify({ servers: { [name]: buildCopilotMcpServerConfig(config, options) } }, null, 2);
+  console.log(`
+Snippet (${snippetPath}; merge into ${copilotMcpConfigPath()}):
+${snippet2}`);
+}
 function cursorMcpConfigPath() {
   return expandPath("~/.cursor/mcp.json");
 }
+function copilotMcpConfigPath() {
+  if (process.env.THREADNOTE_COPILOT_MCP_CONFIG) {
+    return expandPath(process.env.THREADNOTE_COPILOT_MCP_CONFIG);
+  }
+  if ((0, import_node_os2.platform)() === "darwin") {
+    const stablePath = expandPath("~/Library/Application Support/Code/User/mcp.json");
+    const insidersPath = expandPath("~/Library/Application Support/Code - Insiders/User/mcp.json");
+    return existsSyncDirectory((0, import_node_path2.dirname)(stablePath)) || !existsSyncDirectory((0, import_node_path2.dirname)(insidersPath)) ? stablePath : insidersPath;
+  }
+  if ((0, import_node_os2.platform)() === "win32") {
+    const appData = process.env.APPDATA;
+    return appData ? (0, import_node_path2.join)(appData, "Code", "User", "mcp.json") : expandPath("~/AppData/Roaming/Code/User/mcp.json");
+  }
+  const configHome = process.env.XDG_CONFIG_HOME ? expandPath(process.env.XDG_CONFIG_HOME) : expandPath("~/.config");
+  return (0, import_node_path2.join)(configHome, "Code", "User", "mcp.json");
+}
 function parseAgentClient(value) {
-  if (value === "codex" || value === "claude" || value === "cursor") {
+  if (value === "codex" || value === "claude" || value === "copilot" || value === "cursor") {
     return value;
   }
-  throw new Error(`Unsupported agent: ${value}. Expected codex, claude, or cursor.`);
+  throw new Error(`Unsupported agent: ${value}. Expected codex, claude, copilot, or cursor.`);
 }
 function parseClaudeMcpScope(value) {
   if (value === "local" || value === "project" || value === "user") {
@@ -4261,7 +4405,7 @@ async function resolveMcpClients(value, action) {
   }
   let requested;
   if (normalized === "available" || normalized === "all") {
-    requested = ["codex", "claude", "cursor"];
+    requested = ["codex", "claude", "cursor", "copilot"];
   } else {
     requested = normalized.split(",").map((part) => part.trim()).filter(Boolean).map(parseAgentClient);
   }
@@ -4277,6 +4421,16 @@ async function resolveMcpClients(value, action) {
       }
       continue;
     }
+    if (client === "copilot") {
+      if (!await isCopilotAvailable()) {
+        console.log(`WARN VS Code/Copilot config not found; cannot ${action} copilot MCP config.`);
+        continue;
+      }
+      if (!clients.includes(client)) {
+        clients.push(client);
+      }
+      continue;
+    }
     if (!await findExecutable([client])) {
       console.log(`WARN ${client} command not found; cannot ${action} ${client} MCP config.`);
       continue;
@@ -4296,9 +4450,28 @@ async function isCursorAvailable() {
   }
   return (0, import_node_os2.platform)() === "darwin" && await exists("/Applications/Cursor.app");
 }
+async function isCopilotAvailable() {
+  if (process.env.THREADNOTE_COPILOT_MCP_CONFIG) {
+    return true;
+  }
+  if (await exists((0, import_node_path2.dirname)(copilotMcpConfigPath()))) {
+    return true;
+  }
+  if (await findExecutable(["code", "code-insiders"])) {
+    return true;
+  }
+  return (0, import_node_os2.platform)() === "darwin" && await exists("/Applications/Visual Studio Code.app");
+}
+function existsSyncDirectory(path) {
+  try {
+    return (0, import_node_fs2.statSync)(path).isDirectory();
+  } catch (_err) {
+    return false;
+  }
+}
 
 // src/runtime.ts
-var import_node_fs2 = require("node:fs");
+var import_node_fs3 = require("node:fs");
 var import_node_os3 = require("node:os");
 var import_node_path3 = require("node:path");
 function getRuntimeConfig(program2, manifestOverride) {
@@ -4320,7 +4493,7 @@ function getRuntimeConfig(program2, manifestOverride) {
 }
 function defaultManifestPath(agentContextHome) {
   const userManifest = (0, import_node_path3.join)(agentContextHome, USER_MANIFEST_NAME);
-  return (0, import_node_fs2.existsSync)(userManifest) ? userManifest : builtInExampleManifestPath();
+  return (0, import_node_fs3.existsSync)(userManifest) ? userManifest : builtInExampleManifestPath();
 }
 function builtInExampleManifestPath() {
   return (0, import_node_path3.join)(toolRoot(), "config", "seed-manifest.example.yaml");
@@ -8224,13 +8397,13 @@ function detectSecretMatches(content) {
 
 // src/lifecycle.ts
 var import_node_child_process2 = require("node:child_process");
-var import_node_fs4 = require("node:fs");
+var import_node_fs5 = require("node:fs");
 var import_promises8 = require("node:fs/promises");
 var import_node_os5 = require("node:os");
 var import_node_path7 = require("node:path");
 
 // src/update.ts
-var import_node_fs3 = require("node:fs");
+var import_node_fs4 = require("node:fs");
 var import_promises6 = require("node:fs/promises");
 var import_node_os4 = require("node:os");
 var import_node_path6 = require("node:path");
@@ -8321,7 +8494,9 @@ async function runUpdate(config, options) {
   } else {
     console.log("Skipping post-update migration prompts because --no-post-update was provided.");
   }
-  console.log("Update complete. Restart Cursor, Codex, Claude, or open a fresh agent session so MCP tools reload.");
+  console.log(
+    "Update complete. Restart Cursor, Copilot, Codex, Claude, or open a fresh agent session so MCP tools reload."
+  );
 }
 async function runPostUpdate(config, options) {
   if (!options.fromVersion || !options.toVersion) {
@@ -8614,7 +8789,7 @@ async function runtimeThreadnoteBin(runtime) {
 }
 async function isExecutable(path) {
   try {
-    await (0, import_promises6.access)(path, import_node_fs3.constants.X_OK);
+    await (0, import_promises6.access)(path, import_node_fs4.constants.X_OK);
     return true;
   } catch (_err) {
     return false;
@@ -8922,7 +9097,7 @@ async function runStart(config, options) {
     process.exitCode = result;
     return;
   }
-  const logFd = (0, import_node_fs4.openSync)(logPath, "a");
+  const logFd = (0, import_node_fs5.openSync)(logPath, "a");
   const child = spawnDetachedServerWithLog(server, args, logFd);
   child.unref();
   await (0, import_promises8.writeFile)((0, import_node_path7.join)(config.agentContextHome, "openviking-server.pid"), `${child.pid}
@@ -8940,7 +9115,7 @@ function spawnDetachedServerWithLog(server, args, logFd) {
   try {
     return spawnDetachedServer(server, args, logFd);
   } finally {
-    (0, import_node_fs4.closeSync)(logFd);
+    (0, import_node_fs5.closeSync)(logFd);
   }
 }
 function spawnDetachedServer(server, args, logFd) {
@@ -9076,9 +9251,9 @@ async function commandShimCheck() {
   return { name: "threadnote shim", status: "ok", detail: shimPath };
 }
 async function userAgentInstructionsChecks() {
-  const expectedBlock = await renderUserAgentInstructionsBlock();
   return Promise.all(
     USER_AGENT_INSTRUCTION_TARGETS.map(async (target) => {
+      const expectedInstructions = await renderUserAgentInstructions(target);
       const targetPath = expandPath(target.path);
       const content = await readFileIfExists(targetPath);
       if (content === void 0) {
@@ -9092,7 +9267,7 @@ async function userAgentInstructionsChecks() {
           detail: `${targetPath} missing threadnote block; install will add it`
         };
       }
-      if (existingBlock !== expectedBlock) {
+      if (target.kind === "file" && content !== expectedInstructions || target.kind === "block" && existingBlock !== expectedInstructions) {
         return {
           name: target.label,
           status: "warn",
@@ -9311,11 +9486,15 @@ async function removeCommandShim(dryRun) {
   await removePath(shimPath, "command shim", dryRun);
 }
 async function installUserAgentInstructions(dryRun) {
-  const block = await renderUserAgentInstructionsBlock();
   for (const target of USER_AGENT_INSTRUCTION_TARGETS) {
+    const instructions = await renderUserAgentInstructions(target);
     const targetPath = expandPath(target.path);
     const currentContent = await readFileIfExists(targetPath);
-    const nextContent = upsertManagedBlock(currentContent ?? "", block);
+    if (target.kind === "file" && currentContent !== void 0 && extractManagedBlock(currentContent) === void 0) {
+      console.log(`WARN ${targetPath} is not managed by threadnote; not modifying it`);
+      continue;
+    }
+    const nextContent = target.kind === "file" ? instructions : upsertManagedBlock(currentContent ?? "", instructions);
     if (nextContent === void 0) {
       console.log(`WARN ${targetPath} has partial threadnote markers; not modifying it`);
       continue;
@@ -9341,6 +9520,14 @@ async function removeUserAgentInstructions(dryRun) {
       console.log(`Already absent: ${targetPath}`);
       continue;
     }
+    if (target.kind === "file") {
+      if (extractManagedBlock(currentContent) === void 0) {
+        console.log(`WARN ${targetPath} is not managed by threadnote; not removing it`);
+        continue;
+      }
+      await removePath(targetPath, target.label, dryRun);
+      continue;
+    }
     const nextContent = removeManagedBlock(currentContent);
     if (nextContent === void 0) {
       console.log(`WARN ${targetPath} has partial threadnote markers; not modifying it`);
@@ -9362,6 +9549,21 @@ async function removeUserAgentInstructions(dryRun) {
     console.log(`Updated ${targetPath}`);
   }
 }
+async function renderUserAgentInstructions(target) {
+  const block = await renderUserAgentInstructionsBlock();
+  if (target.kind === "block") {
+    return block;
+  }
+  return [
+    "---",
+    "name: Threadnote",
+    "description: Shared local context and handoffs through Threadnote",
+    'applyTo: "**"',
+    "---",
+    "",
+    block
+  ].join("\n");
+}
 async function renderUserAgentInstructionsBlock() {
   const instructions = (await (0, import_promises8.readFile)((0, import_node_path7.join)(toolRoot(), "docs", "agent-instructions.md"), "utf8")).trim();
   return `${USER_INSTRUCTIONS_START_MARKER}
@@ -9557,7 +9759,7 @@ async function main() {
   });
   program2.command("repair").description("Repair local OpenViking install, config files, server health, shim, manifest, and MCP config").option("--dry-run", "Print the repair actions without making changes").option(
     "--mcp <clients>",
-    "MCP clients to repair: available, all, none, codex, claude, cursor, or comma-separated list",
+    "MCP clients to repair: available, all, none, codex, claude, cursor, copilot, or comma-separated list",
     "available"
   ).option("--no-start", "Do not start OpenViking if health is failing").option("--no-post-update", "Skip post-update migration prompts after repair").option("--package-manager <manager>", "uv, pipx, or pip", parsePackageManager).action(async (options) => {
     const config = getRuntimeConfig(program2);
@@ -9574,7 +9776,7 @@ async function main() {
   });
   program2.command("uninstall").description("Remove Threadnote setup and optionally erase local memories").option("--dry-run", "Print uninstall actions without making changes").option(
     "--mcp <clients>",
-    "MCP clients to remove: available, all, none, codex, claude, cursor, or comma-separated list",
+    "MCP clients to remove: available, all, none, codex, claude, cursor, copilot, or comma-separated list",
     "available"
   ).option("--preserve-memories", "Preserve THREADNOTE_HOME and OpenViking memories (default)").option("--erase-memories", "Delete THREADNOTE_HOME, including all OpenViking memories").action(async (options) => {
     await runUninstall(getRuntimeConfig(program2), options);
@@ -9588,10 +9790,10 @@ async function main() {
   program2.command("seed-skills").description("Seed Codex, Claude, and repo-local SKILL.md files as a searchable catalog").option("--dry-run", "Print skill files and ov commands without importing").option("--manifest <path>", "Manifest path for repo-local skill discovery").option("--native", "Use native OpenViking skill ingestion; requires a working VLM config").action(async (options) => {
     await runSeedSkills(getRuntimeConfig(program2, options.manifest), options);
   });
-  program2.command("mcp-install").description("Install OpenViking MCP config for a supported agent").argument("<agent>", "codex, claude, or cursor").option("--apply", "Actually modify the selected agent config").option("--name <name>", "MCP server name", OPENVIKING_MCP_NAME).option("--native-http", "Install OpenViking native HTTP MCP endpoint instead of the local stdio adapter").option("--scope <scope>", "Claude MCP config scope: user, local, or project", parseClaudeMcpScope, "user").option("--url <url>", "OpenViking native HTTP MCP URL").option("--bearer-token-env-var <name>", "Environment variable containing the local API key").action(async (agent, options) => {
+  program2.command("mcp-install").description("Install OpenViking MCP config for a supported agent").argument("<agent>", "codex, claude, cursor, or copilot").option("--apply", "Actually modify the selected agent config").option("--name <name>", "MCP server name", OPENVIKING_MCP_NAME).option("--native-http", "Install OpenViking native HTTP MCP endpoint instead of the local stdio adapter").option("--scope <scope>", "Claude MCP config scope: user, local, or project", parseClaudeMcpScope, "user").option("--url <url>", "OpenViking native HTTP MCP URL").option("--bearer-token-env-var <name>", "Environment variable containing the local API key").action(async (agent, options) => {
     await runMcpInstall(getRuntimeConfig(program2), parseAgentClient(agent), options);
   });
-  program2.command("remember").description("Store a durable engineering memory in OpenViking").option("--dry-run", "Print memory and ov command without storing").option("--kind <kind>", "durable, handoff, incident, preference, or smoke", parseMemoryKind, "durable").option("--project <name>", "Project/repo/topic namespace for lifecycle-aware storage").option("--replace <uri>", "Supersede an existing viking:// memory after the new memory is stored").option("--source-agent-client <name>", "codex, claude, cursor, gemini, or another client name", "codex").option("--status <status>", "active, archived, or superseded", parseMemoryStatus, "active").option("--stdin", "Read memory text from stdin").option("--text <text>", "Memory text to store").option("--topic <name>", "Stable topic name; active memories with the same project/topic update one file").action(async (options) => {
+  program2.command("remember").description("Store a durable engineering memory in OpenViking").option("--dry-run", "Print memory and ov command without storing").option("--kind <kind>", "durable, handoff, incident, preference, or smoke", parseMemoryKind, "durable").option("--project <name>", "Project/repo/topic namespace for lifecycle-aware storage").option("--replace <uri>", "Supersede an existing viking:// memory after the new memory is stored").option("--source-agent-client <name>", "codex, claude, cursor, copilot, or another client name", "codex").option("--status <status>", "active, archived, or superseded", parseMemoryStatus, "active").option("--stdin", "Read memory text from stdin").option("--text <text>", "Memory text to store").option("--topic <name>", "Stable topic name; active memories with the same project/topic update one file").action(async (options) => {
     await runRemember(getRuntimeConfig(program2), options);
   });
   program2.command("migrate-memories").description("Migrate legacy session-only Threadnote memories into durable memory files").option("--all-accounts", "Scan all local OpenViking accounts under THREADNOTE_HOME").option("--dry-run", "Print migration actions without writing memories").option("--limit <count>", "Maximum number of memories to migrate").option(
@@ -9614,7 +9816,7 @@ async function main() {
   program2.command("list").alias("ls").description("List a viking:// directory").argument("[uri]", "viking:// URI to list", "viking://").option("-a, --all", "Show hidden files such as .abstract.md and .overview.md").option("--dry-run", "Print ov command without listing").option("-n, --node-limit <count>", "Maximum number of nodes to list").option("-r, --recursive", "List subdirectories recursively").option("-s, --simple", "Print only paths").action(async (uri, options) => {
     await runList(getRuntimeConfig(program2), uri, options);
   });
-  program2.command("handoff").description("Capture current repo state as a durable cross-agent handoff memory").option("--blockers <text>", "Known blockers").option("--dry-run", "Print handoff without storing").option("--next-step <text>", "Suggested next step").option("--project <name>", "Project/repo namespace; defaults to current repo basename").option("--replace <uri>", "Supersede an existing viking:// memory after the new handoff is stored").option("--source-agent-client <name>", "codex, claude, cursor, gemini, or another client name", "codex").option("--task <text>", "Current task summary").option("--tests <text>", "Tests or checks run").option("--topic <name>", "Stable topic name; active handoffs with the same project/topic update one file").action(async (options) => {
+  program2.command("handoff").description("Capture current repo state as a durable cross-agent handoff memory").option("--blockers <text>", "Known blockers").option("--dry-run", "Print handoff without storing").option("--next-step <text>", "Suggested next step").option("--project <name>", "Project/repo namespace; defaults to current repo basename").option("--replace <uri>", "Supersede an existing viking:// memory after the new handoff is stored").option("--source-agent-client <name>", "codex, claude, cursor, copilot, or another client name", "codex").option("--task <text>", "Current task summary").option("--tests <text>", "Tests or checks run").option("--topic <name>", "Stable topic name; active handoffs with the same project/topic update one file").action(async (options) => {
     await runHandoff(getRuntimeConfig(program2), options);
   });
   program2.command("archive").description("Move a memory into the archived lifecycle tree, then remove the original after the archive is stored").argument("<uri>", "viking:// memory URI to archive").option("--dry-run", "Print archive content and ov commands without changing anything").option("--kind <kind>", "durable, handoff, incident, preference, or smoke", parseMemoryKind).option("--project <name>", "Override inferred project/repo namespace").option("--topic <name>", "Override inferred topic").action(async (uri, options) => {

package/docs/agent-instructions.md

@@ -1,6 +1,6 @@
 # Agent Instructions
 
-Threadnote installs this as user-level agent guidance for Codex, Claude, and Cursor.
+Threadnote installs this as user-level agent guidance for Codex, Claude, Cursor, and Copilot.
 
 ## Shared Context
 
@@ -20,9 +20,14 @@ At the start of a non-trivial task, recall relevant context before making change
 
 - the current repo and branch;
 - recent handoffs;
+- durable feature memories for the branch, feature name, project/topic, or issue;
 - task-specific skills or workflow guidance;
 - user or team preferences that may affect the work.
 
+When a recalled handoff describes an active branch or feature, do a second recall for durable memories about that
+feature before coding. The handoff tells you the current work state; durable feature memories tell you the design,
+decisions, invariants, interfaces, and gotchas that should survive beyond one session.
+
 Skip proactive recall for tiny one-shot questions where context would add noise.
 
 Search results are not the final payload. Treat returned `viking://` URIs as pointers: read the relevant URI, or list a
@@ -36,6 +41,12 @@ logs, or other sensitive data.
 Also remember durable workflow facts you discover during work when they would help future agents and are not already in
 canonical docs. Prefer updating checked-in docs for canonical repo rules.
 
+During feature work on a branch, maintain durable feature knowledge in addition to handoffs. Store or update a durable
+memory when you learn something future agents should know about the feature itself: the intended behavior, design
+decisions, API contracts, data flow, migration semantics, edge cases, known limitations, or why an implementation choice
+was made. Do not wait until the end of the branch; update the feature memory whenever a valuable change lands or a
+decision becomes clear.
+
 Use lifecycle metadata when storing memories:
 
 - `kind: durable` for facts future agents should use by default.
@@ -46,6 +57,14 @@ Use lifecycle metadata when storing memories:
 Archived handoffs are provenance, not default working context. Read them only when current durable memories or active
 handoffs are insufficient.
 
+For branch feature work, prefer two stable memories with the same project and topic:
+
+- `kind: durable` for the feature knowledge that should remain useful after the current agent session.
+- `kind: handoff` for current status, files touched, tests, blockers, and next step.
+
+If a durable feature memory already exists, update it in place with the same project/topic or with `--replace <uri>` /
+`replaceUri`. Avoid creating a new timestamped durable memory for every small progress note.
+
 ## Memory Compaction
 
 When working on the same active issue, prefer keeping one current-state memory updated instead of creating many small
@@ -56,7 +75,8 @@ progress memories. If an existing memory is clearly the current state for the is
 When the issue has a stable name, prefer project/topic storage over timestamped memories:
 
 ```bash
-threadnote remember --kind durable --project my-repo --topic test-workflow --text "..."
+threadnote recall --query "my-repo active-bug durable feature knowledge"
+threadnote remember --kind durable --project my-repo --topic active-bug --text "Feature knowledge: ..."
 threadnote handoff --project my-repo --topic active-bug --task "..." --tests "..."
 ```
 
@@ -78,6 +98,7 @@ Never compact secrets, credentials, customer data, raw production logs, or check
 Before pausing, switching agents, or ending meaningful work with local changes, store a concise handoff. Include:
 
 - repo and branch;
+- related durable feature memory URI or topic, when known;
 - files touched;
 - current status;
 - tests or checks run;
@@ -93,9 +114,11 @@ Use these only when MCP tools are not available:
 ```bash
 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 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..."
 threadnote archive viking://user/example/memories/handoffs/active/example/old-issue.md
 threadnote forget viking://user/example/memories/events/duplicate.md

package/docs/migration.md

@@ -30,8 +30,8 @@ Developers should not need to run `recall`, `remember`, or `handoff` as a normal
 
 The intended workflow has three layers:
 
-- Agent-first: Codex, Claude, or another MCP-enabled agent calls OpenViking tools when the task calls for shared
-  context.
+- Agent-first: Codex, Claude, Copilot, or another MCP-enabled agent calls OpenViking tools when the task calls for
+  shared context.
 - Short CLI fallback: humans and scripts can run `threadnote recall`, `threadnote remember`, or
   `threadnote handoff` from any repo.
 - Checkout-local command: `npm run threadnote -- ...` is the bootstrap and debugging path before the short command shim
@@ -46,8 +46,8 @@ Create a handoff for the next agent before you stop.
 ```
 
 For better continuity, run `threadnote install` so it can add the agent-side guidance from `docs/agent-instructions.md`
-to user-level Codex, Claude, and Cursor instruction files. That guidance tells agents to recall context at task start,
-store durable memories when explicitly asked or when a reusable workflow fact is learned, and create handoffs
+to user-level Codex, Claude, Cursor, and Copilot instruction files. That guidance tells agents to recall context at task
+start, store durable memories when explicitly asked or when a reusable workflow fact is learned, and create handoffs
 automatically before stopping meaningful work.
 
 ## Migration Steps
@@ -141,6 +141,16 @@ paths.
 
    Cursor installs by updating the global `~/.cursor/mcp.json` file.
 
+   For GitHub Copilot in VS Code:
+
+   ```bash
+   threadnote mcp-install copilot
+   threadnote mcp-install copilot --apply
+   ```
+
+   Copilot installs by updating the VS Code user-profile `mcp.json` file. If VS Code uses a custom profile path, set
+   `THREADNOTE_COPILOT_MCP_CONFIG` to that `mcp.json` path before running `mcp-install copilot`.
+
    Later, if the checkout that installed the MCP adapter is deleted or moved, repair it from any fresh checkout:
 
    ```bash
@@ -162,16 +172,21 @@ Preferred developer behavior is conversational:
 
 ```text
 Recall anything relevant for this branch before you start.
-Remember this workflow note for future agents: ...
+Remember this feature decision for future agents: ...
 Create a handoff now.
 ```
 
 Preferred agent behavior is automatic after `threadnote install` has updated the user-level instruction files:
 
-- On non-trivial task start, search OpenViking for recent handoffs and relevant repo guidance.
+- On non-trivial task start, search OpenViking for recent handoffs, durable feature memories for the branch/topic, and
+  relevant repo guidance.
 - When the user says "remember", store the memory after checking that it contains no secret or customer data.
-- When continuing the same active issue, update the current-state memory with `remember --replace <uri>` or
-  `handoff --replace <uri>` instead of creating another near-duplicate progress memory.
+- When continuing the same active issue, keep two current-state records when useful: a durable feature memory for design,
+  decisions, interfaces, and gotchas, plus a handoff for status, tests, blockers, and next steps.
+- When valuable feature knowledge changes, update the durable feature memory with the same project/topic or
+  `remember --replace <uri>` instead of burying that knowledge only in a handoff.
+- When current status changes, update the active handoff with the same project/topic or `handoff --replace <uri>` instead
+  of creating another near-duplicate progress memory.
 - When recall surfaces clearly duplicate or stale memories, store one concise replacement memory and forget only the
   redundant originals.
 - Before pausing, switching agents, or finishing meaningful code changes, store a concise handoff with status, tests,
@@ -181,9 +196,10 @@ Manual CLI remains available for scripts and emergencies:
 
 ```bash
 threadnote recall --query "last handoff for this branch"
-threadnote remember --text "Durable engineering note..."
+threadnote recall --query "durable feature knowledge for this branch"
+threadnote remember --kind durable --project example --topic active-feature --text "Feature knowledge..."
 threadnote remember --replace viking://user/example/memories/events/current.md --text "Updated durable engineering note..."
-threadnote handoff --task "short task summary" --tests "checks run" --next-step "what the next agent should do"
+threadnote handoff --project example --topic active-feature --task "short task summary" --tests "checks run" --next-step "what the next agent should do"
 ```
 
 ## Repo Paths

package/docs/rollout.md

@@ -18,7 +18,7 @@ Start with a local-only pilot.
 
 - Install completes in under 10 minutes after prerequisites.
 - `doctor` reports clear actionable checks.
-- Codex, Claude, or Cursor can store and recall a shared handoff after MCP setup.
+- Codex, Claude, Cursor, or Copilot can store and recall a shared handoff after MCP setup.
 - Seeding curated guidance does not import known secret patterns.
 - Fresh agents can recall repo testing guidance and discover relevant skills.
 - `uninstall --dry-run` previews removal, and `uninstall` leaves memories intact unless `--erase-memories` is explicit.

package/docs/security.md

@@ -6,7 +6,8 @@
 
 - Credentials, access tokens, API keys, certificates, private keys, or shell history.
 - Customer data, production data, HIPAA data, or production logs without explicit approval and scrubbing.
-- Local auth files such as `~/.codex/auth.json`, `~/.claude/.credentials.json`, or Cursor account/session files.
+- Local auth files such as `~/.codex/auth.json`, `~/.claude/.credentials.json`, Cursor account/session files, or VS Code
+  Copilot account/session files.
 - Local settings files that may contain secrets unless they go through redaction.
 
 ## Built-In Controls
@@ -14,9 +15,9 @@
 - `.threadnoteignore` excludes common secret and build-output paths.
 - `.mcp.json`, `config.toml`, and settings JSON are redacted before import.
 - Files are skipped if common secret patterns remain after redaction.
-- `mcp-install` requires `--apply` before it changes Codex, Claude, or Cursor config.
-- `install` updates user-level Codex, Claude, and Cursor instruction files through a managed Markdown block. Existing
-  personal instructions outside that block are preserved.
+- `mcp-install` requires `--apply` before it changes Codex, Claude, Cursor, or Copilot config.
+- `install` updates user-level Codex, Claude, Cursor, and Copilot instruction files through managed Threadnote content.
+  Existing personal instructions outside managed blocks are preserved.
 - `uninstall` preserves local memories by default. `--erase-memories` is required before deleting `THREADNOTE_HOME`.
 - Config files created under `THREADNOTE_HOME` are written with user-only permissions.
 

package/docs/troubleshooting.md

@@ -147,7 +147,7 @@ threadnote repair
 ```
 
 `repair` reinstalls the `threadnote` shim, repairs generated config files, starts OpenViking if needed, and rewrites
-Codex/Claude/Cursor MCP configs to point at the current checkout.
+Codex/Claude/Cursor/Copilot MCP configs to point at the current checkout.
 
 ## MCP Install Is Only Printing Commands
 
@@ -166,6 +166,16 @@ threadnote mcp-install cursor --apply
 This updates the global `~/.cursor/mcp.json` file. Restart Cursor or open a fresh agent session after changing MCP
 config.
 
+For GitHub Copilot in VS Code:
+
+```bash
+threadnote mcp-install copilot --apply
+```
+
+This updates the VS Code user-profile `mcp.json` file. Restart VS Code or run `MCP: List Servers` from the Command
+Palette after changing MCP config. If VS Code uses a custom profile path, set `THREADNOTE_COPILOT_MCP_CONFIG` to that
+`mcp.json` path before running the command.
+
 ## Cursor MCP Tool Says Query Is Missing
 
 If Cursor shows an error like `expected string, received undefined` for Threadnote `search`, the MCP server started but

package/package.json

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