skillwiki 0.9.6 → 0.9.8

package/dist/cli.js

@@ -14,7 +14,7 @@ import {
 } from "./chunk-TPS5XD2J.js";
 
 // src/cli.ts
-import { join as join48 } from "path";
+import { join as join49 } from "path";
 import { Command as Command2 } from "commander";
 
 // ../shared/src/exit-codes.ts
@@ -2360,9 +2360,9 @@ async function runStale(input) {
       if (input.project && !project.includes(input.project)) continue;
       let inferred = false;
       if (input.forceScan && !kind) {
-        const basename2 = t.relPath.split("/").pop();
-        if (!LOOP_CYCLE_PATTERN.test(basename2)) {
-          const m = basename2.match(KIND_FROM_FILENAME);
+        const basename3 = t.relPath.split("/").pop();
+        if (!LOOP_CYCLE_PATTERN.test(basename3)) {
+          const m = basename3.match(KIND_FROM_FILENAME);
           if (m) {
             kind = m[1];
             inferred = true;
@@ -3499,6 +3499,7 @@ function buildCliSurface() {
   program2.command("seed").option("--wiki <name>");
   program2.command("observe").requiredOption("--text <text>").option("--kind <kind>").option("--project <slug>").option("--wiki <name>");
   program2.command("session-brief").option("--project <slug>").option("--write").option("--wiki <name>");
+  program2.command("memory");
   program2.command("ingest").requiredOption("--vault <path>").requiredOption("--type <type>").requiredOption("--title <title>").option("--tags <csv>").option("--provenance <provenance>").option("--dry-run");
   program2.command("fleet");
   const graphCmd = program2.commands.find((c) => c.name() === "graph");
@@ -3524,6 +3525,11 @@ function buildCliSurface() {
   const backupCmd2 = program2.commands.find((c) => c.name() === "backup");
   backupCmd2.command("sync").option("--dry-run").option("--bucket <name>").option("--endpoint <url>").option("--region <region>").option("--prune").option("--wiki <name>");
   backupCmd2.command("restore").option("--bucket <name>").option("--endpoint <url>").option("--region <region>").option("--target <dir>").option("--wiki <name>");
+  const memoryCmd2 = program2.commands.find((c) => c.name() === "memory");
+  memoryCmd2.command("topics").option("--project <slug>").option("--limit <n>").option("--wiki <name>");
+  memoryCmd2.command("index").requiredOption("--project <slug>").option("--wiki <name>");
+  memoryCmd2.command("recall").requiredOption("--project <slug>").requiredOption("--topic <slug>").option("--limit <n>").option("--wiki <name>");
+  memoryCmd2.command("import").requiredOption("--from <path>").requiredOption("--project <slug>").option("--dry-run").option("--apply").option("--max-bytes <n>").option("--wiki <name>");
   const fleetCmd2 = program2.commands.find((c) => c.name() === "fleet");
   fleetCmd2.command("validate");
   fleetCmd2.command("context").option("--file <path>").option("--host-id <id>");
@@ -8329,6 +8335,7 @@ async function runSessionBrief(input) {
     const workItems = await loadWorkItems(scan.data.workItems);
     const digests = await loadTrendDigests(scan.data.typedKnowledge);
     const healthWarnings = await loadHealthWarnings(input.vault);
+    const memoryTopics = project ? await loadMemoryTopics(input.vault, project) : [];
     const latestLogs = newest(transcripts.filter((t) => t.kind === "session-log"), 3);
     const unclaimedCaptures = newest(transcripts.filter((t) => {
       if (t.kind !== "task" && t.kind !== "bug") return false;
@@ -8348,6 +8355,7 @@ async function runSessionBrief(input) {
       activeWork,
       latestDigest,
       projectLogs,
+      memoryTopics,
       healthWarnings
     }), MAX_WORDS);
     let filesWritten = [];
@@ -8359,7 +8367,8 @@ async function runSessionBrief(input) {
         brief,
         generatedAt,
         today,
-        wordCount: countWords(brief)
+        wordCount: countWords(brief),
+        memoryTopics
       });
       filesWritten = writeResult.filesWritten;
       indexUpdated = writeResult.indexUpdated;
@@ -8376,6 +8385,7 @@ async function runSessionBrief(input) {
         index_updated: indexUpdated,
         log_updated: logUpdated,
         generated_at: generatedAt,
+        memory_topics: memoryTopics,
         humanHint
       })
     };
@@ -8488,6 +8498,7 @@ function renderBrief(input) {
   appendSection(lines, "Unclaimed Captures", input.unclaimedCaptures, "No unclaimed task or bug captures found.");
   appendSection(lines, "Recent Session Logs", input.project ? input.projectLogs : input.latestLogs, "No recent session logs found.");
   appendSection(lines, "Latest Agent Memory Trends", input.latestDigest, "No agent memory trends digest found.");
+  appendMemoryTopicsSection(lines, input.project, input.memoryTopics);
   appendTextSection(lines, "Health Warnings", input.healthWarnings, "No high-level health warnings found.");
   lines.push(
     "## Suggested Commands",
@@ -8499,6 +8510,15 @@ function renderBrief(input) {
   );
   return lines.join("\n").trimEnd() + "\n";
 }
+function appendMemoryTopicsSection(lines, project, topics) {
+  if (!project || topics.length === 0) return;
+  lines.push("## Memory Topics", "");
+  for (const topic of topics.slice(0, 5)) {
+    const sourceCount = topic.paths.length === 1 ? "1 source" : `${topic.paths.length} sources`;
+    lines.push(`- ${topic.updated} ${topic.name} (${sourceCount}) \u2014 ${topic.summary}; recall: \`skillwiki memory recall --project ${project} --topic ${topic.name}\``);
+  }
+  lines.push("");
+}
 function appendSection(lines, title, items, empty) {
   lines.push(`## ${title}`, "");
   if (items.length === 0) {
@@ -8537,6 +8557,23 @@ async function loadHealthWarnings(vault) {
     return [];
   }
 }
+async function loadMemoryTopics(vault, project) {
+  const text = await readIfExists2(join38(vault, ".skillwiki", "memory", project, "topics.json"));
+  if (!text) return [];
+  try {
+    const parsed = JSON.parse(text);
+    if (!Array.isArray(parsed.topics)) return [];
+    return parsed.topics.filter((topic) => typeof topic === "object" && topic !== null && !Array.isArray(topic)).map((topic) => ({
+      name: stringField(topic.name),
+      summary: stringField(topic.summary),
+      project: stringField(topic.project) || void 0,
+      updated: stringField(topic.updated),
+      paths: Array.isArray(topic.paths) ? topic.paths.filter((path) => typeof path === "string") : []
+    })).filter((topic) => topic.name && topic.summary && topic.updated && topic.paths.length > 0).sort((a, b) => b.updated.localeCompare(a.updated) || a.name.localeCompare(b.name)).slice(0, 5);
+  } catch {
+    return [];
+  }
+}
 async function writeBriefArtifacts(vault, input) {
   const metaPath = join38(vault, "meta", "latest-session-brief.md");
   const cacheMdPath = join38(vault, ".skillwiki", "session-brief.md");
@@ -8553,7 +8590,8 @@ async function writeBriefArtifacts(vault, input) {
     project: input.project,
     brief: input.brief,
     word_count: input.wordCount,
-    generated_at: input.generatedAt
+    generated_at: input.generatedAt,
+    memory_topics: input.memoryTopics
   }, null, 2)}
 `, "utf8");
   const indexUpdated = await ensureIndexEntry(vault);
@@ -8589,7 +8627,7 @@ function renderCommittedBrief(input) {
     `created: ${input.today}`,
     `updated: ${input.today}`,
     "type: meta",
-    "tags: [generated, session-brief]",
+    "tags: [meta, session-brief]",
     "confidence: high",
     "generated_by: skillwiki session-brief",
     `generated_at: ${input.generatedAt}`,
@@ -8672,10 +8710,553 @@ function dateFromPath(path) {
   return path.match(/\d{4}-\d{2}-\d{2}/)?.[0] ?? "";
 }
 
-// src/commands/ingest.ts
-import { readFile as readFile26, writeFile as writeFile15, mkdir as mkdir14 } from "fs/promises";
-import { join as join39 } from "path";
+// src/commands/memory.ts
 import { createHash as createHash8 } from "crypto";
+import { mkdir as mkdir14, readFile as readFile26, readdir as readdir8, stat as stat9, writeFile as writeFile15 } from "fs/promises";
+import { basename as basename2, extname, join as join39, relative as relative4, sep as sep4 } from "path";
+async function runMemoryTopics(input) {
+  const scan = await scanVault(input.vault);
+  if (!scan.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scan };
+  const cacheText = await readMemoryCache(input.vault, input.project);
+  if (!cacheText) {
+    return {
+      exitCode: ExitCode.OK,
+      result: ok({
+        cache_present: false,
+        topics: [],
+        files_written: [],
+        humanHint: "no memory topics cache found"
+      })
+    };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(cacheText);
+  } catch (e) {
+    return {
+      exitCode: ExitCode.WRITE_FAILED,
+      result: err("WRITE_FAILED", {
+        path: ".skillwiki/memory-topics.json",
+        message: `invalid memory topics cache: ${String(e)}`
+      })
+    };
+  }
+  const limit = normalizeLimit(input.limit);
+  const topics = normalizeTopics(parsed.topics).filter((topic) => !input.project || topic.project === input.project).sort(compareTopics).slice(0, limit);
+  return {
+    exitCode: ExitCode.OK,
+    result: ok({
+      generated_at: stringField2(parsed.generated_at) || void 0,
+      cache_present: true,
+      topics,
+      files_written: [],
+      humanHint: renderHumanHint(topics)
+    })
+  };
+}
+async function runMemoryIndex(input) {
+  const scan = await scanVault(input.vault);
+  if (!scan.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scan };
+  const warnings = [];
+  const sourcePages = dedupePages(scan.data.allMarkdown);
+  const sources = [];
+  for (const page of sourcePages) {
+    const source = await readMemorySource(page, input.project, warnings);
+    if (source) sources.push(source);
+  }
+  const generatedAt = (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+  const topics = buildTopics(input.project, sources);
+  const relCachePath = memoryCacheRelPath(input.project);
+  const absCachePath = join39(input.vault, relCachePath);
+  await mkdir14(join39(input.vault, ".skillwiki", "memory", input.project), { recursive: true });
+  await writeFile15(absCachePath, `${JSON.stringify({
+    generated_at: generatedAt,
+    project: input.project,
+    topics,
+    sources,
+    warnings
+  }, null, 2)}
+`, "utf8");
+  return {
+    exitCode: ExitCode.OK,
+    result: ok({
+      project: input.project,
+      generated_at: generatedAt,
+      topic_count: topics.length,
+      source_count: sources.length,
+      topics,
+      files_written: [relCachePath],
+      warnings,
+      humanHint: `indexed ${sources.length} memory sources into ${topics.length} topics for ${input.project}`
+    })
+  };
+}
+async function runMemoryRecall(input) {
+  const scan = await scanVault(input.vault);
+  if (!scan.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scan };
+  const cacheText = await readMemoryCache(input.vault, input.project);
+  if (!cacheText) {
+    return {
+      exitCode: ExitCode.OK,
+      result: ok({
+        project: input.project,
+        topic: input.topic,
+        sources: [],
+        humanHint: `no memory topics cache found for project ${input.project}`
+      })
+    };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(cacheText);
+  } catch (e) {
+    return {
+      exitCode: ExitCode.WRITE_FAILED,
+      result: err("WRITE_FAILED", {
+        path: memoryCacheRelPath(input.project),
+        message: `invalid memory topics cache: ${String(e)}`
+      })
+    };
+  }
+  const limit = normalizeLimit(input.limit);
+  const sources = normalizeSources(parsed.sources).filter((source) => source.topics.includes(input.topic)).filter((source) => source.memory_privacy !== "secret-blocked").sort(compareSources).slice(0, limit);
+  return {
+    exitCode: ExitCode.OK,
+    result: ok({
+      project: input.project,
+      topic: input.topic,
+      sources,
+      humanHint: renderRecallHint(input.topic, sources)
+    })
+  };
+}
+async function runMemoryImport(input) {
+  const scan = await scanVault(input.vault);
+  if (!scan.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scan };
+  const maxBytes = input.maxBytes ?? 2e5;
+  let files;
+  try {
+    files = await collectImportFiles(input.from);
+  } catch (e) {
+    return {
+      exitCode: ExitCode.WRITE_FAILED,
+      result: err("WRITE_FAILED", { path: input.from, message: String(e) })
+    };
+  }
+  const generatedAt = (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+  const today = generatedAt.slice(0, 10);
+  const entries = [];
+  const filesWritten = [];
+  for (const file of files) {
+    let entry;
+    try {
+      entry = await buildImportEntry(file, input.from, input.project, today, maxBytes);
+      if (input.apply && entry.status === "ready" && entry.proposed_path) {
+        const written2 = await writeImportCapture(input.vault, entry, today);
+        entry.status = "written";
+        entry.written_path = written2.relPath;
+        entry.validation = written2.validation;
+        filesWritten.push(written2.relPath);
+      }
+    } catch (e) {
+      return {
+        exitCode: ExitCode.WRITE_FAILED,
+        result: err("WRITE_FAILED", { path: file, message: String(e) })
+      };
+    }
+    entries.push(entry);
+  }
+  const manifest = {
+    project: input.project,
+    generated_at: generatedAt,
+    source_root: input.from,
+    entries
+  };
+  const ready = entries.filter((entry) => entry.status === "ready").length;
+  const written = entries.filter((entry) => entry.status === "written").length;
+  const rejected = entries.filter((entry) => entry.status === "rejected").length;
+  return {
+    exitCode: ExitCode.OK,
+    result: ok({
+      applied: !!input.apply,
+      manifest,
+      files_written: filesWritten,
+      humanHint: input.apply ? `memory import applied: ${written} written, ${rejected} rejected` : `memory import dry-run: ${ready} ready, ${rejected} rejected`
+    })
+  };
+}
+async function readIfExists3(path) {
+  try {
+    return await readFile26(path, "utf8");
+  } catch {
+    return "";
+  }
+}
+async function collectImportFiles(source) {
+  const st = await stat9(source);
+  if (st.isFile()) return isImportCandidate(source) ? [source] : [];
+  const files = [];
+  await walkImportFiles(source, files);
+  return files.sort((a, b) => a.localeCompare(b));
+}
+async function walkImportFiles(dir, out) {
+  const entries = await readdir8(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name === ".git" || entry.name === "node_modules") continue;
+    const path = join39(dir, entry.name);
+    if (entry.isDirectory()) {
+      await walkImportFiles(path, out);
+    } else if (entry.isFile() && isImportCandidate(path)) {
+      out.push(path);
+    }
+  }
+}
+function isImportCandidate(path) {
+  const ext = extname(path).toLowerCase();
+  return ext === ".md" || ext === ".txt";
+}
+async function buildImportEntry(file, sourceRoot, project, today, maxBytes) {
+  const st = await stat9(file);
+  const sourceKind = classifyImportSource(file);
+  const hash = createHash8("sha256").update(await readFile26(file)).digest("hex");
+  const baseEntry = {
+    source_path: file,
+    source_kind: sourceKind,
+    sha256: hash,
+    memory_kind: defaultImportKind(sourceKind),
+    memory_privacy: "local",
+    redaction_count: 0
+  };
+  if (st.size > maxBytes) {
+    return {
+      ...baseEntry,
+      status: "rejected",
+      reason: "oversized_source"
+    };
+  }
+  if (sourceKind === "codex-rule" || sourceKind === "agents-policy") {
+    return {
+      ...baseEntry,
+      status: "rejected",
+      reason: "policy_source_not_imported"
+    };
+  }
+  const text = await readFile26(file, "utf8");
+  const extracted = extractImportText(text, sourceKind);
+  if (!extracted) {
+    return {
+      ...baseEntry,
+      status: "rejected",
+      reason: "policy_source_not_imported"
+    };
+  }
+  const redacted = redactSensitiveContent(extracted, { file });
+  const privacy = redacted.findings.length > 0 ? "sensitive" : "local";
+  const sourceSlug = slugify3(basename2(file, extname(file)));
+  const relSource = relative4(sourceRoot, file).split(sep4).join("/");
+  const entry = {
+    ...baseEntry,
+    status: "ready",
+    memory_privacy: privacy,
+    redaction_count: redacted.findings.length,
+    proposed_path: `raw/transcripts/${today}-memory-import-${sourceSlug}.md`,
+    source_path: relSource || file
+  };
+  Object.defineProperty(entry, "__content", { value: redacted.text, enumerable: false });
+  Object.defineProperty(entry, "__project", { value: project, enumerable: false });
+  return entry;
+}
+async function writeImportCapture(vault, entry, today) {
+  const content = hiddenString(entry, "__content");
+  const project = hiddenString(entry, "__project");
+  const relPath = await availableImportPath(vault, entry.proposed_path);
+  const absPath = join39(vault, relPath);
+  await mkdir14(join39(vault, "raw", "transcripts"), { recursive: true });
+  await writeFile15(absPath, renderImportCapture(entry, content, project, today), "utf8");
+  const validation = await runValidate({ file: absPath });
+  return {
+    relPath,
+    validation: {
+      valid: validation.exitCode === ExitCode.OK,
+      exit_code: validation.exitCode
+    }
+  };
+}
+async function availableImportPath(vault, proposed) {
+  const ext = extname(proposed);
+  const stem = proposed.slice(0, -ext.length);
+  let candidate = proposed;
+  let i = 2;
+  while (await readIfExists3(join39(vault, candidate))) {
+    candidate = `${stem}-${i}${ext}`;
+    i++;
+  }
+  return candidate;
+}
+function renderImportCapture(entry, content, project, today) {
+  return [
+    "---",
+    "source_url:",
+    `ingested: ${today}`,
+    "kind: note",
+    `project: "[[${project}]]"`,
+    `memory_kind: ${entry.memory_kind}`,
+    "memory_topics: [imported-memory]",
+    "memory_scope: project",
+    "memory_policy: historical",
+    `memory_privacy: ${entry.memory_privacy}`,
+    "memory_status: active",
+    `source_agent: skillwiki memory import`,
+    `source_hash: ${entry.sha256}`,
+    `source_paths: ["${entry.source_path.replaceAll('"', '\\"')}"]`,
+    "---",
+    "",
+    `# Imported Memory: ${basename2(entry.source_path, extname(entry.source_path))}`,
+    "",
+    `Source kind: ${entry.source_kind}`,
+    "",
+    "Promotion guidance: review this raw capture before promoting it to compound or typed knowledge.",
+    "",
+    content.trimEnd(),
+    ""
+  ].join("\n");
+}
+function hiddenString(entry, key) {
+  return entry[key] ?? "";
+}
+function classifyImportSource(file) {
+  const rel = file.split(sep4).join("/");
+  const name = basename2(file);
+  if (rel.includes("/.codex/memories/")) return "codex-memory";
+  if (rel.includes("/.codex/rules/")) return "codex-rule";
+  if (rel.includes("/.claude/") && name === "napkin.md") return "napkin";
+  if (rel.includes("/.memsearch/memory/")) return "memsearch";
+  if (name === "AGENTS.md") return "agents-policy";
+  if (name === "CLAUDE.md") return "claude-auto-memory";
+  return "generic";
+}
+function defaultImportKind(sourceKind) {
+  switch (sourceKind) {
+    case "codex-memory":
+    case "claude-auto-memory":
+      return "preference";
+    case "napkin":
+      return "correction";
+    case "memsearch":
+      return "handoff";
+    default:
+      return "handoff";
+  }
+}
+function extractImportText(text, sourceKind) {
+  if (sourceKind !== "claude-auto-memory") return text;
+  const match = text.match(/<!--\s*AUTO-MEMORY:START\s*-->([\s\S]*?)<!--\s*AUTO-MEMORY:END\s*-->/i);
+  return match?.[1]?.trim() ?? "";
+}
+function normalizeTopics(value) {
+  if (!Array.isArray(value)) return [];
+  const topics = [];
+  for (const item of value) {
+    if (!isRecord(item)) continue;
+    const name = stringField2(item.name);
+    const summary = stringField2(item.summary);
+    const updated = stringField2(item.updated);
+    const paths = stringArray(item.paths);
+    if (!name || !summary || !updated || paths.length === 0) continue;
+    const project = stringField2(item.project);
+    topics.push({
+      name,
+      summary,
+      ...project ? { project } : {},
+      updated,
+      paths
+    });
+  }
+  return topics;
+}
+function normalizeSources(value) {
+  if (!Array.isArray(value)) return [];
+  const sources = [];
+  for (const item of value) {
+    if (!isRecord(item)) continue;
+    const path = stringField2(item.path);
+    const title = stringField2(item.title);
+    const summary = stringField2(item.summary);
+    const updated = stringField2(item.updated);
+    const hash = stringField2(item.hash);
+    const topics = stringArray(item.topics);
+    if (!path || !title || !summary || !updated || !hash || topics.length === 0) continue;
+    const project = stringField2(item.project);
+    sources.push({
+      path,
+      title,
+      summary,
+      updated,
+      hash,
+      topics,
+      ...project ? { project } : {},
+      ...stringField2(item.memory_kind) ? { memory_kind: stringField2(item.memory_kind) } : {},
+      ...stringField2(item.memory_scope) ? { memory_scope: stringField2(item.memory_scope) } : {},
+      ...stringField2(item.memory_policy) ? { memory_policy: stringField2(item.memory_policy) } : {},
+      memory_privacy: stringField2(item.memory_privacy) || "local",
+      memory_status: stringField2(item.memory_status) || "active"
+    });
+  }
+  return sources;
+}
+function normalizeLimit(value) {
+  if (value === void 0 || !Number.isFinite(value) || value <= 0) return 10;
+  return Math.floor(value);
+}
+function compareTopics(a, b) {
+  return b.updated.localeCompare(a.updated) || a.name.localeCompare(b.name);
+}
+function compareSources(a, b) {
+  return b.updated.localeCompare(a.updated) || a.path.localeCompare(b.path);
+}
+function renderHumanHint(topics) {
+  if (topics.length === 0) return "no memory topics found";
+  return topics.map((topic) => {
+    const project = topic.project ? ` [${topic.project}]` : "";
+    return `${topic.updated} ${topic.name}${project} \u2014 ${topic.summary} (${topic.paths.join(", ")})`;
+  }).join("\n");
+}
+function renderRecallHint(topic, sources) {
+  if (sources.length === 0) return `no memory sources found for topic ${topic}`;
+  return sources.map((source) => `${source.updated} ${source.title} (${source.path}) \u2014 ${source.summary}`).join("\n");
+}
+function memoryCacheRelPath(project) {
+  return `.skillwiki/memory/${project}/topics.json`;
+}
+async function readMemoryCache(vault, project) {
+  if (project) {
+    const projectCache = await readIfExists3(join39(vault, memoryCacheRelPath(project)));
+    if (projectCache) return projectCache;
+  }
+  return readIfExists3(join39(vault, ".skillwiki", "memory-topics.json"));
+}
+function dedupePages(pages) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const page of pages) {
+    if (seen.has(page.relPath)) continue;
+    seen.add(page.relPath);
+    out.push(page);
+  }
+  return out;
+}
+async function readMemorySource(page, project, warnings) {
+  const text = await readPage(page);
+  const fm = extractFrontmatter(text);
+  if (!fm.ok) return null;
+  const topics = normalizeMemoryTopics(fm.data.memory_topics, page.relPath, warnings);
+  if (topics.length === 0) return null;
+  const projects = memoryProjects(page.relPath, fm.data);
+  const scope = stringField2(fm.data.memory_scope);
+  if (!projects.includes(project) && scope !== "global" && scope !== "cross-agent") return null;
+  const privacy = stringField2(fm.data.memory_privacy) || "local";
+  if (privacy === "secret-blocked") {
+    warnings.push(`${page.relPath}: skipped secret-blocked memory`);
+    return null;
+  }
+  const status = stringField2(fm.data.memory_status) || "active";
+  if (status === "archived" || status === "rejected") return null;
+  const split = splitFrontmatter(text);
+  const body = split.ok ? split.data.body : text;
+  const updated = stringField2(fm.data.last_seen) || stringField2(fm.data.updated) || stringField2(fm.data.ingested) || dateFromPath2(page.relPath);
+  const title = stringField2(fm.data.title) || page.relPath.split("/").pop()?.replace(/\.md$/, "") || page.relPath;
+  return {
+    path: page.relPath,
+    title,
+    summary: summarize2(body),
+    updated,
+    hash: createHash8("sha256").update(Buffer.from(body, "utf8")).digest("hex"),
+    topics,
+    project,
+    ...stringField2(fm.data.memory_kind) ? { memory_kind: stringField2(fm.data.memory_kind) } : {},
+    ...scope ? { memory_scope: scope } : {},
+    ...stringField2(fm.data.memory_policy) ? { memory_policy: stringField2(fm.data.memory_policy) } : {},
+    memory_privacy: privacy,
+    memory_status: status
+  };
+}
+function normalizeMemoryTopics(value, path, warnings) {
+  const rawTopics = typeof value === "string" ? [value] : stringArray(value);
+  const topics = [];
+  for (const topic of rawTopics) {
+    if (!/^[a-z0-9][a-z0-9-]*$/.test(topic)) {
+      warnings.push(`${path}: invalid memory topic slug ${topic}`);
+      continue;
+    }
+    if (!topics.includes(topic)) topics.push(topic);
+  }
+  return topics;
+}
+function memoryProjects(path, fm) {
+  const projects = /* @__PURE__ */ new Set();
+  const project = wikilinkSlug2(fm.project);
+  if (project) projects.add(project);
+  if (Array.isArray(fm.provenance_projects)) {
+    for (const value of fm.provenance_projects) {
+      const slug = wikilinkSlug2(value);
+      if (slug) projects.add(slug);
+    }
+  }
+  const pathProject = path.match(/^projects\/([^/]+)\//)?.[1];
+  if (pathProject) projects.add(pathProject);
+  return [...projects];
+}
+function buildTopics(project, sources) {
+  const byTopic = /* @__PURE__ */ new Map();
+  for (const source of sources) {
+    for (const topic of source.topics) {
+      const list = byTopic.get(topic) ?? [];
+      list.push(source);
+      byTopic.set(topic, list);
+    }
+  }
+  return [...byTopic.entries()].map(([name, topicSources]) => {
+    const sorted = [...topicSources].sort(compareSources);
+    return {
+      name,
+      project,
+      summary: sorted[0]?.summary ?? "",
+      updated: sorted[0]?.updated ?? "",
+      paths: sorted.map((source) => source.path)
+    };
+  }).sort((a, b) => a.name.localeCompare(b.name));
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringField2(value) {
+  return typeof value === "string" ? value : "";
+}
+function stringArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string" && item.length > 0) : [];
+}
+function wikilinkSlug2(value) {
+  if (typeof value !== "string") return void 0;
+  const match = value.match(/^\[\[([^\]]+)\]\]$/);
+  return match?.[1] ?? value;
+}
+function summarize2(body) {
+  const lines = body.split(/\r?\n/).map((line) => line.replace(/^#+\s*/, "").trim()).filter((line) => line.length > 0 && !line.startsWith("```"));
+  const summary = lines.join(" ").replace(/\s+/g, " ").trim();
+  return summary.length > 180 ? `${summary.slice(0, 177).trimEnd()}...` : summary;
+}
+function dateFromPath2(path) {
+  return path.match(/\d{4}-\d{2}-\d{2}/)?.[0] ?? "";
+}
+function slugify3(value) {
+  const slug = value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return slug || "memory";
+}
+
+// src/commands/ingest.ts
+import { readFile as readFile27, writeFile as writeFile16, mkdir as mkdir15 } from "fs/promises";
+import { join as join40 } from "path";
+import { createHash as createHash9 } from "crypto";
 var ALLOWED_TYPES = /* @__PURE__ */ new Set(["entity", "concept", "comparison", "query"]);
 var TYPE_DIR = {
   entity: "entities",
@@ -8684,7 +9265,7 @@ var TYPE_DIR = {
   query: "queries"
 };
 var ALLOWED_PROVENANCE = /* @__PURE__ */ new Set(["research", "project"]);
-function slugify3(text) {
+function slugify4(text) {
   return text.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 80) || "untitled";
 }
 function isUrl(source) {
@@ -8833,7 +9414,7 @@ async function runIngest(input) {
     sourceContent = fetchResult.data.body;
   } else {
     try {
-      sourceContent = await readFile26(input.source, "utf8");
+      sourceContent = await readFile27(input.source, "utf8");
     } catch {
       return {
         exitCode: ExitCode.FILE_NOT_FOUND,
@@ -8851,15 +9432,15 @@ async function runIngest(input) {
       })
     };
   }
-  const sha256 = createHash8("sha256").update(Buffer.from(sourceContent, "utf8")).digest("hex");
+  const sha256 = createHash9("sha256").update(Buffer.from(sourceContent, "utf8")).digest("hex");
   const today = todayIso();
-  const slug = slugify3(input.title);
+  const slug = slugify4(input.title);
   const tags = input.tags && input.tags.length > 0 ? input.tags : [];
   const rawRelPath = `raw/articles/${slug}.md`;
   const typedDir = TYPE_DIR[input.type] ?? `${input.type}s`;
   const typedRelPath = `${typedDir}/${slug}.md`;
-  const rawAbsPath = join39(input.vault, rawRelPath);
-  const typedAbsPath = join39(input.vault, typedRelPath);
+  const rawAbsPath = join40(input.vault, rawRelPath);
+  const typedAbsPath = join40(input.vault, typedRelPath);
   const identity = assessSourceIdentity({
     rawPath: rawRelPath,
     sourceUrl: sourceUrl ?? void 0,
@@ -8941,8 +9522,8 @@ async function runIngest(input) {
     };
   }
   try {
-    await mkdir14(join39(input.vault, "raw", "articles"), { recursive: true });
-    await writeFile15(rawAbsPath, rawContent, "utf8");
+    await mkdir15(join40(input.vault, "raw", "articles"), { recursive: true });
+    await writeFile16(rawAbsPath, rawContent, "utf8");
   } catch (e) {
     return {
       exitCode: ExitCode.WRITE_FAILED,
@@ -8950,8 +9531,8 @@ async function runIngest(input) {
     };
   }
   try {
-    await mkdir14(join39(input.vault, typedDir), { recursive: true });
-    await writeFile15(typedAbsPath, typedContent, "utf8");
+    await mkdir15(join40(input.vault, typedDir), { recursive: true });
+    await writeFile16(typedAbsPath, typedContent, "utf8");
   } catch (e) {
     return {
       exitCode: ExitCode.WRITE_FAILED,
@@ -9130,19 +9711,19 @@ ${body}`;
 
 // src/commands/sync.ts
 import { existsSync as existsSync17 } from "fs";
-import { join as join41 } from "path";
+import { join as join42 } from "path";
 
 // src/utils/sync-lock.ts
 import { existsSync as existsSync16, mkdirSync as mkdirSync6, readFileSync as readFileSync11, renameSync as renameSync2, unlinkSync as unlinkSync5, writeFileSync as writeFileSync7 } from "fs";
-import { join as join40 } from "path";
-import { createHash as createHash9 } from "crypto";
+import { join as join41 } from "path";
+import { createHash as createHash10 } from "crypto";
 function getSessionId() {
   if (process.env.CLAUDE_SESSION_ID) return process.env.CLAUDE_SESSION_ID;
   if (process.env.SKILLWIKI_SESSION_ID) return process.env.SKILLWIKI_SESSION_ID;
   return process.pid.toString();
 }
 function lockPath(vault) {
-  return join40(vault, ".skillwiki", "sync.lock");
+  return join41(vault, ".skillwiki", "sync.lock");
 }
 function readLock(vault) {
   const path = lockPath(vault);
@@ -9161,7 +9742,7 @@ function isStale(lock, now) {
 }
 function acquireLock(vault, opts = {}) {
   const path = lockPath(vault);
-  const dir = join40(vault, ".skillwiki");
+  const dir = join41(vault, ".skillwiki");
   if (!existsSync16(dir)) {
     mkdirSync6(dir, { recursive: true });
   }
@@ -9236,7 +9817,7 @@ function releaseLock(vault, opts = {}) {
 function runSyncStatus(input) {
   const vault = input.vault;
   const includeStashes = input.includeStashes ?? false;
-  if (!existsSync17(join41(vault, ".git"))) {
+  if (!existsSync17(join42(vault, ".git"))) {
     return {
       exitCode: ExitCode.VAULT_PATH_INVALID,
       result: ok({
@@ -9314,7 +9895,7 @@ function runSyncStatus(input) {
 }
 async function runSyncPush(input) {
   const vault = input.vault;
-  if (!existsSync17(join41(vault, ".git"))) {
+  if (!existsSync17(join42(vault, ".git"))) {
     return {
       exitCode: ExitCode.VAULT_PATH_INVALID,
       result: err("NOT_A_GIT_REPO", { path: vault })
@@ -9437,7 +10018,7 @@ function enableGitLongPathsOnWindows(vault) {
 }
 async function runSyncPull(input) {
   const vault = input.vault;
-  if (!existsSync17(join41(vault, ".git"))) {
+  if (!existsSync17(join42(vault, ".git"))) {
     return {
       exitCode: ExitCode.VAULT_PATH_INVALID,
       result: err("NOT_A_GIT_REPO", { path: vault })
@@ -9678,7 +10259,7 @@ function runSyncUnlock(input) {
 
 // src/commands/backup.ts
 import { statSync as statSync5, readdirSync as readdirSync3, readFileSync as readFileSync12, mkdirSync as mkdirSync7, writeFileSync as writeFileSync8 } from "fs";
-import { join as join42, relative as relative4, dirname as dirname14 } from "path";
+import { join as join43, relative as relative5, dirname as dirname14 } from "path";
 import { PutObjectCommand, HeadObjectCommand, ListObjectsV2Command, GetObjectCommand, DeleteObjectsCommand } from "@aws-sdk/client-s3";
 
 // src/utils/s3-client.ts
@@ -9702,11 +10283,11 @@ var SKIP_DIRS2 = /* @__PURE__ */ new Set([".git", ".obsidian", "_archive", "node
 function* walkMarkdown(dir, base) {
   for (const entry of readdirSync3(dir, { withFileTypes: true })) {
     if (SKIP_DIRS2.has(entry.name)) continue;
-    const full = join42(dir, entry.name);
+    const full = join43(dir, entry.name);
     if (entry.isDirectory()) {
       yield* walkMarkdown(full, base);
     } else if (entry.name.endsWith(".md")) {
-      yield relative4(base, full).replace(/\\/g, "/");
+      yield relative5(base, full).replace(/\\/g, "/");
     }
   }
 }
@@ -9725,7 +10306,7 @@ async function runBackupSync(input) {
   let failed = 0;
   const files = [...walkMarkdown(input.vault, input.vault)];
   for (const relPath of files) {
-    const absPath = join42(input.vault, relPath);
+    const absPath = join43(input.vault, relPath);
     const localStat = statSync5(absPath);
     let needsUpload = true;
     try {
@@ -9801,7 +10382,7 @@ async function runBackupRestore(input) {
     const objects = list.Contents ?? [];
     for (const obj of objects) {
       if (!obj.Key) continue;
-      const localPath = join42(target, obj.Key);
+      const localPath = join43(target, obj.Key);
       try {
         const localStat = statSync5(localPath);
         if (obj.LastModified && localStat.mtime > obj.LastModified) {
@@ -9848,8 +10429,8 @@ async function runBackupRestore(input) {
 
 // src/commands/status.ts
 import { existsSync as existsSync18, statSync as statSync6 } from "fs";
-import { readFile as readFile27 } from "fs/promises";
-import { join as join43 } from "path";
+import { readFile as readFile28 } from "fs/promises";
+import { join as join44 } from "path";
 async function runStatus(input) {
   if (!existsSync18(input.vault)) {
     return { exitCode: ExitCode.VAULT_PATH_INVALID, result: err("VAULT_PATH_INVALID", { vault: input.vault }) };
@@ -9876,7 +10457,7 @@ async function runStatus(input) {
   const compound = scan.data.compound.length;
   let schemaVersion = "v1";
   try {
-    const schemaContent = await readFile27(join43(input.vault, "SCHEMA.md"), "utf8");
+    const schemaContent = await readFile28(join44(input.vault, "SCHEMA.md"), "utf8");
     const versionMatch = schemaContent.match(/version:\s*["']?([^"'\s\n]+)/i);
     if (versionMatch) schemaVersion = versionMatch[1];
   } catch {
@@ -9936,8 +10517,8 @@ async function runStatus(input) {
 }
 
 // src/commands/seed.ts
-import { mkdir as mkdir15, writeFile as writeFile16, stat as stat9 } from "fs/promises";
-import { join as join44 } from "path";
+import { mkdir as mkdir16, writeFile as writeFile17, stat as stat10 } from "fs/promises";
+import { join as join45 } from "path";
 var TODAY = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
 var EXAMPLE_PAGES = {
   "entities/example-project.md": `---
@@ -10006,30 +10587,30 @@ Real sources are immutable after ingestion \u2014 never edit them.
 `;
 async function runSeed(input) {
   try {
-    await stat9(join44(input.vault, "SCHEMA.md"));
+    await stat10(join45(input.vault, "SCHEMA.md"));
   } catch {
     return { exitCode: ExitCode.VAULT_PATH_INVALID, result: err("VAULT_PATH_INVALID", { root: input.vault, reason: "SCHEMA.md missing \u2014 run `skillwiki init` first" }) };
   }
   const created = [];
   const skipped = [];
   for (const [relPath, content] of Object.entries(EXAMPLE_PAGES)) {
-    const absPath = join44(input.vault, relPath);
+    const absPath = join45(input.vault, relPath);
     try {
-      await stat9(absPath);
+      await stat10(absPath);
       skipped.push(relPath);
     } catch {
-      await mkdir15(join44(absPath, ".."), { recursive: true });
-      await writeFile16(absPath, content, "utf8");
+      await mkdir16(join45(absPath, ".."), { recursive: true });
+      await writeFile17(absPath, content, "utf8");
       created.push(relPath);
     }
   }
-  const rawPath = join44(input.vault, "raw", "articles", "example-source.md");
+  const rawPath = join45(input.vault, "raw", "articles", "example-source.md");
   try {
-    await stat9(rawPath);
+    await stat10(rawPath);
     skipped.push("raw/articles/example-source.md");
   } catch {
-    await mkdir15(join44(rawPath, ".."), { recursive: true });
-    await writeFile16(rawPath, EXAMPLE_RAW, "utf8");
+    await mkdir16(join45(rawPath, ".."), { recursive: true });
+    await writeFile17(rawPath, EXAMPLE_RAW, "utf8");
     created.push("raw/articles/example-source.md");
   }
   if (created.length > 0) {
@@ -10051,9 +10632,9 @@ async function runSeed(input) {
 }
 
 // src/commands/canvas.ts
-import { readFile as readFile28, writeFile as writeFile17 } from "fs/promises";
+import { readFile as readFile29, writeFile as writeFile18 } from "fs/promises";
 import { existsSync as existsSync19 } from "fs";
-import { join as join45 } from "path";
+import { join as join46 } from "path";
 var NODE_WIDTH = 240;
 var NODE_HEIGHT = 60;
 var COLUMN_SPACING = 400;
@@ -10131,7 +10712,7 @@ function buildCanvasEdges(adjacency) {
   return edges;
 }
 async function runCanvasGenerate(input) {
-  const graphPath = input.graphPath ?? join45(input.vault, ".skillwiki", "graph.json");
+  const graphPath = input.graphPath ?? join46(input.vault, ".skillwiki", "graph.json");
   if (!existsSync19(graphPath)) {
     return {
       exitCode: ExitCode.FILE_NOT_FOUND,
@@ -10143,7 +10724,7 @@ async function runCanvasGenerate(input) {
   }
   let raw;
   try {
-    raw = await readFile28(graphPath, "utf8");
+    raw = await readFile29(graphPath, "utf8");
   } catch (e) {
     return {
       exitCode: ExitCode.FILE_NOT_FOUND,
@@ -10169,9 +10750,9 @@ async function runCanvasGenerate(input) {
   const nodes = buildCanvasNodes(paths);
   const edges = buildCanvasEdges(graph.adjacency);
   const canvas = { nodes, edges };
-  const outPath = join45(input.vault, "vault-graph.canvas");
+  const outPath = join46(input.vault, "vault-graph.canvas");
   try {
-    await writeFile17(outPath, JSON.stringify(canvas, null, 2));
+    await writeFile18(outPath, JSON.stringify(canvas, null, 2));
   } catch (e) {
     return {
       exitCode: ExitCode.WRITE_FAILED,
@@ -10191,8 +10772,8 @@ written: ${outPath}`
 }
 
 // src/commands/query.ts
-import { readFile as readFile29, stat as stat10 } from "fs/promises";
-import { join as join46 } from "path";
+import { readFile as readFile30, stat as stat11 } from "fs/promises";
+import { join as join47 } from "path";
 var W_KEYWORD = 2;
 var W_SOURCE_OVERLAP = 4;
 var W_WIKILINK = 3;
@@ -10313,10 +10894,10 @@ function computeKeywordScore(terms, title, tags, body) {
   return score;
 }
 async function loadOrBuildGraph(vault) {
-  const graphPath = join46(vault, ".skillwiki", "graph.json");
+  const graphPath = join47(vault, ".skillwiki", "graph.json");
   let needsBuild = false;
   try {
-    const fileStat = await stat10(graphPath);
+    const fileStat = await stat11(graphPath);
     const ageHours = (Date.now() - fileStat.mtimeMs) / (1e3 * 60 * 60);
     if (ageHours > 24) needsBuild = true;
   } catch {
@@ -10327,7 +10908,7 @@ async function loadOrBuildGraph(vault) {
     if (buildResult.exitCode !== 0) return null;
   }
   try {
-    const raw = await readFile29(graphPath, "utf8");
+    const raw = await readFile30(graphPath, "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -10336,14 +10917,14 @@ async function loadOrBuildGraph(vault) {
 
 // src/utils/auto-commit.ts
 import { existsSync as existsSync20 } from "fs";
-import { join as join47 } from "path";
+import { join as join48 } from "path";
 async function postCommit(vault, exitCode) {
   if (exitCode !== 0) return;
   const home = process.env.HOME ?? "";
   const dotenv = await parseDotenvFile(configPath(home));
   const autoCommit = process.env.AUTO_COMMIT ?? dotenv["AUTO_COMMIT"];
   if (autoCommit === "false") return;
-  if (!existsSync20(join47(vault, ".git"))) return;
+  if (!existsSync20(join48(vault, ".git"))) return;
   const lastOps = readLastOp(vault);
   if (lastOps.length === 0) return;
   const porcelain = git(vault, ["status", "--porcelain"]);
@@ -10394,7 +10975,7 @@ program.command("validate <file>").description("validate vault page frontmatter
   emit(await runValidate({ file, apply: !!opts.apply, vault }), vault);
 });
 program.command("graph").description("graph subcommands").command("build <vault>").option("--out <path>", "graph output path (default: <vault>/.skillwiki/graph.json)").option("--wiki <name>", "wiki profile name").action(async (vault, opts) => {
-  const out = opts.out ?? join48(vault, ".skillwiki", "graph.json");
+  const out = opts.out ?? join49(vault, ".skillwiki", "graph.json");
   emit(await runGraphBuild({ vault, out }), vault);
 });
 var canvasCmd = program.command("canvas").description("manage Obsidian canvas files");
@@ -10763,6 +11344,45 @@ program.command("session-brief [vault]").description("render or refresh the boun
     env: { SKILLWIKI_PROJECT: process.env.SKILLWIKI_PROJECT }
   }), v.vault, { postCommit: !!opts.write });
 });
+var memoryCmd = program.command("memory").description("inspect derived agent memory caches");
+memoryCmd.command("topics [vault]").description("list topic-oriented memory from the optional derived cache").option("--project <slug>", "filter topics by project slug").option("--limit <n>", "maximum topics to return", (s) => parseInt(s, 10), 10).option("--wiki <name>", "wiki profile name").action(async (vault, opts) => {
+  const v = await resolveVaultArg(vault, opts.wiki);
+  if (!v.ok) emit({ exitCode: v.exitCode, result: v.payload });
+  else emit(await runMemoryTopics({
+    vault: v.vault,
+    project: opts.project,
+    limit: opts.limit
+  }), v.vault, { postCommit: false });
+});
+memoryCmd.command("index [vault]").description("build the derived project memory topic cache").requiredOption("--project <slug>", "project slug").option("--wiki <name>", "wiki profile name").action(async (vault, opts) => {
+  const v = await resolveVaultArg(vault, opts.wiki);
+  if (!v.ok) emit({ exitCode: v.exitCode, result: v.payload });
+  else emit(await runMemoryIndex({
+    vault: v.vault,
+    project: opts.project
+  }), v.vault);
+});
+memoryCmd.command("recall [vault]").description("recall bounded source summaries for a memory topic").requiredOption("--project <slug>", "project slug").requiredOption("--topic <slug>", "memory topic slug").option("--limit <n>", "maximum sources to return", (s) => parseInt(s, 10), 10).option("--wiki <name>", "wiki profile name").action(async (vault, opts) => {
+  const v = await resolveVaultArg(vault, opts.wiki);
+  if (!v.ok) emit({ exitCode: v.exitCode, result: v.payload });
+  else emit(await runMemoryRecall({
+    vault: v.vault,
+    project: opts.project,
+    topic: opts.topic,
+    limit: opts.limit
+  }), v.vault, { postCommit: false });
+});
+memoryCmd.command("import [vault]").description("preview or apply local memory imports into raw captures").requiredOption("--from <path>", "source file or directory to scan").requiredOption("--project <slug>", "project slug").option("--dry-run", "preview only; do not write captures", false).option("--apply", "write validated raw captures for ready entries", false).option("--max-bytes <n>", "reject source files above this size", (s) => parseInt(s, 10), 2e5).option("--wiki <name>", "wiki profile name").action(async (vault, opts) => {
+  const v = await resolveVaultArg(vault, opts.wiki);
+  if (!v.ok) emit({ exitCode: v.exitCode, result: v.payload });
+  else emit(await runMemoryImport({
+    vault: v.vault,
+    from: opts.from,
+    project: opts.project,
+    apply: !!opts.apply && !opts.dryRun,
+    maxBytes: opts.maxBytes
+  }), v.vault, { postCommit: !!opts.apply && !opts.dryRun });
+});
 program.command("ingest <source>").description("ingest a source URL or local file into the vault").requiredOption("--vault <path>", "vault root directory").requiredOption("--type <type>", "typed-knowledge type (entity|concept|comparison|query)").requiredOption("--title <title>", "page title").option("--tags <csv>", "comma-separated tags").option("--provenance <provenance>", "provenance (research|project)").option("--dry-run", "preview without writing files", false).action(async (source, opts) => {
   const tags = typeof opts.tags === "string" ? opts.tags.split(",").map((s) => s.trim()).filter((s) => s.length > 0) : [];
   emit(await runIngest({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skillwiki",
-  "version": "0.9.6",
+  "version": "0.9.8",
   "type": "module",
   "bin": {
     "skillwiki": "dist/cli.js"

package/skills/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "skillwiki",
-  "version": "0.9.6",
+  "version": "0.9.8",
   "skills": "./",
   "description": "Project-aware Karpathy-style knowledge base for Claude Code: 18 prompt-only skills (wiki-*, proj-*, using-skillwiki) backed by the deterministic `skillwiki` CLI.",
   "author": {

package/skills/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "skillwiki",
-  "version": "0.9.6",
+  "version": "0.9.8",
   "description": "Project-aware Karpathy-style knowledge base for Codex with 18 prompt-only skills backed by the deterministic skillwiki CLI.",
   "author": {
     "name": "karlorz",

package/skills/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skillwiki/skills",
-  "version": "0.9.6",
+  "version": "0.9.8",
   "private": true,
   "files": [
     "wiki-*",