threadnote 0.6.0 → 0.6.2

package/README.md

@@ -240,7 +240,11 @@ For deterministic moments where the agent shouldn't have to remember, Threadnote
 - **`PreCompact`** auto-stores a handoff snapshot for the current repo right before Claude compacts the conversation,
   so the next turn can recall it even if the agent forgot to write a handoff manually.
 - **`SessionStart`** preloads the latest threadnote handoff/feature memory for the current repo into the new session
-  context, so the first turn already knows where you left off.
+  context, so the first turn already knows where you left off. The same hook also runs a daily-cached check against
+  the npm registry and prints a one-line `[threadnote] vX.Y.Z available; run threadnote update` banner when the
+  installed version is behind, so you stop missing releases. Set `THREADNOTE_AUTO_UPDATE=1` to skip the nag and have
+  the hook spawn `threadnote update --yes` in the background instead — the new version takes effect on the next
+  session.
 
 Install them per agent (Codex / Cursor / Copilot are no-ops today — Threadnote prints a clear explanation):
 

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;
     }