@remnic/core 9.66.0 → 9.66.2

package/src/shared-context/governance.test.ts

@@ -0,0 +1,53 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import {
+  applyDefaultEnvelope,
+  isExpired,
+  parseSharedEnvelope,
+} from "./governance.js";
+
+test("applyDefaultEnvelope defaults to informational with no expiry", () => {
+  assert.deepEqual(applyDefaultEnvelope(), { authority: "informational" });
+  assert.deepEqual(applyDefaultEnvelope({}), { authority: "informational" });
+  assert.deepEqual(applyDefaultEnvelope({ authority: "advisory", sharedBy: "agent-a" }), {
+    authority: "advisory",
+    sharedBy: "agent-a",
+  });
+});
+
+test("applyDefaultEnvelope rejects binding without an explicit flag", () => {
+  assert.throws(() => applyDefaultEnvelope({ authority: "binding" }), /binding/);
+  assert.deepEqual(applyDefaultEnvelope({ authority: "binding" }, { binding: true }), {
+    authority: "binding",
+  });
+});
+
+test("isExpired treats expiresAt as a half-open upper bound", () => {
+  const expiresAt = "2026-08-18T12:00:00.000Z";
+  const at = Date.parse(expiresAt);
+  const envelope = { authority: "informational" as const, expiresAt };
+  assert.equal(isExpired(envelope, at - 1), false);
+  assert.equal(isExpired(envelope, at), true);
+  assert.equal(isExpired({}, at), false);
+});
+
+test("parseSharedEnvelope treats a missing legacy envelope as informational with no expiry", () => {
+  assert.deepEqual(parseSharedEnvelope(undefined), { authority: "informational" });
+  assert.deepEqual(parseSharedEnvelope(null), { authority: "informational" });
+  assert.deepEqual(parseSharedEnvelope({ title: "legacy output" }), { authority: "informational" });
+  assert.deepEqual(
+    parseSharedEnvelope({
+      sharedBy: "agent-a",
+      authority: "advisory",
+      expiresAt: "2026-08-18T12:00:00.000Z",
+      supersedes: "item-1",
+    }),
+    {
+      sharedBy: "agent-a",
+      authority: "advisory",
+      expiresAt: "2026-08-18T12:00:00.000Z",
+      supersedes: "item-1",
+    },
+  );
+});

package/src/shared-context/governance.ts

@@ -0,0 +1,86 @@
+/**
+ * Shared-item authority envelope (issue #1957).
+ *
+ * First slice: parse + default + expiry only. Write-path wiring and
+ * curation come later. Binding is never inferred.
+ */
+
+export const SHARED_AUTHORITIES = ["informational", "advisory", "binding"] as const;
+export type SharedAuthority = (typeof SHARED_AUTHORITIES)[number];
+
+export interface SharedEnvelope {
+  sharedBy?: string;
+  authority: SharedAuthority;
+  expiresAt?: string;
+  supersedes?: string;
+}
+
+export interface SharedEnvelopeInput {
+  sharedBy?: string;
+  authority?: string;
+  expiresAt?: string;
+  supersedes?: string;
+}
+
+export interface ApplyDefaultEnvelopeOptions {
+  binding?: boolean;
+}
+
+function isSharedAuthority(value: string): value is SharedAuthority {
+  return (SHARED_AUTHORITIES as readonly string[]).includes(value);
+}
+
+function optionalString(value: unknown): string | undefined {
+  if (typeof value !== "string") return undefined;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+}
+
+function withOptionalFields(
+  authority: SharedAuthority,
+  source: { sharedBy?: unknown; expiresAt?: unknown; supersedes?: unknown },
+): SharedEnvelope {
+  const envelope: SharedEnvelope = { authority };
+  const sharedBy = optionalString(source.sharedBy);
+  const expiresAt = optionalString(source.expiresAt);
+  const supersedes = optionalString(source.supersedes);
+  if (sharedBy) envelope.sharedBy = sharedBy;
+  if (expiresAt) envelope.expiresAt = expiresAt;
+  if (supersedes) envelope.supersedes = supersedes;
+  return envelope;
+}
+
+export function applyDefaultEnvelope(
+  input: SharedEnvelopeInput = {},
+  options: ApplyDefaultEnvelopeOptions = {},
+): SharedEnvelope {
+  const requested = optionalString(input.authority);
+  if (requested !== undefined && !isSharedAuthority(requested)) {
+    throw new Error(
+      `applyDefaultEnvelope: authority must be informational, advisory, or binding; got ${JSON.stringify(requested)}`,
+    );
+  }
+  if (requested === "binding" && options.binding !== true) {
+    throw new Error("applyDefaultEnvelope: authority \"binding\" requires an explicit binding flag");
+  }
+  return withOptionalFields(requested ?? "informational", input);
+}
+
+export function parseSharedEnvelope(raw: unknown): SharedEnvelope {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    return { authority: "informational" };
+  }
+  const record = raw as Record<string, unknown>;
+  const requested = optionalString(record.authority);
+  const authority = requested !== undefined && isSharedAuthority(requested) ? requested : "informational";
+  return withOptionalFields(authority, record);
+}
+
+export function isExpired(envelope: Pick<SharedEnvelope, "expiresAt">, nowMs: number): boolean {
+  if (!Number.isFinite(nowMs)) return false;
+  const expiresAt = envelope.expiresAt?.trim();
+  if (!expiresAt) return false;
+  const expiresAtMs = Date.parse(expiresAt);
+  if (!Number.isFinite(expiresAtMs)) return false;
+  return expiresAtMs <= nowMs;
+}

package/src/shared-context/staleness.test.ts

@@ -0,0 +1,36 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import {
+  filterLiveEnvelopes,
+  markSupersededCirculation,
+  type SharedStalenessItem,
+} from "./staleness.js";
+
+test("filterLiveEnvelopes drops at the expiry instant (half-open)", () => {
+  const expiresAt = "2026-08-18T12:00:00.000Z";
+  const at = Date.parse(expiresAt);
+  const live: SharedStalenessItem = { id: "keep", expiresAt };
+  const forever: SharedStalenessItem = { id: "legacy" };
+  const items: SharedStalenessItem[] = [live, forever];
+
+  assert.deepEqual(filterLiveEnvelopes(items, at - 1), items);
+  assert.deepEqual(filterLiveEnvelopes(items, at), [forever]);
+  assert.deepEqual(filterLiveEnvelopes(items, at + 1), [forever]);
+  assert.equal(items.length, 2);
+});
+
+test("markSupersededCirculation flags targets that still circulate", () => {
+  const older: SharedStalenessItem = { id: "item-1", expiresAt: "2026-08-19T00:00:00.000Z" };
+  const newer: SharedStalenessItem = { id: "item-2", supersedes: "item-1" };
+  const other: SharedStalenessItem = { id: "item-3" };
+  const items: SharedStalenessItem[] = [older, newer, other];
+
+
+  const marked = markSupersededCirculation(items);
+  assert.equal(marked[0]?.circulating, true);
+  assert.equal(marked[1]?.circulating, undefined);
+  assert.equal(marked[2]?.circulating, undefined);
+  assert.equal(older.circulating, undefined);
+  assert.notEqual(marked[0], older);
+});

package/src/shared-context/staleness.ts

@@ -0,0 +1,38 @@
+/**
+ * Shared-item staleness (issue #1957).
+ *
+ * Pure helpers. Expired items drop; superseded items that still circulate
+ * get a marker. Callers never `rm`.
+ */
+import { isExpired } from "./governance.js";
+
+export interface SharedStalenessItem {
+  id: string;
+  expiresAt?: string;
+  supersedes?: string;
+  circulating?: boolean;
+}
+
+/** Drop expired items. Half-open: `nowMs >= expiresAt` is expired. */
+export function filterLiveEnvelopes<T extends { expiresAt?: string }>(
+  items: readonly T[],
+  nowMs: number,
+): T[] {
+  return items.filter((item) => !isExpired(item, nowMs));
+}
+
+/**
+ * Mark items whose id appears in another item's `supersedes`.
+ * Returns a new array. Does not mutate input and does not delete files.
+ */
+export function markSupersededCirculation<T extends SharedStalenessItem>(
+  items: readonly T[],
+): T[] {
+  const supersededIds = new Set<string>();
+  for (const item of items) {
+    if (item.supersedes) supersededIds.add(item.supersedes);
+  }
+  return items.map((item) =>
+    supersededIds.has(item.id) ? { ...item, circulating: true } : item,
+  );
+}

package/src/shared-context/trajectories.test.ts

@@ -0,0 +1,77 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import { publishTrajectory } from "./trajectories.js";
+
+test("publishTrajectory defaults to review and lands pending_review", () => {
+  const result = publishTrajectory({
+    trajectoryId: "traj-1",
+    summary: "ran the check",
+  });
+  assert.deepEqual(result, {
+    ok: true,
+    status: "pending_review",
+    trajectoryId: "traj-1",
+    summary: "ran the check",
+  });
+});
+
+test("publishTrajectory review mode lands pending_review", () => {
+  const result = publishTrajectory({
+    mode: "review",
+    trajectoryId: "traj-1",
+    summary: "ran the check",
+  });
+  assert.equal(result.ok, true);
+  if (result.ok) assert.equal(result.status, "pending_review");
+});
+
+test("publishTrajectory auto mode lands active", () => {
+  const result = publishTrajectory({
+    mode: "auto",
+    trajectoryId: "traj-1",
+    summary: "ran the check",
+  });
+  assert.equal(result.ok, true);
+  if (result.ok) assert.equal(result.status, "active");
+});
+
+test("publishTrajectory off mode returns disabled", () => {
+  assert.deepEqual(
+    publishTrajectory({
+      mode: "off",
+      trajectoryId: "traj-1",
+      summary: "ran the check",
+    }),
+    { ok: false, error: "disabled" },
+  );
+});
+
+test("publishTrajectory rejects an unknown mode", () => {
+  assert.deepEqual(
+    publishTrajectory({
+      mode: "publish",
+      trajectoryId: "traj-1",
+      summary: "ran the check",
+    }),
+    { ok: false, error: "unknown_mode" },
+  );
+});
+
+test("publishTrajectory keeps the summary string and strips tool output", () => {
+  const dirty = {
+    mode: "auto",
+    trajectoryId: "traj-1",
+    summary: "ran the check",
+    toolOutput: "stdout: secret fixture dump",
+  };
+  const result = publishTrajectory(dirty);
+  assert.deepEqual(result, {
+    ok: true,
+    status: "active",
+    trajectoryId: "traj-1",
+    summary: "ran the check",
+  });
+  assert.equal(JSON.stringify(result).includes("stdout"), false);
+  assert.equal("toolOutput" in result, false);
+});

package/src/shared-context/trajectories.ts

@@ -0,0 +1,49 @@
+/**
+ * Shared-context trajectory publish (issue #1957).
+ *
+ * First slice: mode gate + sanitization only. Persistence and
+ * findTrajectories come later.
+ */
+
+export const TRAJECTORY_SHARE_MODES = ["off", "review", "auto"] as const;
+export type TrajectoryShareMode = (typeof TRAJECTORY_SHARE_MODES)[number];
+
+export interface PublishTrajectoryInput {
+  mode?: string;
+  trajectoryId: string;
+  summary: string;
+}
+
+export type PublishTrajectoryResult =
+  | { ok: false; error: "disabled" | "unknown_mode" }
+  | {
+      ok: true;
+      status: "pending_review" | "active";
+      trajectoryId: string;
+      summary: string;
+    };
+
+const MODE_STATUS = {
+  review: "pending_review",
+  auto: "active",
+} as const;
+
+function isTrajectoryShareMode(value: string): value is TrajectoryShareMode {
+  return (TRAJECTORY_SHARE_MODES as readonly string[]).includes(value);
+}
+
+export function publishTrajectory(input: PublishTrajectoryInput): PublishTrajectoryResult {
+  const mode = input.mode ?? "review";
+  if (!isTrajectoryShareMode(mode)) {
+    return { ok: false, error: "unknown_mode" };
+  }
+  if (mode === "off") {
+    return { ok: false, error: "disabled" };
+  }
+  return {
+    ok: true,
+    status: MODE_STATUS[mode],
+    trajectoryId: input.trajectoryId,
+    summary: input.summary,
+  };
+}

package/src/types.ts

@@ -1939,19 +1939,12 @@ export interface PluginConfig extends BoundedJsonlStateConfig, SecurityConfig, D
   // v6.0 Fact deduplication & archival
   /** Enable content-hash deduplication to prevent storing semantically identical facts. */
   factDeduplicationEnabled: boolean;
-  /**
-   * Issue #373 — Write-time semantic similarity guard. When enabled (default),
-   * the orchestrator embeds each candidate fact and queries the existing
-   * embedding index for its top-K nearest neighbors. If the best cosine
-   * similarity is at or above `semanticDedupThreshold`, the fact is dropped
-   * as a near-duplicate. Fails open (keeps the fact) if the embedding backend
-   * is unavailable.
-   */
   semanticDedupEnabled: boolean;
-  /** Cosine similarity threshold in [0, 1] above which a candidate fact is skipped. */
   semanticDedupThreshold: number;
-  /** Number of nearest-neighbor candidates to consider during semantic dedup. */
   semanticDedupCandidates: number;
+  noveltyGateEnabled: boolean;
+  noveltyAddThreshold: number;
+  noveltyNoopThreshold: number;
   /** Enable automatic archival of old, low-importance, rarely-accessed facts. */
   factArchivalEnabled: boolean;
   /** Minimum age in days before a fact is eligible for archival. */