@remnic/core 9.66.2 → 9.66.4

package/src/recall-state-view-current.test.ts

@@ -0,0 +1,23 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { assertCurrentHasNoSuccessor } from "./recall-state-view-current.js";
+
+test("current plus successor id is current_has_successor", () => {
+  assert.deepEqual(assertCurrentHasNoSuccessor({ kind: "current", successorId: "mem-2" }), {
+    ok: false,
+    error: "current_has_successor",
+  });
+});
+
+test("current plus empty successor id is ok", () => {
+  assert.deepEqual(assertCurrentHasNoSuccessor({ kind: "current", successorId: "" }), { ok: true });
+  assert.deepEqual(assertCurrentHasNoSuccessor({ kind: "current", successorId: "   " }), { ok: true });
+  assert.deepEqual(assertCurrentHasNoSuccessor({ kind: "current" }), { ok: true });
+});
+
+test("historical plus successor id is ok", () => {
+  assert.deepEqual(assertCurrentHasNoSuccessor({ kind: "historical", successorId: "mem-2" }), {
+    ok: true,
+  });
+});

package/src/recall-state-view-current.ts

@@ -0,0 +1,24 @@
+/**
+ * Recall state-view current-has-no-successor guard (issue #1952 leftover).
+ *
+ * Pure. Surfaces wait. Current plus a successor is current_has_successor.
+ */
+
+export type AssertCurrentHasNoSuccessorInput = {
+  kind: string;
+  successorId?: string;
+};
+
+export type AssertCurrentHasNoSuccessorResult =
+  | { ok: true }
+  | { ok: false; error: "current_has_successor" };
+
+export function assertCurrentHasNoSuccessor(
+  input: AssertCurrentHasNoSuccessorInput,
+): AssertCurrentHasNoSuccessorResult {
+  const successorId = input.successorId?.trim() ?? "";
+  if (input.kind === "current" && successorId.length > 0) {
+    return { ok: false, error: "current_has_successor" };
+  }
+  return { ok: true };
+}

package/src/recall-state-view-inject.test.ts

@@ -0,0 +1,32 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { injectStateViewLines } from "./recall-state-view-inject.js";
+
+const TEXT = "Was a baker";
+const DATE = "2026-03-01";
+const SUCCESSOR = "new-job";
+
+const historical = {
+  id: "old-job",
+  text: TEXT,
+  stateLabel: "historical" as const,
+  supersededAt: DATE,
+  supersededBy: SUCCESSOR,
+};
+
+test("enabled false keeps original text per item", () => {
+  assert.deepEqual(injectStateViewLines([historical]), [TEXT]);
+  assert.deepEqual(injectStateViewLines([historical], { enabled: false }), [TEXT]);
+});
+
+test("empty list stays empty", () => {
+  assert.deepEqual(injectStateViewLines([]), []);
+  assert.deepEqual(injectStateViewLines([], { enabled: true }), []);
+});
+
+test("enabled prefix maps historical text", () => {
+  assert.deepEqual(injectStateViewLines([historical], { enabled: true }), [
+    `[superseded ${DATE} by ${SUCCESSOR}] ${TEXT}`,
+  ]);
+});

package/src/recall-state-view-inject.ts

@@ -0,0 +1,14 @@
+/**
+ * Recall inject-line mapper for state views (issue #1952).
+ *
+ * Maps each result through renderStateViewLine. A disabled flag keeps
+ * original text per item. An empty list stays empty.
+ */
+import { renderStateViewLine, type StateViewLineResult } from "./recall-state-view-render.js";
+
+export function injectStateViewLines(
+  results: readonly StateViewLineResult[],
+  options: { enabled?: boolean } = {},
+): string[] {
+  return results.map((result) => renderStateViewLine(result, options));
+}

package/src/recall-state-view-kind.test.ts

@@ -0,0 +1,19 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { parseStateViewKind } from "./recall-state-view-kind.js";
+
+test("parses each allowed kind", () => {
+  for (const kind of ["current", "historical", "transition"] as const) {
+    assert.deepEqual(parseStateViewKind(kind), { ok: true, kind });
+  }
+});
+
+test("unknown kind is unknown_kind", () => {
+  assert.deepEqual(parseStateViewKind("ghost"), { ok: false, error: "unknown_kind" });
+  assert.deepEqual(parseStateViewKind("superseded"), { ok: false, error: "unknown_kind" });
+});
+
+test("empty kind is unknown_kind", () => {
+  assert.deepEqual(parseStateViewKind(""), { ok: false, error: "unknown_kind" });
+});

package/src/recall-state-view-kind.ts

@@ -0,0 +1,20 @@
+/**
+ * Recall state-view kind parse (issue #1952 leftover).
+ *
+ * Pure. Surfaces wait. Unknown or empty is unknown_kind.
+ */
+
+const STATE_VIEW_KINDS = ["current", "historical", "transition"] as const;
+
+export type StateViewKind = (typeof STATE_VIEW_KINDS)[number];
+
+export type ParseStateViewKindResult =
+  | { ok: true; kind: StateViewKind }
+  | { ok: false; error: "unknown_kind" };
+
+export function parseStateViewKind(value: string): ParseStateViewKindResult {
+  if ((STATE_VIEW_KINDS as readonly string[]).includes(value)) {
+    return { ok: true, kind: value as StateViewKind };
+  }
+  return { ok: false, error: "unknown_kind" };
+}

package/src/recall-state-view-label.test.ts

@@ -0,0 +1,36 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { labelStateView } from "./recall-state-view-label.js";
+
+const DATE = "2026-03-01";
+const SUCCESSOR = "new-job";
+
+test("kind current is current", () => {
+  assert.equal(
+    labelStateView({ kind: "current", supersededAt: DATE, successorId: SUCCESSOR }),
+    "current",
+  );
+});
+
+test("kind historical with both fields is historical", () => {
+  assert.equal(
+    labelStateView({ kind: "historical", supersededAt: DATE, successorId: SUCCESSOR }),
+    "historical",
+  );
+});
+
+test("missing supersededAt or successorId is current", () => {
+  assert.equal(
+    labelStateView({ kind: "historical", successorId: SUCCESSOR }),
+    "current",
+  );
+  assert.equal(
+    labelStateView({ kind: "transition", supersededAt: DATE }),
+    "current",
+  );
+});
+
+test("unknown kind throws", () => {
+  assert.throws(() => labelStateView({ kind: "ghost" }), /unknown state view kind/);
+});

package/src/recall-state-view-label.ts

@@ -0,0 +1,22 @@
+/**
+ * Pure state-view labeler (issue #1952 leftover).
+ *
+ * Surfaces wait. `current` stays current. `historical` and `transition`
+ * keep their kind only when both supersededAt and successorId are set.
+ * Missing either field is current. Unknown kind throws.
+ */
+import type { StateLabel } from "./recall-state-view.js";
+
+export function labelStateView(input: {
+  kind: string;
+  supersededAt?: string;
+  successorId?: string;
+}): StateLabel {
+  const { kind, supersededAt, successorId } = input;
+  if (kind === "current") return "current";
+  if (kind === "historical" || kind === "transition") {
+    if (!supersededAt || !successorId) return "current";
+    return kind;
+  }
+  throw new Error(`unknown state view kind: ${JSON.stringify(kind)}`);
+}

package/src/recall-state-view-successor.test.ts

@@ -0,0 +1,21 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { parseSuccessorId } from "./recall-state-view-successor.js";
+
+test("ok successor id returns trimmed successorId", () => {
+  assert.deepEqual(parseSuccessorId("mem-2"), { ok: true, successorId: "mem-2" });
+});
+
+test("empty successor id is missing_successor", () => {
+  assert.deepEqual(parseSuccessorId(""), { ok: false, error: "missing_successor" });
+  assert.deepEqual(parseSuccessorId("   "), { ok: false, error: "missing_successor" });
+});
+
+test("newline in successor id is invalid_successor", () => {
+  assert.deepEqual(parseSuccessorId("mem-1\nmem-2"), { ok: false, error: "invalid_successor" });
+});
+
+test("trims surrounding whitespace", () => {
+  assert.deepEqual(parseSuccessorId("  mem-2  "), { ok: true, successorId: "mem-2" });
+});

package/src/recall-state-view-successor.ts

@@ -0,0 +1,16 @@
+/**
+ * Recall state-view successor-id parse (issue #1952 leftover).
+ *
+ * Pure. Surfaces wait. Empty is missing_successor. Newline is invalid_successor.
+ */
+
+export type ParseSuccessorIdResult =
+  | { ok: true; successorId: string }
+  | { ok: false; error: "missing_successor" | "invalid_successor" };
+
+export function parseSuccessorId(value: string): ParseSuccessorIdResult {
+  const successorId = value.trim();
+  if (successorId.length === 0) return { ok: false, error: "missing_successor" };
+  if (successorId.includes("\n")) return { ok: false, error: "invalid_successor" };
+  return { ok: true, successorId };
+}

package/src/recall-state-view-superseded.test.ts

@@ -0,0 +1,20 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { parseSupersededAt } from "./recall-state-view-superseded.js";
+
+test("ok date returns canonical ISO supersededAt", () => {
+  assert.deepEqual(parseSupersededAt("2026-08-19T12:34:56.000Z"), {
+    ok: true,
+    supersededAt: "2026-08-19T12:34:56.000Z",
+  });
+});
+
+test("empty date is missing_date", () => {
+  assert.deepEqual(parseSupersededAt(""), { ok: false, error: "missing_date" });
+  assert.deepEqual(parseSupersededAt("   "), { ok: false, error: "missing_date" });
+});
+
+test("invalid date is invalid_date", () => {
+  assert.deepEqual(parseSupersededAt("not-a-date"), { ok: false, error: "invalid_date" });
+});

package/src/recall-state-view-superseded.ts

@@ -0,0 +1,17 @@
+/**
+ * Recall state-view superseded-at parse (issue #1952 leftover).
+ *
+ * Pure. Surfaces wait. Empty is missing_date. Unparseable is invalid_date.
+ */
+
+export type ParseSupersededAtResult =
+  | { ok: true; supersededAt: string }
+  | { ok: false; error: "missing_date" | "invalid_date" };
+
+export function parseSupersededAt(value: string): ParseSupersededAtResult {
+  const trimmed = value.trim();
+  if (trimmed.length === 0) return { ok: false, error: "missing_date" };
+  const parsed = Date.parse(trimmed);
+  if (!Number.isFinite(parsed)) return { ok: false, error: "invalid_date" };
+  return { ok: true, supersededAt: new Date(parsed).toISOString() };
+}

package/src/recall-state-view-transition.test.ts

@@ -0,0 +1,30 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { assertTransitionHasSuccessor } from "./recall-state-view-transition.js";
+
+test("transition plus empty successor id is transition_missing_successor", () => {
+  assert.deepEqual(assertTransitionHasSuccessor({ kind: "transition", successorId: "" }), {
+    ok: false,
+    error: "transition_missing_successor",
+  });
+  assert.deepEqual(assertTransitionHasSuccessor({ kind: "transition", successorId: "   " }), {
+    ok: false,
+    error: "transition_missing_successor",
+  });
+  assert.deepEqual(assertTransitionHasSuccessor({ kind: "transition" }), {
+    ok: false,
+    error: "transition_missing_successor",
+  });
+});
+
+test("transition plus successor id is ok", () => {
+  assert.deepEqual(assertTransitionHasSuccessor({ kind: "transition", successorId: "mem-2" }), {
+    ok: true,
+  });
+});
+
+test("current plus empty successor id is ok", () => {
+  assert.deepEqual(assertTransitionHasSuccessor({ kind: "current", successorId: "" }), { ok: true });
+  assert.deepEqual(assertTransitionHasSuccessor({ kind: "current" }), { ok: true });
+});

package/src/recall-state-view-transition.ts

@@ -0,0 +1,24 @@
+/**
+ * Recall state-view transition-has-successor guard (issue #1952 leftover).
+ *
+ * Pure. Surfaces wait. Transition without a successor is transition_missing_successor.
+ */
+
+export type AssertTransitionHasSuccessorInput = {
+  kind: string;
+  successorId?: string;
+};
+
+export type AssertTransitionHasSuccessorResult =
+  | { ok: true }
+  | { ok: false; error: "transition_missing_successor" };
+
+export function assertTransitionHasSuccessor(
+  input: AssertTransitionHasSuccessorInput,
+): AssertTransitionHasSuccessorResult {
+  const successorId = input.successorId?.trim() ?? "";
+  if (input.kind === "transition" && successorId.length === 0) {
+    return { ok: false, error: "transition_missing_successor" };
+  }
+  return { ok: true };
+}

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

@@ -0,0 +1,35 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import { checkAuthority } from "./authority.js";
+
+test("checkAuthority rejects a missing actor", () => {
+  assert.deepEqual(checkAuthority({ actor: "", required: "agent-a" }), {
+    ok: false,
+    error: "missing_actor",
+  });
+  assert.deepEqual(checkAuthority({ required: "agent-a" }), {
+    ok: false,
+    error: "missing_actor",
+  });
+  assert.deepEqual(checkAuthority({ actor: "   ", required: "agent-a" }), {
+    ok: false,
+    error: "missing_actor",
+  });
+});
+
+test("checkAuthority allows an empty required role", () => {
+  assert.deepEqual(checkAuthority({ actor: "agent-a", required: "" }), { ok: true });
+  assert.deepEqual(checkAuthority({ actor: "agent-a" }), { ok: true });
+});
+
+test("checkAuthority allows a matching actor", () => {
+  assert.deepEqual(checkAuthority({ actor: "agent-a", required: "agent-a" }), { ok: true });
+});
+
+test("checkAuthority rejects a mismatched actor", () => {
+  assert.deepEqual(checkAuthority({ actor: "agent-a", required: "agent-b" }), {
+    ok: false,
+    error: "forbidden",
+  });
+});

package/src/shared-context/authority.ts

@@ -0,0 +1,25 @@
+/**
+ * Shared-item actor authority (issue #1957).
+ *
+ * Pure helper. Empty required means no gate. Missing actor always fails.
+ */
+
+export type AuthorityCheckError = "missing_actor" | "forbidden";
+
+export type AuthorityCheck =
+  | { ok: true }
+  | { ok: false; error: AuthorityCheckError };
+
+export interface CheckAuthorityInput {
+  actor?: string;
+  required?: string;
+}
+
+export function checkAuthority(input: CheckAuthorityInput): AuthorityCheck {
+  const actor = input.actor?.trim() ?? "";
+  if (actor.length === 0) return { ok: false, error: "missing_actor" };
+  const required = input.required?.trim() ?? "";
+  if (required.length === 0) return { ok: true };
+  if (actor !== required) return { ok: false, error: "forbidden" };
+  return { ok: true };
+}

package/src/shared-context/claim-key.test.ts

@@ -0,0 +1,21 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { parseClaimKey } from "./claim-key.js";
+
+test("ok key returns trimmed key", () => {
+  assert.deepEqual(parseClaimKey("claim-a"), { ok: true, key: "claim-a" });
+});
+
+test("empty key is missing_key", () => {
+  assert.deepEqual(parseClaimKey(""), { ok: false, error: "missing_key" });
+  assert.deepEqual(parseClaimKey("   "), { ok: false, error: "missing_key" });
+});
+
+test("newline in key is invalid_key", () => {
+  assert.deepEqual(parseClaimKey("claim-a\nclaim-b"), { ok: false, error: "invalid_key" });
+});
+
+test("trims surrounding whitespace", () => {
+  assert.deepEqual(parseClaimKey("  claim-a  "), { ok: true, key: "claim-a" });
+});

package/src/shared-context/claim-key.ts

@@ -0,0 +1,16 @@
+/**
+ * Shared-context claim key parse (issue #1957 leftover).
+ *
+ * Pure. Empty is missing_key. Newline is invalid_key.
+ */
+
+export type ParseClaimKeyResult =
+  | { ok: true; key: string }
+  | { ok: false; error: "missing_key" | "invalid_key" };
+
+export function parseClaimKey(value: string): ParseClaimKeyResult {
+  const key = value.trim();
+  if (key.length === 0) return { ok: false, error: "missing_key" };
+  if (key.includes("\n")) return { ok: false, error: "invalid_key" };
+  return { ok: true, key };
+}

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

@@ -0,0 +1,39 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import {
+  detectContradictionPair,
+  type SharedClaimItem,
+} from "./contradictions.js";
+
+test("detectContradictionPair returns same for identical ids", () => {
+  const a: SharedClaimItem = { id: "item-1", claims: { host: "alpha" } };
+  const b: SharedClaimItem = { id: "item-1", claims: { host: "beta" } };
+
+  assert.deepEqual(detectContradictionPair(a, b), { kind: "same" });
+});
+
+test("detectContradictionPair returns conflict with the unequal overlapping keys", () => {
+  const a: SharedClaimItem = {
+    id: "item-1",
+    claims: { tier: "high", host: "alpha", region: "us" },
+  };
+  const b: SharedClaimItem = {
+    id: "item-2",
+    claims: { tier: "high", host: "beta", owner: "ops" },
+  };
+
+  assert.deepEqual(detectContradictionPair(a, b), {
+    kind: "conflict",
+    keys: ["host"],
+  });
+});
+
+test("detectContradictionPair returns none when overlap is absent or equal", () => {
+  const disjoint: SharedClaimItem = { id: "item-1", claims: { host: "alpha" } };
+  const other: SharedClaimItem = { id: "item-2", claims: { owner: "ops" } };
+  const agreeing: SharedClaimItem = { id: "item-3", claims: { host: "alpha" } };
+
+  assert.deepEqual(detectContradictionPair(disjoint, other), { kind: "none" });
+  assert.deepEqual(detectContradictionPair(disjoint, agreeing), { kind: "none" });
+});

package/src/shared-context/contradictions.ts

@@ -0,0 +1,32 @@
+/**
+ * Shared-item contradiction detection (issue #1957).
+ *
+ * Pure helper. Same-id items are one item; overlapping claim keys with
+ * unequal values are a conflict. No deletes, no persistence.
+ */
+
+export interface SharedClaimItem {
+  id: string;
+  claims: Record<string, string>;
+}
+
+export type ContradictionPairResult =
+  | { kind: "same" }
+  | { kind: "conflict"; keys: string[] }
+  | { kind: "none" };
+
+export function detectContradictionPair(
+  a: SharedClaimItem,
+  b: SharedClaimItem,
+): ContradictionPairResult {
+  if (a.id === b.id) {
+    return { kind: "same" };
+  }
+  const keys: string[] = [];
+  for (const key of Object.keys(a.claims)) {
+    if (key in b.claims && a.claims[key] !== b.claims[key]) {
+      keys.push(key);
+    }
+  }
+  return keys.length > 0 ? { kind: "conflict", keys: keys.sort() } : { kind: "none" };
+}

package/src/shared-context/envelope-actor.test.ts

@@ -0,0 +1,21 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { parseEnvelopeActor } from "./envelope-actor.js";
+
+test("ok actor returns trimmed actor", () => {
+  assert.deepEqual(parseEnvelopeActor("agent-a"), { ok: true, actor: "agent-a" });
+});
+
+test("empty actor is missing_actor", () => {
+  assert.deepEqual(parseEnvelopeActor(""), { ok: false, error: "missing_actor" });
+  assert.deepEqual(parseEnvelopeActor("   "), { ok: false, error: "missing_actor" });
+});
+
+test("newline in actor is invalid_actor", () => {
+  assert.deepEqual(parseEnvelopeActor("agent-a\nagent-b"), { ok: false, error: "invalid_actor" });
+});
+
+test("trims surrounding whitespace", () => {
+  assert.deepEqual(parseEnvelopeActor("  agent-a  "), { ok: true, actor: "agent-a" });
+});

package/src/shared-context/envelope-actor.ts

@@ -0,0 +1,16 @@
+/**
+ * Shared-item envelope actor parse (issue #1957 leftover).
+ *
+ * Pure. Empty is missing_actor. Newline is invalid_actor.
+ */
+
+export type ParseEnvelopeActorResult =
+  | { ok: true; actor: string }
+  | { ok: false; error: "missing_actor" | "invalid_actor" };
+
+export function parseEnvelopeActor(value: string): ParseEnvelopeActorResult {
+  const actor = value.trim();
+  if (actor.length === 0) return { ok: false, error: "missing_actor" };
+  if (actor.includes("\n")) return { ok: false, error: "invalid_actor" };
+  return { ok: true, actor };
+}

package/src/shared-context/envelope-at.test.ts

@@ -0,0 +1,19 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { parseEnvelopeAt } from "./envelope-at.js";
+
+const AT = "2026-08-18T12:00:00.000Z";
+
+test("ok at returns ISO string", () => {
+  assert.deepEqual(parseEnvelopeAt(AT), { ok: true, at: AT });
+});
+
+test("empty at is missing_at", () => {
+  assert.deepEqual(parseEnvelopeAt(""), { ok: false, error: "missing_at" });
+  assert.deepEqual(parseEnvelopeAt("   "), { ok: false, error: "missing_at" });
+});
+
+test("invalid at is invalid_at", () => {
+  assert.deepEqual(parseEnvelopeAt("not-a-date"), { ok: false, error: "invalid_at" });
+});

package/src/shared-context/envelope-at.ts

@@ -0,0 +1,17 @@
+/**
+ * Shared-item envelope at parse (issue #1957 leftover).
+ *
+ * Pure. Empty is missing_at. Invalid Date.parse is invalid_at.
+ */
+
+export type ParseEnvelopeAtResult =
+  | { ok: true; at: string }
+  | { ok: false; error: "missing_at" | "invalid_at" };
+
+export function parseEnvelopeAt(value: string): ParseEnvelopeAtResult {
+  const raw = value.trim();
+  if (raw.length === 0) return { ok: false, error: "missing_at" };
+  const ms = Date.parse(raw);
+  if (!Number.isFinite(ms)) return { ok: false, error: "invalid_at" };
+  return { ok: true, at: new Date(ms).toISOString() };
+}

package/src/shared-context/envelope-id.test.ts

@@ -0,0 +1,21 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { parseEnvelopeId } from "./envelope-id.js";
+
+test("ok id returns trimmed id", () => {
+  assert.deepEqual(parseEnvelopeId("item-a"), { ok: true, id: "item-a" });
+});
+
+test("empty id is missing_id", () => {
+  assert.deepEqual(parseEnvelopeId(""), { ok: false, error: "missing_id" });
+  assert.deepEqual(parseEnvelopeId("   "), { ok: false, error: "missing_id" });
+});
+
+test("newline in id is invalid_id", () => {
+  assert.deepEqual(parseEnvelopeId("item-a\nitem-b"), { ok: false, error: "invalid_id" });
+});
+
+test("trims surrounding whitespace", () => {
+  assert.deepEqual(parseEnvelopeId("  item-a  "), { ok: true, id: "item-a" });
+});

package/src/shared-context/envelope-id.ts

@@ -0,0 +1,16 @@
+/**
+ * Shared-item envelope id parse (issue #1957 leftover).
+ *
+ * Pure. Empty is missing_id. Newline is invalid_id.
+ */
+
+export type ParseEnvelopeIdResult =
+  | { ok: true; id: string }
+  | { ok: false; error: "missing_id" | "invalid_id" };
+
+export function parseEnvelopeId(value: string): ParseEnvelopeIdResult {
+  const id = value.trim();
+  if (id.length === 0) return { ok: false, error: "missing_id" };
+  if (id.includes("\n")) return { ok: false, error: "invalid_id" };
+  return { ok: true, id };
+}

package/src/shared-context/envelope-required.test.ts

@@ -0,0 +1,24 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { parseRequiredActor } from "./envelope-required.js";
+
+test("empty required actor is allowed", () => {
+  assert.deepEqual(parseRequiredActor(""), { ok: true, required: "" });
+  assert.deepEqual(parseRequiredActor("   "), { ok: true, required: "" });
+});
+
+test("ok required actor returns trimmed value", () => {
+  assert.deepEqual(parseRequiredActor("agent-a"), { ok: true, required: "agent-a" });
+});
+
+test("newline in required actor is invalid_required", () => {
+  assert.deepEqual(parseRequiredActor("agent-a\nagent-b"), {
+    ok: false,
+    error: "invalid_required",
+  });
+});
+
+test("trims surrounding whitespace", () => {
+  assert.deepEqual(parseRequiredActor("  agent-a  "), { ok: true, required: "agent-a" });
+});