@dzhechkov/harness-cli 0.3.222 → 0.3.224

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dzhechkov/harness-cli",
-  "version": "0.3.222",
+  "version": "0.3.224",
   "description": "The dz CLI — install AI skills for Claude Code, Codex, OpenCode, Hermes, OpenClaude, GitHub Copilot. 35 commands, 13 presets, 6 platform targets.",
   "type": "module",
   "license": "MIT",
@@ -55,7 +55,7 @@
     "@dzhechkov/skills-reverse-engineering": "^0.1.0",
     "@dzhechkov/skills-presentation-storyteller": "^0.1.0",
     "@dzhechkov/skills-website-cloner": "^0.1.0",
-    "@dzhechkov/harness-core": "0.3.116"
+    "@dzhechkov/harness-core": "0.3.118"
   },
   "devDependencies": {
     "@types/node": "^25.6.0",

package/src/cli.ts

@@ -140,7 +140,19 @@ import {
   scaffoldFromSpec,
   renderScaffoldPreview,
   readExistingForScaffold,
+  assembleChallengeContext,
+  buildChallengeBrief,
+  pickAdversaryModel,
+  CHALLENGE_QUESTIONS,
+  loadOutcomes,
+  renderOutcomes,
+  statsForKey,
+  selectAutoCost,
+  recordProvisional,
+  finalizeOutcome,
+  COST_LADDER,
 } from '@dzhechkov/harness-core';
+import type { Family, ModelRung } from '@dzhechkov/harness-core';
 import type { SetupSpec } from '@dzhechkov/harness-core';
 import type { ProvenanceMode, PackVerdict, ClaudeUsageModel, PatternRecord, TargetName, BookKU, HarmonizeReport, UsageCalibrationPlan, ClaimFinding, RecallUsagePatternRow } from '@dzhechkov/harness-core';
 import { getPreset, PRESET_NAMES } from '@dzhechkov/harness-presets';
@@ -4485,6 +4497,13 @@ function cmdFeatureAdrSetup(options: Map<string, string>, flags: Set<string>, cw
   for (const f of result.files) {
     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);
@@ -4496,6 +4515,114 @@ function cmdFeatureAdrSetup(options: Map<string, string>, flags: Set<string>, cw
   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: Map<string, string>, flags: Set<string>, cwd: string, write: Write): number {
+  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: string | undefined): string => (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: Map<string, string>, flags: Set<string>, cwd: string, write: Write): number {
+  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: Family | undefined = fam === 'claude' || fam === 'openai' ? fam : undefined;
+    const ladderCsv = options.get('ladder');
+    let ladder: readonly ModelRung[] | undefined;
+    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: string, write: Write): number {
   const baseDir = join(cwd, 'packages', '@dzhechkov');
   if (!existsSync(baseDir)) {
@@ -4770,6 +4897,10 @@ export async function runCli(argv: string[], io: CliIo = {}): Promise<number> {
         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':