openmausbot 0.1.86 → 0.1.88

package/dist-server/shared/ask-question.js

@@ -29,7 +29,7 @@ function text(value, limit) {
     if (typeof value !== "string")
         return undefined;
     const trimmed = value.trim();
-    return trimmed ? trimmed.slice(0, limit) : undefined;
+    return trimmed ? trimmed.slice(0, limit).trim() : undefined;
 }
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -94,6 +94,55 @@ export function parseAskQuestions(input) {
     }
     return questions.length ? questions : null;
 }
+/** The fenced block a turn-boundary agent ends its run with when it wants
+ * to ask the person something (the BoxAgent transport): the harness cannot
+ * pause mid-run, so the questions ride the final output and OMB parses them
+ * at settle. The block is model-authored — untrusted input like any tool
+ * call — so its body runs through parseAskQuestions and the same caps. */
+const OMB_ASK_FENCE = /(^|\n)[ \t]{0,3}(`{3,}|~{3,})[ \t]*omb-ask[ \t]*\r?\n([\s\S]*?)\r?\n[ \t]{0,3}\2[ \t]*(?=\r?\n|$)/;
+const OMB_ASK_FENCE_GLOBAL = new RegExp(OMB_ASK_FENCE.source, OMB_ASK_FENCE.flags + "g");
+/** The questions inside the first fenced omb-ask block in an output, or
+ * null when there is nothing worth showing (no fence, invalid JSON, or no
+ * entry that parses as a question). The first fence wins: a second block
+ * in the same output is ignored, not merged. */
+export function parseOmbAskQuestions(output) {
+    const match = OMB_ASK_FENCE.exec(output);
+    if (!match)
+        return null;
+    try {
+        return parseAskQuestions(JSON.parse(match[3]));
+    }
+    catch {
+        return null;
+    }
+}
+/** The output with its omb-ask block(s) removed, for display: the person
+ * reads the prose around the ask, never the raw protocol JSON. Text
+ * without a block is returned untouched. */
+export function stripOmbAskBlock(output) {
+    if (!OMB_ASK_FENCE.test(output))
+        return output;
+    return output.replace(OMB_ASK_FENCE_GLOBAL, "").replace(/\n{3,}/g, "\n\n").trim();
+}
+/** The prompt contract that teaches a model the turn-held ask transport: end
+ * the reply with a fenced `omb-ask` block carrying the questions, and the
+ * answers come back on the next prompt. A harness that cannot pause mid-run
+ * (the BoxAgent transport) appends this to every prompt; the caps in the text
+ * are the constants above, so the taught contract and the parser cannot
+ * drift apart. */
+export function ombAskProtocolPrompt() {
+    return [
+        "",
+        "## Asking the person a question",
+        "When a decision belongs to the person, end your reply with a fenced block exactly like this:",
+        "",
+        "```omb-ask",
+        '{"questions":[{"question":"Ship the release now?","header":"Release","options":[{"label":"Ship now"},{"label":"Wait for the QA signoff"}]}]}',
+        "```",
+        "",
+        `The block must be the last thing in your reply. You may ask up to ${MAX_QUESTIONS} questions at once, each with up to ${MAX_OPTIONS} options; the person can always answer in their own words. Their answers arrive on your next prompt as \`Q:\`/\`A:\` lines — never invent them.`,
+    ].join("\n");
+}
 /** The one line the card subtitle and a spoken prompt show. */
 export function askQuestionSummary(questions) {
     const first = questions[0]?.question ?? "";
@@ -139,6 +188,61 @@ export function questionChoices(questions) {
         return undefined;
     return only.options.map((option) => option.label);
 }
+/** The chat runtime's own ask tool: the OpenAI-compatible engines'
+ * counterpart of ASK_USER_QUESTION. Named ask_user so the ASKS_A_PERSON
+ * backstop already covers it — no auto mode may answer a question. */
+export const ASK_USER_TOOL = "ask_user";
+/** The ask_user definition shared by every chat-runtime engine, shaped for
+ * an OpenAI function-calling tool list. The schema states the caps; the
+ * parser enforces them again on arrival, because a model-authored argument
+ * is a request to follow the schema, not a guarantee that it did. */
+export const ASK_USER_TOOL_DEFINITION = {
+    type: "function",
+    function: {
+        name: ASK_USER_TOOL,
+        description: "Ask the person questions when the decision is theirs. Offer concrete options where they exist; they can always answer in their own words. Ask up to six questions in one call rather than one at a time.",
+        parameters: {
+            type: "object",
+            properties: {
+                questions: {
+                    type: "array",
+                    minItems: 1,
+                    maxItems: MAX_QUESTIONS,
+                    items: {
+                        type: "object",
+                        properties: {
+                            question: { type: "string", description: "The question to show the person." },
+                            header: { type: "string", description: "A short label for the question's tab." },
+                            multiSelect: { type: "boolean", description: "Whether several options may be picked." },
+                            options: {
+                                type: "array",
+                                maxItems: MAX_OPTIONS,
+                                description: "Suggested answers; the person may always write their own.",
+                                items: {
+                                    type: "object",
+                                    properties: {
+                                        label: { type: "string" },
+                                        description: { type: "string" },
+                                    },
+                                    required: ["label"],
+                                    additionalProperties: false,
+                                },
+                            },
+                        },
+                        required: ["question"],
+                        additionalProperties: false,
+                    },
+                },
+            },
+            required: ["questions"],
+            additionalProperties: false,
+        },
+    },
+};
+/** The synthetic tool string for an ask parsed out of model-authored final
+ * output (the BoxAgent turn-held transport): there is no tool call to name,
+ * but the event and the ASKS_A_PERSON backstop need one string. */
+export const OMB_ASK_TOOL = "omb-ask";
 /** The lead-in on a formatted answer. It exists for the model — the answer
  * is delivered on the deny channel, so it has to say what it is — and the
  * card strips it back off when it shows the person what they sent. */
@@ -164,6 +268,23 @@ export function formatQuestionAnswers(questions, answers) {
 export function answerWithoutPreamble(answer) {
     return answer.startsWith(`${ANSWER_PREAMBLE}\n\n`) ? answer.slice(ANSWER_PREAMBLE.length + 2) : answer;
 }
+/** The longest formatted answer OMB will echo back into a follow-up prompt
+ * (the BoxAgent continuation). formatQuestionAnswers itself does not
+ * truncate — the tool-result channel has no stated limit — but a prompt is
+ * not the place to find one: six answers at the custom-answer cap is the
+ * most a legitimate reply weighs, so that is the ceiling. */
+export const MAX_ANSWER_ECHO = 6 * MAX_CUSTOM_ANSWER;
+/** Cap a formatted answer for echoing into a follow-up prompt. An over-cap
+ * echo is cut back to the last whole block so no partial answer reads as
+ * one, and says it was truncated. */
+export function capAnswerEcho(answer, limit = MAX_ANSWER_ECHO) {
+    if (answer.length <= limit)
+        return answer;
+    const cut = answer.slice(0, limit);
+    const boundary = cut.lastIndexOf("\n\nQ: ");
+    const kept = boundary > 0 ? cut.slice(0, boundary) : cut;
+    return kept + "\n\n[answer truncated]";
+}
 /**
  * The answer text, read back as one value per question.
  *
@@ -180,21 +301,95 @@ export function answerWithoutPreamble(answer) {
  * With more than one there is, and nothing is filed.
  */
 export function questionAnswersByQuestion(message, questions) {
-    const answers = {};
-    const known = new Map(questions.map((entry) => [entry.question, entry.question]));
-    for (const block of message.split("\n\n")) {
-        const match = /^Q: ([\s\S]+?)\nA: ([\s\S]+)$/.exec(block.trim());
-        if (!match)
+    return questionAnswersById(message, questions.map(question => ({ id: question.question, question })));
+}
+/** Longest protocol id accepted. Ids are harness-internal keys, never shown
+ * on the card, but they ride the reply — so they are capped like the rest. */
+const MAX_QUESTION_ID = 200;
+/** Parse a protocol questions array whose entries carry their own string
+ * ids (codex's item/tool/requestUserInput). The same caps and skip rules
+ * as parseAskQuestions; an entry without both a usable id and a usable
+ * question is skipped rather than fatal, and nothing answerable parses to
+ * null. */
+export function parseProtocolAskQuestions(entries) {
+    if (!Array.isArray(entries))
+        return null;
+    const parsed = [];
+    const seenIds = new Set();
+    for (const raw of entries) {
+        if (!isRecord(raw))
+            continue;
+        const question = parseQuestion(raw);
+        // The id is opaque protocol data echoed back verbatim in the answer, so
+        // it is preserved exactly as sent — trimmed only to reject an
+        // all-whitespace id — and an overlong id is rejected whole rather than
+        // truncated. A duplicate id fails the whole request: two questions
+        // cannot share one answer slot, and silently dropping one would ask
+        // the person a question whose answer could never be delivered.
+        const id = raw.id;
+        if (!question || typeof id !== "string" || !id.trim() || id.length > MAX_QUESTION_ID)
+            continue;
+        if (seenIds.has(id))
+            return null;
+        seenIds.add(id);
+        parsed.push({ id, question });
+        if (parsed.length === MAX_QUESTIONS)
+            break;
+    }
+    return parsed.length ? parsed : null;
+}
+/**
+ * The id-keyed counterpart of questionAnswersByQuestion, for a protocol
+ * that answers by id (codex's requestUserInput) rather than by question
+ * text.
+ *
+ * Each protocol entry's id is paired with the AskQuestion parsed from that
+ * same entry, so a Q:/A: block the card wrote is matched against the text
+ * that produced it and filed under the id that asked. Only ids with a real
+ * block are answered — a question left unanswered gets no entry rather
+ * than a guess. When the reply carries no blocks at all, the flat path
+ * applies with exactly one question: the whole message is that question's
+ * answer, as it is for a phone or an older client. With more than one,
+ * nothing is filed.
+ */
+export function questionAnswersById(message, questions) {
+    const answers = Object.create(null);
+    const idByText = new Map();
+    const ambiguous = new Set();
+    for (const { id, question } of questions) {
+        if (idByText.has(question.question)) {
+            // Two questions with identical text cannot be told apart in a block;
+            // answering either id would be a guess, so neither is answered.
+            ambiguous.add(question.question);
+            continue;
+        }
+        idByText.set(question.question, id);
+    }
+    // A block runs from one Q: header to the next (blank lines inside an
+    // answer are the answer's, not block boundaries), so the reply is scanned
+    // for header-to-header spans instead of split on every blank line.
+    const blocks = message.matchAll(/(?:^|\n\n)Q: ([\s\S]+?)\nA: ([\s\S]*?)(?=\n\nQ: |$)/g);
+    let sawBlock = false;
+    for (const match of blocks) {
+        sawBlock = true;
+        const asked = match[1].trim();
+        if (ambiguous.has(asked))
             continue;
-        // Only a question this ask actually posed. An unrecognized block is
-        // dropped rather than filed under a key the tool never asked about.
-        const question = known.get(match[1].trim());
-        if (question)
-            answers[question] = match[2].trim();
+        const id = idByText.get(asked);
+        const answer = match[2].trim();
+        // A blank A: is no answer: the id stays unanswered rather than filed
+        // as an empty string.
+        if (id && answer)
+            answers[id] = answer;
     }
     if (Object.keys(answers).length)
         return answers;
+    // A structured reply that matched a block is authoritative even when it
+    // answered nothing: falling through to the flat fallback would file the
+    // literal Q:/A: text as the person's answer.
+    if (sawBlock)
+        return {};
     const only = questions.length === 1 ? questions[0] : undefined;
     const flat = message.trim();
-    return only && flat ? { [only.question]: flat } : {};
+    return only && flat ? { [only.id]: flat } : {};
 }

package/dist-server/shared/bot-profile.js

@@ -9,3 +9,18 @@ export const BOT_PROFILE_LIMITS = {
     voice: 200,
     soul: 24_000,
 };
+/** A name or title is quoted inside prompts and cards as one line — a
+ * roster entry, a "Name: …" speaker line, the bracketed provenance note.
+ * Text that can break out of that line (a newline, a control byte, the
+ * Unicode separators) is refused at the door rather than flattened later,
+ * so what the person sees in the sidebar is what every prompt sees too.
+ * Written as a scan because a control-character class is the kind of
+ * literal the linter (rightly) refuses. */
+export function fitsOnOneLine(value) {
+    for (let i = 0; i < value.length; i += 1) {
+        const code = value.charCodeAt(i);
+        if (code < 0x20 || (code >= 0x7f && code <= 0x9f) || code === 0x2028 || code === 0x2029)
+            return false;
+    }
+    return true;
+}

package/dist-server/shared/command-allowlist.js

@@ -0,0 +1 @@
+export {};

package/dist-server/shared/credential-request.js

@@ -14,7 +14,7 @@ export const CREDENTIAL_TARGETS = {
         label: "Box API key",
         description: "Gives bots an isolated cloud computer when Box is selected.",
         placeholder: "Paste your Box API key",
-        helpUrl: "https://docs.ascii.dev/box/api-keys",
+        helpUrl: "https://docs.boat.dev/api-keys",
     },
     opencodeGoApiKey: {
         label: "OpenCode API key",
@@ -76,11 +76,15 @@ export function credentialIsConfigured(config, id) {
             return Boolean(config.imageGen?.key);
     }
 }
-export function isReusableCredentialRequest(message, target, requestingBotId, roomThread) {
+/** A still-pending credential card for this target — the set a newer
+ * request supersedes. Provided, dismissed, and already-superseded cards
+ * keep their settled state untouched. */
+export function isPendingCredentialRequest(message, target, requestingBotId, roomThread) {
     return (message.kind === "secret" &&
         message.secret?.target === target &&
         message.secret.provided !== true &&
         message.secret.dismissed !== true &&
+        message.secret.superseded !== true &&
         (!roomThread || message.from?.botId === requestingBotId));
 }
 export function credentialResumeOutcome(state) {

package/dist-server/shared/line-diff.js

@@ -40,3 +40,26 @@ export function lineDiff(before, after) {
         out.push(`+${b[j++]}`);
     return out;
 }
+/** Cap on diff lines rendered inside an approval card. Past this the card
+ * shows the complete proposed document instead of a truncated diff, because
+ * truncation can hide the very instructions being approved. */
+export const MAX_DIFF_LINES = 400;
+/** The SOUL.md review block shared by the profile and team-setup cards:
+ * byte counts, a line diff for reviewable changes, and the complete
+ * replacement when the diff would outrun the card. The full replacement is
+ * already byte-bounded by profile validation and is readable in the same
+ * generic card on desktop and phones. */
+export function soulDiffLines(before, after) {
+    const encoder = new TextEncoder();
+    const bytesBefore = encoder.encode(before).length;
+    const bytesAfter = encoder.encode(after).length;
+    const diff = lineDiff(before, after);
+    if (diff.length > MAX_DIFF_LINES) {
+        return [
+            `SOUL.md (${bytesBefore} → ${bytesAfter} bytes):`,
+            "Large change — complete proposed instructions (replaces the current SOUL.md):",
+            after || "(empty)",
+        ];
+    }
+    return [`SOUL.md (${bytesBefore} → ${bytesAfter} bytes):`, ...diff];
+}

package/dist-server/shared/model-request.js

@@ -0,0 +1 @@
+export {};

package/dist-server/shared/options-card.js

@@ -0,0 +1,51 @@
+/** The one bot allowed to create passive choice cards for the Watcher flow. */
+export const WATCHER_OPTIONS_CARD_BOT_ID = "f08dd8e3-f942-4eb4-8783-df32b26b88a4";
+/** Keep agent-authored cards small enough to remain useful on desktop and mobile. */
+export const OPTIONS_CARD_LIMITS = {
+    title: 120,
+    subtitle: 1_000,
+    option: 120,
+    minOptions: 2,
+    maxOptions: 6,
+};
+function record(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function boundedText(value, field, maximum) {
+    if (typeof value !== "string")
+        return { error: `${field} must be a string.` };
+    const text = value.trim();
+    if (!text)
+        return { error: `${field} must not be blank.` };
+    if (text.length > maximum)
+        return { error: `${field} must be at most ${maximum} characters.` };
+    return text;
+}
+/** Normalize untrusted model input before it is persisted into a native card. */
+export function parseOptionsCardInput(value) {
+    if (!record(value))
+        return { ok: false, error: "create_options_card needs an object." };
+    const title = boundedText(value.title, "title", OPTIONS_CARD_LIMITS.title);
+    if (typeof title !== "string")
+        return { ok: false, error: title.error };
+    const subtitle = boundedText(value.subtitle, "subtitle", OPTIONS_CARD_LIMITS.subtitle);
+    if (typeof subtitle !== "string")
+        return { ok: false, error: subtitle.error };
+    if (!Array.isArray(value.options))
+        return { ok: false, error: "options must be an array of strings." };
+    if (value.options.length < OPTIONS_CARD_LIMITS.minOptions || value.options.length > OPTIONS_CARD_LIMITS.maxOptions) {
+        return { ok: false, error: `options must contain ${OPTIONS_CARD_LIMITS.minOptions}-${OPTIONS_CARD_LIMITS.maxOptions} items.` };
+    }
+    const options = [];
+    const seen = new Set();
+    for (let index = 0; index < value.options.length; index += 1) {
+        const option = boundedText(value.options[index], `options[${index}]`, OPTIONS_CARD_LIMITS.option);
+        if (typeof option !== "string")
+            return { ok: false, error: option.error };
+        if (seen.has(option))
+            return { ok: false, error: `options must be unique; "${option}" is repeated.` };
+        seen.add(option);
+        options.push(option);
+    }
+    return { ok: true, value: { title, subtitle, options } };
+}