@ouro.bot/cli 0.1.0-alpha.83 → 0.1.0-alpha.831

package/dist/senses/acp-server.js

@@ -0,0 +1,386 @@
+"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.createAcpServer = createAcpServer;
+const node_crypto_1 = require("node:crypto");
+const readline = __importStar(require("node:readline"));
+const frontend_socket_client_1 = require("../heart/frontend-socket-client");
+const runtime_1 = require("../nerves/runtime");
+const SESSION_ID = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/;
+class AcpProtocolError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "AcpProtocolError";
+    }
+}
+function createAcpServer(options) {
+    const sessions = new Set();
+    const activePrompts = new Map();
+    const pendingOutbound = new Map();
+    const createClient = options.createFrontendClient ?? (async () => new frontend_socket_client_1.SocketFrontendClient(options.frontendSocketPath));
+    let clientPromise = null;
+    let frontendClient = null;
+    let removeEventListener = null;
+    let removeCloseListener = null;
+    let lines = null;
+    let running = false;
+    function write(message) {
+        options.stdout.write(`${JSON.stringify(message)}\n`);
+    }
+    function result(id, value) {
+        write({ jsonrpc: "2.0", id, result: value });
+    }
+    function error(id, code, message) {
+        write({ jsonrpc: "2.0", id, error: { code, message } });
+    }
+    async function client() {
+        if (!clientPromise) {
+            clientPromise = createClient().then((value) => {
+                frontendClient = value;
+                removeEventListener = value.onEvent(handleFrontendEvent);
+                removeCloseListener = value.onClose((error) => {
+                    const failure = error ?? new Error("frontend provider disconnected");
+                    for (const prompt of activePrompts.values())
+                        prompt.reject(failure);
+                    pendingOutbound.clear();
+                });
+                return value;
+            });
+        }
+        return clientPromise;
+    }
+    async function subscribe(sessionId) {
+        await (await client()).request("session.subscribe", { sessionKey: sessionId });
+        sessions.add(sessionId);
+    }
+    function sessionUpdate(sessionId, update) {
+        write({ jsonrpc: "2.0", method: "session/update", params: { sessionId, update } });
+    }
+    function permissionRequest(sessionId, event) {
+        const requestId = typeof event.requestId === "string" ? event.requestId : "";
+        if (!requestId || [...pendingOutbound.values()].some((pending) => pending.requestId === requestId))
+            return;
+        const rpcId = `ouro:${(0, node_crypto_1.randomUUID)()}`;
+        pendingOutbound.set(rpcId, { sessionId, requestId });
+        write({
+            jsonrpc: "2.0",
+            id: rpcId,
+            method: "session/request_permission",
+            params: {
+                sessionId,
+                toolCall: {
+                    toolCallId: String(event.toolCallId ?? requestId),
+                    title: String(event.title ?? "Permission requested"),
+                },
+                options: Array.isArray(event.options) ? event.options : [],
+            },
+        });
+    }
+    function replayEvent(sessionId, event) {
+        const data = event.data ?? {};
+        if (event.type === "user_message" && typeof data.text === "string") {
+            sessionUpdate(sessionId, {
+                sessionUpdate: "user_message_chunk",
+                messageId: `${event.turnId}:user`,
+                content: { type: "text", text: data.text },
+            });
+        }
+        else if (event.type === "assistant_delivery" && typeof data.text === "string") {
+            sessionUpdate(sessionId, {
+                sessionUpdate: "agent_message_chunk",
+                messageId: `${event.turnId}:agent`,
+                content: { type: "text", text: data.text },
+            });
+        }
+        else if (event.type === "tool_started") {
+            sessionUpdate(sessionId, {
+                sessionUpdate: "tool_call",
+                toolCallId: `${event.turnId}:${String(data.name ?? "tool")}`,
+                title: String(data.name ?? "tool"),
+                status: "pending",
+                rawInput: data.args ?? {},
+            });
+        }
+        else if (event.type === "tool_completed") {
+            sessionUpdate(sessionId, {
+                sessionUpdate: "tool_call_update",
+                toolCallId: `${event.turnId}:${String(data.name ?? "tool")}`,
+                status: data.success === false ? "failed" : "completed",
+                content: [{ type: "content", content: { type: "text", text: String(data.summary ?? "") } }],
+            });
+        }
+        else if (event.type === "structured_output") {
+            const output = data.output;
+            sessionUpdate(sessionId, {
+                sessionUpdate: "plan",
+                entries: (output?.items ?? []).flatMap((item) => typeof item.text === "string" && item.text.trim()
+                    ? [{ content: item.text.trim(), status: "pending" }]
+                    : []),
+            });
+        }
+    }
+    function handleFrontendEvent(event) {
+        const sessionId = typeof event.sessionKey === "string" ? event.sessionKey : "";
+        if (!sessions.has(sessionId))
+            return;
+        const turnId = typeof event.turnId === "string" ? event.turnId : "";
+        const active = activePrompts.get(sessionId);
+        if (event.event === "text.delta" && typeof event.text === "string") {
+            sessionUpdate(sessionId, {
+                sessionUpdate: "agent_message_chunk",
+                messageId: `${turnId}:agent`,
+                content: { type: "text", text: event.text },
+            });
+        }
+        else if (event.event === "reasoning.delta" && typeof event.text === "string") {
+            sessionUpdate(sessionId, {
+                sessionUpdate: "agent_thought_chunk",
+                messageId: `${turnId}:thought`,
+                content: { type: "text", text: event.text },
+            });
+        }
+        else if (event.event === "tool.started") {
+            replayEvent(sessionId, { type: "tool_started", turnId, data: event });
+        }
+        else if (event.event === "tool.completed") {
+            replayEvent(sessionId, { type: "tool_completed", turnId, data: event });
+        }
+        else if (event.event === "structured.output") {
+            replayEvent(sessionId, { type: "structured_output", turnId, data: event });
+        }
+        else if (event.event === "permission.requested") {
+            const requestId = typeof event.requestId === "string" ? event.requestId : "";
+            if (!requestId || !active || active.turnId !== turnId)
+                return;
+            permissionRequest(sessionId, event);
+        }
+        else if (active && active.turnId === turnId && event.event === "turn.completed") {
+            active.resolve("end_turn");
+        }
+        else if (active && active.turnId === turnId && event.event === "turn.cancelled") {
+            active.resolve("cancelled");
+        }
+        else if (active && active.turnId === turnId && event.event === "turn.failed") {
+            active.reject(new Error(String(event.error ?? "frontend turn failed")));
+        }
+    }
+    function params(value) {
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            throw new AcpProtocolError(-32602, "params must be an object");
+        return value;
+    }
+    function requiredString(value, field) {
+        if (typeof value !== "string" || !value.trim())
+            throw new AcpProtocolError(-32602, `${field} must be a non-empty string`);
+        return value.trim();
+    }
+    function promptText(value) {
+        if (!Array.isArray(value))
+            throw new AcpProtocolError(-32602, "prompt must be an array");
+        const text = value
+            .flatMap((part) => part?.type === "text" && typeof part.text === "string" ? [part.text] : [])
+            .join("");
+        if (!text.trim())
+            throw new AcpProtocolError(-32602, "prompt must contain text");
+        return text;
+    }
+    async function handleResponse(response) {
+        if (response.jsonrpc !== "2.0")
+            throw new AcpProtocolError(-32600, "jsonrpc must be 2.0");
+        if (typeof response.id !== "string")
+            throw new AcpProtocolError(-32602, "response id must be a string");
+        const pending = pendingOutbound.get(response.id);
+        if (!pending)
+            throw new AcpProtocolError(-32602, `unknown response id: ${response.id}`);
+        pendingOutbound.delete(response.id);
+        const outcome = response.result?.outcome;
+        const optionId = outcome?.outcome === "selected" && typeof outcome.optionId === "string"
+            ? outcome.optionId
+            : "cancelled";
+        await (await client()).request("permission.resolve", { requestId: pending.requestId, optionId });
+    }
+    async function handle(request) {
+        if (request.jsonrpc !== "2.0")
+            throw new AcpProtocolError(-32600, "jsonrpc must be 2.0");
+        const method = requiredString(request.method, "method");
+        const requestParams = params(request.params ?? {});
+        const id = request.id;
+        if (method === "initialize") {
+            if (id === undefined)
+                return;
+            if (requestParams.protocolVersion !== 1)
+                throw new AcpProtocolError(-32602, "protocolVersion must be 1");
+            result(id, { protocolVersion: 1 });
+            return;
+        }
+        if (method === "session/new") {
+            if (id === undefined)
+                return;
+            const sessionId = requestParams.sessionId === undefined
+                ? (0, node_crypto_1.randomUUID)()
+                : requiredString(requestParams.sessionId, "sessionId");
+            if (!SESSION_ID.test(sessionId))
+                throw new AcpProtocolError(-32602, "sessionId must be a safe identifier");
+            if (sessions.has(sessionId))
+                throw new AcpProtocolError(-32002, `session already exists: ${sessionId}`);
+            await subscribe(sessionId);
+            result(id, { sessionId, friendId: options.friendId });
+            return;
+        }
+        if (method === "session/load") {
+            if (id === undefined)
+                return;
+            if (options.disableTools) {
+                throw new AcpProtocolError(-32601, "session/load is unavailable in observe-only mode");
+            }
+            const sessionId = requiredString(requestParams.sessionId, "sessionId");
+            const frontend = await client();
+            const replay = await frontend.request("session.load", {
+                agent: options.agent,
+                friendId: options.friendId,
+                sessionKey: sessionId,
+                afterSequence: 0,
+            });
+            if (!Array.isArray(replay?.events) || replay.events.length === 0) {
+                throw new AcpProtocolError(-32001, "session not found");
+            }
+            for (const event of replay.events)
+                replayEvent(sessionId, event);
+            await subscribe(sessionId);
+            for (const pending of replay.pendingPermissions ?? [])
+                permissionRequest(sessionId, pending);
+            result(id, {});
+            return;
+        }
+        if (method === "session/prompt") {
+            if (id === undefined)
+                return;
+            const sessionId = requiredString(requestParams.sessionId, "sessionId");
+            if (!sessions.has(sessionId))
+                throw new AcpProtocolError(-32001, `unknown session: ${sessionId}`);
+            if (activePrompts.has(sessionId))
+                throw new AcpProtocolError(-32002, "session already has an active prompt");
+            const message = promptText(requestParams.prompt);
+            const turnId = (0, node_crypto_1.randomUUID)();
+            const completion = Promise.withResolvers();
+            activePrompts.set(sessionId, { rpcId: id, turnId, resolve: completion.resolve, reject: completion.reject });
+            try {
+                await (await client()).request(options.disableTools ? "turn.start.observe-only" : "turn.start", {
+                    turnId,
+                    agent: options.agent,
+                    friendId: options.friendId,
+                    channel: "mcp",
+                    sessionKey: sessionId,
+                    message,
+                    ...(options.runtimeMcpServers ? { runtimeMcpServers: options.runtimeMcpServers } : {}),
+                });
+                result(id, { stopReason: await completion.promise });
+            }
+            finally {
+                activePrompts.delete(sessionId);
+            }
+            return;
+        }
+        if (method === "session/cancel") {
+            const sessionId = requiredString(requestParams.sessionId, "sessionId");
+            const active = activePrompts.get(sessionId);
+            if (active)
+                await (await client()).request("turn.cancel", { turnId: active.turnId });
+            return;
+        }
+        throw new AcpProtocolError(-32601, `method not found: ${method}`);
+    }
+    async function dispatch(line) {
+        let request;
+        try {
+            request = JSON.parse(line);
+        }
+        catch {
+            error(null, -32700, "parse error");
+            return;
+        }
+        try {
+            if (request.method === undefined && (request.result !== undefined || request.error !== undefined)) {
+                await handleResponse(request);
+            }
+            else {
+                await handle(request);
+            }
+        }
+        catch (caught) {
+            const id = request.id ?? null;
+            const code = caught instanceof AcpProtocolError ? caught.code : -32000;
+            error(id, code, caught instanceof Error ? caught.message : String(caught));
+        }
+    }
+    return {
+        start() {
+            if (running)
+                return;
+            running = true;
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.acp_server_started",
+                message: "ACP server started",
+            });
+            lines = readline.createInterface({ input: options.stdin, crlfDelay: Infinity });
+            lines.on("line", (line) => {
+                if (line.trim())
+                    void dispatch(line);
+            });
+        },
+        stop() {
+            if (!running)
+                return;
+            running = false;
+            lines?.close();
+            lines = null;
+            removeEventListener?.();
+            removeEventListener = null;
+            removeCloseListener?.();
+            removeCloseListener = null;
+            frontendClient?.close();
+            frontendClient = null;
+            clientPromise = null;
+            for (const prompt of activePrompts.values())
+                prompt.reject(new Error("ACP server stopped"));
+            activePrompts.clear();
+            pendingOutbound.clear();
+            sessions.clear();
+        },
+    };
+}

package/dist/senses/attention-queue.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAttentionQueue = buildAttentionQueue;
+exports.dequeueAttentionItem = dequeueAttentionItem;
+exports.attentionQueueEmpty = attentionQueueEmpty;
+exports.buildAttentionQueueSummary = buildAttentionQueueSummary;
+exports.buildAttentionQueueStatusFrame = buildAttentionQueueStatusFrame;
+const runtime_1 = require("../nerves/runtime");
+// ── Queue construction ───────────────────────────────────────────
+function generateItemId() {
+    return Math.random().toString(36).slice(2, 10);
+}
+function originKey(friendId, channel, key) {
+    return `${friendId}/${channel}/${key}`;
+}
+const PACKET_RETURN_HINT_MAX = 180;
+const PACKET_RETURN_HINT_COUNT_MAX = 4;
+const LITERAL_MARKER_RE = /\b[A-Z][A-Z0-9]*(?:_[A-Z0-9]+){2,}\b/;
+const RETURN_HINT_KEY_RE = /(expected|return|marker|answer|verdict)/i;
+function addReturnHint(hints, seen, value) {
+    if (typeof value !== "string")
+        return;
+    const trimmed = value.trim();
+    if (!trimmed || trimmed.length > PACKET_RETURN_HINT_MAX)
+        return;
+    if (!LITERAL_MARKER_RE.test(trimmed))
+        return;
+    if (seen.has(trimmed))
+        return;
+    seen.add(trimmed);
+    hints.push(trimmed);
+}
+function extractQuotedReturnHints(value, hints, seen) {
+    for (const match of value.matchAll(/"([^"\n]{1,180})"/g)) {
+        addReturnHint(hints, seen, match[1]);
+        if (hints.length >= PACKET_RETURN_HINT_COUNT_MAX)
+            return;
+    }
+}
+function extractPacketReturnHints(packet) {
+    const hints = [];
+    const seen = new Set();
+    const sourceRequest = typeof packet.payload.sourceRequest === "string" ? packet.payload.sourceRequest : "";
+    if (sourceRequest)
+        extractQuotedReturnHints(sourceRequest, hints, seen);
+    for (const [key, value] of Object.entries(packet.payload)) {
+        if (hints.length >= PACKET_RETURN_HINT_COUNT_MAX)
+            break;
+        if (key === "sourceRequest" || !RETURN_HINT_KEY_RE.test(key))
+            continue;
+        addReturnHint(hints, seen, value);
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                addReturnHint(hints, seen, item);
+                if (hints.length >= PACKET_RETURN_HINT_COUNT_MAX)
+                    break;
+            }
+        }
+    }
+    return hints;
+}
+function buildAttentionQueue(input) {
+    const { drainedPending, outstandingObligations, friendNameResolver, packetResolver } = input;
+    const seen = new Set();
+    const items = [];
+    const enrichPacket = (packetId) => {
+        if (!packetId || !packetResolver)
+            return {};
+        const packet = packetResolver(packetId);
+        if (!packet)
+            return { packetId };
+        return {
+            packetId,
+            packetKind: packet.kind,
+            packetObjective: packet.objective,
+            packetSummary: packet.summary,
+            packetSuccessCriteria: packet.successCriteria,
+            packetSourceRequest: typeof packet.payload.sourceRequest === "string" ? packet.payload.sourceRequest : undefined,
+            packetReturnHints: extractPacketReturnHints(packet),
+        };
+    };
+    // Source 1: drained pending messages with delegatedFrom (current-turn delegations)
+    for (const msg of drainedPending) {
+        if (!msg.delegatedFrom)
+            continue;
+        const { friendId, channel, key, bridgeId } = msg.delegatedFrom;
+        const oKey = originKey(friendId, channel, key);
+        seen.add(oKey);
+        const resolvedName = friendNameResolver(friendId);
+        items.push({
+            id: msg.obligationId ?? generateItemId(),
+            friendId,
+            friendName: resolvedName ?? friendId,
+            channel,
+            key,
+            ...(bridgeId ? { bridgeId } : {}),
+            delegatedContent: msg.content,
+            ...(msg.obligationId ? { obligationId: msg.obligationId } : {}),
+            ...enrichPacket(msg.packetId),
+            source: "drained",
+            timestamp: msg.timestamp,
+        });
+    }
+    // Source 2: outstanding obligations (crash recovery)
+    for (const obligation of outstandingObligations) {
+        const { friendId, channel, key, bridgeId } = obligation.origin;
+        const oKey = originKey(friendId, channel, key);
+        if (seen.has(oKey))
+            continue; // deduplicate: prefer drained version
+        seen.add(oKey);
+        const resolvedName = friendNameResolver(friendId);
+        items.push({
+            id: obligation.id,
+            friendId,
+            friendName: resolvedName ?? friendId,
+            channel,
+            key,
+            ...(bridgeId ? { bridgeId } : {}),
+            delegatedContent: obligation.delegatedContent,
+            obligationId: obligation.id,
+            ...enrichPacket(obligation.packetId),
+            source: "obligation-recovery",
+            timestamp: obligation.createdAt,
+        });
+    }
+    // Sort FIFO (oldest first)
+    items.sort((a, b) => a.timestamp - b.timestamp);
+    (0, runtime_1.emitNervesEvent)({
+        event: "senses.attention_queue_built",
+        component: "senses",
+        message: `attention queue built with ${items.length} item(s)`,
+        meta: {
+            drainedCount: items.filter((i) => i.source === "drained").length,
+            recoveredCount: items.filter((i) => i.source === "obligation-recovery").length,
+        },
+    });
+    return items;
+}
+// ── Queue operations ─────────────────────────────────────────────
+function dequeueAttentionItem(queue, id) {
+    const index = queue.findIndex((item) => item.id === id);
+    if (index === -1)
+        return null;
+    return queue.splice(index, 1)[0];
+}
+function attentionQueueEmpty(queue) {
+    return queue.length === 0;
+}
+// ── Queue visibility ─────────────────────────────────────────────
+const CONTENT_PREVIEW_MAX = 80;
+const PACKET_SOURCE_PREVIEW_MAX = 240;
+function preview(value, max) {
+    return value.length > max ? `${value.slice(0, max - 3)}...` : value;
+}
+function buildAttentionQueueSummary(queue) {
+    if (queue.length === 0)
+        return "";
+    const lines = [
+        "[internal: current held work items — not messages to send]",
+        "Only listed items are waiting now; older transcript mentions and completed returns/probes are not current pressure.",
+        "To return one, call surface with delegationId set to the bracketed id.",
+        "Return only the requested result; do not add commentary about prior attempts, old loops, or completed probes.",
+        "If literal return options are listed, copy the chosen option exactly, including suffixes and punctuation.",
+    ];
+    for (const item of queue) {
+        if (item.packetKind && item.packetObjective) {
+            lines.push(`- [${item.id}] ${item.friendName} -> ${item.packetKind}: ${item.packetObjective}`);
+            if (item.packetSuccessCriteria?.length) {
+                lines.push(`  return criteria: ${item.packetSuccessCriteria.join("; ")}`);
+            }
+            if (item.packetReturnHints?.length) {
+                lines.push(`  literal return options: ${item.packetReturnHints.map((hint) => `"${hint}"`).join("; ")}`);
+            }
+            const sourceRequest = item.packetSourceRequest ?? item.delegatedContent;
+            if (sourceRequest.trim().length > 0 && sourceRequest.trim() !== item.packetObjective.trim()) {
+                lines.push(`  source request: "${preview(sourceRequest, PACKET_SOURCE_PREVIEW_MAX)}"`);
+            }
+            continue;
+        }
+        lines.push(`- [${item.id}] ${item.friendName} asked: "${preview(item.delegatedContent, CONTENT_PREVIEW_MAX)}"`);
+    }
+    return lines.join("\n");
+}
+function buildAttentionQueueStatusFrame(queue) {
+    return buildAttentionQueueSummary(queue);
+}

package/dist/senses/await-turn-message.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAwaitTurnMessage = buildAwaitTurnMessage;
+const runtime_1 = require("../nerves/runtime");
+function formatElapsed(ms) {
+    if (ms < 60_000)
+        return "<1m ago";
+    const minutes = Math.floor(ms / 60_000);
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    return `${days}d ago`;
+}
+function relativeAge(lastCheckedAt, now) {
+    if (!lastCheckedAt)
+        return null;
+    const lastMs = new Date(lastCheckedAt).getTime();
+    if (!Number.isFinite(lastMs))
+        return null;
+    return formatElapsed(now().getTime() - lastMs);
+}
+function buildAwaitTurnMessage(options) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.await_turn_message_built",
+        message: "built await tick message",
+        meta: { awaitName: options.awaitName, checkedCount: options.checkedCount },
+    });
+    const lines = [];
+    lines.push(`await tick: ${options.awaitName} — ${options.condition}`);
+    if (options.body && options.body.trim().length > 0) {
+        lines.push("");
+        lines.push("what would count as ready:");
+        lines.push(options.body.trim());
+    }
+    const age = relativeAge(options.lastCheckedAt, options.now);
+    const obs = options.lastObservation && options.lastObservation.trim().length > 0
+        ? `last observation: "${options.lastObservation.trim()}"`
+        : "last observation: (none yet)";
+    if (options.checkedCount === 0) {
+        lines.push("");
+        lines.push("history: never checked. this is my first look.");
+    }
+    else {
+        lines.push("");
+        lines.push(`history: checked ${options.checkedCount}x so far. last checked ${age ?? "(unknown)"}. ${obs}.`);
+    }
+    if (options.checkpoint) {
+        lines.push("");
+        lines.push(`last checkpoint: ${options.checkpoint}`);
+    }
+    lines.push("");
+    lines.push("look around and decide. if the condition is met, call resolve_await with verdict='yes' and a one-line observation. otherwise call resolve_await with verdict='no' and a one-line observation of what i saw this tick.");
+    return lines.join("\n");
+}