@dzhechkov/harness-cli 0.3.222 → 0.3.224

package/README.md

@@ -431,7 +431,7 @@ Get the whole set with `dz init --target claude-code --preset meta`, or pick one
 
 > **A skill and its npx toolkit are not duplicates — they're a graduation.** Several skills (e.g. `feature-adr`, `design-thinking`) exist BOTH as a skill inside a `dz` preset AND as a standalone `npx` package. The preset's SKILL.md is **fully functional on its own** (the whole methodology — modules + references — travels with it, and it auto-activates by description), and it's the only way to compile that capability to the **non-Claude platforms** (Codex/OpenCode/Hermes/OpenClaude) via `dz`. The npx package adds **project-level runtime governance** around the same skill: a slash command, governance rules, a context shard, and (for feature-adr) reward-learning + `/harvest`. So: pick the **skill/preset** for a working capability across platforms; pick the **npx toolkit** when you want it as a governed, command-driven fixture of one project.
 
-## All Commands (48)
+## All Commands (50)
 
 ```
 dz setup             --target <name> [--preset <name>] [--select id,id,...] [--skills-dir <dir>] [--memory agentdb] [--no-memory] [--no-hooks] [--install-driver] [--force]
@@ -482,6 +482,8 @@ dz project-skills    [--json] [--stages-json]   # polymorphic feature-adr: resol
 dz mr-rakes          [--json] [--candidate N --confirmed N] [--teach] [--gen-critic <path> [--apply]]   # mine review artifacts (features' QE reports + REVIEW files) for RECURRING mistakes; anti-noise (≥2/≥3 distinct sources); close into dz teach + a project-critic skill (R2 critic role)
 dz retro             [transcript] [--json] [--threshold N] [--no-teach] [--install-hook]   # per-session retro: mine the current session for recurring PROCESS rakes (claimed-done-without-verify, committed-without-verify, n-fix-cycles, ignored-correction), drill the user (socratic + checklist) AND teach the agent — co-learning via the dz teach store
 dz feature-adr-setup [--plan] [--from-spec <f>] [--apply]   # guided project onboarding engine (behind the `configure-feature-adr` skill): --plan shows which docs exist/missing; --from-spec scaffolds vision/map/testing/project-skills (propose; --apply writes; augment-never-clobber)
+dz challenge --plan <plan.md> [--json] [--context-only] [--author <model>]   # adversarial plan-gate (behind the `challenge-panel` skill): assemble a WIDE context pack (plan + vision + testing + map + degradations) + the fixed C1-C8 "break it" brief for a FRESH adversary (≠ plan author); advisory, never blocks
+dz routing [--stage <s>] [--json]   # inspect the learned cost-optimal routing store: what `args.models.<stage>='auto-cost'` believes per (stage, complexity-tier, model) — gated attempts/successes/rate (feeds feature-adr model selection)
 dz publish           [--filter <name>] [--bump-only] [--claim-check <off|warn|error>]   (dry-run by default; pass --yes/--confirm to go live; claim-check gate defaults to warn — surfaces README claim findings, never blocks)
 dz auto-canonicalize --source <github-url> --pack <skills-pack>
 dz sync-upstream     [--package <dir>] [--list] [--all]
@@ -1429,6 +1431,65 @@ retro: 2 recurring rake(s) to drill (from 6800 events):
 First-seen rakes accrue silently; only **recurring** ones get a drill (no nagging on a one-off). The user gets the
 drill, the agent gets the taught rule — from the same mistake, out of one shared `dz teach` store.
 
+### `dz challenge` — when you have an implementation plan and want it broken BEFORE you code
+
+The cross-model QE at feature-adr Step 8 catches problems *after* the code is written. The most expensive plan
+mistakes — overengineering, silent decisions, cemented bad patterns, test-theater, unrealistic scope — cement at
+the plan stage, and the plan's author can't see their own gaps. `dz challenge` assembles the "round"; the
+`challenge-panel` skill fires it at a FRESH adversary that did **not** write the plan:
+```bash
+dz challenge --plan features/my-feature/06_implementation_plan.md              # print the WIDE brief + C1-C8 + verdict schema
+dz challenge --plan features/my-feature/06_implementation_plan.md --context-only  # just what the panel will read + the adversary to use
+dz challenge --plan features/my-feature/06_implementation_plan.md --author codex  # who wrote the plan → prints the CROSS-family adversary
+```
+```
+challenge context for features/my-feature/06_implementation_plan.md:
+  plan:        ✓ 23752 chars
+  vision:      ✓ 2443 chars
+  testing:     ✗ (less calibration)
+  map:         ✓ 4470 chars
+  degradations:✓ 719 chars
+  → adversary: codex — plan authored on claude (Claude) → Codex adversary (cross-family)
+```
+The panel asks a fixed owner-question set in "break it, don't confirm it" mode — **C1** arch-anti-cement (a
+deviation from a pattern in `architecture/degradations.md` is *not* flagged), **C2** prod-ready, **C3** test
+sufficiency + honesty (both under- and over-testing), **C4** overengineering, **C5** silent decisions, **C6**
+runtime consistency, **C7** scope, **C8** executability. Every P0/P1 finding is **cross-validated** by a second
+independent agent (theory is dropped), and the verdict is **advisory — it never auto-blocks**. Two invariants:
+the panel is never the plan's own author (cross-family adversary), and the context pack is WIDE (a narrow slice
+yields shallow findings). In the feature-adr pipeline this runs automatically at the L/XL plan checkpoint; ad-hoc,
+just say **"прогони challenge на этот план"** / **"challenge this plan"**. Scaffold the degradations registry with
+`dz feature-adr-setup --from-spec <spec with {"degradations":true}> --apply`.
+
+### `dz routing` — when you want feature-adr to LEARN which model is worth paying for
+
+feature-adr can route a stage to a fixed model (`args.models.code='opus'`), but you may not know which model is
+actually worth it. The **`auto-cost`** spec learns from real outcomes: it picks the **cheapest** model whose
+learned success-rate is **≥0.7** at `(stage, complexity-tier)`, and a model whose code later **fails the Step-8
+QE gate is down-ranked** (success is *passing the gate*, not "returned something"). Grounded in rUv's shipped
+`MetaHarnessRouter`. Turn it on per stage:
+```js
+Workflow({ scriptPath: '.claude/workflows/feature-adr.js',
+  args: { slug, description, tier: 'L', models: { code: 'auto-cost', qe: 'auto-cost' } } })
+```
+```bash
+dz routing                    # the learned table — what auto-cost currently believes
+dz routing --stage code       # just the code stage
+dz routing --json             # raw store (.dz/routing-outcomes.json)
+```
+```
+Learned routing outcomes (what `auto-cost` currently believes):
+
+## code
+  L   sonnet         100% (4/4 gated, 4 provisional)
+  L   opus            60% (3/5 gated)
+```
+Cold-start (no history) walks a cheapest-first chain and escalates on failure; once a model clears the bar it is
+chosen directly. Two invariants held hard: `auto-cost` on the **qe** stage only ever ranks the **cross-family of
+the coder** (a model never self-QEs), and the whole thing is **opt-in** — with no `auto-cost` spec anywhere the
+pipeline is byte-identical and the store is never touched. Layered under the usage-adaptive override (a session
+near its limit still switches to Codex first). Storage is a plain JSON file — zero native deps.
+
 ## Recipes & FAQ
 
 Scenario → exact command → how to verify → gotcha. **Three gotchas worth calling out up front:**

package/dist/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAsNH,2EAA2E;AAC3E,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AA+0ID,wBAAsB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,GAAE,KAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAgI5E"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAkOH,2EAA2E;AAC3E,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAk8ID,wBAAsB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,GAAE,KAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAoI5E"}

package/dist/cli.js

@@ -9,7 +9,7 @@ import { fileURLToPath } from 'node:url';
 import { execSync } from 'node:child_process';
 import { homedir } from 'node:os';
 import { createRequire } from 'node:module';
-import { createSkill, getSkillInfo, getWorkflow, isTargetName, listSkills, runDoctor, runInit, benchmarkSkill, benchmarkSkills, scanMcp, reconcileCapabilities, RECONCILE_BANNER, buildRegistry, discoverSkillPackDirs, checkUpstream, compareSkills, checkAllUpstream, sweepSkillDrift, syncCanonicalSkill, checkUpgrades, discoverPackages, discoverSourcePackages, fetchAllDownloads, filterByCategory, pretrain, recommend, generatePlugin, publishPackages, runSetup, runMigrate, searchRegistry, runSync, runVerify, runInitAgentsMd, runInitGeminiMd, TARGET_NAMES, WORKFLOW_NAMES, importEcc, recordPattern, resolveLearningBackend, storeStats, consolidateSessions, pruneNoisePatterns, lessonDeltaReport, removePatternsByIds, snapshotStore, recallHybrid, teachGuard, mirrorPatternsToVector, vectorMirrorEnabled, vectorTierStatus, resolveVectorEngine, reindexVectorStore, harmonizeVectorStore, importRvfCheckpoint, statuslineData, writeFeatureAdrState, computeUsage, deriveUsageCalibration, normalizeClaudeUsageModelKey, readUsageLimits, claimCheck, summarize, queryBookKnowledge, loadStorePatternsSync, patternRecordId, loadStoreRecords, recordToPattern, bundleSkills, brainHome, listBrain, promoteProjectToBrain, updateBrainSource, queryBrain, groundPrompt, expandKu, reindexBrainVectors, buildPrimer, exportBrainSlice, importBrainSlice, registerKusToBrain, RECALL_USAGE_LOG_RELATIVE, RECALL_USAGE_LOG_MAX_BYTES, parseRecallUsageLog, buildRecallUsageReport, buildManifest, buildSbom, resolveTrustRoot, decideVerifyPolicy, decideProvenance, isInsideTree, signManifest, verifyManifest, assertKeyOutsideTree, decidePublishGate, MANIFEST_NAME, SBOM_NAME, buildArchitectureMap, renderMapHuman, findArchitectureDrift, renderDriftReport, scanWorkspacePackages, loadSubsystemManifest, loadProductVision, checkFeatureAgainstArchitecture, renderArchCheck, planProjectSkills, guidanceForStage, renderInjectionReport, analyzeCorpus, renderRakeReport, renderCriticSection, rakeAsLesson, rakeReward, DEFAULT_RAKE_THRESHOLDS, streamSessionEvents, findLatestTranscript, detectProcessRakes, buildRetro, renderRetro, retroLessonText, PROCESS_SIGNATURES, RETRO_DOMAIN, scanForSetup, buildSetupPlan, scaffoldFromSpec, renderScaffoldPreview, readExistingForScaffold, } from '@dzhechkov/harness-core';
+import { createSkill, getSkillInfo, getWorkflow, isTargetName, listSkills, runDoctor, runInit, benchmarkSkill, benchmarkSkills, scanMcp, reconcileCapabilities, RECONCILE_BANNER, buildRegistry, discoverSkillPackDirs, checkUpstream, compareSkills, checkAllUpstream, sweepSkillDrift, syncCanonicalSkill, checkUpgrades, discoverPackages, discoverSourcePackages, fetchAllDownloads, filterByCategory, pretrain, recommend, generatePlugin, publishPackages, runSetup, runMigrate, searchRegistry, runSync, runVerify, runInitAgentsMd, runInitGeminiMd, TARGET_NAMES, WORKFLOW_NAMES, importEcc, recordPattern, resolveLearningBackend, storeStats, consolidateSessions, pruneNoisePatterns, lessonDeltaReport, removePatternsByIds, snapshotStore, recallHybrid, teachGuard, mirrorPatternsToVector, vectorMirrorEnabled, vectorTierStatus, resolveVectorEngine, reindexVectorStore, harmonizeVectorStore, importRvfCheckpoint, statuslineData, writeFeatureAdrState, computeUsage, deriveUsageCalibration, normalizeClaudeUsageModelKey, readUsageLimits, claimCheck, summarize, queryBookKnowledge, loadStorePatternsSync, patternRecordId, loadStoreRecords, recordToPattern, bundleSkills, brainHome, listBrain, promoteProjectToBrain, updateBrainSource, queryBrain, groundPrompt, expandKu, reindexBrainVectors, buildPrimer, exportBrainSlice, importBrainSlice, registerKusToBrain, RECALL_USAGE_LOG_RELATIVE, RECALL_USAGE_LOG_MAX_BYTES, parseRecallUsageLog, buildRecallUsageReport, buildManifest, buildSbom, resolveTrustRoot, decideVerifyPolicy, decideProvenance, isInsideTree, signManifest, verifyManifest, assertKeyOutsideTree, decidePublishGate, MANIFEST_NAME, SBOM_NAME, buildArchitectureMap, renderMapHuman, findArchitectureDrift, renderDriftReport, scanWorkspacePackages, loadSubsystemManifest, loadProductVision, checkFeatureAgainstArchitecture, renderArchCheck, planProjectSkills, guidanceForStage, renderInjectionReport, analyzeCorpus, renderRakeReport, renderCriticSection, rakeAsLesson, rakeReward, DEFAULT_RAKE_THRESHOLDS, streamSessionEvents, findLatestTranscript, detectProcessRakes, buildRetro, renderRetro, retroLessonText, PROCESS_SIGNATURES, RETRO_DOMAIN, scanForSetup, buildSetupPlan, scaffoldFromSpec, renderScaffoldPreview, readExistingForScaffold, assembleChallengeContext, buildChallengeBrief, pickAdversaryModel, CHALLENGE_QUESTIONS, loadOutcomes, renderOutcomes, statsForKey, selectAutoCost, recordProvisional, finalizeOutcome, COST_LADDER, } from '@dzhechkov/harness-core';
 import { getPreset, PRESET_NAMES } from '@dzhechkov/harness-presets';
 import { scanGitHub, analyzeRepo, generateReport, deepAnalyze, scanAllSources, ScoutMemory } from '@dzhechkov/scout';
 const USAGE = `dz - DZ cross-platform harness CLI
@@ -4182,6 +4182,13 @@ function cmdFeatureAdrSetup(options, flags, cwd, write) {
         if (f.action === 'unchanged')
             continue; // never clobber
         const abs = resolve(repoRoot, f.path);
+        // Write-boundary augment-never-clobber guard (defense in depth): a 'create' must NEVER overwrite an
+        // existing file, even if the plan (built from a caller-supplied `existing`) said create. 'augment' has
+        // already union-merged the prior content, so overwriting there is the merged result, not a clobber.
+        if (f.action === 'create' && existsSync(abs)) {
+            write(`  · skipped ${f.path} — already exists (not overwritten)`);
+            continue;
+        }
         try {
             mkdirSync(dirname(abs), { recursive: true });
             writeFileSync(abs, f.content);
@@ -4195,6 +4202,120 @@ function cmdFeatureAdrSetup(options, flags, cwd, write) {
     write(`\n↳ wrote ${wrote} file(s). Verify: dz project-skills   +   dz architecture --revise`);
     return 0;
 }
+/**
+ * `dz challenge` — the deterministic "cartridge" behind the `challenge-panel` adversarial plan-gate (R6).
+ * Assembles a WIDE context pack (plan + vision + testing + map + degradations) and prints the fixed C1-C8
+ * "break it, don't confirm it" brief + the verdict schema. It runs NO LLM and writes nothing — the
+ * `challenge-panel` SKILL fires the brief at a FRESH adversary (a model ≠ the plan author) + a mandatory
+ * cross-validator. ADVISE, never block.
+ *   --plan <plan.md>      the plan under review (required)
+ *   --json                emit the assembled context + brief as JSON
+ *   --context-only        just the assembled context summary (what the panel will read)
+ *   --author <model>      the plan-author model → prints the cross-family adversary to dispatch (FR-4)
+ */
+function cmdChallenge(options, flags, cwd, write) {
+    let repoRoot = cwd;
+    try {
+        repoRoot = execSync('git rev-parse --show-toplevel', { cwd, encoding: 'utf-8' }).trim() || cwd;
+    }
+    catch { /* not git */ }
+    const planPath = options.get('plan');
+    if (planPath === undefined) {
+        write('dz challenge: pass --plan <plan.md> (the implementation plan to challenge).');
+        return 1;
+    }
+    const ctx = assembleChallengeContext(repoRoot, planPath);
+    if (ctx.plan === '') {
+        write(`dz challenge: plan not found or empty: ${planPath}`);
+        return 1;
+    }
+    const adversary = pickAdversaryModel(options.get('author') ?? 'claude');
+    if (flags.has('json')) {
+        write(JSON.stringify({ context: ctx, brief: buildChallengeBrief(ctx), adversary, questions: CHALLENGE_QUESTIONS }, null, 2));
+        return 0;
+    }
+    if (flags.has('context-only')) {
+        const has = (v) => (v === undefined ? '✗ (less calibration)' : `✓ ${v.length} chars`);
+        write(`challenge context for ${planPath}:`);
+        write(`  plan:        ✓ ${ctx.plan.length} chars`);
+        write(`  vision:      ${has(ctx.vision)}`);
+        write(`  testing:     ${has(ctx.testing)}`);
+        write(`  map:         ${has(ctx.map)}`);
+        write(`  degradations:${has(ctx.degradations)}`);
+        write(`  → adversary: ${adversary.model} — ${adversary.note}`);
+        return 0;
+    }
+    write(buildChallengeBrief(ctx));
+    write(`\n── dispatch (panel ≠ plan author) ──\n${adversary.model}: ${adversary.note}`);
+    return 0;
+}
+/**
+ * `dz routing` — inspect the learned cost-optimal routing outcome store (feature learned-cost-routing). Shows
+ * what `args.models[stage]='auto-cost'` currently believes per (stage, complexity-tier, model): gated
+ * attempts / successes / rate. Read-only.
+ *   --stage <s>   filter to one pipeline stage (code, qe, plan, …)
+ *   --json        raw store JSON
+ */
+function cmdRouting(options, flags, cwd, write) {
+    let repoRoot = cwd;
+    try {
+        repoRoot = execSync('git rev-parse --show-toplevel', { cwd, encoding: 'utf-8' }).trim() || cwd;
+    }
+    catch { /* not git */ }
+    const stage = options.get('stage');
+    const tier = options.get('tier');
+    const model = options.get('model');
+    // --select: resolve an `auto-cost` stage → the concrete model + escalate chain (the workflow shells out here
+    // because it is sandboxed with no fs). --family restricts to the coder's cross-family (qe guard); --ladder is
+    // the probe-filtered id set (account-specific Codex ids that answered).
+    if (flags.has('select')) {
+        if (!stage || !tier) {
+            write('dz routing --select needs --stage and --tier');
+            return 1;
+        }
+        const fam = options.get('family');
+        const family = fam === 'claude' || fam === 'openai' ? fam : undefined;
+        const ladderCsv = options.get('ladder');
+        let ladder;
+        if (ladderCsv !== undefined) {
+            const ids = new Set(ladderCsv.split(',').map((s) => s.trim()).filter(Boolean));
+            ladder = COST_LADDER.filter((r) => ids.has(r.id));
+        }
+        const statsFor = statsForKey(loadOutcomes(repoRoot), stage, tier);
+        const pick = selectAutoCost(stage, tier, statsFor, { ...(family ? { family } : {}), ...(ladder ? { ladder } : {}) });
+        write(JSON.stringify(pick));
+        return 0;
+    }
+    // --record-provisional / --finalize: the two-phase outcome label. The workflow calls these at stage end
+    // (provisional) and at the downstream gate (finalize, authoritative).
+    if (flags.has('record-provisional')) {
+        if (!stage || !tier || !model) {
+            write('dz routing --record-provisional needs --stage --tier --model');
+            return 1;
+        }
+        recordProvisional(repoRoot, stage, tier, model, flags.has('weak'));
+        write(`recorded provisional: ${stage}/${tier}/${model}${flags.has('weak') ? ' (weak-credit)' : ''}`);
+        return 0;
+    }
+    if (flags.has('finalize')) {
+        if (!stage || !tier || !model) {
+            write('dz routing --finalize needs --stage --tier --model --success <true|false>');
+            return 1;
+        }
+        const success = options.get('success') === 'true';
+        finalizeOutcome(repoRoot, stage, tier, model, success);
+        write(`finalized: ${stage}/${tier}/${model} → ${success ? 'success' : 'FAILURE'}`);
+        return 0;
+    }
+    // default / --json: inspect the learned table.
+    const store = loadOutcomes(repoRoot);
+    if (flags.has('json')) {
+        write(JSON.stringify(store, null, 2));
+        return 0;
+    }
+    write(renderOutcomes(store, stage));
+    return 0;
+}
 function cmdStats(cwd, write) {
     const baseDir = join(cwd, 'packages', '@dzhechkov');
     if (!existsSync(baseDir)) {
@@ -4452,6 +4573,10 @@ export async function runCli(argv, io = {}) {
                 return await cmdRetro(options, flags, cwd, write);
             case 'feature-adr-setup':
                 return cmdFeatureAdrSetup(options, flags, cwd, write);
+            case 'challenge':
+                return cmdChallenge(options, flags, cwd, write);
+            case 'routing':
+                return cmdRouting(options, flags, cwd, write);
             case 'dashboard':
                 return cmdDashboard(cwd, write);
             case 'roam':