@ouro.bot/cli 0.1.0-alpha.70 → 0.1.0-alpha.701

package/dist/senses/bluebubbles/processed-log.js

@@ -0,0 +1,133 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBlueBubblesProcessedLogPath = getBlueBubblesProcessedLogPath;
+exports.hasProcessedBlueBubblesMessage = hasProcessedBlueBubblesMessage;
+exports.hasProcessedBlueBubblesMessageGuid = hasProcessedBlueBubblesMessageGuid;
+exports.recordProcessedBlueBubblesMessage = recordProcessedBlueBubblesMessage;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const config_1 = require("../../heart/config");
+const identity_1 = require("../../heart/identity");
+const runtime_1 = require("../../nerves/runtime");
+function getBlueBubblesProcessedLogPath(agentName, sessionKey) {
+    return path.join((0, identity_1.getAgentRoot)(agentName), "state", "senses", "bluebubbles", "processed", `${(0, config_1.sanitizeKey)(sessionKey)}.ndjson`);
+}
+function readEntries(filePath) {
+    try {
+        const raw = fs.readFileSync(filePath, "utf-8");
+        return raw
+            .split("\n")
+            .map((line) => line.trim())
+            .filter(Boolean)
+            .map((line) => JSON.parse(line))
+            .filter((entry) => typeof entry.messageGuid === "string" && typeof entry.sessionKey === "string");
+    }
+    catch {
+        return [];
+    }
+}
+function readAllEntries(agentName) {
+    const processedDir = path.join((0, identity_1.getAgentRoot)(agentName), "state", "senses", "bluebubbles", "processed");
+    try {
+        return fs.readdirSync(processedDir)
+            .filter((name) => name.endsWith(".ndjson"))
+            .sort()
+            .flatMap((name) => readEntries(path.join(processedDir, name)));
+    }
+    catch {
+        return [];
+    }
+}
+function isCompletedProcessedEntry(entry) {
+    return entry.outcome !== "recovery-timeout";
+}
+function hasProcessedBlueBubblesMessage(agentName, sessionKey, messageGuid) {
+    if (!messageGuid.trim())
+        return false;
+    const filePath = getBlueBubblesProcessedLogPath(agentName, sessionKey);
+    return readEntries(filePath).some((entry) => entry.messageGuid === messageGuid && isCompletedProcessedEntry(entry));
+}
+function hasProcessedBlueBubblesMessageGuid(agentName, messageGuid) {
+    if (!messageGuid.trim())
+        return false;
+    return readAllEntries(agentName).some((entry) => entry.messageGuid === messageGuid && isCompletedProcessedEntry(entry));
+}
+function recordProcessedBlueBubblesMessage(agentName, event, source, outcome) {
+    const filePath = getBlueBubblesProcessedLogPath(agentName, event.chat.sessionKey);
+    try {
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        if (event.messageGuid.trim() && readEntries(filePath).some((entry) => (entry.messageGuid === event.messageGuid
+            && isCompletedProcessedEntry(entry)))) {
+            return filePath;
+        }
+        fs.appendFileSync(filePath, JSON.stringify({
+            recordedAt: new Date().toISOString(),
+            messageGuid: event.messageGuid,
+            sessionKey: event.chat.sessionKey,
+            source,
+            outcome,
+        }) + "\n", "utf-8");
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "senses",
+            event: "senses.bluebubbles_processed_log_error",
+            message: "failed to record bluebubbles processed sidecar log",
+            meta: {
+                agentName,
+                messageGuid: event.messageGuid,
+                sessionKey: event.chat.sessionKey,
+                reason: error instanceof Error ? error.message : String(error),
+            },
+        });
+        return filePath;
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.bluebubbles_processed_logged",
+        message: "recorded handled bluebubbles message to processed sidecar log",
+        meta: {
+            agentName,
+            messageGuid: event.messageGuid,
+            sessionKey: event.chat.sessionKey,
+            source,
+            outcome,
+            path: filePath,
+        },
+    });
+    return filePath;
+}

package/dist/senses/bluebubbles/replay.js

@@ -0,0 +1,284 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replayBlueBubblesFixture = replayBlueBubblesFixture;
+exports.replayJuly9BlueBubblesContextFixture = replayJuly9BlueBubblesContextFixture;
+exports.replayBlueBubblesMessage = replayBlueBubblesMessage;
+exports.formatBlueBubblesReplayText = formatBlueBubblesReplayText;
+const fs = __importStar(require("node:fs"));
+const render_1 = require("../../heart/attachments/render");
+const bluebubbles_1 = require("../../heart/attachments/sources/bluebubbles");
+const machine_identity_1 = require("../../heart/machine-identity");
+const identity_1 = require("../../heart/identity");
+const runtime_credentials_1 = require("../../heart/runtime-credentials");
+const runtime_1 = require("../../nerves/runtime");
+const client_1 = require("./client");
+const model_1 = require("./model");
+function buildReplayHint(probeEventType, event) {
+    if (probeEventType === "updated-message"
+        && event.kind === "mutation"
+        && (event.mutationType === "read" || event.mutationType === "delivery")) {
+        return "replay resolved to a state-only mutation; rerun with --event-type new-message to inspect the original message payload.";
+    }
+    return undefined;
+}
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function requiredString(record, key) {
+    const value = record[key];
+    if (typeof value !== "string" || value.trim().length === 0)
+        throw new Error(`bluebubbles fixture missing ${key}`);
+    return value.trim();
+}
+async function replayBlueBubblesFixture(input) {
+    const fixture = input.fixture;
+    if (fixture.schemaVersion !== 1 || fixture.policyVersion !== "bluebubbles-replay/v1") {
+        throw new Error("unsupported BlueBubbles replay fixture");
+    }
+    const expected = isRecord(fixture.expected) ? fixture.expected : null;
+    const privacy = isRecord(fixture.privacy) ? fixture.privacy : null;
+    if (!expected || !privacy || privacy.rawTranscriptStored !== false || privacy.searchIndex !== false || privacy.vectorIndex !== false) {
+        throw new Error("BlueBubbles replay fixture must be minimized and private");
+    }
+    const result = {
+        sideEffect: false,
+        contextPacketHash: requiredString(expected, "contextPacketHash"),
+        modelInputHash: requiredString(expected, "modelInputHash"),
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.bluebubbles_fixture_replayed",
+        message: "replayed bluebubbles fixture offline",
+        meta: { contextPacketHash: result.contextPacketHash, modelInputHash: result.modelInputHash },
+    });
+    return result;
+}
+function readJsonManifest(filePath) {
+    const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    if (!isRecord(parsed))
+        throw new Error("replay manifest must be an object");
+    return parsed;
+}
+function manifestExpected(manifest) {
+    const expected = isRecord(manifest.expected) ? manifest.expected : null;
+    if (!expected)
+        throw new Error("July 9 replay manifest missing expected block");
+    return expected;
+}
+function july9PrivacyViolations(manifest) {
+    const privacy = isRecord(manifest.privacy) ? manifest.privacy : null;
+    if (!privacy)
+        return ["privacy"];
+    const violations = [];
+    if (privacy.rawLiveTranscriptStored !== false)
+        violations.push("rawLiveTranscriptStored");
+    if (privacy.credentialsStored !== false)
+        violations.push("credentialsStored");
+    if (privacy.searchIndex !== false)
+        violations.push("searchIndex");
+    if (privacy.vectorIndex !== false)
+        violations.push("vectorIndex");
+    return violations;
+}
+function assertJuly9ReplayPrivacy(manifest) {
+    const violations = july9PrivacyViolations(manifest);
+    if (violations.length > 0) {
+        throw new Error(`July 9 replay fixture must be repo-safe and non-indexed: ${violations.join(", ")}`);
+    }
+}
+function manifestMessages(manifest) {
+    const conversation = isRecord(manifest.conversation) ? manifest.conversation : null;
+    const messages = conversation && Array.isArray(conversation.messages) ? conversation.messages : [];
+    return messages.filter(isRecord);
+}
+function optionalString(record, key) {
+    const value = record[key];
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function messageLine(message) {
+    const timestamp = optionalString(message, "timestamp");
+    const author = optionalString(message, "authorLabel");
+    const body = optionalString(message, "body");
+    if (!timestamp || !author || !body)
+        return null;
+    return `[${timestamp}] ${author}: ${body}`;
+}
+async function replayJuly9BlueBubblesContextFixture(input) {
+    const manifest = readJsonManifest(input.manifestPath);
+    if (manifest.schemaVersion !== 1 || manifest.policyVersion !== "july-9-rsvp-regression/v1") {
+        throw new Error("unsupported July 9 replay manifest");
+    }
+    assertJuly9ReplayPrivacy(manifest);
+    const expected = manifestExpected(manifest);
+    const modelInput = manifestMessages(manifest)
+        .map(messageLine)
+        .filter((line) => !!line)
+        .join("\n\n");
+    const result = {
+        sideEffect: false,
+        contextPacketHash: requiredString(expected, "contextPacketHash"),
+        renderedModelInputHash: requiredString(expected, "renderedModelInputHash"),
+        modelInput,
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.bluebubbles_july9_fixture_replayed",
+        message: "replayed July 9 BlueBubbles context fixture",
+        meta: {
+            contextPacketHash: result.contextPacketHash,
+            renderedModelInputHash: result.renderedModelInputHash,
+            messageCount: manifestMessages(manifest).length,
+        },
+    });
+    return result;
+}
+async function replayBlueBubblesMessage(params, deps = {}) {
+    const agentName = params.agentName.trim();
+    const messageGuid = params.messageGuid.trim();
+    const eventType = params.eventType ?? "new-message";
+    if (!agentName) {
+        throw new Error("bluebubbles replay requires agentName");
+    }
+    if (!messageGuid) {
+        throw new Error("bluebubbles replay requires messageGuid");
+    }
+    const setReplayAgentName = deps.setAgentName ?? identity_1.setAgentName;
+    const resetReplayIdentity = deps.resetIdentity ?? identity_1.resetIdentity;
+    const normalizeEvent = deps.normalizeEvent ?? model_1.normalizeBlueBubblesEvent;
+    const loadMachineId = deps.loadMachineId ?? (() => (0, machine_identity_1.loadOrCreateMachineIdentity)().machineId);
+    const refreshMachineRuntimeConfig = deps.refreshMachineRuntimeConfig ?? runtime_credentials_1.refreshMachineRuntimeCredentialConfig;
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.bluebubbles_replay_start",
+        message: "starting bluebubbles historical replay",
+        meta: {
+            agentName,
+            messageGuid,
+            eventType,
+        },
+    });
+    setReplayAgentName(agentName);
+    try {
+        if (!deps.createClient) {
+            const machineId = loadMachineId();
+            await refreshMachineRuntimeConfig(agentName, machineId, { preserveCachedOnFailure: true });
+        }
+        const client = deps.createClient ? deps.createClient() : (0, client_1.createBlueBubblesClient)();
+        const probe = normalizeEvent({
+            type: eventType,
+            data: {
+                guid: messageGuid,
+                hasPayloadData: true,
+            },
+        });
+        const event = await client.repairEvent(probe);
+        const attachmentRecords = event.kind === "message"
+            ? event.attachments
+                .filter((attachment) => typeof attachment.guid === "string" && attachment.guid.trim().length > 0)
+                .map((attachment) => (0, bluebubbles_1.buildBlueBubblesAttachmentRecord)(attachment))
+            : [];
+        const result = {
+            probe: {
+                agentName,
+                messageGuid,
+                eventType,
+            },
+            event,
+            attachmentIds: attachmentRecords.map((attachment) => attachment.id),
+            attachmentBlock: (0, render_1.renderAttachmentBlock)(attachmentRecords),
+            ...(buildReplayHint(eventType, event) ? { hint: buildReplayHint(eventType, event) } : {}),
+        };
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.bluebubbles_replay_end",
+            message: "completed bluebubbles historical replay",
+            meta: {
+                agentName,
+                messageGuid,
+                eventType,
+                kind: event.kind,
+                attachmentCount: attachmentRecords.length,
+            },
+        });
+        return result;
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "senses",
+            event: "senses.bluebubbles_replay_error",
+            message: "bluebubbles historical replay failed",
+            meta: {
+                agentName,
+                messageGuid,
+                eventType,
+                reason: error instanceof Error ? error.message : String(error),
+            },
+        });
+        throw error;
+    }
+    finally {
+        resetReplayIdentity();
+    }
+}
+function formatBlueBubblesReplayText(result) {
+    const lines = [
+        `probe: ${result.probe.eventType}`,
+        `agent: ${result.probe.agentName}`,
+        `message_guid: ${result.probe.messageGuid}`,
+        `result_kind: ${result.event.kind}`,
+        `session: ${result.event.chat.sessionKey}`,
+    ];
+    if (result.event.kind === "mutation") {
+        lines.push(`mutation_type: ${result.event.mutationType}`);
+    }
+    if (result.event.kind === "message" && result.event.inputPartsForAgent?.length) {
+        lines.push(`input_parts_for_agent: ${result.event.inputPartsForAgent.length}`);
+    }
+    if (result.event.repairNotice?.trim()) {
+        lines.push(`repair_notice: ${result.event.repairNotice.trim()}`);
+    }
+    if (result.attachmentBlock && !result.event.textForAgent.includes(result.attachmentBlock)) {
+        lines.push(result.attachmentBlock);
+    }
+    lines.push("[text_for_agent]");
+    lines.push(result.event.textForAgent || "(empty)");
+    if (result.hint) {
+        lines.push("[hint]");
+        lines.push(result.hint);
+    }
+    return lines.join("\n");
+}

package/dist/senses/{bluebubbles-runtime-state.js → bluebubbles/runtime-state.js}

@@ -38,8 +38,8 @@ exports.readBlueBubblesRuntimeState = readBlueBubblesRuntimeState;
 exports.writeBlueBubblesRuntimeState = writeBlueBubblesRuntimeState;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
-const identity_1 = require("../heart/identity");
-const runtime_1 = require("../nerves/runtime");
+const identity_1 = require("../../heart/identity");
+const runtime_1 = require("../../nerves/runtime");
 const DEFAULT_RUNTIME_STATE = {
     upstreamStatus: "unknown",
     detail: "startup health probe pending",
@@ -53,6 +53,9 @@ function readBlueBubblesRuntimeState(agentName, agentRoot) {
     try {
         const raw = fs.readFileSync(filePath, "utf-8");
         const parsed = JSON.parse(raw);
+        const failedRecoveryCount = typeof parsed.failedRecoveryCount === "number" && Number.isFinite(parsed.failedRecoveryCount)
+            ? parsed.failedRecoveryCount
+            : undefined;
         return {
             upstreamStatus: parsed.upstreamStatus === "ok" || parsed.upstreamStatus === "error"
                 ? parsed.upstreamStatus
@@ -61,9 +64,31 @@ function readBlueBubblesRuntimeState(agentName, agentRoot) {
                 ? parsed.detail
                 : DEFAULT_RUNTIME_STATE.detail,
             lastCheckedAt: typeof parsed.lastCheckedAt === "string" ? parsed.lastCheckedAt : undefined,
+            proofMethod: typeof parsed.proofMethod === "string" && parsed.proofMethod.trim()
+                ? parsed.proofMethod
+                : undefined,
             pendingRecoveryCount: typeof parsed.pendingRecoveryCount === "number" && Number.isFinite(parsed.pendingRecoveryCount)
                 ? parsed.pendingRecoveryCount
                 : 0,
+            ...(typeof failedRecoveryCount === "number" ? { failedRecoveryCount } : {}),
+            oldestPendingRecoveryAt: typeof parsed.oldestPendingRecoveryAt === "string"
+                ? parsed.oldestPendingRecoveryAt
+                : undefined,
+            oldestPendingRecoveryAgeMs: typeof parsed.oldestPendingRecoveryAgeMs === "number" && Number.isFinite(parsed.oldestPendingRecoveryAgeMs)
+                ? parsed.oldestPendingRecoveryAgeMs
+                : undefined,
+            activeTurnCount: typeof parsed.activeTurnCount === "number" && Number.isFinite(parsed.activeTurnCount)
+                ? parsed.activeTurnCount
+                : undefined,
+            stalledTurnCount: typeof parsed.stalledTurnCount === "number" && Number.isFinite(parsed.stalledTurnCount)
+                ? parsed.stalledTurnCount
+                : undefined,
+            oldestActiveTurnStartedAt: typeof parsed.oldestActiveTurnStartedAt === "string"
+                ? parsed.oldestActiveTurnStartedAt
+                : undefined,
+            oldestActiveTurnAgeMs: typeof parsed.oldestActiveTurnAgeMs === "number" && Number.isFinite(parsed.oldestActiveTurnAgeMs)
+                ? parsed.oldestActiveTurnAgeMs
+                : undefined,
             lastRecoveredAt: typeof parsed.lastRecoveredAt === "string" ? parsed.lastRecoveredAt : undefined,
             lastRecoveredMessageGuid: typeof parsed.lastRecoveredMessageGuid === "string"
                 ? parsed.lastRecoveredMessageGuid
@@ -102,6 +127,9 @@ function writeBlueBubblesRuntimeState(agentName, state, agentRoot) {
             agentName,
             upstreamStatus: state.upstreamStatus,
             pendingRecoveryCount: state.pendingRecoveryCount,
+            failedRecoveryCount: state.failedRecoveryCount ?? 0,
+            activeTurnCount: state.activeTurnCount ?? 0,
+            stalledTurnCount: state.stalledTurnCount ?? 0,
             path: filePath,
         },
     });

package/dist/senses/{bluebubbles-session-cleanup.js → bluebubbles/session-cleanup.js}

@@ -36,7 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.findObsoleteBlueBubblesThreadSessions = findObsoleteBlueBubblesThreadSessions;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
-const runtime_1 = require("../nerves/runtime");
+const runtime_1 = require("../../nerves/runtime");
 function findObsoleteBlueBubblesThreadSessions(trunkSessionPath) {
     const normalized = trunkSessionPath.trim();
     if (!normalized.endsWith(".json"))

package/dist/senses/bluebubbles-meta-guard.js

@@ -0,0 +1,39 @@
+"use strict";
+// Outbound BlueBubbles meta-content guard.
+//
+// Blocks accidental delivery of internal/meta text — pipeline section markers,
+// surfacing-mechanics prefixes, reasoning tags — to the live iMessage channel.
+// Failure mode is "drop and log", never queue for later delivery.
+//
+// Patterns are deliberately narrow: bracketed system markers and angle-bracket
+// reasoning tags. Plain prose mentioning related concepts is NOT blocked, so
+// user-facing replies that legitimately discuss those concepts still pass.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.containsInternalMetaMarkers = containsInternalMetaMarkers;
+exports.emitBluebubblesMetaBlocked = emitBluebubblesMetaBlocked;
+const runtime_1 = require("../nerves/runtime");
+const META_CONTENT_PATTERNS = [
+    /\[surfaced from inner dialog\]/i,
+    /\[pending from [^\]]+\]:/i,
+    /\[conversation scope:/i,
+    /\[recent active lanes\]/i,
+    /\[routing control:/i,
+    /<\/?think>/i,
+];
+function containsInternalMetaMarkers(text) {
+    if (!text)
+        return false;
+    return META_CONTENT_PATTERNS.some((pattern) => pattern.test(text));
+}
+function emitBluebubblesMetaBlocked(options) {
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn",
+        component: "senses",
+        event: "senses.bluebubbles_meta_blocked",
+        message: options.message,
+        meta: {
+            site: options.site,
+            ...options.meta,
+        },
+    });
+}

package/dist/senses/cli/bracketed-paste.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BracketedPasteHandler = void 0;
+/**
+ * Bracketed paste mode handler for the TUI.
+ *
+ * Detects \x1b[200~ (paste start) and \x1b[201~ (paste end) markers in
+ * raw stdin data. Buffers paste content between markers and emits it as
+ * a single "paste" event. Non-paste data is emitted as "data" unchanged.
+ *
+ * Works alongside Ink's stdin handling by intercepting raw data events.
+ */
+const events_1 = require("events");
+const runtime_1 = require("../../nerves/runtime");
+const PASTE_START = "\x1b[200~";
+const PASTE_END = "\x1b[201~";
+class BracketedPasteHandler extends events_1.EventEmitter {
+    stdin;
+    stdout;
+    pasting = false;
+    buffer = "";
+    dataHandler;
+    constructor(stdin, stdout) {
+        super();
+        this.stdin = stdin;
+        this.stdout = stdout;
+        // Enable bracketed paste mode
+        stdout.write("\x1b[?2004h");
+        this.dataHandler = (chunk) => {
+            this.processChunk(chunk.toString());
+        };
+        stdin.prependListener("data", this.dataHandler);
+    }
+    processChunk(data) {
+        let remaining = data;
+        while (remaining.length > 0) {
+            if (this.pasting) {
+                // Look for end marker in buffer + remaining
+                const combined = this.buffer + remaining;
+                const endIdx = combined.indexOf(PASTE_END);
+                if (endIdx !== -1) {
+                    // Found end marker -- emit paste content
+                    const pasteContent = combined.slice(0, endIdx);
+                    (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.bracketed_paste", message: "bracketed paste received", meta: { length: pasteContent.length } });
+                    this.emit("paste", pasteContent);
+                    this.buffer = "";
+                    this.pasting = false;
+                    // Process remaining data after end marker
+                    remaining = combined.slice(endIdx + PASTE_END.length);
+                    continue;
+                }
+                // No end marker yet -- buffer everything so far
+                this.buffer = combined;
+                return;
+            }
+            // Not pasting -- look for start marker
+            const startIdx = remaining.indexOf(PASTE_START);
+            if (startIdx !== -1) {
+                // Emit any data before the start marker
+                const before = remaining.slice(0, startIdx);
+                if (before.length > 0) {
+                    this.emit("data", before);
+                }
+                // Enter paste mode
+                this.pasting = true;
+                this.buffer = "";
+                remaining = remaining.slice(startIdx + PASTE_START.length);
+                continue;
+            }
+            // No start marker -- emit as regular data
+            this.emit("data", remaining);
+            return;
+        }
+    }
+    /** Disable bracketed paste mode and remove listeners. */
+    destroy() {
+        this.stdout.write("\x1b[?2004l");
+        this.stdin.removeListener("data", this.dataHandler);
+        this.removeAllListeners();
+    }
+}
+exports.BracketedPasteHandler = BracketedPasteHandler;