@hiveai/cli 0.9.5 → 0.9.6

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command44 } from "commander";
+import { Command as Command47 } from "commander";
 
 // src/commands/briefing.ts
 import { existsSync } from "fs";
@@ -197,7 +197,7 @@ async function getHotFiles(root, daysBack, maxHotFiles, filePaths) {
       if (!f) continue;
       counts.set(f, (counts.get(f) ?? 0) + 1);
     }
-    let entries = [...counts.entries()].map(([path41, changes]) => ({ path: path41, changes }));
+    let entries = [...counts.entries()].map(([path45, changes]) => ({ path: path45, changes }));
     const lowerPaths = filePaths.map((p) => p.toLowerCase());
     if (lowerPaths.length > 0) {
       entries = entries.filter((e) => lowerPaths.some((p) => e.path.toLowerCase().includes(p)));
@@ -2297,6 +2297,8 @@ var RUNTIME_README_BODY = `# .ai/.runtime \u2014 disposable local layer
 Not team truth. Use for machine-local session notes or tooling scratch files.
 Official memories belong in .ai/memories/ (versioned in Git).
 Only .gitignore and this README are meant to commit; everything else stays untracked.
+
+Session continuity (local): agents may append \`session-journal.ndjson\` via MCP \`runtime_journal_append\` or \`haive runtime journal append\`.
 `;
 var RUNTIME_GITIGNORE_BODY = `*
 !.gitignore
@@ -2795,7 +2797,11 @@ import {
   serializeMemory as serializeMemory8
 } from "@hiveai/core";
 import { z as z16 } from "zod";
-import { appendUsageEvent, loadConfig as loadConfig2 } from "@hiveai/core";
+import {
+  appendUsageEvent,
+  appendRuntimeJournalEntry,
+  loadConfig as loadConfig2
+} from "@hiveai/core";
 import { mkdir as mkdir52, writeFile as writeFile9, rm } from "fs/promises";
 import { existsSync as existsSync16 } from "fs";
 import path72 from "path";
@@ -2900,7 +2906,11 @@ import {
 } from "@hiveai/core";
 import { z as z29 } from "zod";
 import { existsSync as existsSync27 } from "fs";
-import { findLexicalConflictPairs, loadMemoriesFromDir as loadMemoriesFromDir21 } from "@hiveai/core";
+import {
+  findLexicalConflictPairs,
+  findTopicStatusConflictPairs,
+  loadMemoriesFromDir as loadMemoriesFromDir21
+} from "@hiveai/core";
 import { z as z30 } from "zod";
 import { resolveProjectInfo } from "@hiveai/core";
 import { z as z31 } from "zod";
@@ -2909,9 +2919,13 @@ import { z as z32 } from "zod";
 import { existsSync as existsSync28 } from "fs";
 import { collectTimelineEntries, loadMemoriesFromDir as loadMemoriesFromDir222 } from "@hiveai/core";
 import { z as z33 } from "zod";
+import { appendRuntimeJournalEntry as appendRuntimeJournalEntry2 } from "@hiveai/core";
 import { z as z34 } from "zod";
+import { readRuntimeJournalTail } from "@hiveai/core";
 import { z as z35 } from "zod";
 import { z as z36 } from "zod";
+import { z as z37 } from "zod";
+import { z as z38 } from "zod";
 function createContext(options = {}) {
   const env = options.env ?? process.env;
   const cwd = options.cwd ?? process.cwd();
@@ -3936,6 +3950,14 @@ var SessionTracker = class {
         recapId = result.id;
       } catch {
       }
+      void appendRuntimeJournalEntry(this.ctx.paths, {
+        kind: "session_end",
+        message: recapId ? `auto session close | ${toolSummary} | recap:${recapId}` : `auto session close | ${toolSummary}`,
+        meta: {
+          recap_id: recapId ?? null,
+          total_tool_calls: totalCalls
+        }
+      });
       const ranPostTask = this.events.some(
         (e) => e.tool === "mem_session_end" && !e.summary?.startsWith("Auto-captured")
       );
@@ -5681,12 +5703,16 @@ var MemConflictCandidatesInputSchema = {
   types: z30.array(z30.enum(["decision", "architecture", "convention", "gotcha"])).default(["decision", "architecture"]).describe("Memory types scanned for pairwise lexical overlap"),
   min_jaccard: z30.number().min(0).max(1).default(0.45).describe("Minimum Jaccard token similarity to surface as a candidate pair"),
   max_pairs: z30.number().int().positive().max(100).default(20).describe("Cap pairs returned"),
-  max_scan: z30.number().int().positive().max(2e3).default(500).describe("Maximum memories sampled for O(n\xB2) scan \u2014 excess dropped after chronological sort.")
+  max_scan: z30.number().int().positive().max(2e3).default(500).describe("Maximum memories sampled for O(n\xB2) scan \u2014 excess dropped after chronological sort."),
+  max_topic_pairs: z30.number().int().positive().max(100).default(20).describe(
+    "Cap for extra signal: memories sharing the same topic with validated vs rejected status."
+  )
 };
 async function memConflictCandidates(input, ctx) {
   if (!existsSync27(ctx.paths.memoriesDir)) {
     return {
       pairs: [],
+      topic_status_pairs: [],
       scanned: 0,
       truncated: false,
       notice: "No .ai/memories directory."
@@ -5700,8 +5726,9 @@ async function memConflictCandidates(input, ctx) {
     maxPairs: input.max_pairs,
     maxScan: input.max_scan
   });
-  const notice = pairs.length === 0 ? "No lexical candidate pairs \u2265 threshold \u2014 try lowering min_jaccard or widen since_days/types." : void 0;
-  return { pairs, scanned, truncated, notice };
+  const topicStatusPairs = findTopicStatusConflictPairs(all, input.max_topic_pairs);
+  const notice = pairs.length === 0 && topicStatusPairs.length === 0 ? "No lexical or topic-status candidates \u2014 widen since_days/types or lower min_jaccard." : void 0;
+  return { pairs, topic_status_pairs: topicStatusPairs, scanned, truncated, notice };
 }
 var MemResolveProjectInputSchema = {
   cwd: z31.string().optional().describe("Directory used for root discovery when HAIVE_PROJECT_ROOT is unset.")
@@ -5741,11 +5768,37 @@ async function memTimeline(input, ctx) {
   });
   return { entries, total: entries.length, notice };
 }
+var RuntimeJournalAppendInputSchema = {
+  message: z34.string().min(1).describe("Short line to append to the runtime session journal"),
+  kind: z34.enum(["note", "session_end", "mcp"]).default("note"),
+  tool: z34.string().optional().describe("When kind=mcp, which tool name (optional)")
+};
+async function runtimeJournalAppend(input, ctx) {
+  await appendRuntimeJournalEntry2(ctx.paths, {
+    kind: input.kind,
+    message: input.message,
+    ...input.tool ? { tool: input.tool } : {}
+  });
+  return {
+    ok: true,
+    path_hint: `${ctx.paths.runtimeDir}/session-journal.ndjson`
+  };
+}
+var RuntimeJournalTailInputSchema = {
+  limit: z35.number().int().positive().max(500).default(30).describe("Last N journal entries to return")
+};
+async function runtimeJournalTail(input, ctx) {
+  const entries = await readRuntimeJournalTail(ctx.paths, input.limit);
+  if (entries.length === 0) {
+    return { entries: [], empty: true };
+  }
+  return { entries };
+}
 var BootstrapProjectArgsSchema = {
-  module: z34.string().optional().describe(
+  module: z36.string().optional().describe(
     "Optional module name to scope the analysis to (writes to .ai/modules/<module>/context.md)"
   ),
-  focus: z34.string().optional().describe("Optional area to emphasize (e.g. 'data layer', 'API surface')")
+  focus: z36.string().optional().describe("Optional area to emphasize (e.g. 'data layer', 'API surface')")
 };
 var ROOT_TEMPLATE = `# Project context
 
@@ -5826,8 +5879,8 @@ ${template}\`\`\`
   };
 }
 var PostTaskArgsSchema = {
-  task_summary: z35.string().optional().describe("One sentence describing what you just did"),
-  files_touched: z35.array(z35.string()).optional().describe("Files you created or modified during the task")
+  task_summary: z37.string().optional().describe("One sentence describing what you just did"),
+  files_touched: z37.array(z37.string()).optional().describe("Files you created or modified during the task")
 };
 function postTaskPrompt(args, ctx) {
   const taskLine = args.task_summary ? `
@@ -5910,10 +5963,10 @@ When done, respond with a brief summary: "Saved N memories: [list of IDs]. Sessi
   };
 }
 var ImportDocsArgsSchema = {
-  content: z36.string().describe("The documentation content to analyze and import as memories (Markdown, README, ADR, etc.)"),
-  source: z36.string().optional().describe("Origin of the content (file path, URL, or document title) \u2014 used to anchor memories"),
-  scope: z36.enum(["personal", "team"]).default("team").describe("Scope to assign to created memories"),
-  dry_run: z36.boolean().default(false).describe("If true, describe what would be saved without actually calling mem_save")
+  content: z38.string().describe("The documentation content to analyze and import as memories (Markdown, README, ADR, etc.)"),
+  source: z38.string().optional().describe("Origin of the content (file path, URL, or document title) \u2014 used to anchor memories"),
+  scope: z38.enum(["personal", "team"]).default("team").describe("Scope to assign to created memories"),
+  dry_run: z38.boolean().default(false).describe("If true, describe what would be saved without actually calling mem_save")
 };
 function importDocsPrompt(args, ctx) {
   const sourceLine = args.source ? `
@@ -5976,7 +6029,7 @@ When done, respond with: "Imported N memories: [list of IDs]" or "Nothing action
   };
 }
 var SERVER_NAME = "haive";
-var SERVER_VERSION = "0.9.5";
+var SERVER_VERSION = "0.9.6";
 function jsonResult(data) {
   return {
     content: [
@@ -6659,14 +6712,17 @@ function createHaiveServer(options = {}) {
   server.tool(
     "mem_conflict_candidates",
     [
-      "Bulk lexical scan for decision/architecture-like pairs that look similar (Jaccard on tokens).",
+      "Bulk scan for conflict CANDIDATES (not proof):",
+      "",
+      "  1. Lexical similarity (Jaccard) on decision/architecture-like pairs",
+      "  2. Same frontmatter.topic with validated vs rejected \u2014 quick human-review signal",
       "",
-      "Advisory only \u2014 follow with mem_conflicts_with on specific ids for real contradiction checks.",
+      "Advisory only \u2014 follow with mem_conflicts_with on specific ids.",
       "",
       "PARAMETERS:",
-      "  since_days, types, min_jaccard, max_pairs, max_scan",
+      "  since_days, types, min_jaccard, max_pairs, max_scan, max_topic_pairs",
       "",
-      "RETURNS: { pairs: [{ id_a, id_b, jaccard }], scanned, truncated, notice? }"
+      "RETURNS: { pairs, topic_status_pairs, scanned, truncated, notice? }"
     ].join("\n"),
     MemConflictCandidatesInputSchema,
     async (input) => {
@@ -6674,6 +6730,32 @@ function createHaiveServer(options = {}) {
       return jsonResult(await memConflictCandidates(input, context));
     }
   );
+  server.tool(
+    "runtime_journal_append",
+    [
+      "Append one line to `.ai/.runtime/session-journal.ndjson` \u2014 machine-local session continuity.",
+      "",
+      "Does NOT replace team memories; complements mem_session_end recaps for local traces.",
+      "",
+      "PARAMETERS: message, kind (note|session_end|mcp), optional tool",
+      "",
+      "RETURNS: { ok, path_hint }"
+    ].join("\n"),
+    RuntimeJournalAppendInputSchema,
+    async (input) => jsonResult(await runtimeJournalAppend(input, context))
+  );
+  server.tool(
+    "runtime_journal_tail",
+    [
+      "Read the last N entries from the runtime session journal (parsed JSON lines).",
+      "",
+      "PARAMETERS: limit (default 30, max 500)",
+      "",
+      "RETURNS: { entries: [...], empty?: true }"
+    ].join("\n"),
+    RuntimeJournalTailInputSchema,
+    async (input) => jsonResult(await runtimeJournalTail(input, context))
+  );
   server.tool(
     "pre_commit_check",
     [
@@ -10284,7 +10366,7 @@ function registerDoctor(program2) {
         timeout: 3e3,
         stdio: ["ignore", "pipe", "ignore"]
       }).trim();
-      const cliVersion = "0.9.5";
+      const cliVersion = "0.9.6";
       if (legacyRaw && legacyRaw !== cliVersion) {
         findings.push({
           severity: "warn",
@@ -10748,12 +10830,151 @@ function registerResolveProject(program2) {
   });
 }
 
+// src/commands/runtime-journal.ts
+import { existsSync as existsSync64 } from "fs";
+import path41 from "path";
+import "commander";
+import {
+  appendRuntimeJournalEntry as appendRuntimeJournalEntry3,
+  findProjectRoot as findProjectRoot43,
+  readRuntimeJournalTail as readRuntimeJournalTail2,
+  resolveHaivePaths as resolveHaivePaths40
+} from "@hiveai/core";
+function registerRuntime(program2) {
+  const runtime = program2.command("runtime").description(
+    "Local-only .ai/.runtime helpers (not versioned team memory). See session-journal.ndjson."
+  );
+  const journal = runtime.command("journal").description("Append or read the machine-local session journal (NDJSON)");
+  journal.command("append").description("Append one JSON line to .ai/.runtime/session-journal.ndjson").argument("<message>", "short text to log").option("-k, --kind <kind>", "note | session_end | mcp", "note").option("-d, --dir <dir>", "project root", process.cwd()).action(async (message, opts) => {
+    const root = path41.resolve(opts.dir ?? process.cwd());
+    const paths = resolveHaivePaths40(findProjectRoot43(root));
+    const raw = opts.kind ?? "note";
+    const kind = ["note", "session_end", "mcp"].includes(raw) ? raw : "note";
+    await appendRuntimeJournalEntry3(paths, { kind, message });
+    ui.success(`Appended to ${path41.relative(root, paths.runtimeDir)}/session-journal.ndjson`);
+  });
+  journal.command("tail").description("Print the last N entries from the runtime session journal as JSON").option("-n, --limit <n>", "number of lines", "30").option("-d, --dir <dir>", "project root", process.cwd()).action(async (opts) => {
+    const root = path41.resolve(opts.dir ?? process.cwd());
+    const paths = resolveHaivePaths40(findProjectRoot43(root));
+    const limit = Math.min(500, Math.max(1, parseInt(opts.limit, 10) || 30));
+    if (!existsSync64(paths.haiveDir)) {
+      ui.error("No .ai/ \u2014 run `haive init` first.");
+      process.exitCode = 1;
+      return;
+    }
+    const entries = await readRuntimeJournalTail2(paths, limit);
+    if (entries.length === 0) {
+      ui.info("Journal empty or missing.");
+      return;
+    }
+    console.log(JSON.stringify({ entries, count: entries.length }, null, 2));
+  });
+}
+
+// src/commands/memory-timeline.ts
+import { existsSync as existsSync65 } from "fs";
+import path43 from "path";
+import "commander";
+import {
+  collectTimelineEntries as collectTimelineEntries2,
+  findProjectRoot as findProjectRoot44,
+  resolveHaivePaths as resolveHaivePaths41
+} from "@hiveai/core";
+function registerMemoryTimeline(memory2) {
+  memory2.command("timeline").description(
+    "List related memories chronologically (topic, related_ids, anchors) \u2014 same logic as MCP mem_timeline."
+  ).option("--id <id>", "seed memory id").option("--topic <key>", "filter by frontmatter.topic (use without --id for topic-only)").option("-n, --limit <n>", "max entries", "30").option("-d, --dir <dir>", "project root", process.cwd()).action(async (opts) => {
+    if (!opts.id && !opts.topic) {
+      ui.error("Provide --id and/or --topic.");
+      process.exitCode = 1;
+      return;
+    }
+    const root = path43.resolve(opts.dir ?? process.cwd());
+    const paths = resolveHaivePaths41(findProjectRoot44(root));
+    if (!existsSync65(paths.memoriesDir)) {
+      ui.error("No memories \u2014 run `haive init`.");
+      process.exitCode = 1;
+      return;
+    }
+    const limit = Math.min(100, Math.max(1, parseInt(opts.limit, 10) || 30));
+    const all = await loadMemoriesFromDir25(paths.memoriesDir);
+    const { entries, notice } = collectTimelineEntries2(all, {
+      memoryId: opts.id,
+      topic: opts.topic,
+      limit
+    });
+    if (notice) ui.warn(notice);
+    console.log(JSON.stringify({ entries, total: entries.length }, null, 2));
+  });
+}
+
+// src/commands/memory-conflict-candidates.ts
+import { existsSync as existsSync66 } from "fs";
+import path44 from "path";
+import "commander";
+import {
+  findLexicalConflictPairs as findLexicalConflictPairs2,
+  findTopicStatusConflictPairs as findTopicStatusConflictPairs2,
+  findProjectRoot as findProjectRoot45,
+  resolveHaivePaths as resolveHaivePaths42
+} from "@hiveai/core";
+function parseTypes(csv) {
+  const allowed = ["decision", "architecture", "convention", "gotcha"];
+  const parts = csv.split(",").map((s) => s.trim().toLowerCase());
+  const out = parts.filter((p) => allowed.includes(p));
+  return out.length ? out : ["decision", "architecture"];
+}
+function registerMemoryConflictCandidates(memory2) {
+  memory2.command("conflict-candidates").description(
+    "Heuristic conflict candidates (lexical Jaccard + same-topic validated/rejected pairs) \u2014 aligns with MCP mem_conflict_candidates."
+  ).option("-d, --dir <dir>", "project root", process.cwd()).option("--since-days <n>", "only memories created within N days (lexical scan)", "365").option(
+    "--types <csv>",
+    "decision,architecture,convention,gotcha (lexical scan)",
+    "decision,architecture"
+  ).option("--min-jaccard <x>", "minimum Jaccard for lexical pairs", "0.45").option("--max-pairs <n>", "cap lexical pairs", "20").option("--max-scan <n>", "max memories scanned (lexical)", "500").option("--max-topic-pairs <n>", "cap topic/status pairs", "20").action(async (opts) => {
+    const root = path44.resolve(opts.dir ?? process.cwd());
+    const paths = resolveHaivePaths42(findProjectRoot45(root));
+    if (!existsSync66(paths.memoriesDir)) {
+      ui.error("No memories \u2014 run `haive init`.");
+      process.exitCode = 1;
+      return;
+    }
+    const sinceDays = Math.max(1, parseInt(opts.sinceDays, 10) || 365);
+    const minJaccard = parseFloat(opts.minJaccard) || 0.45;
+    const maxPairs = Math.min(100, Math.max(1, parseInt(opts.maxPairs, 10) || 20));
+    const maxScan = Math.min(2e3, Math.max(1, parseInt(opts.maxScan, 10) || 500));
+    const maxTopicPairs = Math.min(100, Math.max(1, parseInt(opts.maxTopicPairs, 10) || 20));
+    const all = await loadMemoriesFromDir25(paths.memoriesDir);
+    const lexical = findLexicalConflictPairs2(all, {
+      sinceDays,
+      types: parseTypes(opts.types),
+      minJaccard,
+      maxPairs,
+      maxScan
+    });
+    const topicStatusPairs = findTopicStatusConflictPairs2(all, maxTopicPairs);
+    console.log(
+      JSON.stringify(
+        {
+          pairs: lexical.pairs,
+          topic_status_pairs: topicStatusPairs,
+          scanned: lexical.scanned,
+          truncated: lexical.truncated
+        },
+        null,
+        2
+      )
+    );
+  });
+}
+
 // src/index.ts
-var program = new Command44();
-program.name("haive").description("hAIve \u2014 team-first persistent memory layer for AI coding agents").version("0.9.5");
+var program = new Command47();
+program.name("haive").description("hAIve \u2014 team-first persistent memory layer for AI coding agents").version("0.9.6");
 registerInit(program);
 registerWelcome(program);
 registerResolveProject(program);
+registerRuntime(program);
 registerMcp(program);
 registerBriefing(program);
 registerTui(program);
@@ -10785,6 +11006,8 @@ registerMemoryImportChangelog(memory);
 registerMemoryDigest(memory);
 registerMemorySuggest(memory);
 registerMemorySuggestTopic(memory);
+registerMemoryTimeline(memory);
+registerMemoryConflictCandidates(memory);
 registerMemoryArchive(memory);
 registerMemoryLint(memory);
 var session = program.command("session").description("Manage session lifecycle");