clawvault 1.11.2 → 2.0.0

package/dist/chunk-PAYUH64O.js

@@ -0,0 +1,284 @@
+// src/commands/compat.ts
+import * as fs from "fs";
+import * as path from "path";
+import matter from "gray-matter";
+import { spawnSync } from "child_process";
+import { fileURLToPath } from "url";
+var REQUIRED_HOOK_EVENTS = ["gateway:startup", "command:new", "session:start"];
+var REQUIRED_HOOK_BIN = "clawvault";
+function readOptionalFile(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) return null;
+    return fs.readFileSync(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function resolveProjectFile(relativePath, baseDir) {
+  if (baseDir) {
+    return path.resolve(baseDir, relativePath);
+  }
+  const fromCwd = path.resolve(process.cwd(), relativePath);
+  if (fs.existsSync(fromCwd)) {
+    return fromCwd;
+  }
+  return fileURLToPath(new URL(`../../${relativePath}`, import.meta.url));
+}
+function checkOpenClawCli() {
+  const result = spawnSync("openclaw", ["--version"], { stdio: "ignore" });
+  if (result.error) {
+    return {
+      label: "openclaw CLI available",
+      status: "warn",
+      detail: "openclaw binary not found",
+      hint: "Install OpenClaw CLI to enable hook runtime validation."
+    };
+  }
+  if (typeof result.status === "number" && result.status !== 0) {
+    return {
+      label: "openclaw CLI available",
+      status: "warn",
+      detail: `openclaw --version exited with code ${result.status}`,
+      hint: "Ensure OpenClaw CLI is installed and runnable in PATH."
+    };
+  }
+  if (typeof result.signal === "string" && result.signal.length > 0) {
+    return {
+      label: "openclaw CLI available",
+      status: "warn",
+      detail: `openclaw --version terminated by signal ${result.signal}`,
+      hint: "Ensure OpenClaw CLI can execute normally in PATH."
+    };
+  }
+  return { label: "openclaw CLI available", status: "ok" };
+}
+function checkPackageHookRegistration(options) {
+  const packageRaw = readOptionalFile(resolveProjectFile("package.json", options.baseDir));
+  if (!packageRaw) {
+    return {
+      label: "package hook registration",
+      status: "error",
+      detail: "package.json not found"
+    };
+  }
+  try {
+    const parsed = JSON.parse(packageRaw);
+    const registeredHooks = parsed.openclaw?.hooks ?? [];
+    if (registeredHooks.includes("./hooks/clawvault")) {
+      return {
+        label: "package hook registration",
+        status: "ok",
+        detail: "./hooks/clawvault"
+      };
+    }
+    return {
+      label: "package hook registration",
+      status: "error",
+      detail: "Missing ./hooks/clawvault in package openclaw.hooks"
+    };
+  } catch (err) {
+    return {
+      label: "package hook registration",
+      status: "error",
+      detail: err?.message || "Unable to parse package.json"
+    };
+  }
+}
+function checkHookManifest(options) {
+  const hookRaw = readOptionalFile(resolveProjectFile("hooks/clawvault/HOOK.md", options.baseDir));
+  if (!hookRaw) {
+    return {
+      label: "hook manifest",
+      status: "error",
+      detail: "HOOK.md not found"
+    };
+  }
+  try {
+    const parsed = matter(hookRaw);
+    const openclaw = parsed.data?.metadata?.openclaw;
+    const events = Array.isArray(openclaw?.events) ? openclaw?.events ?? [] : [];
+    const missingEvents = REQUIRED_HOOK_EVENTS.filter((event) => !events.includes(event));
+    if (missingEvents.length === 0) {
+      return {
+        label: "hook manifest events",
+        status: "ok",
+        detail: events.join(", ")
+      };
+    }
+    return {
+      label: "hook manifest events",
+      status: "error",
+      detail: `Missing events: ${missingEvents.join(", ")}`
+    };
+  } catch (err) {
+    return {
+      label: "hook manifest events",
+      status: "error",
+      detail: err?.message || "Unable to parse HOOK.md frontmatter"
+    };
+  }
+}
+function checkHookManifestRequirements(options) {
+  const hookRaw = readOptionalFile(resolveProjectFile("hooks/clawvault/HOOK.md", options.baseDir));
+  if (!hookRaw) {
+    return {
+      label: "hook manifest requirements",
+      status: "error",
+      detail: "HOOK.md not found"
+    };
+  }
+  try {
+    const parsed = matter(hookRaw);
+    const requiresBins = parsed.data?.metadata?.openclaw?.requires?.bins;
+    const bins = Array.isArray(requiresBins) ? requiresBins : [];
+    if (bins.includes(REQUIRED_HOOK_BIN)) {
+      return {
+        label: "hook manifest requirements",
+        status: "ok",
+        detail: `bins: ${bins.join(", ")}`
+      };
+    }
+    return {
+      label: "hook manifest requirements",
+      status: "warn",
+      detail: `Missing required hook bin "${REQUIRED_HOOK_BIN}"`,
+      hint: 'Add metadata.openclaw.requires.bins: ["clawvault"] to hooks/clawvault/HOOK.md.'
+    };
+  } catch (err) {
+    return {
+      label: "hook manifest requirements",
+      status: "error",
+      detail: err?.message || "Unable to parse HOOK.md frontmatter"
+    };
+  }
+}
+function checkHookHandlerSafety(options) {
+  const handlerRaw = readOptionalFile(resolveProjectFile("hooks/clawvault/handler.js", options.baseDir));
+  if (!handlerRaw) {
+    return {
+      label: "hook handler script",
+      status: "error",
+      detail: "handler.js not found"
+    };
+  }
+  const usesExecFileSync = handlerRaw.includes("execFileSync");
+  const usesExecSync = /\bexecSync\b/.test(handlerRaw);
+  const enablesShell = /\bshell\s*:\s*true\b/.test(handlerRaw);
+  const delegatesAutoProfile = /['"]--profile['"]\s*,\s*['"]auto['"]/.test(handlerRaw);
+  const violations = [];
+  if (!usesExecFileSync || usesExecSync) {
+    violations.push("execFileSync-only execution path");
+  }
+  if (enablesShell) {
+    violations.push("shell:false execution option");
+  }
+  if (!delegatesAutoProfile) {
+    violations.push("shared context profile delegation (--profile auto)");
+  }
+  if (violations.length > 0) {
+    return {
+      label: "hook handler safety",
+      status: "warn",
+      detail: `Missing conventions: ${violations.join(", ")}`,
+      hint: "Use execFileSync (no shell), avoid execSync, and delegate profile inference via --profile auto."
+    };
+  }
+  return { label: "hook handler safety", status: "ok" };
+}
+function checkSkillMetadata(options) {
+  const skillRaw = readOptionalFile(resolveProjectFile("SKILL.md", options.baseDir));
+  if (!skillRaw) {
+    return {
+      label: "skill metadata",
+      status: "warn",
+      detail: "SKILL.md not found",
+      hint: "Ensure SKILL.md is present for OpenClaw skill distribution."
+    };
+  }
+  let hasOpenClawMetadata = false;
+  let parseError;
+  try {
+    const parsed = matter(skillRaw);
+    const frontmatter = parsed.data ?? {};
+    const metadata = frontmatter.metadata && typeof frontmatter.metadata === "object" && !Array.isArray(frontmatter.metadata) ? frontmatter.metadata : void 0;
+    hasOpenClawMetadata = Boolean(
+      metadata && typeof metadata.openclaw === "object" && metadata.openclaw !== null || typeof frontmatter.openclaw === "object" && frontmatter.openclaw !== null
+    );
+  } catch {
+    parseError = "Unable to parse SKILL.md frontmatter";
+    hasOpenClawMetadata = false;
+  }
+  if (!hasOpenClawMetadata) {
+    hasOpenClawMetadata = /"openclaw"\s*:/.test(skillRaw);
+  }
+  if (!hasOpenClawMetadata) {
+    const detail = parseError ? `${parseError} (or missing metadata.openclaw)` : "Missing metadata.openclaw in SKILL.md";
+    return {
+      label: "skill metadata",
+      status: "warn",
+      detail,
+      hint: "Add metadata.openclaw to SKILL.md frontmatter for OpenClaw compatibility."
+    };
+  }
+  return { label: "skill metadata", status: "ok" };
+}
+function checkOpenClawCompatibility(options = {}) {
+  const checks = [
+    checkOpenClawCli(),
+    checkPackageHookRegistration(options),
+    checkHookManifest(options),
+    checkHookManifestRequirements(options),
+    checkHookHandlerSafety(options),
+    checkSkillMetadata(options)
+  ];
+  const warnings = checks.filter((check) => check.status === "warn").length;
+  const errors = checks.filter((check) => check.status === "error").length;
+  return {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    checks,
+    warnings,
+    errors
+  };
+}
+function formatCompatibilityReport(report) {
+  const lines = [];
+  lines.push("OpenClaw Compatibility Report");
+  lines.push("-".repeat(34));
+  lines.push(`Generated: ${report.generatedAt}`);
+  lines.push("");
+  for (const check of report.checks) {
+    const prefix = check.status === "ok" ? "\u2713" : check.status === "warn" ? "\u26A0" : "\u2717";
+    lines.push(`${prefix} ${check.label}${check.detail ? ` \u2014 ${check.detail}` : ""}`);
+    if (check.hint) {
+      lines.push(`  ${check.hint}`);
+    }
+  }
+  lines.push("");
+  lines.push(`Warnings: ${report.warnings}`);
+  lines.push(`Errors: ${report.errors}`);
+  return lines.join("\n");
+}
+function compatibilityExitCode(report, options = {}) {
+  if (report.errors > 0) {
+    return 1;
+  }
+  if (options.strict && report.warnings > 0) {
+    return 1;
+  }
+  return 0;
+}
+async function compatCommand(options = {}) {
+  const report = checkOpenClawCompatibility({ baseDir: options.baseDir });
+  if (options.json) {
+    console.log(JSON.stringify(report, null, 2));
+  } else {
+    console.log(formatCompatibilityReport(report));
+  }
+  return report;
+}
+
+export {
+  checkOpenClawCompatibility,
+  compatibilityExitCode,
+  compatCommand
+};

package/dist/{chunk-3HFB7EMU.js → chunk-QFBKWDYR.js}

@@ -9,6 +9,9 @@ import {
   qmdEmbed,
   qmdUpdate
 } from "./chunk-MIIXBNO3.js";
+import {
+  buildOrUpdateMemoryGraphIndex
+} from "./chunk-O5V7SD5C.js";
 
 // src/lib/vault.ts
 import * as fs from "fs";
@@ -72,6 +75,7 @@ var ClawVault = class {
       qmdRoot: this.getQmdRoot()
     };
     fs.writeFileSync(configPath, JSON.stringify(meta, null, 2));
+    await this.syncMemoryGraphIndex({ forceFull: true });
     this.initialized = true;
   }
   /**
@@ -116,6 +120,7 @@ var ClawVault = class {
       }
     }
     await this.saveIndex();
+    await this.syncMemoryGraphIndex();
     return this.search.size;
   }
   /**
@@ -180,6 +185,7 @@ var ClawVault = class {
     if (doc) {
       this.search.addDocument(doc);
       await this.saveIndex();
+      await this.syncMemoryGraphIndex();
     }
     if (triggerUpdate || triggerEmbed) {
       qmdUpdate(this.getQmdCollection());
@@ -622,6 +628,12 @@ var ClawVault = class {
       }
     }
   }
+  async syncMemoryGraphIndex(options = {}) {
+    try {
+      await buildOrUpdateMemoryGraphIndex(this.config.path, options);
+    } catch {
+    }
+  }
   generateReadme() {
     return `# ${this.config.name} \u{1F418}
 

package/dist/{chunk-UBRYOIII.js → chunk-TBVI4N53.js}

@@ -1,6 +1,9 @@
 import {
   ClawVault
-} from "./chunk-3HFB7EMU.js";
+} from "./chunk-QFBKWDYR.js";
+import {
+  getMemoryGraph
+} from "./chunk-O5V7SD5C.js";
 
 // src/commands/context.ts
 import * as path2 from "path";
@@ -86,6 +89,34 @@ function fitWithinBudget(items, budget) {
   return fitted;
 }
 
+// src/lib/context-profile.ts
+var INCIDENT_PROMPT_RE = /\b(outage|incident|sev[1-4]|p[0-3]|broken|failure|urgent|rollback|hotfix|degraded)\b/i;
+var PLANNING_PROMPT_RE = /\b(plan|planning|design|architecture|roadmap|proposal|spec|migrate|migration|approach)\b/i;
+var HANDOFF_PROMPT_RE = /\b(resume|continue|handoff|pick up|where (did|was) i|last session)\b/i;
+function inferContextProfile(task) {
+  const normalizedTask = task.trim();
+  if (!normalizedTask) {
+    return "default";
+  }
+  if (INCIDENT_PROMPT_RE.test(normalizedTask)) return "incident";
+  if (HANDOFF_PROMPT_RE.test(normalizedTask)) return "handoff";
+  if (PLANNING_PROMPT_RE.test(normalizedTask)) return "planning";
+  return "default";
+}
+function normalizeContextProfileInput(profile) {
+  if (profile === "planning" || profile === "incident" || profile === "handoff" || profile === "auto") {
+    return profile;
+  }
+  return "default";
+}
+function resolveContextProfile(profile, task) {
+  const normalized = normalizeContextProfileInput(profile);
+  if (normalized === "auto") {
+    return inferContextProfile(task);
+  }
+  return normalized;
+}
+
 // src/commands/context.ts
 var DEFAULT_LIMIT = 5;
 var MAX_SNIPPET_LENGTH = 320;
@@ -157,6 +188,24 @@ function formatContextMarkdown(task, entries) {
   }
   return output.trimEnd();
 }
+var PROFILE_ORDERING = {
+  default: {
+    order: ["red", "daily", "search", "graph", "yellow", "green"],
+    caps: {}
+  },
+  planning: {
+    order: ["search", "graph", "red", "yellow", "daily", "green"],
+    caps: { observation: 12, graph: 12 }
+  },
+  incident: {
+    order: ["red", "search", "yellow", "daily", "graph", "green"],
+    caps: { observation: 20, graph: 8 }
+  },
+  handoff: {
+    order: ["daily", "red", "yellow", "search", "graph", "green"],
+    caps: { "daily-note": 2, observation: 15 }
+  }
+};
 function extractKeywords(text) {
   const raw = text.toLowerCase().match(/[a-z0-9]+/g) ?? [];
   const seen = /* @__PURE__ */ new Set();
@@ -257,8 +306,7 @@ function getTargetDailyDates(now = /* @__PURE__ */ new Date()) {
   const yesterday = yesterdayDate.toISOString().slice(0, 10);
   return [today, yesterday];
 }
-async function buildDailyContextItems(vault) {
-  const allDocuments = await vault.list();
+function buildDailyContextItems(vaultPath, allDocuments) {
   const targetDates = getTargetDailyDates();
   const targetDateSet = new Set(targetDates);
   const byDate = /* @__PURE__ */ new Map();
@@ -278,7 +326,7 @@ async function buildDailyContextItems(vault) {
     if (!document) {
       continue;
     }
-    const relativePath = path2.relative(vault.getPath(), document.path).split(path2.sep).join("/");
+    const relativePath = path2.relative(vaultPath, document.path).split(path2.sep).join("/");
     const snippet = estimateSnippet(document.content);
     items.push({
       priority: 2,
@@ -290,7 +338,9 @@ async function buildDailyContextItems(vault) {
         snippet,
         modified: document.modified.toISOString(),
         age: formatRelativeAge(document.modified),
-        source: "daily-note"
+        source: "daily-note",
+        signals: ["daily_recency"],
+        rationale: "Pinned daily note context (today/yesterday)."
       }
     });
   }
@@ -300,7 +350,7 @@ function buildObservationContextItems(vaultPath, queryKeywords) {
   const observationMarkdown = readObservations(vaultPath, OBSERVATION_LOOKBACK_DAYS);
   const parsed = parseObservationLines(observationMarkdown);
   const items = [];
-  for (const observation of parsed) {
+  for (const [index, observation] of parsed.entries()) {
     const priority = observationPriorityToRank(observation.priority);
     const modifiedDate = asDate(observation.date, /* @__PURE__ */ new Date());
     const date = observation.date || modifiedDate.toISOString().slice(0, 10);
@@ -308,14 +358,16 @@ function buildObservationContextItems(vaultPath, queryKeywords) {
     items.push({
       priority,
       entry: {
-        title: `${observation.priority} observation (${date})`,
+        title: `${observation.priority} observation (${date}) #${index + 1}`,
         path: `observations/${date}.md`,
         category: "observations",
         score: computeKeywordOverlapScore(queryKeywords, observation.content),
         snippet,
         modified: modifiedDate.toISOString(),
         age: formatRelativeAge(modifiedDate),
-        source: "observation"
+        source: "observation",
+        signals: ["observation_priority", "keyword_overlap"],
+        rationale: `Observation priority ${observation.priority} matched task keywords.`
       }
     });
   }
@@ -332,7 +384,9 @@ function buildSearchContextItems(vault, results) {
       snippet: normalizeSnippet(result),
       modified: result.document.modified.toISOString(),
       age: formatRelativeAge(result.document.modified),
-      source: "search"
+      source: "search",
+      signals: ["semantic_search"],
+      rationale: "Selected by semantic retrieval."
     };
     return {
       priority: 3,
@@ -340,6 +394,109 @@ function buildSearchContextItems(vault, results) {
     };
   });
 }
+function toNoteNodeId(vaultPath, absolutePath) {
+  const relativePath = path2.relative(vaultPath, absolutePath).split(path2.sep).join("/");
+  const noteKey = relativePath.toLowerCase().endsWith(".md") ? relativePath.slice(0, -3) : relativePath;
+  return `note:${noteKey}`;
+}
+function buildGraphAdjacency(edges) {
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    const sourceBucket = adjacency.get(edge.source) ?? [];
+    sourceBucket.push(edge);
+    adjacency.set(edge.source, sourceBucket);
+    const targetBucket = adjacency.get(edge.target) ?? [];
+    targetBucket.push(edge);
+    adjacency.set(edge.target, targetBucket);
+  }
+  return adjacency;
+}
+function edgeWeight(edge) {
+  if (edge.type === "frontmatter_relation") return 0.95;
+  if (edge.type === "wiki_link") return 0.8;
+  return 0.6;
+}
+function buildGraphContextItems(params) {
+  const { graph, vaultPath, documents, searchItems, limit } = params;
+  if (searchItems.length === 0 || graph.nodes.length === 0 || graph.edges.length === 0) {
+    return [];
+  }
+  const graphNodeById = new Map(graph.nodes.map((node) => [node.id, node]));
+  const adjacency = buildGraphAdjacency(graph.edges);
+  const docByNodeId = /* @__PURE__ */ new Map();
+  for (const document of documents) {
+    docByNodeId.set(toNoteNodeId(vaultPath, document.path), document);
+  }
+  const anchors = searchItems.map((item) => ({
+    item,
+    nodeId: toNoteNodeId(vaultPath, path2.join(vaultPath, item.entry.path))
+  })).filter((anchor) => graphNodeById.has(anchor.nodeId));
+  const candidates = /* @__PURE__ */ new Map();
+  for (const anchor of anchors) {
+    const connectedEdges = adjacency.get(anchor.nodeId) ?? [];
+    for (const edge of connectedEdges) {
+      const neighborId = edge.source === anchor.nodeId ? edge.target : edge.source;
+      if (neighborId === anchor.nodeId) continue;
+      const neighborNode = graphNodeById.get(neighborId);
+      if (!neighborNode || neighborNode.type === "tag") continue;
+      const neighborDoc = docByNodeId.get(neighborId);
+      const neighborPath = neighborDoc ? path2.relative(vaultPath, neighborDoc.path).split(path2.sep).join("/") : neighborNode.path ?? neighborNode.id;
+      const neighborTitle = neighborDoc?.title ?? neighborNode.title;
+      const modifiedAt = neighborDoc?.modified ?? (neighborNode.modifiedAt ? new Date(neighborNode.modifiedAt) : /* @__PURE__ */ new Date(0));
+      const snippet = neighborDoc?.content ? estimateSnippet(neighborDoc.content) : `Connected via ${edge.type}${edge.label ? ` (${edge.label})` : ""}.`;
+      const score = Math.max(0.05, Math.min(1, anchor.item.entry.score * edgeWeight(edge)));
+      const key = `${neighborId}|${edge.type}|${edge.label ?? ""}`;
+      const existing = candidates.get(key);
+      const candidate = {
+        priority: 3,
+        entry: {
+          title: neighborTitle,
+          path: neighborPath,
+          category: neighborDoc?.category ?? neighborNode.category,
+          score,
+          snippet,
+          modified: modifiedAt.toISOString(),
+          age: formatRelativeAge(modifiedAt),
+          source: "graph",
+          signals: ["graph_neighbor", `edge:${edge.type}`],
+          rationale: `Connected to "${anchor.item.entry.title}" via ${edge.type}${edge.label ? ` (${edge.label})` : ""}.`
+        }
+      };
+      if (!existing || existing.entry.score < candidate.entry.score) {
+        candidates.set(key, candidate);
+      }
+    }
+  }
+  return [...candidates.values()].sort((left, right) => right.entry.score - left.entry.score).slice(0, Math.max(limit, 1));
+}
+function dedupeContextItems(items) {
+  const deduped = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const key = `${item.entry.path}|${item.entry.source}|${item.entry.title}`;
+    const existing = deduped.get(key);
+    if (!existing || existing.entry.score < item.entry.score) {
+      deduped.set(key, item);
+    }
+  }
+  return [...deduped.values()];
+}
+function applySourceCaps(items, caps) {
+  const counts = {};
+  const capped = [];
+  for (const item of items) {
+    const source = item.entry.source;
+    const limit = caps[source];
+    if (limit !== void 0) {
+      const current = counts[source] ?? 0;
+      if (current >= limit) {
+        continue;
+      }
+      counts[source] = current + 1;
+    }
+    capped.push(item);
+  }
+  return capped;
+}
 function renderEntryBlock(entry) {
   return `### ${entry.title} (${entry.source}, score: ${entry.score.toFixed(2)}, ${entry.age})
 ${entry.snippet}
@@ -404,30 +561,50 @@ async function buildContext(task, options) {
   const limit = Math.max(1, options.limit ?? DEFAULT_LIMIT);
   const recent = options.recent ?? true;
   const includeObservations = options.includeObservations ?? true;
+  const profile = resolveContextProfile(options.profile, normalizedTask);
   const queryKeywords = extractKeywords(normalizedTask);
+  const allDocuments = await vault.list();
   const searchResults = await vault.vsearch(normalizedTask, {
     limit,
     temporalBoost: recent
   });
   const searchItems = buildSearchContextItems(vault, searchResults);
-  const dailyItems = await buildDailyContextItems(vault);
+  const dailyItems = buildDailyContextItems(vault.getPath(), allDocuments);
   const observationItems = includeObservations ? buildObservationContextItems(vault.getPath(), queryKeywords) : [];
+  const graph = await getMemoryGraph(vault.getPath());
+  const graphItems = buildGraphContextItems({
+    graph,
+    vaultPath: vault.getPath(),
+    documents: allDocuments,
+    searchItems,
+    limit
+  });
   const byScoreDesc = (left, right) => right.entry.score - left.entry.score;
   const redObservations = observationItems.filter((item) => item.priority === 1).sort(byScoreDesc);
   const yellowObservations = observationItems.filter((item) => item.priority === 4).sort(byScoreDesc);
   const greenObservations = observationItems.filter((item) => item.priority === 5).sort(byScoreDesc);
   const sortedDailyItems = [...dailyItems].sort(byScoreDesc);
   const sortedSearchItems = [...searchItems].sort(byScoreDesc);
-  const ordered = [
-    ...redObservations,
-    ...sortedDailyItems,
-    ...sortedSearchItems,
-    ...yellowObservations,
-    ...greenObservations
-  ];
+  const sortedGraphItems = [...graphItems].sort(byScoreDesc);
+  const grouped = {
+    red: redObservations,
+    daily: sortedDailyItems,
+    search: sortedSearchItems,
+    graph: sortedGraphItems,
+    yellow: yellowObservations,
+    green: greenObservations
+  };
+  const ordering = PROFILE_ORDERING[profile];
+  const ordered = dedupeContextItems(
+    applySourceCaps(
+      ordering.order.flatMap((group) => grouped[group]),
+      ordering.caps
+    )
+  );
   const { context, markdown } = applyTokenBudget(ordered, normalizedTask, options.budget);
   return {
     task: normalizedTask,
+    profile,
     generated: (/* @__PURE__ */ new Date()).toISOString(),
     context,
     markdown
@@ -437,11 +614,19 @@ async function contextCommand(task, options) {
   const result = await buildContext(task, options);
   const format = options.format ?? "markdown";
   if (format === "json") {
+    const context = result.context.map((entry) => ({
+      ...entry,
+      explain: {
+        signals: entry.signals ?? [],
+        rationale: entry.rationale ?? ""
+      }
+    }));
     console.log(JSON.stringify({
       task: result.task,
+      profile: result.profile,
       generated: result.generated,
-      count: result.context.length,
-      context: result.context
+      count: context.length,
+      context
     }, null, 2));
     return;
   }
@@ -455,7 +640,7 @@ function parsePositiveInteger(raw, label) {
   return parsed;
 }
 function registerContextCommand(program) {
-  program.command("context <task>").description("Generate task-relevant context for prompt injection").option("-n, --limit <n>", "Max results", "5").option("--format <format>", "Output format (markdown|json)", "markdown").option("--recent", "Boost recent documents (enabled by default)", true).option("--include-observations", "Include observation memories in output", true).option("--budget <number>", "Optional token budget for assembled context").option("-v, --vault <path>", "Vault path").action(async (task, rawOptions) => {
+  program.command("context <task>").description("Generate task-relevant context for prompt injection").option("-n, --limit <n>", "Max results", "5").option("--format <format>", "Output format (markdown|json)", "markdown").option("--recent", "Boost recent documents (enabled by default)", true).option("--include-observations", "Include observation memories in output", true).option("--budget <number>", "Optional token budget for assembled context").option("--profile <profile>", "Context profile (default|planning|incident|handoff|auto)", "default").option("-v, --vault <path>", "Vault path").action(async (task, rawOptions) => {
     const format = rawOptions.format === "json" ? "json" : "markdown";
     const budget = rawOptions.budget ? parsePositiveInteger(rawOptions.budget, "budget") : void 0;
     const limit = parsePositiveInteger(rawOptions.limit, "limit");
@@ -466,12 +651,16 @@ function registerContextCommand(program) {
       format,
       recent: rawOptions.recent ?? true,
       includeObservations: rawOptions.includeObservations ?? true,
-      budget
+      budget,
+      profile: normalizeContextProfileInput(rawOptions.profile)
     });
   });
 }
 
 export {
+  inferContextProfile,
+  normalizeContextProfileInput,
+  resolveContextProfile,
   formatContextMarkdown,
   buildContext,
   contextCommand,