dsh-continual-evolve 0.11.0 → 0.12.0

package/lib/prefix-cache.js

@@ -1,168 +0,0 @@
-/**
- * Prefix-cache-aware planning input routing (Route A/B).
- *
- * The planner and the review gate re-send session context on every call as
- * flat text. On providers with prompt caching that context is re-billed at
- * full price each time. Route A instead prepends session-derived messages —
- * the same evidence in structured form, eligible for cache-read pricing —
- * and drops the redundant flat trajectory block. Route B keeps the legacy
- * flat-text input byte-for-byte.
- *
- * Adapted from dsh-continual-harness (Route A/B + cache-detect): this port
- * deliberately does NOT reproduce the host loop's byte-identical cache key
- * (no deriveMessages/tools/sessionId plumbing on this seam), so a hit needs
- * a provider that keys on the message-prefix content. Sources are stamped
- * honestly and every reduction is documented below.
- */
-import { createAssistantMessage, createUserMessage } from "@deepseek-ai/dsh-llm";
-/** Default session-prefix budget for one Route A input, in characters. */
-export const DEFAULT_PREFIX_MAX_CHARS = 12000;
-/**
- * Resolve per-call overrides against the defaults.
- *
- * @param opts - sparse per-call overrides.
- * @returns the effective mode (default "auto") and char budget.
- * @throws When maxChars is present but not a positive safe integer (fail loud on misconfiguration).
- */
-export function resolvePrefixCache(opts) {
-    const mode = opts?.mode ?? "auto";
-    const maxChars = opts?.maxChars ?? DEFAULT_PREFIX_MAX_CHARS;
-    if (!Number.isSafeInteger(maxChars) || maxChars < 1) {
-        throw new Error(`evolve: prefix-cache maxChars must be a positive integer, got ${String(opts?.maxChars)}`);
-    }
-    return { mode, maxChars };
-}
-/**
- * True when any assistant message in this session reported cache-read
- * tokens — evidence the provider can serve a warm prefix.
- *
- * @param events - session log rows, newest last.
- * @returns whether cache evidence exists (false on an empty/unreadable log).
- */
-export function hasCacheEvidence(events) {
-    for (const raw of events) {
-        if (typeof raw !== "object" || raw === null)
-            continue;
-        const event = raw;
-        if (event.type !== "assistant/message")
-            continue;
-        const read = event.data?.usage?.cacheReadTokens;
-        if (typeof read === "number" && read > 0)
-            return true;
-    }
-    return false;
-}
-/**
- * Pick the planning input route for one call.
- *
- * @param events - session log rows, newest last.
- * @param mode - routing mode (default "auto").
- * @returns "A" when the session prefix should carry the context, else "B".
- */
-export function detectPlannerRoute(events, mode) {
-    const resolved = mode ?? "auto";
-    if (resolved === "session")
-        return "A";
-    if (resolved === "off")
-        return "B";
-    return hasCacheEvidence(events) ? "A" : "B";
-}
-/**
- * Extract one message's text without depending on the dsh-llm ContentBlock
- * type: string blocks pass through, object blocks contribute their `text`
- * field when present. Non-text blocks (tool calls, images) are dropped.
- */
-function blockText(content) {
-    if (typeof content === "string")
-        return content;
-    if (!Array.isArray(content))
-        return "";
-    const parts = [];
-    for (const block of content) {
-        if (typeof block === "string") {
-            parts.push(block);
-        }
-        else if (block !== null && typeof block === "object" && "text" in block && typeof block.text === "string") {
-            parts.push(block.text);
-        }
-    }
-    return parts.filter((text) => text.length > 0).join(" ");
-}
-/**
- * Rebuild a tail-biased session prefix from the event log.
- *
- * Inclusion mirrors the trajectory grounding (only direct human `user`
- * speech plus the model's own assistant text), so injected plugin context
- * and tool results never echo back into the planning input. Whole messages
- * are dropped oldest-first over budget; a single over-budget message keeps
- * its tail.
- *
- * @param events - session log rows, newest last.
- * @param opts - provider/model stamps the assistant messages (the calling
- * agent's own route); maxChars caps the prefix (default {@link DEFAULT_PREFIX_MAX_CHARS}).
- * @returns the prefix messages, oldest first ([] when nothing qualifies —
- * callers fall back to Route B).
- * @throws When assistant text exists but provider/model is missing (an
- * assistant message cannot be honestly stamped without its route).
- */
-export function buildPrefixMessages(events, opts) {
-    const maxChars = opts.maxChars ?? DEFAULT_PREFIX_MAX_CHARS;
-    if (!Number.isSafeInteger(maxChars) || maxChars < 1) {
-        throw new Error(`evolve: prefix-cache maxChars must be a positive integer, got ${String(opts.maxChars)}`);
-    }
-    const pairs = [];
-    for (let i = events.length - 1; i >= 0; i -= 1) {
-        const raw = events[i];
-        if (typeof raw !== "object" || raw === null)
-            continue;
-        const event = raw;
-        const isUser = event.type === "user/message";
-        const isAssistant = event.type === "assistant/message";
-        if (!isUser && !isAssistant)
-            continue;
-        if (isUser) {
-            const kind = event.data?.source?.kind;
-            if (kind !== undefined && kind !== "user")
-                continue;
-        }
-        const text = blockText(event.data?.content).trim();
-        if (text.length === 0)
-            continue;
-        pairs.push({ role: isUser ? "user" : "assistant", text });
-    }
-    if (pairs.length === 0)
-        return [];
-    // Collected newest-first; restore conversation order before budgeting.
-    pairs.reverse();
-    // Tail-biased budget: drop oldest whole messages over budget; a lone
-    // over-budget message keeps its tail.
-    let total = pairs.reduce((sum, pair) => sum + pair.text.length, 0);
-    while (pairs.length > 1 && total > maxChars) {
-        const dropped = pairs.shift();
-        total -= dropped?.text.length ?? 0;
-    }
-    const oldest = pairs[0];
-    if (oldest !== undefined && total > maxChars) {
-        oldest.text = oldest.text.slice(-maxChars);
-    }
-    const messages = [];
-    for (const pair of pairs) {
-        if (pair.role === "user") {
-            messages.push(createUserMessage({
-                source: { kind: "user" },
-                content: [{ type: "text", text: pair.text }],
-            }));
-        }
-        else {
-            if (!opts.provider || !opts.model) {
-                throw new Error("evolve: prefix-cache needs the agent provider/model to stamp assistant messages");
-            }
-            messages.push(createAssistantMessage({
-                source: { provider: opts.provider, model: opts.model },
-                content: [{ type: "text", text: pair.text }],
-            }));
-        }
-    }
-    return messages;
-}
-//# sourceMappingURL=prefix-cache.js.map

package/lib/project.d.ts

@@ -1,28 +0,0 @@
-/**
- * Stable project key for a workspace. `workspaceIdentity` (when set)
- * replaces the path as the hash source so renamed checkouts of the same
- * logical project keep one store.
- */
-export declare function resolveProjectKey(workspacePath: string, workspaceIdentity?: string): string;
-/** Defense for externally supplied keys (explicit opts): single safe segment. */
-export declare function sanitizeProjectKey(key: string): string;
-/** Minimal agent shape the project-key derivation needs (duck-typed). */
-export interface ProjectKeyAgentLike {
-    session?: {
-        header?: {
-            cwd?: unknown;
-            meta?: {
-                cwd?: unknown;
-            };
-        };
-    };
-}
-/**
- * Derive the project key from an assembling agent's session cwd. Returns
- * undefined when no validated absolute cwd is present — the caller then
- * skips the project layer rather than failing the whole assembly.
- */
-export declare function projectKeyOf(agent: unknown, opts?: {
-    workspaceIdentity?: string;
-}): string | undefined;
-//# sourceMappingURL=project.d.ts.map

package/lib/project.js

@@ -1,66 +0,0 @@
-/**
- * Project scope identity: the third harness layer between session-local
- * staging and the cross-project global store.
- *
- * A project is identified by the session's validated absolute `cwd`
- * (stable slug + sha256, mirroring ZCode's `project-root.ts`), so every
- * session opened in the same workspace shares one project store while
- * different checkouts never collide. All helpers are pure and never throw —
- * a missing cwd simply means "no project layer" (the caller degrades to
- * global+local, the same shape as an empty project store).
- */
-import { createHash } from "node:crypto";
-import { basename, isAbsolute, resolve } from "node:path";
-/**
- * Stable project key for a workspace. `workspaceIdentity` (when set)
- * replaces the path as the hash source so renamed checkouts of the same
- * logical project keep one store.
- */
-export function resolveProjectKey(workspacePath, workspaceIdentity) {
-    const identity = workspaceIdentity?.trim();
-    const normalized = resolve(workspacePath);
-    const keySource = identity && identity.length > 0 ? identity : process.platform === "win32" ? normalized.toLowerCase() : normalized;
-    const hash = createHash("sha256").update(keySource).digest("hex").slice(0, 16);
-    const slug = identity && identity.length > 0 ? "project" : sanitizeSlug(basename(normalized) || "project");
-    return `${slug}-${hash}`;
-}
-function sanitizeSlug(value) {
-    const slug = value
-        .toLowerCase()
-        .replace(/[^a-z0-9._-]+/g, "-")
-        .replace(/^-+|-+$/g, "")
-        .slice(0, 48);
-    return slug.length > 0 ? slug : "project";
-}
-/** Defense for externally supplied keys (explicit opts): single safe segment. */
-export function sanitizeProjectKey(key) {
-    const cleaned = key
-        .trim()
-        .replace(/[^a-zA-Z0-9._-]+/g, "-")
-        .replace(/^-+|-+$/g, "")
-        .slice(0, 64);
-    return cleaned.length > 0 ? cleaned : "project";
-}
-/**
- * Derive the project key from an assembling agent's session cwd. Returns
- * undefined when no validated absolute cwd is present — the caller then
- * skips the project layer rather than failing the whole assembly.
- */
-export function projectKeyOf(agent, opts) {
-    try {
-        const header = agent?.session?.header;
-        const raw = header?.cwd ?? header?.meta?.cwd;
-        if (typeof raw !== "string" || raw.trim().length === 0) {
-            return undefined;
-        }
-        const cwd = raw.trim();
-        if (!isAbsolute(cwd)) {
-            return undefined;
-        }
-        return resolveProjectKey(cwd, opts?.workspaceIdentity);
-    }
-    catch {
-        return undefined;
-    }
-}
-//# sourceMappingURL=project.js.map

package/lib/projection.d.ts

@@ -1,22 +0,0 @@
-import type { HarnessState } from "./types.js";
-/** Index file name at the store root. */
-export declare const MEMORY_INDEX_FILE = "MEMORY.md";
-/** Per-fact file directory inside the store. */
-export declare const MEMORY_FACTS_DIR = "memory";
-/** Map a memory id to a flat filename (`:` is legal on disk but hostile to tools). */
-export declare function memoryFactFilename(id: string): string;
-/**
- * Rewrite the whole projection from the post-apply state: index, one file
- * per memory entry (including archived ones, flagged), and deletion of
- * files whose ids no longer exist. Deterministic — the same state always
- * produces the same files.
- *
- * @param stateDir The store directory holding harness_state.json.
- * @param state The freshly persisted state (post-apply, post-rollback).
- */
-export declare function materializeMemoryProjection(stateDir: string, state: HarnessState): void;
-/** Read back one projected fact file (round-trip helper for tests and tools). */
-export declare function readMemoryFact(factsDir: string, filename: string): string;
-/** True when the store directory carries a projection from a previous apply. */
-export declare function hasMemoryProjection(stateDir: string): boolean;
-//# sourceMappingURL=projection.d.ts.map

package/lib/projection.js

@@ -1,112 +0,0 @@
-/**
- * Readable Markdown projection (P1): a ZCode-style `MEMORY.md` index plus
- * one file per memory fact, materialized from the JSON store.
- *
- * The JSON harness state stays the single source of truth (versions,
- * rollback, audit). The projection is a derived, human-trustable view:
- * it is rewritten from the post-apply state inside the engine, so the
- * model can never write it directly and rollback/archive stay in sync.
- *
- * Layout per store directory:
- *
- *   <stateDir>/MEMORY.md          one line per memory entry
- *   <stateDir>/memory/<file>.md   one fact per file with frontmatter
- */
-import { existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { isArchived, isMemoryType, MEMORY_TYPE_KEY } from "./types.js";
-/** Index file name at the store root. */
-export const MEMORY_INDEX_FILE = "MEMORY.md";
-/** Per-fact file directory inside the store. */
-export const MEMORY_FACTS_DIR = "memory";
-/** Map a memory id to a flat filename (`:` is legal on disk but hostile to tools). */
-export function memoryFactFilename(id) {
-    return `${id.replace(/:/g, "_")}.md`;
-}
-/**
- * Rewrite the whole projection from the post-apply state: index, one file
- * per memory entry (including archived ones, flagged), and deletion of
- * files whose ids no longer exist. Deterministic — the same state always
- * produces the same files.
- *
- * @param stateDir The store directory holding harness_state.json.
- * @param state The freshly persisted state (post-apply, post-rollback).
- */
-export function materializeMemoryProjection(stateDir, state) {
-    const entries = Object.values(state.entries.memory).sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
-    const factsDir = join(stateDir, MEMORY_FACTS_DIR);
-    mkdirSync(factsDir, { recursive: true });
-    const expected = new Map();
-    for (const entry of entries) {
-        let filename = memoryFactFilename(entry.id);
-        let suffix = 1;
-        while (expected.has(filename)) {
-            suffix += 1;
-            filename = `${memoryFactFilename(entry.id).replace(/\.md$/, "")}~${suffix}.md`;
-        }
-        expected.set(filename, entry);
-    }
-    for (const [filename, entry] of expected) {
-        writeFileSync(join(factsDir, filename), renderMemoryFact(entry), { encoding: "utf8", mode: 0o600 });
-    }
-    // Sweep facts whose entries vanished (delete); archived entries keep
-    // their file with archived:true frontmatter.
-    let existing;
-    try {
-        existing = readdirSync(factsDir).filter((file) => file.endsWith(".md"));
-    }
-    catch {
-        existing = [];
-    }
-    for (const file of existing) {
-        if (!expected.has(file)) {
-            try {
-                unlinkSync(join(factsDir, file));
-            }
-            catch {
-                // A stale fact file must not break the apply path; the next
-                // materialization retries the sweep.
-            }
-        }
-    }
-    writeFileSync(join(stateDir, MEMORY_INDEX_FILE), renderMemoryIndex([...expected]), { encoding: "utf8", mode: 0o600 });
-}
-/** Read back one projected fact file (round-trip helper for tests and tools). */
-export function readMemoryFact(factsDir, filename) {
-    return readFileSync(join(factsDir, filename), "utf8");
-}
-/** True when the store directory carries a projection from a previous apply. */
-export function hasMemoryProjection(stateDir) {
-    return existsSync(join(stateDir, MEMORY_INDEX_FILE)) && existsSync(join(stateDir, MEMORY_FACTS_DIR));
-}
-function renderMemoryFact(entry) {
-    const type = isMemoryType(entry.metadata[MEMORY_TYPE_KEY]) ? String(entry.metadata[MEMORY_TYPE_KEY]) : "untyped";
-    const frontmatter = [
-        "---",
-        `id: ${entry.id}`,
-        `scope: ${entry.scope}`,
-        `kind: memory`,
-        `memoryType: ${type}`,
-        `version: ${entry.version}`,
-        `path: ${entry.path}`,
-        `archived: ${isArchived(entry)}`,
-        `created_at: ${entry.created_at}`,
-        `updated_at: ${entry.updated_at}`,
-        "---",
-    ].join("\n");
-    return `${frontmatter}\n\n# ${entry.title}\n\n${entry.content}\n`;
-}
-function renderMemoryIndex(files) {
-    const lines = ["# Memory Index", "", "Derived from the JSON harness state — do not edit by hand; it is rewritten on every memory apply.", ""];
-    if (files.length === 0) {
-        lines.push("(no memory entries yet)");
-        return `${lines.join("\n")}\n`;
-    }
-    for (const [file, entry] of files) {
-        const type = isMemoryType(entry.metadata[MEMORY_TYPE_KEY]) ? String(entry.metadata[MEMORY_TYPE_KEY]) : "untyped";
-        const archived = isArchived(entry) ? ", archived" : "";
-        lines.push(`- [${entry.scope}:${entry.id}] ${entry.title} (type=${type}, v${entry.version}${archived}) → ${MEMORY_FACTS_DIR}/${file}`);
-    }
-    return `${lines.join("\n")}\n`;
-}
-//# sourceMappingURL=projection.js.map

package/lib/promotion.d.ts

@@ -1,94 +0,0 @@
-/**
- * Promotion policy: mechanical, code-enforced gates that decide whether a
- * local entry MAY be promoted to the cross-session global store ("模型提议，
- * 代码保证"). The LLM classification proposes; these guards dispose.
- *
- * Rationale (2026-08-22 store audit): the global store is shared by every
- * project on one profile, so promoting project-scoped knowledge taxes every
- * future session in every project. Measured failure modes:
- * - absolute paths / session ids in promoted content (project-scoped),
- * - near-duplicates of existing global entries re-promoted from later
- *   sessions (title matching alone missed them),
- * - one-line facts whose framing costs more than their content.
- *
- * Pure functions only — the callers (wrapup command, gate local-fate phase)
- * supply the resolved {@link PromotionPolicy}.
- */
-import type { HarnessEntry, HarnessState, RefinementKind } from "./types.js";
-export interface PromotionPolicy {
-    /** Content matching any pattern is project-scoped and stays local. */
-    blockPatterns: RegExp[];
-    /** Whole promotions below this content length stay local (chars). */
-    minPromoteChars: number;
-    /** Content overlap above this against a global entry = duplicate. */
-    maxContentOverlap: number;
-}
-export declare const DEFAULT_PROMOTION_POLICY: PromotionPolicy;
-/**
- * Write-time conflict guard (R2): a global create whose similarity against an
- * existing same-kind entry reaches this score is rejected outright — a
- * near-duplicate adds zero information and the model should evolve_update
- * the existing entry instead.
- */
-export declare const CONFLICT_BLOCK_SCORE = 0.8;
-/** Similarity at/above this stamps {@link CONFLICT_HINT_KEY} but lets the write proceed. */
-export declare const CONFLICT_WARN_SCORE = 0.5;
-/**
- * First reason the content reads as carrying a live credential, or undefined
- * when it screens clean. Unlike {@link projectScopedReason} this guard is
- * NOT policy-configurable — it protects every sink at once (promotion path,
- * global writes at the engine throat, mount materialization).
- */
-export declare function secretLeakReason(content: string): string | undefined;
-/**
- * Build a policy from config values (schemastery strings compiled here so
- * the config layer never touches RegExp). Invalid patterns are skipped —
- * a broken user pattern must not disable the remaining guards.
- */
-export declare function resolvePromotionPolicy(options: {
-    blockPatterns?: readonly string[] | undefined;
-    minPromoteChars?: number | undefined;
-    maxContentOverlap?: number | undefined;
-}): PromotionPolicy;
-/**
- * First reason the content reads as project-scoped, or undefined when it
- * looks portable. Returns the matched pattern source so skip reports stay
- * explainable in reviews.jsonl rationales.
- */
-export declare function projectScopedReason(content: string, policy: PromotionPolicy): string | undefined;
-/**
- * Token set for cheap similarity, built on the search module's tokenizer —
- * one home for "how this project splits words" (ASCII words lowercased plus
- * CJK character bigrams; bigrams survive segmentation-free Chinese text).
- * The set form feeds Jaccard overlap (review audit 2026-08-28 C: the
- * previous private tokenizer duplicated the definition; the calibrated
- * 0.6/0.8 thresholds are judgment values, not data-fitted, so the merge
- * costs at most a test re-pin).
- */
-export declare function normalizedTokens(text: string): Set<string>;
-/** Jaccard similarity of two texts' normalized token sets (0..1). */
-export declare function contentOverlap(a: string, b: string): number;
-export interface SimilarEntryHit {
-    id: string;
-    title: string;
-    score: number;
-}
-/**
- * Human/LLM-readable description of a similarity hit, shared by the block
- * error and the approval-question suffix so both surfaces explain the same
- * way.
- */
-export declare function buildConflictNotice(hit: SimilarEntryHit): string;
-/**
- * The most similar entry of the list, above `minScore`. Title and content
- * both feed the comparison (titles are short; content carries the real
- * signal). Generic form of {@link mostSimilarGlobalEntry} — callers decide
- * which corpus (global store, merged view) the candidates come from.
- */
-export declare function mostSimilarEntry(entries: readonly HarnessEntry[], title: string, content: string, minScore: number): SimilarEntryHit | undefined;
-/**
- * The most similar non-archived global entry of the same kind, above the
- * policy threshold.
- */
-export declare function mostSimilarGlobalEntry(globalState: HarnessState, kind: RefinementKind, title: string, content: string, policy: PromotionPolicy): SimilarEntryHit | undefined;
-//# sourceMappingURL=promotion.d.ts.map

package/lib/promotion.js

@@ -1,171 +0,0 @@
-import { isArchived } from "./types.js";
-import { tokenize } from "./search.js";
-/** Regex sources that mark content as project-scoped (never global). */
-const DEFAULT_BLOCK_PATTERNS = [
-    String.raw `\/(?:mnt|home|Users)\/`, // absolute POSIX paths: "/home/…", "/mnt/…", "/Users/…"
-    String.raw `\bsession-[0-9a-f]{8}\b`, // session-scoped identifiers
-    String.raw `~/\.dsh\b`, // user harness home references
-];
-export const DEFAULT_PROMOTION_POLICY = {
-    blockPatterns: DEFAULT_BLOCK_PATTERNS.map((source) => new RegExp(source, "i")),
-    minPromoteChars: 100,
-    maxContentOverlap: 0.6,
-};
-/**
- * Write-time conflict guard (R2): a global create whose similarity against an
- * existing same-kind entry reaches this score is rejected outright — a
- * near-duplicate adds zero information and the model should evolve_update
- * the existing entry instead.
- */
-export const CONFLICT_BLOCK_SCORE = 0.8;
-/** Similarity at/above this stamps {@link CONFLICT_HINT_KEY} but lets the write proceed. */
-export const CONFLICT_WARN_SCORE = 0.5;
-/**
- * Fixed secret-detection patterns — a security invariant, deliberately NOT
- * part of the configurable {@link PromotionPolicy}: a user pattern typo must
- * never be able to disable secret screening. Each entry pairs a human label
- * with a regex tuned for low false positives (placeholders like
- * "YOUR_API_KEY_HERE" don't match; realistic mixed literals do).
- */
-const SECRET_PATTERNS = [
-    { label: "AnySearch API key", regex: /\bas_sk_[A-Za-z0-9]{8,}\b/ },
-    { label: "Anthropic API key", regex: /\bsk-ant-[A-Za-z0-9_-]{16,}\b/ },
-    { label: "OpenAI-style API key", regex: /\bsk-(?:proj-)?[A-Za-z0-9_-]{16,}\b/ },
-    { label: "GitHub token", regex: /\b(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9]{20,}\b/ },
-    { label: "GitHub fine-grained PAT", regex: /\bgithub_pat_[A-Za-z0-9_]{20,}\b/ },
-    { label: "AWS access key", regex: /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/ },
-    { label: "Google API key", regex: /\bAIza[0-9A-Za-z_-]{35}\b/ },
-    { label: "Slack token", regex: /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/ },
-    { label: "npm grant token", regex: /\bnpm_[A-Za-z0-9]{36}\b/ },
-    { label: "private key block", regex: /-----BEGIN (?:RSA |EC |DSA |OPENSSH |PGP )?PRIVATE KEY(?: BLOCK)?-----/ },
-    {
-        label: "credential assignment",
-        // The credential-name group is manually case-insensitive ("apiKey" in
-        // JSON, "API_KEY" in env examples) so the placeholder lookahead stays
-        // case-sensitive: it excludes only ALL-CAPS placeholders
-        // ("YOUR_KEY_HERE"), not real mixed/lowercase literals.
-        regex: /\b(?:[Aa][Pp][Ii][_-]?[Kk][Ee][Yy]|[Ss][Ee][Cc][Rr][Ee][Tt]|[Tt][Oo][Kk][Ee][Nn]|[Pp][Aa][Ss][Ss][Ww][Oo][Rr][Dd]|[Pp][Aa][Ss][Ss][Ww][Dd]|[Pp][Ww][Dd])\b["']?\s*[:=]\s*["'](?!["']*[A-Z0-9_]+["'])[A-Za-z0-9+/_-]{16,}["']/,
-    },
-];
-/**
- * Redact a matched secret for error/audit surfaces: enough to identify the
- * credential family, never the full value (reasons land in reviews.jsonl,
- * question texts, and logs).
- */
-function redactSecret(matched) {
-    if (matched.length <= 10) {
-        return `${matched.slice(0, 3)}…`;
-    }
-    return `${matched.slice(0, 6)}…${matched.slice(-3)}`;
-}
-/**
- * First reason the content reads as carrying a live credential, or undefined
- * when it screens clean. Unlike {@link projectScopedReason} this guard is
- * NOT policy-configurable — it protects every sink at once (promotion path,
- * global writes at the engine throat, mount materialization).
- */
-export function secretLeakReason(content) {
-    for (const { label, regex } of SECRET_PATTERNS) {
-        const match = regex.exec(content);
-        if (match?.[0]) {
-            return `possible ${label} ("${redactSecret(match[0])}") — secrets must never be sedimented into harness state; rotate the credential and keep it out of the store`;
-        }
-    }
-    return undefined;
-}
-/**
- * Build a policy from config values (schemastery strings compiled here so
- * the config layer never touches RegExp). Invalid patterns are skipped —
- * a broken user pattern must not disable the remaining guards.
- */
-export function resolvePromotionPolicy(options) {
-    const patterns = [...(options.blockPatterns ?? [])]
-        .map((source) => {
-        try {
-            return new RegExp(source, "i");
-        }
-        catch {
-            return undefined;
-        }
-    })
-        .filter((pattern) => pattern !== undefined);
-    return {
-        blockPatterns: patterns.length > 0 ? patterns : DEFAULT_PROMOTION_POLICY.blockPatterns,
-        minPromoteChars: options.minPromoteChars ?? DEFAULT_PROMOTION_POLICY.minPromoteChars,
-        maxContentOverlap: options.maxContentOverlap ?? DEFAULT_PROMOTION_POLICY.maxContentOverlap,
-    };
-}
-/**
- * First reason the content reads as project-scoped, or undefined when it
- * looks portable. Returns the matched pattern source so skip reports stay
- * explainable in reviews.jsonl rationales.
- */
-export function projectScopedReason(content, policy) {
-    for (const pattern of policy.blockPatterns) {
-        if (pattern.test(content)) {
-            return `project-scoped content (matches /${pattern.source}/)`;
-        }
-    }
-    return undefined;
-}
-/**
- * Token set for cheap similarity, built on the search module's tokenizer —
- * one home for "how this project splits words" (ASCII words lowercased plus
- * CJK character bigrams; bigrams survive segmentation-free Chinese text).
- * The set form feeds Jaccard overlap (review audit 2026-08-28 C: the
- * previous private tokenizer duplicated the definition; the calibrated
- * 0.6/0.8 thresholds are judgment values, not data-fitted, so the merge
- * costs at most a test re-pin).
- */
-export function normalizedTokens(text) {
-    return new Set(tokenize(text));
-}
-/** Jaccard similarity of two texts' normalized token sets (0..1). */
-export function contentOverlap(a, b) {
-    const left = normalizedTokens(a);
-    const right = normalizedTokens(b);
-    if (left.size === 0 || right.size === 0) {
-        return 0;
-    }
-    let intersection = 0;
-    for (const token of left) {
-        if (right.has(token)) {
-            intersection += 1;
-        }
-    }
-    return intersection / (left.size + right.size - intersection);
-}
-/**
- * Human/LLM-readable description of a similarity hit, shared by the block
- * error and the approval-question suffix so both surfaces explain the same
- * way.
- */
-export function buildConflictNotice(hit) {
-    return `near-duplicate of ${hit.id} 「${hit.title}」 (similarity ${Math.round(hit.score * 100)}%)`;
-}
-/**
- * The most similar entry of the list, above `minScore`. Title and content
- * both feed the comparison (titles are short; content carries the real
- * signal). Generic form of {@link mostSimilarGlobalEntry} — callers decide
- * which corpus (global store, merged view) the candidates come from.
- */
-export function mostSimilarEntry(entries, title, content, minScore) {
-    let best;
-    for (const other of entries) {
-        if (isArchived(other))
-            continue;
-        const score = Math.max(contentOverlap(title, other.title), contentOverlap(content, other.content));
-        if (score >= minScore && (best === undefined || score > best.score)) {
-            best = { id: other.id, title: other.title, score };
-        }
-    }
-    return best;
-}
-/**
- * The most similar non-archived global entry of the same kind, above the
- * policy threshold.
- */
-export function mostSimilarGlobalEntry(globalState, kind, title, content, policy) {
-    return mostSimilarEntry(Object.values(globalState.entries[kind]), title, content, policy.maxContentOverlap);
-}
-//# sourceMappingURL=promotion.js.map