@agent-native/core 0.149.1 → 0.149.3

package/dist/server/onboarding-html.js

@@ -2965,6 +2965,7 @@ ${signInJourneyInlineScript()}
     }
     function __anFinishOAuthExchange(ret, flowId, sessionToken) {
       __anGoogleSignInInFlight = false;
+      __anMagicLinkInFlight = false;
       if (__anIsBuilderPreview()) {
         if (sessionToken) {
           __anSetOAuthDebug('OAuth exchange redeemed; applying session bridge to embedded app', flowId);
@@ -3220,6 +3221,7 @@ ${identitySsoScript}
     var __anOAuthPollTimer = null;
     var __anOAuthPollCount = 0;
     var __anGoogleSignInInFlight = false;
+    var __anMagicLinkInFlight = false;
     var __anGoogleRecoverBound = false;
     function __anNewOAuthFlowId() {
       try {
@@ -3253,15 +3255,26 @@ ${identitySsoScript}
         if (showDebugOverlay) debug.classList.add('show');
       }
     }
-    function __anShowOAuthError(err, btn, message) {
+    function __anStopOAuthExchangePolling() {
       if (__anOAuthPollTimer) {
         clearInterval(__anOAuthPollTimer);
         __anOAuthPollTimer = null;
       }
+    }
+    function __anShowAuthExchangeError(err, btn, message, kind) {
+      __anStopOAuthExchangePolling();
       err.textContent = message;
-      err.classList.add('show');
+      err.classList.add('show', 'error');
       btn.disabled = false;
-      __anGoogleSignInInFlight = false;
+      if (kind === 'magic-link') {
+        __anMagicLinkInFlight = false;
+        showMagicLinkForm();
+      } else {
+        __anGoogleSignInInFlight = false;
+      }
+    }
+    function __anShowOAuthError(err, btn, message) {
+      __anShowAuthExchangeError(err, btn, message, 'google');
     }
     function __anRecoverGoogleSignInAfterReturn() {
       // The user left for the Google sign-in window and came back. If the flow
@@ -3311,14 +3324,17 @@ ${identitySsoScript}
         __anShowOAuthError(err, btn, __anT('failedToConnect'));
       }
     }
-    function __anWaitForOAuthExchange(flowId, ret, btn, err) {
+    function __anWaitForOAuthExchange(flowId, ret, btn, err, kind, verifier) {
       var started = Date.now();
       var timeoutMs = 5 * 60 * 1000;
+      var isMagicLink = kind === 'magic-link';
       __anOAuthPollCount = 0;
       async function check() {
         __anOAuthPollCount++;
         try {
-          var res = await fetch(__anPath('/_agent-native/auth/desktop-exchange') + '?flow_id=' + encodeURIComponent(flowId), { credentials: 'include' });
+          var exchangeParams = '?flow_id=' + encodeURIComponent(flowId);
+          if (verifier) exchangeParams += '&verifier=' + encodeURIComponent(verifier);
+          var res = await fetch(__anPath('/_agent-native/auth/desktop-exchange') + exchangeParams, { credentials: 'include' });
           var data = await res.json().catch(function() { return {}; });
           if (data && (data.email || data.token)) {
             if (__anOAuthPollTimer) clearInterval(__anOAuthPollTimer);
@@ -3328,7 +3344,12 @@ ${identitySsoScript}
           }
           if (data && data.error) {
             __anSetOAuthDebug('OAuth exchange returned an error: ' + (data.message || data.error), flowId);
-            __anShowOAuthError(err, btn, __anAuthErrorText(data, __anT('googleNotConfigured')));
+            __anShowAuthExchangeError(
+              err,
+              btn,
+              __anAuthErrorText(data, isMagicLink ? __anT('magicLinkFailed') : __anT('googleNotConfigured')),
+              isMagicLink ? 'magic-link' : 'google',
+            );
             return;
           }
           if (data && data.pending && (__anOAuthPollCount === 1 || __anOAuthPollCount % 5 === 0)) {
@@ -3340,10 +3361,17 @@ ${identitySsoScript}
           }
         }
         if (Date.now() - started > timeoutMs) {
-          __anShowOAuthError(err, btn, __anT('googleNeverFinished') + ' Flow ' + __anFlowDebugId(flowId) + '.');
+          __anShowAuthExchangeError(
+            err,
+            btn,
+            isMagicLink
+              ? __anT('magicLinkFailed')
+              : __anT('googleNeverFinished') + ' Flow ' + __anFlowDebugId(flowId) + '.',
+            isMagicLink ? 'magic-link' : 'google',
+          );
         }
       }
-      if (__anOAuthPollTimer) clearInterval(__anOAuthPollTimer);
+      __anStopOAuthExchangePolling();
       __anOAuthPollTimer = setInterval(check, 1000);
       setTimeout(check, 500);
     }
@@ -3479,6 +3507,8 @@ ${googleOnly
       __anSetAuthView('magicLinkSent');
     }
     function showMagicLinkForm() {
+      __anStopOAuthExchangePolling();
+      __anMagicLinkInFlight = false;
       var form = document.getElementById('magic-link-form');
       if (!form) return;
       hideMagicLinkSuccess();
@@ -3851,6 +3881,7 @@ ${googleOnly
     var msg = document.getElementById('m-msg');
     var emailInput = document.getElementById('m-email');
     var email = __anNormalizeAuthEmail(emailInput && emailInput.value);
+    var isDesktopMagicLink = __anIsAgentNativeDesktop();
     msg.classList.remove('show', 'error', 'success');
     if (!__anIsValidAuthEmail(email)) {
       __anShowEmailValidationError(emailInput, msg);
@@ -3858,12 +3889,18 @@ ${googleOnly
     }
     var originalLabel = btn.textContent;
     btn.disabled = true;
+    __anMagicLinkInFlight = isDesktopMagicLink;
     btn.textContent = __anT('sending');
     try {
       var res = await fetch(__anPath('/_agent-native/auth/magic-link'), {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ email: email, callbackURL: __anResumeHref() }),
+        body: JSON.stringify({
+          email: email,
+          callbackURL: isDesktopMagicLink
+            ? __anPath('/_agent-native/auth/magic-link/desktop-callback')
+            : __anResumeHref(),
+        }),
       });
       var data = await res.json().catch(function(error) {
         console.warn('[auth] Could not parse magic-link response', error);
@@ -3873,13 +3910,23 @@ ${googleOnly
         btn.disabled = false;
         btn.textContent = originalLabel;
         showMagicLinkSuccess(email);
+        if (isDesktopMagicLink) {
+          var magicFlowId = data && typeof data.flowId === 'string' ? data.flowId : '';
+          var magicVerifier = data && typeof data.verifier === 'string' ? data.verifier : '';
+          if (!magicFlowId || !magicVerifier) {
+            throw new Error('The sign-in flow was not initialized.');
+          }
+          __anWaitForOAuthExchange(magicFlowId, __anResumeHref(), btn, msg, 'magic-link', magicVerifier);
+        }
         return;
       }
+      __anMagicLinkInFlight = false;
       msg.textContent = __anAuthErrorText(data, __anT('magicLinkFailed'));
       msg.classList.add('show', 'error');
       btn.disabled = false;
       btn.textContent = originalLabel;
     } catch (err) {
+      __anMagicLinkInFlight = false;
       msg.textContent = __anT('networkErrorDashRetry');
       msg.classList.add('show', 'error');
       btn.disabled = false;

package/dist/server/prompts/framework-core-compact.d.ts

@@ -2,7 +2,7 @@
  * Compact framework core instructions (FRAMEWORK_CORE_COMPACT).
  * Used in lazy-context mode (lazyContext: true — the default).
  *
- * Shares rules 8–9, 12–13 with the full variant via shared-rules.ts.
+ * Shares rules 8–9, 13–15 with the full variant via shared-rules.ts.
  * The compact version omits:
  *   - Verbose "Extended Capabilities" section (agent uses get-framework-context)
  *   - Detailed "Parallel Tool Calls" prose (replaced with one-liner)
@@ -18,6 +18,11 @@ export interface FrameworkCoreCompactPromptOptions {
      *  a group's tool by name is gated on this — a prompt naming an absent tool
      *  makes the model call it, fail, and often report the capability as missing. */
     disabledFrameworkGroups?: ReadonlySet<FrameworkToolGroup>;
+    /** True for surfaces whose agent really can edit source (dev mode). This core
+     *  prompt is appended to both the production and development prompts, so the
+     *  Builder-handoff sentence must be dropped here or it contradicts the dev
+     *  prompt's own "you have full local access". */
+    canEditSource?: boolean;
 }
 /**
  * Build the compact FRAMEWORK_CORE prompt string.

package/dist/server/prompts/framework-core-compact.js

@@ -2,7 +2,7 @@
  * Compact framework core instructions (FRAMEWORK_CORE_COMPACT).
  * Used in lazy-context mode (lazyContext: true — the default).
  *
- * Shares rules 8–9, 12–13 with the full variant via shared-rules.ts.
+ * Shares rules 8–9, 13–15 with the full variant via shared-rules.ts.
  * The compact version omits:
  *   - Verbose "Extended Capabilities" section (agent uses get-framework-context)
  *   - Detailed "Parallel Tool Calls" prose (replaced with one-liner)
@@ -10,7 +10,7 @@
  */
 import { frameworkGroupEnabled, } from "../../framework-tools.js";
 import { hasDatabaseReadTools, hasDatabaseWriteTools, } from "../../scripts/db/tool-mode.js";
-import { sharedRule8, SHARED_RULE_9, sharedRule14, SHARED_RULE_15, SHARED_RULE_AGENT_WARNINGS, } from "./shared-rules.js";
+import { sharedRule8, SHARED_RULE_9, sharedRule13, SHARED_RULE_14, SHARED_RULE_15, } from "./shared-rules.js";
 /**
  * Build the compact FRAMEWORK_CORE prompt string.
  *
@@ -54,10 +54,13 @@ For generated media, prefer this app's native generation action; otherwise use \
     const actionSurface = options?.extensionTools === true
         ? "registered actions, extensions, and MCP tools"
         : "registered actions and MCP tools";
+    const codeHandoffClause = options?.canEditSource === true
+        ? ""
+        : ", and hand code changes to Builder — you don't edit source yourself";
     return `
 ### How You Work
 
-Bring a senior engineer's judgment, arrived at through attention not premature certainty: understand the app's data and actions before acting, prefer existing actions and patterns over improvising, and keep work scoped. You act through ${actionSurface}, and hand code changes to Builder — you don't edit source yourself.
+Bring a senior engineer's judgment, arrived at through attention not premature certainty: understand the app's data and actions before acting, prefer existing actions and patterns over improvising, and keep work scoped. You act through ${actionSurface}${codeHandoffClause}.
 
 **Autonomy:** handle the task end to end this turn when feasible — take the actions, confirm they worked, report the outcome. Don't stop at a proposal or half-finished work; work through blockers yourself before handing back. In Plan mode, propose only.
 
@@ -76,18 +79,18 @@ Bring a senior engineer's judgment, arrived at through attention not premature c
 7. **Security** — ${securityRule}
 ${sharedRule8(examples, options)}
 ${SHARED_RULE_9}
-**Native widgets** — For table/chart/graph/report requests, prefer actions labeled \`Native chat widget\`; use \`render-data-widget\` for already-summarized data (≤50 rows) instead of markdown tables. Above that, give the total plus the top rows — never retype a full result set as widget arguments. Deliver files in chat, never just a path.
-10. **Your tool list is not the whole surface** — Most app actions and connected MCP tools load on demand, so search the live registry with \`tool-search\` before concluding a capability doesn't exist.
-11. **Relative dates use runtime context** — The \`<runtime-context>\` block gives the authoritative current date/time. Resolve "today", "yesterday", "last week", and similar phrases to explicit calendar dates before querying data or creating artifacts.
-${sharedRule14(options)}
+10. **Native widgets** — For table/chart/graph/report requests, prefer actions labeled \`Native chat widget\`; use \`render-data-widget\` for already-summarized data (≤50 rows) instead of markdown tables. Above that, give the total plus the top rows — never retype a full result set as widget arguments.
+11. **Downloadable files** — Deliver files in chat, never just a path.
+12. **Your tool list is not the whole surface** — Most app actions and connected MCP tools load on demand, so search the live registry with \`tool-search\` before concluding a capability doesn't exist.
+${sharedRule13(options)}
+${SHARED_RULE_14}
 ${SHARED_RULE_15}
-${SHARED_RULE_AGENT_WARNINGS}
 
 ${resourcesSection}
 ### Extended Capabilities
 
 You also have tools for ${extendedCapabilitiesList}. Call \`get-framework-context\` with the matching key — it lists its own topics — for full instructions when needed.
 
-**Agent teams:** default to doing the work yourself. Delegate ONE sub-agent (\`agent-teams\` action "spawn") for self-contained heavy work; fan out to several only for genuinely independent units; never parallelize tightly-coupled work; cap fan-out around 3. Treat "background agent", "sub-agent", "parallel", "batch", "kick off", "run the rest", and "queued items" as delegation intent when the user is asking you to start or continue independent work items. After \`spawn\`, say the task started/running, not completed; use \`status\`/\`read-result\` before claiming the delegated work is done. Give each sub-agent a self-contained brief (objective, the specific context/IDs it needs, output format, boundaries) — it can't see this thread — then read all results and synthesize one integrated answer. Full details: \`get-framework-context\` key \`agent-teams\`.
+**Agent teams:** default to doing the work yourself; \`agent-teams\` can delegate to background sub-agents. Treat "background agent", "sub-agent", "parallel", "batch", "kick off", "run the rest", and "queued items" as delegation intent when the user is asking you to start or continue independent work items. Read \`get-framework-context\` key \`agent-teams\` before spawning — it carries the fan-out limits, briefing contract, and why a spawn is not a completion.
 ${callAgentSection}`;
 }

package/dist/server/prompts/framework-core.d.ts

@@ -2,7 +2,7 @@
  * Full framework core instructions (FRAMEWORK_CORE).
  * Used in the verbose prompt variant (lazyContext: false).
  *
- * Shared rules (8-9, 12-13) are imported from shared-rules.ts so the
+ * Shared rules (8-9, 13-15) are imported from shared-rules.ts so the
  * compact variant uses the same text and the two can never drift.
  */
 import { type FrameworkToolGroup } from "../../framework-tools.js";
@@ -15,6 +15,11 @@ export interface FrameworkCorePromptOptions {
      *  a group's tool by name is gated on this — a prompt naming an absent tool
      *  makes the model call it, fail, and often report the capability as missing. */
     disabledFrameworkGroups?: ReadonlySet<FrameworkToolGroup>;
+    /** True for surfaces whose agent really can edit source (dev mode). This core
+     *  prompt is appended to both the production and development prompts, so the
+     *  Builder-handoff sentence must be dropped here or it contradicts the dev
+     *  prompt's own "you have full local access". */
+    canEditSource?: boolean;
 }
 /**
  * Build the full FRAMEWORK_CORE prompt string.

package/dist/server/prompts/framework-core.js

@@ -2,12 +2,12 @@
  * Full framework core instructions (FRAMEWORK_CORE).
  * Used in the verbose prompt variant (lazyContext: false).
  *
- * Shared rules (8-9, 12-13) are imported from shared-rules.ts so the
+ * Shared rules (8-9, 13-15) are imported from shared-rules.ts so the
  * compact variant uses the same text and the two can never drift.
  */
 import { frameworkGroupEnabled, } from "../../framework-tools.js";
 import { hasDatabaseReadTools, hasDatabaseWriteTools, } from "../../scripts/db/tool-mode.js";
-import { sharedRule8, SHARED_RULE_9, sharedRule14, SHARED_RULE_15, SHARED_RULE_AGENT_WARNINGS, } from "./shared-rules.js";
+import { sharedRule8, SHARED_RULE_9, sharedRule13, SHARED_RULE_14, SHARED_RULE_15, } from "./shared-rules.js";
 /**
  * Build the full FRAMEWORK_CORE prompt string.
  *
@@ -41,6 +41,9 @@ export function buildFrameworkCore(examples, options) {
     const actionSurface = options?.extensionTools === true
         ? "this app's registered actions, extensions, and connected MCP tools"
         : "this app's registered actions and connected MCP tools";
+    const codeHandoffClause = options?.canEditSource === true
+        ? ""
+        : " — and you hand code changes to Builder rather than editing source yourself";
     const groupOn = (group) => frameworkGroupEnabled(options?.disabledFrameworkGroups, group);
     const resourcesSection = groupOn("resources")
         ? `### Resources
@@ -73,7 +76,7 @@ Workspace resources are user-facing by default. If you need temporary working fi
 
 You bring a senior engineer's judgment to this app, but you let it arrive through attention rather than premature certainty. Understand the app's data and actions before you act — read the current screen, the schema, and what tools exist — and let the shape of the existing system steer you. Prefer the app's own actions and established patterns over improvising a new approach. Keep your work scoped to what the request implies; don't redesign things that already work.
 
-You act through ${actionSurface} — and you hand code changes to Builder rather than editing source yourself. Within that surface, you own the task end to end.
+You act through ${actionSurface}${codeHandoffClause}. Within that surface, you own the task end to end.
 
 ### Autonomy And Persistence
 
@@ -102,13 +105,12 @@ ${refreshRule}
 ${securityRule}
 ${sharedRule8(examples, options)}
 ${SHARED_RULE_9}
-**Native chat widgets** — When an available action says it renders a native widget such as \`data-table\`, \`data-chart\`, or \`data-insights\`, call that action for user requests asking for a table, chart, graph, trend, report, or inline data view. If no domain action exists and you already have compact real data, call \`render-data-widget\`. Let the chat renderer show the action result; do not recreate the same rows as a markdown table or invent chart data in prose. Add only a short human summary or next-step link around the widget. Widget rows are tool arguments you emit one token at a time, so this path is for already-summarized data only — at most 50 table rows and 200 chart points. When the result set is larger, aggregate it first or report the total and show only the top rows; never re-serialize a full query result into widget arguments.
-**Downloadable files** — When the user asks you to create or export a file, deliver it in the same chat turn. For compact tabular results, prefer \`render-data-widget\` so the user gets the native Download CSV action without a second stored copy. For a complete or durable file written through \`workspaceWrite\`, use a normal non-\`scratch/\` path and then call \`show-workspace-file\` with that path so chat renders a direct download card. Never finish by giving filesystem paths or telling the user to navigate elsewhere to find the file.
-10. **Your tool list is not the whole surface** — Most app actions and connected MCP tools load on demand, so search the live registry with \`tool-search\` before concluding a capability doesn't exist.
-11. **Relative dates use runtime context** — The \`<runtime-context>\` block gives the authoritative current date/time. Resolve "today", "yesterday", "last week", and similar phrases to explicit calendar dates before querying data or creating artifacts. When answering factual questions, include the exact date or date range you used.
-${sharedRule14(options)}
+10. **Native chat widgets** — When an available action says it renders a native widget such as \`data-table\`, \`data-chart\`, or \`data-insights\`, call that action for user requests asking for a table, chart, graph, trend, report, or inline data view. If no domain action exists and you already have compact real data, call \`render-data-widget\`. Let the chat renderer show the action result; do not recreate the same rows as a markdown table or invent chart data in prose. Add only a short human summary or next-step link around the widget. Widget rows are tool arguments you emit one token at a time, so this path is for already-summarized data only — at most 50 table rows and 200 chart points. When the result set is larger, aggregate it first or report the total and show only the top rows; never re-serialize a full query result into widget arguments.
+11. **Downloadable files** — When the user asks you to create or export a file, deliver it in the same chat turn. For compact tabular results, prefer \`render-data-widget\` so the user gets the native Download CSV action without a second stored copy. For a complete or durable file written through \`workspaceWrite\`, use a normal non-\`scratch/\` path and then call \`show-workspace-file\` with that path so chat renders a direct download card. Never finish by giving filesystem paths or telling the user to navigate elsewhere to find the file.
+12. **Your tool list is not the whole surface** — Most app actions and connected MCP tools load on demand, so search the live registry with \`tool-search\` before concluding a capability doesn't exist.
+${sharedRule13(options)}
+${SHARED_RULE_14}
 ${SHARED_RULE_15}
-${SHARED_RULE_AGENT_WARNINGS}
 
 ### Parallel Tool Calls
 

package/dist/server/prompts/index.d.ts

@@ -4,5 +4,5 @@
  */
 export { buildFrameworkCore } from "./framework-core.js";
 export { buildFrameworkCoreCompact } from "./framework-core-compact.js";
-export { sharedRule8, SHARED_RULE_9, sharedRule14, SHARED_RULE_15, type PromptExamples, type SharedRuleOptions, } from "./shared-rules.js";
+export { sharedRule8, SHARED_RULE_9, sharedRule13, SHARED_RULE_14, SHARED_RULE_15, type PromptExamples, type SharedRuleOptions, } from "./shared-rules.js";
 export { getModelFamilyOverlay } from "./model-overlays.js";

package/dist/server/prompts/index.js

@@ -4,5 +4,5 @@
  */
 export { buildFrameworkCore } from "./framework-core.js";
 export { buildFrameworkCoreCompact } from "./framework-core-compact.js";
-export { sharedRule8, SHARED_RULE_9, sharedRule14, SHARED_RULE_15, } from "./shared-rules.js";
+export { sharedRule8, SHARED_RULE_9, sharedRule13, SHARED_RULE_14, SHARED_RULE_15, } from "./shared-rules.js";
 export { getModelFamilyOverlay } from "./model-overlays.js";

package/dist/server/prompts/shared-rules.d.ts

@@ -4,8 +4,13 @@
  * identical between them.
  *
  * Rules 8–9 (db-* tools; the consolidated no-fabrication / verify / recover
- * rule) and 12–13 (planning discipline; collaborate through uncertainty) are
- * reproduced verbatim in both prompts — keep them here.
+ * rule) and 13–15 (planning discipline; collaborate through uncertainty;
+ * relay agent warnings) are reproduced verbatim in both prompts — keep them
+ * here.
+ *
+ * Each identifier carries the number its text emits. Renumbering a rule means
+ * renaming its identifier in the same change; the two drifted apart once
+ * already and left people editing a different rule than the name said.
  */
 import { type FrameworkToolGroup } from "../../framework-tools.js";
 import { type DatabaseToolsOption } from "../../scripts/db/tool-mode.js";
@@ -30,7 +35,7 @@ export interface SharedRuleOptions {
 export declare function sharedRule8(examples?: PromptExamples, options?: SharedRuleOptions): string;
 /**
  * Rule 9 — Consolidated anti-fabrication rule (shared). Formerly three
- * separate rules (fabricating facts, fabricating success, and Rule 11's
+ * separate rules (fabricating facts, fabricating success, and a since-removed
  * "verify before you claim done") — merged because they are one behavior,
  * honesty about what actually happened, viewed from three angles. Keep all
  * three sub-behaviors distinct; do not re-split them back into separate
@@ -38,8 +43,8 @@ export declare function sharedRule8(examples?: PromptExamples, options?: SharedR
  */
 export declare const SHARED_RULE_9 = "9. **Never fabricate \u2014 verify results, report failures honestly, and recover instead of giving up.**\n   - **Never fabricate factual claims or records** \u2014 do not invent numbers, metrics, records, query results, URLs, citations, source attributions, customer names, dates, or success rates. This applies inside generated artifacts too: decks, documents, reports, dashboards, Slack/email replies, and charts. Only state factual numbers/claims the user provided or you retrieved with an action/tool. If a data source is unavailable, returns no rows, is missing credentials, or has a connection error, say so clearly; do not create placeholder rows or fetch unrelated providers to look complete unless the user explicitly asked you to import/sync/backfill. Prefer qualitative wording, placeholders like `[metric TBD]`, or clearly labeled draft assumptions over plausible-looking facts \u2014 presenting made-up data as real is worse than admitting the limitation.\n   - **Never fabricate success from tool errors** \u2014 when a tool call returns an error (marked `isError: true`, contains \"Command failed\", \"Error:\", or non-zero exit output), the operation FAILED; do not synthesize a success narrative or describe what it \"would have\" produced. Report the failure verbatim (this applies especially to `bash(command=\"pnpm action ...\")` calls). Before telling the user a mutating action (create/update/delete/send/publish) is done, confirm it actually landed \u2014 check the tool result, or read the refreshed `<current-screen>` / re-query the data; having *called* an action is not proof it worked. If a result is ambiguous, check rather than assume.\n   - **Recover instead of giving up** \u2014 treat a failure or ambiguous result as a signal to retry the obvious fix, try an alternate tool or approach, or clearly hand the blocker back with what you tried; never silently give up, and never paper over a failure by claiming success.";
 /**
- * Rule 12 (name retained as `sharedRule14` for import stability) — Planning and
- * progress. Deliberately states only when to open a progress run; the
+ * Rule 13 — Planning and progress. Deliberately states only when to open a
+ * progress run; the
  * start/update/complete discipline lives in `manage-progress`'s own tool
  * description (packages/core/src/progress/actions.ts). Re-adding the mechanics
  * here means every turn pays for guidance the model only needs once it has the
@@ -49,10 +54,11 @@ export declare const SHARED_RULE_9 = "9. **Never fabricate \u2014 verify results
  * the rule never names a tool the request does not carry. The planning
  * discipline itself still applies — only the tool call goes away.
  */
-export declare function sharedRule14(options?: SharedRuleOptions): string;
+export declare function sharedRule13(options?: SharedRuleOptions): string;
+/** Rule 14 — Collaborate through uncertainty (better-specified version). */
+export declare const SHARED_RULE_14 = "14. **Collaborate through uncertainty** \u2014 If a task stalls, errors, or depends on setup the user may not know about, shift into builder-coach mode instead of repeating the same attempt. State what you verified, name the most likely next checks, and proactively try common unblockers you can inspect (for example prompt size, missing environment variables, unavailable connections, current screen state, or tool choice). When you finish a meaningful step, offer one or two concrete next steps or improvements so non-technical users can keep iterating. When you are genuinely blocked on a decision you cannot resolve from context \u2014 and a wrong guess would be costly \u2014 use `ask-question` to present the choice instead of guessing; otherwise prefer a reasonable assumption and keep moving.";
 /**
- * Rule 14 — Relay agent warnings. Named for what it is rather than its number,
- * since the `SHARED_RULE_14`/`15` names above no longer match theirs.
+ * Rule 15 — Relay agent warnings.
  *
  * Load-bearing: a tool result can carry an `<agent-warning>` block raised deep
  * inside an action (see `agent/action-warnings.ts`) for an operation the caller
@@ -60,6 +66,4 @@ export declare function sharedRule14(options?: SharedRuleOptions): string;
  * Without this rule the model summarizes past the block and reports success,
  * which is the incident this channel was built to prevent.
  */
-export declare const SHARED_RULE_AGENT_WARNINGS = "14. **Relay `<agent-warning>` blocks before you report success** \u2014 A tool result may contain one or more `<agent-warning severity=\"...\" code=\"...\">` blocks. These are not part of the action's return value: they are raised by the operation the tool performed and they are the only place that consequence is reported. Never drop, bury, or paraphrase one away. On `severity=\"critical\"`, stop and tell the user what happened in your own words BEFORE any success summary \u2014 lead with the consequence and the remedy the block names, do not continue a multi-step plan whose later steps depend on the affected state, and if the operation is reversible say so and offer to reverse it. On `severity=\"advisory\"`, mention it in your final response. If a warning says something may already be broken, say that plainly; \"done\" is not an honest answer to a turn that raised a critical warning.";
-/** Rule 13 (const name retained as SHARED_RULE_15 for import stability) — Collaborate through uncertainty (better-specified version). */
-export declare const SHARED_RULE_15 = "13. **Collaborate through uncertainty** \u2014 If a task stalls, errors, or depends on setup the user may not know about, shift into builder-coach mode instead of repeating the same attempt. State what you verified, name the most likely next checks, and proactively try common unblockers you can inspect (for example prompt size, missing environment variables, unavailable connections, current screen state, or tool choice). When you finish a meaningful step, offer one or two concrete next steps or improvements so non-technical users can keep iterating. When you are genuinely blocked on a decision you cannot resolve from context \u2014 and a wrong guess would be costly \u2014 use `ask-question` to present the choice instead of guessing; otherwise prefer a reasonable assumption and keep moving.";
+export declare const SHARED_RULE_15 = "15. **Relay `<agent-warning>` blocks before you report success** \u2014 A tool result may contain one or more `<agent-warning severity=\"...\" code=\"...\">` blocks. These are not part of the action's return value: they are raised by the operation the tool performed and they are the only place that consequence is reported. Never drop, bury, or paraphrase one away. On `severity=\"critical\"`, stop and tell the user what happened in your own words BEFORE any success summary \u2014 lead with the consequence and the remedy the block names, do not continue a multi-step plan whose later steps depend on the affected state, and if the operation is reversible say so and offer to reverse it. On `severity=\"advisory\"`, mention it in your final response. If a warning says something may already be broken, say that plainly; \"done\" is not an honest answer to a turn that raised a critical warning.";

package/dist/server/prompts/shared-rules.js

@@ -4,8 +4,13 @@
  * identical between them.
  *
  * Rules 8–9 (db-* tools; the consolidated no-fabrication / verify / recover
- * rule) and 12–13 (planning discipline; collaborate through uncertainty) are
- * reproduced verbatim in both prompts — keep them here.
+ * rule) and 13–15 (planning discipline; collaborate through uncertainty;
+ * relay agent warnings) are reproduced verbatim in both prompts — keep them
+ * here.
+ *
+ * Each identifier carries the number its text emits. Renumbering a rule means
+ * renaming its identifier in the same change; the two drifted apart once
+ * already and left people editing a different rule than the name said.
  */
 import { frameworkGroupEnabled, } from "../../framework-tools.js";
 import { normalizeDatabaseToolsMode, } from "../../scripts/db/tool-mode.js";
@@ -54,7 +59,7 @@ export function sharedRule8(examples, options) {
 }
 /**
  * Rule 9 — Consolidated anti-fabrication rule (shared). Formerly three
- * separate rules (fabricating facts, fabricating success, and Rule 11's
+ * separate rules (fabricating facts, fabricating success, and a since-removed
  * "verify before you claim done") — merged because they are one behavior,
  * honesty about what actually happened, viewed from three angles. Keep all
  * three sub-behaviors distinct; do not re-split them back into separate
@@ -65,8 +70,8 @@ export const SHARED_RULE_9 = `9. **Never fabricate — verify results, report fa
    - **Never fabricate success from tool errors** — when a tool call returns an error (marked \`isError: true\`, contains "Command failed", "Error:", or non-zero exit output), the operation FAILED; do not synthesize a success narrative or describe what it "would have" produced. Report the failure verbatim (this applies especially to \`bash(command="pnpm action ...")\` calls). Before telling the user a mutating action (create/update/delete/send/publish) is done, confirm it actually landed — check the tool result, or read the refreshed \`<current-screen>\` / re-query the data; having *called* an action is not proof it worked. If a result is ambiguous, check rather than assume.
    - **Recover instead of giving up** — treat a failure or ambiguous result as a signal to retry the obvious fix, try an alternate tool or approach, or clearly hand the blocker back with what you tried; never silently give up, and never paper over a failure by claiming success.`;
 /**
- * Rule 12 (name retained as `sharedRule14` for import stability) — Planning and
- * progress. Deliberately states only when to open a progress run; the
+ * Rule 13 — Planning and progress. Deliberately states only when to open a
+ * progress run; the
  * start/update/complete discipline lives in `manage-progress`'s own tool
  * description (packages/core/src/progress/actions.ts). Re-adding the mechanics
  * here means every turn pays for guidance the model only needs once it has the
@@ -76,15 +81,16 @@ export const SHARED_RULE_9 = `9. **Never fabricate — verify results, report fa
  * the rule never names a tool the request does not carry. The planning
  * discipline itself still applies — only the tool call goes away.
  */
-export function sharedRule14(options) {
+export function sharedRule13(options) {
     if (!frameworkGroupEnabled(options?.disabledFrameworkGroups, "automation")) {
-        return `12. **Plan and track multi-step work** — When a task spans several real steps, work through them in order and tell the user where you are as you go rather than only at the end. Skip ceremony for single-action lookups, simple reads, and anything that finishes in one tool call.`;
+        return `13. **Plan and track multi-step work** — When a task spans several real steps, work through them in order and tell the user where you are as you go rather than only at the end. Skip ceremony for single-action lookups, simple reads, and anything that finishes in one tool call.`;
     }
-    return `12. **Plan and track multi-step work** — When a task spans several real steps the user would want to watch, open a \`manage-progress\` run so the work is visible while it's still in flight, and keep it updated as you go rather than after the fact; the tool's own description carries the full discipline. Skip it for single-action lookups, simple reads, and anything that finishes in one tool call — never create single-step plans.`;
+    return `13. **Plan and track multi-step work** — When a task spans several real steps the user would want to watch, open a \`manage-progress\` run so the work is visible while it's still in flight, and keep it updated as you go rather than after the fact; the tool's own description carries the full discipline. Skip it for single-action lookups, simple reads, and anything that finishes in one tool call — never create single-step plans.`;
 }
+/** Rule 14 — Collaborate through uncertainty (better-specified version). */
+export const SHARED_RULE_14 = `14. **Collaborate through uncertainty** — If a task stalls, errors, or depends on setup the user may not know about, shift into builder-coach mode instead of repeating the same attempt. State what you verified, name the most likely next checks, and proactively try common unblockers you can inspect (for example prompt size, missing environment variables, unavailable connections, current screen state, or tool choice). When you finish a meaningful step, offer one or two concrete next steps or improvements so non-technical users can keep iterating. When you are genuinely blocked on a decision you cannot resolve from context — and a wrong guess would be costly — use \`ask-question\` to present the choice instead of guessing; otherwise prefer a reasonable assumption and keep moving.`;
 /**
- * Rule 14 — Relay agent warnings. Named for what it is rather than its number,
- * since the `SHARED_RULE_14`/`15` names above no longer match theirs.
+ * Rule 15 — Relay agent warnings.
  *
  * Load-bearing: a tool result can carry an `<agent-warning>` block raised deep
  * inside an action (see `agent/action-warnings.ts`) for an operation the caller
@@ -92,6 +98,4 @@ export function sharedRule14(options) {
  * Without this rule the model summarizes past the block and reports success,
  * which is the incident this channel was built to prevent.
  */
-export const SHARED_RULE_AGENT_WARNINGS = `14. **Relay \`<agent-warning>\` blocks before you report success** — A tool result may contain one or more \`<agent-warning severity="..." code="...">\` blocks. These are not part of the action's return value: they are raised by the operation the tool performed and they are the only place that consequence is reported. Never drop, bury, or paraphrase one away. On \`severity="critical"\`, stop and tell the user what happened in your own words BEFORE any success summary — lead with the consequence and the remedy the block names, do not continue a multi-step plan whose later steps depend on the affected state, and if the operation is reversible say so and offer to reverse it. On \`severity="advisory"\`, mention it in your final response. If a warning says something may already be broken, say that plainly; "done" is not an honest answer to a turn that raised a critical warning.`;
-/** Rule 13 (const name retained as SHARED_RULE_15 for import stability) — Collaborate through uncertainty (better-specified version). */
-export const SHARED_RULE_15 = `13. **Collaborate through uncertainty** — If a task stalls, errors, or depends on setup the user may not know about, shift into builder-coach mode instead of repeating the same attempt. State what you verified, name the most likely next checks, and proactively try common unblockers you can inspect (for example prompt size, missing environment variables, unavailable connections, current screen state, or tool choice). When you finish a meaningful step, offer one or two concrete next steps or improvements so non-technical users can keep iterating. When you are genuinely blocked on a decision you cannot resolve from context — and a wrong guess would be costly — use \`ask-question\` to present the choice instead of guessing; otherwise prefer a reasonable assumption and keep moving.`;
+export const SHARED_RULE_15 = `15. **Relay \`<agent-warning>\` blocks before you report success** — A tool result may contain one or more \`<agent-warning severity="..." code="...">\` blocks. These are not part of the action's return value: they are raised by the operation the tool performed and they are the only place that consequence is reported. Never drop, bury, or paraphrase one away. On \`severity="critical"\`, stop and tell the user what happened in your own words BEFORE any success summary — lead with the consequence and the remedy the block names, do not continue a multi-step plan whose later steps depend on the affected state, and if the operation is reversible say so and offer to reverse it. On \`severity="advisory"\`, mention it in your final response. If a warning says something may already be broken, say that plainly; "done" is not an honest answer to a turn that raised a critical warning.`;

package/dist/server/realtime-token.d.ts

@@ -26,8 +26,8 @@ export declare function createRealtimeTokenHandler(): import("h3").EventHandlerW
     expiresAt?: undefined;
     ttlSeconds?: undefined;
 } | {
+    error?: undefined;
     token: string;
     expiresAt: string;
     ttlSeconds: number;
-    error?: undefined;
 }>>;

package/dist/server/transcribe-voice.d.ts

@@ -20,6 +20,6 @@ export declare function createTranscribeVoiceHandler(): import("h3").EventHandle
     error: string;
     text?: undefined;
 } | {
-    text: string;
     error?: undefined;
+    text: string;
 }>>;

package/dist/shared/reasoning-effort.d.ts

@@ -1,9 +1,9 @@
 export declare const REASONING_EFFORTS: readonly ["auto", "none", "minimal", "low", "medium", "high", "xhigh", "max"];
 export type ReasoningEffort = (typeof REASONING_EFFORTS)[number];
 /**
- * Shared chat always chooses an explicit reasoning tier. Keep `auto` in the
+ * Shared chat always chooses an explicit effort tier. Keep `auto` in the
  * accepted type only so older persisted selections and external callers can
- * migrate cleanly; new UI and engine defaults resolve it to Medium.
+ * migrate cleanly; new UI and engine defaults resolve it to High.
  */
 export declare const DEFAULT_REASONING_EFFORT: ReasoningEffort;
 export declare const REASONING_EFFORT_LABELS: Record<ReasoningEffort, string>;
@@ -19,22 +19,22 @@ export declare function normalizeReasoningEffortForRequest(model: string | undef
 export declare function reasoningEffortLabel(effort: ReasoningEffort | undefined): string;
 /**
  * Resolve a user-facing selection for a model. Legacy `auto`, missing values,
- * and tiers unsupported by the newly selected model all become Medium.
- * Non-reasoning models still retain Medium in persisted chat state so moving
- * back to a reasoning model has a predictable default; their engines omit the
- * effort through `normalizeReasoningEffortForModel`.
+ * and tiers unsupported by the newly selected model all become High.
+ * Models without effort controls still retain High in persisted chat state so
+ * moving back to an effort-capable model has a predictable default; their
+ * engines omit the effort through `normalizeReasoningEffortForModel`.
  */
 export declare function resolveReasoningEffortSelection(model: string | undefined, effort: ReasoningEffort | undefined): ReasoningEffort;
 export declare function stepDownReasoningEffort(effort: ReasoningEffort | undefined): ReasoningEffort | undefined;
 export declare function isGPTReasoningModel(model: string): boolean;
 /**
  * Anthropic's adaptive-thinking API is only available on the newer Claude
- * model families. Claude Haiku 4.5 is reasoning-capable, but it still
+ * model families. Claude Haiku 4.5 supports effort, but it still
  * requires the legacy manual `budget_tokens` configuration.
  */
 export declare function supportsClaudeAdaptiveThinking(model: string | undefined): boolean;
 /**
- * Map the shared reasoning ladder to Anthropic's manual thinking budgets for
+ * Map the shared effort ladder to Anthropic's manual thinking budgets for
  * models that do not support adaptive thinking (currently Claude Haiku 4.5).
  */
 export declare function anthropicManualThinkingBudget(effort: ReasoningEffort): 1024 | 4096 | 8000 | 16000 | 32000;

package/dist/shared/reasoning-effort.js

@@ -9,11 +9,11 @@ export const REASONING_EFFORTS = [
     "max",
 ];
 /**
- * Shared chat always chooses an explicit reasoning tier. Keep `auto` in the
+ * Shared chat always chooses an explicit effort tier. Keep `auto` in the
  * accepted type only so older persisted selections and external callers can
- * migrate cleanly; new UI and engine defaults resolve it to Medium.
+ * migrate cleanly; new UI and engine defaults resolve it to High.
  */
-export const DEFAULT_REASONING_EFFORT = "medium";
+export const DEFAULT_REASONING_EFFORT = "high";
 export const REASONING_EFFORT_LABELS = {
     auto: "Auto",
     none: "None",
@@ -91,10 +91,10 @@ export function reasoningEffortLabel(effort) {
 }
 /**
  * Resolve a user-facing selection for a model. Legacy `auto`, missing values,
- * and tiers unsupported by the newly selected model all become Medium.
- * Non-reasoning models still retain Medium in persisted chat state so moving
- * back to a reasoning model has a predictable default; their engines omit the
- * effort through `normalizeReasoningEffortForModel`.
+ * and tiers unsupported by the newly selected model all become High.
+ * Models without effort controls still retain High in persisted chat state so
+ * moving back to an effort-capable model has a predictable default; their
+ * engines omit the effort through `normalizeReasoningEffortForModel`.
  */
 export function resolveReasoningEffortSelection(model, effort) {
     const requested = !effort || effort === "auto" ? DEFAULT_REASONING_EFFORT : effort;
@@ -107,7 +107,7 @@ export function resolveReasoningEffortSelection(model, effort) {
  * One tier down from each effort, stopping at "minimal" — legacy `auto`,
  * "none", and "minimal" itself are left unchanged. Used by the
  * empty-final-response retry so a retried turn asks for meaningfully less
- * reasoning instead of repeating the exact request that came back empty.
+ * effort instead of repeating the exact request that came back empty.
  */
 const REASONING_EFFORT_STEP_DOWN = {
     max: "xhigh",
@@ -138,7 +138,7 @@ function isClaudeReasoningModel(model) {
 }
 /**
  * Anthropic's adaptive-thinking API is only available on the newer Claude
- * model families. Claude Haiku 4.5 is reasoning-capable, but it still
+ * model families. Claude Haiku 4.5 supports effort, but it still
  * requires the legacy manual `budget_tokens` configuration.
  */
 export function supportsClaudeAdaptiveThinking(model) {
@@ -153,7 +153,7 @@ export function supportsClaudeAdaptiveThinking(model) {
     return opusMatch ? parseInt(opusMatch[1], 10) >= 6 : false;
 }
 /**
- * Map the shared reasoning ladder to Anthropic's manual thinking budgets for
+ * Map the shared effort ladder to Anthropic's manual thinking budgets for
  * models that do not support adaptive thinking (currently Claude Haiku 4.5).
  */
 export function anthropicManualThinkingBudget(effort) {