mixdog 0.8.0 → 0.9.0

package/scripts/compact-trigger-migration-smoke.mjs

@@ -0,0 +1,187 @@
+#!/usr/bin/env node
+// Focused coverage for the legacy derived full-window autoCompactTokenLimit
+// migration and the buffer-config preservation fix. No provider / network /
+// disk-store dependency — pure function assertions on the manager helpers.
+import {
+  _resolveSessionContextMeta as resolveSessionContextMeta,
+  _compactTriggerForSession as compactTriggerForSession,
+  _preserveBufferConfigFields as preserveBufferConfigFields,
+} from '../src/runtime/agent/orchestrator/session/manager.mjs';
+import { _autoCompactTokenLimit as routeMetaAutoCompactTokenLimit } from '../src/vendor/statusline/src/gateway/route-meta.mjs';
+import {
+  _routeContextMeta as routeContextMeta,
+  _resolveStatusAutoCompactTokenLimit as resolveStatusAutoCompactTokenLimit,
+} from '../src/vendor/statusline/bin/statusline-route.mjs';
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+// 1) A legacy seed where autoCompactTokenLimit == contextWindow/boundary must
+//    NOT be re-accepted as an explicit limit; it is dropped to null so the
+//    trigger falls back to the default boundary trigger.
+{
+  const seed = {
+    contextWindow: 200000,
+    rawContextWindow: 200000,
+    effectiveContextWindowPercent: 100,
+    autoCompactTokenLimit: 200000, // legacy derived full-window value
+    compactBoundaryTokens: 200000,
+  };
+  const meta = resolveSessionContextMeta(null, 'claude-haiku-4-5-20251001', seed);
+  assert(meta.autoCompactTokenLimit === null,
+    `legacy full-window autoCompactTokenLimit should drop to null, got ${meta.autoCompactTokenLimit}`);
+  assert(meta.compactBoundaryTokens === 200000,
+    `boundary should stay full window, got ${meta.compactBoundaryTokens}`);
+}
+
+// 2) A genuinely-lower explicit limit (< boundary) is preserved.
+{
+  const seed = {
+    contextWindow: 200000,
+    rawContextWindow: 200000,
+    effectiveContextWindowPercent: 100,
+    autoCompactTokenLimit: 120000,
+    compactBoundaryTokens: 200000,
+  };
+  const meta = resolveSessionContextMeta(null, 'claude-haiku-4-5-20251001', seed);
+  assert(meta.autoCompactTokenLimit === 120000,
+    `sub-boundary explicit limit should be preserved, got ${meta.autoCompactTokenLimit}`);
+}
+
+// 3) compactTriggerForSession ignores a boundary-equal stored autoCompactTokenLimit
+//    (legacy artifact) and applies the default 10% buffer; honors a sub-boundary one.
+{
+  const boundary = 200000;
+  const legacy = compactTriggerForSession({ autoCompactTokenLimit: boundary, compaction: {} }, boundary);
+  assert(legacy === 180000, `legacy boundary-equal limit should yield default 10% trigger 180000, got ${legacy}`);
+  const explicit = compactTriggerForSession({ autoCompactTokenLimit: 150000, compaction: {} }, boundary);
+  assert(explicit === 150000, `sub-boundary explicit limit should be the trigger, got ${explicit}`);
+}
+
+// 4) A configured bufferPercent flows into the trigger via session.compaction.
+{
+  const boundary = 200000;
+  // bufferPercent: 5 → 5% → trigger 190000.
+  const trigger = compactTriggerForSession({ compaction: { bufferPercent: 5 } }, boundary);
+  assert(trigger === 190000, `bufferPercent 5 should yield trigger 190000, got ${trigger}`);
+}
+
+// 5) Legacy telemetry from the old default 10% buffer is non-config and reapplies
+//    the current default 10% headroom (trigger 180000). Persisted zero-buffer
+//    telemetry migrates the same way.
+{
+  const boundary = 200000;
+  const legacyTelemetry = compactTriggerForSession({
+    compaction: {
+      boundaryTokens: boundary,
+      triggerTokens: 180000,
+      bufferTokens: 20000,
+      bufferRatio: 0.1,
+    },
+  }, boundary);
+  assert(legacyTelemetry === 180000,
+    `legacy default buffer telemetry should yield 10% headroom trigger 180000, got ${legacyTelemetry}`);
+  const zeroTelemetry = compactTriggerForSession({
+    compaction: {
+      boundaryTokens: boundary,
+      triggerTokens: boundary,
+      bufferTokens: 0,
+      bufferRatio: 0,
+    },
+  }, boundary);
+  assert(zeroTelemetry === 180000,
+    `persisted zero-buffer telemetry should restore default 10% trigger 180000, got ${zeroTelemetry}`);
+  const explicitTokens = compactTriggerForSession({ compaction: { bufferTokens: 10000 } }, boundary);
+  assert(explicitTokens === 190000,
+    `explicit bufferTokens should still lower trigger to 190000, got ${explicitTokens}`);
+}
+
+// 6) preserveBufferConfigFields copies only finite-positive percent/ratio fields.
+{
+  const out = preserveBufferConfigFields({ bufferPercent: 5, bufferRatio: 0.02, bufferFraction: 0, bufferPct: undefined, other: 9 });
+  assert(out.bufferPercent === 5 && out.bufferRatio === 0.02, 'should copy positive percent/ratio fields');
+  assert(!('bufferFraction' in out), 'zero buffer field should be dropped');
+  assert(!('bufferPct' in out), 'undefined buffer field should be dropped');
+  assert(!('other' in out), 'non-buffer fields should not be copied');
+}
+
+// 7) route-meta.autoCompactTokenLimit(): legacy seed/info value == boundary/window
+//    returns null; value >= window returns null; sub-window explicit preserved;
+//    no boundary keeps positive explicit; never derives.
+{
+  // explicit == contextWindow (boundary) → null
+  assert(routeMetaAutoCompactTokenLimit('openai-oauth', 272000, 244800, {}, { autoCompactTokenLimit: 244800 }) === null,
+    'route-meta: explicit == contextWindow should be null');
+  // explicit == rawContextWindow (above effective boundary) → null
+  assert(routeMetaAutoCompactTokenLimit('openai-oauth', 272000, 244800, {}, { autoCompactTokenLimit: 272000 }) === null,
+    'route-meta: explicit >= boundary should be null');
+  // sub-boundary explicit preserved
+  assert(routeMetaAutoCompactTokenLimit('openai-oauth', 272000, 244800, {}, { autoCompactTokenLimit: 150000 }) === 150000,
+    'route-meta: sub-boundary explicit should be preserved');
+  // no explicit → null (never derived)
+  assert(routeMetaAutoCompactTokenLimit('openai-oauth', 272000, 244800, {}, {}) === null,
+    'route-meta: no explicit should be null (never derived)');
+  // no boundary known, positive explicit → kept
+  assert(routeMetaAutoCompactTokenLimit('local', 0, 0, {}, { autoCompactTokenLimit: 60000 }) === 60000,
+    'route-meta: positive explicit with no boundary should be kept');
+}
+
+// 8) statusline-route.routeContextMeta(): same explicit-only sanitization.
+{
+  // inherited full-window autoCompactTokenLimit (== rawContextWindow) → null
+  const legacy = routeContextMeta('anthropic-oauth', { contextWindow: 200000 }, { autoCompactTokenLimit: 200000 });
+  assert(legacy.autoCompactTokenLimit === null,
+    `statusline-route: full-window inherited limit should be null, got ${legacy.autoCompactTokenLimit}`);
+  assert(legacy.contextWindow > 0, 'statusline-route: contextWindow display should remain');
+  // sub-boundary explicit preserved (effective window = 200000*0.9 = 180000)
+  const lower = routeContextMeta('anthropic-oauth', { contextWindow: 200000 }, { autoCompactTokenLimit: 120000 });
+  assert(lower.autoCompactTokenLimit === 120000,
+    `statusline-route: sub-boundary explicit should be preserved, got ${lower.autoCompactTokenLimit}`);
+  // no explicit → null (never derived from window)
+  const none = routeContextMeta('anthropic-oauth', { contextWindow: 200000 }, {});
+  assert(none.autoCompactTokenLimit === null,
+    `statusline-route: no explicit should be null, got ${none.autoCompactTokenLimit}`);
+}
+
+// 9) loadGatewayStatus auto-compact resolver: a stale active full-window limit
+//    must be validated against the ACTIVE window, not the (larger) configured
+//    window. Configured contextWindow=244800 > active gateway_context_window=200000,
+//    active gateway_auto_compact_token_limit=200000 (== active window) => null.
+{
+  const active = {
+    gateway_context_window: 200000,
+    gateway_raw_context_window: 200000,
+    gateway_auto_compact_token_limit: 200000, // stale full-window (== active window)
+  };
+  // No configured route → active value is sanitized against the active window.
+  const activeOnly = resolveStatusAutoCompactTokenLimit(null, active, null);
+  assert(activeOnly === null,
+    `status: stale active full-window limit should be null vs active window, got ${activeOnly}`);
+
+  // Configured route present with a LARGER window must not validate the stale
+  // active value; the configured route's own (here absent) explicit limit wins.
+  const configuredLarger = { contextWindow: 244800, autoCompactTokenLimit: null };
+  const withConfigured = resolveStatusAutoCompactTokenLimit(configuredLarger, active, null);
+  assert(withConfigured === null,
+    `status: configured larger window must not validate stale active limit, got ${withConfigured}`);
+
+  // A lower active explicit value (below the active window) is preserved when
+  // there is no configured route.
+  const lowerActive = resolveStatusAutoCompactTokenLimit(null, {
+    gateway_context_window: 200000,
+    gateway_raw_context_window: 200000,
+    gateway_auto_compact_token_limit: 150000,
+  }, null);
+  assert(lowerActive === 150000,
+    `status: sub-active-boundary explicit should be preserved, got ${lowerActive}`);
+
+  // A configured route's own sanitized explicit limit is surfaced.
+  const configuredExplicit = resolveStatusAutoCompactTokenLimit(
+    { contextWindow: 244800, autoCompactTokenLimit: 120000 }, active, null,
+  );
+  assert(configuredExplicit === 120000,
+    `status: configured explicit limit should surface, got ${configuredExplicit}`);
+}
+
+process.stdout.write('compact-trigger-migration smoke passed ✓\n');

package/scripts/fix-brief-fn.mjs

@@ -0,0 +1,35 @@
+import fs from "node:fs";
+const p = "src/runtime/shared/tool-surface.mjs";
+let s = fs.readFileSync(p, "utf8");
+const start = s.indexOf("export function summarizeAgentSurfaceBrief");
+const end = s.indexOf("function pluralize", start);
+if (start < 0 || end < 0) throw new Error("markers");
+const clean = `export function summarizeAgentSurfaceBrief(name, args, resultText, { isError = false, isResponse = false } = {}) {
+  const a = parseToolArgs(args);
+  const action = String(a?.type || a?.action || "").toLowerCase();
+  const text = String(resultText ?? "").trim();
+
+  if (isResponse && text) {
+    const fromResult = summarizeToolResult(name, args, text, isError);
+    if (fromResult) return truncateAgentSurfaceBrief(stripInlineMarkdown(fromResult));
+    const line = firstAgentResultLine(text);
+    if (line) return truncateAgentSurfaceBrief(stripInlineMarkdown(line));
+  }
+
+  const outbound = firstText(a?.prompt, a?.message);
+  if (outbound && (action === "spawn" || action === "send" || !action)) {
+    return truncateAgentSurfaceBrief(outbound);
+  }
+
+  if ((action === "spawn" || action === "send") && text && !isResponse) {
+    const fromResult = summarizeToolResult(name, args, text, isError);
+    if (fromResult) return truncateAgentSurfaceBrief(stripInlineMarkdown(fromResult));
+  }
+
+  return "";
+}
+
+`;
+s = s.slice(0, start) + clean + s.slice(end);
+fs.writeFileSync(p, s);
+console.log("summarizeAgentSurfaceBrief cleaned");

package/scripts/fix-format-tool-surface.mjs

@@ -0,0 +1,24 @@
+import fs from "node:fs";
+const p = "src/runtime/shared/tool-surface.mjs";
+let s = fs.readFileSync(p, "utf8");
+const block = `export function formatToolSurface(name, args, opts = {}) {
+  const parsed = parseToolArgs(args);
+  return {
+    label: displayToolName(name, parsed),
+    summary: summarizeToolArgs(name, parsed, opts),
+    normalizedName: normalizeToolName(name),
+    args: parsed,
+  };
+}
+
+`;
+while (s.includes(block)) {
+  s = s.replace(block, "");
+}
+const anchor = `/** Collapsed agent/worker surface card: one-line brief under the header (30-40 chars). */`;
+if (!s.includes(anchor)) throw new Error("anchor missing");
+if (!s.includes("export function formatToolSurface")) {
+  s = s.replace(anchor, block + anchor);
+}
+fs.writeFileSync(p, s);
+console.log("fixed formatToolSurface");

package/scripts/fix-tool-exec-visible.mjs

@@ -0,0 +1,42 @@
+import fs from "node:fs";
+const p = "src/tui/components/ToolExecution.jsx";
+let s = fs.readFileSync(p, "utf8");
+const bad = `  let visibleDetailLines = detailLines;
+  if (isSkillSurface && !showRawResult) {
+    visibleDetailLines = [];
+  } else if (isAgentSurfaceCard && !showRawResult) {
+    if (agentSurfaceBrief) {
+      visibleDetailLines = [agentSurfaceBrief];
+    } else if (pending) {
+      visibleDetailLines = [pendingDetailPlaceholder || 'Running'];
+    } else {
+      visibleDetailLines = [];
+    }
+  }
+  } else if (isAgentSurfaceCard && !showRawResult) {
+  } else if (isAgentSurfaceCard && !showRawResult) {
+    const agentDetailFallback = collapsedDetail
+      || (pending ? (pendingDetailPlaceholder || 'Running') : 'Finished');
+    const agentDetailLine = agentSurfaceBrief
+      || truncateToWidth(String(agentDetailFallback), Math.min(AGENT_SURFACE_BRIEF_MAX, maxResultChars));
+    visibleDetailLines = [agentDetailLine];
+  }`;
+const good = `  let visibleDetailLines = detailLines;
+  if (isSkillSurface && !showRawResult) {
+    visibleDetailLines = [];
+  } else if (isAgentSurfaceCard && !showRawResult) {
+    const agentDetailFallback = collapsedDetail
+      || (pending ? (pendingDetailPlaceholder || 'Running') : 'Finished');
+    const agentDetailLine = agentSurfaceBrief
+      || truncateToWidth(String(agentDetailFallback), Math.min(AGENT_SURFACE_BRIEF_MAX, maxResultChars));
+    visibleDetailLines = [agentDetailLine];
+  }`;
+if (s.includes(bad)) {
+  s = s.replace(bad, good);
+  fs.writeFileSync(p, s);
+  console.log("ToolExecution fixed");
+} else if (s.includes("agentDetailFallback")) {
+  console.log("ToolExecution already ok");
+} else {
+  throw new Error("ToolExecution pattern not found");
+}

package/scripts/generate-runtime-manifest.mjs

@@ -0,0 +1,166 @@
+#!/usr/bin/env node
+// generate-runtime-manifest.mjs
+// Aggregator step run after all matrix build jobs succeed.
+// Reads release assets via gh CLI, filters mixdog-runtime-*.tar.gz,
+// fetches sha256 from .sha256 sidecar files, and emits runtime-manifest.json
+// to both dist/ and src/runtime/memory/data/ (for the auto-PR).
+//
+// Environment:
+//   GITHUB_TOKEN  — PAT or GITHUB_TOKEN secret with contents:read
+//   RELEASE_TAG   — e.g. "runtime-v0.4.0" (falls back to process.argv[2])
+//   GITHUB_REPOSITORY — auto-set by Actions (e.g. "owner/repo")
+//   RUNTIME_RELEASE_REPOSITORY — override repo for gh commands (legacy trib-plugin/mixdog)
+
+import { execSync } from 'node:child_process';
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { tmpdir } from 'node:os';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = resolve(__dirname, '..');
+
+const RELEASE_TAG = process.env.RELEASE_TAG ?? process.argv[2];
+const REPO = process.env.RUNTIME_RELEASE_REPOSITORY || process.env.GITHUB_REPOSITORY || '';
+
+if (!RELEASE_TAG) {
+  console.error('ERROR: RELEASE_TAG env var or argv[2] required');
+  process.exit(1);
+}
+
+// ---------------------------------------------------------------------------
+// 1. List release assets via gh CLI
+// ---------------------------------------------------------------------------
+console.log(`Listing assets for release: ${RELEASE_TAG} (repo: ${REPO})`);
+
+let assetsJson;
+try {
+  assetsJson = execSync(
+    `gh release view ${RELEASE_TAG} --repo ${REPO} --json assets`,
+    { encoding: 'utf8', env: process.env }
+  );
+} catch (err) {
+  console.error('gh release view failed:', err.message);
+  process.exit(1);
+}
+
+const { assets } = JSON.parse(assetsJson);
+
+// Filter tarball assets
+const tarballs = assets.filter(a => /^mixdog-runtime-.+\.tar\.gz$/.test(a.name));
+console.log(`Found ${tarballs.length} tarball(s):`, tarballs.map(a => a.name));
+
+if (tarballs.length === 0) {
+  console.error('No mixdog-runtime-*.tar.gz assets found on release.');
+  process.exit(1);
+}
+
+// ---------------------------------------------------------------------------
+// 2. Parse version strings from a filename
+//    Format: mixdog-runtime-{os}-{arch}-pg{major}.{minor}-pgvector{vec}.tar.gz
+// ---------------------------------------------------------------------------
+const PG_RE = /pg(\d+)\.(\d+)/;
+const VEC_RE = /pgvector(\d+(?:\.\d+)+)/;
+
+let pgMajor = 16, pgMinor = 4, pgvectorVersion = '0.7.4';
+for (const t of tarballs) {
+  const pgM = PG_RE.exec(t.name);
+  const vM  = VEC_RE.exec(t.name);
+  if (pgM) { pgMajor = parseInt(pgM[1], 10); pgMinor = parseInt(pgM[2], 10); }
+  if (vM)  { pgvectorVersion = vM[1]; }
+  break; // all tarballs share the same version; just read the first
+}
+
+// ---------------------------------------------------------------------------
+// 3. Fetch sha256 sidecar content for each tarball
+// ---------------------------------------------------------------------------
+async function fetchSha256(sha256AssetName, _downloadUrl) {
+  // Try matching .sha256 sidecar from the asset list first
+  const sidecar = assets.find(a => a.name === sha256AssetName);
+  if (sidecar) {
+    // Download the sidecar file text
+    try {
+      const tmpDir = resolve(tmpdir(), 'mixdog-manifest-sha256');
+      mkdirSync(tmpDir, { recursive: true });
+      execSync(
+        `gh release download ${RELEASE_TAG} --repo ${REPO} --pattern ${sha256AssetName} --dir "${tmpDir}" --clobber`,
+        { encoding: 'utf8', env: process.env }
+      );
+      const content = readFileSync(resolve(tmpDir, sha256AssetName), 'utf8').trim();
+      // Format: "<hex>  <filename>"
+      return content.split(/\s+/)[0];
+    } catch (e) {
+      console.warn(`Could not download sidecar ${sha256AssetName}: ${e.message}`);
+    }
+  }
+  return 'TBD'; // fallback if sidecar not present
+}
+
+// ---------------------------------------------------------------------------
+// 4. Build asset map
+// ---------------------------------------------------------------------------
+const PLATFORM_RE = /mixdog-runtime-([a-z0-9]+)-([a-z0-9]+)-/;
+
+const assetsMap = {};
+
+for (const tarball of tarballs) {
+  const m = PLATFORM_RE.exec(tarball.name);
+  if (!m) { console.warn(`Skipping unrecognised tarball: ${tarball.name}`); continue; }
+  const key = `${m[1]}-${m[2]}`; // e.g. "linux-x64"
+
+  const sha256Key = `${tarball.name}.sha256`;
+  const sha256 = await fetchSha256(sha256Key, tarball.url);
+
+  assetsMap[key] = {
+    url:    tarball.url,
+    sha256,
+    size:   tarball.size ?? 0,
+  };
+}
+
+// Ensure all expected platforms are present (fill missing with TBD)
+const EXPECTED = ['linux-x64', 'linux-arm64', 'darwin-x64', 'darwin-arm64', 'win32-x64'];
+for (const p of EXPECTED) {
+  if (!assetsMap[p]) {
+    console.warn(`WARNING: No asset found for platform ${p} — filling with TBD`);
+    assetsMap[p] = { url: 'TBD', sha256: 'TBD', size: 0 };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// 5. Assemble manifest
+// ---------------------------------------------------------------------------
+const manifest = {
+  schema_version: 1,
+  generated_at:   new Date().toISOString(),
+  release_tag:    RELEASE_TAG,
+  pg: {
+    major: pgMajor,
+    minor: pgMinor,
+  },
+  pgvector: {
+    version: pgvectorVersion,
+  },
+  assets: assetsMap,
+};
+
+const manifestJson = JSON.stringify(manifest, null, 2) + '\n';
+console.log('Manifest:', manifestJson);
+
+// ---------------------------------------------------------------------------
+// 6. Write outputs
+// ---------------------------------------------------------------------------
+const distDir = resolve(ROOT, 'dist');
+mkdirSync(distDir, { recursive: true });
+
+const distPath   = resolve(distDir, 'runtime-manifest.json');
+const bundledPath = resolve(ROOT, 'src', 'runtime', 'memory', 'data', 'runtime-manifest.json');
+
+writeFileSync(distPath, manifestJson);
+console.log(`Written: ${distPath}`);
+
+mkdirSync(dirname(bundledPath), { recursive: true });
+writeFileSync(bundledPath, manifestJson);
+console.log(`Written: ${bundledPath}`);
+
+console.log('generate-runtime-manifest.mjs complete.');