@remnic/core 9.65.8 → 9.66.1

package/src/standup/access-operations.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+
+import { defineOperation } from "../access-boundary.js";
+import { buildStandup, parseStandupDate } from "./build.js";
+
+defineOperation({
+  name: "standup",
+  description: "Deterministic yesterday/today/blockers standup brief.",
+  fleetWide: true,
+  schema: z.object({ date: z.string().optional() }).strict(),
+  handler: async (input, ctx) => ({
+    result: buildStandup(ctx.service.memoryDir, parseStandupDate(input.date)),
+  }),
+});

package/src/standup/build.test.ts

@@ -0,0 +1,34 @@
+import assert from "node:assert/strict";
+import { mkdtemp, mkdir, writeFile, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import { buildStandup, parseStandupDate, previousDate } from "./build.js";
+
+test("parseStandupDate rejects garbage and defaults to UTC today", () => {
+  assert.equal(parseStandupDate(undefined, new Date("2026-08-18T12:00:00Z")), "2026-08-18");
+  assert.throws(() => parseStandupDate("nope"), /YYYY-MM-DD/);
+  assert.equal(previousDate("2026-08-18"), "2026-08-17");
+});
+
+test("buildStandup is deterministic and marks missing days", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-standup-"));
+  try {
+    await mkdir(path.join(memoryDir, "activity"), { recursive: true });
+    await writeFile(
+      path.join(memoryDir, "activity", "2026-08-18.md"),
+      "---\ndate: 2026-08-18\n---\n# Today\n- shipped standup\n- blocker: waiting on review\n",
+      "utf8",
+    );
+    const a = buildStandup(memoryDir, "2026-08-18");
+    const b = buildStandup(memoryDir, "2026-08-18");
+    assert.equal(a.markdown, b.markdown);
+    assert.equal(a.yesterday, "2026-08-17");
+    assert.match(a.markdown, /blocker: waiting on review/);
+    assert.match(a.activityGrid, /yesterday \| \./);
+    assert.match(a.activityGrid, /today \| x/);
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});

package/src/standup/build.ts

@@ -0,0 +1,115 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+
+import { activityDigestPath, isValidActivityDate } from "../activity/digest.js";
+
+export interface StandupBrief {
+  date: string;
+  yesterday: string;
+  today: string;
+  highlights: string[];
+  blockers: string[];
+  activityGrid: string;
+  markdown: string;
+}
+
+export function parseStandupDate(raw: unknown, now = new Date()): string {
+  if (raw === undefined || raw === null || raw === "") {
+    return now.toISOString().slice(0, 10);
+  }
+  const value = String(raw);
+  if (!isValidActivityDate(value)) {
+    throw new Error(`invalid --date ${value}; expected YYYY-MM-DD`);
+  }
+  return value;
+}
+
+export function previousDate(date: string): string {
+  const ms = Date.parse(`${date}T00:00:00Z`);
+  return new Date(ms - 86_400_000).toISOString().slice(0, 10);
+}
+
+export function buildStandup(memoryDir: string, date: string): StandupBrief {
+  const yesterday = previousDate(date);
+  const todayBody = readOptional(activityDigestPath(memoryDir, date));
+  const yesterdayBody = readOptional(activityDigestPath(memoryDir, yesterday));
+  const highlights = extractHighlights(todayBody);
+  const blockers = extractBlockers(todayBody);
+  const activityGrid = renderGrid(yesterdayBody, todayBody);
+  const markdown = [
+    `# Standup ${date}`,
+    "",
+    `## Yesterday (${yesterday})`,
+    yesterdayBody ? firstLines(yesterdayBody, 8) : "_No activity digest._",
+    "",
+    `## Today (${date})`,
+    todayBody ? firstLines(todayBody, 8) : "_No activity digest._",
+    "",
+    "## Highlights",
+    ...(highlights.length > 0 ? highlights.map((line) => `- ${line}`) : ["- _None._"]),
+    "",
+    "## Blockers",
+    ...(blockers.length > 0 ? blockers.map((line) => `- ${line}`) : ["- _None._"]),
+    "",
+    "## Activity grid",
+    "",
+    activityGrid,
+    "",
+  ].join("\n");
+  return {
+    date,
+    yesterday,
+    today: date,
+    highlights,
+    blockers,
+    activityGrid,
+    markdown,
+  };
+}
+
+function readOptional(filePath: string): string | null {
+  try {
+    return readFileSync(filePath, "utf8");
+  } catch {
+    return null;
+  }
+}
+
+function firstLines(body: string, n: number): string {
+  return body.split("\n").filter((line) => !line.startsWith("---")).slice(0, n).join("\n").trim() || "_Empty digest._";
+}
+
+function extractHighlights(body: string | null): string[] {
+  if (!body) return [];
+  return body
+    .split("\n")
+    .map((line) => line.replace(/^[-*]\s+/, "").trim())
+    .filter((line) => line.length > 0 && !line.startsWith("#") && !line.startsWith("---"))
+    .slice(0, 5);
+}
+
+function extractBlockers(body: string | null): string[] {
+  if (!body) return [];
+  return body
+    .split("\n")
+    .map((line) => line.trim())
+    .filter((line) => /blocker|blocked|stuck|waiting/i.test(line))
+    .slice(0, 5);
+}
+
+function renderGrid(yesterday: string | null, today: string | null): string {
+  const y = yesterday ? "x" : ".";
+  const t = today ? "x" : ".";
+  return ["| day | digest |", "|---|---|", `| yesterday | ${y} |`, `| today | ${t} |`].join("\n");
+}
+
+export function standupHelp(): string {
+  return `Usage: remnic standup [--date YYYY-MM-DD]
+
+Deterministic yesterday/today/blockers brief plus an activity grid.
+`;
+}
+
+export function standupMemoryDirPlaceholder(memoryDir: string): string {
+  return path.resolve(memoryDir);
+}

package/src/standup/http-glue.ts

@@ -0,0 +1,15 @@
+import type { ServerResponse } from "node:http";
+import { getOperation } from "../access-boundary.js";
+import type { EngramAccessService } from "../access-service.js";
+
+export async function respondStandup(
+  date: string | null,
+  res: ServerResponse,
+  respondJson: (res: ServerResponse, status: number, payload: unknown) => void,
+  service: EngramAccessService,
+): Promise<void> {
+  const op = getOperation("standup");
+  if (!op) throw new Error("access-boundary: operation not registered: standup");
+  const output = (await op.run({ ...(date ? { date } : {}) }, { service })) as { result: unknown };
+  respondJson(res, 200, output.result);
+}

package/src/standup/mcp-tools.ts

@@ -0,0 +1,16 @@
+import type { McpTool } from "../access-mcp.js";
+
+export const STANDUP_MCP_TOOLS: McpTool[] = [
+  {
+    name: "engram.standup",
+    description:
+      "Deterministic standup brief: yesterday highlights, today priorities, blockers, and an activity grid. Pass date as YYYY-MM-DD; default is today UTC.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        date: { type: "string", description: "Standup day (YYYY-MM-DD). Defaults to today UTC." },
+      },
+      additionalProperties: false,
+    },
+  },
+];

package/src/support-passport/card-projection.ts

@@ -307,6 +307,7 @@ function parseSupportPassportCardMetadata(
 export function hasLiveSupportPassportCard(memory: Pick<MemoryFile, "frontmatter" | "content">): boolean {
   const metadata = parseSupportPassportCardMetadata(memory);
   if (metadata?.fields.status !== "active" && metadata?.fields.status !== "pending_review") return false;
+  if (metadata.sourceMemoryIds.length === 0) return false;
   return SupportPassportCardSchema.omit({ revision: true }).safeParse({
     ...metadata.fields,
     statement: stripAttributesSuffix(memory.content),

package/src/support-passport/card-service-commit-forwarding.test.ts

@@ -56,6 +56,7 @@ test("rejected-draft recovery forwards the commit notification", async () => {
   assert.ok(replacement);
   const storage = {
     getMemoryById: async (id: string) => (id === "draft-one" ? replaced : null),
+    getMemoryByIdIncludingArchived: async (id: string) => (id === "draft-one" ? replaced : null),
   } as unknown as StorageManager;
   const service = new SupportPassportCardService({
     resolveOwner: async () => ({ principal: PRINCIPAL, namespace: NAMESPACE, storage }),

package/src/support-passport/card-service.test.ts

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { mkdir, mkdtemp, readFile, rename, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import { test } from "node:test";
@@ -1425,6 +1425,80 @@ test("retrying an interrupted pending-draft replacement reuses one approvable dr
   }
 });
 
+test("replacement recovery reads a cold-tier rejected predecessor (#2387)", async () => {
+  const subject = await makeSubject();
+  try {
+    const draft = await subject.service.createManualDraft({
+      principal: "owner:alice",
+      title: "Quiet place",
+      statement: "Offer me a quiet place.",
+      category: "environment",
+      reviewBy: OWNER_REVIEW_BY,
+    });
+    const originalWrite = subject.aliceStorage.writeMemoryFrontmatterIfUnchanged.bind(subject.aliceStorage);
+    let interrupted = false;
+    subject.aliceStorage.writeMemoryFrontmatterIfUnchanged = async (memory, patch, lifecycle) => {
+      if (!interrupted && lifecycle?.reasonCode === "draft-replacement-complete") {
+        interrupted = true;
+        throw new Error("simulated process exit before the prepared marker cleared");
+      }
+      return await originalWrite(memory, patch, lifecycle);
+    };
+
+    await assert.rejects(
+      subject.service.replaceCard({
+        principal: "owner:alice",
+        cardId: draft.cardId,
+        expectedRevision: draft.revision,
+        title: "Quiet place and time",
+        statement: "Offer me a quiet place and time.",
+        category: "environment",
+        reviewBy: OWNER_REVIEW_BY,
+      }),
+      /simulated process exit/
+    );
+    subject.aliceStorage.writeMemoryFrontmatterIfUnchanged = originalWrite;
+
+    // Interrupted state: the prior draft is durably rejected while the
+    // replacement still carries its prepared marker. Simulate tier
+    // migration demoting the rejected predecessor to the cold tier.
+    const beforeRecovery = await subject.aliceStorage.readAllMemories();
+    const replacement = beforeRecovery.find((memory) => memory.frontmatter.id !== draft.cardId);
+    assert.ok(replacement);
+    assert.equal(replacement.frontmatter.status, "pending_review");
+    assert.equal(
+      replacement.frontmatter.structuredAttributes?.["support-passport-draft-replacement-prepared"],
+      "true"
+    );
+    const rejectedDraft = beforeRecovery.find((memory) => memory.frontmatter.id === draft.cardId);
+    assert.ok(rejectedDraft);
+    assert.equal(rejectedDraft.frontmatter.status, "rejected");
+    const coldDir = path.join(subject.aliceStorage.dir, "cold", "preference");
+    await mkdir(coldDir, { recursive: true });
+    await rename(rejectedDraft.path, path.join(coldDir, path.basename(rejectedDraft.path)));
+    StorageManager.clearAllStaticCaches();
+    assert.equal(await subject.aliceStorage.getMemoryById(draft.cardId), null);
+    const replacementCard = projectSupportPassportCard(replacement);
+    assert.ok(replacementCard);
+    const approved = await subject.service.approveCard({
+      principal: "owner:alice",
+      cardId: replacement.frontmatter.id,
+      expectedRevision: replacementCard.card.revision,
+    });
+    assert.equal(approved.status, "active");
+
+    assert.deepEqual(
+      (await subject.service.listCards({ principal: "owner:alice" })).map((card) => [card.cardId, card.status]),
+      [[replacement.frontmatter.id, "active"]]
+    );
+
+    const coldPredecessor = await subject.aliceStorage.getMemoryByIdIncludingArchived(draft.cardId);
+    assert.equal(coldPredecessor?.frontmatter.status, "rejected");
+  } finally {
+    await subject.cleanup();
+  }
+});
+
 test("retrying a recovered pending-draft replacement reuses the exact draft", async () => {
   const subject = await makeSubject();
   try {

package/src/support-passport/card-service.ts

@@ -832,7 +832,7 @@ export class SupportPassportCardService {
     if (currentCard.card.status === "pending_review") {
       const priorId = currentMemory.frontmatter.supersedes;
       if (!priorId) return currentMemory;
-      const prior = await storage.getMemoryById(priorId);
+      const prior = await storage.getMemoryByIdIncludingArchived(priorId);
       if (
         prior &&
         ownsMemory(prior, namespace, principal) &&
@@ -973,7 +973,10 @@ export class SupportPassportCardService {
     onCommitted?: () => void
   ): Promise<void> {
     if (!replacement.replacesDraftId) return;
-    const replacedDraft = await storage.getMemoryById(replacement.replacesDraftId);
+    // Tier-independent: an interrupted edit's rejected predecessor can be
+    // demoted to the cold tier before recovery runs; a hot-only lookup would
+    // mistake it for deleted and orphan the valid replacement (#2387).
+    const replacedDraft = await storage.getMemoryByIdIncludingArchived(replacement.replacesDraftId);
     const projectedDraft = replacedDraft ? projectOwnedCard(replacedDraft, namespace, principal) : null;
     if (
       replacedDraft &&
@@ -999,7 +1002,7 @@ export class SupportPassportCardService {
         return;
       }
     }
-    const currentDraft = await storage.getMemoryById(replacement.replacesDraftId);
+    const currentDraft = await storage.getMemoryByIdIncludingArchived(replacement.replacesDraftId);
     if (
       currentDraft &&
       ownsMemory(currentDraft, namespace, principal) &&

package/src/support-passport/card-state.ts

@@ -152,7 +152,11 @@ export function ownerListCards(storedCards: StoredSupportPassportCard[]): Stored
     if (activeReplacementPredecessors.has(item.card.cardId)) return false;
     if (replacedDraftIds.has(item.card.cardId)) return false;
     if (!item.replacesDraftId) return true;
+    // The replaced draft may be demoted to the cold tier or archived after
+    // its rejection; a hot-only projection then reports it missing. A
+    // missing predecessor must not hide the replacement — only a restored
+    // active predecessor does (#2387).
     const replacedStatus = byId.get(item.replacesDraftId)?.card.status;
-    return replacedStatus === "pending_review" || replacedStatus === "rejected";
+    return replacedStatus === undefined || replacedStatus === "pending_review" || replacedStatus === "rejected";
   });
 }

package/src/support-passport/offline-sync-guard.ts

@@ -9,9 +9,13 @@ import {
   type OfflineSyncApplyChangesetResult,
   type OfflineSyncApplyFileContentChunkResult,
 } from "../offline-sync.js";
+import { parseFrontmatter } from "../storage.js";
 import { validateArchiveRelativePath } from "../transfer/fs-utils.js";
 import type { MemoryFile } from "../types.js";
-import { createSupportPassportPrivateFileExclusion } from "./card-projection.js";
+import {
+  createSupportPassportPrivateFileExclusion,
+  isSupportPassportPrivateMemory,
+} from "./card-projection.js";
 
 const MAX_SUPPORT_PASSPORT_FRONTMATTER_BYTES = 1_048_576;
 const SUPPORT_PASSPORT_MARKER = "support-passport-";
@@ -64,6 +68,15 @@ function assertFrontmatterAllowed(frontmatter: string, relativePath: string): vo
   if (frontmatter.includes(SUPPORT_PASSPORT_MARKER)) {
     throw new Error(`offline sync cannot modify private support-passport record: ${relativePath}`);
   }
+  // Canonical classification (#2387): YAML/JSON escapes — e.g. a
+  // structured-attribute key written as `support\u002dpassport-owner` — hide
+  // the marker from the raw scan above, while the storage reader's
+  // JSON.parse reconstructs it after the write. Validate the parsed
+  // frontmatter with the same predicate the read path classifies by.
+  const parsed = parseFrontmatter(frontmatter);
+  if (parsed && isSupportPassportPrivateMemory({ frontmatter: parsed.frontmatter })) {
+    throw new Error(`offline sync cannot modify private support-passport record: ${relativePath}`);
+  }
 }
 
 function inspectBufferedFrontmatter(

package/src/transfer/export-okf.test.ts

@@ -0,0 +1,164 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, rm, writeFile, symlink } from "node:fs/promises";
+import { existsSync, lstatSync, readdirSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import { StorageManager } from "../storage.js";
+import {
+  DEFAULT_OKF_LOG_MAX_ENTRIES,
+  exportOkfBundle,
+  OKF_EXPORT_VERSION,
+  OKF_LOG_TRUNCATION_MARKER,
+  parseIncludeStatus,
+} from "./export-okf.js";
+
+async function seedStore(dir: string): Promise<{ factId: string; decisionId: string }> {
+  const storage = new StorageManager(dir);
+  await storage.ensureDirectories();
+  const decision = await storage.writeMemory("decision", "# Use SQLite\n\nWe use SQLite for the local store.", {
+    source: "test",
+    confidence: 0.9,
+  });
+  const fact = await storage.writeMemory(
+    "fact",
+    "# Rate limit\n\nAPI rate limit is 100/min.\n\n<oai-mem-citation>\n<citation_entries>\nfacts/note.md:1-2|note=[source]\n</citation_entries>\n</oai-mem-citation>\n",
+    {
+      source: "test",
+      confidence: 0.9,
+      tags: ["api"],
+      links: [{ targetId: decision.id, linkType: "supports", strength: 0.8 }],
+    },
+  );
+  const superseded = await storage.writeMemory("fact", "# Old limit\n\nAPI rate limit is 10/min.", { source: "test" });
+  await storage.writeMemoryFrontmatter((await storage.getMemoryById(superseded.id))!, { status: "superseded" });
+  const pending = await storage.writeMemory("correction", "# Pending\n\nNeeds review.", { source: "test" });
+  await storage.writeMemoryFrontmatter((await storage.getMemoryById(pending.id))!, { status: "pending_review" });
+  await writeFile(path.join(dir, "profile.md"), "# User\n\nPrefers short answers.\n", "utf8");
+  return { factId: fact.id, decisionId: decision.id };
+}
+test("parseIncludeStatus rejects unknown values", () => {
+  assert.deepEqual(parseIncludeStatus(undefined), ["active"]);
+  assert.throws(() => parseIncludeStatus("nope"), /allowed:/);
+});
+
+test("exportOkfBundle writes a deterministic active-only bundle", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-okf-src-"));
+  const outA = await mkdtemp(path.join(os.tmpdir(), "remnic-okf-a-"));
+  const outB = path.join(os.tmpdir(), `remnic-okf-b-${Date.now()}`);
+  try {
+    await seedStore(memoryDir);
+    await rm(outA, { recursive: true, force: true });
+    const first = await exportOkfBundle({ memoryDir, outDir: outA });
+    assert.equal(first.exported, 2);
+    assert.ok(first.excluded >= 2);
+    const root = await readFile(path.join(outA, "index.md"), "utf8");
+    assert.match(root, new RegExp(`okf_version: "${OKF_EXPORT_VERSION}"`));
+    assert.doesNotMatch(root, /^type:/m);
+    assert.equal(existsSync(path.join(outA, "profile.md")), false);
+    const files = collectFiles(outA);
+    assert.ok(files.some((f) => f.includes("facts/")));
+    const factFile = files.find((f) => f.includes("facts/"))!;
+    const factBody = await readFile(path.join(outA, factFile), "utf8");
+    assert.match(factBody, /# Citations/);
+    assert.match(factBody, /# Related/);
+    assert.match(factBody, /type: Memory Fact/);
+    await exportOkfBundle({ memoryDir, outDir: outB });
+    assert.deepEqual(collectFiles(outA), collectFiles(outB));
+    for (const rel of collectFiles(outA)) {
+      assert.equal(await readFile(path.join(outA, rel), "utf8"), await readFile(path.join(outB, rel), "utf8"));
+    }
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+    await rm(outA, { recursive: true, force: true });
+    await rm(outB, { recursive: true, force: true });
+  }
+});
+
+test("profile stays off unless requested; non-empty out requires --force", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-okf-src-"));
+  const outDir = await mkdtemp(path.join(os.tmpdir(), "remnic-okf-out-"));
+  try {
+    await seedStore(memoryDir);
+    await rm(outDir, { recursive: true, force: true });
+    await exportOkfBundle({ memoryDir, outDir, includeProfile: true });
+    const profile = await readFile(path.join(outDir, "profile.md"), "utf8");
+    assert.match(profile, /type: Profile/);
+    await writeFile(path.join(outDir, "keep.txt"), "old", "utf8");
+    await assert.rejects(exportOkfBundle({ memoryDir, outDir }), /not empty/);
+    assert.equal(await readFile(path.join(outDir, "keep.txt"), "utf8"), "old");
+    await exportOkfBundle({ memoryDir, outDir, force: true });
+    assert.equal(existsSync(path.join(outDir, "keep.txt")), false);
+    assert.equal(existsSync(path.join(outDir, "index.md")), true);
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+    await rm(outDir, { recursive: true, force: true });
+  }
+});
+
+test("log.md is newest-first and marks truncation", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-okf-src-"));
+  const outDir = path.join(os.tmpdir(), `remnic-okf-log-${Date.now()}`);
+  try {
+    const storage = new StorageManager(memoryDir);
+    await storage.ensureDirectories();
+    await storage.writeMemory("fact", "# One\n\nbody", { source: "test" });
+    await storage.appendMemoryLifecycleEvents([
+      {
+        eventId: "e2",
+        memoryId: "m1",
+        eventType: "created",
+        timestamp: "2026-08-02T00:00:00.000Z",
+        actor: "test",
+        ruleVersion: "1",
+      },
+      {
+        eventId: "e1",
+        memoryId: "m1",
+        eventType: "updated",
+        timestamp: "2026-08-01T00:00:00.000Z",
+        actor: "test",
+        ruleVersion: "1",
+      },
+    ]);
+    await exportOkfBundle({ memoryDir, outDir, includeLog: true, logMaxEntries: 1 });
+    const log = await readFile(path.join(outDir, "log.md"), "utf8");
+    assert.match(log, /## 20\d{2}-\d{2}-\d{2}/);
+    assert.match(log, new RegExp(OKF_LOG_TRUNCATION_MARKER));
+    assert.ok(DEFAULT_OKF_LOG_MAX_ENTRIES > 1);
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+    await rm(outDir, { recursive: true, force: true });
+  }
+});
+
+test("symlink out is rejected", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-okf-src-"));
+  const real = await mkdtemp(path.join(os.tmpdir(), "remnic-okf-real-"));
+  const link = `${real}-link`;
+  try {
+    await seedStore(memoryDir);
+    await symlink(real, link);
+    await assert.rejects(exportOkfBundle({ memoryDir, outDir: link }), /symlink/);
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+    await rm(real, { recursive: true, force: true });
+    await rm(link, { force: true });
+  }
+});
+
+function collectFiles(root: string): string[] {
+  const out: string[] = [];
+  const walk = (dir: string): void => {
+    for (const name of readdirSync(dir).sort()) {
+      const full = path.join(dir, name);
+      const stat = lstatSync(full);
+      if (stat.isSymbolicLink()) continue;
+      if (stat.isDirectory()) walk(full);
+      else out.push(path.relative(root, full).split(path.sep).join("/"));
+    }
+  };
+  walk(root);
+  return out.sort();
+}