@lmzhen/dsh-evolution-core 0.27.3 → 0.28.0

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

@@ -37,7 +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 SkillVersion } from './skill-history.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';
 export interface SkillSummary {
@@ -174,6 +174,39 @@ export interface ArchiveOptions {
     reason?: string;
     /** Permit archiving a bundled skill (curator prune-builtins only; hub-installed and pinned stay protected). */
     allowBundled?: boolean;
+    /** Unit shared with the rest of a multi-skill transaction (merge). */
+    unitId?: string;
+    /** Cross-skill landmark for the unit; a merge source names the target. */
+    unitHead?: UnitHead;
+}
+/** One multi-skill merge commit: target body + support files, with the source names it absorbs. */
+export interface CommitMergePlan {
+    readonly target: string;
+    /** Whether the target already exists. The caller planned this; commit re-checks it. */
+    readonly targetExists: boolean;
+    readonly sources: readonly string[];
+    readonly body: string;
+    readonly supportFiles: readonly {
+        readonly path: string;
+        readonly content: string;
+    }[];
+    /** Plan-time target body; null for a create. */
+    readonly expectedTargetBody: string | null;
+    readonly expectedSourceBodies: readonly {
+        readonly name: string;
+        readonly body: string;
+    }[];
+    readonly origin: WriteOrigin;
+    readonly summary: string;
+}
+export interface CommitMergeResult {
+    readonly ok: boolean;
+    readonly message: string;
+    readonly unitId?: string;
+    readonly targetPath?: string;
+    readonly archived?: readonly string[];
+    /** One per skill written: target + each source. */
+    readonly mutations?: number;
 }
 export declare function skillsRoot(env?: NodeJS.ProcessEnv): string;
 /** 0.3.18 (S4.1, E-30): the ONE root resolution for every member that reads
@@ -270,6 +303,19 @@ export declare function markerEntryName(marker: 'bundled' | 'hub-installed' | 'p
  * rule, or it creates an orphan the later patch/write/remove paths refuse.
  * Single source shared with the plan validator. */
 export declare function validateRestructureTarget(filePath: string): string | null;
+export declare function validateSupportPath(filePath: string): string | null;
+/**
+ * Support-directory references in a markdown body (009 kernel): `references/…`,
+ * `templates/…`, `scripts/…`, `assets/…` relative links — any extension and
+ * nested paths (v7 audit P3-1: `.md`-only matching missed `scripts/run.sh` and
+ * `references/sub/x.md`, both of which dangle just like a `.md` link once the
+ * source package is archived). Pure — who checks them and what the verdict is
+ * belongs to the caller's context (a moved/appended body whose references
+ * travel with an archived source is a dangling link; a restructure pointer is
+ * a fresh link to a file written in the same plan). `..` traversal is a
+ * different defect class (path validation owns it) and is not a support link.
+ */
+export declare function supportRefs(content: string): string[];
 export declare class SkillLibrary {
     readonly root: string;
     readonly limits: SkillLimits;
@@ -487,7 +533,10 @@ export declare class SkillLibrary {
      */
     setPinned(name: string, pinned: boolean, origin?: WriteOrigin): Promise<SkillActionResult>;
     private setPinnedCore;
-    create(name: string, content: string, origin?: WriteOrigin): Promise<SkillActionResult>;
+    create(name: string, content: string, origin?: WriteOrigin, options?: {
+        unitId?: string;
+        unitHead?: UnitHead;
+    }): Promise<SkillActionResult>;
     private createCore;
     update(rawName: string, content: string, origin?: WriteOrigin, anchor?: WriteAnchor): Promise<SkillActionResult>;
     private updateCore;
@@ -519,6 +568,16 @@ export declare class SkillLibrary {
      * instead of throwing `name.includes is not a function`. */
     private safeSnapshotEntryName;
     archive(rawName: string, options?: ArchiveOptions, origin?: WriteOrigin): Promise<SkillActionResult>;
+    /**
+     * Commit one merge plan as a single multi-skill transaction.
+     *
+     * Existing target: archive every source first, then write the target through the
+     * tree-change kernel. Create target: create the target with its final body first
+     * (so absorbedInto can see it), then archive sources and write support files.
+     * Every failure rolls back what already landed; a rollback failure names the
+     * unrestored skills instead of claiming success.
+     */
+    commitMerge(plan: CommitMergePlan): Promise<CommitMergeResult>;
     /**
      * V2 (design §16.7): what an apply-mode consolidation would do for ONE source,
      * computed BEFORE any side effect. `blocked` means behaviour is exactly the

package/lib/types/skill-store.js

@@ -352,7 +352,7 @@ export function validateRestructureTarget(filePath) {
         return `toFile "${filePath}" uses a Windows reserved device name.`;
     return null;
 }
-function validateSupportPath(filePath) {
+export function validateSupportPath(filePath) {
     const normalized = filePath.replace(/\\/g, '/');
     if (normalized.includes('..'))
         return '不允许路径穿越。';
@@ -393,7 +393,7 @@ function validateSupportPath(filePath) {
  * a fresh link to a file written in the same plan). `..` traversal is a
  * different defect class (path validation owns it) and is not a support link.
  */
-function supportRefs(content) {
+export function supportRefs(content) {
     const refs = [];
     for (const match of content.matchAll(/\b(?:references|templates|scripts|assets)\/[A-Za-z0-9._/-]+/g)) {
         const ref = match[0];
@@ -1338,15 +1338,15 @@ export class SkillLibrary {
             path: dir,
         };
     }
-    async create(name, content, origin = this.authority.origin) {
+    async create(name, content, origin = this.authority.origin, options = {}) {
         const normalized = name.trim();
         // P2-3 (v11): the exists-probe → write window runs under the in-process
         // serialize queue (F-208 discipline, like update/patch) — two concurrent
         // create calls for one name used to both pass exists() and double-write
         // (double audit, double mutation event).
-        return await this.serial(() => this.createCore(normalized, content, origin));
+        return await this.serial(() => this.createCore(normalized, content, origin, options));
     }
-    async createCore(normalized, content, origin) {
+    async createCore(normalized, content, origin, options = {}) {
         // C-12 (v10 audit): the inline badName() copy is gone (see setPinned).
         const bad = this.badName(normalized);
         if (bad)
@@ -1511,7 +1511,7 @@ export class SkillLibrary {
                 return { ok: false, message: `创建过程中技能「${normalized}」被并发归档；残留标记已移除：等搬运完成后重试一次。` };
             }
         }
-        await this.audit(normalized, 'create', null, onDisk, 'created');
+        await this.audit(normalized, 'create', null, onDisk, 'created', undefined, options.unitId, options.unitHead);
         this.notifyMutation({ action: 'create', name: normalized, skillDir: dir });
         // Both warnings ride the normal success path (audit/event included) — a
         // durability warning must never skip the accounting.
@@ -1919,10 +1919,222 @@ export class SkillLibrary {
         catch {
             // Same posture as .archive-reason: metadata only, never abort the archive.
         }
-        await this.audit(name, 'archive', md, null, reason, undefined, undefined, undefined, origin);
+        await this.audit(name, 'archive', md, null, reason, undefined, options.unitId, options.unitHead, origin);
         this.notifyMutation({ action: 'archive', name, archivedPath: dest });
         return { ok: true, message: `技能「${name}」已归档到 .archive。`, path: dest };
     }
+    /**
+     * Commit one merge plan as a single multi-skill transaction.
+     *
+     * Existing target: archive every source first, then write the target through the
+     * tree-change kernel. Create target: create the target with its final body first
+     * (so absorbedInto can see it), then archive sources and write support files.
+     * Every failure rolls back what already landed; a rollback failure names the
+     * unrestored skills instead of claiming success.
+     */
+    async commitMerge(plan) {
+        const target = plan.target.trim();
+        const sources = [...new Set(plan.sources.map(name => name.trim()))].filter(name => name !== target);
+        if (sources.length === 0)
+            return { ok: false, message: '合并至少需要一个互不相同的来源技能。' };
+        for (const name of [target, ...sources]) {
+            const bad = this.badName(name);
+            if (bad)
+                return { ok: false, message: bad };
+        }
+        return await this.serial(async () => {
+            const dir = this.dirOf(target);
+            const targetPath = join(dir, 'SKILL.md');
+            const currentTarget = await this.io.readText(targetPath);
+            if (plan.targetExists !== (currentTarget !== null)) {
+                return { ok: false, message: plan.targetExists ? `目标技能「${target}」不存在。` : `目标技能「${target}」已存在。` };
+            }
+            if (currentTarget !== plan.expectedTargetBody) {
+                return { ok: false, message: `目标技能「${target}」在计划之后被改过；拒绝提交（未写入任何内容）。` };
+            }
+            const targetProtection = await this.writeProtection(target, plan.origin);
+            if (targetProtection)
+                return { ok: false, message: `技能「${target}」受保护（${targetProtection}）。` };
+            const expectedSources = new Map(plan.expectedSourceBodies.map(entry => [entry.name.trim(), entry.body]));
+            const sourceBodies = new Map();
+            for (const source of sources) {
+                const protection = await this.deleteProtection(source);
+                if (protection)
+                    return { ok: false, message: `技能「${source}」受保护（${protection}）。` };
+                const body = await this.io.readText(join(this.dirOf(source), 'SKILL.md'));
+                if (body === null)
+                    return { ok: false, message: `来源技能「${source}」不存在。` };
+                const expected = expectedSources.get(source);
+                if (expected === undefined)
+                    return { ok: false, message: `来源技能「${source}」缺少计划字节；拒绝提交。` };
+                if (body !== expected)
+                    return { ok: false, message: `来源技能「${source}」在计划之后被改过；拒绝提交（未写入任何内容）。` };
+                sourceBodies.set(source, body);
+            }
+            const validation = validateFrontmatter(plan.body, target, this.limits);
+            if (validation)
+                return { ok: false, message: validation };
+            const supportPaths = new Set();
+            const supportPrevious = new Map();
+            for (const file of plan.supportFiles) {
+                const badPath = validateSupportPath(file.path);
+                if (badPath)
+                    return { ok: false, message: badPath };
+                if (supportPaths.has(file.path))
+                    return { ok: false, message: `支撑文件重复：${file.path}` };
+                supportPaths.add(file.path);
+                if (Buffer.byteLength(file.content, 'utf8') > this.limits.maxSkillFileBytes)
+                    return { ok: false, message: `支撑文件超过 ${this.limits.maxSkillFileBytes} 字节：${file.path}` };
+                const threat = this.contentThreatBlock(file.content);
+                if (threat)
+                    return { ok: false, message: threat };
+                const previous = await this.io.readText(join(dir, ...file.path.replace(/\\/g, '/').split('/').filter(Boolean)));
+                supportPrevious.set(file.path, previous);
+            }
+            for (const ref of supportRefs(plan.body)) {
+                if (supportPaths.has(ref))
+                    continue;
+                const existing = plan.targetExists
+                    ? await this.io.exists(join(dir, ...ref.replace(/\\/g, '/').split('/').filter(Boolean)))
+                    : false;
+                if (!existing)
+                    return { ok: false, message: `正文引用了未提供的支撑文件「${ref}」；拒绝提交。` };
+            }
+            const unitId = 'u-' + Date.now().toString(36) + '-' + (nextUnitSeq += 1).toString(36);
+            const supportMoves = plan.supportFiles.map((file) => {
+                const previous = supportPrevious.get(file.path) ?? null;
+                return {
+                    path: file.path,
+                    kind: previous === null ? 'created' : 'moved',
+                    to: file.path,
+                    ...(previous === null ? {} : { beforeRef: contentHash(previous) }),
+                    afterRef: contentHash(file.content),
+                };
+            });
+            const unitHead = {
+                moves: supportMoves,
+                sources: [{ skill: target }, ...sources.map(source => ({ skill: source }))],
+            };
+            const archived = [];
+            const rollbackSources = async () => {
+                const stuck = [];
+                for (const source of [...archived].reverse()) {
+                    try {
+                        const restored = await this.restoreFromArchive(source, plan.origin);
+                        if (!restored.ok)
+                            stuck.push(source);
+                    }
+                    catch {
+                        stuck.push(source);
+                    }
+                }
+                return stuck;
+            };
+            const rollbackMessage = (reason, stuck) => ({
+                ok: false,
+                message: stuck.length === 0
+                    ? `合并失败，已回滚：${reason}`
+                    : `合并失败（${reason}）；已回滚，但以下未回滚：${stuck.join(', ')}：它们仍在 .archive 里，请用 /evolution skill restore 恢复。`,
+            });
+            if (plan.targetExists) {
+                for (const source of sources) {
+                    const fresh = await this.io.readText(join(this.dirOf(source), 'SKILL.md'));
+                    if (fresh !== sourceBodies.get(source)) {
+                        const stuck = await rollbackSources();
+                        return rollbackMessage(`来源技能「${source}」在归档前被改过`, stuck);
+                    }
+                    const result = await this.archive(source, {
+                        absorbedInto: target,
+                        unitId,
+                        unitHead: { skill: target },
+                        reason: `Merged into ${target}`,
+                    }, plan.origin);
+                    if (!result.ok) {
+                        const stuck = await rollbackSources();
+                        return rollbackMessage(result.message, stuck);
+                    }
+                    archived.push(source);
+                }
+                const writes = [
+                    { target: targetPath, content: plan.body.trimEnd() + '\n', expected: plan.expectedTargetBody },
+                    ...plan.supportFiles.map(file => ({
+                        target: join(dir, ...file.path.replace(/\\/g, '/').split('/').filter(Boolean)),
+                        content: file.content,
+                        expected: supportPrevious.get(file.path) ?? null,
+                    })),
+                ];
+                const result = await this.applyTreeChange({
+                    name: target,
+                    origin: plan.origin,
+                    protection: 'write',
+                    writes,
+                    auditAction: 'merge',
+                    auditSummary: plan.summary,
+                    eventAction: 'merge',
+                    unitId,
+                    unitHead,
+                });
+                if (!result.ok) {
+                    const stuck = await rollbackSources();
+                    return rollbackMessage(result.message, stuck);
+                }
+                return { ok: true, message: `已把 ${sources.join(', ')} 合并进「${target}」。`, unitId, targetPath: dir, archived, mutations: 1 + sources.length };
+            }
+            const created = await this.createCore(target, plan.body, plan.origin, { unitId, unitHead });
+            if (!created.ok)
+                return { ok: false, message: created.message };
+            for (const source of sources) {
+                const fresh = await this.io.readText(join(this.dirOf(source), 'SKILL.md'));
+                if (fresh !== sourceBodies.get(source)) {
+                    const stuck = await rollbackSources();
+                    const targetRollback = await this.archive(target, { reason: 'merge rolled back' }, plan.origin);
+                    if (!targetRollback.ok)
+                        stuck.push(target);
+                    return rollbackMessage(`来源技能「${source}」在归档前被改过`, stuck);
+                }
+                const result = await this.archive(source, {
+                    absorbedInto: target,
+                    unitId,
+                    unitHead: { skill: target },
+                    reason: `Merged into ${target}`,
+                }, plan.origin);
+                if (!result.ok) {
+                    const stuck = await rollbackSources();
+                    const targetRollback = await this.archive(target, { reason: 'merge rolled back' }, plan.origin);
+                    if (!targetRollback.ok)
+                        stuck.push(target);
+                    return rollbackMessage(result.message, stuck);
+                }
+                archived.push(source);
+            }
+            if (plan.supportFiles.length > 0) {
+                const writes = plan.supportFiles.map(file => ({
+                    target: join(dir, ...file.path.replace(/\\/g, '/').split('/').filter(Boolean)),
+                    content: file.content,
+                    expected: supportPrevious.get(file.path) ?? null,
+                }));
+                const result = await this.applyTreeChange({
+                    name: target,
+                    origin: plan.origin,
+                    protection: 'write',
+                    writes,
+                    auditAction: 'merge',
+                    auditSummary: plan.summary,
+                    eventAction: 'merge',
+                    unitId,
+                    unitHead,
+                });
+                if (!result.ok) {
+                    const stuck = await rollbackSources();
+                    const targetRollback = await this.archive(target, { reason: 'merge rolled back' }, plan.origin);
+                    if (!targetRollback.ok)
+                        stuck.push(target);
+                    return rollbackMessage(result.message, stuck);
+                }
+            }
+            return { ok: true, message: `已把 ${sources.join(', ')} 合并进「${target}」。`, unitId, targetPath: dir, archived, mutations: 1 + sources.length };
+        });
+    }
     /**
      * V2 (design §16.7): what an apply-mode consolidation would do for ONE source,
      * computed BEFORE any side effect. `blocked` means behaviour is exactly the
@@ -2517,25 +2729,27 @@ export class SkillLibrary {
             const isBody = land.target.split(/[\\/]/).pop() === 'SKILL.md';
             const rel = isBody ? undefined : land.target.slice(dir.length + 1).split('\\').join('/');
             // G3b（A22）：代表片＝第一条 landing；kind 判 null（previous 的取值域只有 string/null）。
-            const unitHead = land === landing[0] ? {
-                moves: landing
-                    .filter(l => l.target.split(/[\\/]/).pop() !== 'SKILL.md')
-                    .map((l) => {
-                    const p = l.target.slice(dir.length + 1).split(String.fromCharCode(92)).join(String.fromCharCode(47));
-                    return {
-                        path: p,
-                        kind: l.previous === null ? 'created' : 'moved',
-                        to: p,
-                        ...l.previous === null ? {} : { beforeRef: contentHash(l.previous) },
-                        afterRef: contentHash(l.content),
-                    };
+            const unitHead = land === landing[0]
+                ? (plan.unitHead ?? {
+                    moves: landing
+                        .filter(l => l.target.split(/[\\/]/).pop() !== 'SKILL.md')
+                        .map((l) => {
+                        const p = l.target.slice(dir.length + 1).split(String.fromCharCode(92)).join(String.fromCharCode(47));
+                        return {
+                            path: p,
+                            kind: l.previous === null ? 'created' : 'moved',
+                            to: p,
+                            ...l.previous === null ? {} : { beforeRef: contentHash(l.previous) },
+                            afterRef: contentHash(l.content),
+                        };
+                    })
+                        // F1 (independent review, 2026-10-14): when one plan writes the SAME path twice, keep the
+                        // LAST write -- first-wins left `afterRef` describing the earlier bytes (stale). `beforeRef`
+                        // and `kind` are unaffected: both come from the same per-path pre-read.
+                        .filter((m, idx, all) => all.map(x => x.path).lastIndexOf(m.path) === idx),
+                    sources: [{ skill: name }],
                 })
-                    // F1 (independent review, 2026-10-14): when one plan writes the SAME path twice, keep the
-                    // LAST write -- first-wins left `afterRef` describing the earlier bytes (stale). `beforeRef`
-                    // and `kind` are unaffected: both come from the same per-path pre-read.
-                    .filter((m, idx, all) => all.map(x => x.path).lastIndexOf(m.path) === idx),
-                sources: [{ skill: name }],
-            } : undefined;
+                : undefined;
             // A22: previous is string | null (a read failure rejects the whole plan), so the old
             // `=== undefined ? md : previous` was an unreachable branch -- the type is the truth.
             const auditedBefore = land.previous;

package/lib/types/subagent/channel.js

@@ -6,8 +6,70 @@ function serviceOf(ctx, name) {
 function messageOf(error) {
     return error instanceof Error ? error.message : String(error);
 }
+function textOfValue(value) {
+    if (typeof value === 'string')
+        return value;
+    if (!Array.isArray(value))
+        return '';
+    return value
+        .filter(block => typeof block === 'object' && block !== null && block.type === 'text')
+        .map((block) => {
+        const text = block.text;
+        return typeof text === 'string' ? text : '';
+    })
+        .join('');
+}
+function abortLink(signal, timeoutMs) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => { controller.abort(new Error('subagent turn timeout')); }, timeoutMs);
+    const onAbort = () => { controller.abort(signal?.reason); };
+    signal?.addEventListener('abort', onAbort, { once: true });
+    return {
+        controller,
+        cleanup: () => {
+            clearTimeout(timer);
+            signal?.removeEventListener('abort', onAbort);
+        },
+    };
+}
+function waitForSubagentEnd(ctx, childId, signal, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const finish = (fn) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            fn();
+        };
+        const eventCtx = ctx;
+        const off = typeof eventCtx.on === 'function'
+            ? eventCtx.on('subagent/end', (info) => {
+                if (info.id !== childId)
+                    return;
+                finish(() => { resolve(info); });
+            })
+            : () => { };
+        const timer = setTimeout(() => {
+            finish(() => { reject(new Error('timed out waiting for subagent/end: ' + childId)); });
+        }, timeoutMs);
+        const onAbort = () => {
+            finish(() => { reject(signal.reason instanceof Error ? signal.reason : new Error('conversation turn aborted')); });
+        };
+        signal.addEventListener('abort', onAbort, { once: true });
+        function cleanup() {
+            clearTimeout(timer);
+            signal.removeEventListener('abort', onAbort);
+            off();
+        }
+        if (signal.aborted)
+            onAbort();
+    });
+}
 export function createSubagentChannel(ctx) {
     let lastKind = 'reviewer';
+    const active = new Map();
+    const disposed = new Set();
     const channel = {
         get state() {
             return probeChannelState(ctx, lastKind);
@@ -125,6 +187,146 @@ export function createSubagentChannel(ctx) {
                 }
             }
         },
+        async open(spec) {
+            lastKind = spec.kind;
+            const probe = probeChannelState(ctx, spec.kind);
+            if (probe.kind === 'unavailable')
+                return probe;
+            if (spec.allow.length === 0)
+                return { kind: 'unavailable', code: 'E-324', reason: 'allow set is empty' };
+            const subagents = serviceOf(ctx, 'subagents');
+            const presets = serviceOf(ctx, 'agentPresets');
+            if (subagents === undefined || presets === undefined) {
+                return { kind: 'unavailable', code: 'E-323', reason: 'subagents/agentPresets service unavailable' };
+            }
+            const parentPresetId = presets.composedPreset(spec.parent.ctx);
+            if (parentPresetId === undefined) {
+                return { kind: 'unavailable', code: 'E-323', reason: 'parent preset could not be resolved' };
+            }
+            const ensured = await ensureRestrictedPreset(ctx, { kind: spec.kind, parentPresetId, allow: spec.allow });
+            if (ensured.kind === 'failed')
+                return { kind: 'unavailable', code: 'E-324', reason: ensured.reason };
+            const link = abortLink(spec.signal, spec.timeoutMs);
+            let activation;
+            try {
+                activation = await subagents.startActivation({
+                    provider: 'spawn',
+                    label: spec.label,
+                    delivery: 'caller',
+                    request: {
+                        parent: spec.parent,
+                        prompt: [{ type: 'text', text: spec.promptText }],
+                        agentPreset: ensured.presetId,
+                        ...(spec.cwd !== undefined ? { cwd: spec.cwd } : {}),
+                        ...(spec.maxDepth !== undefined ? { maxDepth: spec.maxDepth } : {}),
+                        ...(spec.agentOptions !== undefined ? { agentOptions: spec.agentOptions } : {}),
+                    },
+                    signal: link.controller.signal,
+                });
+                const result = await activation.result;
+                if (result.stopReason === 'aborted') {
+                    try {
+                        await activation.dispose();
+                    }
+                    catch { /* teardown must not replace the outcome */ }
+                    return { kind: 'aborted' };
+                }
+                if (result.stopReason !== 'completed') {
+                    try {
+                        await activation.dispose();
+                    }
+                    catch { /* teardown must not replace the outcome */ }
+                    return { kind: 'unavailable', code: 'E-323', reason: 'round 1 did not complete: ' + result.stopReason };
+                }
+                const turn = {
+                    childId: activation.childId,
+                    stopReason: result.stopReason,
+                    text: textOfValue(result.output),
+                    ...(result.structured !== undefined ? { structured: result.structured } : {}),
+                    ...(result.diagnostic !== undefined ? { diagnostic: result.diagnostic } : {}),
+                };
+                active.set(activation.childId, { childId: activation.childId, parent: spec.parent, activation, disposed: false });
+                disposed.delete(activation.childId);
+                return { kind: 'ok', childId: activation.childId, turn };
+            }
+            catch (error) {
+                if (activation !== undefined) {
+                    try {
+                        await activation.dispose();
+                    }
+                    catch { /* teardown must not replace the outcome */ }
+                }
+                if (link.controller.signal.aborted)
+                    return { kind: 'aborted' };
+                return { kind: 'unavailable', code: 'E-323', reason: messageOf(error) };
+            }
+            finally {
+                link.cleanup();
+            }
+        },
+        async continueTurn(childId, promptText, options) {
+            if (disposed.has(childId))
+                return { kind: 'unavailable', code: 'E-324', reason: 'conversation is disposed' };
+            const current = active.get(childId);
+            if (current === undefined || current.disposed) {
+                return { kind: 'unavailable', code: 'E-323', reason: 'no open conversation for ' + childId };
+            }
+            const subagents = serviceOf(ctx, 'subagents');
+            if (subagents?.sendMessage === undefined) {
+                return { kind: 'unavailable', code: 'E-323', reason: 'subagents.sendMessage unavailable' };
+            }
+            const link = abortLink(options?.signal, options?.timeoutMs ?? 120_000);
+            let pending;
+            try {
+                pending = waitForSubagentEnd(ctx, childId, link.controller.signal, options?.timeoutMs ?? 120_000);
+                await subagents.sendMessage(current.parent, childId, [{ type: 'text', text: promptText }], { signal: link.controller.signal });
+            }
+            catch (error) {
+                link.cleanup();
+                if (options?.signal?.aborted === true)
+                    return { kind: 'aborted' };
+                return { kind: 'unavailable', code: 'E-323', reason: messageOf(error) };
+            }
+            try {
+                const info = await pending;
+                if (info.stopReason === 'aborted')
+                    return { kind: 'aborted' };
+                const turn = {
+                    childId,
+                    stopReason: info.stopReason ?? 'completed',
+                    text: textOfValue(info.lastAssistantMessage),
+                    ...(info.diagnostic !== undefined ? { diagnostic: info.diagnostic } : {}),
+                };
+                return { kind: 'ok', childId, turn };
+            }
+            catch (error) {
+                if (options?.signal?.aborted === true)
+                    return { kind: 'aborted' };
+                return { kind: 'unavailable', code: 'E-323', reason: messageOf(error) };
+            }
+            finally {
+                link.cleanup();
+            }
+        },
+        async dispose(childId) {
+            const current = active.get(childId);
+            if (current === undefined || current.disposed) {
+                disposed.add(childId);
+                return;
+            }
+            current.disposed = true;
+            active.delete(childId);
+            disposed.add(childId);
+            try {
+                await current.activation.dispose();
+            }
+            catch (error) {
+                try {
+                    ctx.logger.warn('subagent conversation: dispose failed: ' + messageOf(error));
+                }
+                catch { /* logging must not mask teardown */ }
+            }
+        },
     };
     return channel;
 }