mixdog 1.2.4 → 1.2.6

package/src/tui/session/notice-text.mjs

@@ -35,7 +35,6 @@ const FAILED_NOTICE_ACTIONS = new Map([
   ['oauth login', 'start OAuth login'],
   ['output style switch', 'switch output style'],
   ['openai usage auth save', 'save OpenAI usage auth'],
-  ['opencode go usage auth save', 'save OpenCode Go usage auth'],
   ['plugin add', 'add plugin'],
   ['plugin mcp enable', 'enable plugin MCP'],
   ['plugin uninstall', 'uninstall plugin'],

package/src/tui/session/session-api/intake/submission.mjs

@@ -4,7 +4,7 @@
 import { promptDisplayText } from '../../queue-helpers.mjs';
 
 export function createSubmissionIntake(bag) {
-  const { runtime, nextId, flags, getState, enqueue, autoClearBeforeSubmit } = bag;
+  const { nextId, flags, getState, enqueue, autoClearBeforeSubmit } = bag;
 
   const submission = (text, options = {}) => {
     const displayText = promptDisplayText(text, options);
@@ -25,19 +25,13 @@ export function createSubmissionIntake(bag) {
   };
 
   const enqueueSubmission = (intake) => {
+    // The queue itself wakes a passive `task wait` or shell hold for typed
+    // input (not for slash commands, which run after the turn); see enqueue.
     const accepted = enqueue(intake.text, intake.queueOptions);
-    // User input wakes a passive `task wait` without cancelling either the
-    // turn or the background task. The returned running snapshot creates the
-    // normal post-tool boundary, where this queued prompt is injected.
-    if (accepted !== false) {
-      if ((intake.queueOptions.mode || 'prompt') === 'prompt') {
-        bag.cancelQuotaResumeOnUserInput?.();
-        bag.cancelQueuedGoalContinuations?.();
-        bag.archiveCompletedGoalOnUserInput?.();
-      }
-      try {
-        runtime.interruptTaskWait?.('user-message');
-      } catch {}
+    if (accepted !== false && (intake.queueOptions.mode || 'prompt') === 'prompt') {
+      bag.cancelQuotaResumeOnUserInput?.();
+      bag.cancelQueuedGoalContinuations?.();
+      bag.archiveCompletedGoalOnUserInput?.();
     }
     return accepted;
   };

package/src/tui/session/session-api/integrations.mjs

@@ -139,6 +139,7 @@ export function createSessionIntegrationsApi(bag, { oauthFlows }) {
       (result) => `custom provider saved: ${result.id}`
     ),
     updateCustomProviderModel: (id, modelId, patch) => runtime.updateCustomProviderModel(id, modelId, patch),
+    setModelPreferences: (provider, changes) => runtime.setModelPreferences(provider, changes),
     removeCustomProvider: async (id) => {
       const result = await runtime.removeCustomProvider(id);
       refreshRouteStats();
@@ -148,11 +149,6 @@ export function createSessionIntegrationsApi(bag, { oauthFlows }) {
     testCustomProvider: (input) => runtime.testCustomProvider(input),
     checkCustomProviderKeyEnv: (name) => runtime.checkCustomProviderKeyEnv(name),
     discoverCustomProviderModels: (input) => runtime.discoverCustomProviderModels(input),
-    saveOpenCodeGoUsageAuth: async (opts) => {
-      await runtime.saveOpenCodeGoUsageAuth(opts);
-      pushNotice('OpenCode Go usage auth saved', 'info');
-      return true;
-    },
     saveOpenAIUsageSessionKey: async (secret) => {
       await runtime.saveOpenAIUsageSessionKey(secret);
       pushNotice('OpenAI usage auth saved', 'info');

package/src/tui/session/session-flow/drain.mjs

@@ -332,6 +332,14 @@ export function createDrainLoop(
     }
     submissions.remember(submissionId);
     pending.push(entry);
+    // Typed input or a deliverable notification ends a passive task wait or
+    // shell hold so the next boundary hands it to the model now.
+    const wake = steering.taskWaitWakeForEntry(entry);
+    if (wake) {
+      try {
+        bag.runtime?.interruptTaskWait?.(wake, wake === 'notification' ? entry.execution?.id || null : null);
+      } catch {}
+    }
     const needsDurableSteering =
       (getState().busy || getState().commandBusy || flags.autoClearRunning || flags.quotaResumePending) &&
       steering.shouldMirrorSteeringEntry(entry);

package/src/tui/session/session-flow/steering.mjs

@@ -131,6 +131,47 @@ export function createSteeringOps(bag, { queue, submissions }) {
     );
   }
 
+  // Queued input the user typed (editable prompts), not runtime notices.
+  function hasPendingUserInput() {
+    if (!admissionOpen()) return false;
+    return pending.some((entry) => isQueuedEntryEditable(entry) && !isSlashQueuedEntry(entry));
+  }
+
+  // A notification the next boundary will deliver: a task notification (one
+  // the agent already received through task wait/read is not deliverable) or
+  // the Goal closeout. `later` entries (scheduled and channel injects) wait
+  // for the turn to end, so they are not deliverable mid-turn.
+  function isDeliverableNotification(entry) {
+    const mode = entry?.mode;
+    return (
+      admissionOpen() &&
+      (mode === 'task-notification' || mode === 'goal-closeout') &&
+      queuePriorityValue(entry.priority) <= queuePriorityValue('next') &&
+      canDeliverSteeringEntry(entry) &&
+      steeringMessageFromEntry(entry) !== null
+    );
+  }
+
+  function hasPendingNotification() {
+    return pending.some(isDeliverableNotification);
+  }
+
+  // What one queued entry should wake a passive wait or shell hold for: typed
+  // input, a deliverable notification, or nothing (slash commands and
+  // informational meta prompts run or ride along without ending a wait).
+  function taskWaitWakeForEntry(entry) {
+    if (!admissionOpen()) return false;
+    if (isQueuedEntryEditable(entry) && !isSlashQueuedEntry(entry)) return 'user-message';
+    return isDeliverableNotification(entry) ? 'notification' : false;
+  }
+
+  // What a passive wait or shell hold should wake for right now: user input
+  // first, else a deliverable notification.
+  function pendingTaskWaitWake() {
+    if (hasPendingUserInput()) return 'user-message';
+    return hasPendingNotification() ? 'notification' : false;
+  }
+
   // `later` notifications (scheduled tasks) are skipped unless the runtime
   // explicitly asks for a later flush.
   function drainPendingSteering(_sessionIdOrOptions = null, maybeOptions = null) {
@@ -219,6 +260,11 @@ export function createSteeringOps(bag, { queue, submissions }) {
     commitSteeringQueueEntries,
     settleSteeredSubmissions,
     hasPendingSteering,
+    hasPendingUserInput,
+    isDeliverableNotification,
+    hasPendingNotification,
+    taskWaitWakeForEntry,
+    pendingTaskWaitWake,
     drainPendingSteering,
     restoreLeadSteeringFromDisk,
   };

package/src/tui/session/session-flow.mjs

@@ -39,6 +39,8 @@ export function createSessionFlow(bag) {
     enqueue: loop.enqueue,
     settleClosedQueue: loop.settleClosedQueue,
     hasPendingSteering: steering.hasPendingSteering,
+    hasPendingUserInput: steering.hasPendingUserInput,
+    pendingTaskWaitWake: steering.pendingTaskWaitWake,
     drainPendingSteering: steering.drainPendingSteering,
     restoreLeadSteeringFromDisk: steering.restoreLeadSteeringFromDisk,
     autoClearBeforeSubmit: autoClear.autoClearBeforeSubmit,

package/src/tui/session/turn-stream.mjs

@@ -33,6 +33,12 @@ export function createTurnStream(deps) {
     // segment out of the provider's final content individually: the combined
     // prefix no longer matches when the provider omits an earlier segment.
     committedSegments: [],
+    // The open segment was settled when the provider streamed a tool call
+    // (turn.mjs); cleared when that response's tool calls open.
+    settledBeforeToolCall: false,
+    // The phase the provider named for the message this segment streams
+    // (`commentary` / `final_answer`), or null; the desktop row carries it.
+    phase: null,
     thinkingText: '',
     thinkingStartedAt: 0,
     thinkingSegmentStartedAt: 0,
@@ -113,6 +119,7 @@ function ensureAssistant(stream, initialText = '') {
       text: String(initialText || ''),
       at,
       messageId,
+      ...phaseField(stream),
       ...stream.routeMeta,
     });
   }
@@ -149,11 +156,17 @@ function partialNow(stream) {
       streaming: true,
       at: identity.at,
       messageId: identity.messageId,
+      ...phaseField(stream),
       ...stream.routeMeta,
     },
   };
 }
 
+// The row's `phase` field; absent when the provider named none.
+function phaseField(stream) {
+  return stream.phase ? { phase: stream.phase } : {};
+}
+
 function samePartial(left, right) {
   if (left === right) return true;
   if (!left || !right) return false;
@@ -208,6 +221,7 @@ function resetLineScan(stream) {
 function closeAssistantSegment(stream) {
   stream.currentAssistantId = null;
   stream.currentAssistantText = '';
+  stream.phase = null;
   stream.claimPersistedAssistant = false;
   stream.assistantIdentity = null;
   resetLineScan(stream);
@@ -296,6 +310,7 @@ function flushTextBatch(stream) {
         text: visibleText,
         streaming: true,
         at: current?.at || Date.now(),
+        phase: stream.phase || undefined,
         ...stream.routeMeta,
       };
     }
@@ -449,6 +464,24 @@ export function appendAssistantText(stream, full, { committed = false } = {}) {
   flushStreamBatch(stream);
 }
 
+// The provider named the phase of the message it is streaming. A message of
+// another phase than the open segment's text is its own row: that segment
+// settles first. A segment whose phase was not known yet (the provider named
+// it only on the finished message) takes it.
+export function noteAssistantPhase(stream, phase) {
+  if (phase !== 'commentary' && phase !== 'final_answer') return;
+  if (stream.phase === phase) return;
+  if (stream.phase && stream.currentAssistantText.trim()) {
+    flushStreamBatch(stream);
+    commitAssistantSegment(stream);
+  }
+  stream.phase = phase;
+  const tail = stream.getState().streamingTail;
+  if (stream.currentAssistantId != null && tail?.id === stream.currentAssistantId) {
+    stream.updateStreamingTail(tail.id, { phase });
+  }
+}
+
 // Reasoning is not a commit boundary: a turn interrupted while it is still
 // thinking produced no model-visible message, so Esc must hand the prompt
 // back to the input box. Text, tool calls and turn end still commit it.

package/src/tui/session/turn.mjs

@@ -34,6 +34,7 @@ import {
   appendTextDelta,
   appendAssistantText,
   appendReasoningDelta,
+  noteAssistantPhase,
   resetStreamedText,
   applyStageChange,
   settleFinalText,
@@ -241,9 +242,21 @@ function injectSteerMessage({ stream, cards, pushUserOrSyntheticItem }, text, st
   pushUserOrSyntheticItem(value, steeringIds[0], 'injected', steeringItemExtras(steeringMeta));
 }
 
+function settleSegmentBeforeToolCall(ctx) {
+  const { stream } = ctx;
+  if (!stream.currentAssistantText.trim()) return;
+  ctx.markPromptCommitted();
+  flushStreamBatch(stream);
+  commitAssistantSegment(stream, { sealToolBlock: true });
+  // The response's own content (onAssistantText, before its tool calls open)
+  // is this streamed text again: it must not reopen as a second row.
+  stream.settledBeforeToolCall = true;
+}
+
 async function openToolCalls(ctx, calls) {
   const { stream, cards, runtime } = ctx;
   ctx.markPromptCommitted();
+  stream.settledBeforeToolCall = false;
   // Flush buffered mid-turn assistant text before the tool card appears;
   // otherwise, with neither a thinking panel nor a spinner active, the
   // message above the tool card vanished.
@@ -372,9 +385,14 @@ function turnHandlers(ctx) {
   };
 }
 
-function toolHandlers(ctx) {
+export function toolHandlers(ctx) {
   const { isCurrentTurn, cards, getState, set, options } = ctx;
   return {
+    // The provider streamed a tool call: the text before it is complete (a
+    // preamble), so it settles now instead of after the whole response.
+    onAssistantToolCallObserved: () => {
+      if (isCurrentTurn()) settleSegmentBeforeToolCall(ctx);
+    },
     onToolCall: async (_iter, calls) => {
       if (isCurrentTurn()) await openToolCalls(ctx, calls);
     },
@@ -431,13 +449,22 @@ export function streamHandlers(ctx) {
       // The streaming path owns this segment when it already produced text.
       // Do not check turn-global assistantText: earlier closed preambles stay
       // there across tool calls.
-      if (stream.currentAssistantText.trim()) return;
+      if (stream.currentAssistantText.trim() || stream.settledBeforeToolCall) return;
       ctx.markPromptCommitted();
       appendAssistantText(stream, full, { committed: detail?.committed === true });
     },
     onReasoningDelta: (chunk) => {
       if (isCurrentTurn()) appendReasoningDelta(stream, String(chunk ?? ''));
     },
+    // A provider output item started. A tool call ends the text before it
+    // (a preamble settles at the call's start, not after its arguments or
+    // the whole response); a message naming its phase marks its row as
+    // commentary or final answer.
+    onStreamItemStart: (detail) => {
+      if (!isCurrentTurn()) return;
+      if (detail?.kind === 'tool') settleSegmentBeforeToolCall(ctx);
+      else if (detail?.kind === 'text') noteAssistantPhase(stream, detail.phase);
+    },
   };
 }
 
@@ -693,7 +720,7 @@ export function createRunTurn(bag) {
       markPromptCommitted: () => commitPromptRestore(flags, turn),
     };
     const stopTaskWaitSteeringCheck = registerTaskWaitSteeringCheck(
-      (sessionId) => isCurrentTurn() && runtime.id === sessionId && bag.hasPendingSteering()
+      (sessionId) => isCurrentTurn() && runtime.id === sessionId && bag.pendingTaskWaitWake()
     );
     try {
       const { result, session } = await runtime.ask(userText, {

package/src/ui/statusline.mjs

@@ -10,7 +10,6 @@
  * CLI route passed here.
  */
 import { readCachedOAuthUsageSnapshot } from '../runtime/agent/orchestrator/providers/oauth-usage.mjs';
-import { readCachedOpenCodeGoUsageSnapshot } from '../runtime/agent/orchestrator/providers/opencode-go-usage.mjs';
 import { buildGatewayLimits } from '../runtime/agent/orchestrator/providers/statusline-route-meta.mjs';
 import { formatGatewayLimitSegments, loadGatewayStatus } from '../vendor/statusline/bin/statusline-route.mjs';
 import { createSessionStats } from './session-stats.mjs';
@@ -614,14 +613,11 @@ function refreshFallbackQuotaStatus(cacheKey, normalizedProvider, model) {
 // the route reports nothing worth a segment.
 function fallbackQuotaValue(routeInfo, normalizedProvider) {
   let usageSnapshot = null;
-  if (normalizedProvider === 'opencode-go') {
-    usageSnapshot = readCachedOpenCodeGoUsageSnapshot();
-  } else if (normalizedProvider.includes('oauth')) {
+  if (normalizedProvider.includes('oauth')) {
     try {
       usageSnapshot = readCachedOAuthUsageSnapshot(routeInfo, { allowStale: true });
     } catch {}
   }
-  if (normalizedProvider === 'opencode-go' && !usageSnapshot) return null;
   // Boot guard: do not render previous-launch usage before the current
   // runtime has captured at least one snapshot. Once captured in this
   // process, keep it visible while idle even if refreshes are delayed.
@@ -647,7 +643,6 @@ function fallbackQuotaValue(routeInfo, normalizedProvider) {
 
 function providerKindForQuota(provider) {
   const p = String(provider || '').toLowerCase();
-  if (p === 'opencode-go') return 'quota-api';
   if (p.includes('oauth')) return 'oauth';
   if (p === 'mixdog-local') return 'local';
   return 'api';

package/src/ui/streaming-markdown-heal.mjs

@@ -8,19 +8,47 @@ const HEALABLE_MARKDOWN_SYNTAX = /[`*_~[]/;
 function openFence(text) {
   let marker = '';
   let length = 0;
+  let start = 0;
+  let lineStart = 0;
   for (const rawLine of String(text ?? '').split('\n')) {
     const fence = FENCE_LINE.exec(rawLine.replace(/\r$/, ''));
-    if (!fence) continue;
-    const marks = fence[1];
-    if (!marker) {
-      marker = marks[0];
-      length = marks.length;
-    } else if (marks[0] === marker && marks.length >= length && !fence[2].trim()) {
-      marker = '';
-      length = 0;
+    if (fence) {
+      const marks = fence[1];
+      if (!marker) {
+        marker = marks[0];
+        length = marks.length;
+        start = lineStart;
+      } else if (marks[0] === marker && marks.length >= length && !fence[2].trim()) {
+        marker = '';
+        length = 0;
+      }
     }
+    lineStart += rawLine.length + 1;
   }
-  return marker ? { marker, length } : null;
+  return marker ? { marker, length, start } : null;
+}
+
+// The opening fence line arrives a token at a time: ``` → ```py → ```python.
+// Rendered at once, the card opened unlabelled and then relabelled (and
+// re-highlighted) per token. The card appears with its first code character:
+// an opening line alone would paint an empty box before any code.
+function trimPartialOpeningFence(text, fence) {
+  const lineEnd = text.indexOf('\n', fence.start);
+  return lineEnd >= 0 && /\S/.test(text.slice(lineEnd + 1)) ? text : text.slice(0, fence.start);
+}
+
+// A line holding only a block marker so far has no content to show, and the
+// marker alone parses as something else: `-` or `=` under a paragraph is a
+// setext underline (the paragraph flashed into a heading until the item text
+// arrived), `2` is a lazy paragraph continuation until its `.` arrives, `#`
+// grows into `##`, and a lone backtick run is literal text until it becomes a
+// fence. Hold the line back until its first content character.
+const PENDING_BLOCK_MARKER_LINE = /(?:^|\n)[ \t]*(?:[-+*=_#>~`]+|\d{1,9}[.)]?)[ \t]*$/;
+
+function trimPendingBlockMarker(text) {
+  const pending = PENDING_BLOCK_MARKER_LINE.exec(text);
+  if (!pending) return text;
+  return text.slice(0, pending.index + (pending[0].startsWith('\n') ? 1 : 0));
 }
 
 // A closing fence arrives a token at a time. Until its run is long enough to
@@ -57,7 +85,9 @@ function closeInlineCode(text, isPendingLocalPath) {
     } else if (run === open) open = 0;
     index = end;
   }
-  if (open && isPendingLocalPath?.(text.slice(openIndex + open))) {
+  // An opener with nothing after it yet closes into an empty span, which
+  // parses as a literal backtick run that then vanishes into code.
+  if (open && (!text.slice(openIndex + open) || isPendingLocalPath?.(text.slice(openIndex + open)))) {
     return text.slice(0, openIndex);
   }
   return open > 0 ? `${text}${'`'.repeat(open)}` : text;
@@ -93,6 +123,7 @@ function scanEmphasisRuns(masked) {
     let end = index + 1;
     while (masked[end] === marker) end += 1;
     const length = end - index;
+    const at = index;
     const before = index > 0 ? masked[index - 1] : '';
     const after = end < masked.length ? masked[end] : '';
     const beforeSpace = isMarkdownSpace(before);
@@ -102,16 +133,26 @@ function scanEmphasisRuns(masked) {
     const left = !afterSpace && (!afterPunctuation || beforeSpace || beforePunctuation);
     const right = !beforeSpace && (!beforePunctuation || afterSpace || afterPunctuation);
     if (marker === '~') {
-      if (length >= 2) runs.push({ marker, length: 2, canOpen: left, canClose: right });
+      // A single tilde is inert, but at the end it may be half of `~~`.
+      runs.push({
+        marker,
+        length: Math.min(length, 2),
+        canOpen: left && length >= 2,
+        canClose: right && length >= 2,
+        at,
+        end,
+      });
     } else if (marker === '_') {
       runs.push({
         marker,
         length,
         canOpen: left && (!right || beforePunctuation),
         canClose: right && (!left || afterPunctuation),
+        at,
+        end,
       });
     } else {
-      runs.push({ marker, length, canOpen: left, canClose: right });
+      runs.push({ marker, length, canOpen: left, canClose: right, at, end });
     }
     index = end;
   }
@@ -120,7 +161,9 @@ function scanEmphasisRuns(masked) {
 
 function closeEmphasis(text) {
   const open = [];
-  for (const run of scanEmphasisRuns(maskCode(text))) {
+  const runs = scanEmphasisRuns(maskCode(text));
+  const last = runs[runs.length - 1];
+  for (const run of runs) {
     let length = run.length;
     while (run.canClose && length > 0) {
       let match = -1;
@@ -137,13 +180,21 @@ function closeEmphasis(text) {
       length -= used;
       open.length = opener.length > 0 ? match + 1 : match;
     }
+    // A run ending the text that closed nothing has no content after it yet:
+    // it painted as literal `**` until the next token turned it into style.
+    if (run === last && run.end === text.length && length === run.length) {
+      return closeEmphasis(text.slice(0, run.at));
+    }
     if (length > 0 && run.canOpen) open.push({ marker: run.marker, length });
   }
-  let healed = text;
+  // Closers go before trailing whitespace: `**word ` closed after the space
+  // could not close (a closing run must follow non-space) and stayed literal.
+  const body = text.trimEnd();
+  let closers = '';
   for (let index = open.length - 1; index >= 0; index -= 1) {
-    healed += open[index].marker.repeat(Math.min(open[index].length, 3));
+    closers += open[index].marker.repeat(Math.min(open[index].length, 3));
   }
-  return healed;
+  return closers ? `${body}${closers}${text.slice(body.length)}` : text;
 }
 
 function linkDestinationEnd(text, start) {
@@ -228,26 +279,44 @@ function tableCells(line) {
 // time. Until the delimiter is complete (and has the header's cell count) the
 // rows are a paragraph of raw pipes, which then re-laid out as a table of a
 // different height — the reply grew and shrank under a followed transcript.
-// Hold both rows back until the table can form in one step.
+// Hold both rows back until the table can form in one step. The head may end
+// a block under paragraph lines (a table directly below its caption line),
+// and a header row needs no leading pipe: such a row is held while it is the
+// block's last line, and with a partial delimiter row below it.
 function trimPendingTableHead(text) {
   let offset = 0;
   for (const blank of text.matchAll(/\n[ \t]*\r?\n/g)) offset = blank.index + blank[0].length;
   const block = text.slice(offset);
   const lines = block.split('\n').map((line) => line.replace(/\r$/, ''));
-  if (lines.length === 0 || lines.length > 2 || !PIPE_ROW.test(lines[0])) return text;
-  if (lines.length === 2) {
-    const delimiter = lines[1];
-    if (!PARTIAL_DELIMITER_ROW.test(delimiter)) return text;
-    if (DELIMITER_ROW.test(delimiter) && tableCells(delimiter) === tableCells(lines[0])) return text;
+  // A row that ended with its newline is still the block's last row: the
+  // empty line after it is not a (partial) delimiter row.
+  let last = lines.length - 1;
+  if (last >= 1 && !lines[last].trim()) last -= 1;
+  let head = last;
+  if (last >= 1 && PARTIAL_DELIMITER_ROW.test(lines[last]) && hasCellPipe(lines[last - 1])) {
+    const delimiter = lines[last];
+    if (DELIMITER_ROW.test(delimiter) && tableCells(delimiter) === tableCells(lines[last - 1])) return text;
+    head = last - 1;
   }
-  return text.slice(0, offset);
+  if (!(PIPE_ROW.test(lines[head]) || hasCellPipe(lines[head]))) return text;
+  // Rows below a delimiter belong to a table that already formed.
+  if (lines.slice(0, head).some((line) => DELIMITER_ROW.test(line))) return text;
+  let start = offset;
+  for (let index = 0; index < head; index += 1) start += lines[index].length + 1;
+  return text.slice(0, start);
+}
+
+// A cell separator outside inline code: the line can head a table.
+function hasCellPipe(line) {
+  return /(?<!\\)\|/.test(line.replace(INLINE_CODE_SPAN, ''));
 }
 
 export function healStreamingMarkdownTail(text, isPendingLocalPath) {
   const source = String(text ?? '');
   const fence = source.includes('`') || source.includes('~') ? openFence(source) : null;
-  if (fence) return trimPartialClosingFence(source, fence);
-  const value = source.includes('|') ? trimPendingTableHead(source) : source;
+  if (fence) return trimPartialOpeningFence(trimPartialClosingFence(source, fence), fence);
+  const unmarked = trimPendingBlockMarker(source);
+  const value = unmarked.includes('|') ? trimPendingTableHead(unmarked) : unmarked;
   const hasSyntax = HEALABLE_MARKDOWN_SYNTAX.test(value);
   if (!value || (!hasSyntax && !isPendingLocalPath)) return value;
   const healed = hasSyntax

package/src/vendor/statusline/bin/statusline-route.mjs

@@ -113,7 +113,6 @@ function cleanString(value) {
 function providerKind(provider) {
   const p = String(provider || '').toLowerCase();
   if (!p) return 'unknown';
-  if (p === 'opencode-go') return 'quota-api';
   if (p.includes('oauth')) return 'oauth';
   if (p === 'mixdog-local') return 'local';
   return 'api';

package/src/vendor/statusline/src/gateway/route-meta.mjs

@@ -101,7 +101,6 @@ function cleanBool(value) {
 function providerKind(provider) {
   const p = String(provider || '').toLowerCase();
   if (!p) return 'unknown';
-  if (p === 'opencode-go') return 'quota-api';
   if (p.includes('oauth')) return 'oauth';
   if (p === 'mixdog-local') return 'local';
   return 'api';

package/src/workflows/default/WORKFLOW.md

@@ -4,17 +4,13 @@ name: Default
 description: "Handle tasks as requested."
 ---
 
-Consult the user and build the work plan together. Explicit read-only requests
-proceed immediately. When file edits, state mutation, or delegation are
-required, investigate and plan only until the user approves the latest plan. If the
-plan leaves the user a choice among clear options, ask it with `ask_user`
-before asking for approval.
+An explicit request is the approval within its scope: carry it out, including
+routine supporting steps and delegation, without asking again. Resolve
+discoverable facts by inspection; decide minor details yourself and say which
+you chose. Read-only requests do not authorize changes.
 
-When user input is required, park only the affected work and continue
-unaffected approved work. Ask pending questions together once no such work
-remains.
-
-While an approved Goal is active, work inside its objective is already
-approved: carry it out without stepwise approval. Reserve questions for scope
-outside that objective, including a commit, push, release, deployment, or
-payment the user has not requested.
+Ask only for a decision that only the user can make and that materially
+changes the outcome, or for authorization outside the request's scope —
+including a commit, push, release, deployment, or payment the user has not
+requested. When user input is required, park only the affected work, continue
+the rest, and ask pending questions together once no such work remains.