mixdog 1.2.5 → 1.3.0

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

@@ -279,19 +279,36 @@ 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) {

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.

package/src/session-runtime/automation-agents.mjs

@@ -1,94 +0,0 @@
-/**
- * Agent delegation for automation sessions (schedules, webhooks). They run
- * headless in the daemon, so no session runtime registers tools for them or
- * receives their agents' completions. The daemon's canonical agent control is
- * exposed under a dedicated internal-tool scope instead, and the completions of
- * the agents a run starts come back here, where the run turns them into the
- * conversation's next turn — what a Lead in a window does when one arrives.
- */
-import { setInternalToolsProvider } from '../runtime/agent/orchestrator/internal-tools.mjs';
-import { AGENT_TOOL } from './services/agent-tool/tool-def.mjs';
-
-export const AUTOMATION_TOOL_SCOPE = 'automation';
-// How long a run waits for the next result of an agent it started; past it the
-// run ends with the conversation as it stands.
-const AGENT_RESULT_WAIT_MS = 60 * 60_000;
-
-const runs = new Map(); // sessionId → { pending: Set<taskId>, ready: string[], wake }
-
-function resultText(result) {
-  return typeof result === 'string' ? result : JSON.stringify(result ?? '');
-}
-
-/** Registers the agent tool for automation sessions; returns its disposer. */
-export function registerAutomationAgentTool(executeAgentControl) {
-  return setInternalToolsProvider({
-    scopeId: AUTOMATION_TOOL_SCOPE,
-    tools: [AGENT_TOOL],
-    async executor(_name, args, callerCtx = {}) {
-      const result = await executeAgentControl(args, {
-        callerCwd: callerCtx.callerCwd,
-        invocationSource: 'model-tool',
-        callerSessionId: callerCtx.callerSessionId || null,
-        clientHostPid: process.pid,
-        signal: callerCtx.signal,
-      });
-      // A spawn/send acknowledgement ("agent task: <id>", "status: running")
-      // is a result still to come for this run.
-      const text = resultText(result);
-      const taskId = /agent task: ([\w.:-]+)/.exec(text)?.[1];
-      const run = runs.get(String(callerCtx.callerSessionId || ''));
-      if (run && taskId && /status: running/.test(text)) run.pending.add(taskId);
-      return result;
-    },
-  });
-}
-
-/** Hands an agent completion to the automation run that started the task; false when none did. */
-export function deliverAutomationCompletion(sessionId, text, meta = {}) {
-  const run = runs.get(String(sessionId || ''));
-  const taskId = String(meta?.execution_id || '');
-  if (!run?.pending.has(taskId)) return false;
-  // The header-only preview precedes the body-carrying completion.
-  if (meta?.model_visible === false) return true;
-  run.pending.delete(taskId);
-  run.ready.push(String(text || ''));
-  run.wake?.();
-  return true;
-}
-
-// Ask options for a follow-up turn fed by agent results: the runtime reporting
-// worker output, not the user — stored as a task notification and never a
-// source of explicit skill selection.
-export const AUTOMATION_RESULT_TURN_OPTS = Object.freeze({ promptSource: 'task-notification' });
-
-/**
- * Runs an automation conversation to its end: the first turn, then one more
- * turn per batch of agent results while agents it started are still out.
- * `nextTurn(text, askOpts)` receives AUTOMATION_RESULT_TURN_OPTS as the
- * results' provenance. Resolves with the last turn's result.
- */
-export async function runAutomationTurns(sessionId, firstTurn, nextTurn, { waitMs = AGENT_RESULT_WAIT_MS } = {}) {
-  const run = { pending: new Set(), ready: [], wake: null };
-  runs.set(sessionId, run);
-  try {
-    let result = await firstTurn();
-    while (run.pending.size > 0 || run.ready.length > 0) {
-      if (run.ready.length === 0) {
-        const arrived = await new Promise((resolve) => {
-          const timer = setTimeout(() => resolve(false), waitMs);
-          run.wake = () => {
-            clearTimeout(timer);
-            resolve(true);
-          };
-        });
-        run.wake = null;
-        if (!arrived) break;
-      }
-      result = await nextTurn(run.ready.splice(0).join('\n\n'), { ...AUTOMATION_RESULT_TURN_OPTS });
-    }
-    return result;
-  } finally {
-    runs.delete(sessionId);
-  }
-}

package/src/session-runtime/automation-workflow.mjs

@@ -1,59 +0,0 @@
-/**
- * Resolve a stored automation workflow id (schedule/webhook row) into
- * createSession options: the workflow summary meta plus the WORKFLOW.md
- * context block, exactly like a desktop New task session gets for the
- * active workflow. An empty/unknown id resolves to the default pack via
- * loadWorkflowPack's fallback; resolution failures degrade to no workflow
- * context (the session still runs with the base lead ruleset).
- */
-import { createWorkflowHelpers } from '../runtime/agent/orchestrator/runtime-core/workflow.mjs';
-import { STANDALONE_ROOT, STANDALONE_DATA_DIR } from './runtime-paths.mjs';
-import { readMarkdownDocument, normalizeAgentPermissionOrNone } from '../runtime/shared/markdown-frontmatter.mjs';
-import { IMPLICIT_APPROVAL_MODE } from '../runtime/agent/orchestrator/session/approval-mode.mjs';
-import { loadConfig } from '../runtime/agent/orchestrator/config.mjs';
-import { configuredOrchestrationMode } from '../runtime/shared/orchestration.mjs';
-import { AUTOMATION_TOOL_SCOPE } from './automation-agents.mjs';
-
-let _helpers = null;
-function helpers() {
-  if (!_helpers) {
-    _helpers = createWorkflowHelpers({
-      rootDir: STANDALONE_ROOT,
-      dataDir: STANDALONE_DATA_DIR,
-      readMarkdownDocument,
-      normalizeAgentPermissionOrNone,
-    });
-  }
-  return _helpers;
-}
-
-/** Non-interactive createSession opts, plus workflow context when the id resolves. */
-export function automationWorkflowOpts(workflowId) {
-  const config = loadConfig({ secrets: false });
-  // The user's orchestration setting governs an automation exactly as it does a
-  // New task: a workflow id alone never turns delegation on, and the agent
-  // tool reaches the run through the automation tool scope.
-  const baseOpts = {
-    approvalMode: IMPLICIT_APPROVAL_MODE,
-    orchestrationMode: configuredOrchestrationMode(config),
-    mcpScopeId: AUTOMATION_TOOL_SCOPE,
-  };
-  const id = String(workflowId || '').trim();
-  if (!id) return baseOpts;
-  try {
-    const h = helpers();
-    const pack = h.loadWorkflowPack(undefined, id);
-    if (!pack) return baseOpts;
-    // The whole config, so disabled agents and the orchestration mode are the
-    // user's, with only the active workflow swapped for the automation's own.
-    const resolved = h.activeWorkflowContext({ ...config, workflow: { ...config.workflow, active: id } }, undefined);
-    return {
-      ...baseOpts,
-      workflow: resolved.summary,
-      workflowContext: resolved.context,
-      orchestrationMode: resolved.orchestrationMode,
-    };
-  } catch {
-    return baseOpts;
-  }
-}