mixdog 0.7.1

package/agents/scheduler-task.md

@@ -0,0 +1,18 @@
+# Scheduler Task
+
+Scheduled channel task agent. Executes a cron-triggered run defined in the scheduler configuration.
+
+Stateless: each scheduled run is independent. Task instructions come from the schedule configuration.
+
+Per-entry config lives in `${CLAUDE_PLUGIN_DATA}/schedules/<name>/{config.json, instructions.md}` — `instructions.md` is the per-run brief, `config.json` holds time/timezone/days/channel/model.
+
+## Routing (by channel presence)
+
+Decided purely by `channel` presence in `config.json` — no `type`/`mode`/`role` field:
+
+- **No `channel`** → on fire, the task is injected into the current (Lead) session, handled with full context.
+- **With a `channel`** → this role runs as a direct dispatch and reports straight to that Discord channel (config carries the `model` preset).
+
+## Skip protocol
+
+When a run has nothing to report (no action needed, nothing changed, or a dedup/duplicate), emit `[meta:silent]` as the FIRST line and nothing else. This drops the notification entirely: zero Lead turn, zero channel post. See `rules/bridge/20-skip-protocol.md`. True skips only — never to suppress an actionable result.

package/agents/webhook-handler.md

@@ -0,0 +1,27 @@
+# Webhook Handler
+
+Webhook event analysis agent. Processes an inbound webhook delivery, extracts actionable information, and reports it.
+
+Stateless: each webhook event is processed independently. No context from prior webhooks.
+
+Per-entry config lives in `${CLAUDE_PLUGIN_DATA}/webhooks/<name>/{config.json, instructions.md}` — `instructions.md` is the per-delivery brief, `config.json` holds parser/secret/channel/model.
+
+## Routing (by channel presence)
+
+Decided purely by `channel` presence in `config.json` — no `mode`/`type`/`role` field:
+
+- **No `channel`** → the delivery is injected into the current (Lead) session, handled with full context.
+- **With a `channel`** → this role runs as a direct dispatch and reports the result straight to that Discord channel (config carries the `model` preset).
+
+## Skip protocol
+
+When a delivery has nothing to report — no code change, non-default branch, docs-only, or a dedup/duplicate event — emit `[meta:silent]` as the FIRST line and nothing else. This drops the notification entirely: zero Lead turn, zero channel post. See `rules/bridge/20-skip-protocol.md`. Use only for true skips, never to suppress an actionable finding.
+
+## Discipline
+
+- One read per concrete file:line evidence; never re-read the same file or paraphrase the same grep.
+- After 2 grep turns without a locked file:line, switch to `code_graph
+  find_symbol` / `callers` / `references`, or `mode:search` (keyword or
+  partial symbol name — file-less, before grep).
+- Response: keep narrative tight — `path:line` + one short cause + one suggested fix. Skip prelude, scope renegotiation, and closer questions.
+- Stop as soon as the issue is grounded; further tool calls without new evidence are wasted budget.

package/agents/worker.md

@@ -0,0 +1,24 @@
+Public bridge-worker tool discipline; the `explorer` role shares it.
+The universal bridge contract — `<final-answer>` output, git refusal —
+lives in rules/bridge/00-common.md; the tool routing policy lives in
+rules/shared/01-tool.md. This file adds only the public-worker edit +
+retrieval discipline.
+
+## Scope / Edits
+
+- Do only the brief; no unrelated features, cleanup, abstractions, or
+  error handling.
+- Prefer direct local changes.
+- Comment only when the WHY is non-obvious.
+- No compatibility shim inside your own change scope.
+- No unrelated rewrite.
+
+## Tools
+
+- Do not use `recall` or `search`.
+
+## Mismatch
+
+On coordinate mismatch, report
+`mismatch: at <path:line> expected '<X>' got '<Y>'`, then re-locate once
+via normal routing. Found -> continue; not found -> return partial findings.

package/bin/bridge

@@ -0,0 +1,133 @@
+#!/usr/bin/env bun
+// bridge — CLI prompt store + lightweight bridge for mixdog
+// Usage:
+//   bridge store <key> <file>   Store file content with key
+//   bridge store <key>          Read from stdin
+//   bridge list                 List stored keys
+//   bridge get <key>            Print stored content
+//   bridge delete <key>         Remove a key
+//   bridge <role> <prompt...>   Send prompt via owner HTTP (no server boot)
+//   bridge <role> -             Read prompt from stdin
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { tmpdir } from 'os';
+import { request } from 'http';
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+const { resolvePluginData } = require('../lib/plugin-paths.cjs');
+
+const STORE_PATH = join(
+  resolvePluginData(),
+  'prompt-store.json'
+);
+
+function load() {
+  if (!existsSync(STORE_PATH)) return {};
+  try { return JSON.parse(readFileSync(STORE_PATH, 'utf-8')); } catch { return {}; }
+}
+
+function save(store) {
+  mkdirSync(dirname(STORE_PATH), { recursive: true });
+  writeFileSync(STORE_PATH, JSON.stringify(store, null, 2) + '\n', 'utf-8');
+}
+
+function getOwnerPort() {
+  const activeFile = join(tmpdir(), 'mixdog', 'active-instance.json');
+  if (!existsSync(activeFile)) return null;
+  try {
+    const state = JSON.parse(readFileSync(activeFile, 'utf-8'));
+    return state.httpPort || null;
+  } catch { return null; }
+}
+
+function httpPost(port, path, body) {
+  return new Promise((resolve, reject) => {
+    const data = JSON.stringify(body);
+    const req = request({ hostname: '127.0.0.1', port, path, method: 'POST', headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(data) } }, res => {
+      const chunks = [];
+      res.on('data', c => chunks.push(c));
+      res.on('end', () => {
+        try { resolve(JSON.parse(Buffer.concat(chunks).toString())); }
+        catch { resolve({ raw: Buffer.concat(chunks).toString() }); }
+      });
+    });
+    req.on('error', reject);
+    req.write(data);
+    req.end();
+  });
+}
+
+const [,, cmd, ...rest] = process.argv;
+
+switch (cmd) {
+  case 'store': {
+    const [key, file] = rest;
+    if (!key) { console.error('Usage: bridge store <key> [file]'); process.exit(1); }
+    let content;
+    if (file) {
+      content = readFileSync(file, 'utf-8');
+    } else {
+      const chunks = [];
+      for await (const chunk of process.stdin) chunks.push(chunk);
+      content = Buffer.concat(chunks).toString('utf-8');
+    }
+    const store = load();
+    store[key] = content;
+    save(store);
+    console.log(`Stored '${key}' (${content.length} chars)`);
+    break;
+  }
+  case 'list': {
+    const store = load();
+    const keys = Object.keys(store);
+    if (keys.length === 0) { console.log('(empty)'); break; }
+    for (const k of keys) console.log(`${k} (${store[k].length} chars)`);
+    break;
+  }
+  case 'get': {
+    const [key2] = rest;
+    if (!key2) { console.error('Usage: bridge get <key>'); process.exit(1); }
+    const store = load();
+    if (!(key2 in store)) { console.error(`Key '${key2}' not found`); process.exit(1); }
+    console.log(store[key2]);
+    break;
+  }
+  case 'delete': {
+    const [key3] = rest;
+    if (!key3) { console.error('Usage: bridge delete <key>'); process.exit(1); }
+    const store = load();
+    if (!(key3 in store)) { console.error(`Key '${key3}' not found`); process.exit(1); }
+    delete store[key3];
+    save(store);
+    console.log(`Deleted '${key3}'`);
+    break;
+  }
+  default: {
+    const role = cmd;
+    if (!role || role.startsWith('-')) { console.error('Usage: bridge <role> <prompt...> | bridge <role> - (stdin)'); process.exit(1); }
+    const port = getOwnerPort();
+    if (!port) { console.error('No running mixdog instance found'); process.exit(1); }
+    const body = { role };
+    if (rest[0] === '-') {
+      const chunks = [];
+      for await (const chunk of process.stdin) chunks.push(chunk);
+      body.prompt = Buffer.concat(chunks).toString('utf-8').trim();
+    } else if (rest.length) {
+      body.prompt = rest.join(' ');
+    } else {
+      console.error('Usage: bridge <role> <prompt...> | bridge <role> - (stdin)');
+      process.exit(1);
+    }
+    try {
+      const result = await httpPost(port, '/bridge', body);
+      const text = result?.content?.[0]?.text || JSON.stringify(result);
+      console.log(text);
+    } catch (e) {
+      console.error(`bridge failed: ${e.message}`);
+      process.exit(1);
+    }
+    break;
+  }
+}

package/bin/statusline-launcher.mjs

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+// mixdog statusline launcher — version-independent STABLE entry.
+// settings.json points here forever; each tick it resolves the ACTIVE
+// install from installed_plugins.json (never a version-pinned path), so a
+// plugin version bump self-heals on the next refresh with no restart.
+// Node-builtins only — must run under both bun and node.
+//
+// FAIL-SOFT INVARIANT (non-negotiable): this command runs for EVERY machine
+// on every tick. ANY error (missing/locked/parse-broken manifest, missing
+// target, throw) must still print one minimal `mixdog` line and exit 0. A
+// crashing command makes CC render nothing.
+
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { spawnSync } from 'child_process';
+import { pathToFileURL } from 'url';
+
+function failSoft() {
+  try { process.stdout.write('mixdog\n'); } catch {}
+  process.exit(0);
+}
+
+async function main() {
+  // CC stdin JSON (may be empty). Never block the tick on a read error.
+  let stdinBuf = Buffer.alloc(0);
+  try { stdinBuf = fs.readFileSync(0); } catch {}
+
+  // Resolve the ACTIVE install from the manifest — manifest-canonical, no
+  // version pin. Any failure here → fail-soft.
+  const manifestPath = path.join(
+    os.homedir(), '.claude', 'plugins', 'installed_plugins.json'
+  );
+  let installPath = '';
+  try {
+    const data = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    const entry = data?.plugins?.['mixdog@trib-plugin']?.[0];
+    installPath = String(entry?.installPath || '').replace(/\\/g, '/');
+  } catch { return failSoft(); }
+  if (!installPath) return failSoft();
+
+  // (a) Native shim fast path — match resolveStatusLineCommand's os/arch map.
+  const ext = process.platform === 'win32' ? '.exe' : '';
+  const platMap = { win32: 'windows', darwin: 'macos', linux: 'linux' };
+  const archMap = { x64: 'x86_64', arm64: 'aarch64' };
+  const prebuiltDir = `${platMap[process.platform]}-${archMap[process.arch]}`;
+  const shimCandidates = [
+    `${installPath}/native/mixdog-shim/target/release/mixdog-shim${ext}`,
+    `${installPath}/native/prebuilt/${prebuiltDir}/mixdog-shim${ext}`,
+  ];
+  for (const shimPath of shimCandidates) {
+    let exists = false;
+    try { exists = fs.existsSync(shimPath); } catch {}
+    if (!exists) continue;
+    try {
+      const r = spawnSync(shimPath, ['--kind=statusline'], { input: stdinBuf, windowsHide: true });
+      if (r.status === 0 && r.stdout && r.stdout.length) {
+        process.stdout.write(r.stdout);
+        return process.exit(0);
+      }
+    } catch {}
+    // Shim present but failed — fall through to the lib path / fail-soft.
+    break;
+  }
+
+  // (b) Library fallback — render in-process via statusline-lib's export.
+  const libPath = `${installPath}/bin/statusline-lib.mjs`;
+  let mod;
+  try { mod = await import(pathToFileURL(libPath).href); } catch { return failSoft(); }
+  const render = mod && mod.renderStatusLine;
+  if (typeof render !== 'function') return failSoft();
+  let out = '';
+  try { out = await render(stdinBuf.toString('utf8')); } catch { return failSoft(); }
+  process.stdout.write(out && out.length ? out : 'mixdog\n');
+  process.exit(0);
+}
+
+main().catch(failSoft);