@lmzhen/dsh-evolution-merge 0.30.16 → 0.30.18

package/lib/types/facts.js

@@ -0,0 +1,68 @@
+import { loadMergeState } from "./state.js";
+import { MERGE_COMMAND_SURFACE } from "./command-surface.js";
+const queueOf = (row) => row.state === 'approved' ? 'fuse' : row.queue;
+const isExpired = (row) => row.expired !== undefined;
+export function countsOf(rows) {
+    const active = { verify: 0, pending: 0, fuse: 0, skipped: 0 };
+    let expired = 0;
+    for (const row of rows) {
+        if (isExpired(row)) {
+            expired += 1;
+            continue;
+        }
+        active[queueOf(row)] += 1;
+    }
+    return { active, expired };
+}
+export function toRunView(record, readAt) {
+    const state = (record.mergeStatus ?? record.state);
+    return {
+        wireVersion: 1,
+        readAt,
+        id: record.id,
+        state,
+        command: record.command ?? 'scan',
+        ...(record.stage === undefined ? {} : { stage: record.stage }),
+        progress: record.progress === undefined ? null : { done: record.progress.done, total: record.progress.total },
+        startedAt: record.startedAt,
+        ...(record.endedAt === undefined ? {} : { endedAt: record.endedAt }),
+        ...(record.failure === undefined ? {} : { failure: { stage: 'settle', code: 'run-failed', retryable: false, retryFrom: 'none', detail: record.failure } }),
+        ...(record.parentRunId === undefined ? {} : { parentRunId: record.parentRunId }),
+        ...(record.pairKey === undefined ? {} : { currentPairKey: record.pairKey }),
+        actions: [
+            { id: 'status', command: '/evolution merge status ' + record.id, confirm: false, enabled: true },
+            { id: 'report', command: '/evolution merge report ' + record.id, confirm: false, enabled: record.resultRef !== undefined },
+            { id: 'cancel', command: '/evolution merge cancel ' + record.id, confirm: false, enabled: state === 'running' },
+        ],
+    };
+}
+/** GET projection: reads state + runs; never writes. */
+export async function readFacts(options) {
+    const loaded = await loadMergeState(options.io, options.home);
+    return buildFacts({
+        rows: loaded.state.rows,
+        runs: options.runs,
+        approval: options.approval,
+        readAt: options.readAt,
+        notes: loaded.ok ? [] : [loaded.note ?? 'state-unreadable'],
+    });
+}
+export function buildFacts(input) {
+    const ordered = [...input.runs].sort((a, b) => b.startedAt - a.startedAt);
+    const active = ordered.find(run => (run.mergeStatus ?? run.state) === 'running');
+    const last = ordered.find(run => (run.mergeStatus ?? run.state) !== 'running');
+    const notes = input.notes ?? [];
+    return {
+        wireVersion: 1,
+        readAt: input.readAt,
+        approval: { mergeApproval: input.approval },
+        counts: countsOf(input.rows),
+        active: active === undefined ? null : toRunView(active, input.readAt),
+        last: last === undefined ? null : toRunView(last, input.readAt),
+        startCommands: { scan: '/evolution merge scan', pair: '/evolution merge pair <a> <b>' },
+        fallback: MERGE_COMMAND_SURFACE.fallback,
+        notes,
+        degraded: notes.length > 0,
+    };
+}
+//# sourceMappingURL=facts.js.map

package/lib/types/gate-filter.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Gate filter: turn lexical/proposed candidates into the candidates scan may process.
+ * L0 keeps are dropped unless the deterministic 10% audit re-runs L2 and overrides.
+ */
+import type { MergeCandidate } from './contracts.ts';
+import { type GateCache, type GateFacts, type GateModelPort, type GateVerdict } from './ladder.ts';
+export interface GateFilterOptions {
+    readonly facts: readonly GateFacts[];
+    readonly model: GateModelPort;
+    readonly modelName: string;
+    readonly signal: AbortSignal;
+    readonly runSeed: string;
+    readonly cache?: GateCache;
+    readonly auditRate?: number;
+}
+export interface GateDecision {
+    readonly candidate: MergeCandidate;
+    readonly verdicts: readonly GateVerdict[];
+    readonly auditOverride: boolean;
+}
+export interface GateFilterResult {
+    readonly kept: readonly GateDecision[];
+    readonly dropped: readonly GateDecision[];
+    readonly errors: readonly {
+        readonly candidate: MergeCandidate;
+        readonly message: string;
+    }[];
+    readonly calls: number;
+}
+export declare function filterCandidates(candidates: readonly MergeCandidate[], options: GateFilterOptions): Promise<GateFilterResult>;
+//# sourceMappingURL=gate-filter.d.ts.map

package/lib/types/gate-filter.js

@@ -0,0 +1,64 @@
+import { pairKey } from "./contracts.js";
+import { runLadder, selectedForAudit } from "./ladder.js";
+function withGate(candidate, verdicts, auditOverride) {
+    const last = verdicts[verdicts.length - 1];
+    if (last === undefined)
+        return candidate;
+    return {
+        ...candidate,
+        gate: {
+            level: last.level,
+            verdict: last.verdict,
+            reason: last.reason,
+            ...(last.cached ? { cached: true } : {}),
+            ...(auditOverride ? { auditOverride: true } : {}),
+        },
+    };
+}
+export async function filterCandidates(candidates, options) {
+    const kept = [];
+    const dropped = [];
+    const errors = [];
+    let calls = 0;
+    for (const candidate of candidates) {
+        const first = await runLadder({
+            level: 'L0', candidate, facts: options.facts, model: options.model,
+            modelName: options.modelName, signal: options.signal,
+            ...(options.cache === undefined ? {} : { cache: options.cache }),
+        });
+        calls += first.calls;
+        if (first.route === 'error') {
+            errors.push({ candidate, message: first.error ?? 'gate error' });
+            continue;
+        }
+        if (first.route !== 'keep' || first.droppedAt !== 'L0') {
+            if (first.route === 'merge' || first.route === 'undecided')
+                kept.push({ candidate: withGate(candidate, first.verdicts, false), verdicts: first.verdicts, auditOverride: false });
+            else
+                dropped.push({ candidate, verdicts: first.verdicts, auditOverride: false });
+            continue;
+        }
+        if (!selectedForAudit(pairKey(candidate.a, candidate.b), options.runSeed, options.auditRate ?? 0.1)) {
+            dropped.push({ candidate, verdicts: first.verdicts, auditOverride: false });
+            continue;
+        }
+        const audit = await runLadder({
+            level: 'L0', startLevel: 'L2', candidate, facts: options.facts, model: options.model,
+            modelName: options.modelName, signal: options.signal,
+            ...(options.cache === undefined ? {} : { cache: options.cache }),
+        });
+        calls += audit.calls;
+        if (audit.route === 'merge' || audit.route === 'undecided') {
+            const all = [...first.verdicts, ...audit.verdicts];
+            kept.push({ candidate: withGate(candidate, all, true), verdicts: all, auditOverride: true });
+        }
+        else if (audit.route === 'error') {
+            errors.push({ candidate, message: audit.error ?? 'audit gate error' });
+        }
+        else {
+            dropped.push({ candidate, verdicts: [...first.verdicts, ...audit.verdicts], auditOverride: true });
+        }
+    }
+    return { kept, dropped, errors, calls };
+}
+//# sourceMappingURL=gate-filter.js.map

package/lib/types/index.d.ts

@@ -22,7 +22,11 @@ export interface MergePresentationScope {
         }, owner?: unknown) => unknown;
     };
 }
-export declare function engineConfigFromEnv(configuredRoot?: string): Record<string, unknown> | undefined;
+export interface EngineModelConfig {
+    readonly embedder_model: string;
+    readonly embedder_model_last: string;
+}
+export declare function engineConfigFromRoot(configuredRoot?: string): EngineModelConfig | undefined;
 export interface MergePresentationContext {
     inject(names: string[], run: (scope: MergePresentationScope) => void): void;
     readonly fiber?: unknown;
@@ -69,7 +73,6 @@ export * from './new-child-authoring.ts';
 export * from './status.ts';
 export * from './skipped.ts';
 export * from './read-commands.ts';
-export * from './routes.ts';
 export * from './merge-routes.ts';
 export * from './merge-command.ts';
 export * from './params.ts';

package/lib/types/index.js

@@ -4,13 +4,13 @@ import { screen as engineScreen } from '@lmzhen/dsh-evolution-merge-engine';
 import { selectWithErrors } from "./adapters/select.js";
 import { createEngineScreening } from "./adapters/engine-screen.js";
 import { createEngineRunner } from "./adapters/model-runner.js";
-import { authorityFrom, createSubagentChannel, DEFAULT_SKILL_LIMITS, evolutionHome, evolutionIoAdapter, newRunRegistry, newSkillLibrary, policyStageLimits, skillsRoot } from '@lmzhen/dsh-evolution-core';
+import { authorityFrom, createSubagentChannel, DEFAULT_SKILL_LIMITS, evolutionHome, evolutionIoAdapter, newRunRegistry, newSkillLibrary, policyStageLimits } from '@lmzhen/dsh-evolution-core';
 import { registerHostRoutes } from '@lmzhen/dsh-evolution-core/http-routes';
-import { loadMergeState, upsertRow } from "./state.js";
+import { loadMergeState, transactRows } from "./state.js";
 import { cleanupExpiredStaging } from "./staging.js";
 import { recoverCommitJournals } from "./commit-recovery.js";
 import { readCommitReceipts } from "./commit-receipt.js";
-import { transition } from "./coordinator.js";
+import { pairKey, rowIdOf } from "./contracts.js";
 import { makeMergeRoutes } from "./merge-routes.js";
 import { createMergeCommand, runMergeCommand } from "./merge-command.js";
 import { createMergeRuntime } from "./runtime.js";
@@ -27,15 +27,11 @@ export const Config = z.object({
     mergePairTimeoutMinutes: z.number().min(1).default(15),
     mergeModelsRoot: z.string().default(''),
 });
-export function engineConfigFromEnv(configuredRoot) {
-    const root = configuredRoot !== undefined && configuredRoot !== '' ? configuredRoot : process.env.SKILL_MERGE_MODELS_ROOT;
-    if (root === undefined || root === '')
+export function engineConfigFromRoot(configuredRoot) {
+    const root = configuredRoot?.trim() ?? '';
+    if (root === '')
         return undefined;
     return {
-        models_dir: '',
-        offline: true,
-        auto_provision: false,
-        embed_backend: 'local',
         embedder_model: join(root, 'potion-multilingual-128M-int8'),
         embedder_model_last: join(root, 'potion-multilingual-128M-pca64-int8'),
     };
@@ -91,7 +87,6 @@ export * from "./new-child-authoring.js";
 export * from "./status.js";
 export * from "./skipped.js";
 export * from "./read-commands.js";
-export * from "./routes.js";
 export * from "./merge-routes.js";
 export * from "./merge-command.js";
 export * from "./params.js";
@@ -123,7 +118,6 @@ export function apply(ctx, rawConfig = {}) {
         const home = evolutionHome();
         void loadMergeState(io, home).then(loaded => cleanupExpiredStaging(io, home, Date.now(), new Set(loaded.state.rows.map(row => row.runId).filter((id) => id !== undefined)))).catch((error) => { ctx.logger.warn('merge staging cleanup failed: ' + (error instanceof Error ? error.message : String(error))); });
         const runs = newRunRegistry({ io, home, warn: (message) => { ctx.logger.warn(message); } });
-        void runs.load();
         ctx.effect(() => {
             const host = ctx;
             if (typeof host.on !== 'function')
@@ -138,18 +132,14 @@ export function apply(ctx, rawConfig = {}) {
             io, ctx, authority: authorityFrom({ origin: 'subagent' }),
             limits: { ...DEFAULT_SKILL_LIMITS, ...policyStageLimits(policySnapshot?.get?.()) },
         });
-        const mergeSkillsRoot = skills.root ?? skillsRoot();
-        void recoverCommitJournals(io, home, Date.now(), mergeSkillsRoot, async (name) => {
-            const result = await skills.restoreFromArchive(name);
-            return result.ok;
-        }, (runId) => {
+        void runs.load().then(() => recoverCommitJournals(io, home, Date.now(), (runId) => {
             const run = runs.find(runId);
             return run !== undefined && run.state === 'running';
-        }).then((reports) => { if (reports.length > 0)
+        })).then((reports) => { if (reports.length > 0)
             ctx.logger.info('merge commit recovery: ' + reports.map(report => report.runId + '=' + report.action).join(', ')); }).catch((error) => { ctx.logger.warn('merge commit recovery failed: ' + (error instanceof Error ? error.message : String(error))); });
         const channel = subagentChannelAdapter(createSubagentChannel(ctx));
         const stage = new StageToolRegistry();
-        const engineConfig = engineConfigFromEnv(params.mergeModelsRoot);
+        const engineConfig = engineConfigFromRoot(params.mergeModelsRoot);
         const llm = ctx.get('llm');
         const defaultModel = ctx.get('agentDefaultModel');
         const runner = llm === undefined || defaultModel === undefined
@@ -160,7 +150,7 @@ export function apply(ctx, rawConfig = {}) {
             home,
             engine: { screen: engineScreen },
             select: selectWithErrors,
-            cfg: { ...(engineConfig ?? {}), judge: 'deepseek' },
+            cfg: { ...engineConfig, judge: 'deepseek' },
             ...(runner === undefined ? {} : { runner }),
             async onSelection(selection) {
                 const loaded = await loadMergeState(io, home);
@@ -168,12 +158,12 @@ export function apply(ctx, rawConfig = {}) {
                 for (const skipped of selection.skipped) {
                     if (loaded.state.rows.some(row => row.pairKey === skipped.pairKey))
                         continue;
-                    const next = transition(undefined, {
-                        type: 'gate-keep', a: skipped.a, b: skipped.b,
-                        ...(skipped.reason === undefined ? {} : { reason: skipped.reason }), at,
-                    });
-                    if (next.ok && next.row !== null)
-                        await upsertRow(io, home, () => Date.now(), next.row);
+                    const key = pairKey(skipped.a, skipped.b);
+                    await transactRows(io, home, tx => tx.createSkipped({
+                        id: rowIdOf(key), pairKey: key, a: skipped.a, b: skipped.b, version: 0,
+                        createdAt: at, updatedAt: at, origin: 'agent',
+                        state: 'skipped', reason: skipped.reason ?? 'gate-keep', attempts: 0,
+                    }).ok);
                 }
             },
         });

package/lib/types/ladder.js

@@ -57,7 +57,7 @@ function payloadFor(level, candidate, facts) {
 }
 const SYSTEM = 'Judge whether two skill documents describe the same reusable capability. Shared vocabulary or a shared preamble is not duplication. Return only strict JSON: {"verdict":1|0|-1,"reason":"..."}';
 function extractJson(text) {
-    const fenced = /\`\`\`(?:json)?\s*([\s\S]*?)\`\`\`/i.exec(text);
+    const fenced = /`\``(?:json)?\s*([\s\S]*?)`\``/i.exec(text);
     const body = fenced?.[1] ?? text;
     const start = body.indexOf('{');
     if (start < 0)

package/lib/types/merge-routes.d.ts

@@ -1,6 +1,6 @@
 /**
- * Four read-only merge routes: view / rows / run / runs. The host loads rows and runs; these
- * handlers only project. A missing merge service answers 503 instead of pretending empty.
+ * Four read-only merge routes: view / rows / body / history.
+ * The host loads rows and runs; these handlers only project wire envelopes.
  */
 import type { RunRecord } from '@lmzhen/dsh-evolution-core';
 import { type ConnectionFetchRouteLike, type DecisionAudit } from '@lmzhen/dsh-evolution-core/http-routes';

package/lib/types/merge-routes.js

@@ -1,6 +1,6 @@
 import { HOST_ROUTES, json, methodNotAllowed } from '@lmzhen/dsh-evolution-core/http-routes';
-import { buildMergeView, pageQueue, toRunFact } from "./routes.js";
-import { renderMarkdown } from "./domain/markdown.js";
+import { buildFacts } from "./facts.js";
+import { toBodyView, toHistoryView, toQueuePage } from "./wire-projection.js";
 const MERGE_PATHS = HOST_ROUTES.merge;
 const MERGE_BASE = MERGE_PATHS.view.slice(0, -'view'.length);
 export const MERGE_ROUTES = {
@@ -10,7 +10,8 @@ export const MERGE_ROUTES = {
     history: (MERGE_PATHS.history ?? MERGE_BASE + 'history'),
 };
 export function makeMergeRoutes(deps, _audit) {
-    const absent = () => json(503, { ok: false, error: { code: 'merge-service-absent', message: 'merge service is not mounted' } });
+    const absent = () => json(404, { wireVersion: 1, code: 'E-325', message: 'merge service is not mounted' });
+    const bad = (message) => json(400, { wireVersion: 1, code: 'merge-bad-query', message });
     const get = (request) => (request.method === 'GET' ? null : methodNotAllowed(['GET']));
     const url = (request) => new URL(request.url, 'http://local');
     return [
@@ -25,12 +26,10 @@ export function makeMergeRoutes(deps, _audit) {
                 const source = deps.getSource();
                 if (source === undefined)
                     return absent();
+                const readAt = Date.now();
+                const rows = await source.rows();
                 const runs = await source.runs(undefined, 20);
-                const latestMerge = runs.find(run => run.kind === 'merge');
-                return json(200, {
-                    ok: true,
-                    data: buildMergeView(await source.rows(), source.commands(), latestMerge === undefined ? undefined : toRunFact(latestMerge), source.approval?.()),
-                });
+                return json(200, buildFacts({ rows, runs, approval: source.approval?.() === true, readAt }));
             },
         },
         {
@@ -46,15 +45,16 @@ export function makeMergeRoutes(deps, _audit) {
                     return absent();
                 const query = url(request).searchParams;
                 const queue = query.get('queue') ?? 'verify';
-                if (queue !== 'verify' && queue !== 'pending' && queue !== 'fuse' && queue !== 'skipped') {
-                    return json(400, { ok: false, error: { code: 'bad-queue', message: 'queue must be verify/pending/fuse/skipped' } });
-                }
-                const cursor = Number.parseInt(query.get('cursor') ?? '0', 10);
+                if (queue !== 'verify' && queue !== 'pending' && queue !== 'fuse' && queue !== 'skipped')
+                    return bad('queue must be verify/pending/fuse/skipped');
+                const expiredOnly = query.get('expired') === '1';
+                if (expiredOnly && queue !== 'pending')
+                    return bad('expired is only allowed for pending');
                 const limit = Number.parseInt(query.get('limit') ?? '50', 10);
-                return json(200, {
-                    ok: true,
-                    data: pageQueue(await source.rows(), queue, Number.isFinite(cursor) ? cursor : 0, Number.isFinite(limit) ? limit : 50),
-                });
+                const offset = Number.parseInt(query.get('cursor') ?? '0', 10);
+                const rows = await source.rows();
+                const page = toQueuePage(rows, queue, expiredOnly, Date.now(), Number.isFinite(limit) ? limit : 50);
+                return json(200, Number.isFinite(offset) && offset > 0 ? { ...page, rows: page.rows.slice(offset) } : page);
             },
         },
         {
@@ -71,13 +71,12 @@ export function makeMergeRoutes(deps, _audit) {
                 const query = url(request).searchParams;
                 const id = query.get('id');
                 const side = query.get('side');
-                if (id === null || id === '' || (side !== 'a' && side !== 'b')) {
-                    return json(400, { ok: false, error: { code: 'bad-body-query', message: 'id and side=a|b are required' } });
-                }
+                if (id === null || id === '' || (side !== 'a' && side !== 'b'))
+                    return bad('id and side=a|b are required');
                 const content = await source.body(id, side);
                 return content === null
-                    ? json(404, { ok: false, error: { code: 'body-not-found', message: 'merge body not found: ' + id } })
-                    : json(200, { ok: true, data: { content, markdown: true, html: renderMarkdown(content) } });
+                    ? json(200, { wireVersion: 1, code: 'merge-body-missing', message: 'merge body not found: ' + id })
+                    : json(200, toBodyView(id, side === 'a' ? 'live' : 'archive', content, Date.now()));
             },
         },
         {
@@ -91,7 +90,7 @@ export function makeMergeRoutes(deps, _audit) {
                 const source = deps.getSource();
                 if (source === undefined)
                     return absent();
-                return json(200, { ok: true, data: { items: await source.history() } });
+                return json(200, toHistoryView(await source.history(), Date.now()));
             },
         },
     ];

package/lib/types/metrics.d.ts

@@ -0,0 +1,16 @@
+/** RG6 merge metrics projection: stable names/labels from state + runs. */
+import type { RunRecord } from '@lmzhen/dsh-evolution-core';
+import type { MergeRow } from './contracts.ts';
+export interface MetricSample {
+    readonly name: string;
+    readonly labels: Readonly<Record<string, string>>;
+    readonly value: number;
+}
+export interface MergeMetricCounters {
+    readonly lockWaitMs?: number;
+    readonly claimConflict?: number;
+    readonly recoveryFail?: number;
+}
+export declare const MERGE_METRIC_NAMES: readonly ["merge_queue_depth", "merge_run_total", "merge_run_duration_ms", "merge_lock_wait_ms", "merge_claim_conflict_total", "merge_recovery_fail_total"];
+export declare function buildMergeMetrics(rows: readonly MergeRow[], runs: readonly RunRecord[], counters?: MergeMetricCounters): readonly MetricSample[];
+//# sourceMappingURL=metrics.d.ts.map

package/lib/types/metrics.js

@@ -0,0 +1,27 @@
+import { countsOf } from "./facts.js";
+export const MERGE_METRIC_NAMES = [
+    'merge_queue_depth',
+    'merge_run_total',
+    'merge_run_duration_ms',
+    'merge_lock_wait_ms',
+    'merge_claim_conflict_total',
+    'merge_recovery_fail_total',
+];
+export function buildMergeMetrics(rows, runs, counters = {}) {
+    const counts = countsOf(rows);
+    const samples = [];
+    for (const queue of ['verify', 'pending', 'fuse', 'skipped'])
+        samples.push({ name: 'merge_queue_depth', labels: { queue, kind: 'active' }, value: counts.active[queue] });
+    samples.push({ name: 'merge_queue_depth', labels: { queue: 'pending', kind: 'expired' }, value: counts.expired });
+    for (const run of runs) {
+        const state = run.mergeStatus ?? run.state;
+        samples.push({ name: 'merge_run_total', labels: { state }, value: 1 });
+        if (run.endedAt !== undefined)
+            samples.push({ name: 'merge_run_duration_ms', labels: { state }, value: Math.max(0, run.endedAt - run.startedAt) });
+    }
+    samples.push({ name: 'merge_lock_wait_ms', labels: {}, value: counters.lockWaitMs ?? 0 });
+    samples.push({ name: 'merge_claim_conflict_total', labels: {}, value: counters.claimConflict ?? 0 });
+    samples.push({ name: 'merge_recovery_fail_total', labels: {}, value: counters.recoveryFail ?? 0 });
+    return samples;
+}
+//# sourceMappingURL=metrics.js.map

package/lib/types/new-child-authoring.d.ts

@@ -2,7 +2,7 @@
  * Round2 with a NEW child (approval after the pending window). The child gets the round2
  * prompt and writes the staging tree; the plugin then runs the same gate/commit path.
  */
-import type { EvolutionIoLike } from '@lmzhen/dsh-evolution-core';
+import type { EvolutionIoLike, UnitTransaction } from '@lmzhen/dsh-evolution-core';
 import type { MergeDecision, MergeRow } from './contracts.ts';
 import type { SkillCard } from './skill-card.ts';
 import type { ConversationChannelLike } from './channel-port.ts';
@@ -21,8 +21,10 @@ export interface NewChildAuthoringOptions {
     readonly timeoutMs: number;
     readonly commitPort: CommitPort;
     readonly now: () => number;
+    readonly isBlocked?: (name: string) => boolean | Promise<boolean>;
     readonly onChild?: (context: StageToolContext) => void;
     readonly onChildClosed?: (childId: string) => void;
+    readonly unit?: UnitTransaction | undefined;
 }
 export declare function runNewChildAuthoring(options: NewChildAuthoringOptions, row: MergeRow, decision: MergeDecision, signal: AbortSignal): Promise<ScanRound2Outcome>;
 export declare function createNewChildRound2(options: Omit<NewChildAuthoringOptions, 'runId'>): (row: MergeRow, decision: MergeDecision, signal: AbortSignal, runId: string) => Promise<ScanRound2Outcome>;

package/lib/types/new-child-authoring.js

@@ -6,8 +6,15 @@ import { validateStagedTree, hasBlockingFinding } from "./rules.js";
 import { commitStagedRun } from "./commit-execute.js";
 export async function runNewChildAuthoring(options, row, decision, signal) {
     const targetCard = options.cards.find(card => card.name === decision.target);
-    if (targetCard?.protectionUnknown === true || targetCard?.protectedBy === 'pinned')
-        return { kind: 'failed', failure: { stage: 'author', code: 'target-pinned', message: 'target is pinned: ' + decision.target, retryable: false, retryFrom: 'none' } };
+    const createMode = decision.mode === 'create-umbrella';
+    if (!createMode && targetCard !== undefined) {
+        if (targetCard.managed !== true)
+            return { kind: 'failed', failure: { stage: 'author', code: 'target-not-managed', message: 'target is not family-managed: ' + decision.target, retryable: false, retryFrom: 'none' } };
+        if (targetCard.protectionUnknown === true || targetCard.protectedBy != null)
+            return { kind: 'failed', failure: { stage: 'author', code: 'target-protected', message: 'target is protected: ' + decision.target, retryable: false, retryFrom: 'none' } };
+    }
+    if (!createMode && await options.isBlocked?.(decision.target) === true)
+        return { kind: 'failed', failure: { stage: 'author', code: 'target-blocked', message: 'target is blocked by curator: ' + decision.target, retryable: false, retryFrom: 'none' } };
     const stageKey = row.stagingRef ?? stageKeyOf(options.runId, pairKey(row.a, row.b));
     const existing = await readStaging(options.io, options.home, stageKey);
     if (existing.kind === 'present') {
@@ -58,7 +65,11 @@ export async function runNewChildAuthoring(options, row, decision, signal) {
         const findings = validateStagedTree(tree.value);
         if (hasBlockingFinding(findings))
             return { kind: 'failed', failure: { stage: 'validate', code: 'rule-gate', message: 'staged tree failed the rule gate', retryable: true, retryFrom: 'agent2' } };
-        const commit = await commitStagedRun(options.io, options.home, stageKey, options.commitPort, { origin: 'subagent', summary: 'merge ' + row.a + ' + ' + row.b, now: options.now });
+        const commit = await commitStagedRun(options.io, options.home, stageKey, options.commitPort, {
+            origin: 'foreground', summary: 'merge ' + row.a + ' + ' + row.b, now: options.now,
+            ...(options.isBlocked === undefined ? {} : { isBlocked: options.isBlocked }),
+            ...(options.unit === undefined ? {} : { unit: options.unit }),
+        });
         if (!commit.ok)
             return { kind: 'failed', failure: { stage: 'commit', code: 'commit-failed', message: commit.message, retryable: true, retryFrom: 'agent2' } };
         const receipt = commit.receipt;

package/lib/types/pending-actions.d.ts

@@ -1,6 +1,6 @@
 /**
- * Pending approval actions. The row lookup and the transition happen in one
- * mutateMergeState transaction, so two clients approving the same row cannot both win.
+ * Pending approval actions. The row lookup and transition happen in one v3
+ * transactRows transaction, so two clients approving the same row cannot both win.
  */
 import type { EvolutionIoLike } from '@lmzhen/dsh-evolution-core';
 import type { MergeRow } from './contracts.ts';

package/lib/types/pending-actions.js

@@ -1,22 +1,22 @@
-import { transition } from "./coordinator.js";
-import { mutateMergeState } from "./state.js";
+import { v3ToLegacy } from "./domain/row-v3-bridge.js";
+import { transactRows } from "./state.js";
 async function act(io, home, now, id, type) {
-    return await mutateMergeState(io, home, now, (rows) => {
-        const index = rows.findIndex(row => row.id === id);
-        if (index < 0)
-            return { rows, result: { ok: false, reason: 'not-found', message: 'pending row not found: ' + id } };
-        const current = rows[index];
-        if (current.state !== 'pending')
-            return { rows, result: { ok: false, reason: 'not-pending', message: 'row is not pending: ' + current.state } };
+    void now;
+    return await transactRows(io, home, tx => {
+        const row = tx.rows().find(item => item.id === id);
+        if (row === undefined)
+            return { ok: false, reason: 'not-found', message: 'pending row not found: ' + id };
+        if (row.state !== 'pending')
+            return { ok: false, reason: 'not-pending', message: 'row is not pending: ' + row.state };
         const event = type === 'approve'
-            ? { type: 'approve', at: new Date(now()).toISOString() }
-            : { type: 'reject', at: new Date(now()).toISOString() };
-        const next = transition(current, event);
-        if (!next.ok || next.row === null)
-            return { rows, result: { ok: false, reason: 'invalid', message: next.ok ? 'transition produced no row' : next.message } };
-        const copy = [...rows];
-        copy[index] = next.row;
-        return { rows: copy, result: { ok: true, row: next.row } };
+            ? { type: 'approved', runId: row.runId ?? 'approve:' + id }
+            : { type: 'skipped', reason: 'rejected', origin: 'human' };
+        const moved = tx.transition(id, event, row.version);
+        if (!moved.ok)
+            return { ok: false, reason: 'invalid', message: moved.message };
+        if (moved.row === null)
+            return { ok: false, reason: 'invalid', message: 'transition produced no row' };
+        return { ok: true, row: v3ToLegacy(moved.row) };
     });
 }
 export async function approvePending(io, home, now, id) {

package/lib/types/propose.d.ts

@@ -0,0 +1,26 @@
+/**
+ * C3 semantic proposer: one library-level model call (sharded when the library is large)
+ * that proposes candidate pairs. It never judges merge quality; L0–L2 does that.
+ */
+import type { MergeCandidate } from './contracts.ts';
+import type { SkillCard } from './screening.ts';
+export interface ModelPort {
+    callJson(request: {
+        readonly system: string;
+        readonly user: string;
+        readonly maxTokens: number;
+        readonly signal: AbortSignal;
+    }): Promise<unknown>;
+}
+export interface ProposeOptions {
+    readonly shardSize?: number;
+    readonly maxPairs?: number;
+    readonly signal: AbortSignal;
+}
+export interface ProposeResult {
+    readonly candidates: readonly MergeCandidate[];
+    readonly shards: number;
+    readonly degraded: readonly string[];
+}
+export declare function proposePairs(cards: readonly SkillCard[], port: ModelPort, options: ProposeOptions): Promise<ProposeResult>;
+//# sourceMappingURL=propose.d.ts.map