@dzhechkov/harness-core 0.3.138 → 0.3.141

package/src/index.ts

@@ -96,7 +96,7 @@ export type {
 export { runSetup, generateHooksConfig, generateAgentdbWriter, writerVersionOf, AGENTDB_WRITER_VERSION } from './setup.js';
 export { statuslineData, readFeatureAdrState, writeFeatureAdrState, featureAdrStatePath } from './statusline.js';
 export type { StatuslineData, FeatureAdrState, WriteFeatureAdrStateInput } from './statusline.js';
-export { indexPatternsToAgentdb, resolveAgentdbPath, searchAgentdbPatterns, listAgentdbDzIds, resolveAgentdbEmbedder, cosineSimilarity, importVectorsToAgentdb, reindexAgentdbRows, bumpAgentdbUses, clearAgentdbQuarantine } from './agentdb-index.js';
+export { indexPatternsToAgentdb, resolveAgentdbPath, searchAgentdbPatterns, listAgentdbDzIds, resolveAgentdbEmbedder, cosineSimilarity, importVectorsToAgentdb, reindexAgentdbRows, bumpAgentdbUses, clearAgentdbQuarantine, deleteAgentdbByDzIds, readAgentdbRowsByTaskType, DZ_OWNED_TASK_TYPES } from './agentdb-index.js';
 export type { AgentdbSearchHit, AgentdbSearchResult, AgentdbImportRow } from './agentdb-index.js';
 export { DEFAULT_EMBED_MODEL, LEGACY_EMBED_MODEL, DEFAULT_EMBED_DIM, KNOWN_EMBED_DIMS, resolveEmbedModel, readEmbedManifest, writeEmbedManifest, embedManifestPath, legacyEmbedManifest } from './embedding-config.js';
 export type { EmbedModelConfig, EmbedModelSource, EmbedManifest } from './embedding-config.js';
@@ -326,3 +326,12 @@ export * from './skills-verify.js';
 // from darwin-mode; measurements are dz-native and NEVER fake a verdict (INSUFFICIENT_DATA is a
 // finding, not a pass).
 export * from './compounding.js';
+
+// Run-process scorecard (feature dz-score, Reading C) — scores the DISCIPLINE of a feature-adr run
+// from its artifacts. Descriptive-only, permanently: it never gates.
+export * from './score.js';
+
+// Smart Backlog (feature smart-backlog) — goal-directed idea pipeline: capture → semantic dedup
+// against the EXISTING Brain vector engine (ADR-001, no 2nd store) → GoalMap alignment (ADR-003) →
+// weighted roulette (ADR-004) → idea2prd enrich hand-off → stub-first Jira adapter seam (ADR-006).
+export * from './backlog.js';

package/src/score.ts

@@ -0,0 +1,220 @@
+/**
+ * `dz score --slug <feature>` — score a feature-adr RUN's process discipline (feature dz-score,
+ * Reading C of `features/dz-score/PROPOSAL.md`, chosen by the user 2026-07-28).
+ *
+ * It scores the PROCESS, not the code: were the ADR's safety properties given a named test? was
+ * discrimination proven? did cross-model QE happen and what did it say? was the work verified live?
+ * did the READMEs travel in the same change? did the learning loop run?
+ *
+ * Readings A (repo dashboard) and B (skill scoring) were rejected in the proposal: A invites
+ * Goodharting the gates, B would be a fourth scoring surface. C is hard to game — the only way to
+ * score well is to actually run the discipline.
+ *
+ * DESCRIPTIVE-ONLY, permanently: the command never gates, never exits non-zero on a low score.
+ * The health-advisor 1.2.0 run is the reference case: its QE report marked the registration
+ * criterion "✅ (mechanism)" with no live evidence — this scorecard exists to make that visible.
+ *
+ * Discriminators were chosen from a SURVEY of the 132 real runs on disk (34/77 ADRs carry a
+ * Confirmation section; 31/75 QE reports carry MEASURED markers) — not guessed.
+ *
+ * PURE: the CLI reads the artifact files; this module only classifies.
+ */
+
+export type DisciplineVerdict = 'pass' | 'partial' | 'absent';
+
+export interface DisciplineScore {
+  readonly id: string;
+  readonly title: string;
+  readonly verdict: DisciplineVerdict;
+  /** The line of evidence the verdict rests on — a scorecard must show its work. */
+  readonly evidence: string;
+}
+
+export interface RunScorecard {
+  readonly slug: string;
+  readonly disciplines: readonly DisciplineScore[];
+  /** Extracted cross-model grade, when one exists (e.g. "A−", "C"). */
+  readonly qeGrade: string | null;
+  readonly passed: number;
+  readonly total: number;
+  readonly summary: string;
+}
+
+/** The artifact texts of one run, keyed by RELATIVE path under `features/<slug>/`. */
+export type RunArtifacts = Readonly<Record<string, string>>;
+
+function collect(artifacts: RunArtifacts, predicate: (path: string) => boolean): string {
+  return Object.entries(artifacts)
+    .filter(([p]) => predicate(p))
+    .map(([, text]) => text)
+    .join('\n');
+}
+
+/** First matching line (trimmed, capped) — the evidence a verdict shows. */
+function evidenceLine(text: string, re: RegExp): string | null {
+  for (const line of text.split('\n')) {
+    if (re.test(line)) return line.trim().slice(0, 140);
+  }
+  return null;
+}
+
+/**
+ * Like {@link evidenceLine}, but a NEGATED mention is not evidence: "Codex was not used" and
+ * "no discrimination proof was performed" both satisfied the plain regexes (Codex QE #1, and its
+ * heuristic table). A line whose match is preceded by a negation word is skipped. Heuristic — but
+ * the failure mode flips from a silent false pass to a visible miss the shown evidence exposes.
+ */
+const NEGATION_RE = /\b(no|not|never|without|wasn'?t|isn'?t)\b/i;
+function evidenceLinePositive(text: string, re: RegExp): string | null {
+  for (const line of text.split('\n')) {
+    if (!re.test(line)) continue;
+    // Whole-line negation: "Codex was NOT used" carries its negation AFTER the match, so a
+    // before-the-match check missed it. The trade is deliberate: a genuine line that happens to
+    // contain a negation is SKIPPED (a visible miss the evidence exposes) rather than a negated
+    // line being ACCEPTED (a silent false pass).
+    if (NEGATION_RE.test(line)) continue;
+    return line.trim().slice(0, 140);
+  }
+  return null;
+}
+
+// Word-bounded on BOTH sides: "upgrade B-tree" fabricated a B- (Codex QE #1). The lookahead also
+// rejects "Grade B-tree" (letter after the dash) while keeping the real "Grade: A−" formats.
+const GRADE_RE = /(?<![A-Za-z])[Gg]rade[d]?:?\s*\*{0,2}\s*([A-F][+−-]?)(?![A-Za-z-])/;
+
+export function extractQeGrade(qeText: string): string | null {
+  const m = GRADE_RE.exec(qeText);
+  return m?.[1] ?? null;
+}
+
+export function scoreRun(slug: string, artifacts: RunArtifacts): RunScorecard {
+  const adrText = collect(artifacts, (p) => p.startsWith('03_adr/'));
+  const qeText = collect(artifacts, (p) => p === '08_qe_report.md' || p === '09_fleet_qe_assessment.md');
+  const planText = collect(artifacts, (p) => p === '06_implementation_plan.md' || p === '03.5_ideation_report.md');
+  const complexityText = collect(artifacts, (p) => p === '00_complexity_assessment.md');
+  const manifestText = collect(artifacts, (p) => p.startsWith('07_code_changes/'));
+  const allText = collect(artifacts, () => true);
+
+  const disciplines: DisciplineScore[] = [];
+  const add = (id: string, title: string, verdict: DisciplineVerdict, evidence: string): void => {
+    disciplines.push({ id, title, verdict, evidence });
+  };
+
+  // 1. ADR with a Confirmation — a named decision whose load-bearing property names its test.
+  if (adrText === '') {
+    add('adr-confirmation', 'ADR present, property → named test', 'absent', 'no 03_adr/*.md artifact');
+  } else {
+    const conf = evidenceLine(adrText, /^##+\s*Confirmation/i);
+    add(
+      'adr-confirmation',
+      'ADR present, property → named test',
+      conf !== null ? 'pass' : 'partial',
+      conf ?? 'ADR exists but has no Confirmation section — the load-bearing property names no test',
+    );
+  }
+
+  // 2. Discrimination — proof the test can FAIL (the §42 gate, or an explicit mutation proof).
+  const discr =
+    evidenceLinePositive(allText, /discrimination|§42/i) ??
+    evidenceLinePositive(allText, /mutation[s]?\s.*(prov|kill)|mutant[s]?\s.*(kill|red)|RED on the old|goes? RED|failed as expected/i);
+  add(
+    'discrimination',
+    'the property test is proven able to fail',
+    discr !== null ? 'pass' : 'absent',
+    discr ?? 'no discrimination/§42/mutation-proof evidence in any artifact',
+  );
+
+  // 3. Cross-model QE — an independent family reviewed it, and a grade exists.
+  const grade = extractQeGrade(qeText);
+  if (qeText === '') {
+    add('cross-model-qe', 'independent cross-model review with a grade', 'absent', 'no 08_qe_report.md artifact');
+  } else {
+    const crossLine = evidenceLinePositive(qeText, /codex|gpt-|cross-model/i);
+    const gradeLine = grade !== null ? evidenceLine(qeText, GRADE_RE) : null;
+    add(
+      'cross-model-qe',
+      'independent cross-model review with a grade',
+      crossLine !== null && grade !== null ? 'pass' : 'partial',
+      crossLine !== null
+        ? grade !== null
+          ? `${crossLine}${gradeLine !== null && gradeLine !== crossLine ? ` | ${gradeLine}` : ''}`.slice(0, 140)
+          : `${crossLine} — but NO parseable grade`.slice(0, 140)
+        : 'QE report exists but no (non-negated) cross-model reviewer is named (self-review only)',
+    );
+  }
+
+  // 4. Live verification — the property was observed, not inferred. The health-advisor 1.2.0 QE
+  //    report is the cautionary case: "✅ (mechanism)" with no live evidence shipped a dead feature.
+  const live = evidenceLine(qeText, /MEASURED|verified live|VERIFIED LIVE|reproducer/i);
+  const liveAnywhere = live ?? evidenceLine(allText, /MEASURED|verified live|VERIFIED LIVE|reproducer/i);
+  add(
+    'live-verification',
+    'claims verified by running, not by reasoning',
+    live !== null ? 'pass' : liveAnywhere !== null ? 'partial' : 'absent',
+    live ?? liveAnywhere ?? 'no MEASURED / verified-live / reproducer marker anywhere — every claim is inferred',
+  );
+
+  // 5. README-first — the docs travelled in the same change.
+  const readme = evidenceLine(qeText + '\n' + manifestText, /README/);
+  add(
+    'readme-first',
+    'READMEs updated in the same change',
+    readme !== null ? 'pass' : 'absent',
+    readme ?? 'no README mention in the QE report or the change manifest',
+  );
+
+  // 6. The learning loop — Step-0 recall folded in, Step-8 lessons taught.
+  const recalled = evidenceLine(complexityText + '\n' + allText, /LEARNED_PATTERNS|dz recall|recalled/i);
+  const taught = evidenceLine(allText, /lesson[s]? taught|dz teach|taught \(/i);
+  add(
+    'learning-loop',
+    'Step-0 recall used; Step-8 lessons taught',
+    recalled !== null && taught !== null ? 'pass' : recalled !== null || taught !== null ? 'partial' : 'absent',
+    recalled !== null && taught !== null
+      ? `${recalled.slice(0, 68)} | ${taught.slice(0, 68)}`
+      : recalled ?? taught ?? 'no recall/teach evidence — the run neither drew on nor fed the learned store',
+  );
+
+  // 7. Amendment confirmation — only when amendments EXIST; their absence is not a failure.
+  //    Born in the PLAN/ideation: a stray "AM-7" in QE prose (e.g. another feature's test name)
+  //    must not conjure the discipline (caught by the very first dogfood run).
+  const plannedAm = [...new Set(planText.match(/AM-\d+/g) ?? [])].sort();
+  if (plannedAm.length > 0) {
+    // One stray AM-9 in QE must not satisfy AM-1..AM-2 (Codex QE #3): coverage is id-by-id.
+    const covered = plannedAm.filter((id) => qeText.includes(id));
+    const missing = plannedAm.filter((id) => !qeText.includes(id));
+    add(
+      'amendment-confirmation',
+      'amendments carried into QE with confirmation',
+      missing.length === 0 ? 'pass' : covered.length > 0 ? 'partial' : 'partial',
+      missing.length === 0
+        ? `all planned amendments reach QE: ${plannedAm.join(', ')}`
+        : `planned ${plannedAm.join(', ')} — QE never mentions ${missing.join(', ')}`,
+    );
+  }
+
+  const passed = disciplines.filter((d) => d.verdict === 'pass').length;
+  const total = disciplines.length;
+  const worst = disciplines.filter((d) => d.verdict === 'absent').map((d) => d.id);
+  const summary =
+    `${passed}/${total} disciplines fully evidenced` +
+    (grade !== null ? ` · QE grade ${grade}` : ' · no QE grade') +
+    (worst.length > 0 ? ` · absent: ${worst.join(', ')}` : '');
+
+  return { slug, disciplines, qeGrade: grade, passed, total, summary };
+}
+
+const MARK: Record<DisciplineVerdict, string> = { pass: '✓', partial: '◐', absent: '✗' };
+
+export function renderScorecard(card: RunScorecard): string {
+  const out: string[] = [];
+  out.push(`dz score — ${card.slug} (process scorecard; descriptive-only, never a gate)`);
+  out.push('');
+  for (const d of card.disciplines) {
+    out.push(`  ${MARK[d.verdict]} ${d.title}`);
+    out.push(`      ${d.evidence}`);
+  }
+  out.push('');
+  out.push(`  ${card.summary}`);
+  return out.join('\n');
+}

package/src/vector-tier.ts

@@ -65,7 +65,13 @@ import {
   cosineSimilarity,
   importVectorsToAgentdb,
   reindexAgentdbRows,
+  readAgentdbRowsByTaskType,
+  DZ_OWNED_TASK_TYPES,
 } from './agentdb-index.js';
+// smart-backlog (ADR-001/005 lifecycle): `dz vector reindex` must re-embed dz-backlog rows too, or
+// they rot in a stale embedding space after a model bump. One-directional import — backlog.ts imports
+// agentdb-index/compounding only, never vector-tier, so there is no cycle.
+import { BACKLOG_TASK_TYPE } from './backlog.js';
 import { currentEmbedManifest, guardEmbedSpace, DEFAULT_EMBED_DIM, resolveEmbedModel, type EmbedModelConfig } from './embedding-config.js';
 import { applyLearningSignals, applyLearningSignalsWithDelta, resolveLearningBackend, type LearningSignalBackend } from './learning-backend.js';
 
@@ -278,6 +284,15 @@ export interface ReindexVectorReport {
    * silent, since a mixed store looks healthy right up until someone widens a query.
    */
   readonly staleTaskTypes?: readonly string[];
+  /**
+   * smart-backlog honest-skip status. Set ONLY on the non-agentdb-engine path: backlog code never touches
+   * the shared manifest, so under a non-agentdb engine NOTHING is reindexed — `backlog:'skipped'` +
+   * `generic:'skipped'` + a non-empty `error` say so (overall success is never claimed). Unset on the full
+   * agentdb reindex path (which owns and re-embeds dz-backlog together with the other types) — behavior for
+   * every other caller is unchanged.
+   */
+  readonly backlog?: 'skipped';
+  readonly generic?: 'skipped';
 }
 
 export type TeachGuardResult =
@@ -963,10 +978,31 @@ export async function vectorTierStatus(
 }
 
 export async function reindexVectorStore(projectRoot: string, opts: VectorServiceOptions = {}): Promise<ReindexVectorReport> {
+  // ARCHITECTURAL INVARIANT (smart-backlog): backlog code never PARTIALLY advances the SHARED agentdb
+  // model manifest — no path re-stamps it to a new model while leaving a sibling task type un-re-embedded.
+  // The FIRST backlog write legitimately establishes the manifest when the store is new (correct); a model
+  // ADVANCE happens ONLY here, in a full reindex that re-embeds EVERY owned task type together atomically
+  // (taskTypes = DZ_OWNED_TASK_TYPES, which owns dz-backlog — HIGH-3). The old backlog-only re-stamp path
+  // spawned an endless class of edge cases (missing/corrupt/rollback/scan-error); it is REMOVED.
   const resolved = pickEngine(projectRoot, opts);
-  if (resolved.engine === undefined) return { reembedded: 0, error: resolved.reason ?? 'no vector engine available' };
-  if (resolved.engine.kind !== 'agentdb') {
-    return { reembedded: 0, error: 'dz vector reindex currently rewrites the agentdb learned-pattern mirror; switch memory.vector.engine to agentdb/auto' };
+  if (resolved.engine === undefined || resolved.engine.kind !== 'agentdb') {
+    // Non-agentdb (or absent) engine: the generic learned-pattern reindex can't run here, and backlog must
+    // not advance the shared manifest partially. Touch NOTHING — honest skip with a UNIFORM shape (LOW-I:
+    // always report backlog/generic skipped). Backlog's same-model writes already bind vectors to the
+    // current model (HIGH-2); a model bump needs a FULL reindex under the agentdb engine.
+    // A non-agentdb vector engine is CONFIGURED (rvf resolved, or requested-but-not-installed) ⇒ the
+    // manifest-untouched message pointing to the full agentdb reindex. Only a genuinely absent engine
+    // (no config, nothing resolvable) falls back to the bare reason.
+    const nonAgentdbConfigured = resolved.engine !== undefined || readVectorEngineMode(projectRoot) === 'rvf';
+    return {
+      reembedded: 0,
+      backlog: 'skipped',
+      generic: 'skipped',
+      error: nonAgentdbConfigured
+        ? 'a non-agentdb vector engine (e.g. RVF) is configured; no reindex was performed and the shared model manifest was NOT touched. ' +
+          'Run a full reindex under memory.vector.engine=agentdb/auto to re-embed every task type (dz-teach/dz-learning/dz-backlog) together.'
+        : resolved.reason ?? 'no vector engine available',
+    };
   }
   let records: MemoryRecord[];
   try {
@@ -984,7 +1020,14 @@ export async function reindexVectorStore(projectRoot: string, opts: VectorServic
       ...(r.tags !== undefined ? { tags: r.tags } : {}),
       ...(r.metadata !== undefined ? { metadata: r.metadata } : {}),
     }));
-  return reindexAgentdbRows(projectRoot, rows);
+  // HIGH-G: ownership is by STORE-PRESENCE. Read the dz-backlog rows that ACTUALLY EXIST IN THE STORE and
+  // re-embed THOSE (their stored text) — never reconstruct them from ideas.jsonl, or an empty/unreadable
+  // sidecar would advance the manifest while the store's real dz-backlog rows rot in the old model space.
+  // Symmetric with dz-teach/dz-learning (re-embedded from their store of truth). Only widen the owned set
+  // when the store actually holds dz-backlog rows — a store with none reindexes byte-identically to before.
+  const backlogStoreRows = readAgentdbRowsByTaskType(projectRoot, BACKLOG_TASK_TYPE).rows;
+  if (backlogStoreRows.length === 0) return reindexAgentdbRows(projectRoot, rows);
+  return reindexAgentdbRows(projectRoot, [...rows, ...backlogStoreRows], { taskTypes: DZ_OWNED_TASK_TYPES });
 }
 
 /* ------------------------------------------------------------------ */