maka-agent 0.2.0-dev.76.20261009 → 0.2.0-dev.77.20261009

package/node_modules/@maka/runtime/dist/conversation-copy.js

@@ -40,6 +40,8 @@ import { baseToolResultProjection, decodeLedgerTransition, reduceEffectiveModelP
 import { archivedToolResultProjection } from './tool-result-archive-transition.js';
 import { serializeToolResultProjectionV1 } from './tool-result-archive-encoding.js';
 import { createHash } from 'node:crypto';
+import { encodeCanonicalRuntimeEvent } from '@maka/core/canonical-runtime-event';
+import { conversationCopyAgentOutput, isConversationCopyAgentOutputSnapshot, } from './conversation-copy-agent-output.js';
 import { readToolResultPage, readableToolResult, resolveReadInput, READ_PAGE_MAX_BYTES, } from './read-page.js';
 /** Walks every typed StorageRef site reached by conversation-copy rewriting. */
 function collectConversationCopyStorageRefs(input) {
@@ -52,7 +54,7 @@ function collectConversationCopyStorageRefs(input) {
         if (isArchivedToolResultPlaceholder(value))
             return;
         try {
-            addContent(decodePersistedToolResultContent(markPersisted(value)));
+            addContent(decodeConversationCopyToolResult(value));
         }
         catch {
             // Opaque tool results carry no typed StorageRef.
@@ -141,7 +143,7 @@ export function rewriteConversationCopyMessage(message, references) {
     if (message.type === 'tool_result') {
         return {
             ...message,
-            content: rewriteToolResultContent(message.content, references),
+            content: rewriteToolResultContent(message.content, references, references.toolNamesByCall?.get(conversationCopyToolCallKey(message.turnId, message.toolUseId))),
         };
     }
     if (message.type === 'token_usage' && message.providerRequestTraceId) {
@@ -153,7 +155,8 @@ export function rewriteConversationCopyMessage(message, references) {
     return message;
 }
 function rewriteAttachmentResourceRefs(text, artifactIds) {
-    return text.replace(/maka:\/\/runtime\/attachments\/[^\s)\]}>`'",;:!]+/g, (candidate) => {
+    // Snapshot tool evidence can contain JSON-escaped quotes and newlines.
+    return text.replace(/maka:\/\/runtime\/attachments\/[^\\\s)\]}>`'",;:!]+/g, (candidate) => {
         const parsed = parseAttachmentResourceRef(candidate);
         const artifactId = parsed ? artifactIds.get(parsed.artifactId) : undefined;
         return artifactId ? `maka://runtime/attachments/${artifactId}` : candidate;
@@ -320,6 +323,10 @@ export async function cloneConversationRuntimeLedger(input) {
     const operationIds = toolOperationIdMap(flattenedPlans, targetInvocationIds);
     const references = {
         ...input.referenceMap,
+        toolNamesByCall: conversationCopyToolNames({
+            messages: input.copiedMessages,
+            runtimeEvents: flattenedPlans.flatMap((plan) => plan.events),
+        }),
         runIds,
         invocationIds,
         operationIds,
@@ -589,6 +596,14 @@ function rewriteReadInput(input, references, clonedEvents) {
         : rewriteLedgerArchiveText(rewriteAttachmentResourceRefs(original, references.artifactIds), references);
     if (!input.path.startsWith('maka://read/'))
         return { ...input, path };
+    if (path !== original &&
+        !eventId &&
+        references.ledgerArchives?.has(original) &&
+        parseToolResultArchiveResourceRef(original)?.storage !== 'ledger') {
+        // A retired v1 body has become a rewritten ledger snapshot. Its previous
+        // byte offset and digest cannot address the new resource.
+        return { path };
+    }
     const url = new URL(input.path);
     if (eventId && path !== original) {
         const copied = clonedEvents.get(eventId);
@@ -674,7 +689,21 @@ async function loadConversationCopyRunEvents(sourceRuns, sourceEvents, copyTurnI
         ];
     }));
 }
-export function conversationCopyLinkedChildReferences(content) {
+// Legacy archive bodies and provider projections can store the raw result;
+// RuntimeEvents and transcript messages normally carry the JSON wrapper.
+function decodeConversationCopyToolResult(value, toolName) {
+    if (toolName === 'agent_output' &&
+        (conversationCopyAgentOutput(value) || isConversationCopyAgentOutputSnapshot(value)))
+        return { kind: 'json', value };
+    return decodePersistedToolResultContent(markPersisted(value));
+}
+export function conversationCopyLinkedChildReferences(content, toolName) {
+    if (content.kind === 'json') {
+        if (toolName !== 'agent_output')
+            return [];
+        const output = conversationCopyAgentOutput(content.value);
+        return output ? [output.reference] : [];
+    }
     if (content.kind === 'subagent') {
         if (!content.childSessionId)
             return [];
@@ -706,27 +735,56 @@ export function conversationCopyLinkedChildReferences(content) {
         : []);
 }
 export function collectConversationCopyLinkedChildReferences(input) {
-    const references = [];
-    const add = (value) => {
+    return conversationCopyToolResults(input).flatMap(({ content, toolName }) => conversationCopyLinkedChildReferences(content, toolName));
+}
+/** Pair transcript results with call metadata, including historical ledger-only calls. */
+function conversationCopyToolNames(input) {
+    const names = new Map();
+    const add = (turnId, callId, name) => {
+        const key = conversationCopyToolCallKey(turnId, callId);
+        names.set(key, names.has(key) && names.get(key) !== name ? undefined : name);
+    };
+    for (const message of input.messages) {
+        if (message.type === 'tool_call')
+            add(message.turnId, message.id, message.toolName);
+    }
+    for (const event of input.runtimeEvents) {
+        if (event.content?.kind === 'function_call' || event.content?.kind === 'function_response') {
+            add(event.turnId, event.content.id, event.content.name);
+        }
+    }
+    return names;
+}
+function conversationCopyToolCallKey(turnId, callId) {
+    return JSON.stringify([turnId, callId]);
+}
+function conversationCopyToolResults(input) {
+    const results = [];
+    const toolNames = conversationCopyToolNames(input);
+    const add = (value, toolName) => {
         if (isArchivedToolResultPlaceholder(value))
             return;
         try {
-            references.push(...conversationCopyLinkedChildReferences(decodePersistedToolResultContent(markPersisted(value))));
+            results.push({ content: decodeConversationCopyToolResult(value, toolName), toolName });
         }
         catch {
-            // Opaque tool results have no typed linked-child references.
+            // Opaque tool results have no typed conversation-copy references.
         }
     };
     for (const message of input.messages) {
         if (message.type === 'tool_result') {
-            references.push(...conversationCopyLinkedChildReferences(message.content));
+            results.push({
+                content: message.content,
+                toolName: toolNames.get(conversationCopyToolCallKey(message.turnId, message.toolUseId)),
+            });
         }
     }
     for (const event of input.runtimeEvents) {
-        if (event.content?.kind === 'function_response')
-            add(event.content.result);
+        if (event.content?.kind === 'function_response') {
+            add(event.content.result, toolNames.get(conversationCopyToolCallKey(event.turnId, event.content.id)));
+        }
     }
-    return references;
+    return results;
 }
 /**
  * Collects the `relativePath` of every `session_file` StorageRef that the copied
@@ -737,6 +795,8 @@ export function collectConversationCopyLinkedChildReferences(input) {
  * their refs resolve in `rewriteStorageRef`. Walks exactly the ref sites reached
  * by `rewriteStorageRef`: user-message attachments, tool_result image refs, text
  * runtime-event attachments, and function_response / archived tool-result images.
+ * Static agent_output snapshots also own their Artifacts; those can retain a
+ * child Turn id outside the copied parent's turn closure and need explicit inclusion.
  */
 export function collectConversationCopySessionFileRefs(input) {
     const refs = new Set();
@@ -745,6 +805,14 @@ export function collectConversationCopySessionFileRefs(input) {
             refs.add(ref.relativePath);
         }
     }
+    for (const { content, toolName } of conversationCopyToolResults(input)) {
+        if (toolName === 'agent_output' &&
+            content.kind === 'json' &&
+            isConversationCopyAgentOutputSnapshot(content.value)) {
+            for (const artifactId of content.value.artifactIds)
+                refs.add(artifactId);
+        }
+    }
     return refs;
 }
 function cloneAgentRunEvent(event, ids, references, sourceCompactableEvents, clonedRuntimeEvents, checkpointIds, providerTraceIds, logicalCallIds, clonedTransitions) {
@@ -830,10 +898,9 @@ function cloneAgentRunEvent(event, ids, references, sourceCompactableEvents, clo
     }
     else if (event.type === MODEL_PROJECTION_TRANSITION_EVENT_TYPE) {
         const cloned = clonedTransitions.get(event);
-        // Every transition whose target is in the copied slice was gathered into
-        // this run's ledger, wherever it was recorded. So a transition that finds no
-        // cloned target has genuinely lost its target as well, and dropping it
-        // cannot bring replaced content back.
+        // A transition is omitted only when its target was excluded or its archive
+        // wrapper was collapsed into an already copied archive. Neither case can
+        // bring replaced content back into the model-visible history.
         if (!cloned)
             return null;
         data = { ...event.data, transition: cloned, runtimeEventId: cloned.target.runtimeEventId };
@@ -873,37 +940,57 @@ function cloneModelProjectionTransition(event, references, clonedRuntimeEvents,
     }
     const placeholder = rawPlaceholder;
     const existing = transitionState.get(clonedTarget.id);
-    const sourceProjection = existing?.projection ?? baseToolResultProjection(clonedTarget);
+    // RuntimeEvent storage canonicalizes JSON key order. Hash the bytes a later
+    // archive read will reconstruct, including newly built snapshot projections.
+    const sourceProjection = existing?.projection ??
+        baseToolResultProjection(encodeCanonicalRuntimeEvent(clonedTarget).event);
     if (!sourceProjection) {
         throw new Error(`Cannot copy model projection transition ${event.id} onto its target`);
     }
-    // The copied event already holds the target's rewritten result, so every
-    // archive, including a legacy Artifact-backed one, is rebuilt as a ledger
-    // archive of that event instead of pointing at the source's archived body.
+    const previousTransitionId = source.previousTransitionId
+        ? requiredMappedId(transitionIds, source.previousTransitionId, 'model projection transition')
+        : undefined;
+    // Persisted placeholders can use a public event address or an exact legacy
+    // ledger identity. Both must resolve to the same rebuilt archive on recopy.
+    const sourceRefs = new Set([
+        buildToolResultArchiveResourceRef(placeholder),
+        ...(placeholder.resourceRef ? [placeholder.resourceRef] : []),
+    ]);
+    const previousPlaceholder = existing?.projection.kind === 'json' ? existing.projection.value : undefined;
+    if (existing &&
+        isArchivedToolResultPlaceholder(previousPlaceholder) &&
+        previousPlaceholder.rewriteVersion === 2) {
+        if (previousTransitionId !== existing.transitionId)
+            throw new Error(`Cannot collapse disconnected archive transition ${event.id}`);
+        // Public Read addresses identify an event, not a transition. Archiving
+        // this placeholder again would make that address return itself. Keep the
+        // first archive of the copied body and alias every later wrapper to it.
+        for (const sourceRef of sourceRefs)
+            references.ledgerArchives?.set(sourceRef, previousPlaceholder);
+        transitionIds.set(source.transitionId, existing.transitionId);
+        return null;
+    }
+    if (clonedTarget.content?.kind === 'function_response' && !clonedTarget.content.modelProjection)
+        clonedTarget.content.modelProjection = sourceProjection;
+    // Rebuild every archive over the copied ledger, including legacy v1 bodies.
     const serialized = serializeToolResultProjectionV1(sourceProjection);
     const rewritten = buildLedgerArchivedToolResultPlaceholder({
         storage: 'ledger',
         runtimeEventId: clonedTarget.id,
         toolCallId: placeholder.toolCallId,
         toolName: placeholder.toolName,
+        originalEstimatedTokens: placeholder.originalEstimatedTokens,
+        reason: placeholder.reason,
         sourceProjectionDigest: durableToolResultProjectionDigest(sourceProjection),
         bodySha256: createHash('sha256').update(serialized).digest('hex'),
         originalBytes: Buffer.byteLength(serialized),
-        originalEstimatedTokens: placeholder.originalEstimatedTokens,
-        reason: placeholder.reason,
-        ...(source.previousTransitionId
-            ? {
-                previousTransitionId: requiredMappedId(transitionIds, source.previousTransitionId, 'model projection transition'),
-            }
-            : {}),
+        ...(previousTransitionId ? { previousTransitionId } : {}),
     });
     if (placeholder.page) {
         rewritten.page = readToolResultPage(serialized, { path: rewritten.resourceRef }, READ_PAGE_MAX_BYTES - Buffer.byteLength(JSON.stringify(rewritten)) - 32);
     }
-    // Earlier Reads of a legacy archive keep naming its copied Artifact.
-    if (placeholder.rewriteVersion === 2) {
-        references.ledgerArchives?.set(placeholder.resourceRef ?? buildToolResultArchiveResourceRef(placeholder), rewritten);
-    }
+    for (const sourceRef of sourceRefs)
+        references.ledgerArchives?.set(sourceRef, rewritten);
     const transition = buildModelProjectionTransition({
         sessionId: references.targetSessionId,
         target: {
@@ -917,11 +1004,7 @@ function cloneModelProjectionTransition(event, references, clonedRuntimeEvents,
         // The applied chain is copied in fold order, so a predecessor is always
         // rebuilt before its successor. An unmapped one means the chain broke, and
         // rooting the successor instead would change what the fold decides.
-        ...(source.previousTransitionId
-            ? {
-                previousTransitionId: requiredMappedId(transitionIds, source.previousTransitionId, 'model projection transition'),
-            }
-            : {}),
+        ...(previousTransitionId ? { previousTransitionId } : {}),
         now: source.createdAt,
     });
     transitionIds.set(source.transitionId, transition.transitionId);
@@ -1135,6 +1218,9 @@ function rewriteInvocationOpening(opening, references) {
     };
 }
 function rewriteRuntimeEventReferences(event, references) {
+    const toolName = event.content?.kind === 'function_response'
+        ? references.toolNamesByCall?.get(conversationCopyToolCallKey(event.turnId, event.content.id))
+        : undefined;
     const content = event.content?.kind === 'text'
         ? {
             ...event.content,
@@ -1151,10 +1237,10 @@ function rewriteRuntimeEventReferences(event, references) {
         : event.content?.kind === 'function_response'
             ? {
                 ...event.content,
-                result: rewriteRuntimeToolResult(event.content.result, references),
+                result: rewriteRuntimeToolResult(event.content.result, references, toolName),
                 ...(event.content.modelProjection
                     ? {
-                        modelProjection: rewriteDurableToolResultProjectionArtifactRefs(event.content.modelProjection, (ref) => rewriteProjectionArtifactRef(ref, references)),
+                        modelProjection: rewriteConversationCopyModelProjection(event.content.modelProjection, references, toolName),
                     }
                     : {}),
             }
@@ -1249,7 +1335,24 @@ function rewriteToolRecoveryFact(recovery, operationId, references) {
         },
     };
 }
-function rewriteToolResultContent(content, references) {
+function rewriteToolResultContent(content, references, toolName) {
+    if (toolName === 'agent_output' && content.kind === 'json') {
+        if (isConversationCopyAgentOutputSnapshot(content.value)) {
+            return rewriteAgentOutputSnapshot(content.value, references);
+        }
+        const output = conversationCopyAgentOutput(content.value);
+        if (output) {
+            const shared = sharedChild(output.reference.childSessionId, references);
+            if (!shared) {
+                return rewriteAgentOutputSnapshot(output.snapshot, references);
+            }
+            // Revision children remain owned by their original physical Session.
+            // Validate those external references without rewriting their identities.
+            rewriteLinkedRunId(output.reference.runId, shared, references, 'AgentRun');
+            rewriteLinkedArtifactIds(output.reference.artifactIds, shared, references);
+            return content;
+        }
+    }
     if (content.kind === 'image') {
         return { ...content, ref: rewriteStorageRef(content.ref, references) };
     }
@@ -1320,17 +1423,44 @@ function rewriteToolResultContent(content, references) {
     }
     return content;
 }
-function rewriteRuntimeToolResult(value, references) {
+function rewriteAgentOutputSnapshot(snapshot, references) {
+    return {
+        kind: 'json',
+        value: {
+            ...snapshot,
+            ...(snapshot.text !== undefined
+                ? { text: rewriteAttachmentResourceRefs(snapshot.text, references.artifactIds) }
+                : {}),
+            artifactIds: rewriteArtifactIds(snapshot.artifactIds, references),
+        },
+    };
+}
+function rewriteConversationCopyModelProjection(projection, references, toolName) {
+    if (toolName === 'agent_output' &&
+        projection.kind === 'json' &&
+        (conversationCopyAgentOutput(projection.value) ||
+            isConversationCopyAgentOutputSnapshot(projection.value))) {
+        const content = rewriteToolResultContent({ kind: 'json', value: projection.value }, references, toolName);
+        if (content.kind === 'json')
+            return { ...projection, value: content.value };
+    }
+    return rewriteDurableToolResultProjectionArtifactRefs(projection, (ref) => rewriteProjectionArtifactRef(ref, references));
+}
+function rewriteRuntimeToolResult(value, references, toolName) {
     if (isArchivedToolResultPlaceholder(value))
         return rewriteArchivedToolResult(value, references);
     let content;
     try {
-        content = decodePersistedToolResultContent(markPersisted(value));
+        content = decodeConversationCopyToolResult(value, toolName);
     }
     catch {
         return value;
     }
-    return rewriteToolResultContent(content, references);
+    const rewritten = rewriteToolResultContent(content, references, toolName);
+    return (conversationCopyAgentOutput(value) || isConversationCopyAgentOutputSnapshot(value)) &&
+        rewritten.kind === 'json'
+        ? rewritten.value
+        : rewritten;
 }
 function rewriteArtifactIds(artifactIds, references) {
     return artifactIds.flatMap((artifactId) => {
@@ -1401,11 +1531,11 @@ function rewriteProjectionArtifactRef(ref, references) {
     return rewritten;
 }
 function rewriteArchivedToolResult(value, references) {
+    const migrated = references.ledgerArchives?.get(buildToolResultArchiveResourceRef(value));
+    if (migrated)
+        return migrated;
     if (value.rewriteVersion === 2) {
-        const rewritten = references.ledgerArchives?.get(buildToolResultArchiveResourceRef(value));
-        if (!rewritten)
-            throw new Error('Cannot copy ledger archive without its committed transition');
-        return rewritten;
+        throw new Error('Cannot copy ledger archive without its committed transition');
     }
     const artifactId = rewriteOwnedArtifactId(value.artifactId, references);
     const resource = value.resourceRef

package/node_modules/@maka/runtime/dist/filesystem-worker/resource-resolver.js

@@ -19,7 +19,9 @@
 import { realpath, stat } from 'node:fs/promises';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
-export const FILESYSTEM_WORKER_BUNDLE_NAME = 'filesystem-worker.js';
+// `.mjs` so Node never looks for a package.json to decide the module type:
+// the Windows AppContainer sandbox denies that read and the worker crashes.
+export const FILESYSTEM_WORKER_BUNDLE_NAME = 'filesystem-worker.mjs';
 export function filesystemWorkerBundleCandidate(location) {
     if (location.kind === 'desktop-packaged') {
         return join(location.resourcesPath, 'workers', FILESYSTEM_WORKER_BUNDLE_NAME);

package/node_modules/@maka/runtime/dist/owned-child-process.js

@@ -0,0 +1,209 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { buildSpawnStdio } from './child-fd-input.js';
+import { terminateProcessTree } from './process-tree-terminator.js';
+/** The returned PID owns the command group. Its private IPC channel is a
+ * lifetime lease: only the supervisor can spawn the command, and losing the
+ * owner tears down the group even when no Host cleanup callback can run.
+ * Output and descriptor payloads flow directly through inherited OS handles.
+ * `ready` resolves with the command's own PID once the supervisor admits it.
+ */
+export function spawnOwnedProcess(input) {
+    const stdio = buildSpawnStdio(input.fdInputs, input.stdin);
+    const child = spawn(process.execPath, [fileURLToPath(new URL('./owned-process-main.js', import.meta.url))], {
+        cwd: input.cwd,
+        // Caller-supplied environment belongs to the command, not this trusted supervisor.
+        env: {
+            ...process.env,
+            NODE_OPTIONS: '',
+            ...(process.versions.electron ? { ELECTRON_RUN_AS_NODE: '1' } : {}),
+        },
+        stdio: [...stdio, 'ipc'],
+        // POSIX: the supervisor leads a new process group that the command joins.
+        // Termination signals the group and removes descendants visible outside
+        // it at each process-table snapshot. Windows has no process groups;
+        // taskkill /T owns the equivalent cleanup. There, detaching also keeps
+        // the supervisor out of the Host's libuv job, which would kill it with
+        // the Host before it could stop the command's descendants; the command
+        // itself stays in the supervisor's job.
+        detached: true,
+        windowsHide: true,
+    });
+    let started = false;
+    let completed = false;
+    let failureReported = false;
+    let resolveReady;
+    let rejectReady;
+    const ready = new Promise((resolve, reject) => {
+        resolveReady = resolve;
+        rejectReady = reject;
+    });
+    // Some callers observe ChildProcess errors instead of awaiting admission.
+    void ready.catch(() => { });
+    const timer = setTimeout(() => fail(new Error('Command supervisor startup timed out')), 10_000);
+    timer.unref();
+    const terminate = () => {
+        if (child.pid)
+            void terminateProcessTree({ pid: child.pid, signal: 'SIGKILL' }).catch(() => { });
+    };
+    // Once the supervisor is reaped its PID can be reused, so a tree walk from it
+    // could reach unrelated processes. Its POSIX process group cannot be
+    // reallocated while members remain, so it alone still names the command.
+    // Windows has no such handle; taskkill /T on a reaped PID is skipped.
+    const terminateOrphanedGroup = () => {
+        if (process.platform === 'win32' || !child.pid)
+            return;
+        try {
+            process.kill(-child.pid, 'SIGKILL');
+        }
+        catch {
+            // The group is already empty.
+        }
+    };
+    // Command output reaches these pipes directly, racing the IPC admission
+    // message. Hold it until callers have observed `ready`, so output never
+    // precedes admission, as with a direct spawn. Callers attach 'data'
+    // listeners synchronously; an explicit pause keeps those from resuming.
+    const outputs = [child.stdout, child.stderr].filter((stream) => stream !== null);
+    for (const stream of outputs)
+        stream.pause();
+    let outputReleased = false;
+    const releaseOutput = () => {
+        if (outputReleased)
+            return;
+        outputReleased = true;
+        for (const stream of outputs)
+            stream.resume();
+    };
+    /**
+     * `stop` says who stops the tree: `tree` walks it from the live supervisor;
+     * `group` signals only its process group, because the supervisor is exiting
+     * on its own and its PID may be reaped before a walk could start; `none`
+     * leaves the stop to the supervisor, which walks its own tree.
+     */
+    function fail(error, stop = 'tree') {
+        if (failureReported)
+            return;
+        failureReported = true;
+        clearTimeout(timer);
+        rejectReady(error);
+        releaseOutput();
+        if (stop === 'tree')
+            terminate();
+        else if (stop === 'group')
+            terminateOrphanedGroup();
+        child.emit('error', error);
+    }
+    child.once('error', (error) => {
+        clearTimeout(timer);
+        rejectReady(error);
+        releaseOutput();
+    });
+    child.once('spawn', () => {
+        const request = {
+            kind: 'launch',
+            program: input.program,
+            args: input.args,
+            cwd: input.cwd,
+            env: input.env ?? process.env,
+            shell: input.shell,
+            inheritedFds: (input.fdInputs ?? []).map(({ fd }) => fd),
+        };
+        child.send(request, (error) => {
+            if (error && child.exitCode === null && child.signalCode === null)
+                fail(error);
+        });
+    });
+    child.on('message', (value) => {
+        const message = value;
+        if (message.kind === 'started') {
+            started = true;
+            clearTimeout(timer);
+            resolveReady(message.pid);
+            // Promise continuations of `ready` run before the check phase; a
+            // nextTick resume would deliver output ahead of them.
+            setImmediate(releaseOutput);
+        }
+        else if (message.kind === 'completed') {
+            completed = true;
+        }
+        else if (message.kind === 'failed') {
+            // A result already arrived; a later report cannot replace it.
+            if (completed)
+                return;
+            const error = Object.assign(new Error(message.message), { code: message.code });
+            if (!started) {
+                // The command never spawned; the supervisor is exiting on its own.
+                completed = true;
+                fail(error, 'group');
+            }
+            else {
+                // A supervisor fault after admission: it stops its own tree, including
+                // descendants that left its group, before exiting. Signalling the group
+                // now would kill it mid-walk. The group kill on its exit stays the
+                // backstop, so `completed` remains unset.
+                fail(error, 'none');
+            }
+        }
+    });
+    child.once('exit', (code) => {
+        clearTimeout(timer);
+        releaseOutput();
+        // `exit` is not ordered after IPC messages still being read; the channel's
+        // close is. Decide a missing result only once the channel has drained.
+        if (completed || !child.connected)
+            settleExit(code);
+        else
+            child.once('disconnect', () => settleExit(code));
+    });
+    function settleExit(code) {
+        if (!started)
+            rejectReady(new Error('Command supervisor exited before admission'));
+        if (completed)
+            return;
+        // The group can outlive its leader. An unexpected supervisor exit must
+        // not leave an admitted command running while the Host is still alive.
+        terminateOrphanedGroup();
+        // A clean exit without `completed` lost the command's result. On POSIX the
+        // Host's own stops end the supervisor by signal, so any exit code there is
+        // a supervisor fault too. On Windows taskkill, the Host's forced stop, also
+        // ends with an ordinary code.
+        const lost = code === 0 || (code !== null && process.platform !== 'win32');
+        if (lost && !failureReported) {
+            child.emit('error', new Error('Command supervisor lost its result'));
+        }
+    }
+    return { child, ready };
+}
+/** A supervisor PID denotes the whole command group, including during startup. */
+export function signalOwnedProcess(child, signal) {
+    if (process.platform === 'win32' || !child.pid)
+        return child.kill(signal);
+    try {
+        process.kill(-child.pid, signal);
+        return true;
+    }
+    catch (error) {
+        if (error.code === 'ESRCH')
+            return false;
+        throw error;
+    }
+}