dsh-continual-evolve 0.11.0 → 0.12.1

package/lib/search.js

@@ -1,136 +0,0 @@
-/** BM25 term-saturation constant (Okapi k1). */
-export const BM25_K1 = 1.5;
-/** BM25 document-length normalization constant (Okapi b). */
-export const BM25_B = 0.75;
-/** Multiplier for title-field matches (title hits outweigh body hits 2:1). */
-export const TITLE_FIELD_WEIGHT = 2;
-/**
- * One pass, two run shapes: ASCII alphanumeric words, or maximal CJK runs.
- * Runs never mix scripts because the alternation splits at the boundary, so
- * 「深色主题dark主题」 tokenizes as 深色/色主/主题, "dark", 主题.
- */
-const TOKEN_RUN_PATTERN = /[a-z0-9]+|[\u4e00-\u9fff]+/g;
-const ASCII_RUN_PATTERN = /^[a-z0-9]+$/;
-/**
- * Tokenize text for relevance scoring: lowercase ASCII runs become word
- * tokens; CJK runs become overlapping character bigrams (a single-character
- * run stays a unigram). Deterministic and allocation-light — safe to call per
- * injection build.
- *
- * @param text Arbitrary entry or query text.
- * @returns Tokens in occurrence order (duplicates kept; consumers dedupe when
- *          order-independent weighting is wanted).
- */
-export function tokenize(text) {
-    const tokens = [];
-    for (const match of text.toLowerCase().matchAll(TOKEN_RUN_PATTERN)) {
-        const run = match[0];
-        if (ASCII_RUN_PATTERN.test(run)) {
-            tokens.push(run);
-        }
-        else if (run.length === 1) {
-            tokens.push(run);
-        }
-        else {
-            for (let i = 0; i < run.length - 1; i += 1) {
-                tokens.push(run.slice(i, i + 2));
-            }
-        }
-    }
-    return tokens;
-}
-function buildFieldStats(fieldTokens) {
-    const tfs = fieldTokens.map((tokens) => {
-        const tf = new Map();
-        for (const token of tokens) {
-            tf.set(token, (tf.get(token) ?? 0) + 1);
-        }
-        return tf;
-    });
-    const df = new Map();
-    let totalLength = 0;
-    for (let position = 0; position < tfs.length; position += 1) {
-        const tf = tfs[position];
-        let length = 0;
-        for (const count of tf.values()) {
-            length += count;
-        }
-        totalLength += length;
-        for (const token of tf.keys()) {
-            df.set(token, (df.get(token) ?? 0) + 1);
-        }
-    }
-    return {
-        tfs,
-        lengths: fieldTokens.map((tokens) => tokens.length),
-        df,
-        averageLength: tfs.length === 0 ? 0 : totalLength / tfs.length,
-    };
-}
-/**
- * Build the corpus statistics (per-field tf, df, average length) for one
- * ranking call. Pure: the index reads its input snapshot and never mutates
- * the entries.
- *
- * @param entries The candidate entries being ranked this call.
- * @returns An index that answers {@link relevanceScore} for exactly these
- *          entries (identity-keyed).
- */
-export function buildRelevanceIndex(entries) {
-    const titles = [];
-    const bodies = [];
-    for (const entry of entries) {
-        titles.push(tokenize(entry.title));
-        bodies.push(tokenize(`${entry.content} ${entry.path}`));
-    }
-    return {
-        size: entries.length,
-        positions: new Map(entries.map((entry, position) => [entry, position])),
-        titles: buildFieldStats(titles),
-        bodies: buildFieldStats(bodies),
-    };
-}
-/** One field's BM25 contribution for a single term (0 when the term is absent). */
-function bm25Term(termFrequency, documentFrequency, corpusSize, docLength, averageLength) {
-    if (termFrequency <= 0 || documentFrequency <= 0) {
-        return 0;
-    }
-    const inverseDocumentFrequency = Math.log(1 + (corpusSize - documentFrequency + 0.5) / (documentFrequency + 0.5));
-    const normalization = averageLength > 0 ? 1 - BM25_B + BM25_B * (docLength / averageLength) : 1;
-    return inverseDocumentFrequency * ((termFrequency * (BM25_K1 + 1)) / (termFrequency + BM25_K1 * normalization));
-}
-/**
- * Field-weighted BM25 score of `entry` against `query` within `index`:
- * `TITLE_FIELD_WEIGHT × bm25(title) + bm25(body)`. Query tokens are deduped,
- * so repeating a word adds no weight.
- *
- * @returns A score > 0 when at least one query token occurs in the entry
- *          (either field), and exactly 0 otherwise — the property rankEntries'
- *          relevance-first ordering relies on. Never throws; an entry outside
- *          the index simply scores 0.
- */
-export function relevanceScore(index, entry, query) {
-    const position = index.positions.get(entry);
-    if (position === undefined || index.size === 0) {
-        return 0;
-    }
-    const seen = new Set();
-    let titleScore = 0;
-    let bodyScore = 0;
-    for (const token of tokenize(query)) {
-        if (seen.has(token)) {
-            continue;
-        }
-        seen.add(token);
-        const titleDf = index.titles.df.get(token) ?? 0;
-        if (titleDf > 0) {
-            titleScore += bm25Term(index.titles.tfs[position]?.get(token) ?? 0, titleDf, index.size, index.titles.lengths[position] ?? 0, index.titles.averageLength);
-        }
-        const bodyDf = index.bodies.df.get(token) ?? 0;
-        if (bodyDf > 0) {
-            bodyScore += bm25Term(index.bodies.tfs[position]?.get(token) ?? 0, bodyDf, index.size, index.bodies.lengths[position] ?? 0, index.bodies.averageLength);
-        }
-    }
-    return TITLE_FIELD_WEIGHT * titleScore + bodyScore;
-}
-//# sourceMappingURL=search.js.map

package/lib/service.d.ts

@@ -1,63 +0,0 @@
-/**
- * The evolution engine: the only entry point that mutates harness state.
- * Every mutation path goes through here so snapshot-before-write, apply
- * accounting, persistence, and result history are enforced in one place.
- */
-import type { EntrySource, HarnessScope, HarnessState, RefinementProposal, RefinementResult } from "./types.js";
-import { applyRefinementProposal } from "./apply.js";
-import type { HistoryRetention } from "./store.js";
-/** A post-commit apply failure that still carries the durable applied result. */
-export declare class EvolutionApplyPostCommitError extends Error {
-    readonly result: RefinementResult;
-    readonly scope: HarnessScope;
-    readonly storeId: string | undefined;
-    readonly cause: unknown;
-    constructor(message: string, result: RefinementResult, scope: HarnessScope, storeId: string | undefined, cause: unknown);
-}
-export interface ApplyContext {
-    scope: HarnessScope;
-    sessionId?: string;
-    /** When set, optimistic-concurrency checks reject edits whose entries changed since this baseline. */
-    baselineState?: Parameters<typeof applyRefinementProposal>[0];
-    /** Trajectory citation stamped into newly created entries (see apply.ts). */
-    source?: EntrySource | undefined;
-    /** Marks the resulting refinement as the deterministic rollback of another (audit chain). */
-    rollbackOf?: string | undefined;
-}
-export interface EvolutionHooks {
-    /** Called after every applied refinement (side-effect boundary: skills sync, etc.). */
-    onApplied?: (result: RefinementResult) => void;
-}
-export interface EvolutionEngineOptions {
-    /**
-     * Storage-hygiene retention (#20): how many snapshots / JSONL tail
-     * lines each apply keeps. Resolved with generous defaults — rollback
-     * only needs recent snapshots and readers need a working window.
-     */
-    historyRetain?: Partial<HistoryRetention>;
-}
-export declare function createEvolutionEngine(baseDir: string, hooks?: EvolutionHooks, opts?: EvolutionEngineOptions): {
-    load: (scope: HarnessScope, sessionId: string | undefined) => HarnessState;
-    apply: (scope: HarnessScope, sessionId: string | undefined, proposal: RefinementProposal, context?: ApplyContext) => RefinementResult;
-    rollback: (scope: HarnessScope, sessionId: string | undefined, refinementId: string) => RefinementResult;
-    rollbackResult: (scope: HarnessScope, sessionId: string | undefined, target: RefinementResult) => RefinementResult;
-    history: (scope: HarnessScope, sessionId: string | undefined) => RefinementResult[];
-    exportStore: (scope: HarnessScope, sessionId: string | undefined) => ExportedStore;
-    importStore: (scope: HarnessScope, sessionId: string | undefined, payload: unknown) => {
-        entries: number;
-        refinements: number;
-    };
-    baseDir: string;
-    retention: HistoryRetention;
-};
-/** The on-disk shape `/evolve export` writes and `/evolve import` reads. */
-export interface ExportedStore {
-    version: number;
-    scope: HarnessScope;
-    schema: number;
-    entries: HarnessState["entries"];
-    refinements: HarnessState["refinements"];
-    history: RefinementResult[];
-}
-export type EvolutionEngine = ReturnType<typeof createEvolutionEngine>;
-//# sourceMappingURL=service.d.ts.map

package/lib/service.js

@@ -1,253 +0,0 @@
-import { CONFLICT_HINT_KEY } from "./types.js";
-import { applyRefinementProposal } from "./apply.js";
-import { randomUUID } from "node:crypto";
-import { rollbackProposal } from "./rollback.js";
-import { loadHarnessState, saveHarnessState } from "./state.js";
-import { appendResult, loadResults, pruneJsonlFile, pruneSnapshots, resolveHistoryRetention, snapshotBefore, storePaths } from "./store.js";
-import { materializeMemoryProjection } from "./projection.js";
-import { CONFLICT_BLOCK_SCORE, CONFLICT_WARN_SCORE, buildConflictNotice, mostSimilarEntry, secretLeakReason } from "./promotion.js";
-/** A post-commit apply failure that still carries the durable applied result. */
-export class EvolutionApplyPostCommitError extends Error {
-    result;
-    scope;
-    storeId;
-    cause;
-    constructor(message, result, scope, storeId, cause) {
-        super(message);
-        this.result = result;
-        this.scope = scope;
-        this.storeId = storeId;
-        this.cause = cause;
-    }
-}
-export function createEvolutionEngine(baseDir, hooks = {}, opts = {}) {
-    const retention = resolveHistoryRetention(opts.historyRetain);
-    /**
-     * Load a scope's state. For `project` the `sessionId` parameter carries
-     * the project key (see `resolveProjectKey` in project.ts); callers
-     * derive it with `projectKeyOf(agent)` and pass it through unchanged.
-     */
-    function load(scope, sessionId) {
-        return loadHarnessState(storePaths(baseDir, scope, sessionId).stateDir, scope);
-    }
-    function apply(scope, sessionId, proposal, context) {
-        const paths = storePaths(baseDir, scope, sessionId);
-        // Working state is ALWAYS the freshest on-disk snapshot: apply mutates
-        // and persists the state whole-file, so building on the caller's
-        // planning-time copy would silently overwrite concurrent writers
-        // (another gate run, another session writing global). The caller's
-        // baselineState is ONLY the optimistic-concurrency comparison baseline
-        // — "reject edits whose target changed since planning" (review audit
-        // 2026-08-28 B1: the two roles were previously folded into one object,
-        // which made the advertised guard unreachable).
-        const state = load(scope, sessionId);
-        // Write-time conflict guard (R2): persistent-scope creates are
-        // checked against the existing same-kind entries BEFORE any side
-        // effect — a near-duplicate is rejected with an actionable error
-        // (evolve_update instead), a moderate overlap proceeds stamped with
-        // CONFLICT_HINT_KEY. Rollbacks bypass the guard: re-creating an entry
-        // that resembles its successor is the point of rollback. Local scope
-        // is never blocked (scratch space); the wrapup/fate promotion path
-        // already enforces its own overlap policy there.
-        //
-        // Secret-leak guard (P0, same throat): every persistent-scope create
-        // and update is screened before any side effect. Project and global
-        // stores both outlive the current session, so approval never turns a
-        // credential-shaped literal into an allowed write. The screen covers
-        // every field the edit can plant: title, content, and the JSON forms
-        // of reference, arguments, and metadata. Fixed patterns, not policy-
-        // configurable.
-        const warnHits = new Map();
-        if ((scope === "project" || scope === "global") && !context?.rollbackOf) {
-            for (const [index, edit] of proposal.edits.entries()) {
-                if (edit.action === "create" || edit.action === "update") {
-                    const screenable = [
-                        typeof edit.id === "string" ? edit.id : "",
-                        typeof edit.path === "string" ? edit.path : "",
-                        typeof edit.title === "string" ? edit.title : "",
-                        typeof edit.content === "string" ? edit.content : "",
-                        edit.reference !== undefined ? JSON.stringify(edit.reference) : "",
-                        edit.arguments !== undefined ? JSON.stringify(edit.arguments) : "",
-                        edit.metadata !== undefined ? JSON.stringify(edit.metadata) : "",
-                    ];
-                    const secret = secretLeakReason(screenable.join("\n"));
-                    if (secret) {
-                        throw new Error(`${edit.action} blocked: ${secret}`);
-                    }
-                }
-                if (edit.action !== "create")
-                    continue;
-                // An unknown kind must fail per-edit in validateEdit, never
-                // crash the whole proposal here (review audit 2026-08-28 S1).
-                const corpus = state.entries[edit.kind];
-                if (!corpus)
-                    continue;
-                const hit = mostSimilarEntry(Object.values(corpus), edit.title ?? "", edit.content ?? "", CONFLICT_WARN_SCORE);
-                if (!hit)
-                    continue;
-                if (hit.score >= CONFLICT_BLOCK_SCORE) {
-                    throw new Error(`create blocked: ${buildConflictNotice(hit)} already lives in the global ${edit.kind} store — use evolve_update on it instead of adding a duplicate`);
-                }
-                warnHits.set(index, hit);
-            }
-        }
-        const id = `evolve_${Date.now().toString(36)}_${randomUUID().slice(0, 8)}`;
-        // Code-enforced snapshot: runs before any mutation, cannot be skipped by the model.
-        snapshotBefore(paths, id);
-        const result = applyRefinementProposal(state, proposal, {
-            id,
-            scope,
-            ...(context?.source ? { source: context.source } : {}),
-            ...(context?.baselineState ? { baselineState: context.baselineState } : {}),
-            ...(context?.rollbackOf ? { rollbackOf: context.rollbackOf } : {}),
-        });
-        // Stamp warn-tier conflicts onto the freshly created entries (both the
-        // live state and the result's after-snapshot stay coherent).
-        for (const [index, hit] of warnHits) {
-            const applied = result.appliedEdits[index];
-            if (!applied?.applied || applied.action !== "create" || !applied.id)
-                continue;
-            const hint = `${applied.kind}:${hit.id}:${hit.score.toFixed(2)}`;
-            const live = state.entries[applied.kind][applied.id];
-            if (live) {
-                live.metadata[CONFLICT_HINT_KEY] = hint;
-                if (applied.after) {
-                    applied.after.metadata[CONFLICT_HINT_KEY] = hint;
-                }
-            }
-        }
-        saveHarnessState(paths.stateDir, state);
-        try {
-            appendResult(paths, result);
-        }
-        catch (cause) {
-            throw new EvolutionApplyPostCommitError(`Refinement ${result.id} persisted state but failed to append history: ${cause instanceof Error ? cause.message : String(cause)}`, result, scope, sessionId, cause);
-        }
-        // Storage hygiene (#20): bound the append-only past at write time —
-        // snapshots keep the newest N, the per-store history keeps its tail.
-        // Best-effort (never throws): a prune failure must not fail the apply.
-        try {
-            pruneSnapshots(paths.snapshotsDir, retention.snapshots);
-        }
-        catch {
-            // ignored — the next apply retries
-        }
-        try {
-            pruneJsonlFile(paths.resultsPath, retention.refinements);
-        }
-        catch {
-            // ignored — the next apply retries
-        }
-        // Readable Markdown projection (P1): rewritten from the post-apply
-        // state whenever a memory edit landed, so rollback and archive stay
-        // in sync through this same apply path. The model has no writer for
-        // these files — only this engine entry point materializes them.
-        if (result.appliedEdits.some((edit) => edit.applied && edit.kind === "memory")) {
-            try {
-                materializeMemoryProjection(paths.stateDir, state);
-            }
-            catch {
-                // ignored — the projection is derived (JSON stays the source
-                // of truth) and the next memory apply retries
-            }
-        }
-        try {
-            hooks.onApplied?.(result);
-        }
-        catch (cause) {
-            throw new EvolutionApplyPostCommitError(`Refinement ${result.id} persisted state but a post-commit hook failed: ${cause instanceof Error ? cause.message : String(cause)}`, result, scope, sessionId, cause);
-        }
-        return result;
-    }
-    /** Roll back an already-observed result without consulting history. */
-    function rollbackResult(scope, sessionId, target) {
-        return apply(scope, sessionId, rollbackProposal(target), { scope, rollbackOf: target.id });
-    }
-    function rollback(scope, sessionId, refinementId) {
-        const paths = storePaths(baseDir, scope, sessionId);
-        const history = loadResults(paths);
-        const target = history.find((item) => item.id === refinementId);
-        if (!target) {
-            throw new Error(`Refinement ${refinementId} not found in ${scope} history`);
-        }
-        return rollbackResult(scope, sessionId, target);
-    }
-    function history(scope, sessionId) {
-        return loadResults(storePaths(baseDir, scope, sessionId));
-    }
-    /** Serialize one store (entries + refinement history) for `/evolve export`. */
-    function exportStore(scope, sessionId) {
-        const state = load(scope, sessionId);
-        return {
-            version: 1,
-            scope,
-            schema: state.schema,
-            entries: state.entries,
-            refinements: state.refinements,
-            history: history(scope, sessionId),
-        };
-    }
-    /**
-     * Replace one store from an export payload (raw state write — the same
-     * semantics the command always had: no snapshot, no per-edit validation,
-     * the payload is trusted because a human handed over the file).
-     */
-    function importStore(scope, sessionId, payload) {
-        if (!isValidExport(payload)) {
-            throw new Error("invalid export file shape: expected {version, entries: {prompt, memory, skill, subagent}, refinements, history}");
-        }
-        const entriesBlock = payload["entries"];
-        const state = {
-            schema: typeof payload["schema"] === "number" ? payload["schema"] : 1,
-            entries: {
-                prompt: toEntryRecord(entriesBlock["prompt"]),
-                memory: toEntryRecord(entriesBlock["memory"]),
-                skill: toEntryRecord(entriesBlock["skill"]),
-                subagent: toEntryRecord(entriesBlock["subagent"]),
-            },
-            refinements: Array.isArray(payload["refinements"]) ? payload["refinements"] : [],
-        };
-        const paths = storePaths(baseDir, scope, sessionId);
-        saveHarnessState(paths.stateDir, state);
-        let refinements = 0;
-        if (Array.isArray(payload["history"])) {
-            for (const result of payload["history"]) {
-                if (isResultRecord(result)) {
-                    appendResult(paths, result);
-                    refinements += 1;
-                }
-            }
-            // Storage hygiene (#20): an imported history obeys the same tail
-            // budget as a live one.
-            try {
-                pruneJsonlFile(paths.resultsPath, retention.refinements);
-            }
-            catch {
-                // ignored — the next apply retries
-            }
-        }
-        const entries = Object.values(state.entries).reduce((n, byKind) => n + Object.keys(byKind).length, 0);
-        return { entries, refinements };
-    }
-    return { load, apply, rollback, rollbackResult, history, exportStore, importStore, baseDir, retention };
-}
-function toEntryRecord(value) {
-    if (typeof value !== "object" || value === null || Array.isArray(value)) {
-        return {};
-    }
-    return value;
-}
-function isValidExport(payload) {
-    if (typeof payload !== "object" || payload === null || Array.isArray(payload))
-        return false;
-    const record = payload;
-    const entries = record["entries"];
-    if (typeof entries !== "object" || entries === null || Array.isArray(entries))
-        return false;
-    const kinds = ["prompt", "memory", "skill", "subagent"];
-    return kinds.every((kind) => Object.prototype.hasOwnProperty.call(entries, kind));
-}
-function isResultRecord(value) {
-    return typeof value === "object" && value !== null && "id" in value && "appliedEdits" in value;
-}
-//# sourceMappingURL=service.js.map

package/lib/skill-render.d.ts

@@ -1,23 +0,0 @@
-/**
- * Skill rendering: pure functions that convert harness entries into
- * SKILL.md documents. Extracted from skill.ts to break the circular
- * dependency between skill.ts ↔ skillquality.ts.
- *
- * Both skill.ts (materializer) and skillquality.ts (validator) need
- * these rendering functions; importing from this shared leaf module
- * keeps the dependency graph acyclic.
- */
-import type { HarnessEntry } from "./types.js";
-/** Convert a harness entry id (underscore slug) to a kebab-case skill name. */
-export declare function skillNameOf(id: string): string;
-/**
- * Render a harness skill entry as a discoverable SKILL.md document.
- *
- * 2026-08-22: the frontmatter description now carries a ROUTING HINT —
- * title plus the first meaningful content line — instead of the bare title.
- * The skill catalog matches on description; a title-only description gave
- * loaders nothing to route on (observed: materialized skills were 7-line
- * stubs with a one-line description and no use-when signal).
- */
-export declare function renderSkillMarkdown(entry: HarnessEntry): string;
-//# sourceMappingURL=skill-render.d.ts.map

package/lib/skill-render.js

@@ -1,69 +0,0 @@
-/** Convert a harness entry id (underscore slug) to a kebab-case skill name. */
-export function skillNameOf(id) {
-    return id.toLowerCase().replace(/_/g, "-");
-}
-/**
- * First content line usable as a routing hint: non-empty, not a Markdown
- * heading, not a list marker, not frontmatter. Undefined when the body is
- * effectively empty.
- */
-function routingHint(content) {
-    for (const rawLine of content.split("\n")) {
-        const line = rawLine.trim();
-        if (line.length === 0)
-            continue;
-        if (line.startsWith("#") || line.startsWith("---") || line.startsWith("-") || line.startsWith("*"))
-            continue;
-        return oneLine(line);
-    }
-    return undefined;
-}
-/** Max rendered frontmatter description length (loaders truncate anyway). */
-const MAX_DESCRIPTION_LENGTH = 240;
-/**
- * Render a harness skill entry as a discoverable SKILL.md document.
- *
- * 2026-08-22: the frontmatter description now carries a ROUTING HINT —
- * title plus the first meaningful content line — instead of the bare title.
- * The skill catalog matches on description; a title-only description gave
- * loaders nothing to route on (observed: materialized skills were 7-line
- * stubs with a one-line description and no use-when signal).
- */
-export function renderSkillMarkdown(entry) {
-    const hint = routingHint(entry.content);
-    const base = oneLine(entry.title);
-    let description;
-    if (base.length === 0) {
-        description = (hint ?? "").slice(0, MAX_DESCRIPTION_LENGTH);
-    }
-    else if (hint !== undefined && !base.toLowerCase().includes(hint.toLowerCase())) {
-        description = `${base} — use when: ${hint}`.slice(0, MAX_DESCRIPTION_LENGTH);
-    }
-    else {
-        description = base.slice(0, MAX_DESCRIPTION_LENGTH);
-    }
-    const lines = [
-        "---",
-        `name: ${skillNameOf(entry.id)}`,
-        `description: ${description}`,
-        "---",
-        "",
-        entry.content.trim(),
-    ];
-    const reference = entry.reference;
-    if (reference && typeof reference === "object" && Object.keys(reference).length > 0) {
-        lines.push("", "## Invocation");
-        for (const [key, value] of Object.entries(reference)) {
-            lines.push(`- ${key}: ${JSON.stringify(value)}`);
-        }
-    }
-    const args = entry.arguments;
-    if (args && typeof args === "object" && Object.keys(args).length > 0) {
-        lines.push("", "## Arguments", "```json", JSON.stringify(entry.arguments, null, 2), "```");
-    }
-    return `${lines.join("\n").trimEnd()}\n`;
-}
-function oneLine(text) {
-    return text.replace(/\s+/g, " ").trim();
-}
-//# sourceMappingURL=skill-render.js.map

package/lib/skill.d.ts

@@ -1,15 +0,0 @@
-import type { RefinementResult } from "./types.js";
-export { renderSkillMarkdown, skillNameOf } from "./skill-render.js";
-/** Resolve and defend the skill directory for an entry id. */
-export declare function skillDir(skillsRoot: string, id: string): string;
-/**
- * Apply the skill-kind edits of an applied refinement to the skills root.
- * Returns materialization warnings (rendered-SKILL.md mechanical problems
- * and dangling resource references) — the file is still written, but the
- * caller should surface them: a rendered file that fails the platform's
- * frontmatter rules would be IGNORED by the skill loader, and a body
- * referencing resources the entry does not ship would load with broken
- * links.
- */
-export declare function syncSkillsFromResult(skillsRoot: string, result: RefinementResult): string[];
-//# sourceMappingURL=skill.d.ts.map

package/lib/skill.js

@@ -1,80 +0,0 @@
-/**
- * Skill materializer: syncs skill-kind harness entries to the DSH skills
- * filesystem (`$DSH_HOME/skills/<kebab-name>/SKILL.md`) so the `skill` tool
- * and catalog can discover and load them. Writes are atomic (tmp + rename)
- * so the filesystem watcher never sees a partial file.
- *
- * Skill names must be kebab-case (the harness store ids are underscore slugs;
- * the materialized name converts `_` → `-`).
- */
-import { existsSync, mkdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import { join, resolve, sep } from "node:path";
-import { renderSkillMarkdown, skillNameOf } from "./skill-render.js";
-import { skillResourceRefs, validateRenderedSkill } from "./skillquality.js";
-export { renderSkillMarkdown, skillNameOf } from "./skill-render.js";
-/** Resolve and defend the skill directory for an entry id. */
-export function skillDir(skillsRoot, id) {
-    const root = resolve(skillsRoot);
-    const dir = resolve(join(root, skillNameOf(id)));
-    if (dir !== root && !dir.startsWith(`${root}/`) && !dir.startsWith(`${root}${sep}`)) {
-        throw new Error(`skill path escapes skills root: ${dir}`);
-    }
-    return dir;
-}
-/**
- * Apply the skill-kind edits of an applied refinement to the skills root.
- * Returns materialization warnings (rendered-SKILL.md mechanical problems
- * and dangling resource references) — the file is still written, but the
- * caller should surface them: a rendered file that fails the platform's
- * frontmatter rules would be IGNORED by the skill loader, and a body
- * referencing resources the entry does not ship would load with broken
- * links.
- */
-export function syncSkillsFromResult(skillsRoot, result) {
-    const warnings = [];
-    for (const edit of result.appliedEdits) {
-        if (edit.kind !== "skill" || !edit.applied)
-            continue;
-        if (edit.action === "delete" || !edit.after) {
-            removeSkill(skillsRoot, edit.id);
-            continue;
-        }
-        warnings.push(...writeSkill(skillsRoot, edit.after));
-    }
-    return warnings;
-}
-/** Write one skill entry as a SKILL.md; returns materialization warnings. */
-function writeSkill(skillsRoot, entry) {
-    const dir = skillDir(skillsRoot, entry.id);
-    mkdirSync(dir, { recursive: true });
-    const temp = join(dir, `SKILL.md.${process.pid}.tmp`);
-    writeFileSync(temp, renderSkillMarkdown(entry), "utf8");
-    renameSync(temp, join(dir, "SKILL.md"));
-    return materializationWarnings(dir, entry);
-}
-/** Post-write checks on the exact file that landed on disk. */
-function materializationWarnings(dir, entry) {
-    const warnings = [];
-    for (const problem of validateRenderedSkill(entry)) {
-        warnings.push(`skill ${entry.id}: rendered SKILL.md would be ignored by the platform: ${problem}`);
-    }
-    const root = resolve(dir);
-    for (const ref of skillResourceRefs(entry.content)) {
-        const target = resolve(root, ref);
-        if (target !== root && !target.startsWith(`${root}${sep}`)) {
-            warnings.push(`skill ${entry.id}: body resource reference escapes the skill directory: ${ref}`);
-            continue;
-        }
-        if (!existsSync(target)) {
-            warnings.push(`skill ${entry.id}: body references missing resource ${ref} (expected at ${target})`);
-        }
-    }
-    return warnings;
-}
-function removeSkill(skillsRoot, id) {
-    const dir = skillDir(skillsRoot, id);
-    if (existsSync(dir)) {
-        rmSync(dir, { recursive: true, force: true });
-    }
-}
-//# sourceMappingURL=skill.js.map