@lmzhen/dsh-evolution-core 0.30.18 → 0.30.19

package/lib/types/index.d.ts

@@ -84,6 +84,7 @@ export * from './drift-signals.ts';
 export * from './skill-history.ts';
 export * from './unit-members.ts';
 export * from './skill-store.ts';
+export * from './skill-revision.ts';
 export * from './store-ledger.ts';
 export * from './reachability.ts';
 export * from './state-store.ts';

package/lib/types/index.js

@@ -85,6 +85,7 @@ export * from "./drift-signals.js";
 export * from "./skill-history.js";
 export * from "./unit-members.js";
 export * from "./skill-store.js";
+export * from "./skill-revision.js";
 export * from "./store-ledger.js";
 export * from "./reachability.js";
 export * from "./state-store.js";

package/lib/types/params.js

@@ -186,7 +186,7 @@ export const PARAM_EXPOSURE = Object.freeze([
     { id: 'threatExemptLabels', group: 'deployment', tier: 'E1', authority: 'cordis', owner: 'evolution-threat', applies: 'none', docAnchor: 'PARAMETERS.md#deployment', summary: 'Threat labels the deployment declares benign (safety surface, never user-writable).', why: 'security' },
     { id: 'evolution-threat.enabled', group: 'deployment', tier: 'E2', authority: 'cordis', owner: 'evolution-threat', applies: 'none', docAnchor: 'PARAMETERS.md#deployment', summary: 'Mount the write-time threat guard at all.', why: 'security' },
     { id: 'evolution-threat.maxScanChars', group: 'deployment', tier: 'E2', authority: 'cordis', owner: 'evolution-threat', applies: 'none', docAnchor: 'PARAMETERS.md#deployment', summary: 'Scan window size of the threat guard.', why: 'security' },
-    { id: 'evolution-approval.enabled', group: 'deployment', tier: 'E2', authority: 'cordis', owner: 'evolution-approval', applies: 'none', docAnchor: 'PARAMETERS.md#deployment', summary: 'Require approval before a staged write executes.', why: 'security' },
+    { id: 'evolution-approval.enabled', group: 'deployment', tier: 'E3', authority: 'cordis', owner: 'evolution-approval', applies: 'live', docAnchor: 'PARAMETERS.md#deployment', summary: 'Master approval switch: run the approval pipeline for foreground writes.', label: '启用批准流水线', hint: '关闭后前台写入不再经批准。', control: 'switch', unit: '', values: '', card: 'evolution-approval' },
     { id: 'evolution-approval.stageForeground', group: 'deployment', tier: 'E2', authority: 'cordis', owner: 'evolution-approval', applies: 'none', docAnchor: 'PARAMETERS.md#deployment', summary: 'Stage foreground agent writes for approval too.', why: 'security' },
     { id: 'evolution-approval.pendingTtlMs', group: 'deployment', tier: 'E3', authority: 'cordis', owner: 'evolution-approval', applies: 'live', docAnchor: 'PARAMETERS.md#deployment', summary: 'How long a staged write may wait before it expires: expired writes are closed as rejected and are NEVER executed; 0 (the default) means the window never expires.', label: '待批过期时间', hint: '一条待批写入最多等多久：超时就按「拒绝」关掉（不会执行，写效果不会落地）；0 = 永不过期（默认）。', control: 'number', unit: '毫秒', values: '', card: 'evolution-approval' },
     { id: 'approvalConfirm', group: 'write-caps', tier: 'E3', authority: 'cordis', owner: 'evolution-approval', applies: 'live', docAnchor: 'PARAMETERS.md#write-caps', summary: 'What the confirmation before an APPROVE does: write straight through, ask first, or treat an unanswered prompt as a cancel. The same three words skillWriteConfirm uses for a skill write.', label: '批准前先确认', hint: '点「批准」时要不要再确认一次：直接执行 / 先确认 / 等待超时即取消。默认直接执行（不打断批量批准）。', control: 'select', unit: '', values: 'auto|ask|timeout', valueLabels: '直接执行|先确认|等待超时即取消', card: 'evolution-approval' },

package/lib/types/platform-services.d.ts

@@ -20,7 +20,7 @@ export interface PlatformServiceProbe {
     /** Where the probe runs. */
     readonly side: 'host' | 'client';
 }
-/** The 25 probes, in service-name order (the guard checks this list against the tree). */
+/** The 26 probes, in service-name order (the guard checks this list against the tree). */
 export declare const PLATFORM_SERVICE_PROBES: readonly PlatformServiceProbe[];
 /**
  * The HOST-side probes that do not resolve in this runtime — what `/evolution doctor` prints as

package/lib/types/platform-services.js

@@ -11,7 +11,7 @@
  * `client` probes run in the browser half, where the host has no view of the seats.
  * @module @lmzhen/dsh-evolution-core
  */
-/** The 25 probes, in service-name order (the guard checks this list against the tree). */
+/** The 26 probes, in service-name order (the guard checks this list against the tree). */
 export const PLATFORM_SERVICE_PROBES = Object.freeze([
     { service: 'agents', feature: 'review and curator subagent wake-ups', side: 'host' },
     { service: 'approval', feature: 'the platform approval policy the approval row shadows', side: 'host' },
@@ -20,7 +20,7 @@ export const PLATFORM_SERVICE_PROBES = Object.freeze([
     { service: 'evolutionApproval', feature: 'pending writes: list, approve and reject from the command surface', side: 'host' },
     { service: 'evolutionCurator', feature: '/evolution curator subcommands, skill undo and history', side: 'host' },
     { service: 'evolutionIo', feature: 'every durable read and write (the IO seam)', side: 'host' },
-    { service: 'evolutionMerge', feature: 'merge rows and run state', side: 'host' },
+    { service: 'evolutionMerge', feature: 'merge command delegation and the merge doctor fact', side: 'host' },
     { service: 'hmr', feature: 'the preset install read-merge-write commit (the platform HMR lock serializes it)', side: 'host' },
     { service: 'evolutionMemoryBudget', feature: 'the memory-budget divergence section of this report', side: 'host' },
     { service: 'evolutionPolicy', feature: 'the policy snapshot that shadows row knobs', side: 'host' },

package/lib/types/run-registry.d.ts

@@ -75,10 +75,13 @@ export interface RunRecord {
     supersededAt?: number | undefined;
     /** The run this run was spawned from (approve/resume after an earlier command). */
     parentRunId?: string | undefined;
-    /** Merge-side projection; core lifecycle stays four-state. */
+    /** @deprecated Legacy merge projection; read-only compatibility, never written. */
     mergeStatus?: 'running' | 'succeeded' | 'failed' | 'cancelled' | 'awaiting-approval' | 'undone' | 'superseded' | 'interrupted' | 'orphan' | undefined;
+    /** @deprecated Legacy merge projection; read-only compatibility, never written. */
     stagingRef?: string | undefined;
+    /** @deprecated Legacy merge projection; read-only compatibility, never written. */
     pairKey?: string | undefined;
+    /** @deprecated Legacy merge projection; read-only compatibility, never written. */
     pairs?: readonly unknown[] | undefined;
 }
 /** What a started run gets: its id and the signal its work must honour. */
@@ -90,10 +93,13 @@ export interface RunHandle {
     readonly startedAt: number;
     readonly command?: RunCommand | undefined;
     readonly parentRunId?: string | undefined;
-    /** Merge-side projection; core lifecycle stays four-state. */
+    /** @deprecated Legacy merge projection; read-only compatibility, never written. */
     readonly mergeStatus?: 'running' | 'succeeded' | 'failed' | 'cancelled' | 'awaiting-approval' | 'undone' | 'superseded' | 'interrupted' | 'orphan' | undefined;
+    /** @deprecated Legacy merge projection; read-only compatibility, never written. */
     readonly stagingRef?: string | undefined;
+    /** @deprecated Legacy merge projection; read-only compatibility, never written. */
     readonly pairKey?: string | undefined;
+    /** @deprecated Legacy merge projection; read-only compatibility, never written. */
     readonly pairs?: readonly unknown[] | undefined;
 }
 /** How a run ended, as reported by its owner. */
@@ -101,6 +107,7 @@ export interface RunOutcome {
     state: 'succeeded' | 'failed' | 'cancelled';
     resultRef?: string | undefined;
     failure?: string | undefined;
+    /** @deprecated Legacy merge projection; read-only compatibility, never written. */
     mergeStatus?: 'running' | 'succeeded' | 'failed' | 'cancelled' | 'awaiting-approval' | 'undone' | 'superseded' | 'interrupted' | 'orphan' | undefined;
 }
 /** The registry surface the commands row drives. */
@@ -131,13 +138,19 @@ export interface RunRegistry {
         command?: RunCommand;
         total?: number;
         parentRunId?: string;
-        mergeStatus?: 'running' | 'succeeded' | 'failed' | 'cancelled' | 'awaiting-approval' | 'undone' | 'superseded' | 'interrupted' | 'orphan';
-        stagingRef?: string;
-        pairKey?: string;
-        pairs?: readonly unknown[];
     }): Promise<RunHandle>;
     /** Record a run's terminal state (first writer wins). */
     settle(id: string, outcome: RunOutcome): Promise<void>;
+    /**
+     * Settle a run this process does not own: the controlled orphan upgrade.
+     *
+     * Startup recovery runs AFTER `load()` (which materializes the orphan verdict for a
+     * dead owner). A committed unit then proves the run really succeeded, so the verdict
+     * must be upgradeable — but ONLY from an explicit orphan stamp (or a still-running
+     * row whose owner is gone). A run that is genuinely in flight elsewhere is refused.
+     * @returns whether the index now carries the requested terminal state.
+     */
+    settleRecovered(id: string, outcome: RunOutcome): Promise<boolean>;
     /** Record the current stage/progress of a running run. */
     stage(id: string, stage: RunStage, progress?: RunProgress): Promise<void>;
     /** Mark runs as superseded by a tree restore; idempotent. */

package/lib/types/run-registry.js

@@ -110,10 +110,6 @@ function parseIndex(raw) {
             ...(typeof record.failure === 'string' ? { failure: record.failure } : {}),
             ...(typeof record.supersededAt === 'number' ? { supersededAt: record.supersededAt } : {}),
             ...(typeof record.parentRunId === 'string' ? { parentRunId: record.parentRunId } : {}),
-            ...(record.mergeStatus === 'running' || record.mergeStatus === 'succeeded' || record.mergeStatus === 'failed' || record.mergeStatus === 'cancelled' || record.mergeStatus === 'awaiting-approval' || record.mergeStatus === 'undone' || record.mergeStatus === 'superseded' || record.mergeStatus === 'interrupted' || record.mergeStatus === 'orphan' ? { mergeStatus: record.mergeStatus } : {}),
-            ...(typeof record.stagingRef === 'string' ? { stagingRef: record.stagingRef } : {}),
-            ...(typeof record.pairKey === 'string' ? { pairKey: record.pairKey } : {}),
-            ...(Array.isArray(record.pairs) ? { pairs: record.pairs } : {}),
         });
     }
     return { ok: true, records, foreign, ...(notes.length > 0 ? { note: notes.join('; ') } : {}) };
@@ -139,7 +135,7 @@ export function newRunRegistry(options) {
     /** A row whose owner cannot be reached: `pid` absent (an older build) or not alive. */
     const ownerIsGone = (row) => row.pid === undefined || !isProcessAlive(row.pid);
     /** The verdict is materialized ONCE, so its `endedAt` (and the duration a reader sees) is stable. */
-    const orphanOf = (row) => ({ ...row, state: 'failed', mergeStatus: 'orphan', endedAt: now(), failure: ORPHAN_FAILURE });
+    const orphanOf = (row) => ({ ...row, state: 'failed', endedAt: now(), failure: ORPHAN_FAILURE });
     /** Every row this process knows, newest first. ALL reads go through here. */
     const view = () => [...owned.values(), ...foreign.values()].sort((a, b) => b.startedAt - a.startedAt);
     /** Retained history: every running row plus the newest terminal rows per kind. */
@@ -308,7 +304,7 @@ export function newRunRegistry(options) {
             const run = this.find(id);
             if (run?.state !== 'running')
                 return false;
-            await this.settle(id, { state: 'failed', failure: 'orphan', mergeStatus: 'orphan' });
+            await this.settle(id, { state: 'failed', failure: 'orphan' });
             return true;
         },
         async begin(kind, seed) {
@@ -325,10 +321,6 @@ export function newRunRegistry(options) {
                 pid: process.pid,
                 ...(seed?.command !== undefined ? { command: seed.command } : {}),
                 ...(seed?.parentRunId !== undefined ? { parentRunId: seed.parentRunId } : {}),
-                ...(seed?.mergeStatus !== undefined ? { mergeStatus: seed.mergeStatus } : {}),
-                ...(seed?.stagingRef !== undefined ? { stagingRef: seed.stagingRef } : {}),
-                ...(seed?.pairKey !== undefined ? { pairKey: seed.pairKey } : {}),
-                ...(seed?.pairs !== undefined ? { pairs: seed.pairs } : {}),
                 ...(seed?.total !== undefined ? { progress: { done: 0, total: seed.total } } : {}),
             });
             // Write-through (0.19.1, review P2): answering "started" promises a run another
@@ -360,8 +352,6 @@ export function newRunRegistry(options) {
                 if (row === undefined || row.supersededAt !== undefined)
                     continue;
                 row.supersededAt = now();
-                if (row.kind === 'merge')
-                    row.mergeStatus = 'superseded';
                 changed = true;
             }
             if (changed)
@@ -380,8 +370,6 @@ export function newRunRegistry(options) {
                     if (row.kind !== kind || row.supersededAt !== undefined)
                         continue;
                     row.supersededAt = now();
-                    if (row.kind === 'merge')
-                        row.mergeStatus = 'superseded';
                     marked += 1;
                 }
                 const kept = capped([...merged.values()]);
@@ -403,11 +391,46 @@ export function newRunRegistry(options) {
                 row.resultRef = outcome.resultRef;
             if (outcome.failure !== undefined)
                 row.failure = outcome.failure;
-            if (outcome.mergeStatus !== undefined)
-                row.mergeStatus = outcome.mergeStatus;
             controllers.delete(id);
             await persist();
         },
+        async settleRecovered(id, outcome) {
+            const local = owned.get(id);
+            if (local !== undefined) {
+                await this.settle(id, outcome);
+                return owned.get(id)?.state === outcome.state;
+            }
+            let changed = false;
+            await transactIo(options.io, path, (current) => {
+                const onDisk = parseIndex(current);
+                const row = onDisk.records.find(item => item.id === id);
+                if (row === undefined)
+                    return current;
+                // The two admissible sources: an unresolved running row with a dead owner, or
+                // the orphan verdict load() already materialized. Anything else is a real
+                // terminal answer (someone's cancel/success) and stays put.
+                const recoverable = (row.state === 'running' && ownerIsGone(row))
+                    || (row.state === 'failed' && row.failure === ORPHAN_FAILURE);
+                if (!recoverable)
+                    return current;
+                changed = true;
+                const next = {
+                    ...row,
+                    state: outcome.state,
+                    endedAt: now(),
+                    ...(outcome.resultRef === undefined ? {} : { resultRef: outcome.resultRef }),
+                    ...(outcome.failure === undefined ? {} : { failure: outcome.failure }),
+                };
+                const kept = capped(onDisk.records.map(item => item.id === id ? next : item));
+                const live = kept.filter(item => item.state === 'running');
+                const done = kept.filter(item => TERMINAL.has(item.state));
+                return JSON.stringify({ schemaVersion: RUNS_SCHEMA_VERSION, runs: [...live, ...done, ...onDisk.foreign] }, null, 2);
+            });
+            // Rebuild the foreign view so this process answers the upgraded verdict at once.
+            if (changed)
+                await this.load();
+            return changed;
+        },
         inFlight(kind) {
             return view().find(row => row.state === 'running' && (kind === undefined || row.kind === kind));
         },

package/lib/types/skill-history.d.ts

@@ -36,6 +36,10 @@ export declare const HISTORY_INDEX_VERSION = 1;
 export declare const BASELINE_ACTION = "baseline";
 /** G3b: one unit's head. Exactly one of the two forms is present (they never coexist). */
 export interface UnitHead {
+    /** The merge run this unit belongs to, when the writer recorded one. */
+    runId?: string;
+    /** This unit starts a fresh target baseline; older versions remain listable but outside it. */
+    baseline?: true;
     /** Representative shard: the unit's WHOLE manifest of moves (one entry per written path). */
     moves?: readonly Readonly<Record<string, unknown>>[];
     /** Representative shard: the skills this unit wrote, so members resolve without a directory scan. */

package/lib/types/skill-revision.d.ts

@@ -0,0 +1,37 @@
+/** One support file as read through the store (path is normalized `references/x.md`). */
+export interface RevisionFile {
+    readonly path: string;
+    readonly content: string;
+}
+/** The two-state content anchor: absent (no live skill) or a content hash. */
+export type RevisionAnchor = {
+    readonly kind: 'absent';
+} | {
+    readonly kind: 'present';
+    readonly sha256: string;
+};
+/**
+ * Canonical fingerprint of one skill's content.
+ *
+ * Field order and separators are a wire format: decisions persist anchors derived from
+ * this string, and a later commit compares against it. Do not reorder.
+ * @param name - the (trimmed) skill name.
+ * @param body - the SKILL.md text.
+ * @param files - every support file under SUPPORT_DIRS.
+ * @returns the fingerprint string to hash.
+ */
+export declare function revisionFingerprint(name: string, body: string, files: readonly RevisionFile[]): string;
+/** Hash one fingerprint into its anchor (CRLF-normalized by contentHash). */
+export declare function revisionAnchor(name: string, body: string, files: readonly RevisionFile[]): RevisionAnchor;
+/** Anchor for a skill whose body may be absent. */
+export declare function revisionAnchorOf(name: string, body: string | null, files: readonly RevisionFile[]): RevisionAnchor;
+/**
+ * Support digest over several skills' fingerprints: the union of their full content.
+ *
+ * Sort is by fingerprint (name-prefixed), so name order and fingerprint order agree and
+ * a decision-time digest can be recomputed by a committer that only has hashes.
+ * @param fingerprints - one fingerprint per involved skill (missing skills simply absent).
+ * @returns the digest recorded on a decision and re-checked at commit.
+ */
+export declare function revisionSupportDigest(fingerprints: readonly string[]): string;
+//# sourceMappingURL=skill-revision.d.ts.map

package/lib/types/skill-revision.js

@@ -0,0 +1,45 @@
+/**
+ * Content-revision identity shared by every planner that records a decision and every
+ * committer that re-checks it.
+ *
+ * A skill's revision covers the trimmed NAME, the SKILL.md body and every support file
+ * (`references/…`, `templates/…`, `scripts/…`, `assets/…`), each as read through the
+ * store. The merge domain records a decision-time anchor and the store compares the live
+ * anchor before writing; both sides must hash the same bytes or the compare is meaningless,
+ * so the hash lives HERE and nowhere else.
+ */
+import { contentHash } from "./mutations.js";
+/**
+ * Canonical fingerprint of one skill's content.
+ *
+ * Field order and separators are a wire format: decisions persist anchors derived from
+ * this string, and a later commit compares against it. Do not reorder.
+ * @param name - the (trimmed) skill name.
+ * @param body - the SKILL.md text.
+ * @param files - every support file under SUPPORT_DIRS.
+ * @returns the fingerprint string to hash.
+ */
+export function revisionFingerprint(name, body, files) {
+    const ordered = [...files].sort((left, right) => left.path.localeCompare(right.path));
+    return name + '\u0000' + body + '\u0000' + ordered.map(file => file.path + '\u0000' + file.content).join('\u0000');
+}
+/** Hash one fingerprint into its anchor (CRLF-normalized by contentHash). */
+export function revisionAnchor(name, body, files) {
+    return { kind: 'present', sha256: contentHash(revisionFingerprint(name, body, files)) };
+}
+/** Anchor for a skill whose body may be absent. */
+export function revisionAnchorOf(name, body, files) {
+    return body === null ? { kind: 'absent' } : revisionAnchor(name, body, files);
+}
+/**
+ * Support digest over several skills' fingerprints: the union of their full content.
+ *
+ * Sort is by fingerprint (name-prefixed), so name order and fingerprint order agree and
+ * a decision-time digest can be recomputed by a committer that only has hashes.
+ * @param fingerprints - one fingerprint per involved skill (missing skills simply absent).
+ * @returns the digest recorded on a decision and re-checked at commit.
+ */
+export function revisionSupportDigest(fingerprints) {
+    return contentHash([...fingerprints].sort().join('\u0000'));
+}
+//# sourceMappingURL=skill-revision.js.map

package/lib/types/skill-store.d.ts

@@ -37,6 +37,7 @@ import { transactIo, type EvolutionIoLike } from './io.ts';
 import { type Probe } from './probe.ts';
 import type { SkillLimits } from './limits.ts';
 import { type MutationRecord } from './mutations.ts';
+import { type RevisionAnchor, type RevisionFile } from './skill-revision.ts';
 import { type UnitHead, type SkillVersion } from './skill-history.ts';
 import { type SkillHealthAssessment, type SkillHealthThresholds } from './skill-health.ts';
 import type { EvolutionSkillMutatedEvent } from './events.ts';
@@ -181,6 +182,9 @@ export interface ArchiveOptions {
 }
 /** One multi-skill merge commit: target body + support files, with the source names it absorbs. */
 export interface CommitMergePlan {
+    readonly runId?: string;
+    /** The unit transaction id; history must record this exact id for undo. */
+    readonly unitId?: string;
     readonly target: string;
     /** Whether the target already exists. The caller planned this; commit re-checks it. */
     readonly targetExists: boolean;
@@ -196,6 +200,11 @@ export interface CommitMergePlan {
         readonly name: string;
         readonly body: string;
     }[];
+    /** Stage limits snapshot; absent uses the deployed store limits. */
+    readonly limits?: import('./limits.ts').SkillLimits;
+    readonly targetRevision?: RevisionAnchor;
+    readonly sourceRevisions?: Readonly<Record<string, RevisionAnchor>>;
+    readonly supportDigest?: string;
     readonly origin: WriteOrigin;
     readonly summary: string;
     /** Real write-phase callback used by UnitTransaction; not persisted. */
@@ -210,6 +219,8 @@ export interface CommitMergePlan {
 export interface CommitMergeResult {
     readonly ok: boolean;
     readonly message: string;
+    /** Typed refusal kind for the revision CAS (target/source/support changed after the plan). */
+    readonly code?: 'target-changed' | 'source-changed' | 'support-changed';
     readonly unitId?: string;
     readonly targetPath?: string;
     readonly archived?: readonly string[];
@@ -422,7 +433,20 @@ export declare class SkillLibrary {
     }): Promise<SkillSummary[]>;
     read(rawName: string): Promise<string | null>;
     /**
-  
+     * Content anchor of one live skill: name + body + every support file under SUPPORT_DIRS.
+     *
+     * This is the commit-side counterpart of the decision-time anchor recorded by the merge
+     * domain (see skill-revision.ts): both sides call the same fingerprint, so a changed
+     * source, target or support file cannot slip past the commit CAS.
+     * @param rawName - caller-supplied skill name (trimmed here).
+     * @returns present anchor, or absent when the skill has no SKILL.md.
+     */
+    revisionFingerprint(rawName: string): Promise<string | null>;
+    /** Content anchor of one live skill; the hash a decision records and a commit re-checks. */
+    revisionAnchor(rawName: string): Promise<RevisionAnchor>;
+    /** Every support file of one live skill, in listing order; unreadable/missing files fail loud. */
+    liveSupportFiles(rawName: string): Promise<readonly RevisionFile[]>;
+    /**
      * Single path-building choke point (rc.42 audit P2-5): every directory path
   
      * is built from the TRIMMED name, so a name that passes `badName` (which
@@ -527,6 +551,8 @@ export declare class SkillLibrary {
      * @returns the versions, oldest first.
      */
     listVersions(rawName: string): Promise<SkillVersion[]>;
+    /** Versions from the latest merge baseline onward; old versions stay listable via listVersions. */
+    listBaselineVersions(rawName: string): Promise<SkillVersion[]>;
     /**
      * One version's content, read back from the content-addressed blob store.
      * @param rawName - the skill's name.
@@ -535,6 +561,10 @@ export declare class SkillLibrary {
      *   blob cannot be read — never an empty string.
      */
     readVersion(rawName: string, v: number): Promise<string | null>;
+    /** Read an archived skill's human-readable reason, exact or stamped. */
+    readArchiveReason(rawName: string): Promise<string | null>;
+    /** Read an archived skill body (SKILL.md) by its original name, exact or stamped. */
+    readArchived(rawName: string): Promise<string | null>;
     /**
      * Pin or unpin a skill (`.pinned` marker). Pinned skills are protected from
      * deletion, from background-review writes, and from the lifecycle — a
@@ -577,6 +607,8 @@ export declare class SkillLibrary {
      * P2-4 (v19): a non-string entry (`skills: [123]`) is refused structurally
      * instead of throwing `name.includes is not a function`. */
     private safeSnapshotEntryName;
+    /** Mark merge-absorbed sources archived in the usage sidecar (FR-DATA-07). */
+    private foldArchivedUsage;
     archive(rawName: string, options?: ArchiveOptions, origin?: WriteOrigin): Promise<SkillActionResult>;
     /**
      * Commit one merge plan as a single multi-skill transaction.