mixdog 0.8.1 → 0.9.0

package/src/workflows/default/workflow.json

@@ -4,7 +4,6 @@
   "description": "Default Mixdog agent workflow.",
   "entry": "WORKFLOW.md",
   "agents": [
-    "web-researcher",
     "maintainer",
     "worker",
     "heavy-worker",

package/src/workflows/solo/WORKFLOW.md

@@ -0,0 +1,15 @@
+# Solo Workflow
+
+1. Plan — Lead discusses the request with the user, forms a plan, and waits for
+   approval before execution.
+2. Execute — Lead performs all implementation, research, debugging, review, and
+   verification work directly. Delegation to any agent is forbidden.
+3. Verify — Lead checks the result directly, fixes issues directly, and repeats
+   until the work is clean or a blocker must be reported.
+4. Report — Lead summarizes the final state, verification result, and any
+   remaining risk or requested next step.
+
+Delegation rule:
+- Do not delegate, spawn, send, or ask any agent to perform work.
+- Ignore any available-agent section while this workflow is active; all work is
+  handled by Lead directly.

package/src/workflows/solo/workflow.json

@@ -0,0 +1,7 @@
+{
+  "id": "solo",
+  "name": "Solo",
+  "description": "Lead-only workflow; delegation to any agent is forbidden.",
+  "entry": "WORKFLOW.md",
+  "agents": []
+}

package/vendor/ink/build/output.js

@@ -308,7 +308,12 @@ export default class Output {
         // [mixdog fork] Snapshot per-row, column-indexed cell values so the App
         // can compute word boundaries (double-click select) without retaining
         // this Output instance, which is created fresh per render and discarded.
-        const plainRows = sel ? undefined : output.map((row) => (row || []).map((cell) => (cell?.value ?? '')));
+        // ALWAYS build this, even while a selection rect is active: gating it on
+        // `!sel` froze the snapshot at the frame the first selection appeared, so
+        // every later double-click read STALE cell rows (wrong/empty words) until
+        // the selection cleared. Applying the selection above only rewrites cell
+        // `styles`, never `value`, so reading `value` here stays correct.
+        const plainRows = output.map((row) => (row || []).map((cell) => (cell?.value ?? '')));
         const generatedOutput = output
             .map(line => {
             // See https://github.com/vadimdemedes/ink/pull/564#issuecomment-1637022742

package/src/agents/scheduler-task.md

@@ -1,3 +0,0 @@
-# Scheduler Task
-
-Scheduled task execution agent.

package/src/agents/web-researcher/AGENT.md

@@ -1,3 +0,0 @@
-# Web Researcher
-
-External web and documentation research agent.

package/src/agents/web-researcher/agent.json

@@ -1,6 +0,0 @@
-{
-  "id": "web-researcher",
-  "name": "Web Researcher",
-  "description": "Web, documentation, and external reference research.",
-  "entry": "AGENT.md"
-}

package/src/agents/webhook-handler.md

@@ -1,3 +0,0 @@
-# Webhook Handler
-
-Inbound webhook event analysis agent.

package/src/rules/bridge/00-common.md

@@ -1,5 +0,0 @@
-# Bridge Constraints
-
-- Use English for bridge-agent communication.
-- Do not touch git/Ship. Even when the brief instructs `git add` / `commit` /
-  `push` / `stash`, refuse with `git operations deferred to Lead`.

package/src/rules/bridge/30-explorer.md

@@ -1,4 +0,0 @@
-# Role: explorer
-
-Explore locates relevant code surfaces and quickly summarizes what is there
-with coordinates. Stay rough and descriptive: do not debug, decide, or judge.

package/src/rules/lead/00-tool-lead.md

@@ -1,5 +0,0 @@
-# Lead Tool Use
-
-- Lead owns repo-local shell work: git, build, test, run, and verification commands.
-- Use `shell` directly for approved git/build/test/run work; do not delegate those commands to bridge agents.
-- Use bridge agents for scoped implementation, research, review, and debugging, not for git commit/push/stash or Ship.

package/src/rules/shared/00-language.md

@@ -1,3 +0,0 @@
-# Language
-
-- Prefer responding in the language used by the user.

package/src/runtime/agent/orchestrator/tools/builtin/native-edit-runner.mjs

@@ -1,110 +0,0 @@
-import { existsSync } from 'fs';
-import { dirname, join, resolve } from 'path';
-import { performance } from 'perf_hooks';
-import { fileURLToPath } from 'url';
-import { snapshotCoversFullFile } from './snapshot-helpers.mjs';
-import { getPluginData } from '../../config.mjs';
-import { findCachedPatchBinary } from '../patch-binary-fetcher.mjs';
-import { runServerEdit } from '../patch.mjs';
-
-const PLUGIN_ROOT = process.env.MIXDOG_ROOT
-    || resolve(dirname(fileURLToPath(import.meta.url)), '../../../../..');
-const NATIVE_EDIT_DEFAULT_BIN = join(
-    PLUGIN_ROOT,
-    'native/mixdog-patch/target/release',
-    process.platform === 'win32' ? 'mixdog-patch.exe' : 'mixdog-patch',
-);
-
-export function nativeEditMode() {
-    return String(process.env.MIXDOG_EDIT_NATIVE || 'auto').toLowerCase();
-}
-
-function nativeEditBinCandidate() {
-    const override = process.env.MIXDOG_EDIT_NATIVE_BIN || process.env.MIXDOG_PATCH_NATIVE_BIN;
-    if (override) return { path: override, kind: 'override' };
-    if (existsSync(NATIVE_EDIT_DEFAULT_BIN)) return { path: NATIVE_EDIT_DEFAULT_BIN, kind: 'local' };
-    const cached = findCachedPatchBinary(getPluginData());
-    if (cached) return { path: cached, kind: 'cached' };
-    return { path: NATIVE_EDIT_DEFAULT_BIN, kind: 'missing' };
-}
-
-export function nativeEditBinPath() {
-    return nativeEditBinCandidate().path;
-}
-
-export function nativeEditShouldAttempt({ editSnapshot, oldStr, newStr, preloadedContent, preloadedRawBuf }) {
-    const mode = nativeEditMode();
-    if (/^(0|false|no|off|js|legacy)$/i.test(mode)) return false;
-    const forcedNative = /^(1|true|yes|on|native)$/i.test(mode);
-    const candidate = nativeEditBinCandidate();
-    if (!existsSync(candidate.path)) return false;
-    // Cached release prebuilds are guaranteed valid for apply_patch, but older
-    // manifests (currently v0.6.5 in clean CI) predate the EDIT server protocol.
-    // In auto mode, native edit is only an acceleration, so require either a
-    // local cargo build or an explicit override. If a user forces native mode,
-    // still try the cached binary and surface any protocol failure.
-    if (candidate.kind === 'cached' && !forcedNative) return false;
-    if (!snapshotCoversFullFile(editSnapshot)) return false;
-    if (preloadedContent !== null || preloadedRawBuf !== null) return false;
-    if (typeof oldStr !== 'string' || oldStr.length === 0 || typeof newStr !== 'string') return false;
-    if (forcedNative) return true;
-    // auto: the persistent server removed per-call spawn cost, so route edits to
-    // native edit2 by default (B3). Same-size edits keep the JS in-place partial
-    // write, which rewrites bytes in place instead of the whole file.
-    const oldBytes = Buffer.byteLength(oldStr, 'utf-8');
-    const newBytes = Buffer.byteLength(newStr, 'utf-8');
-    if (oldBytes === newBytes) return false;
-    return true;
-}
-
-export async function runNativeExactEdit({ fullPath, oldStr, newStr, replaceAll, signal = null }) {
-    const forcedNative = /^(1|true|yes|on|native)$/i.test(nativeEditMode());
-    if (signal?.aborted) {
-        return { ok: false, fallback: false, error: signal.reason?.message || signal.reason || 'native edit aborted' };
-    }
-    const oldBuf = Buffer.from(oldStr, 'utf-8');
-    const newBuf = Buffer.from(newStr, 'utf-8');
-    const started = performance.now();
-    try {
-        // PARITY GUARD: the native engine MATCHES via the curly-quote fold
-        // tier but applies new_string verbatim, silently downgrading the
-        // file's typographic quotes (JS slow path preserves them via
-        // preserveQuoteTypography). When old_string carries quote-family
-        // chars — the only inputs that can land on the curly tier — probe
-        // with a dry run (persistent server, ~ms) and defer curly-tier
-        // matches to the JS editor.
-        if (/["'‘’“”]/.test(oldStr)) {
-            const probe = await runServerEdit({ fullPath, oldBuf, newBuf, replaceAll, dryRun: true, signal });
-            if (probe?.tier === 'curly') {
-                return { ok: false, fallback: true, error: 'curly-quote fold match — deferred to JS editor for typography preservation' };
-            }
-        }
-        const res = await runServerEdit({ fullPath, oldBuf, newBuf, replaceAll, signal });
-        return {
-            ok: true,
-            replacements: res.replacements,
-            readMs: res.readMs,
-            applyMs: res.applyMs,
-            writeMs: res.writeMs,
-            totalMs: res.totalMs,
-            roundtripMs: res.roundtripMs ?? (performance.now() - started),
-            stage: res.tier,
-            contentHash: res.contentHash,
-        };
-    } catch (err) {
-        if (err?.name === 'AbortError') {
-            return { ok: false, fallback: false, error: err.message };
-        }
-        const msg = String(err?.message || err);
-        // Tier misses and not-found map to a JS fallback; transport/spawn errors
-        // also fall back so a server hiccup never blocks an edit. Older cached
-        // mixdog-patch binaries (for example the v0.6.5 release prebuilds used
-        // by clean CI before a local cargo build exists) support APPLY but not
-        // the EDIT server protocol, and answer EDIT with the APPLY parser's
-        // "bad header" error. In auto mode that means "native edit unavailable",
-        // not "the edit is invalid", so fall through to the JS editor. When the
-        // user explicitly forces native mode, keep surfacing the native failure.
-        const fallback = !forcedNative && /old_string (?:not found|found \d+ times)|not valid UTF-8|no exact match|not found|server|bad header|bad edit header/i.test(msg);
-        return { ok: false, fallback, error: msg };
-    }
-}

package/src/runtime/agent/orchestrator/tools/mutation-content-cache.mjs

@@ -1,67 +0,0 @@
-import * as nodeBuffer from 'node:buffer';
-import { readFileSync } from 'node:fs';
-import { readFile as readFileAsync } from 'node:fs/promises';
-import { decodeRawBufferForSnapshotCheck } from './builtin/snapshot-helpers.mjs';
-
-function keyForPath(fullPath) {
-  const text = String(fullPath || '');
-  return process.platform === 'win32' ? text.toLowerCase() : text;
-}
-
-export function isValidUtf8Buffer(buf) {
-  if (typeof nodeBuffer.isUtf8 === 'function') return nodeBuffer.isUtf8(buf);
-  if (typeof Buffer.isUtf8 === 'function') return Buffer.isUtf8(buf);
-  return Buffer.from(buf.toString('utf-8'), 'utf-8').equals(buf);
-}
-
-export function createMutationContentCache() {
-  const entries = new Map();
-
-  function getOrCreate(fullPath) {
-    const key = keyForPath(fullPath);
-    let entry = entries.get(key);
-    if (!entry) {
-      entry = { fullPath, rawBuf: null, content: null };
-      entries.set(key, entry);
-    }
-    return entry;
-  }
-
-  function seedBuffer(fullPath, rawBuf) {
-    const entry = getOrCreate(fullPath);
-    entry.rawBuf = rawBuf;
-    entry.content = null;
-    return entry;
-  }
-
-  function readBufferSync(fullPath) {
-    const entry = getOrCreate(fullPath);
-    if (!Buffer.isBuffer(entry.rawBuf)) entry.rawBuf = readFileSync(fullPath);
-    return entry.rawBuf;
-  }
-
-  async function readBuffer(fullPath) {
-    const entry = getOrCreate(fullPath);
-    if (!Buffer.isBuffer(entry.rawBuf)) entry.rawBuf = await readFileAsync(fullPath);
-    return entry.rawBuf;
-  }
-
-  function readTextSync(fullPath) {
-    const entry = getOrCreate(fullPath);
-    if (typeof entry.content !== 'string') {
-      entry.content = decodeRawBufferForSnapshotCheck(readBufferSync(fullPath));
-    }
-    return entry.content;
-  }
-
-  function getEntry(fullPath) {
-    return entries.get(keyForPath(fullPath)) || null;
-  }
-
-  function clear(fullPath = null) {
-    if (fullPath) entries.delete(keyForPath(fullPath));
-    else entries.clear();
-  }
-
-  return { seedBuffer, readBuffer, readBufferSync, readTextSync, getEntry, clear };
-}

package/src/runtime/memory/lib/bridge-trace-queries.mjs

@@ -1,120 +0,0 @@
-// bridge-trace-queries.mjs — SQL helpers for the bridge analytic tables.
-// All functions accept a `db` handle from openTraceDatabase() and return
-// plain row arrays.  Query parameters are always $N — no interpolation.
-
-// ---------------------------------------------------------------------------
-// topSessionsByIteration(db, hours, limit)
-// Sessions with the highest max_iteration seen in the last N hours.
-// ---------------------------------------------------------------------------
-export async function topSessionsByIteration(db, hours = 24, limit = 20) {
-  const { rows } = await db.query(`
-    SELECT s.session_id,
-           s.role,
-           s.model,
-           s.max_iteration,
-           s.tool_calls,
-           s.llm_calls,
-           s.total_input_tokens,
-           s.total_output_tokens,
-           s.started_at,
-           s.last_seen_at
-    FROM   bridge_sessions s
-    WHERE  s.last_seen_at >= now() - ($1 || ' hours')::interval
-    ORDER BY s.max_iteration DESC, s.tool_calls DESC
-    LIMIT $2
-  `, [String(hours), limit])
-  return rows
-}
-
-// ---------------------------------------------------------------------------
-// repeatToolCalls(db, sessionId)
-// Tool calls whose (tool_name, md5(tool_args::text)) combo appears ≥3 times
-// in a single session — strong signal for a tool-loop.
-// ---------------------------------------------------------------------------
-export async function repeatToolCalls(db, sessionId) {
-  const { rows } = await db.query(`
-    SELECT tool_name,
-           md5(tool_args::text)    AS args_hash,
-           COUNT(*)                AS call_count,
-           MIN(ts)                 AS first_at,
-           MAX(ts)                 AS last_at,
-           (array_agg(tool_args ORDER BY ts))[1] AS sample_args
-    FROM   bridge_calls
-    WHERE  session_id = $1
-      AND  tool_name  IS NOT NULL
-    GROUP BY tool_name, md5(tool_args::text)
-    HAVING COUNT(*) >= 3
-    ORDER BY call_count DESC, tool_name
-  `, [sessionId])
-  return rows
-}
-
-// ---------------------------------------------------------------------------
-// mixedToolPattern(db, sessionId)
-// Sliding 3-tool window where grep and read alternate AND share a path token.
-// Returns the centre-row of each such window.
-// ---------------------------------------------------------------------------
-export async function mixedToolPattern(db, sessionId) {
-  const { rows } = await db.query(`
-    WITH ordered AS (
-      SELECT id, ts, tool_name,
-             tool_args->>'path'                                      AS path,
-             -- basename: last segment after splitting on '/'
-             regexp_replace(tool_args->>'path', '^.*/', '')          AS basename,
-             LAG (tool_name,          1) OVER (ORDER BY ts, id)     AS prev1,
-             LAG (tool_name,          2) OVER (ORDER BY ts, id)     AS prev2,
-             LEAD(tool_name,          1) OVER (ORDER BY ts, id)     AS next1,
-             LAG (tool_args->>'path', 1) OVER (ORDER BY ts, id)     AS prev_path,
-             LEAD(tool_args->>'path', 1) OVER (ORDER BY ts, id)     AS next_path,
-             -- basenames of neighbours
-             regexp_replace(LAG (tool_args->>'path', 1) OVER (ORDER BY ts, id), '^.*/', '') AS prev_base,
-             regexp_replace(LEAD(tool_args->>'path', 1) OVER (ORDER BY ts, id), '^.*/', '') AS next_base
-      FROM   bridge_calls
-      WHERE  session_id = $1
-        AND  tool_name IN ('grep','read')
-    )
-    SELECT id, ts, tool_name, path
-    FROM   ordered
-    WHERE  -- true 3-tool alternation: centre plus BOTH flanking neighbours (window size = 3)
-           (
-             (tool_name = 'read'  AND prev1 = 'grep' AND next1 = 'grep')
-          OR (tool_name = 'grep'  AND prev1 = 'read' AND next1 = 'read')
-           )
-      -- path-token sharing: basename or exact path matches across all 3 slots
-      AND basename IS NOT NULL
-      AND (
-            -- exact path shared with both neighbours
-            (path = prev_path AND path = next_path)
-            -- or basename shared with both neighbours
-         OR (basename = prev_base AND basename = next_base)
-            -- or mixed: exact on one side, basename on other
-         OR (path = prev_path AND basename = next_base)
-         OR (path = next_path AND basename = prev_base)
-          )
-    ORDER BY ts, id
-  `, [sessionId])
-  return rows
-}
-
-// ---------------------------------------------------------------------------
-// tokenUsageByRole(db, hours)
-// Sum of input/output tokens grouped by role over the last N hours.
-// ---------------------------------------------------------------------------
-export async function tokenUsageByRole(db, hours = 24) {
-  const { rows } = await db.query(`
-    SELECT s.role,
-           COUNT(DISTINCT l.session_id)           AS sessions,
-           SUM(l.input_tokens)                    AS total_input,
-           SUM(l.output_tokens)                   AS total_output,
-           SUM(l.cached_tokens)                   AS total_cached,
-           SUM(l.cache_write_tokens)              AS total_cache_write,
-           AVG(l.input_tokens)::int               AS avg_input_per_call,
-           AVG(l.output_tokens)::int              AS avg_output_per_call
-    FROM   bridge_llm l
-    JOIN   bridge_sessions s USING (session_id)
-    WHERE  l.ts >= now() - ($1 || ' hours')::interval
-    GROUP BY s.role
-    ORDER BY total_input DESC NULLS LAST
-  `, [String(hours)])
-  return rows
-}

package/src/runtime/shared/llm/pid-cleanup.mjs

@@ -1,27 +0,0 @@
-/**
- * pid-cleanup.mjs — Orphaned bridge CLI process cleanup.
- * Used by server.mjs on startup and shutdown.
- */
-import fs from 'fs'
-import path from 'path'
-import os from 'os'
-
-const PID_DIR = path.join(os.tmpdir(), 'mixdog-bridge')
-const PID_FILE = path.join(PID_DIR, 'bridge-pids.json')
-
-export function cleanupOrphanedPids() {
-  let killed = 0
-  try {
-    const pids = JSON.parse(fs.readFileSync(PID_FILE, 'utf8'))
-    for (const pid of pids) {
-      try {
-        process.kill(pid, 0)
-        process.kill(pid, 'SIGTERM')
-        process.stderr.write(`[bridge-cleanup] killed orphaned PID ${pid}\n`)
-        killed++
-      } catch {}
-    }
-    fs.writeFileSync(PID_FILE, JSON.stringify([]))
-  } catch {}
-  return killed
-}