threadnote 0.6.1 → 0.6.2

package/dist/mcp_server.cjs

@@ -1191,14 +1191,14 @@ var require_util = __commonJS({
       });
     }
     exports2.useFunc = useFunc;
-    var Type;
-    (function(Type2) {
-      Type2[Type2["Num"] = 0] = "Num";
-      Type2[Type2["Str"] = 1] = "Str";
-    })(Type || (exports2.Type = Type = {}));
+    var Type2;
+    (function(Type3) {
+      Type3[Type3["Num"] = 0] = "Num";
+      Type3[Type3["Str"] = 1] = "Str";
+    })(Type2 || (exports2.Type = Type2 = {}));
     function getErrorPath(dataProp, dataPropType, jsPropertySyntax) {
       if (dataProp instanceof codegen_1.Name) {
-        const isNumber = dataPropType === Type.Num;
+        const isNumber = dataPropType === Type2.Num;
         return jsPropertySyntax ? isNumber ? (0, codegen_1._)`"[" + ${dataProp} + "]"` : (0, codegen_1._)`"['" + ${dataProp} + "']"` : isNumber ? (0, codegen_1._)`"/" + ${dataProp}` : (0, codegen_1._)`"/" + ${dataProp}.replace(/~/g, "~0").replace(/\\//g, "~1")`;
       }
       return jsPropertySyntax ? (0, codegen_1.getProperty)(dataProp).toString() : "/" + escapeJsonPointer(dataProp);
@@ -1499,37 +1499,37 @@ var require_dataType = __commonJS({
       DataType2[DataType2["Wrong"] = 1] = "Wrong";
     })(DataType || (exports2.DataType = DataType = {}));
     function getSchemaTypes(schema2) {
-      const types = getJSONTypes(schema2.type);
-      const hasNull = types.includes("null");
+      const types2 = getJSONTypes(schema2.type);
+      const hasNull = types2.includes("null");
       if (hasNull) {
         if (schema2.nullable === false)
           throw new Error("type: null contradicts nullable: false");
       } else {
-        if (!types.length && schema2.nullable !== void 0) {
+        if (!types2.length && schema2.nullable !== void 0) {
           throw new Error('"nullable" cannot be used without "type"');
         }
         if (schema2.nullable === true)
-          types.push("null");
+          types2.push("null");
       }
-      return types;
+      return types2;
     }
     exports2.getSchemaTypes = getSchemaTypes;
     function getJSONTypes(ts) {
-      const types = Array.isArray(ts) ? ts : ts ? [ts] : [];
-      if (types.every(rules_1.isJSONType))
-        return types;
-      throw new Error("type must be JSONType or JSONType[]: " + types.join(","));
+      const types2 = Array.isArray(ts) ? ts : ts ? [ts] : [];
+      if (types2.every(rules_1.isJSONType))
+        return types2;
+      throw new Error("type must be JSONType or JSONType[]: " + types2.join(","));
     }
     exports2.getJSONTypes = getJSONTypes;
-    function coerceAndCheckDataType(it, types) {
+    function coerceAndCheckDataType(it, types2) {
       const { gen, data, opts } = it;
-      const coerceTo = coerceToTypes(types, opts.coerceTypes);
-      const checkTypes = types.length > 0 && !(coerceTo.length === 0 && types.length === 1 && (0, applicability_1.schemaHasRulesForType)(it, types[0]));
+      const coerceTo = coerceToTypes(types2, opts.coerceTypes);
+      const checkTypes = types2.length > 0 && !(coerceTo.length === 0 && types2.length === 1 && (0, applicability_1.schemaHasRulesForType)(it, types2[0]));
       if (checkTypes) {
-        const wrongType = checkDataTypes(types, data, opts.strictNumbers, DataType.Wrong);
+        const wrongType = checkDataTypes(types2, data, opts.strictNumbers, DataType.Wrong);
         gen.if(wrongType, () => {
           if (coerceTo.length)
-            coerceData(it, types, coerceTo);
+            coerceData(it, types2, coerceTo);
           else
             reportTypeError(it);
         });
@@ -1538,15 +1538,15 @@ var require_dataType = __commonJS({
     }
     exports2.coerceAndCheckDataType = coerceAndCheckDataType;
     var COERCIBLE = /* @__PURE__ */ new Set(["string", "number", "integer", "boolean", "null"]);
-    function coerceToTypes(types, coerceTypes) {
-      return coerceTypes ? types.filter((t) => COERCIBLE.has(t) || coerceTypes === "array" && t === "array") : [];
+    function coerceToTypes(types2, coerceTypes) {
+      return coerceTypes ? types2.filter((t) => COERCIBLE.has(t) || coerceTypes === "array" && t === "array") : [];
     }
-    function coerceData(it, types, coerceTo) {
+    function coerceData(it, types2, coerceTo) {
       const { gen, data, opts } = it;
       const dataType = gen.let("dataType", (0, codegen_1._)`typeof ${data}`);
       const coerced = gen.let("coerced", (0, codegen_1._)`undefined`);
       if (opts.coerceTypes === "array") {
-        gen.if((0, codegen_1._)`${dataType} == 'object' && Array.isArray(${data}) && ${data}.length == 1`, () => gen.assign(data, (0, codegen_1._)`${data}[0]`).assign(dataType, (0, codegen_1._)`typeof ${data}`).if(checkDataTypes(types, data, opts.strictNumbers), () => gen.assign(coerced, data)));
+        gen.if((0, codegen_1._)`${dataType} == 'object' && Array.isArray(${data}) && ${data}.length == 1`, () => gen.assign(data, (0, codegen_1._)`${data}[0]`).assign(dataType, (0, codegen_1._)`typeof ${data}`).if(checkDataTypes(types2, data, opts.strictNumbers), () => gen.assign(coerced, data)));
       }
       gen.if((0, codegen_1._)`${coerced} !== undefined`);
       for (const t of coerceTo) {
@@ -1622,19 +1622,19 @@ var require_dataType = __commonJS({
         return checkDataType(dataTypes[0], data, strictNums, correct);
       }
       let cond;
-      const types = (0, util_1.toHash)(dataTypes);
-      if (types.array && types.object) {
+      const types2 = (0, util_1.toHash)(dataTypes);
+      if (types2.array && types2.object) {
         const notObj = (0, codegen_1._)`typeof ${data} != "object"`;
-        cond = types.null ? notObj : (0, codegen_1._)`!${data} || ${notObj}`;
-        delete types.null;
-        delete types.array;
-        delete types.object;
+        cond = types2.null ? notObj : (0, codegen_1._)`!${data} || ${notObj}`;
+        delete types2.null;
+        delete types2.array;
+        delete types2.object;
       } else {
         cond = codegen_1.nil;
       }
-      if (types.number)
-        delete types.integer;
-      for (const t in types)
+      if (types2.number)
+        delete types2.integer;
+      for (const t in types2)
         cond = (0, codegen_1.and)(cond, checkDataType(t, data, strictNums, correct));
       return cond;
     }
@@ -2439,9 +2439,9 @@ var require_validate = __commonJS({
     function typeAndKeywords(it, errsCount) {
       if (it.opts.jtd)
         return schemaKeywords(it, [], false, errsCount);
-      const types = (0, dataType_1.getSchemaTypes)(it.schema);
-      const checkedTypes = (0, dataType_1.coerceAndCheckDataType)(it, types);
-      schemaKeywords(it, types, !checkedTypes, errsCount);
+      const types2 = (0, dataType_1.getSchemaTypes)(it.schema);
+      const checkedTypes = (0, dataType_1.coerceAndCheckDataType)(it, types2);
+      schemaKeywords(it, types2, !checkedTypes, errsCount);
     }
     function checkRefsAndKeywords(it) {
       const { schema: schema2, errSchemaPath, opts, self } = it;
@@ -2491,7 +2491,7 @@ var require_validate = __commonJS({
       if (items instanceof codegen_1.Name)
         gen.assign((0, codegen_1._)`${evaluated}.items`, items);
     }
-    function schemaKeywords(it, types, typeErrors, errsCount) {
+    function schemaKeywords(it, types2, typeErrors, errsCount) {
       const { gen, schema: schema2, data, allErrors, opts, self } = it;
       const { RULES } = self;
       if (schema2.$ref && (opts.ignoreKeywordsWithRef || !(0, util_1.schemaHasRulesButRef)(schema2, RULES))) {
@@ -2499,7 +2499,7 @@ var require_validate = __commonJS({
         return;
       }
       if (!opts.jtd)
-        checkStrictTypes(it, types);
+        checkStrictTypes(it, types2);
       gen.block(() => {
         for (const group of RULES.rules)
           groupKeywords(group);
@@ -2511,7 +2511,7 @@ var require_validate = __commonJS({
         if (group.type) {
           gen.if((0, dataType_2.checkDataType)(group.type, data, opts.strictNumbers));
           iterateKeywords(it, group);
-          if (types.length === 1 && types[0] === group.type && typeErrors) {
+          if (types2.length === 1 && types2[0] === group.type && typeErrors) {
             gen.else();
             (0, dataType_2.reportTypeError)(it);
           }
@@ -2535,27 +2535,27 @@ var require_validate = __commonJS({
         }
       });
     }
-    function checkStrictTypes(it, types) {
+    function checkStrictTypes(it, types2) {
       if (it.schemaEnv.meta || !it.opts.strictTypes)
         return;
-      checkContextTypes(it, types);
+      checkContextTypes(it, types2);
       if (!it.opts.allowUnionTypes)
-        checkMultipleTypes(it, types);
+        checkMultipleTypes(it, types2);
       checkKeywordTypes(it, it.dataTypes);
     }
-    function checkContextTypes(it, types) {
-      if (!types.length)
+    function checkContextTypes(it, types2) {
+      if (!types2.length)
         return;
       if (!it.dataTypes.length) {
-        it.dataTypes = types;
+        it.dataTypes = types2;
         return;
       }
-      types.forEach((t) => {
+      types2.forEach((t) => {
         if (!includesType(it.dataTypes, t)) {
           strictTypesError(it, `type "${t}" not allowed by context "${it.dataTypes.join(",")}"`);
         }
       });
-      narrowSchemaTypes(it, types);
+      narrowSchemaTypes(it, types2);
     }
     function checkMultipleTypes(it, ts) {
       if (ts.length > 1 && !(ts.length === 2 && ts.includes("null"))) {
@@ -9556,9 +9556,9 @@ var ZodUnion = class extends ZodType {
     return this._def.options;
   }
 };
-ZodUnion.create = (types, params) => {
+ZodUnion.create = (types2, params) => {
   return new ZodUnion({
-    options: types,
+    options: types2,
     typeName: ZodFirstPartyTypeKind.ZodUnion,
     ...processCreateParams(params)
   });
@@ -21542,10 +21542,10 @@ function _property(property, schema2, params) {
   });
 }
 // @__NO_SIDE_EFFECTS__
-function _mime(types, params) {
+function _mime(types2, params) {
   return new $ZodCheckMimeType({
     check: "mime_type",
-    mime: types,
+    mime: types2,
     ...normalizeParams(params)
   });
 }
@@ -24603,7 +24603,7 @@ var ZodFile = /* @__PURE__ */ $constructor("ZodFile", (inst, def) => {
   inst._zod.processJSONSchema = (ctx, json3, params) => fileProcessor(inst, ctx, json3, params);
   inst.min = (size, params) => inst.check(_minSize(size, params));
   inst.max = (size, params) => inst.check(_maxSize(size, params));
-  inst.mime = (types, params) => inst.check(_mime(Array.isArray(types) ? types : [types], params));
+  inst.mime = (types2, params) => inst.check(_mime(Array.isArray(types2) ? types2 : [types2], params));
 });
 function file(params) {
   return _file(ZodFile, params);
@@ -27777,15 +27777,15 @@ function parseUnionDef(def, refs) {
     return asAnyOf(def, refs);
   const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options;
   if (options.every((x) => x._def.typeName in primitiveMappings && (!x._def.checks || !x._def.checks.length))) {
-    const types = options.reduce((types2, x) => {
+    const types2 = options.reduce((types3, x) => {
       const type2 = primitiveMappings[x._def.typeName];
-      return type2 && !types2.includes(type2) ? [...types2, type2] : types2;
+      return type2 && !types3.includes(type2) ? [...types3, type2] : types3;
     }, []);
     return {
-      type: types.length > 1 ? types : types[0]
+      type: types2.length > 1 ? types2 : types2[0]
     };
   } else if (options.every((x) => x._def.typeName === "ZodLiteral" && !x.description)) {
-    const types = options.reduce((acc, x) => {
+    const types2 = options.reduce((acc, x) => {
       const type2 = typeof x._def.value;
       switch (type2) {
         case "string":
@@ -27804,8 +27804,8 @@ function parseUnionDef(def, refs) {
           return acc;
       }
     }, []);
-    if (types.length === options.length) {
-      const uniqueTypes = types.filter((x, i, a) => a.indexOf(x) === i);
+    if (types2.length === options.length) {
+      const uniqueTypes = types2.filter((x, i, a) => a.indexOf(x) === i);
       return {
         type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],
         enum: options.reduce((acc, x) => {
@@ -30950,7 +30950,7 @@ var StdioServerTransport = class {
 };
 
 // src/mcp_server.ts
-var import_promises3 = require("node:fs/promises");
+var import_promises4 = require("node:fs/promises");
 var import_node_os3 = require("node:os");
 var import_node_path3 = require("node:path");
 
@@ -30958,10 +30958,8 @@ var import_node_path3 = require("node:path");
 var DEFAULT_ACCOUNT = "local";
 var DEFAULT_AGENT_ID = "threadnote";
 
-// src/share.ts
+// src/manifest.ts
 var import_promises2 = require("node:fs/promises");
-var import_node_os2 = require("node:os");
-var import_node_path2 = require("node:path");
 
 // node_modules/js-yaml/dist/js-yaml.mjs
 function isNothing(subject) {
@@ -33542,12 +33540,50 @@ function renamed(from, to) {
     throw new Error("Function yaml." + from + " is removed in js-yaml 4. Use yaml." + to + " instead, which is now safe by default.");
   };
 }
+var Type = type;
+var Schema = schema;
+var FAILSAFE_SCHEMA = failsafe;
+var JSON_SCHEMA = json2;
+var CORE_SCHEMA = core;
+var DEFAULT_SCHEMA = _default3;
 var load = loader.load;
 var loadAll = loader.loadAll;
 var dump = dumper.dump;
+var YAMLException = exception;
+var types = {
+  binary,
+  float,
+  map: map2,
+  null: _null4,
+  pairs,
+  set: set2,
+  timestamp,
+  bool,
+  int: int2,
+  merge: merge2,
+  omap,
+  seq,
+  str
+};
 var safeLoad = renamed("safeLoad", "load");
 var safeLoadAll = renamed("safeLoadAll", "loadAll");
 var safeDump = renamed("safeDump", "dump");
+var jsYaml = {
+  Type,
+  Schema,
+  FAILSAFE_SCHEMA,
+  JSON_SCHEMA,
+  CORE_SCHEMA,
+  DEFAULT_SCHEMA,
+  load,
+  loadAll,
+  dump,
+  YAMLException,
+  types,
+  safeLoad,
+  safeLoadAll,
+  safeDump
+};
 
 // src/utils.ts
 var import_node_child_process = require("node:child_process");
@@ -33652,6 +33688,9 @@ function expandPath(path) {
 function getInvocationCwd() {
   return process.env.THREADNOTE_CALLER_CWD ?? process.cwd();
 }
+function trimTrailingSlash(value) {
+  return value.endsWith("/") ? value.slice(0, -1) : value;
+}
 function sha256(content) {
   return (0, import_node_crypto.createHash)("sha256").update(content).digest("hex");
 }
@@ -33725,6 +33764,74 @@ function uriSegment(value) {
   const normalized = value.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
   return normalized.length > 0 ? normalized : "unknown";
 }
+async function inferProjectFromQuery(manifestPath, query) {
+  try {
+    const manifest = await readSeedManifest(manifestPath);
+    const normalized = query.toLowerCase();
+    return manifest.projects.find((project) => normalized.includes(project.name.toLowerCase()));
+  } catch {
+    return void 0;
+  }
+}
+async function readSeedManifest(path) {
+  const raw = await (0, import_promises2.readFile)(path, "utf8");
+  const loaded = jsYaml.load(raw);
+  if (!isJsonObject(loaded)) {
+    throw new Error(`Manifest must be an object: ${path}`);
+  }
+  const version2 = readNumber(loaded, "version");
+  const projectsValue = loaded.projects;
+  if (!Array.isArray(projectsValue)) {
+    throw new Error(`Manifest projects must be an array: ${path}`);
+  }
+  const projects = [];
+  for (const projectValue of projectsValue) {
+    if (!isJsonObject(projectValue)) {
+      throw new Error(`Manifest project must be an object: ${path}`);
+    }
+    const seed = readStringArray(projectValue, "seed");
+    projects.push({
+      name: readString(projectValue, "name"),
+      path: readString(projectValue, "path"),
+      seed,
+      uri: readString(projectValue, "uri")
+    });
+  }
+  let futureMonorepo;
+  if (isJsonObject(loaded.future_monorepo)) {
+    futureMonorepo = {
+      pathCandidates: readStringArray(loaded.future_monorepo, "path_candidates"),
+      uri: readString(loaded.future_monorepo, "uri")
+    };
+  }
+  return { futureMonorepo, projects, version: version2 };
+}
+function readString(object3, key) {
+  const value = object3[key];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`Expected non-empty string for ${key}`);
+  }
+  return value;
+}
+function readNumber(object3, key) {
+  const value = object3[key];
+  if (typeof value !== "number") {
+    throw new Error(`Expected number for ${key}`);
+  }
+  return value;
+}
+function readStringArray(object3, key) {
+  const value = object3[key];
+  if (!Array.isArray(value) || !value.every((item) => typeof item === "string")) {
+    throw new Error(`Expected string array for ${key}`);
+  }
+  return value;
+}
+
+// src/share.ts
+var import_promises3 = require("node:fs/promises");
+var import_node_os2 = require("node:os");
+var import_node_path2 = require("node:path");
 
 // src/runtime.ts
 function withIdentity(config2, args) {
@@ -33949,13 +34056,13 @@ async function writeMemoryFile(config2, ov, uri, content, initialMode, dryRun) {
     console.log(`Would run: ${formatShellCommand(ov, args)}`);
     return;
   }
-  const stagingDir = await (0, import_promises2.mkdtemp)((0, import_node_path2.join)((0, import_node_os2.tmpdir)(), "threadnote-share-"));
+  const stagingDir = await (0, import_promises3.mkdtemp)((0, import_node_path2.join)((0, import_node_os2.tmpdir)(), "threadnote-share-"));
   const tempPath = (0, import_node_path2.join)(stagingDir, "body.txt");
   try {
-    await (0, import_promises2.writeFile)(tempPath, content, { encoding: "utf8", mode: 384 });
+    await (0, import_promises3.writeFile)(tempPath, content, { encoding: "utf8", mode: 384 });
     await writeOvFileWithRetry(config2, ov, uri, tempPath, initialMode);
   } finally {
-    await (0, import_promises2.rm)(stagingDir, { force: true, recursive: true });
+    await (0, import_promises3.rm)(stagingDir, { force: true, recursive: true });
   }
 }
 async function writeOvFileWithRetry(config2, ov, uri, fromFile, initialMode) {
@@ -34051,7 +34158,7 @@ async function bestEffortRemoveWorktreeFile(rollbackUri, worktree, label) {
   if (!relative2) {
     return;
   }
-  await (0, import_promises2.rm)((0, import_node_path2.join)(worktree, relative2), { force: true });
+  await (0, import_promises3.rm)((0, import_node_path2.join)(worktree, relative2), { force: true });
 }
 async function removeMemoryUri(config2, ov, uri, dryRun) {
   const args = withIdentity(config2, ["rm", uri]);
@@ -34091,6 +34198,7 @@ async function main() {
         "Stdio MCP adapter for Threadnote shared local context.",
         "Prefer `recall_context` to find candidate viking:// URIs, then `read_context` files or `list_context` directories.",
         'Always pass JSON arguments. Example: recall_context({"query":"current repo latest handoff"}).',
+        "recall_context also surfaces seeded project resources under viking://resources/repos/<project> when the query mentions a project from the seed manifest. See its tool description for the query convention.",
         "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 a handoff describes an active branch or feature, recall durable feature memories for the same branch/topic before coding.",
@@ -34110,6 +34218,7 @@ function getRuntimeConfig() {
     account: process.env.THREADNOTE_ACCOUNT ?? DEFAULT_ACCOUNT,
     agentContextHome: expandPath(process.env.THREADNOTE_HOME ?? "~/.openviking"),
     agentId: process.env.THREADNOTE_AGENT_ID ?? DEFAULT_AGENT_ID,
+    manifestPath: expandPath(process.env.THREADNOTE_MANIFEST ?? "~/.openviking/seed-manifest.yaml"),
     user: process.env.THREADNOTE_USER ?? process.env.USER ?? "unknown"
   };
 }
@@ -34118,13 +34227,13 @@ function registerTools(server, config2) {
     server,
     config2,
     "recall_context",
-    'Search Threadnote context. Required: pass JSON arguments with a non-empty query, for example {"query":"unity-ui-ccc latest handoff"}.'
+    `Search Threadnote context across personal memories and seeded project resources. Returns semantic hits from indexed Threadnote context (handoffs, durable feature memories, preferences, shared team memories) \u2014 and, when the query mentions a project name from the seed manifest, also from that project's seeded guidance (README, AGENTS.md, CLAUDE.md, SKILL.md, docs/**) under viking://resources/repos/<project>. Include the repo or project name in the query to make the project-guidance pass fire. Required: pass JSON arguments with a non-empty query, for example {"query":"unity-ui-ccc latest handoff"}.`
   );
   registerSearchTool(
     server,
     config2,
     "search",
-    "Compatibility alias for recall_context. Required: pass JSON arguments with a non-empty query."
+    "Compatibility alias for recall_context. Searches both personal memories and seeded project resources; see recall_context for the query conventions."
   );
   registerReadTool(
     server,
@@ -34324,40 +34433,78 @@ function registerSearchTool(server, config2, name, description) {
       if (!checkedUri.ok) {
         return checkedUri.error;
       }
-      return runRecallTool(
-        config2,
-        [
-          "search",
-          checkedQuery.value,
-          ...checkedUri.value ? ["--uri", checkedUri.value] : [],
-          ...nodeLimit ? ["--node-limit", String(nodeLimit)] : []
-        ],
-        includeArchived === true
-      );
+      return runRecallTool(config2, {
+        query: checkedQuery.value,
+        pinnedUri: checkedUri.value,
+        nodeLimit,
+        includeArchived: includeArchived === true
+      });
     }
   );
 }
-async function runRecallTool(config2, args, includeArchived) {
-  const semanticResult = await runOpenVikingTool(config2, args);
+async function runRecallTool(config2, params) {
+  const baseArgs = [
+    "search",
+    params.query,
+    ...params.pinnedUri ? ["--uri", params.pinnedUri] : [],
+    ...params.nodeLimit ? ["--node-limit", String(params.nodeLimit)] : []
+  ];
+  const semanticResult = await runOpenVikingTool(config2, baseArgs);
   if (semanticResult.isError === true) {
     return semanticResult;
   }
-  const query = args[1];
-  const exactMatches = typeof query === "string" ? await exactMemoryMatchesText(config2, query, includeArchived) : void 0;
-  if (!exactMatches) {
-    return semanticResult;
-  }
   const [firstContent] = semanticResult.content;
   if (firstContent?.type !== "text") {
     return semanticResult;
   }
-  return {
-    ...semanticResult,
-    content: [{ type: "text", text: `${firstContent.text}
-
-Exact durable memory matches:
-${exactMatches}` }]
-  };
+  const sections = [];
+  if (firstContent.text) {
+    sections.push(firstContent.text);
+  }
+  const seededSection = await seededResourcesSection(config2, params);
+  if (seededSection) {
+    sections.push(seededSection);
+  }
+  const exactMatches = await exactMemoryMatchesText(config2, params.query, params.includeArchived);
+  if (exactMatches) {
+    sections.push(`Exact durable memory matches:
+${exactMatches}`);
+  }
+  if (sections.length <= 1) {
+    return semanticResult;
+  }
+  return { ...semanticResult, content: [{ type: "text", text: sections.join("\n\n") }] };
+}
+async function seededResourcesSection(config2, params) {
+  if (params.pinnedUri) {
+    return void 0;
+  }
+  const project = await inferProjectFromQuery(config2.manifestPath, params.query);
+  if (!project) {
+    return void 0;
+  }
+  const projectResourceUri = trimTrailingSlash(project.uri);
+  if (!projectResourceUri.startsWith("viking://")) {
+    return void 0;
+  }
+  const ov = await requiredOpenVikingCli();
+  const args = [
+    "search",
+    params.query,
+    "--uri",
+    projectResourceUri,
+    ...params.nodeLimit ? ["--node-limit", String(params.nodeLimit)] : []
+  ];
+  const result = await runCommand(ov, withIdentity2(config2, args), { allowFailure: true });
+  if (result.exitCode !== 0) {
+    return void 0;
+  }
+  const body = [result.stdout.trim(), result.stderr.trim()].filter(Boolean).join("\n");
+  if (!body) {
+    return void 0;
+  }
+  return `Seeded project resources (${projectResourceUri}):
+${body}`;
 }
 async function exactMemoryMatchesText(config2, query, includeArchived) {
   const terms = exactRecallTerms(query);
@@ -34682,7 +34829,11 @@ function exactMemoryScopes(config2, includeArchived) {
     `${userBase}/incidents/active`,
     `${userBase}/events`,
     `${userBase}/shared`,
-    `viking://agent/${uriSegment2(config2.agentId)}/memories`
+    `viking://agent/${uriSegment2(config2.agentId)}/memories`,
+    // Seeded project resources live outside the user/memories tree. Include
+    // them so exact-term grep surfaces matches in seeded READMEs, AGENTS.md,
+    // SKILL.md, and docs/** alongside personal memory hits.
+    "viking://resources/repos"
   ];
   return includeArchived ? [...scopes, `${userBase}/durable/archived`, `${userBase}/handoffs/archived`, `${userBase}/incidents/archived`] : scopes;
 }
@@ -34899,8 +35050,8 @@ async function requiredOpenVikingCli() {
 async function firstExistingPath(paths) {
   for (const path of paths) {
     try {
-      await (0, import_promises3.access)(path);
-      return await (0, import_promises3.realpath)(path);
+      await (0, import_promises4.access)(path);
+      return await (0, import_promises4.realpath)(path);
     } catch (_err) {
       continue;
     }

package/dist/threadnote.cjs

@@ -7118,6 +7118,15 @@ function uriSegment(value) {
   const normalized = value.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
   return normalized.length > 0 ? normalized : "unknown";
 }
+async function inferProjectFromQuery(manifestPath, query) {
+  try {
+    const manifest = await readSeedManifest(manifestPath);
+    const normalized = query.toLowerCase();
+    return manifest.projects.find((project) => normalized.includes(project.name.toLowerCase()));
+  } catch {
+    return void 0;
+  }
+}
 async function readSeedManifest(path) {
   const raw = await (0, import_promises3.readFile)(path, "utf8");
   const loaded = jsYaml.load(raw);
@@ -7388,11 +7397,32 @@ async function runRecall(config, options) {
     args.push("--node-limit", String(parsePositiveInteger(options.nodeLimit, "node limit")));
   }
   await maybeRun(options.dryRun === true, ov, withIdentity(config, args));
+  await augmentRecallWithSeededResources(config, ov, options, inferredUri);
   await printExactMemoryMatches(config, ov, options.query, {
     dryRun: options.dryRun === true,
     includeArchived: options.includeArchived === true
   });
 }
+async function augmentRecallWithSeededResources(config, ov, options, inferredUri) {
+  if (options.uri || options.inferScope === false) {
+    return;
+  }
+  const project = await inferProjectFromQuery(config.manifestPath, options.query);
+  if (!project) {
+    return;
+  }
+  const projectResourceUri = trimTrailingSlash(project.uri);
+  if (!projectResourceUri.startsWith("viking://") || projectResourceUri === inferredUri) {
+    return;
+  }
+  const args = ["search", options.query, "--uri", projectResourceUri];
+  if (options.nodeLimit) {
+    args.push("--node-limit", String(parsePositiveInteger(options.nodeLimit, "node limit")));
+  }
+  console.log(`
+Also searching seeded resources: ${projectResourceUri}`);
+  await maybeRun(options.dryRun === true, ov, withIdentity(config, args));
+}
 async function runRead(config, uri, options) {
   assertVikingUri(uri);
   const ov = await openVikingCliForMode(options.dryRun === true);
@@ -7511,21 +7541,11 @@ async function runImportPack(config, options) {
   );
 }
 async function inferRecallUri(config, query) {
-  const normalizedQuery = query.toLowerCase();
-  if (/\bskills?\b/.test(normalizedQuery)) {
-    const project2 = await inferProjectFromQuery(config, normalizedQuery);
-    return project2 ? `viking://resources/agent-skills/repo-local-${uriSegment(project2.name)}` : "viking://resources/agent-skills";
-  }
-  const project = await inferProjectFromQuery(config, normalizedQuery);
-  return project ? trimTrailingSlash(project.uri) : void 0;
-}
-async function inferProjectFromQuery(config, normalizedQuery) {
-  try {
-    const manifest = await readSeedManifest(config.manifestPath);
-    return manifest.projects.find((project) => normalizedQuery.includes(project.name.toLowerCase()));
-  } catch (_err) {
+  if (!/\bskills?\b/.test(query.toLowerCase())) {
     return void 0;
   }
+  const project = await inferProjectFromQuery(config.manifestPath, query);
+  return project ? `viking://resources/agent-skills/repo-local-${uriSegment(project.name)}` : "viking://resources/agent-skills";
 }
 async function printExactMemoryMatches(config, ov, query, options) {
   const terms = exactRecallTerms(query);
@@ -7755,7 +7775,11 @@ function exactMemoryScopes(config, includeArchived) {
     `${userBase}/incidents/active`,
     `${userBase}/events`,
     `${userBase}/shared`,
-    `viking://agent/${uriSegment(config.agentId)}/memories`
+    `viking://agent/${uriSegment(config.agentId)}/memories`,
+    // Seeded project resources (READMEs, AGENTS.md, SKILL.md, docs/**) live
+    // under viking://resources/repos/<project>. Include them so an exact-term
+    // grep in a recall surfaces matches in seeded guidance, not only memories.
+    "viking://resources/repos"
   ];
   return includeArchived ? [...scopes, `${userBase}/durable/archived`, `${userBase}/handoffs/archived`, `${userBase}/incidents/archived`] : scopes;
 }

package/docs/agent-instructions.md

@@ -21,9 +21,17 @@ 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;
+- seeded project guidance under `viking://resources/repos/<project>` — README, AGENTS.md, CLAUDE.md, SKILL.md, docs/\*\*
+  — for canonical conventions, test commands, release process, on-call runbooks, and anything the team has checked into
+  the repo;
 - task-specific skills or workflow guidance;
 - user or team preferences that may affect the work.
 
+Include the repo or project name as a token in the recall query so the project-guidance pass fires. `recall_context`
+runs a parallel scoped search against `viking://resources/repos/<project>` whenever the query mentions a seeded project
+name, so memories AND project documentation come back in the same response. Treat seeded resources as the canonical
+source for "how does this repo do X" and personal memories as in-flight or per-author context layered on top.
+
 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.

package/docs/index.html

@@ -78,7 +78,11 @@
       body {
         line-height: 1.55;
         font-size: clamp(15px, 1.05vw, 17px);
-        overflow-x: hidden;
+        overflow-x: clip;
+      }
+
+      html {
+        overflow-x: clip;
       }
 
       ::selection {
@@ -117,6 +121,10 @@
         padding: 1em 1.2em;
         overflow-x: auto;
         line-height: 1.55;
+        /* Without this, a single long unbreakable line (curl URLs, etc.)
+           pushes the pre wider than its container and out of the viewport on
+           mobile. With it, the pre scrolls internally instead. */
+        max-width: 100%;
       }
 
       pre code {
@@ -148,6 +156,10 @@
         display: flex;
         flex-direction: column;
         justify-content: center;
+        /* Default flex/block intrinsic min-width is the widest child, which
+           lets long unbreakable mono lines (URLs, MCP calls) make the inner
+           wider than its declared 100%. Hard-cap it. */
+        min-width: 0;
       }
 
       .slide-eyebrow {
@@ -222,29 +234,14 @@
         align-items: flex-start;
       }
 
-      .page-logo {
-        position: fixed;
-        top: 1.5rem;
-        left: 1.5rem;
-        width: 220px;
-        height: 220px;
-        z-index: 40;
-        pointer-events: none;
-      }
-
-      .page-logo img {
-        width: 100%;
-        height: 100%;
+      .hero-logo {
         display: block;
-      }
-
-      @media (max-width: 720px) {
-        .page-logo {
-          width: 120px;
-          height: 120px;
-          top: 1rem;
-          left: 1rem;
-        }
+        width: clamp(140px, 18vw, 220px);
+        height: auto;
+        margin-bottom: 1.5rem;
+        /* Override `#hero .slide-inner { align-items: flex-start }` for just
+           this child so the logo sits centered above the left-aligned title. */
+        align-self: center;
       }
 
       .hero-title-gradient {
@@ -504,35 +501,89 @@
         border-radius: var(--radius-lg);
         padding: 1.5rem;
         display: grid;
-        gap: 0.6rem;
+        gap: 0.75rem;
         transition: border-color 0.2s ease;
+        /* Let the grid track shrink to its container width rather than to the
+           widest mono child. Without this, long MCP call/response lines push
+           the grid item past viewport and the page scrolls horizontally on
+           mobile. */
+        min-width: 0;
       }
 
       .vignette:hover {
         border-color: var(--accent-line);
       }
 
-      .vignette .v-prompt {
+      .vignette .v-say {
         font-style: italic;
+        font-size: 0.96rem;
         color: var(--text);
-        font-size: 1rem;
+        background: rgba(255, 255, 255, 0.03);
+        border-left: 3px solid var(--accent);
+        border-radius: 4px;
+        padding: 0.55rem 0.85rem;
       }
 
-      .vignette .v-answer {
+      .vignette .v-auto {
+        font-style: italic;
         color: var(--muted);
-        font-size: 0.95rem;
       }
 
-      .vignette .v-cmd {
+      .vignette pre.v-call,
+      .vignette pre.v-response {
         font-family: var(--font-mono);
-        font-size: 0.82rem;
-        color: var(--accent);
-        padding: 0.45rem 0.75rem;
+        font-size: 0.78rem;
         background: var(--code-bg);
+        padding: 0.55rem 0.75rem;
         border-radius: 6px;
         border: 1px solid var(--line);
-        white-space: nowrap;
+        border-left: 1px solid var(--line);
+        white-space: pre-wrap;
+        word-break: break-word;
         overflow-x: auto;
+        max-width: 100%;
+        line-height: 1.45;
+        margin: 0;
+      }
+
+      .vignette .v-call {
+        color: var(--accent);
+      }
+
+      .vignette .v-response {
+        color: var(--muted);
+      }
+
+      .vignette .v-say::before,
+      .vignette .v-call::before,
+      .vignette .v-response::before {
+        display: block;
+        font-family: var(--font-mono);
+        font-size: 0.68rem;
+        letter-spacing: 0.12em;
+        text-transform: uppercase;
+        color: var(--muted);
+        font-style: normal;
+        margin-bottom: 0.35rem;
+      }
+
+      .vignette .v-say::before {
+        content: 'You ask';
+        color: var(--accent);
+      }
+
+      .vignette .v-call::before {
+        content: 'Agent calls';
+      }
+
+      .vignette .v-response::before {
+        content: 'MCP returns';
+      }
+
+      .vignette .v-answer {
+        color: var(--muted);
+        font-size: 0.95rem;
+        margin-top: 0.25rem;
       }
 
       /* side nav dots */
@@ -695,10 +746,6 @@
   <body>
     <div class="progress"><div class="progress-bar" id="progressBar"></div></div>
 
-    <div class="page-logo" aria-hidden="true">
-      <img src="threadnote-logo-inverted.svg" alt="" />
-    </div>
-
     <nav class="deck-nav" aria-label="Section progress">
       <a href="#hero" data-label="Intro"><span>Intro</span></a>
       <a href="#problem" data-label="Problem"><span>Problem</span></a>
@@ -710,8 +757,8 @@
       <a href="#seed" data-label="Seed"><span>Seed</span></a>
       <a href="#update" data-label="Update"><span>Update</span></a>
       <a href="#lifecycle" data-label="Lifecycle"><span>Lifecycle</span></a>
-      <a href="#use-cases" data-label="Use cases"><span>Use cases</span></a>
       <a href="#share" data-label="Share"><span>Share</span></a>
+      <a href="#use-cases" data-label="Use cases"><span>Use cases</span></a>
       <a href="#close" data-label="Get started"><span>Start</span></a>
     </nav>
 
@@ -719,6 +766,7 @@
       <!-- 1. HERO -->
       <section id="hero" class="slide">
         <div class="slide-inner">
+          <img class="hero-logo" src="threadnote-logo-inverted.svg" alt="" aria-hidden="true" />
           <h1 class="hero-title-gradient">
             Shared local context<br />for <em class="hero-accent">development agents</em>.
           </h1>
@@ -727,7 +775,7 @@
             team-shared decisions — recallable from any session, on any agent, in any worktree.
           </p>
           <div class="cta-row">
-            <span class="pill">v0.5.0 · local-first · MIT</span>
+            <span class="pill"><span id="version-tag">v0.6.1</span> · local-first · MIT</span>
           </div>
         </div>
         <div class="scroll-cue">scroll ↓ &nbsp;·&nbsp; <span class="kbd">↓</span> / <span class="kbd">j</span></div>
@@ -1254,75 +1302,10 @@ threadnote remember \
         </div>
       </section>
 
-      <!-- 11. USE CASES -->
-      <section id="use-cases" class="slide">
-        <div class="slide-inner">
-          <span class="slide-eyebrow">10 · Real-world use cases</span>
-          <h2>Where it actually pays off.</h2>
-
-          <div class="vignettes">
-            <div class="vignette reveal">
-              <div class="v-prompt">"Continue the feature from yesterday."</div>
-              <div class="v-answer">
-                Fresh session, fresh agent. Threadnote recalls the active handoff for the branch plus the durable
-                feature memory: design decisions, the open PR, what's left, what just failed in CI. No re-explaining.
-              </div>
-              <div class="v-cmd">threadnote recall --query "&lt;branch&gt; latest handoff"</div>
-            </div>
-
-            <div class="vignette reveal">
-              <div class="v-prompt">"What did we conclude about that prod-on-call thing?"</div>
-              <div class="v-answer">
-                The sanitized handoff from the on-call escalation is still there. Re-open the same Slack thread three
-                weeks later; the durable feature memory points your agent at the right files and the resolution.
-              </div>
-              <div class="v-cmd">threadnote recall --query "export workflow timeout on-call findings"</div>
-            </div>
-
-            <div class="vignette reveal">
-              <div class="v-prompt">"Switch from Codex to Claude mid-task."</div>
-              <div class="v-answer">
-                Codex stores a handoff before pausing. Claude opens the same MCP layer, recalls the handoff plus the
-                durable memory, picks up the test command and the open blocker without you typing them again.
-              </div>
-              <div class="v-cmd">threadnote handoff --task "..." --next-step "..."</div>
-            </div>
-
-            <div class="vignette reveal">
-              <div class="v-prompt">"Onboard a new teammate to a feature."</div>
-              <div class="v-answer">
-                Publish the feature's durable memory to the team repo with <code>share publish</code>. Their agent
-                pulls it on the next <code>share sync</code> and recall surfaces it alongside their own personal
-                memories — no DM forwarding, no PDF dumping.
-              </div>
-              <div class="v-cmd">threadnote share publish viking://user/&lt;you&gt;/memories/durable/...</div>
-            </div>
-
-            <div class="vignette reveal">
-              <div class="v-prompt">"Compaction is about to nuke the context."</div>
-              <div class="v-answer">
-                Before context fills up, the agent stores a handoff. The next turn after compaction recalls it — the
-                summary covers the conversation arc, threadnote covers the durable facts the summary couldn't keep.
-              </div>
-              <div class="v-cmd">threadnote handoff --project &lt;repo&gt; --topic &lt;feature&gt; ...</div>
-            </div>
-
-            <div class="vignette reveal">
-              <div class="v-prompt">"Where does this repo run its release notes?"</div>
-              <div class="v-answer">
-                You discovered it the hard way last time. Tell your agent to <code>remember</code> the fact. Next time
-                anyone asks, the agent finds it in two seconds without grepping the wiki.
-              </div>
-              <div class="v-cmd">threadnote remember --kind durable --topic release-process ...</div>
-            </div>
-          </div>
-        </div>
-      </section>
-
-      <!-- 12. SHARE -->
+      <!-- 11. SHARE -->
       <section id="share" class="slide">
         <div class="slide-inner">
-          <span class="slide-eyebrow">11 · Sharing across the team</span>
+          <span class="slide-eyebrow">10 · Sharing across the team</span>
           <h2>Curated memories. Yours to push. Theirs to pull.</h2>
           <p class="lead">
             <code>threadnote share</code> publishes a subset of durable memories into a git repo so other engineers'
@@ -1409,6 +1392,81 @@ threadnote remember \
         </div>
       </section>
 
+      <!-- 12. USE CASES -->
+      <section id="use-cases" class="slide">
+        <div class="slide-inner">
+          <span class="slide-eyebrow">11 · Real-world use cases</span>
+          <h2>What you say. What the agent does.</h2>
+          <p class="lead">
+            You don't run threadnote commands yourself. You talk to your agent the way you already do; the agent calls
+            the MCP layer and the memory stays in sync across sessions, agents, and teammates.
+          </p>
+
+          <div class="vignettes">
+            <div class="vignette reveal">
+              <div class="v-say">Continue where we left off on this branch.</div>
+              <pre class="v-call">recall_context({query: "&lt;branch&gt; latest handoff durable feature memory"})</pre>
+              <pre class="v-response">→ viking://user/you/memories/handoffs/active/&lt;branch&gt;/auto-precompact.md
+→ viking://user/you/memories/durable/projects/&lt;repo&gt;/&lt;feature&gt;.md</pre>
+              <div class="v-answer">
+                Fresh session, fresh agent. It reads both pointers, picks up the design decisions, the open PR, what's
+                left to test, and what just failed in CI. No re-explaining.
+              </div>
+            </div>
+
+            <div class="vignette reveal">
+              <div class="v-say">Save where we are — I'm switching to another agent.</div>
+              <pre class="v-call">remember_context({kind: "handoff", project: "&lt;repo&gt;", topic: "&lt;feature&gt;", text: "..."})</pre>
+              <pre class="v-response">Stored: viking://user/you/memories/handoffs/active/&lt;repo&gt;/&lt;feature&gt;.md</pre>
+              <div class="v-answer">
+                Open the next agent — the SessionStart hook recalls the same handoff and the durable memory. It picks
+                up the test command and the open blocker without you retyping them.
+              </div>
+            </div>
+
+            <div class="vignette reveal">
+              <div class="v-say">Share this feature's design memory with the team.</div>
+              <pre class="v-call">share_publish({uri: "viking://user/you/memories/durable/projects/&lt;repo&gt;/&lt;feature&gt;.md"})</pre>
+              <pre class="v-response">Published → shared/&lt;team&gt;/durable/projects/&lt;repo&gt;/&lt;feature&gt;.md
+git push: ok</pre>
+              <div class="v-answer">
+                The memory lands in the team git repo. A teammate's next <code>share sync</code> pulls it; their
+                recall surfaces it alongside their own memories — no DM forwarding, no PDF dumping.
+              </div>
+            </div>
+
+            <div class="vignette reveal">
+              <div class="v-say v-auto">(automatic — the PreCompact hook fires before context compaction)</div>
+              <pre class="v-call">remember_context({kind: "handoff", project: "&lt;repo&gt;", topic: "auto-precompact", text: "..."})</pre>
+              <pre class="v-response">Stored: viking://user/you/memories/handoffs/active/&lt;repo&gt;/auto-precompact.md</pre>
+              <div class="v-answer">
+                Compaction summarizes the conversation arc but loses the durable facts. Threadnote's hook captures them
+                first; the post-compaction turn recalls them and resumes without amnesia.
+              </div>
+            </div>
+
+            <div class="vignette reveal">
+              <div class="v-say">Remember that this repo cuts release notes from CI via gh release create.</div>
+              <pre class="v-call">remember_context({kind: "durable", project: "&lt;repo&gt;", topic: "release-process", text: "..."})</pre>
+              <pre class="v-response">Stored: viking://user/you/memories/durable/projects/&lt;repo&gt;/release-process.md</pre>
+              <div class="v-answer">
+                Next time anyone asks where releases happen, the agent finds it in two seconds. No grepping the wiki.
+              </div>
+            </div>
+
+            <div class="vignette reveal">
+              <div class="v-say">What did we conclude about the export-workflow timeout?</div>
+              <pre class="v-call">recall_context({query: "export workflow timeout findings"})</pre>
+              <pre class="v-response">→ viking://user/you/memories/durable/projects/&lt;repo&gt;/export-timeout.md (score 0.71)</pre>
+              <div class="v-answer">
+                Re-open the same investigation three weeks later; the durable memory points your agent at the right
+                files and the resolution. The trail doesn't decay.
+              </div>
+            </div>
+          </div>
+        </div>
+      </section>
+
       <!-- 13. CLOSE -->
       <section id="close" class="slide">
         <div class="slide-inner">
@@ -1538,6 +1596,27 @@ threadnote doctor --dry-run</code></pre>
           }
         });
       })();
+
+      // Replace the hardcoded version pill with whatever npm currently
+      // serves as latest. Fails silently and keeps the fallback text on any
+      // network or registry error — the deck must render even offline.
+      (async () => {
+        const tag = document.getElementById('version-tag');
+        if (!tag) return;
+        try {
+          const response = await fetch('https://registry.npmjs.org/threadnote/latest', {
+            headers: {accept: 'application/json'},
+            signal: AbortSignal.timeout(3000),
+          });
+          if (!response.ok) return;
+          const data = await response.json();
+          if (typeof data.version === 'string' && data.version.length > 0) {
+            tag.textContent = 'v' + data.version;
+          }
+        } catch {
+          // Keep the static fallback.
+        }
+      })();
     </script>
   </body>
 </html>

package/package.json

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