brainclaw 1.5.4 → 1.6.0

package/dist/core/loops/bootstrap-acquire.js

@@ -0,0 +1,195 @@
+/**
+ * pln#518 step 1 — bootstrap-loop singleton acquire path.
+ *
+ * Extracts the find-existing + coordination-lock + openLoop sequence from the
+ * bclaw_coordinate ideate handler so that both the CLI (`brainclaw
+ * bootstrap-loop`) and the MCP facade share the same code path. Previously
+ * the CLI used a bare `listLoops` scan without acquiring any lock, allowing
+ * two concurrent CLI invocations to both pass the scan and call `openLoop`
+ * directly — bypassing the singleton acquire and producing duplicate loops.
+ *
+ * Algorithm (lock is opportunistic, not blocking):
+ *   1. Find an existing bootstrap loop in {open, paused} → join it.
+ *   2. Atomically acquire the coordination-lock claim. If another caller won,
+ *      re-find once; join if now visible, else throw
+ *      `BootstrapCoordinationInProgressError`.
+ *   3. Call `openLoop`, release the lock (success or fail).
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { acquireClaimScope, listClaims, releaseClaim } from '../claims.js';
+import { BOOTSTRAP_PRESET } from './presets/bootstrap.js';
+import { listLoops, openLoop } from './store.js';
+export class BootstrapCoordinationInProgressError extends Error {
+    blockingClaimId;
+    constructor(blockingClaimId) {
+        super(`another coordinator is currently opening a bootstrap loop (claim ${blockingClaimId}); retry shortly.`);
+        this.name = 'BootstrapCoordinationInProgressError';
+        this.blockingClaimId = blockingClaimId;
+    }
+}
+// ---- internal helpers -------------------------------------------------------
+/**
+ * Resolve symlinks + relative segments and normalize casing on
+ * case-insensitive filesystems (Windows) so that two callers
+ * reaching the same directory via different path representations
+ * always produce the same lock scope key.
+ */
+export function normalizeLockKey(cwd) {
+    let normalized;
+    try {
+        normalized = fs.realpathSync(cwd);
+    }
+    catch {
+        // Path may not exist (yet) — fall back to path.resolve which still
+        // strips relative segments + normalizes separators.
+        normalized = path.resolve(cwd);
+    }
+    // Windows: case-insensitive filesystem, normalize to lower case.
+    if (process.platform === 'win32') {
+        normalized = normalized.toLowerCase();
+    }
+    return normalized;
+}
+/** Returns the first active/paused bootstrap loop, or undefined. */
+export function findExistingBootstrapLoop(cwd) {
+    const all = listLoops({ kind: 'ideation' }, cwd);
+    return all.find((l) => l.protocol?.preset === 'bootstrap' && (l.status === 'open' || l.status === 'paused'));
+}
+/**
+ * pln#518 step 4 — orphan-lock TTL sweep.
+ *
+ * A process crash between `saveClaim(lock)` and the release branches in
+ * `acquireBootstrapLoop` leaves the opportunistic coordination lock active
+ * forever. Subsequent bootstrap callers would surface
+ * `BootstrapCoordinationInProgressError` to the operator until manual
+ * cleanup. This sweep releases any active lock that:
+ *   - matches the bootstrap-coordination-lock scope key for `cwd`, AND
+ *   - is older than `ttlMs` (default 5 minutes), AND
+ *   - has NO backing bootstrap loop materialized (releasing while a loop
+ *     IS being opened would mask a real-time race; we only sweep true
+ *     orphans).
+ *
+ * Best-effort: never throws. Returns the count of locks released so callers
+ * can surface the action in warnings if useful.
+ */
+const DEFAULT_LOCK_TTL_MS = 5 * 60 * 1000; // 5 minutes
+export function sweepOrphanBootstrapLocks(cwd, opts = {}) {
+    const ttlMs = opts.ttlMs ?? DEFAULT_LOCK_TTL_MS;
+    const now = opts.now ?? new Date();
+    const lockScope = `bootstrap-coordination-lock:${normalizeLockKey(cwd ?? process.cwd())}`;
+    // If a backing loop already exists, do NOT sweep — a concurrent acquire
+    // might be mid-flight and the lock is legitimate. The findExisting check
+    // in acquireBootstrapLoop will catch the loop before we even reach the
+    // lock check, so sweeping here would only catch stuck-mid-open cases.
+    const backingLoop = findExistingBootstrapLoop(cwd);
+    if (backingLoop)
+        return { released: 0 };
+    let released = 0;
+    try {
+        const claims = listClaims(cwd);
+        for (const claim of claims) {
+            if (claim.status !== 'active' || claim.scope !== lockScope)
+                continue;
+            const createdAt = new Date(claim.created_at).getTime();
+            if (Number.isNaN(createdAt))
+                continue;
+            const ageMs = now.getTime() - createdAt;
+            if (ageMs <= ttlMs)
+                continue;
+            try {
+                releaseClaim(claim.id, cwd);
+                released += 1;
+            }
+            catch {
+                /* best-effort */
+            }
+        }
+    }
+    catch {
+        /* best-effort: never throw on sweep failure */
+    }
+    return { released };
+}
+// ---- main export ------------------------------------------------------------
+/**
+ * Singleton acquire path for the bootstrap loop.
+ *
+ * Callers must NOT call `openLoop` themselves for bootstrap — this function
+ * is the sole entry point. Both the CLI and the MCP bclaw_coordinate ideate
+ * handler delegate here.
+ *
+ * Throws `BootstrapCoordinationInProgressError` when a coordination lock is
+ * held by a concurrent caller and no loop has materialised yet; callers
+ * should surface this to the operator with a "retry shortly" message.
+ *
+ * All other errors (e.g. from `openLoop`) propagate as-is.
+ */
+export function acquireBootstrapLoop(opts, cwd) {
+    const warnings = [];
+    // Step 1 — find an already-open loop.
+    const existing = findExistingBootstrapLoop(cwd);
+    if (existing) {
+        warnings.push(`bootstrap loop already open on this project (${existing.id}, phase=${existing.current_phase}, status=${existing.status}); joined existing instead of opening a duplicate.`);
+        return { action: 'joined', loop: existing, warnings };
+    }
+    // Step 1b — sweep any stale orphan coordination locks before the acquire
+    // (pln#518 step 4). Without this, a crash between saveClaim(lock) and the
+    // release branches would block all future bootstrap callers indefinitely.
+    const sweep = sweepOrphanBootstrapLocks(cwd);
+    if (sweep.released > 0) {
+        warnings.push(`released ${sweep.released} orphan bootstrap coordination lock(s) older than the TTL with no backing loop.`);
+    }
+    // Step 2 — atomically acquire the coordination-lock claim with a
+    // normalized scope key (pln#518 step 2 — symlinks / Windows casing
+    // / relative-segment representations all map to the same key).
+    const lockScope = `bootstrap-coordination-lock:${normalizeLockKey(cwd ?? process.cwd())}`;
+    const acquireResult = acquireClaimScope({
+        scope: lockScope,
+        agent: opts.actor,
+        agent_id: opts.agent_id,
+        description: `bootstrap coordination lock (open by ${opts.actor})`,
+        user: process.env.USER || process.env.USERNAME || undefined,
+        session_id: opts.session_id,
+        model: opts.model,
+    }, cwd);
+    if (!acquireResult.acquired) {
+        // Lost race — re-check once: the holder may have just finished opening the loop.
+        const reFound = findExistingBootstrapLoop(cwd);
+        if (reFound) {
+            warnings.push(`bootstrap loop opened by a parallel coordinator (${reFound.id}); joined existing.`);
+            return { action: 'joined', loop: reFound, warnings };
+        }
+        throw new BootstrapCoordinationInProgressError(acquireResult.conflicting_claim.id);
+    }
+    // Step 3 — open the loop, release the lock.
+    const lockClaimId = acquireResult.claim.id;
+    try {
+        const loop = openLoop({
+            kind: 'ideation',
+            title: opts.title ?? 'Bootstrap PROJECT.md',
+            goal: opts.goal,
+            created_by: opts.created_by ?? opts.agent_id ?? opts.actor,
+            slots: [
+                {
+                    role: 'champion',
+                    agent: opts.actor,
+                    ...(opts.agent_id ? { agent_id: opts.agent_id } : {}),
+                },
+            ],
+            phases: BOOTSTRAP_PRESET.phases,
+            stop_condition: BOOTSTRAP_PRESET.stop_condition,
+            protocol: BOOTSTRAP_PRESET.protocol,
+        }, cwd);
+        return { action: 'opened', loop, warnings };
+    }
+    finally {
+        try {
+            releaseClaim(lockClaimId, cwd);
+        }
+        catch {
+            /* best-effort */
+        }
+    }
+}
+//# sourceMappingURL=bootstrap-acquire.js.map

package/dist/core/loops/facade-schema.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { LOOP_KINDS, LOOP_STATUSES, LoopLinksSchema, LoopPhaseSchema, LoopRefSchema, LoopSlotSchema, REVIEW_MODES, StopConditionSchema, } from './types.js';
+import { LOOP_KINDS, LOOP_STATUSES, LoopLinksSchema, LoopPhaseSchema, LoopRefSchema, LoopSlotSchema, ON_TIMEOUT_POLICIES, OperatorQuestionOptionSchema, PAUSE_SCOPES, RESOLVED_VIA, REVIEW_MODES, StopConditionSchema, } from './types.js';
 /**
  * `bclaw_loop(intent)` request schemas — one per intent, unioned into a
  * discriminated schema. Mirrors the BclawLoopInput type from the v8 RFC.
@@ -7,6 +7,7 @@ import { LOOP_KINDS, LOOP_STATUSES, LoopLinksSchema, LoopPhaseSchema, LoopRefSch
 const CallerEnvelopeFields = {
     agent: z.string().optional(),
     agentId: z.string().optional(),
+    project: z.string().optional(),
     client_request_id: z.string().min(1).optional(),
 };
 /**
@@ -73,6 +74,8 @@ export const BclawLoopCompleteTurnSchema = z.object({
         type: z.string().min(1),
         body: z.string().optional(),
         ref: LoopRefSchema.optional(),
+        /** pln#492 synthesis audit trail. Required when type === 'plan_draft'. */
+        addresses_critique: z.array(z.string().min(1)).optional(),
     })
         .optional(),
     expected_version: z.number().int().nonnegative().optional(),
@@ -96,6 +99,8 @@ export const BclawLoopAddArtifactSchema = z.object({
         body: z.string().optional(),
         produced_by: z.string().optional(),
         ref: LoopRefSchema.optional(),
+        /** pln#492 synthesis audit trail. Required when type === 'plan_draft'. */
+        addresses_critique: z.array(z.string().min(1)).optional(),
     }),
     expected_version: z.number().int().nonnegative().optional(),
     ...CallerEnvelopeFields,
@@ -121,6 +126,64 @@ export const BclawLoopCloseSchema = z.object({
     expected_version: z.number().int().nonnegative().optional(),
     ...CallerEnvelopeFields,
 });
+/**
+ * pln#508 step 2 — `bclaw_loop(intent='request_input')`.
+ *
+ * A slot pauses on an operator question. The handler generates a fresh
+ * `question_id`, JSON-encodes the OperatorQuestionBody, attaches it as an
+ * `operator_question` artifact, appends the id to `LoopThread.open_questions`,
+ * and transitions either the slot (`pause_scope='slot'` → status=waiting_input)
+ * or the whole loop (`pause_scope='loop'` → status=paused, pause_reason='awaiting_operator').
+ *
+ * Refused when the loop is not in status='open' (no compounding pauses) and
+ * when `loop.protocol.max_operator_questions` is already reached (anti
+ * autonomy-gap cap, e.g. the bootstrap preset sets max=3).
+ */
+export const BclawLoopRequestInputSchema = z.object({
+    intent: z.literal('request_input'),
+    loop_id: z.string().regex(/^lop_[0-9a-z]+$/),
+    slot_id: z.string().min(1),
+    phase: z.string().min(1),
+    question_text: z.string().min(1).max(500),
+    evidence: z.array(z.string().min(1)).min(1),
+    suggested_default: z.string().optional(),
+    options: z.array(OperatorQuestionOptionSchema).min(2).max(4).optional(),
+    pause_scope: z.enum(PAUSE_SCOPES),
+    on_timeout: z.enum(ON_TIMEOUT_POLICIES),
+    timeout_at: z.string().datetime().optional(),
+    expected_version: z.number().int().nonnegative().optional(),
+    ...CallerEnvelopeFields,
+});
+/**
+ * pln#508 step 2 — `bclaw_loop(intent='provide_input')`.
+ *
+ * Resolves an open operator_question. Idempotency: if `replies_to` is no
+ * longer in `loop.open_questions` but an existing operator_answer artifact
+ * references it, the existing answer is returned (no new artifact created).
+ * Unknown `replies_to` → `unknown_question` error.
+ *
+ * Resume logic:
+ * - If the source question had `pause_scope='slot'`, the asking slot
+ *   (`by_slot_id`) transitions from `waiting_input` back to `working`.
+ * - If `pause_scope='loop'` AND `open_questions` becomes empty AND the
+ *   loop is paused on `awaiting_operator`, the loop resumes to status='open'.
+ */
+export const BclawLoopProvideInputSchema = z.object({
+    intent: z.literal('provide_input'),
+    loop_id: z.string().regex(/^lop_[0-9a-z]+$/),
+    replies_to: z.string().regex(/^qst_[0-9a-z]+$/),
+    resolved_via: z.enum(RESOLVED_VIA),
+    answer_text: z.string().optional(),
+    chosen_option_id: z.string().optional(),
+    /**
+     * Defaults to 'operator'. The timeout machinery (pln#508 step 3) calls
+     * the underlying verb with `by='system'` to create synthetic answers,
+     * but external callers should leave this absent.
+     */
+    by: z.enum(['operator', 'system']).optional(),
+    expected_version: z.number().int().nonnegative().optional(),
+    ...CallerEnvelopeFields,
+});
 export const BclawLoopRequestSchema = z.discriminatedUnion('intent', [
     BclawLoopOpenSchema,
     BclawLoopGetSchema,
@@ -132,6 +195,8 @@ export const BclawLoopRequestSchema = z.discriminatedUnion('intent', [
     BclawLoopPauseSchema,
     BclawLoopResumeSchema,
     BclawLoopCloseSchema,
+    BclawLoopRequestInputSchema,
+    BclawLoopProvideInputSchema,
 ]);
 export const BCLAW_LOOP_INTENTS = [
     'open',
@@ -144,5 +209,7 @@ export const BCLAW_LOOP_INTENTS = [
     'pause',
     'resume',
     'close',
+    'request_input',
+    'provide_input',
 ];
 //# sourceMappingURL=facade-schema.js.map

package/dist/core/loops/hooks/bootstrap-write.js

@@ -0,0 +1,144 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { memoryDir, writeFileAtomic } from '../../io.js';
+import { nowISO } from '../../ids.js';
+import { LoopArtifactSchema, RefBasedArtifactBodySchema, } from '../types.js';
+/**
+ * Directory where ref-based artifact payloads for a given loop live on disk.
+ * No central helper exists yet, so this is the canonical place to compute it.
+ * Layout mirrors the thread/event storage convention in store.ts:
+ *
+ *   <memoryDir>/loops/threads/<loop_id>/artifacts/<ref>
+ */
+function loopArtifactsDir(loopId, cwd) {
+    return path.join(memoryDir(cwd ?? process.cwd()), 'loops', 'threads', loopId, 'artifacts');
+}
+/**
+ * Returns the most recently produced `project_md_final` artifact on the loop,
+ * or `undefined` if none has been added yet. Artifacts on `loop.artifacts` are
+ * appended in production order, so the last match is "latest".
+ */
+function findLatestFinal(loop) {
+    for (let i = loop.artifacts.length - 1; i >= 0; i--) {
+        const a = loop.artifacts[i];
+        if (a.type === 'project_md_final')
+            return a;
+    }
+    return undefined;
+}
+/**
+ * Parse the ref-based body off a known-typed loop artifact. The
+ * LoopArtifactSchema validator already enforces the JSON shape, so any failure
+ * here points at a corrupt thread file rather than schema drift.
+ */
+function parseRefBody(artifact) {
+    if (!artifact.body) {
+        throw new Error(`writeProjectMdSafe: artifact ${artifact.artifact_id} (type=${artifact.type}) has no body — expected ref-based payload`);
+    }
+    return RefBasedArtifactBodySchema.parse(JSON.parse(artifact.body));
+}
+/**
+ * Hand-rolled unified-diff renderer.
+ *
+ * Phase 0 spec §file_overwrite_approval explicitly accepts a coarse diff for
+ * v1 — the operator reads it; nothing automated patches with it. So we render
+ * every old line as `-` and every new line as `+` under a single `@@` hunk
+ * header. Output is stable and deterministic.
+ */
+function generateUnifiedDiff(oldContent, newContent, oldLabel, newLabel) {
+    const oldLines = oldContent.length === 0 ? [] : oldContent.split(/\r?\n/);
+    const newLines = newContent.length === 0 ? [] : newContent.split(/\r?\n/);
+    const oldCount = oldLines.length;
+    const newCount = newLines.length;
+    const oldStart = oldCount === 0 ? 0 : 1;
+    const newStart = newCount === 0 ? 0 : 1;
+    const lines = [];
+    lines.push(`--- ${oldLabel}`);
+    lines.push(`+++ ${newLabel}`);
+    lines.push(`@@ -${oldStart},${oldCount} +${newStart},${newCount} @@`);
+    for (const l of oldLines)
+        lines.push(`-${l}`);
+    for (const l of newLines)
+        lines.push(`+${l}`);
+    return lines.join('\n');
+}
+function sha256Hex(content) {
+    return crypto.createHash('sha256').update(content, 'utf8').digest('hex');
+}
+/**
+ * pln#512 step 1 — IMPL.
+ *
+ * @see WriteProjectMdResult
+ * @see WriteProjectMdOptions
+ */
+export function writeProjectMdSafe(loop, cwd, opts) {
+    const resolvedCwd = cwd ?? process.cwd();
+    const target_path = path.join(resolvedCwd, 'PROJECT.md');
+    const finalArtifact = findLatestFinal(loop);
+    if (!finalArtifact) {
+        return {
+            needs_approval: false,
+            target_path,
+            written: false,
+            reason: 'no_final_artifact',
+        };
+    }
+    const body = parseRefBody(finalArtifact);
+    const sourcePath = path.join(loopArtifactsDir(loop.id, resolvedCwd), body.ref);
+    const sourceContent = fs.readFileSync(sourcePath, 'utf8');
+    const exists = fs.existsSync(target_path);
+    const isEmpty = exists && fs.statSync(target_path).size === 0;
+    if (!exists || isEmpty) {
+        writeFileAtomic(target_path, sourceContent);
+        return {
+            needs_approval: false,
+            target_path,
+            written: true,
+            reason: exists ? 'empty' : 'absent',
+        };
+    }
+    // pln#512 step 2 — approval short-circuit. When the operator has already
+    // signed off on the overwrite (via a resolved file_overwrite_approval
+    // question), the caller passes opts.approved=true and we write atomically
+    // without re-generating a diff artifact. Mirrors the absent/empty branch
+    // semantics so callers see a unified shape.
+    if (opts?.approved === true) {
+        writeFileAtomic(target_path, sourceContent);
+        return {
+            needs_approval: false,
+            target_path,
+            written: true,
+            reason: 'present_non_empty',
+        };
+    }
+    // Present + non-empty → build a file_diff artifact for operator approval.
+    // We do NOT touch the loop thread or the target file; the caller (step 2)
+    // splices the artifact onto the thread under request_input.
+    const existingContent = fs.readFileSync(target_path, 'utf8');
+    const diff = generateUnifiedDiff(existingContent, sourceContent, 'PROJECT.md', 'PROJECT.md (proposed)');
+    const artifactId = `art_${crypto.randomBytes(6).toString('hex')}`;
+    const patchRef = `${artifactId}.patch`;
+    const patchPath = path.join(loopArtifactsDir(loop.id, resolvedCwd), patchRef);
+    fs.mkdirSync(path.dirname(patchPath), { recursive: true });
+    writeFileAtomic(patchPath, diff);
+    const refBody = {
+        ref: patchRef,
+        byte_count: Buffer.byteLength(diff, 'utf8'),
+        sha256: sha256Hex(diff),
+    };
+    const diff_artifact = LoopArtifactSchema.parse({
+        artifact_id: artifactId,
+        phase: finalArtifact.phase,
+        type: 'file_diff',
+        body: JSON.stringify(refBody),
+        produced_at: nowISO(),
+    });
+    return {
+        needs_approval: true,
+        target_path,
+        diff_artifact,
+        reason: 'present_non_empty',
+    };
+}
+//# sourceMappingURL=bootstrap-write.js.map

package/dist/core/loops/hooks/notify-operator.js

@@ -0,0 +1,148 @@
+import child_process from 'node:child_process';
+/**
+ * pln#513 step 4 — OS notifications hook on input_requested events.
+ *
+ * Best-effort, fire-and-forget OS-native heads-up so the operator notices
+ * when a bootstrap loop pauses on an operator_question. Gated by
+ * `BRAINCLAW_OPERATOR_NOTIFICATIONS=1` (opt-in) and scoped to bootstrap-preset
+ * loops in v1. Every code path is wrapped so a missing notifier binary,
+ * unparseable artifact body, or spawn error never propagates to the caller —
+ * the journal write must remain the source of truth.
+ */
+const TITLE = 'brainclaw';
+const QUESTION_TEXT_CAP = 80;
+function isEnabled() {
+    return process.env.BRAINCLAW_OPERATOR_NOTIFICATIONS === '1';
+}
+function isBootstrapLoop(loop) {
+    return loop.protocol?.preset === 'bootstrap';
+}
+/**
+ * Resolve the matching operator_question artifact body for the event's
+ * question_id and return its question_text, truncated. Returns undefined
+ * whenever the artifact can't be located or its body fails to parse —
+ * the notification body still works without it.
+ */
+function resolveQuestionText(event, loop) {
+    if (event.kind !== 'input_requested')
+        return undefined;
+    for (const artifact of loop.artifacts) {
+        if (artifact.type !== 'operator_question' || artifact.body === undefined)
+            continue;
+        try {
+            const body = JSON.parse(artifact.body);
+            if (body.question_id === event.question_id) {
+                const text = body.question_text;
+                if (typeof text !== 'string' || text.length === 0)
+                    return undefined;
+                return text.length > QUESTION_TEXT_CAP
+                    ? `${text.slice(0, QUESTION_TEXT_CAP)}…`
+                    : text;
+            }
+        }
+        catch {
+            // ignore unparseable bodies; fall through to the next artifact
+        }
+    }
+    return undefined;
+}
+/**
+ * Sanitize the message before passing it to a shell-bridge command
+ * (osascript, powershell). We allow only printable ASCII apart from
+ * double-quotes / backticks / backslashes / control chars to avoid quoting
+ * pitfalls on every platform. The fallback `notify-send` on Linux runs
+ * via an arg vector so its sanitization is just length-capping.
+ */
+function sanitizeForShell(message) {
+    return message
+        .replace(/["`\\$]/g, '')
+        .replace(/[\r\n\t]/g, ' ')
+        .replace(/[\x00-\x1f\x7f]/g, '');
+}
+function composeMessage(event, loop) {
+    const base = `brainclaw bootstrap: question awaiting input on loop ${loop.id}`;
+    const text = resolveQuestionText(event, loop);
+    return text ? `${base} — ${text}` : base;
+}
+function spawnDetached(command, args) {
+    const child = child_process.spawn(command, args, {
+        detached: true,
+        stdio: 'ignore',
+        windowsHide: true,
+    });
+    child.on('error', () => {
+        // missing binary or exec failure — best-effort, swallow.
+    });
+    child.unref();
+}
+function notifyLinux(message) {
+    spawnDetached('notify-send', [TITLE, message]);
+}
+function notifyMac(message) {
+    const safe = sanitizeForShell(message);
+    spawnDetached('osascript', [
+        '-e',
+        `display notification "${safe}" with title "${TITLE}"`,
+    ]);
+}
+function notifyWindows(message) {
+    const safe = sanitizeForShell(message);
+    // Try BurntToast if available; fall back to a terminal bell on stderr if
+    // PowerShell itself cannot be invoked. Both paths are best-effort — we
+    // never observe the exit code.
+    const psCommand = `if (Get-Module -ListAvailable -Name BurntToast) { ` +
+        `Import-Module BurntToast; New-BurntToastNotification -Text "${TITLE}", "${safe}" ` +
+        `} else { [console]::Beep(800, 200) }`;
+    const child = child_process.spawn('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', psCommand], { detached: true, stdio: 'ignore', windowsHide: true });
+    child.on('error', () => {
+        try {
+            process.stderr.write('\x07');
+        }
+        catch {
+            // give up silently
+        }
+    });
+    child.unref();
+}
+/**
+ * Fire an OS-native notification on `input_requested` events for bootstrap
+ * loops. Returns immediately when:
+ *   - the event is not `input_requested`,
+ *   - the env-var opt-in is missing,
+ *   - the loop's protocol preset is not `bootstrap`,
+ *   - the host platform has no supported notifier.
+ *
+ * Never throws. The cwd parameter is accepted for parity with other hooks
+ * but currently unused — the hook decides everything from the event + loop
+ * snapshot the caller already loaded.
+ */
+export function notifyOperatorOnInputRequested(event, loop, cwd) {
+    void cwd;
+    try {
+        if (event.kind !== 'input_requested')
+            return;
+        if (!isEnabled())
+            return;
+        if (!isBootstrapLoop(loop))
+            return;
+        const message = composeMessage(event, loop);
+        switch (process.platform) {
+            case 'linux':
+                notifyLinux(message);
+                return;
+            case 'darwin':
+                notifyMac(message);
+                return;
+            case 'win32':
+                notifyWindows(message);
+                return;
+            default:
+                return;
+        }
+    }
+    catch {
+        // Hook is best-effort — swallow any unexpected error so the journal
+        // write that triggered us stays the source of truth.
+    }
+}
+//# sourceMappingURL=notify-operator.js.map