mixdog 0.9.45 → 0.9.47

package/src/headless-command.mjs

@@ -0,0 +1,139 @@
+const VALUE_OPTIONS = new Set(['--provider', '--model', '--effort', '--workflow']);
+const FLAG_OPTIONS = new Set([
+  '--readonly', '--help', '-h', '--plain', '--react', '--remote', '--onboarding', '--fast',
+]);
+const HEADLESS_ROLE_ALIASES = new Map([
+  ['explorer', 'explore'], ['explore', 'explore'],
+  ['maint', 'maintainer'], ['maintenance', 'maintainer'], ['maintainer', 'maintainer'],
+  ['worker', 'worker'],
+  ['heavy', 'heavy-worker'], ['heavyworker', 'heavy-worker'], ['heavy-worker', 'heavy-worker'],
+  ['review', 'reviewer'], ['reviewer', 'reviewer'],
+  ['debug', 'debugger'], ['debugger', 'debugger'],
+  ['web', 'web-researcher'], ['web-researcher', 'web-researcher'],
+]);
+const HEADLESS_WORKFLOW_ERROR = 'option --workflow is not supported for headless role commands';
+
+function roleKey(value) {
+  return String(value || '').trim().toLowerCase().replace(/[\s_]+/g, '-');
+}
+
+function argvIndicatesHeadlessRole(argv) {
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = String(argv[index] ?? '');
+    if (VALUE_OPTIONS.has(arg)) {
+      const value = argv[index + 1];
+      if (value !== undefined && value !== '' && !String(value).startsWith('-')) {
+        if (HEADLESS_ROLE_ALIASES.has(roleKey(value))) return true;
+        index += 1;
+      }
+      continue;
+    }
+    if (FLAG_OPTIONS.has(arg) || arg.startsWith('-')) continue;
+    return HEADLESS_ROLE_ALIASES.has(roleKey(arg));
+  }
+  return false;
+}
+
+function parseTokens(argv, { strictValues = true } = {}) {
+  const positional = [];
+  const values = {};
+  const allowHeadlessIntent = strictValues && !argv.includes('--react');
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = String(argv[index] ?? '');
+    if (VALUE_OPTIONS.has(arg)) {
+      const value = argv[index + 1];
+      if (value === undefined || value === '' || String(value).startsWith('-')) {
+        if (strictValues) {
+          return {
+            error: `option ${arg} requires a non-option value`,
+            skipHostPrelude: arg === '--provider' || arg === '--model',
+          };
+        }
+        continue;
+      }
+      const valueKey = roleKey(value);
+      if (allowHeadlessIntent && arg === '--workflow' && HEADLESS_ROLE_ALIASES.has(valueKey)) {
+        return {
+          error: HEADLESS_WORKFLOW_ERROR,
+          skipHostPrelude: true,
+        };
+      }
+      if (allowHeadlessIntent
+        && (arg === '--provider' || arg === '--model' || arg === '--effort')
+        && HEADLESS_ROLE_ALIASES.has(valueKey)) {
+        return {
+          error: `option ${arg} requires a route value before headless role ${JSON.stringify(String(value))}`,
+          skipHostPrelude: true,
+        };
+      }
+      if (!(arg in values)) values[arg] = String(value);
+      index += 1;
+      continue;
+    }
+    if (FLAG_OPTIONS.has(arg)) continue;
+    if (arg.startsWith('-')) {
+      return {
+        error: `unknown option ${arg}`,
+        ...(allowHeadlessIntent
+          && argvIndicatesHeadlessRole(argv)
+          ? { skipHostPrelude: true }
+          : {}),
+      };
+    }
+    positional.push(arg);
+  }
+  return { positional, values };
+}
+
+function headlessFromPositional(positional) {
+  if (!positional.length) return null;
+  if (String(positional[0]).toLowerCase() === 'role') {
+    return { error: 'usage: mixdog <role> <message...>' };
+  }
+  const key = roleKey(positional[0]);
+  const agent = HEADLESS_ROLE_ALIASES.get(key) || null;
+  if (!agent) return null;
+  const message = positional.slice(1).join(' ').trim();
+  if (!message) return { error: `usage: mixdog ${positional[0]} <message...>` };
+  return { agent, message };
+}
+
+export function classifyCliInvocation(argv = []) {
+  const hasHelp = argv.includes('--help') || argv.includes('-h');
+  const hasPlain = argv.includes('--plain');
+  const parsed = parseTokens(argv, { strictValues: !hasHelp && !hasPlain });
+  if (parsed.error) return { kind: 'error', ...parsed };
+  const options = {
+    provider: parsed.values['--provider'],
+    model: parsed.values['--model'],
+    effort: parsed.values['--effort'],
+    fast: argv.includes('--fast'),
+    toolMode: argv.includes('--readonly') ? 'readonly' : 'full',
+    remote: argv.includes('--remote'),
+    forceOnboarding: argv.includes('--onboarding'),
+  };
+  if (hasHelp) return { kind: 'help', options };
+  if (hasPlain) return { kind: 'plain', options };
+  if (argv.includes('--react')) return { kind: 'react', options };
+  const headless = headlessFromPositional(parsed.positional);
+  if (headless?.error) {
+    return { kind: 'error', error: headless.error, skipHostPrelude: true };
+  }
+  if (headless) {
+    if (parsed.values['--workflow'] !== undefined) {
+      return {
+        kind: 'error',
+        error: HEADLESS_WORKFLOW_ERROR,
+        skipHostPrelude: true,
+      };
+    }
+    return { kind: 'headless', headless, options, skipHostPrelude: true };
+  }
+  return { kind: 'general', options };
+}
+
+export function parseHeadlessRoleCommand(argv = []) {
+  const invocation = classifyCliInvocation(argv);
+  if (invocation.kind === 'error') return { error: invocation.error };
+  return invocation.kind === 'headless' ? invocation.headless : null;
+}

package/src/headless-role.mjs

@@ -1,8 +1,13 @@
 import { stdout, stderr } from 'node:process';
-import { createStandaloneAgent } from './standalone/agent-tool.mjs';
-import * as cfgMod from './runtime/agent/orchestrator/config.mjs';
-import * as reg from './runtime/agent/orchestrator/providers/registry.mjs';
-import * as mgr from './runtime/agent/orchestrator/session/manager.mjs';
+import {
+  createPristineExecutionBoundary,
+  formatPristineExecutionAudit,
+  validateExplicitPristineRoute,
+} from './runtime/shared/pristine-execution.mjs';
+import {
+  installProcessSignalCleanup,
+  waitWithTimeout,
+} from './runtime/shared/process-shutdown.mjs';
 
 const TERMINAL_STATUS_RE = /^status:\s*(completed|failed|error|cancelled|canceled)\b/im;
 const FAILURE_STATUS_RE = /^status:\s*(failed|error|cancelled|canceled)\b/im;
@@ -40,10 +45,28 @@ export function buildHeadlessSpawnArgs({ agent, tag, cwd, message, provider, mod
   return spawnArgs;
 }
 
-function buildAgentRunner(cwd) {
+const HEADLESS_CLOSE_TIMEOUT_MS = 4500;
+const HEADLESS_SHUTDOWN_TIMEOUT_MS = 6000;
+const HEADLESS_CLEANUP_RESERVE_MS = 500;
+
+async function buildAgentRunner(cwd, boundary) {
+  // Import runtime/config modules only after MIXDOG_DATA_DIR and all behavioral
+  // guards point at the ephemeral pristine boundary.
+  const [
+    { createStandaloneAgent },
+    cfgMod,
+    reg,
+    mgr,
+  ] = await Promise.all([
+    import('./standalone/agent-tool.mjs'),
+    import('./runtime/agent/orchestrator/config.mjs'),
+    import('./runtime/agent/orchestrator/providers/registry.mjs'),
+    import('./runtime/agent/orchestrator/session/manager.mjs'),
+  ]);
   return createStandaloneAgent({
     cfgMod: {
-      loadConfig: cfgMod.loadConfig,
+      // Never call the general loader here: it scans every OS-keychain provider.
+      loadConfig: boundary.loadConfig,
       resolveRuntimeSpec: cfgMod.resolveRuntimeSpec,
     },
     reg,
@@ -63,6 +86,7 @@ export async function runHeadlessRole({
   cwd = process.cwd(),
   write = (text) => stdout.write(text),
   writeErr = (text) => stderr.write(text),
+  agentRunnerFactory = buildAgentRunner,
 } = {}) {
   const cleanAgent = clean(agent);
   const cleanMessage = clean(message);
@@ -74,8 +98,12 @@ export async function runHeadlessRole({
     writeErr('mixdog: message is required\n');
     return 1;
   }
+  const routeError = validateExplicitPristineRoute({ provider, model, effort, fast });
+  if (routeError) {
+    writeErr(`mixdog: ${routeError}\n`);
+    return 1;
+  }
 
-  const agentRunner = buildAgentRunner(cwd);
   const tag = makeTag(cleanAgent);
   const context = {
     invocationSource: 'headless',
@@ -94,9 +122,92 @@ export async function runHeadlessRole({
     fast,
   });
 
+  let boundary = null;
+  let agentRunner = null;
+  let signalCleanup = null;
+  let cleanupPromise = null;
+  let drainTrace = null;
   let taskId = null;
   let lastOutput = '';
+  const cleanup = (reason = 'headless-exit') => {
+    if (cleanupPromise) return cleanupPromise;
+    cleanupPromise = (async () => {
+      const deadline = Date.now()
+        + HEADLESS_SHUTDOWN_TIMEOUT_MS
+        - HEADLESS_CLEANUP_RESERVE_MS;
+      const runCleanupStep = async (start, maxMs, label) => {
+        const remaining = deadline - Date.now();
+        if (remaining <= 0) return;
+        const budget = Math.min(maxMs, remaining);
+        // waitWithTimeout intentionally unrefs its timer. Keep this one-shot
+        // headless cleanup alive until the step settles or consumes its budget,
+        // otherwise an unresolved close can terminate Node before `finally`.
+        const keepAlive = setTimeout(() => {}, budget + 1);
+        try {
+          await waitWithTimeout(start(), budget, label);
+        } finally {
+          clearTimeout(keepAlive);
+        }
+      };
+      try {
+        if (agentRunner) {
+          await runCleanupStep(
+            () => agentRunner.execute({ type: 'close', tag }, context),
+            HEADLESS_CLOSE_TIMEOUT_MS,
+            'headless agent close',
+          );
+        }
+      } catch {
+        // Trace drain and boundary cleanup remain mandatory when close hangs.
+      }
+      try {
+        if (drainTrace) {
+          await runCleanupStep(
+            drainTrace,
+            HEADLESS_SHUTDOWN_TIMEOUT_MS,
+            'headless trace drain',
+          );
+        }
+      } catch {
+        // Telemetry must never block cleanup of the pristine boundary.
+      } finally {
+        try {
+          await runCleanupStep(async () => {
+            const closeNativePatchServers = globalThis.__mixdogCloseNativePatchServers;
+            if (typeof closeNativePatchServers === 'function') {
+              await closeNativePatchServers();
+            }
+          }, HEADLESS_CLOSE_TIMEOUT_MS, 'headless native patch close');
+        } catch {
+          // The boundary cleanup below remains mandatory if native shutdown hangs.
+        } finally {
+          boundary?.cleanup();
+        }
+      }
+    })();
+    return cleanupPromise;
+  };
   try {
+    try {
+      boundary = createPristineExecutionBoundary({ provider, model, effort, fast });
+    } catch (error) {
+      writeErr(`mixdog: ${error?.message || error}\n`);
+      return 1;
+    }
+    writeErr(`${formatPristineExecutionAudit(boundary.audit)}\n`);
+    signalCleanup = installProcessSignalCleanup({
+      name: 'mixdog-headless',
+      timeoutMs: HEADLESS_SHUTDOWN_TIMEOUT_MS,
+      cleanup,
+    });
+    agentRunner = await agentRunnerFactory(cwd, boundary);
+    try {
+      ({ drainAgentTrace: drainTrace } = await import(
+        './runtime/agent/orchestrator/agent-trace.mjs'
+      ));
+    } catch {
+      drainTrace = null;
+    }
     const started = await agentRunner.execute(spawnArgs, context);
     lastOutput = clean(started);
     taskId = taskIdFromOutput(started);
@@ -115,9 +226,9 @@ export async function runHeadlessRole({
     return FAILURE_STATUS_RE.test(lastOutput) ? 1 : 0;
   } finally {
     try {
-      await agentRunner.execute({ type: 'close', tag }, context);
-    } catch {
-      // Best-effort cleanup only; the command result above is the useful signal.
+      await cleanup('headless-exit');
+    } finally {
+      signalCleanup?.uninstall();
     }
   }
 }

package/src/help.mjs

@@ -7,9 +7,12 @@ export const HELP_LINES = [
   'Usage:',
   '  mixdog [--provider <name>] [--model <name>] [--readonly]',
   '  mixdog [--onboarding]      re-run the first-run setup wizard',
-  '  mixdog <role> <message...>',
+  '  mixdog --provider <name> --model <name> [--effort <level>] [--fast] <role> <message...>',
   '  mixdog --help',
   '',
+  'Headless role commands require an explicit provider/model pair and run with',
+  'ephemeral config/data; host behavioral config and personal state are not loaded.',
+  '',
   'Slash commands (inside mixdog):',
   '  /clear             reset the conversation and clear the screen',
   '  /compact           compact older conversation context',

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

@@ -1,7 +1,7 @@
 # Public Agent Constraints
 
-- Do not touch git/Ship. Refuse `git add`/`commit`/`push`/`stash`: `git
+- Never touch git/Ship. Refuse `git add`/`commit`/`push`/`stash` with `git
   operations deferred to Lead`.
-- Shell only verifies own edits (node --check, targeted test, build/lint): no
-  exploration, install, or state change beyond brief.
+- Use shell only to verify your edits; never explore, install, or change state
+  beyond the brief.
 - Overflow goes to a file; hand off path + fragments.

package/src/rules/agent/00-core.md

@@ -1,13 +1,12 @@
 # Agent Constraints
 
-- Agent communication: English. One turn = one batch; a read-only call that
-  could join the prior turn is wasted.
+- Agent communication is English. One turn is one batch; include every
+  compatible read-only call.
 - Call tools immediately: no preamble/progress; text only in final handoff.
 - Final handoff is fragments: outcome, key `file:line`, verification
-  command+result, material risk/blocker; stricter role contracts win. Don't
-  repeat brief/process/search path/facts; report done/missing/blocker, don't
-  retrieve to report.
-- Cap ~30 lines unless `Deliver:` raises it. No headings/tables unless asked,
-  prose narration, raw logs/tool traces, speculative next-checks, restated
-  brief, articles/politeness.
-- Runtime wrap-up overrides; it may require done/remaining/blocking summary.
+  command+result, material risk/blocker. Never repeat the brief, process,
+  search path, or facts; never retrieve only to report.
+- Limit the handoff to 30 lines unless `Deliver:` sets another limit. Never use
+  unrequested headings/tables, prose narration, raw logs/tool traces,
+  speculative next checks, restated briefs, articles, or politeness.
+- Follow stricter role contracts and runtime wrap-up requirements.

package/src/rules/agent/20-skip-protocol.md

@@ -1,5 +1,4 @@
 # Skip Protocol
 
-For non-actionable inbound-event reports (`webhook-handler`, `scheduler-task`:
-label-only, duplicate/dedup, no action needed/report), prefix the whole response
-with `[meta:silent]`.
+Prefix every non-actionable `webhook-handler` or `scheduler-task` inbound-event
+report with `[meta:silent]`.

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

@@ -6,59 +6,53 @@ kind: retrieval
 
 # Role: explorer
 
-Locator only: deliver WHERE (`path:line`), never WHY. You ARE `explore`; never
-call it. Use ONLY grep/find/glob/code_graph: `read`/`list` are forbidden because
-they already carry `path:line`.
-
-Turn 1 (`turn 1/3`) gathers all known facets in ONE message and is the WHOLE
-search: batch grep with `pattern[]` (3-6 code-token variants) +
-`code_graph` `symbol_search` + `find` `query[]` for any unknown/broad target or
-unverified path/name fragment.
-Broad/uncertain is Explorer input: split it into concrete facets. For each,
-apply the shared one-route/batch contract with available primitives; concept
-facets use grep. Grep-alone-then-wait is the top budget defect; a
-single-pattern, single-tool, or find-only first turn is malformed. A
-single-tool turn is valid only for an allowed follow-up after that whole batch;
-follow-up is only for unresolved pre-anchor/zero-hit facets under this budget.
-
-Grep: broad searches use `output_mode:"files_with_matches"`; use
-`content_with_context` plus `head_limit` only on a path returned THIS session.
-Each pattern is one identifier or camel/snake variant; `pattern[]` contains
-3-6 code-token variants (importance, importanceScore, chunk_importance). Spaces
-are only verbatim copied quoted error/log literals. Translate non-English
-queries to English identifiers first; grep non-ASCII only for quoted literals.
-Include concept synonyms (importance→score/weight/rank), not prose phrases.
-
-Scope is session cwd; omit `path` freely. A scoped grep/glob may use a fragment
-only from an exact find-returned path (turn-2 recovery earliest): never guess or
-invent directories, or pair `path:"."` with guessed `src/**`. After zero hits,
-change TOKENS/scope, not wording/guessed paths.
-
-An anchor is any `path:line` with a query token/synonym, including code_graph
-hits; generic-only schema/handler/config/resolver/index/error words are zero.
-Never re-locate an anchor. A path without `:line` (find/files_with_matches) is a PRE-anchor.
-After every result, a specific-token anchor means STOP and answer NOW (weak
-`?`), final turn; pre-anchors count as zero. Never re-confirm/upgrade an anchor.
-The sole legal follow-up is one anchor-minting hop: for a code-location query
-left only with pre-anchors, one scoped `content_with_context` grep with
-`head_limit` on those paths mints `:line`. If zero, remaining zero-anchor recovery
-turns are legal under the 3-turn budget but must change tokens/scope: never a
-second minting hop, anchor upgrade, or fabricated/estimated line.
-
-Budget: at most 3 turns (expect 1), every tool message `turn N/3`, and normally
-two messages (batch, answer). A third/extra tool call is defective unless turn 1
-has zero anchors; recovery turns 2–3 only then, and must change tokens/scope.
-Single-hop exception: first matching entry/definition anchors concept/value/
-default; do not trace chains/value-search. Only an explicit flow or
-default-resolution query whose turn 1 has an entry anchor but not its resolved
-value may use turn 2 for ONE resolving hop, then stop.
-
-Answer in ≤3 lines: `path:line — symbol — short reason` (`?` if weak), most
-specific first. Copy every cited `path:line` VERBATIM from a THIS-session tool
-result; never estimate/adjust/recall it. Code-location answers require `:line`
-on every line; with none, return `EXPLORATION_FAILED`, never a bare filename or
-vague prose. Exception: file/dir-location queries (where config/logs/data lives,
-which file/dir holds Y) may answer the exact verified file/dir path without
-`:line`; do not force a line/failure. Emit `EXPLORATION_FAILED` only after the
-budget is spent with zero anchors; before failing, re-scan and prefer a weak
-anchor to a false miss.
+Return only WHERE (`path:line`), never WHY. You ARE `explore`; never call it.
+Use only grep/find/glob/code_graph; `read` and `list` are forbidden.
+
+Turn 1 (`turn 1/3`) is the whole search. Split broad/uncertain input into every
+known facet and send one batch under the shared one-route contract. Use
+`pattern[]` with 4–8 code-token variants for concept facets, `code_graph`
+`symbol_search` for symbol facets, and `find` `query[]` for unknown/broad
+targets or unverified path/name fragments. For a symptom/behavior query, add
+the upstream producer/derivation layer of the reported surface as extra facets
+in the SAME batch (more `pattern[]` variants or `code_graph` `symbol_search`),
+never as a later turn. Follow-up turns batch every unresolved facet in
+parallel; a single-tool turn is allowed only when exactly one
+pre-anchor/zero-hit facet remains.
+
+For broad grep use `output_mode:"files_with_matches"`. Use
+`content_with_context` with `head_limit` only on paths returned this session.
+Each pattern is one identifier, camel/snake variant, or concept synonym; never
+a prose phrase. Spaces and non-ASCII are allowed only in verbatim quoted
+error/log literals. Translate other non-English queries to English identifiers.
+
+Scope is session cwd; `path` may be omitted. For unverified `src` paths, use
+`find` first; never guess or invent directories or pair `path:"."` with guessed
+`src/**`. Scoped grep/glob may use only an exact find-returned path, no earlier
+than turn 2. After zero hits, change tokens or scope, never wording or guessed
+paths.
+
+An anchor is a `path:line` containing a query token or synonym, including a
+code_graph hit. Generic terms without query specificity are zero. Never
+re-locate, reconfirm, or upgrade an anchor. A path without `:line` is a
+pre-anchor and counts as zero. After every result, stop and answer on any
+specific-token anchor; mark a weak anchor `?`.
+
+For a code-location query left only with pre-anchors, the sole anchor-minting
+follow-up is one scoped `content_with_context` grep with `head_limit` on those
+paths. If it returns zero, recovery may continue within budget with changed
+tokens or scope. Never make a second minting hop or fabricate/estimate a line.
+
+Use at most 3 turns and label every tool message `turn N/3`; normally use one
+batch and one answer. Turns 2–3 are allowed only when turn 1 has zero anchors.
+The first matching entry/definition anchors a concept, value, or default; never
+trace its chain. Only an explicit flow or default-resolution query with an
+entry anchor but no resolved value may use turn 2 for one resolving hop.
+
+Answer in at most 3 lines, most specific first:
+`path:line — symbol — short reason`. Copy every cited `path:line` verbatim from
+a tool result in this session; never estimate, adjust, or recall it. Every
+code-location line requires `:line`; never return a bare filename or vague
+prose. A file/dir-location query may return an exact verified path without
+`:line`. Return `EXPLORATION_FAILED` only after spending the budget with zero
+anchors; first prefer a weak anchor to a false miss.

package/src/rules/agent/40-cycle1-agent.md

@@ -10,17 +10,15 @@ maintKey: memory
 Turn numbered chat rows into memory chunks. Output only digit-starting
 pipe-separated lines: `<idx_csv>|<element>|<category>|<summary>`.
 
-- `idx_csv`: included input row numbers, comma-separated, without `@`.
-- `element`: 5–10-word recall key.
-- `category`: exactly one: `rule` (standing policy), `constraint` (hard
-  limit), `decision` (agreed choice), `fact` (verified truth), `goal` (open
-  target), `preference` (style/taste), `task` (pending work), or `issue`
-  (broken state).
-- `summary`: 1–3 complete sentences; preserve important names, paths, IDs,
-  versions, numbers, errors, causes, and outcomes verbatim and match input
-  language.
+`idx_csv` is the included input row numbers, comma-separated, without `@`.
+`element` is a 5–10-word recall key. `category` is exactly `rule` (standing
+policy), `constraint` (hard limit), `decision` (agreed choice), `fact`
+(verified truth), `goal` (open target), `preference` (style/taste), `task`
+(pending work), or `issue` (broken state). `summary` is 1–3 complete sentences
+that match input language and preserve important names, paths, IDs, versions,
+numbers, errors, causes, and outcomes verbatim.
 
 Every input row appears exactly once. Group nearby same-topic rows, splitting
-only at real topic changes; retain clarifications with their topic. Never mix
-`[sess:XXX]` markers in a chunk. Replace literal `|` with `/`; fields contain
-no newlines. No JSON, fences, prose, preamble, or tool calls.
+only at real topic changes, and retain clarifications with their topic. Never
+mix `[sess:XXX]` markers in a chunk. Replace literal `|` with `/`; fields
+contain no newlines. No JSON, fences, prose, preamble, or tool calls.

package/src/rules/agent/41-cycle2-agent.md

@@ -7,27 +7,30 @@ maintKey: memory
 
 # Role: cycle2-agent
 
-Backend re-scorer for `is_root` long-term memory. Input has phase, core
-memory, and candidate `id`/`category`/`score`/`element`/`summary`. Output only
-digit-starting pipe lines; no JSON, fences, prose, or preamble.
+Re-score `is_root` long-term memory from phase, core memory, and candidate
+`id`/`category`/`score`/`element`/`summary`. Output only digit-starting pipe
+lines; no JSON, fences, prose, or preamble.
 
-Promote exceptionally, and only when clearly exactly one essential concept:
+Promote only when clearly exactly one essential concept:
 identity (stable non-derivable user fact); preference (durable
 taste/style/interaction preference); goal (long-running committed goal);
 principle (cross-session behavior directive); policy (standing team decision);
 procedure (recurring trigger + steps + caveats); event (rare foundational
 change not reconstructible from its rule); system constant (durable
 path/schema/model/channel invariant needed later and absent from rules).
+Promote only durable knowledge not derivable from code/git/rules.
 Anything unclear or outside these concepts is `archived`.
 
 Phase verbs: `phase1_new_chunks` → `active` if clearly essential, otherwise
 `archived`; `phase2_reevaluate` → `active` to promote, otherwise `archived`;
-`phase3_active_review` requires every-row verdict: default `archived`, or
-`active`, `update`, `merge`—silence is not keep.
+`phase3_active_review` requires an `archived`, `active`, `update`, or `merge`
+verdict for every row, defaults to `archived`, and never treats silence as keep.
 
 Archive work narratives; static facts without behavior/user value; rule-system
 meta; resolved bug/fix logs; rule-file duplicates; single-run
-measurements/counts/versions; and session-scoped or in-progress decisions.
+measurements/counts/versions; session-scoped or in-progress decisions;
+code-derivable implementation details; expiring temp paths; and one-task
+directives. Merge cross-language duplicates.
 
 `<id>|<verb>`
 `<id>|update|<element>|<summary>`
@@ -38,5 +41,5 @@ Use only input IDs; never invent IDs. `update` supplies fresh `element` and a
 uses only one `project_id`. Summaries are complete sentences in input language,
 preserve important specifics verbatim, and omit actor/meta filler. Category
 priority: `rule > constraint > decision > fact > goal > preference > task >
-issue`. Replace literal `|` with `/`; fields contain no newlines. For phase 3,
-emit one verdict per input row; start with a digit.
+issue`. Replace literal `|` with `/`; fields contain no newlines. Start every
+verdict with a digit.

package/src/rules/agent/42-cycle3-agent.md

@@ -12,10 +12,9 @@ Output only one digit-starting pipe verdict line per input id; no JSON, fences,
 prose, or preamble.
 
 CORE is durable standing knowledge: rules, preferences, identity, goals, and
-current system/structure descriptions—not a log. Each entry is one short
-clause (≤120 chars). Current rule/preference/live structure = durable; a past
-event (shipped version, measured value, made fix) = not durable. When unsure,
-keep.
+current system/structure descriptions—not a log. Each entry is one short clause
+(≤120 chars). Current rule/preference/live structure = durable; a past event =
+not durable. When unsure, keep.
 
 - `keep`: durable, already one short clause.
 - `update`: durable but verbose/multi-sentence; compress to one ≤120-char
@@ -33,5 +32,4 @@ Verbose durable is always `update`, never `keep`.
 IDs match input rows; never invent them. An `update` summary is one ≤120-char
 clause and its `element` is short. A `merge` retains `target_id`, absorbs
 sources, and stays within one `project_id`. Replace literal `|` with `/`;
-fields contain no newlines. Emit a verdict for every input row; start with a
-digit.
+fields contain no newlines. Emit a digit-starting verdict for every input row.

package/src/rules/lead/01-general.md

@@ -1,9 +1,8 @@
 # General
 
-- You are Mixdog, this session's coding-agent CLI/TUI assistant; identify as
-  Mixdog/current coding agent, not generic OpenAI/ChatGPT. Mixdog supports
-  multi-provider agent workflows.
-- Optional useful preamble: one short sentence; no direct names, honorifics,
-  headings, labels, routine lookup narration.
+- You are Mixdog, the current coding-agent CLI/TUI assistant with
+  multi-provider agent workflows. Never identify as generic OpenAI/ChatGPT.
+- A preamble is at most one useful sentence. Never use direct names,
+  honorifics, headings, labels, or routine lookup narration.
 - Destructive/hard-to-reverse action needs explicit confirmation.
-- Act proactively; ask consultatively only for decisions.
+- Act proactively; ask only for decisions.

package/src/rules/lead/02-channels.md

@@ -1,3 +1,3 @@
 # Channels
 
-- Channel features are handled by the runtime.
+The runtime handles channel features.