dsh-continual-evolve 0.10.6 → 0.12.0

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

package/lib/recall.d.ts

@@ -1,85 +0,0 @@
-/**
- * Targeted memory recall (P1): the precise-reading counterpart of the cheap
- * directory index.
- *
- * The injected directory view (`inject.ts`) shows one line per entry and the
- * full `evolve_list` dumps whole stores; neither answers "give me everything
- * about X". Recall fills that gap: filter by query/kind/scope/memory-type,
- * rank with the same CJK BM25 machinery as injection, and return full
- * content plus source, version, and staleness signals. Read-only — it never
- * mutates a store.
- */
-import type { EvolutionEngine } from "./service.js";
-import type { HarnessScope, RefinementKind } from "./types.js";
-/** Memory recall types (the `memoryType` taxonomy, not entry kinds). */
-export declare const RECALL_MEMORY_TYPES: readonly ["user", "feedback", "project", "reference"];
-export type RecallMemoryType = (typeof RECALL_MEMORY_TYPES)[number];
-/** Default and maximum hits returned per recall call. */
-export declare const DEFAULT_RECALL_LIMIT = 10;
-export declare const MAX_RECALL_LIMIT = 50;
-export interface RecallFilters {
-    /** Free-text relevance query; empty means "most recently updated first". */
-    query?: string;
-    /** Entry kinds to search; default is memory only. */
-    kinds?: RefinementKind[];
-    /** Stores to search; default is local + project + global. */
-    scopes?: HarnessScope[];
-    /** Memory-type filter (applies to memory entries only). */
-    memoryTypes?: RecallMemoryType[];
-    /** Maximum hits; clamped to 1..50, defaults to 10. */
-    limit?: number;
-    /** Include archived entries; default false. */
-    includeArchived?: boolean;
-}
-/** One recalled entry with full content and provenance. */
-export interface RecallHit {
-    scope: HarnessScope;
-    kind: RefinementKind;
-    id: string;
-    title: string;
-    content: string;
-    path: string;
-    version: number;
-    createdAt: string;
-    updatedAt: string;
-    archived: boolean;
-    /** Memory-type hook for memory entries; undefined for other kinds. */
-    memoryType?: string;
-    /** Conflict-hint stamp left by the promotion guard, when present. */
-    staleHint?: string;
-    /** Session the entry was distilled from, when recorded. */
-    sourceSession?: string;
-    /** Source user-message seqs, when recorded. */
-    sourceSeqs?: number[];
-}
-export interface RecallResult {
-    hits: RecallHit[];
-    /** Skipped scopes with reasons (read-path honesty: never silently drop a store). */
-    notes: string[];
-    /** Candidates seen before ranking/truncation. */
-    totalCandidates: number;
-}
-export interface RecallContext {
-    /** Live session id for the local store; absent → local is skipped with a note. */
-    sessionId?: string | undefined;
-    /** Resolved project key; absent → project is skipped with a note. */
-    projectKey?: string | undefined;
-}
-/**
- * Search the harness stores with mechanical filters and BM25 ranking.
- *
- * @param engine The evolution engine (read-only use).
- * @param context Store identities for the session-scoped stores.
- * @param filters Query/kind/scope/type/limit/archive filters.
- * @returns Ranked hits plus a note for every scope that could not be read.
- * @throws On an unknown kind, scope, or memory type — fail loud instead of
- *         silently narrowing the search.
- */
-export declare function recallMemories(engine: EvolutionEngine, context: RecallContext, filters?: RecallFilters): RecallResult;
-/**
- * Render recall hits for a model or human reader: full content, version,
- * source, and staleness on every hit; skipped scopes are always shown so
- * "no results" can never hide an unread store.
- */
-export declare function formatRecallResult(result: RecallResult, query?: string): string;
-//# sourceMappingURL=recall.d.ts.map

package/lib/recall.js

@@ -1,142 +0,0 @@
-import { buildRelevanceIndex, relevanceScore } from "./search.js";
-import { CONFLICT_HINT_KEY } from "./types.js";
-import { isArchived, isMemoryType, ARCHIVED_AT_KEY, MEMORY_TYPE_KEY, SOURCE_SEQS_KEY, SOURCE_SESSION_KEY } from "./types.js";
-/** Memory recall types (the `memoryType` taxonomy, not entry kinds). */
-export const RECALL_MEMORY_TYPES = ["user", "feedback", "project", "reference"];
-/** Entry kinds recall can filter on; memory is the default. */
-const RECALL_KINDS = ["prompt", "memory", "skill", "subagent"];
-/** Default and maximum hits returned per recall call. */
-export const DEFAULT_RECALL_LIMIT = 10;
-export const MAX_RECALL_LIMIT = 50;
-/**
- * Search the harness stores with mechanical filters and BM25 ranking.
- *
- * @param engine The evolution engine (read-only use).
- * @param context Store identities for the session-scoped stores.
- * @param filters Query/kind/scope/type/limit/archive filters.
- * @returns Ranked hits plus a note for every scope that could not be read.
- * @throws On an unknown kind, scope, or memory type — fail loud instead of
- *         silently narrowing the search.
- */
-export function recallMemories(engine, context, filters = {}) {
-    const kinds = filters.kinds ?? ["memory"];
-    for (const kind of kinds) {
-        if (!RECALL_KINDS.includes(kind)) {
-            throw new Error(`evolve_recall: unknown kind "${kind}" (expected one of ${RECALL_KINDS.join(", ")})`);
-        }
-    }
-    const scopes = filters.scopes ?? ["local", "project", "global"];
-    for (const scope of scopes) {
-        if (scope !== "local" && scope !== "project" && scope !== "global") {
-            throw new Error(`evolve_recall: unknown scope "${scope}" (expected local, project, or global)`);
-        }
-    }
-    const memoryTypes = filters.memoryTypes ?? [];
-    for (const memoryType of memoryTypes) {
-        if (!RECALL_MEMORY_TYPES.includes(memoryType)) {
-            throw new Error(`evolve_recall: unknown memoryType "${memoryType}" (expected one of ${RECALL_MEMORY_TYPES.join(", ")})`);
-        }
-    }
-    const limit = typeof filters.limit === "number" && Number.isFinite(filters.limit) && filters.limit > 0
-        ? Math.min(Math.floor(filters.limit), MAX_RECALL_LIMIT)
-        : DEFAULT_RECALL_LIMIT;
-    const query = filters.query?.trim() ?? "";
-    const candidates = [];
-    const notes = [];
-    for (const scope of scopes) {
-        const storeId = scope === "local" ? context.sessionId : scope === "project" ? context.projectKey : undefined;
-        if (scope !== "global" && storeId === undefined) {
-            notes.push(`${scope} store skipped: ${scope === "local" ? "no live session id" : "no project key for this session"}`);
-            continue;
-        }
-        let state;
-        try {
-            state = engine.load(scope, storeId);
-        }
-        catch (cause) {
-            notes.push(`${scope} store unreadable: ${cause instanceof Error ? cause.message : String(cause)}`);
-            continue;
-        }
-        for (const kind of kinds) {
-            for (const entry of Object.values(state.entries[kind])) {
-                if (!filters.includeArchived && isArchived(entry))
-                    continue;
-                if (kind === "memory" && memoryTypes.length > 0) {
-                    const type = entry.metadata[MEMORY_TYPE_KEY];
-                    if (typeof type !== "string" || !memoryTypes.includes(type))
-                        continue;
-                }
-                candidates.push(entry);
-            }
-        }
-    }
-    const ranked = query.length > 0 ? rankByRelevance(candidates, query) : [...candidates].sort((a, b) => (a.updated_at < b.updated_at ? 1 : a.updated_at > b.updated_at ? -1 : 0));
-    return { hits: ranked.slice(0, limit).map(toRecallHit), notes, totalCandidates: candidates.length };
-}
-function rankByRelevance(candidates, query) {
-    const index = buildRelevanceIndex(candidates);
-    const normalized = query.trim().toLowerCase();
-    return candidates
-        .map((entry) => {
-        let score = relevanceScore(index, entry, query);
-        // Exact scope:id addressing wins over fuzzy relevance (the
-        // memory-agent manifest search precedent).
-        if (`${entry.scope}:${entry.id}`.toLowerCase() === normalized)
-            score += 1000;
-        return { entry, score };
-    })
-        .filter((hit) => hit.score > 0)
-        .sort((a, b) => b.score - a.score || (a.entry.updated_at < b.entry.updated_at ? 1 : -1))
-        .map((hit) => hit.entry);
-}
-function toRecallHit(entry) {
-    const memoryType = entry.kind === "memory" && isMemoryType(entry.metadata[MEMORY_TYPE_KEY])
-        ? String(entry.metadata[MEMORY_TYPE_KEY])
-        : undefined;
-    const staleHint = typeof entry.metadata[CONFLICT_HINT_KEY] === "string" && entry.metadata[CONFLICT_HINT_KEY].length > 0
-        ? String(entry.metadata[CONFLICT_HINT_KEY])
-        : undefined;
-    const sourceSession = typeof entry.metadata[SOURCE_SESSION_KEY] === "string" ? String(entry.metadata[SOURCE_SESSION_KEY]) : undefined;
-    const rawSeqs = entry.metadata[SOURCE_SEQS_KEY];
-    const sourceSeqs = Array.isArray(rawSeqs) && rawSeqs.every((seq) => typeof seq === "number") ? rawSeqs : undefined;
-    return {
-        scope: entry.scope,
-        kind: entry.kind,
-        id: entry.id,
-        title: entry.title,
-        content: entry.content,
-        path: entry.path,
-        version: entry.version,
-        createdAt: entry.created_at,
-        updatedAt: entry.updated_at,
-        archived: isArchived(entry),
-        ...(memoryType !== undefined ? { memoryType } : {}),
-        ...(staleHint !== undefined ? { staleHint } : {}),
-        ...(sourceSession !== undefined ? { sourceSession } : {}),
-        ...(sourceSeqs !== undefined ? { sourceSeqs } : {}),
-    };
-}
-/**
- * Render recall hits for a model or human reader: full content, version,
- * source, and staleness on every hit; skipped scopes are always shown so
- * "no results" can never hide an unread store.
- */
-export function formatRecallResult(result, query) {
-    const lines = [`recall: ${result.hits.length} hit(s)${query?.trim() ? ` for "${query.trim()}"` : ""} (${result.totalCandidates} candidate(s))`];
-    for (const hit of result.hits) {
-        const type = hit.memoryType !== undefined ? ` · type=${hit.memoryType}` : "";
-        const archived = hit.archived ? " · archived" : "";
-        const stale = hit.staleHint !== undefined ? ` · conflict-hint=${hit.staleHint}` : "";
-        const source = hit.sourceSession !== undefined ? ` · src=${hit.sourceSession}${hit.sourceSeqs ? `:${hit.sourceSeqs.join(",")}` : ""}` : "";
-        lines.push(`- [${hit.scope}:${hit.kind}:${hit.id}] ${hit.title} (v${hit.version}${type}${archived}${stale}${source})`);
-        lines.push(`  ${hit.content}`);
-    }
-    for (const note of result.notes) {
-        lines.push(`note: ${note}`);
-    }
-    if (result.hits.length === 0) {
-        lines.push(`(${ARCHIVED_AT_KEY} entries are hidden unless includeArchived is set)`);
-    }
-    return lines.join("\n");
-}
-//# sourceMappingURL=recall.js.map

package/lib/record-language.d.ts

@@ -1,85 +0,0 @@
-/**
- * Record language resolution for evolution writes.
- *
- * Every durable record (refinement summary/rationale, entry title/content,
- * review and wrap-up verdicts) is generated prose. Its language is resolved
- * per call through one chain — never hardcoded at any single site:
- *
- * 1. explicit `recordLanguage` plugin config (`zh`|`en`; `auto` defers);
- * 2. the durable DSH client preference (`locale` namespace, `preference`
- *    field — the same source the desktop shell and the web GUI follow);
- * 3. detection over recent direct user text (Han-character signal);
- * 4. `en`, matching the DSH `FALLBACK_LOCALE`.
- *
- * The durable-preference read is intentionally fail-open: the settings
- * service is host-owned and its shape may drift, so any mismatch yields
- * `undefined` and the chain moves on instead of breaking the evolution run.
- */
-/** Natural languages evolution records are authored in. */
-export type RecordLanguage = "zh" | "en";
-/** Plugin-facing preference: an explicit language or deferral to detection. */
-export type RecordLanguagePreference = "auto" | RecordLanguage;
-/**
- * Upstream durable-settings address reused verbatim
- * (`@deepseek-ai/dsh-client-locale`: `LOCALE_SETTINGS_NAMESPACE`,
- * `LOCALE_PREFERENCE_FIELD`). New keys are never invented here.
- */
-export declare const DSH_LOCALE_NAMESPACE = "locale";
-export declare const DSH_LOCALE_PREFERENCE_FIELD = "preference";
-/**
- * Detect Chinese from user text by Han-character density.
- *
- * @param text Arbitrary user-supplied text.
- * @returns `"zh"` on sufficient Han signal, otherwise `undefined` (no
- *          signal — never a default; the resolver owns the fallback).
- */
-export declare function detectLanguageFromText(text: string): RecordLanguage | undefined;
-/**
- * Read the durable DSH client language preference through the host settings
- * service. Fail-open by contract: a missing service, a throwing read, an
- * async-shaped reply, or an unknown value all yield `undefined`.
- *
- * The service is resolved through `ctx.get("settings")` (the global registry),
- * which sees services provided by sibling plugin entries. A direct
- * `ctx.settings` walks only the caller's fiber ancestor chain and throws
- * "cannot get property \"settings\" without inject" — the same failure mode
- * documented in `goal.ts` — and a throw here would abort the whole snapshot
- * gate, so the property access itself is guarded. Plain-object contexts
- * (tests, non-Cordis hosts) fall back to the direct property.
- *
- * @param ctx Cordis context that may carry the host settings service.
- * @returns The stored preference (`zh`/`en`, subtag-tolerant) or `undefined`.
- */
-export declare function durableLocalePreference(ctx: unknown): string | undefined;
-/**
- * Normalize an explicit preference or durable value to a record language.
- *
- * @param value Candidate language id (config or durable preference).
- * @returns `"zh"`/`"en"` on a recognized id, otherwise `undefined`.
- */
-export declare function normalizeRecordLanguage(value: string | undefined): RecordLanguage | undefined;
-export interface ResolveRecordLanguageInput {
-    /** Explicit plugin config; absent/`auto` defers to the chain below. */
-    configured?: RecordLanguagePreference | undefined;
-    /** Host context for the durable-preference read; absent skips that tier. */
-    ctx?: unknown;
-    /** Recent direct user text for the detection tier; absent skips it. */
-    trajectoryText?: string;
-}
-/**
- * Resolve the authoring language for one evolution write.
- *
- * @param input Configured preference, host context, and trajectory sample.
- * @returns The winning language; always defined (`en` is the final fallback).
- */
-export declare function resolveRecordLanguage(input: ResolveRecordLanguageInput): RecordLanguage;
-/**
- * The one-line prompt addendum appended to every record-authoring system
- * prompt. Machine contracts (JSON keys, ids, paths, code) stay untouched —
- * only natural-language values follow the resolved language.
- *
- * @param lang Resolved record language.
- * @returns The instruction line for `lang`.
- */
-export declare function recordLanguageInstruction(lang: RecordLanguage): string;
-//# sourceMappingURL=record-language.d.ts.map