@remnic/core 9.69.16 → 9.69.17

package/dist/transfer/export-okf.js

@@ -4,30 +4,30 @@ import {
   exportOkfBundle,
   firstHeading,
   parseIncludeStatus
-} from "../chunk-I4QAH4SY.js";
+} from "../chunk-5J36BYRI.js";
 import {
   OKF_EXPORT_VERSION
-} from "../chunk-YWN3GYI2.js";
+} from "../chunk-NYFWBYY4.js";
 import "../chunk-D24OXEPB.js";
 import "../chunk-3UXOZBHV.js";
-import "../chunk-VYD63IFH.js";
+import "../chunk-N3DSSCOR.js";
 import "../chunk-UHVXE24Y.js";
 import "../chunk-4ZWCQJNM.js";
 import "../chunk-WVGXCBOC.js";
-import "../chunk-JGXMA6HL.js";
-import "../chunk-BE4Y6GK6.js";
-import "../chunk-N37X5RU7.js";
-import "../chunk-NNBZS3DY.js";
-import "../chunk-CYEPCZN5.js";
-import "../chunk-GIC6BASP.js";
+import "../chunk-6FUMA6AA.js";
+import "../chunk-D35XLYQ7.js";
 import "../chunk-YQNNHLCG.js";
-import "../chunk-W7IGLX4G.js";
 import "../chunk-6KTXE6A3.js";
+import "../chunk-RACZB5HT.js";
+import "../chunk-AG46P24C.js";
+import "../chunk-CYEPCZN5.js";
+import "../chunk-XZBXINXZ.js";
 import "../chunk-GUMZC2BO.js";
-import "../chunk-LEPOP46W.js";
+import "../chunk-W7IGLX4G.js";
+import "../chunk-227UFSEQ.js";
+import "../chunk-ET356KSB.js";
 import "../chunk-72A4L5JJ.js";
 import "../chunk-A7Q43EUZ.js";
-import "../chunk-ET356KSB.js";
 import "../chunk-S2V7RUCL.js";
 import "../chunk-OYV6RKPM.js";
 import "../chunk-S2HLHAZ4.js";
@@ -38,8 +38,8 @@ import "../chunk-LDXUBPMO.js";
 import "../chunk-XSTNGNJP.js";
 import "../chunk-AAD2ZS6P.js";
 import "../chunk-LUDBXTBJ.js";
-import "../chunk-3ONXXHQO.js";
 import "../chunk-YXZG5TVN.js";
+import "../chunk-3ONXXHQO.js";
 import "../chunk-5GINB5LC.js";
 import "../chunk-3WU7XOFN.js";
 import "../chunk-G7D6GZ5J.js";

package/dist/verified-recall.js

@@ -1,26 +1,26 @@
 import {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
-} from "./chunk-LJAP4KSW.js";
+} from "./chunk-FK2SJX27.js";
 import "./chunk-B7RWBZXW.js";
-import "./chunk-VYD63IFH.js";
+import "./chunk-N3DSSCOR.js";
 import "./chunk-UHVXE24Y.js";
 import "./chunk-4ZWCQJNM.js";
 import "./chunk-WVGXCBOC.js";
-import "./chunk-JGXMA6HL.js";
-import "./chunk-BE4Y6GK6.js";
-import "./chunk-N37X5RU7.js";
-import "./chunk-NNBZS3DY.js";
-import "./chunk-CYEPCZN5.js";
-import "./chunk-GIC6BASP.js";
+import "./chunk-6FUMA6AA.js";
+import "./chunk-D35XLYQ7.js";
 import "./chunk-YQNNHLCG.js";
-import "./chunk-W7IGLX4G.js";
 import "./chunk-6KTXE6A3.js";
+import "./chunk-RACZB5HT.js";
+import "./chunk-AG46P24C.js";
+import "./chunk-CYEPCZN5.js";
+import "./chunk-XZBXINXZ.js";
 import "./chunk-GUMZC2BO.js";
-import "./chunk-LEPOP46W.js";
+import "./chunk-W7IGLX4G.js";
+import "./chunk-227UFSEQ.js";
+import "./chunk-ET356KSB.js";
 import "./chunk-72A4L5JJ.js";
 import "./chunk-A7Q43EUZ.js";
-import "./chunk-ET356KSB.js";
 import "./chunk-S2V7RUCL.js";
 import "./chunk-OYV6RKPM.js";
 import "./chunk-S2HLHAZ4.js";
@@ -31,8 +31,8 @@ import "./chunk-LDXUBPMO.js";
 import "./chunk-XSTNGNJP.js";
 import "./chunk-AAD2ZS6P.js";
 import "./chunk-LUDBXTBJ.js";
-import "./chunk-3ONXXHQO.js";
 import "./chunk-YXZG5TVN.js";
+import "./chunk-3ONXXHQO.js";
 import "./chunk-5GINB5LC.js";
 import "./chunk-3WU7XOFN.js";
 import "./chunk-G7D6GZ5J.js";

package/dist/who-knows-cli.d.ts

@@ -1,4 +1,4 @@
-import { W as WhoKnowsResult } from './access-service-tcC_jK6C.js';
+import { W as WhoKnowsResult } from './access-service-DmDS8Y5P.js';
 import './types-Cy1l6fzp.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';

package/dist/who-knows-cli.js

@@ -4,26 +4,26 @@ import {
   renderWhoKnows,
   renderWhoKnowsJson,
   renderWhoKnowsText
-} from "./chunk-TRLCMLX7.js";
-import "./chunk-LUDXSSTW.js";
-import "./chunk-VYD63IFH.js";
+} from "./chunk-YYP5GM6J.js";
+import "./chunk-FCL6ENLF.js";
+import "./chunk-N3DSSCOR.js";
 import "./chunk-UHVXE24Y.js";
 import "./chunk-4ZWCQJNM.js";
 import "./chunk-WVGXCBOC.js";
-import "./chunk-JGXMA6HL.js";
-import "./chunk-BE4Y6GK6.js";
-import "./chunk-N37X5RU7.js";
-import "./chunk-NNBZS3DY.js";
-import "./chunk-CYEPCZN5.js";
-import "./chunk-GIC6BASP.js";
+import "./chunk-6FUMA6AA.js";
+import "./chunk-D35XLYQ7.js";
 import "./chunk-YQNNHLCG.js";
-import "./chunk-W7IGLX4G.js";
 import "./chunk-6KTXE6A3.js";
+import "./chunk-RACZB5HT.js";
+import "./chunk-AG46P24C.js";
+import "./chunk-CYEPCZN5.js";
+import "./chunk-XZBXINXZ.js";
 import "./chunk-GUMZC2BO.js";
-import "./chunk-LEPOP46W.js";
+import "./chunk-W7IGLX4G.js";
+import "./chunk-227UFSEQ.js";
+import "./chunk-ET356KSB.js";
 import "./chunk-72A4L5JJ.js";
 import "./chunk-A7Q43EUZ.js";
-import "./chunk-ET356KSB.js";
 import "./chunk-S2V7RUCL.js";
 import "./chunk-OYV6RKPM.js";
 import "./chunk-S2HLHAZ4.js";
@@ -34,8 +34,8 @@ import "./chunk-LDXUBPMO.js";
 import "./chunk-XSTNGNJP.js";
 import "./chunk-AAD2ZS6P.js";
 import "./chunk-LUDBXTBJ.js";
-import "./chunk-3ONXXHQO.js";
 import "./chunk-YXZG5TVN.js";
+import "./chunk-3ONXXHQO.js";
 import "./chunk-5GINB5LC.js";
 import "./chunk-3WU7XOFN.js";
 import "./chunk-G7D6GZ5J.js";

package/dist/who-knows.d.ts

@@ -1,4 +1,4 @@
-export { bA as WHO_KNOWS_AUTHORSHIP_BONUS, bB as WHO_KNOWS_DEFAULT_LIMIT, bC as WHO_KNOWS_MAX_EVIDENCE, bD as WHO_KNOWS_MAX_LIMIT, bE as WHO_KNOWS_MCP_TOOLS, bF as WhoKnowsEntity, bG as WhoKnowsEvidence, bH as WhoKnowsHit, bI as WhoKnowsHttpOutcome, W as WhoKnowsResult, bJ as WhoKnowsStorage, bT as computeWhoKnows, bZ as handleWhoKnowsHttpQuery, c2 as loadWhoKnowsEntities, c9 as tokenizeTopic, ca as validateWhoKnowsInput } from './access-service-tcC_jK6C.js';
+export { bA as WHO_KNOWS_AUTHORSHIP_BONUS, bB as WHO_KNOWS_DEFAULT_LIMIT, bC as WHO_KNOWS_MAX_EVIDENCE, bD as WHO_KNOWS_MAX_LIMIT, bE as WHO_KNOWS_MCP_TOOLS, bF as WhoKnowsEntity, bG as WhoKnowsEvidence, bH as WhoKnowsHit, bI as WhoKnowsHttpOutcome, W as WhoKnowsResult, bJ as WhoKnowsStorage, bT as computeWhoKnows, bZ as handleWhoKnowsHttpQuery, c2 as loadWhoKnowsEntities, c9 as tokenizeTopic, ca as validateWhoKnowsInput } from './access-service-DmDS8Y5P.js';
 import './types-Cy1l6fzp.js';
 import './orchestrator-DqLcuNMP.js';
 import './recall-state.js';

package/dist/who-knows.js

@@ -9,25 +9,25 @@ import {
   loadWhoKnowsEntities,
   tokenizeTopic,
   validateWhoKnowsInput
-} from "./chunk-LUDXSSTW.js";
-import "./chunk-VYD63IFH.js";
+} from "./chunk-FCL6ENLF.js";
+import "./chunk-N3DSSCOR.js";
 import "./chunk-UHVXE24Y.js";
 import "./chunk-4ZWCQJNM.js";
 import "./chunk-WVGXCBOC.js";
-import "./chunk-JGXMA6HL.js";
-import "./chunk-BE4Y6GK6.js";
-import "./chunk-N37X5RU7.js";
-import "./chunk-NNBZS3DY.js";
-import "./chunk-CYEPCZN5.js";
-import "./chunk-GIC6BASP.js";
+import "./chunk-6FUMA6AA.js";
+import "./chunk-D35XLYQ7.js";
 import "./chunk-YQNNHLCG.js";
-import "./chunk-W7IGLX4G.js";
 import "./chunk-6KTXE6A3.js";
+import "./chunk-RACZB5HT.js";
+import "./chunk-AG46P24C.js";
+import "./chunk-CYEPCZN5.js";
+import "./chunk-XZBXINXZ.js";
 import "./chunk-GUMZC2BO.js";
-import "./chunk-LEPOP46W.js";
+import "./chunk-W7IGLX4G.js";
+import "./chunk-227UFSEQ.js";
+import "./chunk-ET356KSB.js";
 import "./chunk-72A4L5JJ.js";
 import "./chunk-A7Q43EUZ.js";
-import "./chunk-ET356KSB.js";
 import "./chunk-S2V7RUCL.js";
 import "./chunk-OYV6RKPM.js";
 import "./chunk-S2HLHAZ4.js";
@@ -38,8 +38,8 @@ import "./chunk-LDXUBPMO.js";
 import "./chunk-XSTNGNJP.js";
 import "./chunk-AAD2ZS6P.js";
 import "./chunk-LUDBXTBJ.js";
-import "./chunk-3ONXXHQO.js";
 import "./chunk-YXZG5TVN.js";
+import "./chunk-3ONXXHQO.js";
 import "./chunk-5GINB5LC.js";
 import "./chunk-3WU7XOFN.js";
 import "./chunk-G7D6GZ5J.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "9.69.16",
+  "version": "9.69.17",
   "description": "Framework-agnostic Remnic memory engine — orchestrator, storage, extraction, search, trust zones",
   "type": "module",
   "main": "dist/index.js",
@@ -3227,7 +3227,7 @@
     "core"
   ],
   "peerDependencies": {
-    "@remnic/coding-graph": "^9.69.16"
+    "@remnic/coding-graph": "^9.69.17"
   },
   "peerDependenciesMeta": {
     "@remnic/coding-graph": {

package/src/access-mcp-output-schemas.ts

@@ -18,7 +18,7 @@ const T_NULLABLE_STRING = { type: ["string", "null"] } as const;
 /** Build a JSON Schema object type with the given properties. */
 function objectSchema(
   properties: Record<string, Readonly<Record<string, unknown>>>,
-  required?: readonly string[],
+  required?: readonly string[]
 ): Record<string, unknown> {
   return {
     type: "object",
@@ -82,8 +82,20 @@ const TOOL_OUTPUT_SCHEMAS: Readonly<Record<string, Record<string, unknown>>> = {
     skipped: T_NUMBER,
     removed: T_ARRAY,
   }),
-  deep_recall: objectSchema({ ok: T_BOOLEAN, error: T_NULLABLE_STRING, entries: T_ARRAY, trace: T_ARRAY, rendered: T_STRING }, ["entries", "trace"]),
-  standup: objectSchema({ date: T_STRING, yesterday: T_STRING, today: T_STRING, highlights: T_ARRAY, priorities: T_ARRAY, blockers: T_ARRAY, activityGrid: T_STRING, markdown: T_STRING }),
+  deep_recall: objectSchema(
+    { ok: T_BOOLEAN, error: T_NULLABLE_STRING, entries: T_ARRAY, trace: T_ARRAY, rendered: T_STRING },
+    ["entries", "trace"]
+  ),
+  standup: objectSchema({
+    date: T_STRING,
+    yesterday: T_STRING,
+    today: T_STRING,
+    highlights: T_ARRAY,
+    priorities: T_ARRAY,
+    blockers: T_ARRAY,
+    activityGrid: T_STRING,
+    markdown: T_STRING,
+  }),
   action_confidence: objectSchema({
     schemaVersion: T_NUMBER,
     decision: T_STRING,
@@ -176,6 +188,7 @@ const TOOL_OUTPUT_SCHEMAS: Readonly<Record<string, Record<string, unknown>>> = {
     effectiveNamespace: T_STRING,
     lcmArchived: T_BOOLEAN,
     extractionQueued: T_BOOLEAN,
+    transcriptPersisted: T_BOOLEAN,
   }),
   lcm_search: objectSchema({
     query: T_STRING,
@@ -274,42 +287,45 @@ const TOOL_OUTPUT_SCHEMAS: Readonly<Record<string, Record<string, unknown>>> = {
     guidelineVersion: { type: ["number", "null"] } as const,
   }),
   memory_search: objectSchema({ query: T_STRING, results: T_ARRAY, count: T_NUMBER }),
-  external_wiki_search: objectSchema({
-    query: T_STRING,
-    hits: {
-      type: "array",
-      items: {
-        type: "object",
-        properties: {
-          wikiId: T_STRING,
-          title: T_STRING,
-          path: T_STRING,
-          snippet: T_STRING,
-          score: T_NUMBER,
-          rank: T_NUMBER,
-          citations: {
-            type: "array",
-            items: {
-              type: "object",
-              properties: {
-                path: T_STRING,
-                lineStart: T_NUMBER,
-                lineEnd: T_NUMBER,
-                note: T_STRING,
+  external_wiki_search: objectSchema(
+    {
+      query: T_STRING,
+      hits: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            wikiId: T_STRING,
+            title: T_STRING,
+            path: T_STRING,
+            snippet: T_STRING,
+            score: T_NUMBER,
+            rank: T_NUMBER,
+            citations: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  path: T_STRING,
+                  lineStart: T_NUMBER,
+                  lineEnd: T_NUMBER,
+                  note: T_STRING,
+                },
+                required: ["path", "lineStart", "lineEnd", "note"],
+                additionalProperties: false,
               },
-              required: ["path", "lineStart", "lineEnd", "note"],
-              additionalProperties: false,
             },
+            indexBlurb: T_STRING,
           },
-          indexBlurb: T_STRING,
+          required: ["wikiId", "title", "path", "snippet", "score", "rank", "citations"],
+          additionalProperties: false,
         },
-        required: ["wikiId", "title", "path", "snippet", "score", "rank", "citations"],
-        additionalProperties: false,
       },
+      count: T_NUMBER,
+      degradedWikiIds: T_ARRAY,
     },
-    count: T_NUMBER,
-    degradedWikiIds: T_ARRAY,
-  }, ["query", "hits", "count", "degradedWikiIds"]),
+    ["query", "hits", "count", "degradedWikiIds"]
+  ),
   memory_profile: objectSchema({ profile: T_STRING }),
   memory_entities_list: objectSchema({ entities: T_ARRAY, count: T_NUMBER }),
   memory_questions: objectSchema({ questions: T_ARRAY, count: T_NUMBER }),
@@ -408,7 +424,17 @@ const TOOL_OUTPUT_SCHEMAS: Readonly<Record<string, Record<string, unknown>>> = {
     elapsedMs: T_NUMBER,
     skippedReason: T_STRING,
   }),
-  memory_summarize_hourly: objectSchema({ ok: T_BOOLEAN, message: T_STRING }),
+  memory_summarize_hourly: objectSchema({
+    ok: T_BOOLEAN,
+    message: T_STRING,
+    sessionsConsidered: T_NUMBER,
+    sessionsWithEntries: T_NUMBER,
+    summariesWritten: T_NUMBER,
+    staleStore: T_BOOLEAN,
+    newestEntryTimestamp: T_NULLABLE_STRING,
+    scanFailed: T_BOOLEAN,
+    warning: T_STRING,
+  }),
   conversation_index_update: objectSchema({
     enabled: T_BOOLEAN,
     sessions: T_NUMBER,

package/src/access-observe-transcript-persistence.test.ts

@@ -0,0 +1,252 @@
+/**
+ * Issue #2783: the daemon's observe path must persist observe-derived turns
+ * into the transcript store, and `memory_summarize_hourly` must report an
+ * empty/stale transcript store distinctly instead of a bare unconditional
+ * ok. Delegate-mode gateways (and any observe-only client) starve the
+ * hourly summarizer otherwise — 11 days of silent empty runs in the field.
+ */
+import assert from "node:assert/strict";
+import { mkdtemp, readdir, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import { EngramAccessService } from "./access-service.js";
+import { HourlySummarizer } from "./summarizer.js";
+import { Orchestrator } from "./orchestrator.js";
+import { TranscriptManager } from "./transcript.js";
+import type { CodingContext, PluginConfig } from "./types.js";
+
+interface StubOrchestrator {
+  config: PluginConfig;
+  transcript: TranscriptManager;
+  summarizer: HourlySummarizer;
+  lcmEngine?: undefined;
+  ingestReplayBatch: () => Promise<unknown[]>;
+  _codingContextBySession: Map<string, CodingContext>;
+}
+
+function makeService(
+  memoryDir: string,
+  transcriptEnabled: boolean,
+  transcriptSkipChannelTypes: string[] = []
+): { service: EngramAccessService; orchestrator: StubOrchestrator } {
+  const config = {
+    memoryDir,
+    transcriptEnabled,
+    transcriptSkipChannelTypes,
+    namespacesEnabled: false,
+    defaultNamespace: "default",
+  } as unknown as PluginConfig;
+  const orch = Object.create(Orchestrator.prototype) as Orchestrator;
+  const stub: StubOrchestrator = {
+    config,
+    transcript: new TranscriptManager(config),
+    summarizer: new HourlySummarizer(config),
+    lcmEngine: undefined,
+    ingestReplayBatch: async () => [],
+    _codingContextBySession: new Map<string, CodingContext>(),
+  };
+  Object.assign(orch as unknown as Record<string, unknown>, stub);
+  return { service: new EngramAccessService(orch), orchestrator: stub };
+}
+
+async function withTempDir(fn: (dir: string) => Promise<void>): Promise<void> {
+  const dir = await mkdtemp(path.join(tmpdir(), "remnic-2783-"));
+  try {
+    await fn(dir);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+}
+
+async function readAllTranscriptLines(dir: string): Promise<Array<Record<string, unknown>>> {
+  const root = path.join(dir, "transcripts");
+  const entries: Array<Record<string, unknown>> = [];
+  const typeDirs = await readdir(root, { withFileTypes: true }).catch(() => []);
+  for (const typeEnt of typeDirs) {
+    if (!typeEnt.isDirectory()) continue;
+    const idDirs = await readdir(path.join(root, typeEnt.name), { withFileTypes: true });
+    for (const idEnt of idDirs) {
+      if (!idEnt.isDirectory()) continue;
+      const files = await readdir(path.join(root, typeEnt.name, idEnt.name));
+      for (const file of files) {
+        if (!file.endsWith(".jsonl")) continue;
+        const raw = await readFile(path.join(root, typeEnt.name, idEnt.name, file), "utf-8");
+        for (const line of raw.split("\n")) {
+          if (line.trim().length === 0) continue;
+          entries.push(JSON.parse(line) as Record<string, unknown>);
+        }
+      }
+    }
+  }
+  return entries;
+}
+
+const USER_TURN = "please summarize the replication topology for the fleet";
+const ASSISTANT_TURN = "the fleet uses one primary daemon with a replicated failover copy";
+
+test("observe persists user and assistant turns into the transcript store (#2783)", async () => {
+  await withTempDir(async (dir) => {
+    const { service } = makeService(dir, true);
+    const response = await service.observe({
+      sessionKey: "agent:delegate-test:session-1",
+      messages: [
+        { role: "user", content: USER_TURN },
+        { role: "assistant", content: ASSISTANT_TURN },
+      ],
+    });
+    assert.equal(response.transcriptPersisted, true);
+    const entries = await readAllTranscriptLines(dir);
+    assert.equal(entries.length, 2);
+    assert.equal(entries[0]?.role, "user");
+    assert.equal(entries[0]?.content, USER_TURN);
+    assert.equal(entries[0]?.sessionKey, "agent:delegate-test:session-1");
+    assert.equal(entries[1]?.role, "assistant");
+    assert.equal(entries[1]?.content, ASSISTANT_TURN);
+    assert.equal(typeof entries[0]?.turnId, "string");
+    assert.equal(typeof entries[0]?.timestamp, "string");
+  });
+});
+
+test("observe filters short messages below the embedded parity noise floor (#2783)", async () => {
+  await withTempDir(async (dir) => {
+    const { service } = makeService(dir, true);
+    const response = await service.observe({
+      sessionKey: "agent:delegate-test:session-2",
+      messages: [
+        { role: "user", content: "ok" },
+        { role: "assistant", content: ASSISTANT_TURN },
+      ],
+    });
+    assert.equal(response.transcriptPersisted, true);
+    const entries = await readAllTranscriptLines(dir);
+    assert.equal(entries.length, 1);
+    assert.equal(entries[0]?.role, "assistant");
+  });
+});
+
+test("a re-POST of the same user turn is deduped; new turns still append (#2783)", async () => {
+  await withTempDir(async (dir) => {
+    const { service } = makeService(dir, true);
+    await service.observe({
+      sessionKey: "agent:delegate-test:session-3",
+      messages: [
+        { role: "user", content: USER_TURN },
+        { role: "assistant", content: ASSISTANT_TURN },
+      ],
+    });
+    // Un-keyed client retry of the SAME turn (no idempotencyKey).
+    await service.observe({
+      sessionKey: "agent:delegate-test:session-3",
+      messages: [
+        { role: "user", content: USER_TURN },
+        { role: "assistant", content: ASSISTANT_TURN },
+      ],
+    });
+    const afterRetry = await readAllTranscriptLines(dir);
+    assert.equal(afterRetry.length, 2);
+
+    // A genuinely new turn still appends.
+    await service.observe({
+      sessionKey: "agent:delegate-test:session-3",
+      messages: [{ role: "user", content: "now check the failover read path end to end please" }],
+    });
+    const afterNew = await readAllTranscriptLines(dir);
+    assert.equal(afterNew.length, 3);
+  });
+});
+
+test("transcript persistence is gated on the transcriptEnabled capability (#2783)", async () => {
+  await withTempDir(async (dir) => {
+    const { service } = makeService(dir, false);
+    const response = await service.observe({
+      sessionKey: "agent:delegate-test:session-4",
+      messages: [{ role: "user", content: USER_TURN }],
+    });
+    assert.equal(response.transcriptPersisted, false);
+    const entries = await readAllTranscriptLines(dir);
+    assert.equal(entries.length, 0);
+  });
+});
+
+test("memory_summarize_hourly warns distinctly when the transcript store is empty (#2783)", async () => {
+  await withTempDir(async (dir) => {
+    const { service } = makeService(dir, true);
+    const result = await service.memorySummarizeHourly();
+    assert.equal(result.ok, true);
+    assert.equal(result.sessionsConsidered, 0);
+    assert.equal(result.warning, "transcript store is empty");
+    assert.match(result.message, /transcript store is empty/);
+  });
+});
+
+test("memory_summarize_hourly warns distinctly when the store is stale and the hour was idle (#2783)", async () => {
+  await withTempDir(async (dir) => {
+    const { service, orchestrator } = makeService(dir, true);
+    // Seed one transcript entry far in the past: the store is non-empty but
+    // stale, and the target hour has no entries.
+    await orchestrator.transcript.append({
+      timestamp: new Date(Date.now() - 6 * 60 * 60 * 1000).toISOString(),
+      role: "user",
+      content: "an old turn from a much earlier hour",
+      sessionKey: "agent:delegate-test:session-5",
+      turnId: "seed-turn",
+    });
+    const result = await service.memorySummarizeHourly();
+    assert.equal(result.ok, true);
+    assert.ok(result.sessionsConsidered > 0);
+    assert.equal(result.sessionsWithEntries, 0);
+    assert.equal(result.staleStore, true);
+    assert.equal(result.warning, "no transcript entries for the target hour and no new entries recently");
+  });
+});
+
+test("observeTranscriptSessionKey scopes transcripts to the effective write namespace (#2783 review)", async () => {
+  const { observeTranscriptSessionKey } = await import("./access-observe-transcript.js");
+  const config = { defaultNamespace: "generalist" } as { defaultNamespace: string };
+  // Same client-controlled sessionKey from two principals in different
+  // namespaces must not share one transcript identity.
+  const a = observeTranscriptSessionKey("agent:shared-key:s1", "project-origin-aaa", config);
+  const b = observeTranscriptSessionKey("agent:shared-key:s1", "project-origin-bbb", config);
+  assert.notEqual(a, b);
+  assert.ok(a.includes("project-origin-aaa"));
+  assert.ok(b.includes("project-origin-bbb"));
+  // A default-store write keeps the raw key (single-store deployments
+  // unchanged, mirroring the LCM archive key rules).
+  assert.equal(observeTranscriptSessionKey("agent:shared-key:s1", "generalist", config), "agent:shared-key:s1");
+});
+
+test("skip-listed channel types report transcriptPersisted=false, not a silent success (#2783 review)", async () => {
+  await withTempDir(async (dir) => {
+    // cron is in the default skip list; a session whose channel type
+    // resolves to it must not report persisted=true for a no-op append.
+    const { service } = makeService(dir, true, ["cron"]);
+    const response = await service.observe({
+      sessionKey: "agent:nightly:cron:job-1",
+      messages: [{ role: "user", content: "this nightly cron turn must not claim transcript persistence" }],
+    });
+    assert.equal(response.transcriptPersisted, false);
+    const entries = await readAllTranscriptLines(dir);
+    assert.equal(entries.length, 0);
+  });
+});
+
+test("overlapping identical observes do not double-append the same turn (#2783 review)", async () => {
+  await withTempDir(async (dir) => {
+    const { service } = makeService(dir, true);
+    const [a, b] = await Promise.all([
+      service.observe({
+        sessionKey: "agent:overlap:s1",
+        messages: [{ role: "user", content: "the same turn submitted concurrently by a retrying client" }],
+      }),
+      service.observe({
+        sessionKey: "agent:overlap:s1",
+        messages: [{ role: "user", content: "the same turn submitted concurrently by a retrying client" }],
+      }),
+    ]);
+    const entries = await readAllTranscriptLines(dir);
+    assert.equal(entries.length, 1);
+    assert.equal(a.transcriptPersisted !== b.transcriptPersisted, true);
+  });
+});