@lmzhen/dsh-evolution-merge 0.30.17 → 0.30.18

package/lib/types/adapters/library.js

@@ -8,7 +8,10 @@ export function skillLibraryPort(skills) {
             const names = await archivedNames.call(skills);
             return names === null ? true : names.includes(name);
         },
-        commitMerge: plan => skills.commitMerge(plan),
+        isNameOccupied: async (name) => {
+            const probe = skills.skillDirExists;
+            return typeof probe === 'function' ? await probe.call(skills, name) : false;
+        },
         async readSupportFiles(name) {
             if (typeof skills.listSupportFiles !== 'function')
                 return [];

package/lib/types/adapters/model.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Structural ModelPort adapter over the platform llm service. The platform exposes either
+ * `stream()` (the current shape) or the older prepareCall()/stream pair; both return raw text
+ * because the gate and proposer own JSON extraction.
+ */
+import type { ModelPort } from '../propose.ts';
+export interface ModelRoute {
+    readonly provider: string;
+    readonly model: string;
+}
+export interface LlmChunkLike {
+    readonly type: string;
+    readonly text?: string;
+    readonly usage?: unknown;
+    readonly reason?: {
+        readonly kind?: string;
+        readonly failure?: {
+            readonly message?: string;
+        };
+    };
+}
+export interface LlmCallLike {
+    readonly config: Record<string, unknown>;
+    stream(input: Record<string, unknown>): AsyncIterable<LlmChunkLike>;
+}
+export interface LlmServiceLike {
+    prepareCall?(config: Record<string, unknown>, signal?: AbortSignal): Promise<LlmCallLike>;
+    stream?(options: Record<string, unknown>): AsyncIterable<LlmChunkLike>;
+}
+export declare function createModelPort(llm: LlmServiceLike, route: () => ModelRoute): ModelPort;
+//# sourceMappingURL=model.d.ts.map

package/lib/types/adapters/model.js

@@ -0,0 +1,46 @@
+function append(chunk, text) {
+    if (chunk.type === 'text-delta' || chunk.type === 'text')
+        return text + (chunk.text ?? '');
+    if (chunk.type === 'finish' && chunk.reason?.kind === 'error') {
+        throw new Error('model call failed: ' + (chunk.reason.failure?.message ?? 'unknown'));
+    }
+    return text;
+}
+export function createModelPort(llm, route) {
+    return {
+        async callJson(request) {
+            const selection = route();
+            let text = '';
+            if (llm.stream !== undefined) {
+                for await (const chunk of llm.stream({
+                    provider: selection.provider,
+                    model: selection.model,
+                    system: request.system,
+                    messages: [{ role: 'user', content: [{ type: 'text', text: request.user }] }],
+                    maxTokens: request.maxTokens,
+                    temperature: 0,
+                    signal: request.signal,
+                }))
+                    text = append(chunk, text);
+                return text;
+            }
+            if (llm.prepareCall === undefined)
+                throw new Error('llm service has neither stream nor prepareCall');
+            const call = await llm.prepareCall({
+                provider: selection.provider,
+                model: selection.model,
+                maxTokens: request.maxTokens,
+                temperature: 0,
+            }, request.signal);
+            for await (const chunk of call.stream({
+                ...call.config,
+                system: request.system,
+                messages: [{ role: 'user', content: [{ type: 'text', text: request.user }] }],
+                signal: request.signal,
+            }))
+                text = append(chunk, text);
+            return text;
+        },
+    };
+}
+//# sourceMappingURL=model.js.map

package/lib/types/approve-command.d.ts

@@ -16,6 +16,8 @@ export interface RunApproveCommandOptions {
     readonly ports: ApprovePorts;
     readonly rowId: string;
     readonly platformWrite: boolean;
+    readonly detached?: boolean;
+    readonly pairTimeoutMinutes?: number;
     readonly now: () => number;
 }
 export declare function runApproveCommand(options: RunApproveCommandOptions): Promise<WithMergeRunResult>;

package/lib/types/approve-command.js

@@ -1,55 +1,50 @@
 import { approvePending } from "./pending-actions.js";
 import { loadMergeState } from "./state.js";
-import { acquireTargetClaim } from "./target-claim.js";
 import { withMergeRun } from "./run-shell.js";
 import { recordRound2Outcome } from "./round2-outcome.js";
 export async function runApproveCommand(options) {
     const loaded = await loadMergeState(options.io, options.home);
     const before = loaded.state.rows.find(item => item.id === options.rowId);
-    const target = before?.decision?.target;
-    const claim = target === undefined ? null : await acquireTargetClaim(options.io, options.home, target, options.now());
-    if (target !== undefined && claim === null)
-        return { ok: false, message: 'target already claimed by another approve: ' + target };
-    try {
-        const taken = await approvePending(options.io, options.home, options.now, options.rowId);
-        if (!taken.ok)
-            return { ok: false, message: taken.message };
-        const row = taken.row;
-        const decision = row.decision;
-        if (decision === undefined)
-            return { ok: false, message: 'pending row has no decision' };
-        return await withMergeRun({
-            io: options.io,
-            home: options.home,
-            registry: options.registry,
-            command: 'approve',
-            approval: { platformWrite: options.platformWrite, mergeApproval: true },
-            now: options.now,
-            async body(ctx) {
-                const stage = (name) => ctx.stage(name, { done: 0, total: 1 });
-                await stage('author');
-                let outcome;
-                try {
-                    outcome = await options.ports.round2(row, decision, ctx.signal, ctx.runId);
-                }
-                catch (error) {
-                    outcome = { kind: 'failed', failure: { stage: 'author', code: 'merge-failed', message: error instanceof Error ? error.message : String(error), retryable: true, retryFrom: 'agent2' } };
-                }
-                const base = { scope: { candidatePairs: 1, queueBefore: { verify: 0, pending: 0, fuse: 1, skipped: 0 } }, notes: [] };
-                const record = await recordRound2Outcome(options.io, options.home, options.now, row, outcome);
-                return {
-                    ...base,
-                    stopReason: record.merged ? 'completed' : 'failed',
-                    pairs: [record.pair],
-                    totals: record.merged
-                        ? { merged: 1, kept: 0, pending: 0, failed: 0 }
-                        : { merged: 0, kept: 0, pending: 0, failed: 1 },
-                };
-            },
-        });
-    }
-    finally {
-        await claim?.release();
-    }
+    if (before === undefined)
+        return { ok: false, message: 'pending row not found: ' + options.rowId };
+    if (before.state !== 'pending')
+        return { ok: false, message: 'row is not pending: ' + before.state };
+    const taken = await approvePending(options.io, options.home, options.now, options.rowId);
+    if (!taken.ok)
+        return { ok: false, message: taken.message };
+    const row = taken.row;
+    const decision = row.decision;
+    if (decision === undefined)
+        return { ok: false, message: 'pending row has no decision' };
+    return await withMergeRun({
+        io: options.io,
+        home: options.home,
+        registry: options.registry,
+        command: 'approve',
+        approval: { platformWrite: options.platformWrite, mergeApproval: true },
+        now: options.now,
+        ...(options.detached === true ? { detached: true } : {}),
+        async body(ctx) {
+            const stage = (name) => ctx.stage(name, { done: 0, total: 1 });
+            await stage('author');
+            let outcome;
+            try {
+                outcome = await options.ports.round2(row, decision, ctx.signal, ctx.runId);
+            }
+            catch (error) {
+                outcome = { kind: 'failed', failure: { stage: 'author', code: 'merge-failed', message: error instanceof Error ? error.message : String(error), retryable: true, retryFrom: 'agent2' } };
+            }
+            const base = { scope: { candidatePairs: 1, queueBefore: { verify: 0, pending: 0, fuse: 1, skipped: 0 } }, notes: [] };
+            const record = await recordRound2Outcome(options.io, options.home, options.now, row, outcome);
+            return {
+                ...base,
+                stopReason: record.merged ? 'completed' : 'failed',
+                pairs: [record.pair],
+                totals: record.merged
+                    ? { merged: 1, kept: 0, pending: 0, failed: 0 }
+                    : { merged: 0, kept: 0, pending: 0, failed: 1 },
+            };
+        },
+    });
 }
 //# sourceMappingURL=approve-command.js.map

package/lib/types/authoring-flow.d.ts

@@ -3,7 +3,7 @@
  * rule gate, then commit through the injected CommitPort. The channel adapter and the
  * author tool live outside; this is the seam they share.
  */
-import type { EvolutionIoLike } from '@lmzhen/dsh-evolution-core';
+import type { EvolutionIoLike, UnitTransaction } from '@lmzhen/dsh-evolution-core';
 import { type RuleFinding } from './rules.ts';
 import { type CommitPort, type CommitStagedResult } from './commit-execute.ts';
 import type { StagedTree } from './rules.ts';
@@ -24,6 +24,8 @@ export interface RunAuthoringOptions {
     readonly commitPort: CommitPort;
     readonly now: () => number;
     readonly summary: string;
+    readonly isBlocked?: (name: string) => boolean | Promise<boolean>;
+    readonly unit?: UnitTransaction | undefined;
 }
 export type AuthoringResult = {
     readonly ok: true;

package/lib/types/authoring-flow.js

@@ -4,18 +4,26 @@ import { validateStagedTree, hasBlockingFinding } from "./rules.js";
 import { commitStagedRun } from "./commit-execute.js";
 export async function runAuthoring(options) {
     const targetCard = options.cards.find(card => card.name === options.target);
-    if (targetCard?.protectionUnknown === true || targetCard?.protectedBy === 'pinned')
-        return { ok: false, message: 'target is pinned: ' + options.target };
+    const mode = options.mode ?? (targetCard === undefined ? 'create-umbrella' : 'merge-into-existing');
+    const createMode = mode === 'create-umbrella';
+    if (!createMode && targetCard !== undefined) {
+        if (targetCard.managed !== true)
+            return { ok: false, message: 'target is not family-managed: ' + options.target };
+        if (targetCard.protectionUnknown === true || targetCard.protectedBy != null)
+            return { ok: false, message: 'target is protected (' + (targetCard.protectedBy ?? 'unknown') + '): ' + options.target };
+    }
+    if (!createMode && await options.isBlocked?.(options.target) === true)
+        return { ok: false, message: 'target is blocked by curator: ' + options.target };
     const stageKey = options.stageKey ?? options.runId;
     if (options.reuseStaging === true) {
-        if (!await setStagingTarget(options.io, options.home, stageKey, options.target, options.mode))
+        if (!await setStagingTarget(options.io, options.home, stageKey, options.target, mode))
             return { ok: false, message: 'staging missing or unreadable: ' + stageKey };
     }
     else {
         const created = await createStaging(options.io, options.home, {
             runId: stageKey,
             target: options.target,
-            ...(options.mode === undefined ? {} : { mode: options.mode }),
+            mode,
             sources: options.cards.map(card => ({ name: card.name, body: card.body, files: card.files ?? [] })),
             promptVersion: 'merge-b/v1',
             ttlDays: 7,
@@ -37,9 +45,11 @@ export async function runAuthoring(options) {
     if (hasBlockingFinding(findings))
         return { ok: false, message: 'staged tree failed the rule gate', findings };
     const commit = await commitStagedRun(options.io, options.home, stageKey, options.commitPort, {
-        origin: 'subagent',
+        origin: 'foreground',
         summary: options.summary,
         now: options.now,
+        ...(options.isBlocked === undefined ? {} : { isBlocked: options.isBlocked }),
+        ...(options.unit === undefined ? {} : { unit: options.unit }),
     });
     if (!commit.ok)
         return { ok: false, message: commit.message };

package/lib/types/command-surface.d.ts

@@ -0,0 +1,5 @@
+/** Frozen merge CommandSurface v1: 19 commands, JSON-safe, no handlers. */
+import type { CommandSpec, CommandSurface } from './wire.ts';
+export declare const MERGE_COMMANDS: readonly CommandSpec[];
+export declare const MERGE_COMMAND_SURFACE: CommandSurface;
+//# sourceMappingURL=command-surface.d.ts.map

package/lib/types/command-surface.js

@@ -0,0 +1,44 @@
+const flag = (name, kind = 'boolean', valueName) => ({ name, kind, ...(valueName === undefined ? {} : { valueName }) });
+const pos = (name, kind, required = true) => ({ name, kind, required });
+const action = (id, command, confirm = false) => ({ id, command, confirm });
+function spec(id, words, flags, positional, readOnly, needsRun, rowActions, fallback) {
+    return { id, words, flags, positional, summary: id, readOnly, needsRun, defaults: {}, rowActions, fallback };
+}
+export const MERGE_COMMANDS = [
+    spec('merge.scan', ['scan'], [], [], false, true, [], '/evolution merge scan'),
+    spec('merge.pair', ['pair'], [], [pos('a', 'skill'), pos('b', 'skill')], false, true, [action('pair', '/evolution merge pair', true)], '/evolution merge pair <a> <b>'),
+    spec('merge.pair.force', ['pair'], [flag('force')], [pos('a', 'skill'), pos('b', 'skill')], false, true, [], '/evolution merge pair --force <a> <b>'),
+    spec('merge.status', ['status'], [], [pos('id', 'id', false)], true, false, [action('status', '/evolution merge status')], '/evolution merge status'),
+    spec('merge.report', ['report'], [], [pos('id', 'id', false)], true, false, [action('report', '/evolution merge report')], '/evolution merge report'),
+    spec('merge.cancel', ['cancel'], [], [pos('id', 'id', false)], false, false, [action('cancel', '/evolution merge cancel')], '/evolution merge cancel <id>'),
+    spec('merge.runs', ['runs'], [], [], true, false, [], '/evolution merge runs'),
+    spec('merge.pending', ['pending'], [], [], true, false, [], '/evolution merge pending'),
+    spec('merge.pending.expired', ['pending'], [flag('expired')], [], true, false, [], '/evolution merge pending --expired'),
+    spec('merge.approve', ['approve'], [], [pos('id', 'id')], false, true, [action('approve', '/evolution merge approve <id>')], '/evolution merge approve <id>'),
+    spec('merge.reject', ['reject'], [], [pos('id', 'id')], false, false, [action('reject', '/evolution merge reject <id>', true)], '/evolution merge reject <id>'),
+    spec('merge.skipped', ['skipped'], [], [], true, false, [], '/evolution merge skipped'),
+    spec('merge.skipped.restore', ['skipped'], [flag('restore', 'value', 'id')], [], false, false, [action('restore', '/evolution merge skipped --restore <id>', true)], '/evolution merge skipped --restore <id>'),
+    spec('merge.candidates', ['candidates'], [], [], true, false, [], '/evolution merge candidates'),
+    spec('merge.candidates.retry', ['candidates'], [flag('retry', 'value', 'id')], [], false, true, [action('retry-candidates', '/evolution merge candidates --retry <id>')], '/evolution merge candidates --retry <id>'),
+    spec('merge.resume', ['resume'], [], [pos('id', 'id', false)], true, false, [], '/evolution merge resume'),
+    spec('merge.resume.retry', ['resume'], [flag('retry', 'value', 'id')], [], false, true, [action('retry-resume', '/evolution merge resume --retry <id>')], '/evolution merge resume --retry <id>'),
+    spec('merge.discard', ['discard'], [], [pos('id', 'id')], false, false, [action('discard', '/evolution merge discard <id>', true)], '/evolution merge discard <id>'),
+    spec('merge.undo', ['undo'], [flag('run', 'value', 'id')], [pos('target', 'target')], false, false, [], '/evolution merge undo <target> --run <id>'),
+];
+export const MERGE_COMMAND_SURFACE = {
+    wireVersion: 1,
+    prefix: '/evolution merge',
+    commands: MERGE_COMMANDS,
+    fallback: [
+        { id: 'scan', command: '/evolution merge scan' },
+        { id: 'pair', command: '/evolution merge pair <a> <b>' },
+        { id: 'candidates', command: '/evolution merge candidates' },
+        { id: 'pending', command: '/evolution merge pending' },
+        { id: 'skipped', command: '/evolution merge skipped' },
+        { id: 'resume', command: '/evolution merge resume' },
+        { id: 'status', command: '/evolution merge status' },
+        { id: 'report', command: '/evolution merge report' },
+        { id: 'doctor', command: '/evolution merge doctor' },
+    ],
+};
+//# sourceMappingURL=command-surface.js.map

package/lib/types/commit-assembly.d.ts

@@ -11,6 +11,8 @@ export interface CommitAssemblyPort {
     readSkill(name: string): Promise<string | null>;
     /** Whether the name is already occupied by an archived (tombstoned) skill. */
     isArchived?(name: string): Promise<boolean>;
+    /** Whether a directory exists for the name (including a SKILL.md-less ghost). */
+    isNameOccupied?(name: string): Promise<boolean>;
 }
 export interface CommitAssemblyOptions {
     readonly origin: WriteOrigin;

package/lib/types/commit-assembly.js

@@ -12,13 +12,18 @@ export async function assembleStagedCommit(io, home, runId, port, options) {
     const requested = staging.value.manifest.target;
     let target = requested;
     let targetCurrent = await port.readSkill(requested);
+    if (staging.value.manifest.mode !== 'create-umbrella' && targetCurrent === null) {
+        return { ok: false, message: 'target is gone; refusing to re-create it: ' + requested };
+    }
     const requestedArchived = targetCurrent === null && await port.isArchived?.(requested) === true;
-    if (staging.value.manifest.mode === 'create-umbrella' && (targetCurrent !== null || requestedArchived)) {
+    const requestedOccupied = targetCurrent === null && await port.isNameOccupied?.(requested) === true;
+    if (staging.value.manifest.mode === 'create-umbrella' && (targetCurrent !== null || requestedArchived || requestedOccupied)) {
         target = requested;
         for (let suffix = 2; suffix <= 99; suffix += 1) {
             const candidate = requested + '-v' + String(suffix);
             if (await port.readSkill(candidate) === null
-                && await port.isArchived?.(candidate) !== true) {
+                && await port.isArchived?.(candidate) !== true
+                && await port.isNameOccupied?.(candidate) !== true) {
                 target = candidate;
                 targetCurrent = null;
                 break;

package/lib/types/commit-execute.d.ts

@@ -6,8 +6,11 @@
 import type { CommitMergePlan, CommitMergeResult, EvolutionIoLike } from '@lmzhen/dsh-evolution-core';
 import { type CommitAssemblyPort } from './commit-assembly.ts';
 import { type CommitReceipt } from './commit-receipt.ts';
+import type { UnitTransaction } from '@lmzhen/dsh-evolution-core';
 export interface CommitPort extends CommitAssemblyPort {
-    commitMerge(plan: CommitMergePlan): Promise<CommitMergeResult>;
+    /** Transitional G2: when set, commit-execute prefers this over commitMerge. */
+    unit?: UnitTransaction;
+    commitMerge?(plan: CommitMergePlan): Promise<CommitMergeResult>;
     readSupportFiles?(name: string): Promise<readonly {
         readonly path: string;
         readonly content: string;
@@ -17,6 +20,9 @@ export interface CommitStagedOptions {
     readonly origin: CommitMergePlan['origin'];
     readonly summary: string;
     readonly now: () => number;
+    readonly isBlocked?: (name: string) => boolean | Promise<boolean>;
+    /** G2 transitional: when present, commit through core UnitTransaction. */
+    readonly unit?: UnitTransaction;
 }
 export type CommitStagedResult = {
     readonly ok: true;

package/lib/types/commit-execute.js

@@ -7,18 +7,48 @@ export async function commitStagedRun(io, home, runId, port, options) {
     const assembled = await assembleStagedCommit(io, home, runId, port, { origin: options.origin, summary: options.summary });
     if (!assembled.ok)
         return { ok: false, message: assembled.message };
-    try {
-        await writeCommitSnapshot(io, home, runId, assembled.plan, options.now(), port);
+    if (await options.isBlocked?.(assembled.plan.target) === true) {
+        return { ok: false, message: 'target is blocked by curator: ' + assembled.plan.target, plan: assembled.plan };
     }
-    catch (error) {
-        return { ok: false, message: 'commit snapshot failed; refusing to write: ' + (error instanceof Error ? error.message : String(error)), plan: assembled.plan };
+    const journal = { runId, target: assembled.plan.target, create: !assembled.plan.targetExists, sources: assembled.plan.sources, phase: 'prepared', updatedAt: new Date(options.now()).toISOString() };
+    let result;
+    const transaction = options.unit ?? port.unit;
+    if (transaction !== undefined) {
+        const first = assembled.plan.sources[0] ?? assembled.plan.target;
+        const unitPlan = { runId, pairKey: pairKey(assembled.plan.target, first), target: assembled.plan.target, targetExists: assembled.plan.targetExists, sources: assembled.plan.sources, body: assembled.plan.body, supportFiles: assembled.plan.supportFiles, expectedTargetBody: assembled.plan.expectedTargetBody, expectedSourceBodies: assembled.plan.expectedSourceBodies, origin: options.origin, summary: options.summary };
+        try {
+            await writeJournal(io, home, journal);
+        }
+        catch { /* compat mirror; unit journal is authority */ }
+        const prepared = await transaction.prepare(unitPlan);
+        if (!prepared.ok)
+            return { ok: false, message: prepared.message, plan: assembled.plan };
+        const committed = await transaction.commit(prepared.prepared);
+        if (!committed.ok) {
+            try {
+                await writeJournal(io, home, { ...journal, phase: 'failed', updatedAt: new Date(options.now()).toISOString() });
+            }
+            catch { }
+            ;
+            return { ok: false, message: committed.message, plan: assembled.plan };
+        }
+        result = { ok: true, message: 'merged', unitId: committed.evidence.unitId, archived: committed.evidence.sources.filter(source => source.archived).map(source => source.name), mutations: committed.evidence.mutations };
     }
-    const journal = { runId, target: assembled.plan.target, create: !assembled.plan.targetExists, sources: assembled.plan.sources, phase: 'sources-archived', updatedAt: new Date(options.now()).toISOString() };
-    try {
-        await writeJournal(io, home, journal);
+    else {
+        try {
+            await writeCommitSnapshot(io, home, runId, assembled.plan, options.now(), port);
+        }
+        catch (error) {
+            return { ok: false, message: 'commit snapshot failed; refusing to write: ' + (error instanceof Error ? error.message : String(error)), plan: assembled.plan };
+        }
+        try {
+            await writeJournal(io, home, journal);
+        }
+        catch { /* journal is best-effort */ }
+        if (port.commitMerge === undefined)
+            return { ok: false, message: 'commit port missing: UnitTransaction or commitMerge required', plan: assembled.plan };
+        result = await port.commitMerge(assembled.plan);
     }
-    catch { /* journal is best-effort; receipt remains the commit record */ }
-    const result = await port.commitMerge(assembled.plan);
     if (!result.ok) {
         try {
             await writeJournal(io, home, { ...journal, phase: 'failed', updatedAt: new Date(options.now()).toISOString() });
@@ -26,7 +56,7 @@ export async function commitStagedRun(io, home, runId, port, options) {
         catch { }
         return { ok: false, message: result.message, plan: assembled.plan };
     }
-    const committed = { ...journal, phase: 'committed', updatedAt: new Date(options.now()).toISOString() };
+    const committed = { ...journal, phase: 'committed', updatedAt: new Date(options.now()).toISOString(), ...(result.unitId === undefined ? {} : { unitId: result.unitId }) };
     try {
         await writeJournal(io, home, committed);
     }

package/lib/types/commit-recovery.d.ts

@@ -2,9 +2,14 @@ import type { EvolutionIoLike } from '@lmzhen/dsh-evolution-core';
 import type { CommitJournal } from './domain/commit-journal.ts';
 export interface CommitRecoveryReport {
     readonly runId: string;
-    readonly phase: CommitJournal['phase'];
+    readonly phase: CommitJournal['phase'] | 'unknown';
     readonly action: string;
     readonly ok: boolean;
+    readonly target?: string;
+    readonly sources?: readonly string[];
+    readonly journalPath?: string;
+    readonly snapshotPath?: string;
+    readonly unitId?: string;
 }
-export declare function recoverCommitJournals(io: EvolutionIoLike, home: string, now: number, skillRoot: string, restoreSource?: (name: string) => Promise<boolean>, isActive?: (runId: string) => boolean): Promise<readonly CommitRecoveryReport[]>;
+export declare function recoverCommitJournals(io: EvolutionIoLike, home: string, now: number, isActive?: (runId: string) => boolean): Promise<readonly CommitRecoveryReport[]>;
 //# sourceMappingURL=commit-recovery.d.ts.map