brainclaw 0.29.2 → 1.5.4

package/dist/core/entity-registry.js

@@ -0,0 +1,344 @@
+/**
+ * Entity Registry — single source of truth for the canonical CRUD surface.
+ *
+ * Phase 3 slice 3a (pln_c6472192). Consumed by bclaw_find / get / create /
+ * update / remove / transition (slice 3b). Grammar-consistency tests
+ * live in tests/unit/entity-registry.test.ts.
+ *
+ * Design principles (per entity-model-audit §6 P6.2):
+ *  - Declarative: transition matrix + side-effect tags as data.
+ *  - Imperative side effects (the code that actually releases claims,
+ *    promotes candidates, emits events) stays in `src/core/operations/*`
+ *    and `src/core/<entity>.ts` — the registry references them by name
+ *    but does not dispatch.
+ *  - Short-label prefixes match the authoritative map in `src/core/ids.ts`
+ *    (a consistency test pins this).
+ *  - `updatable` is the subset of persisted fields `bclaw_update` may
+ *    patch. Non-listed fields are set at create time or via a
+ *    transition — never by plain update.
+ */
+import { CandidateSchema, ClaimSchema, ConstraintSchema, CrossProjectLinkSchema, CurrentSessionStateSchema, DecisionSchema, HandoffSchema, InboxMessageSchema, InstructionEntrySchema, PlanItemSchema, PlanStepSchema, RuntimeNoteSchema, SequenceSchema, TrapSchema, AssignmentSchema, AgentRunSchema, ActionRequiredSchema, } from './schema.js';
+/** Canonical plan lifecycle. */
+const plan = {
+    name: 'plan',
+    shortLabelPrefix: 'pln',
+    schema: PlanItemSchema,
+    updatable: ['text', 'priority', 'tags', 'assignee', 'estimated_effort', 'actual_effort', 'depends_on'],
+    statusField: 'status',
+    transitions: {
+        todo: ['in_progress', 'blocked', 'done', 'dropped'],
+        in_progress: ['blocked', 'done', 'dropped'],
+        blocked: ['in_progress', 'dropped'],
+    },
+    terminal: ['done', 'dropped'],
+    sideEffects: {
+        'in_progress->done': ['audit:plan_done', 'cascade:release_linked_claims_if_last'],
+        'todo->done': ['audit:plan_done', 'cascade:release_linked_claims_if_last'],
+        'todo->dropped': ['audit:plan_dropped'],
+        'in_progress->dropped': ['audit:plan_dropped'],
+        'blocked->dropped': ['audit:plan_dropped'],
+    },
+};
+/** Plan steps — finer-grained lifecycle with a testing stage. */
+const step = {
+    name: 'step',
+    shortLabelPrefix: 'stp',
+    schema: PlanStepSchema,
+    updatable: ['text', 'assignee'],
+    statusField: 'status',
+    transitions: {
+        todo: ['in_progress', 'blocked', 'done'],
+        in_progress: ['testing', 'done', 'blocked'],
+        testing: ['done', 'blocked', 'in_progress'],
+        blocked: ['in_progress', 'todo'],
+    },
+    terminal: ['done'],
+    sideEffects: {
+        'testing->done': ['audit:step_done', 'cascade:auto_complete_plan_if_last_step'],
+        'in_progress->done': ['audit:step_done', 'cascade:auto_complete_plan_if_last_step'],
+    },
+};
+/** Claim — file-level advisory lock. */
+const claim = {
+    name: 'claim',
+    shortLabelPrefix: 'clm',
+    schema: ClaimSchema,
+    updatable: ['description'],
+    statusField: 'status',
+    transitions: {
+        active: ['released', 'stale'],
+    },
+    terminal: ['released', 'stale'],
+    sideEffects: {
+        'active->released': ['audit:claim_released', 'cascade:plan_status_if_last_claim'],
+        'active->stale': ['audit:claim_stale', 'heartbeat:expired'],
+    },
+};
+/** Session — execution envelope. Status tracked via timestamps, not an enum. */
+const session = {
+    name: 'session',
+    shortLabelPrefix: 'sess',
+    schema: CurrentSessionStateSchema,
+    updatable: ['last_seen_at'],
+    transitions: {},
+    terminal: [],
+    sideEffects: {},
+};
+/** Handoff — session-end artefact. Downscale in 3e: no more review sub-flow. */
+const handoff = {
+    name: 'handoff',
+    shortLabelPrefix: 'hnd',
+    schema: HandoffSchema,
+    updatable: ['narrative', 'tags'],
+    statusField: 'status',
+    transitions: {
+        open: ['accepted', 'closed'],
+        accepted: ['closed'],
+    },
+    terminal: ['closed'],
+    sideEffects: {
+        'open->closed': ['audit:handoff_closed'],
+        'open->accepted': ['audit:handoff_accepted'],
+        'accepted->closed': ['audit:handoff_closed'],
+    },
+};
+/** Decision — memory record with a retrospective outcome field (not a lifecycle status). */
+const decision = {
+    name: 'decision',
+    shortLabelPrefix: 'dec',
+    schema: DecisionSchema,
+    updatable: ['text', 'tags', 'outcome', 'scope', 'related_paths'],
+    statusField: 'outcome',
+    transitions: {
+        pending: ['approved', 'rejected', 'deferred'],
+        deferred: ['approved', 'rejected'],
+    },
+    terminal: ['approved', 'rejected'],
+    sideEffects: {},
+};
+/** Constraint — enforced rule. */
+const constraint = {
+    name: 'constraint',
+    shortLabelPrefix: 'cst',
+    schema: ConstraintSchema,
+    updatable: ['text', 'tags', 'category', 'scope', 'related_paths', 'expires_at'],
+    statusField: 'status',
+    transitions: {
+        active: ['resolved', 'expired'],
+    },
+    terminal: ['resolved', 'expired'],
+    sideEffects: {
+        'active->resolved': ['audit:constraint_resolved'],
+        'active->expired': ['audit:constraint_expired'],
+    },
+};
+/** Trap — environmental pitfall. */
+const trap = {
+    name: 'trap',
+    shortLabelPrefix: 'trp',
+    schema: TrapSchema,
+    updatable: ['text', 'tags', 'severity', 'scope', 'related_paths', 'expires_at', 'platform_scope'],
+    statusField: 'status',
+    transitions: {
+        active: ['resolved', 'expired'],
+    },
+    terminal: ['resolved', 'expired'],
+    sideEffects: {
+        'active->resolved': ['audit:trap_resolved'],
+        'active->expired': ['audit:trap_expired'],
+    },
+};
+/**
+ * Candidate — review queue entity. Slated for removal in v1.0: new code
+ * should prefer direct memory writes + read-time confidence filtering.
+ * Kept in the registry so that legacy accept/reject flows still work.
+ */
+const candidate = {
+    name: 'candidate',
+    shortLabelPrefix: 'cnd',
+    schema: CandidateSchema,
+    updatable: ['text', 'tags', 'severity', 'narrative', 'related_paths', 'plan_id'],
+    statusField: 'status',
+    transitions: {
+        pending: ['accepted', 'rejected'],
+    },
+    terminal: ['accepted', 'rejected'],
+    sideEffects: {
+        'pending->accepted': ['audit:candidate_accepted', 'promote:to_decision_or_constraint_or_trap_or_handoff'],
+        'pending->rejected': ['audit:candidate_rejected'],
+    },
+};
+/** Runtime note — observation record, no lifecycle. */
+const runtime_note = {
+    name: 'runtime_note',
+    shortLabelPrefix: 'rtn',
+    schema: RuntimeNoteSchema,
+    updatable: ['text', 'tags', 'visibility', 'expires_at'],
+    transitions: {},
+    terminal: [],
+    sideEffects: {},
+};
+/** Sequence — lane-based execution coordinator across plans/steps. */
+const sequence = {
+    name: 'sequence',
+    shortLabelPrefix: 'seq',
+    schema: SequenceSchema,
+    updatable: ['name', 'description', 'tags', 'items', 'owner'],
+    statusField: 'status',
+    transitions: {
+        draft: ['active', 'archived'],
+        active: ['archived'],
+    },
+    terminal: ['archived'],
+    sideEffects: {
+        'draft->active': ['audit:sequence_activated'],
+        'active->archived': ['audit:sequence_archived'],
+    },
+};
+/** Inbox message — dispatch brief, review request, or signal. */
+const inbox_message = {
+    name: 'inbox_message',
+    shortLabelPrefix: 'msg',
+    schema: InboxMessageSchema,
+    updatable: [],
+    statusField: 'status',
+    transitions: {
+        pending: ['read', 'acknowledged', 'archived'],
+        read: ['acknowledged', 'archived'],
+        acknowledged: ['archived'],
+    },
+    terminal: ['archived'],
+    sideEffects: {
+        'pending->read': ['timestamp:read_at'],
+        'pending->acknowledged': ['timestamp:read_at', 'timestamp:ack_at'],
+        'read->acknowledged': ['timestamp:ack_at'],
+    },
+};
+/** Instruction — rule layer (global/project/agent). No lifecycle status. */
+const instruction = {
+    name: 'instruction',
+    shortLabelPrefix: 'ins',
+    schema: InstructionEntrySchema,
+    updatable: ['text', 'tags', 'active'],
+    transitions: {},
+    terminal: [],
+    sideEffects: {},
+};
+/**
+ * Assignment — work delegation record. Its transition matrix is rich and
+ * owned by `src/core/assignments.ts` (transitionAssignment + VALID). The
+ * registry mirrors that matrix so the canonical CRUD verbs see a unified
+ * surface; the imperative transition code stays where it is.
+ */
+const assignment = {
+    name: 'assignment',
+    shortLabelPrefix: 'asgn',
+    schema: AssignmentSchema,
+    updatable: ['brief', 'tags'],
+    statusField: 'status',
+    transitions: {
+        created: ['offered', 'expired'],
+        offered: ['accepted', 'expired', 'rerouted'],
+        accepted: ['started', 'failed', 'timed_out'],
+        started: ['completed', 'failed', 'blocked', 'timed_out'],
+        failed: ['retrying'],
+        timed_out: ['retrying'],
+        retrying: ['offered'],
+        blocked: ['started', 'rerouted', 'failed'],
+    },
+    terminal: ['completed', 'expired', 'rerouted'],
+    sideEffects: {
+        'created->offered': ['timestamp:offered_at', 'event:assignment_offered', 'audit:assignment_offered'],
+        'offered->accepted': ['timestamp:accepted_at', 'event:assignment_accepted', 'sync:agent_run'],
+        'accepted->started': ['timestamp:started_at', 'event:assignment_started', 'sync:agent_run'],
+        'started->completed': ['timestamp:completed_at', 'event:assignment_completed', 'sync:agent_run'],
+        'started->failed': ['timestamp:failed_at', 'event:assignment_failed', 'sync:agent_run'],
+    },
+};
+/** Agent run — per-attempt execution record paired with an assignment. */
+const agent_run = {
+    name: 'agent_run',
+    shortLabelPrefix: 'run',
+    schema: AgentRunSchema,
+    updatable: ['output_summary', 'error_summary'],
+    statusField: 'status',
+    transitions: {
+        created: ['launching', 'waiting_input', 'running', 'cancelled', 'interrupted'],
+        launching: ['waiting_input', 'running', 'failed', 'cancelled', 'timed_out', 'interrupted'],
+        waiting_input: ['running', 'blocked', 'failed', 'cancelled', 'timed_out', 'interrupted'],
+        running: ['waiting_input', 'blocked', 'completed', 'failed', 'cancelled', 'timed_out', 'interrupted'],
+        blocked: ['waiting_input', 'running', 'failed', 'cancelled', 'timed_out', 'interrupted'],
+    },
+    terminal: ['completed', 'failed', 'cancelled', 'timed_out', 'interrupted'],
+    sideEffects: {
+        'running->completed': ['timestamp:completed_at', 'event:agent_run_completed'],
+        'running->failed': ['timestamp:completed_at', 'event:agent_run_failed'],
+    },
+};
+/** Action — required follow-up item. */
+const action = {
+    name: 'action',
+    shortLabelPrefix: 'act',
+    schema: ActionRequiredSchema,
+    updatable: ['description', 'priority'],
+    statusField: 'status',
+    transitions: {
+        open: ['in_progress', 'completed', 'dismissed'],
+        in_progress: ['completed', 'dismissed'],
+    },
+    terminal: ['completed', 'dismissed'],
+    sideEffects: {
+        'open->completed': ['audit:action_completed'],
+        'in_progress->completed': ['audit:action_completed'],
+    },
+};
+/**
+ * Cross-project link — federation peer entry stored in config.yaml
+ * (cross_project_links). Stateless: identified by `name`, no lifecycle.
+ * Storage is YAML-in-config rather than a per-entity directory, so the
+ * `bclaw_create/find/remove` ops route through `src/core/cross-project.ts`
+ * helpers (addCrossProjectLink / resolveCrossProjectLinks /
+ * removeCrossProjectLink).
+ */
+const cross_project_link = {
+    name: 'cross_project_link',
+    shortLabelPrefix: 'xpl',
+    schema: CrossProjectLinkSchema,
+    updatable: ['name', 'role', 'channels'],
+    transitions: {},
+    terminal: [],
+    sideEffects: {},
+};
+export const ENTITY_REGISTRY = {
+    plan, step, claim, session, handoff,
+    decision, constraint, trap, candidate, runtime_note, sequence,
+    inbox_message, instruction,
+    assignment, agent_run, action,
+    cross_project_link,
+};
+export const ENTITY_NAMES = Object.keys(ENTITY_REGISTRY);
+/** Look up an entity spec by name. Throws if the name is unknown. */
+export function getEntitySpec(name) {
+    const spec = ENTITY_REGISTRY[name];
+    if (!spec)
+        throw new Error(`Unknown entity: ${name}`);
+    return spec;
+}
+/**
+ * Check if a transition is valid for the given entity.
+ * Stateless entities (no statusField) always reject transitions.
+ */
+export function isValidTransition(name, from, to) {
+    const spec = getEntitySpec(name);
+    if (!spec.statusField)
+        return false;
+    if (spec.terminal.includes(from))
+        return false;
+    const allowed = spec.transitions[from];
+    return allowed ? allowed.includes(to) : false;
+}
+/** Canonical transition key for sideEffects lookup: `from->to`. */
+export function transitionKey(from, to) {
+    return `${from}->${to}`;
+}
+//# sourceMappingURL=entity-registry.js.map

package/dist/core/events.js

@@ -2,11 +2,22 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { resolveEventSessionId } from './identity.js';
 import { RuntimeEventSchema } from './schema.js';
-import { readFileSync, resolveEntityDir } from './io.js';
+import { readFileSync, resolveEntityDir, writeFileAtomic } from './io.js';
 import { logger } from './logger.js';
+import { mutate } from './mutation-pipeline.js';
+import { generateId, nowISO } from './ids.js';
 function runtimeDir(cwd) {
     return resolveEntityDir('runtime', cwd ?? process.cwd(), 'read');
 }
+function runtimeEventsDir(cwd, mode = 'read') {
+    return path.join(resolveEntityDir('runtime', cwd ?? process.cwd(), mode), 'agent-runtime');
+}
+function ensureRuntimeEventsDir(cwd) {
+    const dir = runtimeEventsDir(cwd, 'write');
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
 function collectJsonFiles(dir) {
     const files = [];
     if (!fs.existsSync(dir))
@@ -50,7 +61,100 @@ export function listRuntimeEvents(cwd) {
     }
     return events.sort((a, b) => a.created_at.localeCompare(b.created_at));
 }
+export function queryRuntimeEvents(filter = {}, cwd) {
+    let events = listRuntimeEvents(cwd);
+    if (filter.id) {
+        events = events.filter((event) => event.id === filter.id);
+    }
+    if (filter.agent) {
+        events = events.filter((event) => event.agent === filter.agent);
+    }
+    if (filter.session_id) {
+        events = events.filter((event) => resolveEventSessionId(event) === filter.session_id);
+    }
+    if (filter.event_type) {
+        events = events.filter((event) => event.event_type === filter.event_type);
+    }
+    if (filter.assignment_id) {
+        events = events.filter((event) => event.assignment_id === filter.assignment_id);
+    }
+    if (filter.run_id) {
+        events = events.filter((event) => event.run_id === filter.run_id);
+    }
+    if (filter.claim_id) {
+        events = events.filter((event) => event.claim_id === filter.claim_id);
+    }
+    if (filter.plan_id) {
+        events = events.filter((event) => event.plan_id === filter.plan_id);
+    }
+    if (filter.sequence_id) {
+        events = events.filter((event) => event.sequence_id === filter.sequence_id);
+    }
+    if (filter.reflectableOnly) {
+        events = events.filter((event) => isReflectableRuntimeEvent(event));
+    }
+    return events;
+}
 export function listRuntimeEventsBySession(session, cwd) {
-    return listRuntimeEvents(cwd).filter((event) => resolveEventSessionId(event) === session);
+    return queryRuntimeEvents({ session_id: session }, cwd);
+}
+export function saveRuntimeEvent(event, cwd) {
+    const parsed = RuntimeEventSchema.parse(event);
+    mutate({ cwd }, () => {
+        ensureRuntimeEventsDir(cwd);
+        const filepath = path.join(runtimeEventsDir(cwd, 'write'), `${parsed.id}.json`);
+        writeFileAtomic(filepath, JSON.stringify(parsed, null, 2) + '\n');
+    });
+    return parsed;
+}
+export function createRuntimeEvent(options, cwd) {
+    const event = RuntimeEventSchema.parse({
+        id: options.id ?? generateId('runtime_events'),
+        agent: options.agent,
+        agent_id: options.agent_id,
+        project_id: options.project_id,
+        host_id: options.host_id,
+        session_id: options.session_id,
+        event_type: options.event_type,
+        created_at: options.created_at ?? nowISO(),
+        text: options.text,
+        tags: options.tags ?? [],
+        assignment_id: options.assignment_id,
+        run_id: options.run_id,
+        claim_id: options.claim_id,
+        message_id: options.message_id,
+        plan_id: options.plan_id,
+        sequence_id: options.sequence_id,
+        correlation_id: options.correlation_id,
+        scope: options.scope,
+        transport: options.transport,
+        status: options.status,
+        status_reason: options.status_reason,
+        candidate_type: options.candidate_type,
+        severity: options.severity,
+        from: options.from,
+        to: options.to,
+        related_paths: options.related_paths,
+        metadata: options.metadata,
+        model: options.model,
+    });
+    return saveRuntimeEvent(event, cwd);
+}
+const REFLECTABLE_RUNTIME_EVENT_TYPES = new Set([
+    'task_started',
+    'observation',
+    'risk_detected',
+    'handoff_requested',
+    'task_finished',
+    'session_start',
+    'session_end',
+]);
+export function isReflectableRuntimeEvent(event) {
+    if (event.candidate_type)
+        return true;
+    return REFLECTABLE_RUNTIME_EVENT_TYPES.has(event.event_type);
+}
+export function isTaskLifecycleRuntimeEvent(event) {
+    return event.event_type === 'task_started' || event.event_type === 'task_finished';
 }
 //# sourceMappingURL=events.js.map

package/dist/core/execution-adapters.js

@@ -0,0 +1,154 @@
+import { spawn, execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { buildClaimEnvPrefix } from './execution-profile.js';
+import { getCapabilityProfile } from './agent-capability.js';
+import { nowISO } from './ids.js';
+/**
+ * Check if a binary is resolvable on the system PATH.
+ * On Windows, `spawn({shell:true})` always succeeds (launches cmd.exe),
+ * masking ENOENT for missing binaries. This pre-check catches that.
+ */
+function resolveBinaryOnPath(binary) {
+    // Absolute or relative path — check directly
+    if (binary.includes('/') || binary.includes('\\')) {
+        return fs.existsSync(binary) ? binary : undefined;
+    }
+    try {
+        if (process.platform === 'win32') {
+            const output = execFileSync('where', [binary], { encoding: 'utf-8', timeout: 5000 });
+            const matches = output
+                .split(/\r?\n/)
+                .map((line) => line.trim())
+                .filter(Boolean);
+            if (matches.length === 0)
+                return undefined;
+            return (matches.find((candidate) => /\.(exe|com)$/i.test(candidate)) ??
+                matches.find((candidate) => /\.(cmd|bat)$/i.test(candidate)) ??
+                matches[0]);
+        }
+        else {
+            const output = execFileSync('which', [binary], { encoding: 'utf-8', timeout: 5000 }).trim();
+            return output || undefined;
+        }
+    }
+    catch {
+        return undefined;
+    }
+}
+function buildManualEnvPrefix(claimId) {
+    // pln#496 step stp_a9afe59d: the cross-platform / cross-shell logic
+    // now lives in execution-profile.ts:buildClaimEnvPrefix. Keep this
+    // wrapper for symmetry with the dispatcher's buildEnvPrefix.
+    return buildClaimEnvPrefix(claimId);
+}
+export class CliExecutionAdapter {
+    id = 'cli';
+    canSpawn(agentName) {
+        const profile = getCapabilityProfile(agentName);
+        if (!profile) {
+            return { canSpawn: false, reason: `unknown agent profile: ${agentName}` };
+        }
+        if (!profile.runtime.canBeSpawnedCli) {
+            return { canSpawn: false, reason: `agent ${agentName} is not CLI-spawnable` };
+        }
+        if (!profile.invoke_template || !profile.invoke_binary) {
+            return { canSpawn: false, reason: `agent ${agentName} has no invoke template` };
+        }
+        if (process.env.BRAINCLAW_NO_SPAWN === '1') {
+            return { canSpawn: false, reason: 'BRAINCLAW_NO_SPAWN is set' };
+        }
+        return { canSpawn: true, reason: 'agent has spawnable profile' };
+    }
+    prepareManualCommand(invoke, options) {
+        const envPrefix = buildManualEnvPrefix(options.claimId);
+        return {
+            command: `${envPrefix}${invoke.bashCommand}`,
+            shell: process.platform === 'win32' ? 'cmd' : (invoke.shell ? 'bash' : 'sh'),
+        };
+    }
+    start(invoke, options) {
+        const isWin32 = process.platform === 'win32';
+        const env = {
+            ...process.env,
+            ...(invoke.env ?? {}),
+            ...(options.claimId ? { BRAINCLAW_CLAIM_ID: options.claimId } : {}),
+        };
+        if (invoke.promptDelivery === 'temp_file' && invoke.tempFilePath && invoke.promptText) {
+            const dir = path.dirname(invoke.tempFilePath);
+            if (!fs.existsSync(dir))
+                fs.mkdirSync(dir, { recursive: true });
+            fs.writeFileSync(invoke.tempFilePath, invoke.promptText, 'utf-8');
+        }
+        // Pre-check: on Windows shell:true masks ENOENT (cmd.exe spawns OK, exits 1 silently)
+        const resolvedExecutable = isWin32
+            ? resolveBinaryOnPath(invoke.executable)
+            : invoke.executable;
+        if (isWin32 && !resolvedExecutable) {
+            throw new Error(`Cannot spawn agent ${options.agent}: binary '${invoke.executable}' not found on PATH`);
+        }
+        const spawnExecutable = resolvedExecutable ?? invoke.executable;
+        const useShell = isWin32 && /\.(cmd|bat)$/i.test(spawnExecutable);
+        const needsStdin = invoke.promptDelivery === 'stdin_pipe' && invoke.promptText;
+        const stdio = needsStdin ? ['pipe', 'ignore', 'ignore'] : 'ignore';
+        // pln#476: wrap the spawn command with a brief-ack step so the worker
+        // shell touches a sentinel file BEFORE the agent binary runs.
+        // waitForAssignmentHandshake checks that file as evidence the spawn
+        // executed — needed for codex (which lacks the brainclaw MCP context
+        // to call bclaw_assignment_update). When ackRoot/assignmentId are
+        // omitted, we keep the original direct-binary spawn.
+        const useAckWrap = !!(options.assignmentId && (options.ackRoot ?? options.worktreePath));
+        let child;
+        if (useAckWrap) {
+            const ackRoot = options.ackRoot ?? options.worktreePath;
+            const ackDir = path.join(ackRoot, '.brainclaw', 'coordination', 'runtime', 'ack');
+            const ackPath = path.join(ackDir, `${options.assignmentId}.ack`);
+            fs.mkdirSync(ackDir, { recursive: true });
+            const ackStep = isWin32
+                ? `type nul > "${ackPath}"`
+                : `touch "${ackPath}"`;
+            const wrappedCmd = `${ackStep} && ${invoke.bashCommand}`;
+            child = spawn(wrappedCmd, [], {
+                detached: !isWin32,
+                shell: true,
+                stdio,
+                cwd: options.worktreePath,
+                env,
+                windowsHide: true,
+            });
+        }
+        else {
+            child = spawn(spawnExecutable, invoke.args, {
+                // Windows: detached is unreliable with shell:true — child stays in parent's process group.
+                // POSIX: detached lets the child survive parent exit.
+                detached: !isWin32,
+                shell: useShell,
+                stdio,
+                cwd: options.worktreePath,
+                env,
+                windowsHide: true,
+            });
+        }
+        // Swallowed to prevent unhandled 'error' event crash.
+        // On POSIX ENOENT: pid is undefined → the throw below handles it.
+        // On Windows shell:true: this never fires for ENOENT (cmd.exe succeeds);
+        // the isBinaryOnPath pre-check above catches that case instead.
+        child.on('error', () => { });
+        if (needsStdin && child.stdin) {
+            child.stdin.write(invoke.promptText);
+            child.stdin.end();
+        }
+        child.unref();
+        const pid = child.pid;
+        if (!pid) {
+            throw new Error(`Failed to spawn agent ${options.agent}: no PID returned`);
+        }
+        return {
+            pid,
+            started_at: nowISO(),
+            status: 'started',
+        };
+    }
+}
+export const defaultExecutionAdapter = new CliExecutionAdapter();
+//# sourceMappingURL=execution-adapters.js.map