mixdog 0.7.1

package/commands/config.md

@@ -0,0 +1,16 @@
+---
+description: Open the mixdog settings UI (Providers + Presets)
+allowed-tools: Bash(bun:*)
+---
+
+## Launch (already executed)
+
+- Launcher output: !`bun "${CLAUDE_PLUGIN_ROOT}/setup/launch.mjs"`
+
+The config UI launcher above has ALREADY run at command invocation — the
+settings window is opening (or open) at http://localhost:3458. Do NOT call
+`open_config` or re-run the launcher when the output above shows a
+"Config UI:" URL; just report that URL to the user.
+
+Only if the launcher output above shows an error instead of a URL, fall back
+to calling the `open_config` tool, then report the resulting URL.

package/commands/doctor.md

@@ -0,0 +1,13 @@
+---
+description: Run mixdog health diagnostics
+allowed-tools: Bash(bun:*)
+---
+
+<!--
+Checks version sync, Bun version/source, shell runtime, supervisor,
+hook-pipe reachability, config/data files, cache layout & storage sizes,
+voice runtime, required npm deps, and log sizes. Prints an OK/WARN/FAIL
+report; exits 1 on any FAIL.
+-->
+
+!`bun "${CLAUDE_PLUGIN_ROOT}/scripts/doctor.mjs"`

package/commands/setup.md

@@ -0,0 +1,17 @@
+---
+description: Open the mixdog initial setup UI
+allowed-tools: Bash(bun:*)
+disable-model-invocation: true
+---
+
+## Launch (already executed)
+
+- Launcher output: !`bun "${CLAUDE_PLUGIN_ROOT}/setup/launch.mjs"`
+
+The setup UI launcher above has ALREADY run at command invocation — the
+setup window is opening (or open) at http://localhost:3458. Do NOT call
+`open_config` or re-run the launcher when the output above shows a
+"Config UI:" URL; just report that URL to the user.
+
+Only if the launcher output above shows an error instead of a URL, fall back
+to calling the `open_config` tool, then report the resulting URL.

package/defaults/cycle3-review-prompt.md

@@ -0,0 +1,90 @@
+# Task
+
+You review user-curated CORE memory against the current project memory. Each
+entry is shown with its most-related current memory. Emit ONE verdict line per
+entry id. The system may conservatively apply safe compression updates and
+strict duplicate merges automatically; deletes and broad rewrites require
+explicit user confirmation. Extracting a lesson from a narrative is a BROAD
+rewrite — emit it only as a proposal (proposal mode), never as an auto-applied
+conservative "safe compression" update; conservative mode must not lossy-rewrite
+user-curated core. The first character of your response is a digit.
+Plain text — no preamble, JSON, or fences. NEVER attempt a tool call.
+
+## What CORE is
+
+CORE is durable standing knowledge that lands in one of three layers:
+
+- **L1 — Relationship / communication:** user identity, address form,
+  reply-style preferences, patterns the user dislikes.
+- **L2 — Behavior rules:** principles the user corrected or insisted on, hard
+  safety boundaries, quality bars.
+- **L3 — Current map:** one-line project-landscape summaries, live long-running
+  goals, environment anchors documented nowhere else.
+
+Every entry should be ONE short clause (≤120 chars). CORE is not a log.
+
+## The distinction that decides every verdict
+
+- An entry that DESCRIBES how something currently is — an L1/L2/L3 rule,
+  preference, goal, or live map entry — is DURABLE.
+- An entry that RECORDS a past event that already happened — a version shipped,
+  a value measured, a fix made — is NOT durable. For a past decision/failure,
+  keep only the one-line lesson that still constrains behavior (as L2); archive
+  the narrative. Extracting that lesson is a BROAD rewrite, so it belongs in a
+  proposal, not an auto-applied conservative update — conservative mode must not
+  lossy-rewrite user-curated core.
+- Anything whose source of truth is code, rules files, or skill docs — plus
+  implementation specs, code-internal constants, measurements, resolved-bug
+  stories, status snapshots — is NOT durable.
+
+When unsure which it is → keep.
+
+Related memory is evidence, not authority. Archived related rows may contain
+historical context or old work logs; use them only when they clearly prove a
+CORE entry is a past-event log, duplicate, or stale. If related memory is empty
+or inconclusive, keep the CORE entry.
+
+## Verdicts
+
+- `keep` — durable and already one short clause.
+- `update` — durable but verbose or multi-sentence → rewrite as one ≤120-char clause.
+- `merge` — duplicates another entry → fold into the survivor (same project pool).
+- `delete` — records a past event, not a current rule or structure; OR merely
+  restates a rule already in **Current rules** below (rules load every session,
+  so a CORE copy is redundant); OR is sourced from code, rules files, or skill
+  docs, or is an implementation spec, constant, measurement, resolved-bug
+  story, or status snapshot that fits no L1/L2/L3 layer. Do not delete an entry
+  that adds durable specifics the rule itself does not state.
+
+A verbose durable entry is always `update`, never `keep`.
+Delete is the rarest verdict. Prefer `keep` for durable rules/preferences and
+`update` for compression when the current behavior is still valid.
+
+## Current rules (Source Of Truth — loaded into the session every turn)
+
+These rules are always present, so a CORE entry that merely restates one is
+redundant → `delete`. Treat them as authority for the delete-on-restatement
+verdict only; an entry that is merely related but adds durable specifics the
+rule does not state stays `keep`/`update`.
+
+{{CURRENT_RULES}}
+
+## Entries to review
+
+Each block is one CORE entry followed by its most-related current memory.
+
+{{CORE_REVIEW}}
+
+## Output
+
+One line per entry id, any order:
+
+```
+<id>|keep
+<id>|update|<element>|<summary>
+<id>|merge|<target_id>|<source_ids_csv>
+<id>|delete
+```
+
+`summary` ≤120 chars, one clause. No literal `|` or newline inside a field
+(replace `|` with `/`). No prose, no fences. First character is a digit.

package/defaults/hidden-roles.json

@@ -0,0 +1,65 @@
+{
+  "roles": [
+    {
+      "name": "explorer",
+      "slot": "explore",
+      "systemFile": "rules/bridge/30-explorer.md",
+      "description": "Filesystem navigation agent invoked by the `explore` MCP tool",
+      "invokedBy": "explore",
+      "toolSchemaProfile": "unified",
+      "kind": "retrieval",
+      "permission": "read",
+      "stallCap": { "idleSeconds": 240, "toolRunningSeconds": 180 }
+    },
+    {
+      "name": "cycle1-agent",
+      "slot": "cycle1",
+      "systemFile": "rules/bridge/40-cycle1-agent.md",
+      "description": "Chunker/classifier invoked by memory-cycle runCycle1",
+      "invokedBy": "cycle1",
+      "toolSchemaProfile": "llm-only",      "kind": "maintenance",
+      "permission": "read",
+      "stallCap": { "idleSeconds": 300, "toolRunningSeconds": 300 }
+    },
+    {
+      "name": "cycle2-agent",
+      "slot": "cycle2",
+      "systemFile": "rules/bridge/41-cycle2-agent.md",
+      "description": "Root re-scorer invoked by memory-cycle runCycle2",
+      "invokedBy": "cycle2",
+      "toolSchemaProfile": "llm-only",      "kind": "maintenance",
+      "permission": "read",
+      "stallCap": { "idleSeconds": 300, "toolRunningSeconds": 300 }
+    },
+    {
+      "name": "cycle3-agent",
+      "slot": "cycle3",
+      "systemFile": "rules/bridge/42-cycle3-agent.md",
+      "description": "Core memory reviewer invoked by memory-cycle runCycle3",
+      "invokedBy": "cycle3",
+      "toolSchemaProfile": "llm-only",      "kind": "maintenance",
+      "permission": "read",
+      "stallCap": { "idleSeconds": 300, "toolRunningSeconds": 300 }
+    },
+    {
+      "name": "scheduler-task",
+      "slot": "scheduler",
+      "systemFile": "agents/scheduler-task.md",
+      "description": "Scheduled-task executor invoked by scheduler tick",
+      "invokedBy": "scheduler",
+      "toolSchemaProfile": "unified",      "kind": "maintenance",
+      "permission": "read-write",
+      "stallCap": { "idleSeconds": 600, "toolRunningSeconds": 600 }
+    },
+    {
+      "name": "webhook-handler",
+      "slot": "webhook",
+      "systemFile": "agents/webhook-handler.md",
+      "description": "Webhook payload handler invoked by inbound webhook events",
+      "invokedBy": "webhook",
+      "toolSchemaProfile": "unified",      "kind": "maintenance",
+      "permission": "read-write",
+      "stallCap": { "idleSeconds": 600, "toolRunningSeconds": 600 }
+    }
+  ]
+}

package/defaults/memory-chunk-prompt.md

@@ -0,0 +1,63 @@
+You are a strict memory chunker and classifier.
+
+Read the entries below, group contiguous related entries into memory chunks,
+and output pipe-separated lines only. No JSON, no prose, no fences, no preamble.
+The first character of your response must be a digit.
+
+## Output
+
+One line per chunk:
+
+```
+idx_csv|element|category|summary
+```
+
+- `idx_csv`: comma-separated 1-based input indexes. Use bare numbers.
+- `element`: short recall key, 5-10 words, with the subject and any distinctive
+  identifier.
+- `category`: exactly one of `rule`, `constraint`, `decision`, `fact`, `goal`,
+  `preference`, `task`, `issue`.
+- `summary`: compact declarative memory. Preserve decisive identifiers,
+  numbers, paths, versions, causes, outcomes, and constraints when present.
+- Fields must not contain literal `|` or newlines.
+
+## Chunking
+
+- Every substantive input should appear in exactly one chunk.
+- Omit entries whose only function is acknowledgement, courtesy, reaction, or
+  handoff and which add no fact, decision, constraint, result, preference, or
+  task.
+- Do not include non-substantive rows in a chunk merely because they are
+  adjacent to useful content.
+- Never merge across `[sess:...]` markers.
+- Split unrelated topics even when they are adjacent.
+- Keep question/context and answer/resolution together when they form one
+  cause-outcome memory.
+- If later entries supersede earlier ones, summarize the latest state while
+  keeping the relevant member ids together.
+
+## Categories
+
+- `rule`: standing operating rule or durable identity/system policy.
+- `constraint`: hard limit, prohibition, or approval boundary.
+- `decision`: explicit choice with a clear resolution moment.
+- `fact`: verified current state or observed technical detail.
+- `goal`: long-running target still in flight.
+- `preference`: user style or taste that may guide future behavior.
+- `task`: concrete work item with a done state or next step.
+- `issue`: bug, incident, broken state, or risk needing attention.
+
+Choose the category that best preserves future recall intent. Do not use
+`decision` unless a choice was actually made.
+
+## Quality
+
+- Use the same language as the input content.
+- Prefer one dense sentence; use two only when ambiguity would otherwise remain.
+- Do not pad thin content or speculate beyond the source.
+- Do not name speakers or describe the conversation mechanics.
+- Keep technical identifiers verbatim.
+
+## Entries
+
+{{ENTRIES}}

package/defaults/memory-promote-prompt.md

@@ -0,0 +1,135 @@
+# Task
+
+Judge generated memory candidates. Output pipe-separated lines only: no JSON,
+no prose, no fences, no tool calls. The first character of your response must
+be a digit.
+
+Example:
+
+For Entries numbered `1. id:... 2. id:... 3. id:... 4. id:...`:
+
+```
+1|archived
+2|active
+2|why|A|Durable reply-style preference; forgetting it changes future responses.
+2|core|user prefers terse one-line replies
+3|update|compact element|one-sentence durable summary
+3|why|B|Live project-map anchor documented nowhere else.
+3|core|current project layout summary
+4|merge|2|2,4|merged element|merged durable summary
+2|why|A|Same durable preference as the survivor.
+2|core|merged core line
+```
+
+## Required Lines
+
+Emit exactly one primary verdict for every Entry:
+
+The first field of every line MUST be the ROW NUMBER printed before the entry
+in Entries (the `<n>.` prefix, 1-based). One verdict per row; do not skip a row
+or invent a row number that is not listed.
+
+```
+<row>|active
+<row>|archived
+<row>|update|<element>|<summary>
+<row>|merge|<target_row>|<source_rows_csv>|<element>|<summary>
+```
+
+For every non-archived primary verdict (`active`, `update`, `merge`), also emit:
+
+```
+<row>|why|A|<short reason>
+<row>|core|<core_summary>
+```
+
+Use `why|A` for durable cross-session invariants (L1/L2). Use `why|B` for L3
+current-map entries: one-line project-landscape summaries, live long-running
+goals, and environment anchors documented nowhere else. `why` is validation
+evidence only; it is
+not stored. `core_summary` is injected into Core Memory, so keep it one
+self-contained clause, <=120 chars. For `merge`, `why` and `core` may use the
+survivor `target_row`.
+
+Allowed primary verbs:
+
+| Current status | Verbs |
+|---|---|
+| `pending` | `active`, `archived` |
+| `active` | `active`, `archived`, `update`, `merge` |
+
+## Source Of Truth
+
+Current rules load every session. User-curated core is canonical. If a
+candidate restates either source, archive it; do not promote duplicates.
+
+### Current Rules
+
+{{CURRENT_RULES}}
+
+### User-Curated Core
+
+{{USER_CORE}}
+
+### Active Generated Core
+
+{{CORE_MEMORY}}
+
+## Entries
+
+{{ITEMS}}
+
+Active: {{ACTIVE_COUNT}} / cap: {{ACTIVE_CAP}}
+
+## Decision Rule
+
+Long-term memory is exceptional. Keep ONLY content that lands in one of three
+layers:
+
+- **L1 — Relationship / communication:** user identity, address form,
+  reply-style preferences, and patterns the user dislikes. (`why|A`)
+- **L2 — Behavior rules:** principles the user corrected or insisted on during
+  work, hard safety boundaries, and quality bars. (`why|A`)
+- **L3 — Current map:** one-line project-landscape summaries, live
+  long-running goals, and environment anchors documented nowhere else. (`why|B`)
+
+**Transform rule.** For a past decision or failure, ask: *does a lesson from it
+still constrain today's behavior?* If yes → keep the one-line L2 lesson and
+archive the narrative. For an ACTIVE row, use `update` to rewrite it into the
+lesson. For a PENDING row (which allows only `active`/`archived`), promote with
+`active` and put the one-line lesson in its `core` line — pending rows cannot
+emit `update`. If no → archive. Anything whose source of truth is code, rules
+files, or skill docs → archive.
+
+Archive everything else: implementation specs, code-internal constants,
+measurements, resolved-bug stories, and status snapshots.
+
+The cap is an upper bound, not a target. When `Active < cap`, seed and grow the
+active set: a pending row with a concrete A/B reason that is NOT a
+Source-Of-Truth duplicate MUST be promoted with `active` — promotion is NOT
+reserved for already-active rows, and an empty active set must be bootstrapped
+from clear, non-duplicate A/B pending rows. When `Active > cap`, contract
+strictly: any active entry without a concrete A/B reason must archive.
+
+If useful content is buried inside work narrative, keep only the durable L2
+behavior lesson (via `update` on an active row, or `active` for a pending row);
+archive the surrounding story.
+
+## Merge / Update
+
+- `update` rewrites verbose durable entries into one short element and one
+  one-sentence summary.
+- `merge` only within the same project pool. The survivor is `target_row`.
+- Never merge across project_id boundaries.
+- `element` <=100 chars. `summary` <=200 chars. No literal `|` or newlines.
+- When a row genuinely fails the A/B bar or you are unsure it qualifies, prefer
+  `archived`. But never withhold `active` from a pending row that clearly meets
+  A/B merely because it is currently pending — clear, non-duplicate A/B pending
+  rows are promoted, not archived (rows that restate current rules or
+  user-curated core still archive per Source Of Truth).
+
+## Output
+
+Pipe lines only. No prose. First character must be a digit. Each line's first
+field MUST be the ROW NUMBER (`<n>.` prefix) shown before that entry in
+Entries. Emit one verdict per listed row; do not skip rows or invent numbers.

package/defaults/mixdog-config.template.json

@@ -0,0 +1,27 @@
+{
+  "channels": {
+    "promptInjection": {
+      "mode": "claude_md",
+      "targetPath": "~/.claude/CLAUDE.md"
+    }
+  },
+  "memory": {
+    "enabled": true,
+    "user": { "title": "" },
+    "cycle1": { "interval": "10m" },
+    "cycle2": { "interval": "1h" }
+  },
+  "search": {
+    "enabled": true,
+    "rawSearch": {
+      "maxResults": 10,
+      "credentials": {
+        "firecrawl": { "apiKey": "" },
+        "tavily": { "apiKey": "" },
+        "exa": { "apiKey": "" }
+      }
+    },
+    "requestTimeoutMs": 120000,
+    "crawl": { "maxPages": 10, "maxDepth": 2, "sameDomainOnly": true }
+  }
+}

package/defaults/user-workflow.json

@@ -0,0 +1,8 @@
+{
+  "roles": [
+    { "name": "worker", "preset": "sonnet-high", "permission": "full" },
+    { "name": "reviewer", "preset": "opus-high", "permission": "full" },
+    { "name": "debugger", "preset": "opus-high", "permission": "full" },
+    { "name": "tester", "preset": "sonnet-high", "permission": "full" }
+  ]
+}

package/defaults/user-workflow.md

@@ -0,0 +1,12 @@
+Default role assignment:
+- Implementation → worker
+- Verification → reviewer
+- Debugging → debugger
+- Testing → tester
+
+Cross-verification loop (1:1 worker↔reviewer pairing is the DEFAULT):
+- Pair every implementation worker 1:1 with its own reviewer: the moment a worker completes, immediately dispatch a dedicated reviewer scoped to that worker's files. Parallel fix workers get parallel paired reviewers — reviews never serialize behind one combined pass. Start the Lead self-check (syntax check, diff inspection, invariant verification) in parallel too.
+- When several workers touched interacting files, the LEAD performs ONE thin integration pass DIRECTLY (Lead self-check — NOT a dispatched reviewer; spawning another reviewer adds latency) to catch cross-file effects. Never replace the 1:1 paired reviewers with a single combined reviewer.
+- If a reviewer returns issues, dispatch a fix worker → re-pair it 1:1 with a reviewer. Repeat until every reviewer issues a clean verdict ("all issues resolved" / "ship-ready").
+- If issues require changing the original plan/spec (not just fixable bugs), halt the loop and report to the user. Resume only after the user updates the plan.
+- Do not report completion to the user before every reviewer's clean verdict. Mid-loop status updates may share round count and issue count but must not claim done.

package/hooks/hooks.json

@@ -0,0 +1,73 @@
+{
+  "description": "mixdog unified hooks",
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "startup|clear",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"${CLAUDE_PLUGIN_ROOT}/native/mixdog-shim/target/release/mixdog-shim.exe\" --part=rules",
+            "timeout": 30
+          },
+          {
+            "type": "command",
+            "command": "\"${CLAUDE_PLUGIN_ROOT}/native/mixdog-shim/target/release/mixdog-shim.exe\" --part=core",
+            "timeout": 130
+          },
+          {
+            "type": "command",
+            "command": "\"${CLAUDE_PLUGIN_ROOT}/native/mixdog-shim/target/release/mixdog-shim.exe\" --part=recap",
+            "timeout": 130
+          }
+        ]
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": "^mcp__plugin_mixdog_(?:mixdog|trib-plugin)__(?!(?:read|list|glob|grep|code_graph|find_symbol|find_references|find_callers|explore|recall|search|fetch|web_fetch|schedule_status|list_models|job_wait|download_attachment)$)",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"${CLAUDE_PLUGIN_ROOT}/native/mixdog-shim/target/release/mixdog-shim.exe\"",
+            "timeout": 10
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "Edit|Write|MultiEdit|Bash|NotebookEdit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"${CLAUDE_PLUGIN_ROOT}/native/mixdog-shim/target/release/mixdog-shim.exe\" --kind=post-tool",
+            "timeout": 5
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/turn-timer.cjs\" start",
+            "timeout": 10
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/turn-timer.cjs\" stop",
+            "timeout": 10
+          }
+        ]
+      }
+    ]
+  }
+}

package/hooks/lib/active-instance.cjs

@@ -0,0 +1,77 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const RUNTIME_ROOT = path.join(os.tmpdir(), 'mixdog');
+const ACTIVE_INSTANCE_FILE = path.join(RUNTIME_ROOT, 'active-instance.json');
+
+function parsePositivePid(value) {
+  const pid = Number(value);
+  return Number.isFinite(pid) && pid > 0 ? pid : null;
+}
+
+function readActiveInstance() {
+  try {
+    const active = JSON.parse(fs.readFileSync(ACTIVE_INSTANCE_FILE, 'utf8'));
+    return activeInstanceStaleReason(active) ? null : active;
+  } catch {
+    return null;
+  }
+}
+
+function getActiveOwnerPid(active) {
+  return parsePositivePid(active && active.ownerLeadPid)
+    || parsePositivePid(active && active.terminalLeadPid)
+    || parsePositivePid(active && active.supervisor_pid)
+    || parsePositivePid(active && active.instanceId);
+}
+
+function isPidAlive(pid) {
+  const n = parsePositivePid(pid);
+  if (!n) return false;
+  try {
+    process.kill(n, 0);
+    return true;
+  } catch (err) {
+    return err && err.code === 'EPERM';
+  }
+}
+
+function activeInstanceStaleReason(active) {
+  const ownerPid = getActiveOwnerPid(active);
+  if (!isPidAlive(ownerPid)) return `owner PID ${ownerPid || 'unknown'} is dead`;
+  const channelsPid = parsePositivePid(active && active.channels_pid);
+  if (channelsPid && !isPidAlive(channelsPid)) return `channels PID ${channelsPid} is dead`;
+  const workerPid = parsePositivePid(active && active.worker_pid);
+  if (workerPid && !isPidAlive(workerPid)) return `worker PID ${workerPid} is dead`;
+  const serverPid = parsePositivePid(active && active.server_pid);
+  if (serverPid && !isPidAlive(serverPid)) return `server PID ${serverPid} is dead`;
+  return '';
+}
+
+function getPermissionInstanceId(active) {
+  return getPermissionInstanceIds(active)[0] || '';
+}
+
+function getPermissionInstanceIds(active) {
+  const ids = [];
+  const ownerPid = parsePositivePid(active && active.ownerLeadPid)
+    || parsePositivePid(active && active.terminalLeadPid);
+  if (ownerPid) ids.push(String(ownerPid));
+  if (active && active.instanceId) ids.push(String(active.instanceId));
+  return [...new Set(ids.filter(Boolean))];
+}
+
+module.exports = {
+  ACTIVE_INSTANCE_FILE,
+  RUNTIME_ROOT,
+  activeInstanceStaleReason,
+  getActiveOwnerPid,
+  getPermissionInstanceId,
+  getPermissionInstanceIds,
+  isPidAlive,
+  parsePositivePid,
+  readActiveInstance,
+};