@bivy/bivy 0.21.2-staging.10 → 0.21.2-staging.11

package/bin/bivy.mjs

@@ -2685,6 +2685,7 @@ finish: Bivy already pushes when a turn ends while the user is away. --json prin
 // Blocks until the user answers (printing the answer), or with --async returns
 // an id to read later with `bivy ask status|wait <id>`.
 const ASK_USAGE = `Usage: bivy ask "<question>" [--option <label>]… [--multi] [--header <label>] [--timeout 10m] [--async] [--json]
+       bivy ask "<question>" --secret <NAME> [--url <https://…>] [--timeout 10m] [--json]
        bivy ask status <id> [--json]
        bivy ask wait <id> [--timeout 10m] [--json]`;
 
@@ -2697,6 +2698,11 @@ Ask the user a question in the chat and wait for the answer. Their devices get a
 several with --multi) or write their own; without options they type an answer.
 --header is the short label on the card.
 
+--secret NAME asks for an API key, token or password instead: the card takes a
+hidden value, the node stores it in its vault as NAME, and this prints only
+secret://NAME, never the value. --url is where the user finds it. Use it with
+'bivy secrets exec --env NAME -- <command>'.
+
 Prints the answer and exits 0. Exits 1 if the user dismissed the question and 5
 if --timeout (default 10m, up to 24h) passes first; the card closes then.
 --async returns the question's id at once; 'bivy ask wait <id>' blocks for the
@@ -2706,7 +2712,7 @@ answer later and 'bivy ask status <id>' checks without waiting.
   }
   const json = wantsJson(args);
   const fail = (error) => cliError(error, { json, paint: c.red });
-  const parsed = parseSessionArgs(args, ["--session", "--option", "--header", "--timeout"]);
+  const parsed = parseSessionArgs(args, ["--session", "--option", "--header", "--timeout", "--secret", "--url"]);
   if (parsed.error) return fail({ code: "usage", message: parsed.error, exit: EXIT.usage });
   const sessionId = resolveAttachSessionId({ sessionFlag: parsed.one("--session"), env: process.env });
   if (!sessionId) return fail({ code: "no_session", message: "No session id.", hint: "Run inside an agent session ($BIVY_SESSION_ID) or pass --session <id>.", next: "bivy sessions --json", exit: EXIT.usage });
@@ -2729,6 +2735,7 @@ answer later and 'bivy ask status <id>' checks without waiting.
   };
   const answerText = (result) => Object.values(result.answers ?? {}).join("\n");
   const finish = (result) => {
+    if (result.status === "answered" && !answerText(result)) return fail({ code: "failed", message: "The secret was not stored on this node.", next: "bivy secrets doctor", exit: EXIT.failed });
     const out = { id: result.id, status: result.status, ...(result.status === "answered" ? { answer: answerText(result) } : {}) };
     if (result.status === "answered") { console.log(json ? JSON.stringify(out) : out.answer); return; }
     if (result.status === "pending") { console.log(json ? JSON.stringify(out) : `Still waiting for an answer. Check again with: bivy ask wait ${result.id}`); process.exit(EXIT.timeout); }
@@ -2755,8 +2762,10 @@ answer later and 'bivy ask status <id>' checks without waiting.
   if (!question) return fail({ code: "usage", message: ASK_USAGE, exit: EXIT.usage });
   const options = parsed.values["--option"] ?? [];
   if (options.length === 1) return fail({ code: "usage", message: "Offer at least two --option values, or none for a free-text answer.", exit: EXIT.usage });
+  const secretName = parsed.one("--secret");
+  if (parsed.one("--url") !== undefined && secretName === undefined) return fail({ code: "usage", message: "--url goes with --secret.", exit: EXIT.usage });
   const started = await call("", {
-    questions: [{ question, header: parsed.one("--header"), options, multiSelect: parsed.has("--multi") }],
+    questions: [{ question, header: parsed.one("--header"), options, multiSelect: parsed.has("--multi"), ...(secretName !== undefined ? { secret: { name: secretName, url: parsed.one("--url") } } : {}) }],
     timeoutSeconds: timeout,
   });
   if (parsed.has("--async")) {
@@ -6806,8 +6815,10 @@ Unlike 'bivy run', these commands operate on governed background Runs with check
       // secrets-cli.ts only recognizes "--help"/"help" as the FIRST argument, so
       // a subcommand-position --help (e.g. 'bivy secrets list --help') would
       // otherwise be ignored and the live action would run anyway (#113).
-      const forwardArgs = (args.includes("-h") || args.includes("--help")) ? ["--help"] : args;
-      process.exit(await run(nodeBin, [...nodeScriptArgs(secretsEntry), ...forwardArgs], { cwd: repoRoot, env: process.env }));
+      // Words after `--` belong to `secrets exec`'s command, not to us.
+      const own = args.includes("--") ? args.slice(0, args.indexOf("--")) : args;
+      const forwardArgs = (own.includes("-h") || own.includes("--help")) ? ["--help"] : args;
+      process.exit(await run(nodeBin, [...nodeScriptArgs(secretsEntry), ...forwardArgs], { cwd: own[0] === "exec" ? process.cwd() : repoRoot, env: process.env }));
       break;
     }
     case "voice": {

package/bin/cli-commands.mjs

@@ -46,8 +46,9 @@ export const COMMANDS = [
   { name: "attach", group: "session", scope: "session", json: true, usage: 'attach <file> [--caption "…"] [--artifact]', summary: "Show a local file or image to the user in the chat" },
   { name: "notify", group: "session", scope: "session", json: true, usage: "notify [--urgent]", summary: "Push to the user's phone so they come back (nothing posted in the chat)",
     tools: [{ name: "notify_user", description: "Push to the user's phone so they come back to this session, e.g. when you are blocked on them while still working. The push names the session only and nothing is posted in the chat, so say what you need in your reply. Not needed when you finish: Bivy already pushes when a turn ends while they are away. Sent only when nobody has the app open, at most one a minute per session.", input: { urgent: { type: "boolean", description: "Push even while the user has the app open." } }, argv: ["notify", { when: "urgent", flag: "--urgent" }] }] },
-  { name: "ask", group: "session", scope: "session", json: true, usage: 'ask "<question>" [--option A --option B] [--async]', summary: "Ask the user a question and wait for the answer", subcommands: ["status", "wait"],
-    tools: [{ name: "ask_user", description: "Ask the user a question in the chat and wait for their answer (their phone gets a push). Offer 2-8 options, or none for a free-text answer; they can always write their own. Returns {status, answer}: status is answered, dismissed (decide yourself) or expired.", input: { question: { type: "string", description: "The question.", required: true }, options: { type: "array", items: { type: "string" }, description: "Choices to pick from (2-8)." }, multiple: { type: "boolean", description: "Allow several choices." }, header: { type: "string", description: "A short label for the card." }, timeout_seconds: { type: "number", description: "How long to wait (default 600)." } }, argv: ["ask", { arg: "question" }, { flag: "--option", from: "options" }, { when: "multiple", flag: "--multi" }, { flag: "--header", from: "header" }, { flag: "--timeout", from: "timeout_seconds" }] }] },
+  { name: "ask", group: "session", scope: "session", json: true, usage: 'ask "<question>" [--option A --option B] [--secret NAME] [--async]', summary: "Ask the user a question (or for a secret) and wait for the answer", subcommands: ["status", "wait"],
+    tools: [{ name: "ask_user", description: "Ask the user a question in the chat and wait for their answer (their phone gets a push). Offer 2-8 options, or none for a free-text answer; they can always write their own. Returns {status, answer}: status is answered, dismissed (decide yourself) or expired.", input: { question: { type: "string", description: "The question.", required: true }, options: { type: "array", items: { type: "string" }, description: "Choices to pick from (2-8)." }, multiple: { type: "boolean", description: "Allow several choices." }, header: { type: "string", description: "A short label for the card." }, timeout_seconds: { type: "number", description: "How long to wait (default 600)." } }, argv: ["ask", { arg: "question" }, { flag: "--option", from: "options" }, { when: "multiple", flag: "--multi" }, { flag: "--header", from: "header" }, { flag: "--timeout", from: "timeout_seconds" }] },
+      { name: "request_secret", description: "Ask the user for an API key, token or password. Their card takes a hidden value that is stored in this machine's vault as `name`; you get back only secret://<name>, never the value. Use it with `bivy secrets exec --env <name> -- <command>`. Never ask for a secret with ask_user. Returns {status, answer}.", input: { name: { type: "string", description: "Vault name, env-var style, e.g. STRIPE_API_KEY.", required: true }, question: { type: "string", description: "What to paste and why, e.g. \"Paste your Stripe secret key so I can create the products.\"", required: true }, url: { type: "string", description: "https:// page where the user finds or creates it." }, timeout_seconds: { type: "number", description: "How long to wait (default 600)." } }, argv: ["ask", { arg: "question" }, { flag: "--secret", from: "name" }, { flag: "--url", from: "url" }, { flag: "--timeout", from: "timeout_seconds" }] }] },
   { name: "title", group: "session", scope: "session", json: true, usage: 'title "<title>"', summary: "Rename this session",
     tools: [{ name: "set_session_title", description: "Rename this session in the user's session list. Use a short title (under 60 characters) that says what the work is, when the first message made a poor title or the work changed direction.", input: { title: { type: "string", description: "The new title.", required: true } }, argv: ["title", { arg: "title" }] }] },
   { name: "app", group: "session", scope: "session", json: true, usage: "app <publish|shot|present|share|run|…>", summary: "Live previews: publish a web/terminal/desktop app, screenshot it, present it", subcommands: ["publish", "list", "remove", "shot", "present", "share", "notes", "run", "click", "type", "key", "scroll", "drag", "move", "menu"],
@@ -114,7 +115,7 @@ export const COMMANDS = [
   { name: "logout", aliases: ["signout"], group: "accounts", scope: "account", usage: "logout", summary: "Sign this machine out" },
   { name: "provider", aliases: ["model"], group: "accounts", scope: "node", usage: "provider login [provider]", summary: "Sign into a model provider", subcommands: ["login"] },
   { name: "auth", aliases: ["credentials", "creds"], group: "accounts", scope: "node", usage: "auth <list|add|remove|import|sync|…>", summary: "Model credentials: import local logins, add, sync", subcommands: ["list", "add", "remove", "sync", "preset", "ingest", "config", "import"] },
-  { name: "secrets", aliases: ["secret"], group: "accounts", scope: "node", usage: "secrets <list|set|ref|delete|doctor|resolve>", summary: "Store tokens in the node vault", subcommands: ["list", "set", "ref", "delete", "doctor", "resolve"] },
+  { name: "secrets", aliases: ["secret"], group: "accounts", scope: "node", usage: "secrets <list|set|ref|delete|doctor|resolve|exec>", summary: "Store tokens in the node vault, and run a command with them", subcommands: ["list", "set", "ref", "delete", "doctor", "resolve", "exec"] },
   { name: "github:connect", aliases: ["connect-repo"], group: "accounts", scope: "node", usage: "github:connect [owner/repo]", summary: "Connect GitHub" },
   { name: "github:app-create", group: "accounts", scope: "node", usage: "github:app-create [--org <org>]", summary: "One-click: create and connect a GitHub App" },
   { name: "github:app-connect", group: "accounts", scope: "node", usage: "github:app-connect --app-id <id> --key <path.pem>", summary: "Connect an existing GitHub App" },

package/bin/guides/talk-to-the-user.md

@@ -30,6 +30,19 @@ dismissed it (use your judgment), exit 5 that `--timeout` (default 10m) passed.
 For long waits use `--async`, keep working, and later `bivy ask wait <id>`.
 Ask only when you can't reasonably decide yourself.
 
+## You need a key or password: ask for a secret
+
+    bivy ask "Paste your Stripe secret key so I can create the products" \
+      --secret STRIPE_API_KEY --url https://dashboard.stripe.com/apikeys
+    bivy secrets exec --env STRIPE_API_KEY -- stripe products list
+
+The card takes a hidden value and stores it in this machine's vault; you get
+back `secret://STRIPE_API_KEY`, never the value. Use it through
+`bivy secrets exec`, which puts it in the command's environment. It stays
+stored for later sessions, so try `bivy secrets exec` first and ask only when
+it says the secret is missing. Never ask for a secret with a plain `bivy ask`
+or in chat, and never print it: the answer would land in the transcript.
+
 ## Name the session: title
 
     bivy title "Fix login redirect loop"

package/dist/apps/styles.css

@@ -884,6 +884,11 @@ input, textarea, select { font-family: inherit; font-size: 16px; }
    and anything below 16px makes iOS Safari auto-zoom the viewport on focus. */
 .question-other-input { box-sizing: border-box; resize: vertical; min-height: 40px; }
 .question-other-input:disabled { opacity: 0.6; }
+/* A secret request's fine print: where the value goes, and where to find it. */
+.question-note { margin: 0; font-size: 12px; color: var(--muted); }
+.question-note code { font-size: 12px; }
+.question-note a { color: var(--accent); font-weight: 600; text-decoration: underline; text-underline-offset: 2px; }
+.question-note a:hover { color: var(--accent-hover); }
 
 /* ---- GitHub pill + action sheet ---- */
 .github-pill { flex: none; background: transparent; font: inherit; cursor: pointer; }

package/dist/redact.js

@@ -79,11 +79,33 @@ const KNOWN_SECRET_FIELDS = [
     "privateKeyPem",
 ];
 const KNOWN_SECRET_FIELD_VALUE = new RegExp(`("(?:${KNOWN_SECRET_FIELDS.join("|")})"\\s*:\\s*")[^"\\\\]*(?:\\\\.[^"\\\\]*)*(")`, "g");
+// Exact values the node knows are secret: what the user typed into a secret
+// card, and the node vault's local entries. These have no shape to match on (a
+// random API key, a password), so the vault registers them here and every
+// persisted write masks them wherever they appear. Short values are skipped:
+// masking "1234" everywhere would mangle ordinary text.
+const MIN_KNOWN_SECRET = 8;
+const knownSecrets = new Set();
+/** Mask `value` in everything persisted from now on. */
+export function registerSecretValue(value) {
+    const trimmed = String(value ?? "").trim();
+    if (trimmed.length >= MIN_KNOWN_SECRET)
+        knownSecrets.add(trimmed);
+}
 /** Mask credentials in `text`. Safe on non-string / empty input. */
 export function redactSecrets(text) {
     if (!text)
         return text;
-    let out = text
+    let out = text;
+    for (const value of knownSecrets) {
+        if (out.includes(value))
+            out = out.split(value).join(REDACTED);
+        // Persisted text is JSON: a value with quotes, backslashes or newlines appears escaped.
+        const escaped = JSON.stringify(value).slice(1, -1);
+        if (escaped !== value && out.includes(escaped))
+            out = out.split(escaped).join(REDACTED);
+    }
+    out = out
         .replace(URL_CREDENTIAL, `$1:${REDACTED}@`)
         .replace(GH_TOKEN, REDACTED)
         .replace(GH_FINE_PAT, REDACTED)

package/dist/secrets-cli.js

@@ -1,10 +1,11 @@
 // SPDX-License-Identifier: AGPL-3.0-only
 // Copyright (c) 2026 Petter André Sjulstad
+import { spawn } from "node:child_process";
 import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { SecretVault } from "./secrets.js";
+import { SecretVault, secretExecPlan } from "./secrets.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const repoRoot = path.resolve(__dirname, "..");
 const appDir = process.env.BIVY_DATA_DIR ?? path.join(repoRoot, ".bivy");
@@ -59,6 +60,9 @@ Commands:
   bivy secrets delete <id>
   bivy secrets doctor
   bivy secrets resolve <id>           Verify a secret resolves without printing it
+  bivy secrets exec --env NAME[=ref]… -- <command> [args…]
+                                      Run a command with secrets in its environment
+                                      (NAME alone means secret://NAME), never printing them
 
 Common ids:
   github.repo-token
@@ -67,8 +71,27 @@ Common ids:
   integration.github
 `);
 }
+async function exec(args) {
+    const plan = secretExecPlan(args);
+    const env = { ...process.env };
+    for (const [name, ref] of plan.env) {
+        const value = await vault.resolve(ref);
+        if (!value)
+            throw new Error(`${ref} did not resolve. Ask the user for it with: bivy ask "<what to paste>" --secret ${name}`);
+        env[name] = value;
+    }
+    return new Promise((resolve, reject) => {
+        const child = spawn(plan.command[0], plan.command.slice(1), { stdio: "inherit", env });
+        child.on("error", reject);
+        child.on("exit", (code, signal) => resolve(code ?? (signal ? 128 : 1)));
+    });
+}
 async function main() {
     const [cmd, id, ...rest] = process.argv.slice(2);
+    if (cmd === "exec") {
+        process.exitCode = await exec(process.argv.slice(3));
+        return;
+    }
     if (!cmd || cmd === "help" || cmd === "--help") {
         usage();
         return;

package/dist/secrets.js

@@ -125,6 +125,23 @@ export class SecretVault {
             return this.decryptRecord(record);
         return undefined;
     }
+    /** Every value stored in this vault itself (not references), for redaction.
+     *  A record that no longer decrypts is skipped. */
+    localValues() {
+        this.reload();
+        const values = [];
+        for (const record of Object.values(this.data.records)) {
+            if (record.backend !== "local")
+                continue;
+            try {
+                const value = this.decryptRecord(record);
+                if (value)
+                    values.push(value);
+            }
+            catch { }
+        }
+        return values;
+    }
     setReference(id, ref, description) {
         const normalized = normalizeSecretId(id);
         const trimmed = String(ref || "").trim();
@@ -291,6 +308,27 @@ function modeIsPrivate(file) {
         return false;
     }
 }
+/** `--env NAME` or `--env NAME=<secret://…|op://…|env://…|cmd://…|id>` pairs before `--`. */
+export function secretExecPlan(args) {
+    const split = args.indexOf("--");
+    if (split < 0 || split === args.length - 1)
+        throw new Error("Usage: bivy secrets exec --env NAME[=ref]… -- <command> [args…]");
+    const env = [];
+    const own = args.slice(0, split);
+    for (let i = 0; i < own.length; i++) {
+        const spec = own[i] === "--env" ? own[++i] : own[i].startsWith("--env=") ? own[i].slice("--env=".length) : undefined;
+        if (!spec)
+            throw new Error(`Unexpected argument ${own[i]}; pass secrets as --env NAME[=ref].`);
+        const eq = spec.indexOf("=");
+        const name = eq < 0 ? spec : spec.slice(0, eq);
+        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name))
+            throw new Error(`${name || "(empty)"} is not an environment variable name.`);
+        env.push([name, eq < 0 ? `secret://${name}` : spec.slice(eq + 1)]);
+    }
+    if (!env.length)
+        throw new Error("Name at least one secret: --env NAME.");
+    return { env, command: args.slice(split + 1) };
+}
 export async function resolveSecret(value, appDir) {
     return new SecretVault(appDir).resolve(value);
 }

package/dist/server.js

@@ -171,7 +171,7 @@ import { discoverGithubRepos, listGithubUserRepos } from "./github-repos.js";
 import { loadGitHubAppConfigs, orderAppsForOwner, listGitHubApps, removeGitHubApp, upsertGitHubApp, privateKeyIdFor, } from "./github-apps.js";
 import { buildAppManifest, convertManifest, renderManifestForm } from "./github-app-manifest.js";
 import { encryptGithubAppEnvelope, decryptGithubAppEnvelope, readLocalGithubAppVaultKey, writeLocalGithubAppVaultKey, forgetLocalGithubAppVaultKey, mintLocalGithubAppVaultKey, } from "./github-app-vault.js";
-import { redactSecrets } from "./redact.js";
+import { redactSecrets, registerSecretValue } from "./redact.js";
 import { getSttConfig, isSttProvider, removeSttKey, setSttKey, setSttProvider, transcribeAudio, MAX_AUDIO_BYTES, } from "./stt.js";
 import { synthesizeOpenAiSpeech } from "./tts.js";
 import { seal, open } from "./e2e.js";
@@ -423,7 +423,18 @@ setSessionTokenSigner(sessionTokens.sign);
 // clarifying question across sessions; the guardian interceptor below raises
 // them, and session.question(.resolved) is broadcast from its listeners.
 const questionManager = new QuestionManager();
-const agentQuestions = new AgentQuestions(questionManager);
+// A secret the user types into a `bivy ask --secret` card goes to the node
+// vault; the agent gets its secret:// reference. Vault values are masked in
+// every persisted transcript write (redact.ts), including ones stored before.
+const agentQuestions = new AgentQuestions(questionManager, Date.now, (name, value, description) => {
+    new SecretVault(appDir).setLocal(name, value, description);
+    registerSecretValue(value);
+});
+try {
+    for (const value of new SecretVault(appDir).localValues())
+        registerSecretValue(value);
+}
+catch { }
 // `bivy automation apply` from an agent: an approval request like any other, so
 // the node's approval mode decides whether the user is asked ("never" applies
 // at once; autonomous asks, as for deploys). Either way the result lands in the

package/dist/session/agent-questions.js

@@ -4,6 +4,10 @@ import { randomUUID } from "node:crypto";
 export const MAX_ASK_TIMEOUT_MS = 24 * 60 * 60 * 1000;
 const KEEP_SETTLED_MS = 24 * 60 * 60 * 1000;
 const KEEP_MAX = 200;
+/** Secret names are env-var shaped, so a request can never overwrite one of the
+ *  node's own dotted vault ids (github.repo-token, integration.<id>.api-key, …). */
+const SECRET_NAME = /^[A-Za-z][A-Za-z0-9_]{0,63}$/;
+export const secretRef = (name) => `secret://${name}`;
 /** Validates `bivy ask` input: 1–4 questions, each with text, a short header and
  *  none (a free-text answer) or 2–8 options. Returns an error message, or the questions. */
 export function askQuestionsFrom(value) {
@@ -23,6 +27,19 @@ export function askQuestionsFrom(value) {
             return "Each option needs a label (up to 200 characters).";
         if (new Set(labels).size !== labels.length)
             return "Options must be different.";
+        const secret = raw.secret;
+        if (secret !== undefined) {
+            const name = typeof secret?.name === "string" ? secret.name.trim() : "";
+            if (!SECRET_NAME.test(name))
+                return "A secret name is a letter, then letters, digits or underscores (up to 64), like STRIPE_API_KEY.";
+            if (labels.length)
+                return "A secret question takes no options.";
+            const url = typeof secret.url === "string" ? secret.url.trim() : "";
+            if (url && !/^https:\/\/\S+$/.test(url))
+                return "The secret's link must be an https:// URL.";
+            out.push({ question, header: typeof raw.header === "string" && raw.header.trim() ? header : "Secret", options: [], secret: { name, ...(url ? { url } : {}) } });
+            continue;
+        }
         out.push({ question, header, options: labels.map((label) => ({ label })), ...(raw.multiSelect === true ? { multiSelect: true } : {}) });
     }
     if (new Set(out.map((q) => q.question)).size !== out.length)
@@ -32,14 +49,18 @@ export function askQuestionsFrom(value) {
 export class AgentQuestions {
     questions;
     now;
+    storeSecret;
     results = new Map();
     waiters = new Map();
     /** How each of our questions settled. QuestionManager reports it to onResolved
      *  listeners synchronously, before the request's promise callbacks run. */
     settled = new Map();
-    constructor(questions, now = Date.now) {
+    constructor(questions, now = Date.now, 
+    /** Keeps a secret answer; the agent only ever sees its reference. */
+    storeSecret = () => { throw new Error("No secret store on this node."); }) {
         this.questions = questions;
         this.now = now;
+        this.storeSecret = storeSecret;
         questions.onResolved((request) => { if (this.results.has(request.id))
             this.settled.set(request.id, request.status); });
     }
@@ -54,7 +75,7 @@ export class AgentQuestions {
             this.settled.delete(id);
             result.status = answer.behavior === "completed" ? "answered" : status === "expired" ? "expired" : "dismissed";
             if (answer.behavior === "completed")
-                result.answers = answer.answers;
+                result.answers = this.keepSecrets(items, answer.answers);
             result.settledAt = this.now();
             for (const wake of this.waiters.get(id) ?? [])
                 wake();
@@ -62,6 +83,25 @@ export class AgentQuestions {
         });
         return this.view(result);
     }
+    /** Moves secret answers into the store, leaving their references in their place.
+     *  An empty secret, or one the store refuses, reads back as no answer. */
+    keepSecrets(items, answers) {
+        const out = { ...answers };
+        for (const item of items) {
+            if (!item.secret)
+                continue;
+            const value = out[item.question] ?? "";
+            out[item.question] = "";
+            if (!value.trim())
+                continue;
+            try {
+                this.storeSecret(item.secret.name, value.trim(), item.question);
+                out[item.question] = secretRef(item.secret.name);
+            }
+            catch { /* left empty: the agent sees no answer and can ask again */ }
+        }
+        return out;
+    }
     get(sessionId, id) {
         const result = this.results.get(id);
         return result && result.sessionId === sessionId ? this.view(result) : undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bivy/bivy",
-  "version": "0.21.2-staging.10",
+  "version": "0.21.2-staging.11",
   "type": "module",
   "license": "AGPL-3.0-only",
   "description": "Run coding agents on machines you own. Open-source, self-hostable agent workspace.",