"note": "Heuristic false-green LEADS, not findings. A finding requires a demonstrated reproduction (surviving mutation via mutation-runner). Do not treat a candidate as a confirmed false green. Coverage-theater leads may include tests that delegate their assertion to a custom helper the classifier does not recognise; verify before acting.",

  "sourceDigest": "sha256:dd810dd48c5bdbc9becd7fcc01dd41a4ca2abf0b2d6f6a545907247f6e3e8361",

  "summary": {

    "filesScanned": 2462,

    "filesScanned": 2464,

    "candidateCount": 16,

    "byMode": {

      "false_green_coverage_theater": 15,

{

  "schemaVersion": "1",

  "repository": "OpenAgentsInc/openagents",

  "sourceDigest": "sha256:0f196ae412fa4a0b3d7028db3535205a6051cd8c714835d7baf61e7fab70c6b5",

  "sourceDigest": "sha256:432d55f76eea481e2c0451fb1f2511fa7e93ec7ac0f709ccb0aaed7ed1fa912c",

  "surfaces": [

    {

      "id": "app:@openagentsinc/acceptance-runner",

      "oracles": [

        {

          "type": "test",

          "ref": "packages/openagents-cli (59 tracked test files)"

          "ref": "packages/openagents-cli (61 tracked test files)"

        },

        {

          "type": "behavior-contract",

    leak: "oa_live_abcdef0123456789",

    category: "oa_token",

  },

  {

    label: "oa_pat_ personal access token",

    raw: "the token is oa_pat_abc123def456ghi789jkl012 here",

    leak: "oa_pat_abc123def456",

    category: "oa_token",

  },

  {

    label: "X verification code",

    raw: "Code: oa-x-9f2bc-defG",

  },

  {

    category: "oa_token",

    pattern: /\boa_(?:live|test|sk|key|secret|tok|token)?_?[A-Za-z0-9]{12,}\b/g,

    pattern: /\boa_(?:live|test|sk|key|secret|tok|token|pat)?_?[A-Za-z0-9]{12,}\b/g,

    replace: () => tag("oa_token"),

  },

  {

# Vendored from packages/agent-experience-memory and packages/atif;

# kept byte-identical to the canonical sources (see scripts/vendor-memory.mjs),

# so the canonical formatting wins over this package's formatter.

src/memory/

#!/usr/bin/env node

/**

 * Vendor the agent-experience-memory modules the coder's memory runs on.

 *

 * The CLI ships standalone — `pnpm pack` and a global install with no

 * workspace around it — so it cannot carry a runtime dependency on the

 * unpublished workspace package. The canonical sources stay in

 * `packages/agent-experience-memory` and `packages/atif`; this script copies

 * the exact closure into `src/memory/` with only import specifiers rewritten.

 * `test/vendored-memory-drift.test.ts` re-runs the same transform and fails

 * when the vendored tree no longer matches the canonical sources, so the two

 * copies cannot drift silently.

 *

 * Run from the package root: `node scripts/vendor-memory.mjs`

 */

import { mkdirSync, readFileSync, writeFileSync } from "node:fs";

import { dirname, join } from "node:path";

import { fileURLToPath } from "node:url";

const packageRoot = join(dirname(fileURLToPath(import.meta.url)), "..");

const packagesRoot = join(packageRoot, "..");

/** source path (from packages/) → vendored name, with specifier rewrites. */

export const VENDORED = [

  ["atif/src/redaction.ts", "redaction.ts", [["./bip39-wordlist.ts", "./bip39-wordlist.js"]]],

  ["atif/src/bip39-wordlist.ts", "bip39-wordlist.ts", []],

  ["agent-experience-memory/src/internal/sha256.ts", "sha256.ts", []],

  ["agent-experience-memory/src/internal/canonical.ts", "canonical.ts", []],

  ["agent-experience-memory/src/contract/refs.ts", "refs.ts", []],

  ["agent-experience-memory/src/contract/pattern.ts", "pattern.ts", [["./refs.js", "./refs.js"]]],

  ["agent-experience-memory/src/ranking.ts", "ranking.ts", []],

  [

    "agent-experience-memory/src/engram.ts",

    "engram.ts",

    [

      ["@openagentsinc/atif/redaction", "./redaction.js"],

      ["./internal/canonical.js", "./canonical.js"],

      ["./internal/sha256.js", "./sha256.js"],

    ],

  ],

  [

    "agent-experience-memory/src/consolidation.ts",

    "consolidation.ts",

    [

      ["./contract/pattern.js", "./pattern.js"],

      ["./contract/refs.js", "./refs.js"],

      ["./internal/canonical.js", "./canonical.js"],

      ["./internal/sha256.js", "./sha256.js"],

    ],

  ],

  [

    "agent-experience-memory/src/subagent-memory.ts",

    "subagent-memory.ts",

    [

      ["./contract/pattern.js", "./pattern.js"],

      ["./contract/refs.js", "./refs.js"],

      ["./internal/canonical.js", "./canonical.js"],

      ["./internal/sha256.js", "./sha256.js"],

    ],

  ],

];

const HEADER = (source) =>

  `// Vendored from packages/${source} by scripts/vendor-memory.mjs — do not edit here.\n` +

  `// The drift guard (test/vendored-memory-drift.test.ts) fails when this copy\n` +

  `// no longer matches the canonical source.\n`;

/** The vendored text for one entry, derived from the canonical source. */

export const renderVendored = (source, rewrites) => {

  let text = readFileSync(join(packagesRoot, source), "utf8");

  for (const [from, to] of rewrites) {

    text = text.replaceAll(`"${from}"`, `"${to}"`);

  }

  return HEADER(source) + text;

};

const BARREL = `// The barrel coder-memory.ts consumes; regenerated by scripts/vendor-memory.mjs.

export * from "./engram.js";

export * from "./consolidation.js";

export * from "./subagent-memory.js";

`;

export const writeAll = () => {

  const out = join(packageRoot, "src", "memory");

  mkdirSync(out, { recursive: true });

  for (const [source, name, rewrites] of VENDORED) {

    writeFileSync(join(out, name), renderVendored(source, rewrites));

  }

  writeFileSync(join(out, "index.ts"), BARREL);

};

if (process.argv[1] === fileURLToPath(import.meta.url)) {

  writeAll();

  console.log(`vendored ${VENDORED.length} modules into src/memory/`);

}

  selfChildLane,

} from "./coder-delegate.js";

import { fleetPlainLines } from "./coder-fleet.js";

import { CoderMemory } from "./coder-memory.js";

import { runCoderPlain } from "./coder-plain.js";

import type { CoderDelegation } from "./coder-session.js";

import type { ReplySource } from "./coder-session.js";

  // children of two models still render as one fleet and stop together.

  const registry = new CoderTaskRegistry();

  // One memory for the session too: children inherit the parent's distilled

  // heuristics in their prompts, and what they report is harvested back into

  // the local engram ledger (openagents.com project 15, issues #226/#227).

  const memory = new CoderMemory({ projectScope: `project:${options.cwd}` });

  // Labelled by the name that was asked for. A caller who names `ox-alpha` and

  // is answered `x-preview-f-free` cannot tell whether the request was honoured

  // or silently fell back, and one that was asked exactly this said so rather

      fleet: new DelegateFleet(registry, harness, {

        maxConcurrent: Math.max(1, options.concurrency),

        cwd: options.cwd,

        memory,

      }),

      label: `${harness.agent} (${childLaneName(harness.model)})`,

    };

    const fleet = new DelegateFleet(registry, harness, {

      maxConcurrent: Math.max(1, options.concurrency),

      cwd: options.cwd,

      memory,

    });

    return {

  const fleet = new DelegateFleet(registry, harness, {

    maxConcurrent: Math.max(1, options.concurrency),

    cwd: options.cwd,

    memory,

  });

  return {

    delegation: {

    name: "ox-alpha",

    harness: "openagents (this process, one `shell` tool)",

    model: "Ox Alpha",

    served: "the OpenAgents inference proxy, routed to OpenRouter `stealth/ox-alpha`, on this session's thread grant",

    served:

      "the OpenAgents inference proxy, routed to OpenRouter `stealth/ox-alpha`, on this session's thread grant",

    bestFor: "work whose shape is the question: design, architecture, an open-ended refactor",

  },

  {

    // implies two models sends a caller here for the wrong reason.

    model: "Ox Alpha — the same model as `ox-alpha`, under opencode's name for it",

    served: "OpenCode Zen, on this machine's opencode credential",

    bestFor: "the same work as `ox-alpha`, when you want opencode's harness and tools instead of ours",

    bestFor:

      "the same work as `ox-alpha`, when you want opencode's harness and tools instead of ours",

  },

  {

    name: "gemini",

  return text.replace(/\x1b\[[0-9;]*[A-Za-z]/g, "");

}

import type { CoderDelegationMemory } from "./coder-memory.js";

export interface DelegateFleetOptions {

  /**

   * How many children may run at once.

  readonly transcriptDirectory?: string | undefined;

  /** The console's own directory, used when a request names none. */

  readonly cwd?: string | undefined;

  /**

   * The parent's memory, when the session carries one. `inherit` contributes

   * an advisory block to each child prompt; `harvest` records a completed

   * child's answer. Both are best-effort: memory never breaks a delegation.

   */

  readonly memory?: CoderDelegationMemory | undefined;

}

/**

    }

    const cwd = request.cwd ?? this.options.cwd ?? process.cwd();

    // Inherited memory rides the prompt itself, so every harness — a shell

    // child, Devin over ACP, an opencode lane — carries it the same way.

    let inherited = "";

    try {

      inherited = this.options.memory?.inherit(request.prompt) ?? "";

    } catch {

      inherited = "";

    }

    const prompt = inherited.length > 0 ? `${request.prompt}\n\n${inherited}` : request.prompt;

    // Registered before it can queue, so a child waiting for a slot is visible

    // as `pending` rather than as nothing at all.

    const task = this.registry.register({

      id: this.mintId(),

      description: request.description.trim().length > 0 ? request.description : "delegated task",

      prompt: request.prompt,

      prompt,

      agent: this.harness.agent,

      model: this.harness.model,

      cwd,

    this.active += 1;

    try {

      return await this.execute(task.id, request, cwd);

      return await this.execute(task.id, { ...request, prompt }, cwd);

    } finally {

      this.active -= 1;

      this.waiting.shift()?.();

      const failure = reported ?? thrown;

      if (failure === undefined) {

        this.registry.complete(id, text);

        try {

          this.options.memory?.harvest(id, text);

        } catch {

          // Memory must never turn a completed child into a failed one.

        }

        return { status: "completed", taskId: id, result: text };

      }

import { createHmac, randomBytes } from "node:crypto";

import {

  appendFileSync,

  chmodSync,

  existsSync,

  mkdirSync,

  readFileSync,

  writeFileSync,

} from "node:fs";

import { homedir } from "node:os";

import { join } from "node:path";

import {

  buildEngramBody,

  buildEngramEvent,

  buildSubagentMemoryContext,

  consolidateEpisodes,

  engramContentDigest,

  guardEngramContent,

  harvestSubagentOutcome,

  ledgerEntriesAsHeuristics,

  promoteHeuristicToPattern,

  signSupersedingEngram,

  verifyEngramEventId,

  verifySupersessionChain,

  HarvestedLedgerEntry,

  type EngramEvent,

  type EngramBody,

  type ParentHeuristic,

} from "./memory/index.js";

import { Schema as S } from "effect";

/**

 * The coder's own memory: a local, append-only ledger of signed engrams.

 *

 * This is the live wiring of the agent-continuity program (openagents.com

 * project 15): what a delegated child learns is harvested into the parent's

 * ledger (#227), and what the parent knows seeds the next child's prompt as a

 * bounded advisory block (#226). Between sessions the ledger is the memory —

 * one JSONL file of NIP-AE-shaped engram events under `~/.openagents/memory`,

 * every value through the hard-unsafe redaction gate before it is signed, and

 * every read re-verifying event ids and supersession chains.

 *

 * The signature is a local HMAC over the canonical event id with a key held at

 * `~/.openagents/memory/signing-key` (0600) — integrity against accidental

 * edits and a stable authorship mark for this machine, not a Nostr Schnorr

 * signature. When the relay sync adapter (#222) lands, the same events re-sign

 * under a real Nostr key; the body and chain shapes are already NIP-AE.

 */

const decodeLedgerEntry = S.decodeUnknownSync(HarvestedLedgerEntry);

/** What the delegate fleet asks of memory, kept small so the fleet stays dumb. */

export interface CoderDelegationMemory {

  /** The advisory block to append to a child prompt, or empty when nothing qualifies. */

  inherit(taskText: string): string;

  /** Record a completed child's answer into the ledger. Never throws. */

  harvest(childId: string, answer: string): void;

}

export interface CoderMemoryOptions {

  /** Ledger directory. Default `~/.openagents/memory`. */

  readonly directory?: string;

  /** The project scope written into harvested entries. Default derived from cwd. */

  readonly projectScope?: string;

  /** Epoch-milliseconds clock, injectable for tests. */

  readonly now?: () => number;

}

const OWNER_SCOPE = "owner:local";

const sanitizeScope = (value: string): string => {

  const cleaned = value.replace(/[^A-Za-z0-9._:/-]+/g, "-").replace(/^[^A-Za-z0-9]+/, "");

  return cleaned.length > 0 ? cleaned.slice(0, 200) : "project";

};

export class CoderMemory implements CoderDelegationMemory {

  private readonly directory: string;

  private readonly ledgerPath: string;

  private readonly keyPath: string;

  private readonly projectScope: string;

  private readonly now: () => number;

  private key: Buffer | undefined;

  constructor(options: CoderMemoryOptions = {}) {

    this.directory = options.directory ?? join(homedir(), ".openagents", "memory");

    this.ledgerPath = join(this.directory, "engrams.jsonl");

    this.keyPath = join(this.directory, "signing-key");

    this.projectScope = sanitizeScope(options.projectScope ?? `project:${process.cwd()}`);

    this.now = options.now ?? Date.now;

  }

  /** The local signing key, created on first use. */

  private signingKey(): Buffer {

    if (this.key !== undefined) return this.key;

    mkdirSync(this.directory, { recursive: true, mode: 0o700 });

    if (!existsSync(this.keyPath)) {

      writeFileSync(this.keyPath, randomBytes(32).toString("hex"), { mode: 0o600 });

      chmodSync(this.keyPath, 0o600);

    }

    this.key = Buffer.from(readFileSync(this.keyPath, "utf8").trim(), "hex");

    return this.key;

  }

  private signer(): { pubkey: string; sign: (eventId: string) => string } {

    const key = this.signingKey();

    // A stable 64-hex identity derived from the key, so events from the same

    // machine share an author without the key itself ever leaving the file.

    const pubkey = createHmac("sha256", key).update("openagents.coder-memory.pubkey").digest("hex");

    return {

      pubkey,

      sign: (eventId: string) => createHmac("sha256", key).update(eventId).digest("hex"),

    };

  }

  /**

   * Guard, build, sign, and append one engram. Returns the event, or undefined

   * when the value is hard-unsafe (credential-shaped material never persists).

   */

  record(slug: string, value: string | null, entityId: string): EngramEvent | undefined {

    const verdict = guardEngramContent(value);

    if (!verdict.storable) return undefined;

    const body = buildEngramBody(slug, verdict.redacted, {

      admission: "admitted",

      entityId,

      contentDigest: engramContentDigest(verdict.redacted),

      sourceEventRefs: [],

      relations: [],

      derivedFromSlugs: [],

    });

    const { pubkey, sign } = this.signer();

    const event = buildEngramEvent(

      pubkey,

      Math.floor(this.now() / 1000),

      slug,

      JSON.stringify(body),

      sign,

    );

    appendFileSync(this.ledgerPath, `${JSON.stringify(event)}\n`, { mode: 0o600 });

    return event;

  }

  /**

   * Correct a remembered value: append a superseding engram referencing the

   * prior event. The prior event stays in the ledger; reads resolve the chain.

   * Pass `null` to tombstone the slug.

   */

  correct(slug: string, newValue: string | null): EngramEvent | undefined {

    const chain = this.chains().get(slug);

    const prior = chain?.[chain.length - 1];

    if (prior === undefined) return undefined;

    const verdict = guardEngramContent(newValue);

    if (!verdict.storable) return undefined;

    const { pubkey, sign } = this.signer();

    const event = signSupersedingEngram(

      prior,

      verdict.redacted,

      Math.max(Math.floor(this.now() / 1000), prior.created_at + 1),

      pubkey,

      sign,

    );

    appendFileSync(this.ledgerPath, `${JSON.stringify(event)}\n`, { mode: 0o600 });

    return event;

  }

  /** All ledger events grouped per slug in append order, invalid lines dropped. */

  private chains(): Map<string, Array<EngramEvent>> {

    const chains = new Map<string, Array<EngramEvent>>();

    if (!existsSync(this.ledgerPath)) return chains;

    for (const line of readFileSync(this.ledgerPath, "utf8").split("\n")) {

      if (line.trim().length === 0) continue;

      let event: EngramEvent;

      try {

        event = JSON.parse(line) as EngramEvent;

      } catch {

        continue;

      }

      if (!verifyEngramEventId(event)) continue;

      const dTag = event.tags.find((tag) => tag[0] === "d")?.[1];

      if (dTag === undefined) continue;

      const chain = chains.get(dTag) ?? [];

      chain.push(event);

      chains.set(dTag, chain);

    }

    return chains;

  }

  /**

   * The live value per slug: each chain verified end to end, the newest body

   * winning, tombstoned and broken chains dropped entirely — a chain that does

   * not verify is not memory, it is noise.

   */

  bodies(): ReadonlyArray<EngramBody> {

    return this.living().map((entry) => entry.body);

  }

  private living(): ReadonlyArray<{ body: EngramBody; createdAtMs: number }> {

    const out: Array<{ body: EngramBody; createdAtMs: number }> = [];

    for (const chain of this.chains().values()) {

      if (!verifySupersessionChain(chain)) continue;

      const last = chain[chain.length - 1];

      if (last === undefined) continue;

      let body: EngramBody;

      try {

        body = JSON.parse(last.content) as EngramBody;

      } catch {

        continue;

      }

      if (body.value === null) continue;

      out.push({ body, createdAtMs: last.created_at * 1000 });

    }

    return out;

  }

  /**

   * The harvested ledger entries currently alive in the engram stream.

   *

   * The ledger stores only the redacted finding text — a typed entry carries

   * 64-hex digests, and the redaction gate rightly refuses hex of that shape

   * as key-shaped material — so the typed entry is rebuilt deterministically

   * from the finding, the child id, and the event time on every read.

   */

  entries(): ReadonlyArray<HarvestedLedgerEntry> {

    const entries: Array<HarvestedLedgerEntry> = [];

    for (const { body, createdAtMs } of this.living()) {

      if (!body.slug.startsWith("harvest/") || body.value === null) continue;

      const rebuilt = harvestSubagentOutcome({

        ownerScope: OWNER_SCOPE,

        projectScope: this.projectScope,

        outcome: {

          childId: body.openagents.entityId,

          summary: body.value,

          completedAtMs: createdAtMs,

        },

      });

      for (const entry of rebuilt.entries) {

        entries.push(decodeLedgerEntry(entry));

      }

    }

    return entries;

  }

  /**

   * The parent's heuristics: harvested findings at the harvest confidence

   * floor, plus what one dreaming pass distills from them — clusters of

   * related findings synthesized and, where support is strong enough,

   * promoted through the reviewed pattern layer at higher confidence.

   */

  heuristics(): ReadonlyArray<ParentHeuristic> {

    const entries = this.entries();

    const base = ledgerEntriesAsHeuristics(entries);

    const consolidated = consolidateEpisodes({

      ownerScope: OWNER_SCOPE,

      projectScope: this.projectScope,

      episodes: entries.map((entry) => ({

        ref: entry.entryId,

        text: entry.finding,

        observedAtMs: Date.parse(entry.completedAt),

      })),

      nowMs: this.now(),

    });

    const promoted = consolidated.heuristics.map((heuristic): ParentHeuristic => {

      const pattern = promoteHeuristicToPattern(

        heuristic,

        "delegating a coding task like the ones this heuristic came from",

      );

      return {

        ref: pattern.patternRef,

        text: heuristic.heuristic,

        confidence: heuristic.confidence,

      };

    });

    return [...promoted, ...base];

  }

  inherit(taskText: string): string {

    try {

      const heuristics = this.heuristics();

      if (heuristics.length === 0) return "";

      return buildSubagentMemoryContext({ heuristics, taskText }).block;

    } catch {

      // Memory must never break a delegation.

      return "";

    }

  }

  harvest(childId: string, answer: string): void {

    try {

      const trimmed = answer.trim();

      if (trimmed.length === 0) return;

      const harvested = harvestSubagentOutcome({

        ownerScope: OWNER_SCOPE,

        projectScope: this.projectScope,

        outcome: {

          childId,

          summary: trimmed.slice(0, 1000),

          completedAtMs: this.now(),

        },

      });

      for (const entry of harvested.entries) {

        this.record(`harvest/${entry.digest.slice(7, 19)}`, entry.finding, entry.childId);

      }

    } catch {

      // Memory must never break a delegation.

    }

  }

}

// Vendored from packages/atif/src/bip39-wordlist.ts by scripts/vendor-memory.mjs — do not edit here.

// The drift guard (test/vendored-memory-drift.test.ts) fails when this copy

// no longer matches the canonical source.

// BIP39 English wordlist (2048 words), embedded so the mnemonic redactor can

// verify a candidate word-run is an ACTUAL seed phrase (every word in the list)

// rather than ordinary prose. Kept dependency-free on purpose: this is static

// reference data, not a runtime dependency. Source: the canonical BIP39 English

// wordlist (as shipped by @scure/bip39). Do not reorder or edit by hand.

export const BIP39_ENGLISH_WORDS: ReadonlySet<string> = new Set([

  "abandon", "ability", "able", "about", "above", "absent", "absorb", "abstract",

  "absurd", "abuse", "access", "accident", "account", "accuse", "achieve", "acid",

  "acoustic", "acquire", "across", "act", "action", "actor", "actress", "actual",

  "adapt", "add", "addict", "address", "adjust", "admit", "adult", "advance",

  "advice", "aerobic", "affair", "afford", "afraid", "again", "age", "agent",

  "agree", "ahead", "aim", "air", "airport", "aisle", "alarm", "album",

  "alcohol", "alert", "alien", "all", "alley", "allow", "almost", "alone",

  "alpha", "already", "also", "alter", "always", "amateur", "amazing", "among",

  "amount", "amused", "analyst", "anchor", "ancient", "anger", "angle", "angry",

  "animal", "ankle", "announce", "annual", "another", "answer", "antenna", "antique",

  "anxiety", "any", "apart", "apology", "appear", "apple", "approve", "april",

  "arch", "arctic", "area", "arena", "argue", "arm", "armed", "armor",

  "army", "around", "arrange", "arrest", "arrive", "arrow", "art", "artefact",

  "artist", "artwork", "ask", "aspect", "assault", "asset", "assist", "assume",

  "asthma", "athlete", "atom", "attack", "attend", "attitude", "attract", "auction",

  "audit", "august", "aunt", "author", "auto", "autumn", "average", "avocado",

  "avoid", "awake", "aware", "away", "awesome", "awful", "awkward", "axis",

  "baby", "bachelor", "bacon", "badge", "bag", "balance", "balcony", "ball",

  "bamboo", "banana", "banner", "bar", "barely", "bargain", "barrel", "base",

  "basic", "basket", "battle", "beach", "bean", "beauty", "because", "become",

  "beef", "before", "begin", "behave", "behind", "believe", "below", "belt",

  "bench", "benefit", "best", "betray", "better", "between", "beyond", "bicycle",

  "bid", "bike", "bind", "biology", "bird", "birth", "bitter", "black",

  "blade", "blame", "blanket", "blast", "bleak", "bless", "blind", "blood",

  "blossom", "blouse", "blue", "blur", "blush", "board", "boat", "body",

  "boil", "bomb", "bone", "bonus", "book", "boost", "border", "boring",

  "borrow", "boss", "bottom", "bounce", "box", "boy", "bracket", "brain",

  "brand", "brass", "brave", "bread", "breeze", "brick", "bridge", "brief",

  "bright", "bring", "brisk", "broccoli", "broken", "bronze", "broom", "brother",

  "brown", "brush", "bubble", "buddy", "budget", "buffalo", "build", "bulb",

  "bulk", "bullet", "bundle", "bunker", "burden", "burger", "burst", "bus",

  "business", "busy", "butter", "buyer", "buzz", "cabbage", "cabin", "cable",

  "cactus", "cage", "cake", "call", "calm", "camera", "camp", "can",

  "canal", "cancel", "candy", "cannon", "canoe", "canvas", "canyon", "capable",

  "capital", "captain", "car", "carbon", "card", "cargo", "carpet", "carry",

  "cart", "case", "cash", "casino", "castle", "casual", "cat", "catalog",

  "catch", "category", "cattle", "caught", "cause", "caution", "cave", "ceiling",

  "celery", "cement", "census", "century", "cereal", "certain", "chair", "chalk",

  "champion", "change", "chaos", "chapter", "charge", "chase", "chat", "cheap",

  "check", "cheese", "chef", "cherry", "chest", "chicken", "chief", "child",

  "chimney", "choice", "choose", "chronic", "chuckle", "chunk", "churn", "cigar",

  "cinnamon", "circle", "citizen", "city", "civil", "claim", "clap", "clarify",

  "claw", "clay", "clean", "clerk", "clever", "click", "client", "cliff",

  "climb", "clinic", "clip", "clock", "clog", "close", "cloth", "cloud",

  "clown", "club", "clump", "cluster", "clutch", "coach", "coast", "coconut",

  "code", "coffee", "coil", "coin", "collect", "color", "column", "combine",

  "come", "comfort", "comic", "common", "company", "concert", "conduct", "confirm",

  "congress", "connect", "consider", "control", "convince", "cook", "cool", "copper",

  "copy", "coral", "core", "corn", "correct", "cost", "cotton", "couch",

  "country", "couple", "course", "cousin", "cover", "coyote", "crack", "cradle",

  "craft", "cram", "crane", "crash", "crater", "crawl", "crazy", "cream",

  "credit", "creek", "crew", "cricket", "crime", "crisp", "critic", "crop",

  "cross", "crouch", "crowd", "crucial", "cruel", "cruise", "crumble", "crunch",

  "crush", "cry", "crystal", "cube", "culture", "cup", "cupboard", "curious",

  "current", "curtain", "curve", "cushion", "custom", "cute", "cycle", "dad",

  "damage", "damp", "dance", "danger", "daring", "dash", "daughter", "dawn",

  "day", "deal", "debate", "debris", "decade", "december", "decide", "decline",

  "decorate", "decrease", "deer", "defense", "define", "defy", "degree", "delay",

  "deliver", "demand", "demise", "denial", "dentist", "deny", "depart", "depend",

  "deposit", "depth", "deputy", "derive", "describe", "desert", "design", "desk",

  "despair", "destroy", "detail", "detect", "develop", "device", "devote", "diagram",

  "dial", "diamond", "diary", "dice", "diesel", "diet", "differ", "digital",

  "dignity", "dilemma", "dinner", "dinosaur", "direct", "dirt", "disagree", "discover",

  "disease", "dish", "dismiss", "disorder", "display", "distance", "divert", "divide",

  "divorce", "dizzy", "doctor", "document", "dog", "doll", "dolphin", "domain",

  "donate", "donkey", "donor", "door", "dose", "double", "dove", "draft",

  "dragon", "drama", "drastic", "draw", "dream", "dress", "drift", "drill",

  "drink", "drip", "drive", "drop", "drum", "dry", "duck", "dumb",

  "dune", "during", "dust", "dutch", "duty", "dwarf", "dynamic", "eager",

  "eagle", "early", "earn", "earth", "easily", "east", "easy", "echo",

  "ecology", "economy", "edge", "edit", "educate", "effort", "egg", "eight",

  "either", "elbow", "elder", "electric", "elegant", "element", "elephant", "elevator",

  "elite", "else", "embark", "embody", "embrace", "emerge", "emotion", "employ",

  "empower", "empty", "enable", "enact", "end", "endless", "endorse", "enemy",

  "energy", "enforce", "engage", "engine", "enhance", "enjoy", "enlist", "enough",

  "enrich", "enroll", "ensure", "enter", "entire", "entry", "envelope", "episode",

  "equal", "equip", "era", "erase", "erode", "erosion", "error", "erupt",

  "escape", "essay", "essence", "estate", "eternal", "ethics", "evidence", "evil",

  "evoke", "evolve", "exact", "example", "excess", "exchange", "excite", "exclude",

  "excuse", "execute", "exercise", "exhaust", "exhibit", "exile", "exist", "exit",

  "exotic", "expand", "expect", "expire", "explain", "expose", "express", "extend",

  "extra", "eye", "eyebrow", "fabric", "face", "faculty", "fade", "faint",

  "faith", "fall", "false", "fame", "family", "famous", "fan", "fancy",

  "fantasy", "farm", "fashion", "fat", "fatal", "father", "fatigue", "fault",

  "favorite", "feature", "february", "federal", "fee", "feed", "feel", "female",

  "fence", "festival", "fetch", "fever", "few", "fiber", "fiction", "field",

  "figure", "file", "film", "filter", "final", "find", "fine", "finger",

  "finish", "fire", "firm", "first", "fiscal", "fish", "fit", "fitness",

  "fix", "flag", "flame", "flash", "flat", "flavor", "flee", "flight",

  "flip", "float", "flock", "floor", "flower", "fluid", "flush", "fly",

  "foam", "focus", "fog", "foil", "fold", "follow", "food", "foot",

  "force", "forest", "forget", "fork", "fortune", "forum", "forward", "fossil",

  "foster", "found", "fox", "fragile", "frame", "frequent", "fresh", "friend",

  "fringe", "frog", "front", "frost", "frown", "frozen", "fruit", "fuel",

  "fun", "funny", "furnace", "fury", "future", "gadget", "gain", "galaxy",

  "gallery", "game", "gap", "garage", "garbage", "garden", "garlic", "garment",

  "gas", "gasp", "gate", "gather", "gauge", "gaze", "general", "genius",

  "genre", "gentle", "genuine", "gesture", "ghost", "giant", "gift", "giggle",

  "ginger", "giraffe", "girl", "give", "glad", "glance", "glare", "glass",

  "glide", "glimpse", "globe", "gloom", "glory", "glove", "glow", "glue",

  "goat", "goddess", "gold", "good", "goose", "gorilla", "gospel", "gossip",

  "govern", "gown", "grab", "grace", "grain", "grant", "grape", "grass",

  "gravity", "great", "green", "grid", "grief", "grit", "grocery", "group",

  "grow", "grunt", "guard", "guess", "guide", "guilt", "guitar", "gun",

  "gym", "habit", "hair", "half", "hammer", "hamster", "hand", "happy",

  "harbor", "hard", "harsh", "harvest", "hat", "have", "hawk", "hazard",

  "head", "health", "heart", "heavy", "hedgehog", "height", "hello", "helmet",

  "help", "hen", "hero", "hidden", "high", "hill", "hint", "hip",

  "hire", "history", "hobby", "hockey", "hold", "hole", "holiday", "hollow",

  "home", "honey", "hood", "hope", "horn", "horror", "horse", "hospital",

  "host", "hotel", "hour", "hover", "hub", "huge", "human", "humble",

  "humor", "hundred", "hungry", "hunt", "hurdle", "hurry", "hurt", "husband",

  "hybrid", "ice", "icon", "idea", "identify", "idle", "ignore", "ill",

  "illegal", "illness", "image", "imitate", "immense", "immune", "impact", "impose",

  "improve", "impulse", "inch", "include", "income", "increase", "index", "indicate",

  "indoor", "industry", "infant", "inflict", "inform", "inhale", "inherit", "initial",

  "inject", "injury", "inmate", "inner", "innocent", "input", "inquiry", "insane",

  "insect", "inside", "inspire", "install", "intact", "interest", "into", "invest",

  "invite", "involve", "iron", "island", "isolate", "issue", "item", "ivory",

  "jacket", "jaguar", "jar", "jazz", "jealous", "jeans", "jelly", "jewel",

  "job", "join", "joke", "journey", "joy", "judge", "juice", "jump",

  "jungle", "junior", "junk", "just", "kangaroo", "keen", "keep", "ketchup",

  "key", "kick", "kid", "kidney", "kind", "kingdom", "kiss", "kit",

  "kitchen", "kite", "kitten", "kiwi", "knee", "knife", "knock", "know",

  "lab", "label", "labor", "ladder", "lady", "lake", "lamp", "language",

  "laptop", "large", "later", "latin", "laugh", "laundry", "lava", "law",

  "lawn", "lawsuit", "layer", "lazy", "leader", "leaf", "learn", "leave",

  "lecture", "left", "leg", "legal", "legend", "leisure", "lemon", "lend",

  "length", "lens", "leopard", "lesson", "letter", "level", "liar", "liberty",

  "library", "license", "life", "lift", "light", "like", "limb", "limit",

  "link", "lion", "liquid", "list", "little", "live", "lizard", "load",

  "loan", "lobster", "local", "lock", "logic", "lonely", "long", "loop",

  "lottery", "loud", "lounge", "love", "loyal", "lucky", "luggage", "lumber",

  "lunar", "lunch", "luxury", "lyrics", "machine", "mad", "magic", "magnet",

  "maid", "mail", "main", "major", "make", "mammal", "man", "manage",

  "mandate", "mango", "mansion", "manual", "maple", "marble", "march", "margin",

  "marine", "market", "marriage", "mask", "mass", "master", "match", "material",

  "math", "matrix", "matter", "maximum", "maze", "meadow", "mean", "measure",

  "meat", "mechanic", "medal", "media", "melody", "melt", "member", "memory",

  "mention", "menu", "mercy", "merge", "merit", "merry", "mesh", "message",

  "metal", "method", "middle", "midnight", "milk", "million", "mimic", "mind",

  "minimum", "minor", "minute", "miracle", "mirror", "misery", "miss", "mistake",

  "mix", "mixed", "mixture", "mobile", "model", "modify", "mom", "moment",

  "monitor", "monkey", "monster", "month", "moon", "moral", "more", "morning",

  "mosquito", "mother", "motion", "motor", "mountain", "mouse", "move", "movie",

  "much", "muffin", "mule", "multiply", "muscle", "museum", "mushroom", "music",

  "must", "mutual", "myself", "mystery", "myth", "naive", "name", "napkin",

  "narrow", "nasty", "nation", "nature", "near", "neck", "need", "negative",

  "neglect", "neither", "nephew", "nerve", "nest", "net", "network", "neutral",

  "never", "news", "next", "nice", "night", "noble", "noise", "nominee",

  "noodle", "normal", "north", "nose", "notable", "note", "nothing", "notice",

  "novel", "now", "nuclear", "number", "nurse", "nut", "oak", "obey",

  "object", "oblige", "obscure", "observe", "obtain", "obvious", "occur", "ocean",

  "october", "odor", "off", "offer", "office", "often", "oil", "okay",

  "old", "olive", "olympic", "omit", "once", "one", "onion", "online",

  "only", "open", "opera", "opinion", "oppose", "option", "orange", "orbit",

  "orchard", "order", "ordinary", "organ", "orient", "original", "orphan", "ostrich",

  "other", "outdoor", "outer", "output", "outside", "oval", "oven", "over",

  "own", "owner", "oxygen", "oyster", "ozone", "pact", "paddle", "page",

  "pair", "palace", "palm", "panda", "panel", "panic", "panther", "paper",

  "parade", "parent", "park", "parrot", "party", "pass", "patch", "path",

  "patient", "patrol", "pattern", "pause", "pave", "payment", "peace", "peanut",

  "pear", "peasant", "pelican", "pen", "penalty", "pencil", "people", "pepper",

  "perfect", "permit", "person", "pet", "phone", "photo", "phrase", "physical",

  "piano", "picnic", "picture", "piece", "pig", "pigeon", "pill", "pilot",

  "pink", "pioneer", "pipe", "pistol", "pitch", "pizza", "place", "planet",

  "plastic", "plate", "play", "please", "pledge", "pluck", "plug", "plunge",

  "poem", "poet", "point", "polar", "pole", "police", "pond", "pony",

  "pool", "popular", "portion", "position", "possible", "post", "potato", "pottery",

  "poverty", "powder", "power", "practice", "praise", "predict", "prefer", "prepare",

  "present", "pretty", "prevent", "price", "pride", "primary", "print", "priority",

  "prison", "private", "prize", "problem", "process", "produce", "profit", "program",

  "project", "promote", "proof", "property", "prosper", "protect", "proud", "provide",

  "public", "pudding", "pull", "pulp", "pulse", "pumpkin", "punch", "pupil",

  "puppy", "purchase", "purity", "purpose", "purse", "push", "put", "puzzle",

  "pyramid", "quality", "quantum", "quarter", "question", "quick", "quit", "quiz",

  "quote", "rabbit", "raccoon", "race", "rack", "radar", "radio", "rail",

  "rain", "raise", "rally", "ramp", "ranch", "random", "range", "rapid",

  "rare", "rate", "rather", "raven", "raw", "razor", "ready", "real",

  "reason", "rebel", "rebuild", "recall", "receive", "recipe", "record", "recycle",

  "reduce", "reflect", "reform", "refuse", "region", "regret", "regular", "reject",

  "relax", "release", "relief", "rely", "remain", "remember", "remind", "remove",

  "render", "renew", "rent", "reopen", "repair", "repeat", "replace", "report",

  "require", "rescue", "resemble", "resist", "resource", "response", "result", "retire",

  "retreat", "return", "reunion", "reveal", "review", "reward", "rhythm", "rib",

  "ribbon", "rice", "rich", "ride", "ridge", "rifle", "right", "rigid",

  "ring", "riot", "ripple", "risk", "ritual", "rival", "river", "road",

  "roast", "robot", "robust", "rocket", "romance", "roof", "rookie", "room",

  "rose", "rotate", "rough", "round", "route", "royal", "rubber", "rude",

  "rug", "rule", "run", "runway", "rural", "sad", "saddle", "sadness",

  "safe", "sail", "salad", "salmon", "salon", "salt", "salute", "same",

  "sample", "sand", "satisfy", "satoshi", "sauce", "sausage", "save", "say",

  "scale", "scan", "scare", "scatter", "scene", "scheme", "school", "science",

  "scissors", "scorpion", "scout", "scrap", "screen", "script", "scrub", "sea",

  "search", "season", "seat", "second", "secret", "section", "security", "seed",

  "seek", "segment", "select", "sell", "seminar", "senior", "sense", "sentence",

  "series", "service", "session", "settle", "setup", "seven", "shadow", "shaft",

  "shallow", "share", "shed", "shell", "sheriff", "shield", "shift", "shine",

  "ship", "shiver", "shock", "shoe", "shoot", "shop", "short", "shoulder",

  "shove", "shrimp", "shrug", "shuffle", "shy", "sibling", "sick", "side",

  "siege", "sight", "sign", "silent", "silk", "silly", "silver", "similar",

  "simple", "since", "sing", "siren", "sister", "situate", "six", "size",

  "skate", "sketch", "ski", "skill", "skin", "skirt", "skull", "slab",

  "slam", "sleep", "slender", "slice", "slide", "slight", "slim", "slogan",

  "slot", "slow", "slush", "small", "smart", "smile", "smoke", "smooth",

  "snack", "snake", "snap", "sniff", "snow", "soap", "soccer", "social",

  "sock", "soda", "soft", "solar", "soldier", "solid", "solution", "solve",

  "someone", "song", "soon", "sorry", "sort", "soul", "sound", "soup",

  "source", "south", "space", "spare", "spatial", "spawn", "speak", "special",

  "speed", "spell", "spend", "sphere", "spice", "spider", "spike", "spin",

  "spirit", "split", "spoil", "sponsor", "spoon", "sport", "spot", "spray",

  "spread", "spring", "spy", "square", "squeeze", "squirrel", "stable", "stadium",

  "staff", "stage", "stairs", "stamp", "stand", "start", "state", "stay",

  "steak", "steel", "stem", "step", "stereo", "stick", "still", "sting",

  "stock", "stomach", "stone", "stool", "story", "stove", "strategy", "street",

  "strike", "strong", "struggle", "student", "stuff", "stumble", "style", "subject",

  "submit", "subway", "success", "such", "sudden", "suffer", "sugar", "suggest",

  "suit", "summer", "sun", "sunny", "sunset", "super", "supply", "supreme",

  "sure", "surface", "surge", "surprise", "surround", "survey", "suspect", "sustain",

  "swallow", "swamp", "swap", "swarm", "swear", "sweet", "swift", "swim",

  "swing", "switch", "sword", "symbol", "symptom", "syrup", "system", "table",

  "tackle", "tag", "tail", "talent", "talk", "tank", "tape", "target",

  "task", "taste", "tattoo", "taxi", "teach", "team", "tell", "ten",

  "tenant", "tennis", "tent", "term", "test", "text", "thank", "that",

  "theme", "then", "theory", "there", "they", "thing", "this", "thought",

  "three", "thrive", "throw", "thumb", "thunder", "ticket", "tide", "tiger",

  "tilt", "timber", "time", "tiny", "tip", "tired", "tissue", "title",

  "toast", "tobacco", "today", "toddler", "toe", "together", "toilet", "token",

  "tomato", "tomorrow", "tone", "tongue", "tonight", "tool", "tooth", "top",

  "topic", "topple", "torch", "tornado", "tortoise", "toss", "total", "tourist",

  "toward", "tower", "town", "toy", "track", "trade", "traffic", "tragic",

  "train", "transfer", "trap", "trash", "travel", "tray", "treat", "tree",

  "trend", "trial", "tribe", "trick", "trigger", "trim", "trip", "trophy",

  "trouble", "truck", "true", "truly", "trumpet", "trust", "truth", "try",

  "tube", "tuition", "tumble", "tuna", "tunnel", "turkey", "turn", "turtle",

  "twelve", "twenty", "twice", "twin", "twist", "two", "type", "typical",

  "ugly", "umbrella", "unable", "unaware", "uncle", "uncover", "under", "undo",

  "unfair", "unfold", "unhappy", "uniform", "unique", "unit", "universe", "unknown",

  "unlock", "until", "unusual", "unveil", "update", "upgrade", "uphold", "upon",

  "upper", "upset", "urban", "urge", "usage", "use", "used", "useful",

  "useless", "usual", "utility", "vacant", "vacuum", "vague", "valid", "valley",

  "valve", "van", "vanish", "vapor", "various", "vast", "vault", "vehicle",

  "velvet", "vendor", "venture", "venue", "verb", "verify", "version", "very",

  "vessel", "veteran", "viable", "vibrant", "vicious", "victory", "video", "view",

  "village", "vintage", "violin", "virtual", "virus", "visa", "visit", "visual",

  "vital", "vivid", "vocal", "voice", "void", "volcano", "volume", "vote",

  "voyage", "wage", "wagon", "wait", "walk", "wall", "walnut", "want",

  "warfare", "warm", "warrior", "wash", "wasp", "waste", "water", "wave",

  "way", "wealth", "weapon", "wear", "weasel", "weather", "web", "wedding",

  "weekend", "weird", "welcome", "west", "wet", "whale", "what", "wheat",

  "wheel", "when", "where", "whip", "whisper", "wide", "width", "wife",

  "wild", "will", "win", "window", "wine", "wing", "wink", "winner",

  "winter", "wire", "wisdom", "wise", "wish", "witness", "wolf", "woman",

  "wonder", "wood", "wool", "word", "work", "world", "worry", "worth",

  "wrap", "wreck", "wrestle", "wrist", "write", "wrong", "yard", "year",

  "yellow", "you", "young", "youth", "zebra", "zero", "zone", "zoo",

])

// Vendored from packages/agent-experience-memory/src/internal/canonical.ts by scripts/vendor-memory.mjs — do not edit here.

// The drift guard (test/vendored-memory-drift.test.ts) fails when this copy

// no longer matches the canonical source.

import { sha256Hex } from "./sha256.js";

/**

 * Deterministic canonical JSON: object keys are sorted, arrays keep order.

 *

 * Two structurally equal values always serialize to the same bytes, so a digest

 * over the canonical form is a stable content address. This mirrors the frozen

 * `compileThreadExportArtifact` canonicalization in `agent-runtime-schema` so

 * the DSE artifact digest and the frozen export digest share one rule. The input

 * is `unknown` because callers pass Effect-encoded structs at a serialization

 * boundary; the function walks JSON-shaped values and leaves primitives intact.

 */

const compareStrings = (left: string, right: string): number =>

  left < right ? -1 : left > right ? 1 : 0;

const canonicalize = (value: unknown): unknown => {

  if (Array.isArray(value)) return value.map(canonicalize);

  if (typeof value !== "object" || value === null) return value;

  return Object.fromEntries(

    Object.entries(value)

      .sort(([left], [right]) => compareStrings(left, right))

      .map(([key, child]) => [key, canonicalize(child)]),

  );

};

/** Serialize a value to its deterministic canonical string form. */

export const canonicalStringify = (value: unknown): string => JSON.stringify(canonicalize(value));

/** The lowercase-hex SHA-256 digest of the canonical serialization of `value`. */

export const canonicalDigest = (value: unknown): string => sha256Hex(canonicalStringify(value));

// Vendored from packages/agent-experience-memory/src/consolidation.ts by scripts/vendor-memory.mjs — do not edit here.

// The drift guard (test/vendored-memory-drift.test.ts) fails when this copy

// no longer matches the canonical source.

import { Schema as S } from "effect";

import type { GlobalPattern } from "./pattern.js";

import { FactRef, OwnerScopeId, PatternRef, ProjectScopeId } from "./refs.js";

import { canonicalStringify } from "./canonical.js";

import { sha256Hex } from "./sha256.js";

import {

  cosineSimilarity,

} from "./ranking.js";

import { guardEngramContent } from "./engram.js";

/**

 * Background autonomous consolidation — "agent dreaming" / heuristic synthesis

 * (issue #224).

 *

 * Consolidation is an OFFLINE, background pass over already-redacted episodic

 * material. It never runs inside a turn, never reads a raw prompt or trajectory,

 * and never blocks recall: a host schedules it when idle, exactly like a freeze.

 *

 * The pass has three stages:

 *

 * 1. CLUSTER — related episodic engrams are grouped by cosine similarity of

 *    their embeddings (single-linkage with a bounded threshold), so no center,

 *    no iteration count, and no randomness is involved and equal inputs always

 *    give equal clusters.

 * 2. SYNTHESIZE — each cluster of MIN_CLUSTER_SIZE or more episodes becomes one

 *    synthesized heuristic engram: a redacted heuristic sentence distilled by a

 *    pure, deterministic summarizer (shared-token distillation, most recent

 *    first). No model provider is consulted, so the pass cannot fail open and

 *    cannot leak: the synthesizer only ever recombines text that already passed

 *    the engram redaction boundary at capture time.

 * 3. PROMOTE — a synthesis whose support meets the confidence floor is promoted

 *    into a `GlobalPattern` (the reviewed AFS-10 distilled layer), carrying its

 *    supporting success/failure fact references.

 *

 * Every produced value passes `guardEngramContent` again before it can be

 * signed, because synthesis recombines redacted fragments and the boundary is

 * per-value, not per-source.

 */

/** A single episodic memory offered to the consolidation pass. */

export interface EpisodicEngram {

  readonly ref: string;

  readonly text: string;

  /** Capture-time embedding; may be absent for a text-only episode. */

  readonly embedding?: ReadonlyArray<number>;

  /** Epoch milliseconds of the episode observation, used for recency order. */

  readonly observedAtMs: number;

  readonly admission?: "admitted" | "candidate" | "rejected";

}

export const CONSOLIDATION_MIN_CLUSTER_SIZE = 2 as const;

export const CONSOLIDATION_SIMILARITY_THRESHOLD = 0.5 as const;

export const CONSOLIDATION_CONFIDENCE_FLOOR = 0.6 as const;

/** Upper bound on episodes in one cluster considered by the synthesizer. */

export const CONSOLIDATION_MAX_EPISODES_PER_CLUSTER = 16 as const;

/** The synthesized heuristic engram — the output of one dream cycle. */

export const SynthesizedHeuristic = S.Struct({

  schema: S.Literal("openagents.heuristic_synth.v1"),

  synthId: S.String.check(S.isPattern(/^synth:[a-f0-9]{64}$/)),

  ownerScope: OwnerScopeId,

  projectScope: ProjectScopeId,

  /** The redacted heuristic sentence. */

  heuristic: S.String.check(S.isMinLength(1), S.isMaxLength(1000)),

  /** The episode refs that support the heuristic, most recent first. */

  sourceRefs: S.Array(FactRef),

  /**

   * Support strength: |supporting| / |episodes| inside the synthesizing

   * cluster, in [0, 1].

   */

  confidence: S.Number.check(S.isGreaterThanOrEqualTo(0), S.isLessThanOrEqualTo(1)),

  synthesizedAt: S.String.check(

    S.isPattern(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?Z$/),

  ),

});

export type SynthesizedHeuristic = typeof SynthesizedHeuristic.Type;

const decodeSynth = S.decodeUnknownSync(SynthesizedHeuristic);

const decodePatternRef = S.decodeUnknownSync(PatternRef);

const decodeFactRef = S.decodeUnknownSync(FactRef);

const tokenize = (text: string): ReadonlyArray<string> =>

  text

    .toLowerCase()

    .split(/[^a-z0-9]+/)

    .filter((token) => token.length > 1);