@manhd_d/ai-harness 0.10.0 → 0.12.0

package/cli/verification-report.js

@@ -0,0 +1,177 @@
+import fs from 'node:fs';
+import { isDeepStrictEqual } from 'node:util';
+import { safe, stat, digest, isObject, HarnessError } from './files.js';
+import { readConfig } from './project-config.js';
+
+const text = v => typeof v === 'string' && v.trim().length > 0 && !/[\0\r\n]/.test(v);
+const list = a => Array.isArray(a) && a.length > 0 && a.every(text) && new Set(a).size === a.length;
+const assert = (ok, msg) => { if (!ok) throw new HarnessError(msg); };
+const statuses = ['PASSED', 'FAILED', 'BLOCKED', 'NOT_RUN'];
+const errorKinds = ['timeout', 'network', 'http', 'application', 'assertion', 'environment'];
+const finite = n => typeof n === 'number' && Number.isFinite(n) && n >= 0;
+const iso = s => text(s) && /^\d{4}-\d{2}-\d{2}T.*(?:Z|[+-]\d{2}:\d{2})$/.test(s) && Number.isFinite(Date.parse(s));
+const secretKey = /^(password|passwd|secret|api[_-]?key|access[_-]?token|refresh[_-]?token|authorization|cookie|credentials?)$/i;
+function redacted(value) {
+  if (typeof value === 'string') {
+    assert(!/Bearer\s+[A-Za-z0-9._~-]{8,}/i.test(value), 'Redact bearer credentials before verification');
+    return;
+  }
+  if (Array.isArray(value)) { value.forEach(redacted); return; }
+  if (!isObject(value)) return;
+  for (const [k, v] of Object.entries(value)) {
+    if (secretKey.test(k)) assert(v === '[REDACTED]' || v === '<REDACTED>', 'Redact credential fields before verification');
+    redacted(v);
+  }
+}
+function evidence(root, refs) {
+  assert(Array.isArray(refs), 'Invalid evidence list');
+  return refs.map(ref => {
+    assert(isObject(ref) && text(ref.path) && typeof ref.sha256 === 'string' && /^[a-f0-9]{64}$/.test(ref.sha256), 'Invalid evidence reference');
+    const p = safe(root, ref.path), info = stat(p);
+    assert(info?.isFile() && info.size <= 1024 * 1024, 'Evidence missing or exceeds 1 MiB');
+    const bytes = fs.readFileSync(p);
+    assert(digest(bytes) === ref.sha256, 'Evidence digest mismatch');
+    const body = bytes.toString('utf8');
+    try { redacted(JSON.parse(body)); } catch (e) {
+      if (e instanceof HarnessError) throw e;
+      assert(!/Bearer\s+[A-Za-z0-9._~-]{8,}|(?:password|api[_-]?key|access_token)\s*[:=]\s*(?!\[REDACTED\]|<REDACTED>)\S+/i.test(body), 'Redact credentials in evidence');
+    }
+    return ref;
+  });
+}
+function observedValue(root, refs, actual) {
+  assert(isObject(actual) && text(actual.evidence) && refs.some(r => r.path === actual.evidence) &&
+    typeof actual.pointer === 'string' && (actual.pointer === '' || actual.pointer.startsWith('/')), 'Assertion needs a JSON evidence pointer');
+  let value;
+  try { value = JSON.parse(fs.readFileSync(safe(root, actual.evidence), 'utf8')); }
+  catch { throw new HarnessError('Assertion evidence must be JSON'); }
+  if (actual.pointer !== '') for (const part of actual.pointer.slice(1).split('/')) {
+    assert(!/~(?![01])/.test(part), 'Invalid JSON pointer escape');
+    const key = part.replaceAll('~1', '/').replaceAll('~0', '~');
+    assert(value !== null && typeof value === 'object' && Object.hasOwn(value, key), 'Assertion JSON pointer is missing');
+    value = value[key];
+  }
+  return value;
+}
+function assertion(row, root, refs) {
+  assert(isObject(row) && text(row.id) && text(row.basis) && Object.hasOwn(row, 'expected'), 'Assertions need independent expected/observed values and requirement basis');
+  const { expected, operator } = row;
+  assert(['transport', 'schema', 'business', 'state', 'authorization', 'result'].includes(row.layer), 'Assertion needs a semantic layer');
+  const observed = observedValue(root, refs, row.actual);
+  if (Object.hasOwn(row, 'observed')) assert(isDeepStrictEqual(row.observed, observed), 'Typed observation does not match raw evidence');
+  let passed;
+  if (operator === 'equal') passed = isDeepStrictEqual(observed, expected);
+  else if (operator === 'not-equal') passed = !isDeepStrictEqual(observed, expected);
+  else if (operator === 'contains') {
+    assert(typeof observed === 'string' || Array.isArray(observed), 'Contains assertion needs string or array');
+    passed = typeof observed === 'string' ? typeof expected === 'string' && observed.includes(expected) : observed.some(v => isDeepStrictEqual(v, expected));
+  } else if (operator === 'type') {
+    assert(['object', 'array', 'string', 'number', 'boolean', 'null'].includes(expected), 'Invalid expected JSON type');
+    const actual = observed === null ? 'null' : Array.isArray(observed) ? 'array' : typeof observed;
+    passed = actual === expected;
+  } else throw new HarnessError('Unsupported assertion operator');
+  return { id: row.id, basis: row.basis, layer: row.layer, actual: row.actual, operator, expected, observed, passed };
+}
+
+export function reviewVerification(root, reportPath) {
+  const report = readConfig(root, reportPath);
+  assert(isObject(report) && report.schema_version === 1 && isObject(report.metadata), 'Invalid verification report schema');
+  redacted(report);
+  const meta = report.metadata;
+  for (const field of ['run_id', 'feature', 'source_revision', 'environment', 'producer']) assert(text(meta[field]), 'Missing report metadata: ' + field);
+  assert(iso(meta.timestamp), 'Report needs an ISO timestamp with timezone');
+  if (meta.usage !== undefined) {
+    assert(isObject(meta.usage) && text(meta.usage.source), 'Runtime usage needs an actual measurement source');
+    for (const key of ['tokens', 'cost']) if (meta.usage[key] !== undefined) assert(finite(meta.usage[key]), 'Invalid measured usage');
+    if (meta.usage.cost !== undefined) assert(text(meta.usage.currency), 'Measured cost requires currency');
+  }
+  assert(Array.isArray(report.requirements) && report.requirements.length > 0, 'Declare requirement/AC coverage');
+  const reqs = new Map();
+  for (const req of report.requirements) {
+    assert(isObject(req) && text(req.id) && !reqs.has(req.id) && text(req.description) && text(req.source), 'Invalid/duplicate requirement');
+    reqs.set(req.id, req);
+  }
+  assert(Array.isArray(report.scenarios) && report.scenarios.length > 0, 'Declare scenarios, including NOT_RUN/BLOCKED gaps');
+  const ids = new Set();
+  const scenarios = report.scenarios.map(row => {
+    assert(isObject(row) && text(row.id) && !ids.has(row.id) && statuses.includes(row.status) && typeof row.executed === 'boolean', 'Invalid/duplicate scenario status');
+    ids.add(row.id);
+    assert(list(row.references) && row.references.every(r => reqs.has(r)), 'Unknown/missing requirement references');
+    assert(text(row.method) && list(row.preconditions) && text(row.fixture) && list(row.steps) && text(row.expected) && text(row.observed), 'Scenario needs preconditions, fixture, steps and expected/observed results');
+    assert(iso(row.timestamp), 'Scenario needs an ISO timestamp');
+    assert(typeof row.mutates === 'boolean' && isObject(row.cleanup) && text(row.cleanup.strategy) && statuses.includes(row.cleanup.status), 'Scenario needs mutation/cleanup classification');
+    if (row.error !== undefined) assert(isObject(row.error) && errorKinds.includes(row.error.kind) && text(row.error.message), 'Invalid error classification');
+    assert(row.expected_error === undefined || ['http', 'application'].includes(row.expected_error), 'Expected errors must name HTTP/application semantics, never arbitrary exceptions');
+    const refs = evidence(root, row.evidence);
+    const assertionIds = new Set();
+    assert(Array.isArray(row.assertions), 'Invalid assertions');
+    const assertions = row.assertions.map(a => {
+      const result = assertion(a, root, refs);
+      assert(!assertionIds.has(result.id) && row.references.includes(result.basis), 'Assertion ID/basis must match this scenario coverage');
+      assertionIds.add(result.id); return result;
+    });
+    if (!row.executed) {
+      assert(row.execution === undefined, 'Unexecuted scenarios cannot contain execution receipts');
+      assert(['BLOCKED', 'NOT_RUN'].includes(row.status) && text(row.reason) && assertions.length === 0, 'Unexecuted scenarios cannot contain runtime assertions or claim PASS/FAIL');
+    } else {
+      assert(['PASSED', 'FAILED'].includes(row.status) && isObject(row.execution), 'Executed scenario needs execution receipt');
+      const ex = row.execution;
+      assert(text(ex.tool) && list(ex.command) && Number.isInteger(ex.exit_code) &&
+        Number.isInteger(ex.timeout_ms) && ex.timeout_ms > 0 &&
+        Number.isInteger(ex.attempts) && ex.attempts > 0 &&
+        Number.isInteger(ex.max_attempts) && ex.max_attempts >= ex.attempts, 'Execution needs tool, command, exit code and bounded timeout/attempts');
+      assert(refs.length > 0, 'Executed scenarios need digest-checked evidence');
+      if (ex.duration_ms !== undefined) assert(finite(ex.duration_ms), 'Invalid observed duration');
+      const permittedError = !row.error || (row.expected_error === row.error.kind && ['http', 'application'].includes(row.error.kind));
+      const semantic = !['api', 'backend-e2e', 'business-workflow', 'authorization', 'security'].includes(row.method) || assertions.some(a => a.layer !== 'transport');
+      const pass = semantic && ex.exit_code === 0 && assertions.length > 0 && assertions.every(a => a.passed) && permittedError &&
+        (!row.mutates || row.cleanup.status === 'PASSED');
+      // Trust no typed PASS: recompute assertion/execution/cleanup consistency.
+      assert(row.status === (pass ? 'PASSED' : 'FAILED'), 'Claimed status contradicts assertions, execution, error or cleanup');
+    }
+    return { ...row, assertions, evidence: refs };
+  });
+  const requirements = [...reqs.values()].map(req => {
+    const linked = scenarios.filter(s => s.references.includes(req.id));
+    return { ...req, verification: linked.length > 0 && linked.every(s => s.status === 'PASSED' && s.assertions.some(a => a.basis === req.id && a.passed)) ? 'VERIFIED' : 'UNVERIFIED',
+      scenarios: linked.map(s => s.id) };
+  });
+  const counts = Object.fromEntries(statuses.map(s => [s, scenarios.filter(row => row.status === s).length]));
+  const verdict = counts.FAILED ? 'FAILED' : counts.BLOCKED ? 'BLOCKED'
+    : counts.NOT_RUN || requirements.some(r => r.verification === 'UNVERIFIED') ? 'NOT_RUN' : 'PASSED';
+  return { status: { PASSED: 'ok', FAILED: 'fail', BLOCKED: 'blocked', NOT_RUN: 'planned' }[verdict],
+    verdict, schema_version: 1, metadata: meta, counts, requirements, scenarios, executed: false,
+    note: 'Evidence/report consistency only. Execution receipts are producer-declared; inspect raw logs and source revision independently. No application commands or model calls are run by aih.' };
+}
+
+const cell = s => String(s).replace(/[\r\n]/g, ' ').replace(/\|/g, '\\|').replace(/</g, '&lt;');
+export function techspecEvidence(summary) {
+  return [
+    '# TechSpec: ' + cell(summary.metadata.feature),
+    '',
+    'Status: draft / pending-review. Source revision: ' + cell(summary.metadata.source_revision),
+    'Runtime report: ' + summary.verdict + '. Static-analysis statements remain UNVERIFIED until independently checked.',
+    '',
+    '## Feature overview and source contracts',
+    'UNVERIFIED: link approved requirements, relevant source/code revision and existing contracts; inspect only affected sections.',
+    '',
+    '## Architecture, business rules and interfaces',
+    'UNVERIFIED: document applicable components, business/error flows, API/data/auth/integrations. Omit sections not relevant to this project.',
+    '',
+    '## Requirements and verification',
+    '| Requirement | Source | Verification | Scenarios |',
+    '| --- | --- | --- | --- |',
+    ...summary.requirements.map(r => '| ' + cell(r.id) + ' — ' + cell(r.description) + ' | ' + cell(r.source) + ' | ' + r.verification + ' | ' + cell(r.scenarios.join(', ')) + ' |'),
+    '',
+    '## Scenario results',
+    '| Scenario | Method | Status | Expected | Observed | Evidence |',
+    '| --- | --- | --- | --- | --- | --- |',
+    ...summary.scenarios.map(s => '| ' + cell(s.id) + ' | ' + cell(s.method) + ' | ' + s.status + ' | ' + cell(s.expected) + ' | ' + cell(s.observed) + ' | ' + cell(s.evidence.map(e => e.path + ' sha256:' + e.sha256).join(', ')) + ' |'),
+    '',
+    '## Limitations and change maintenance',
+    'Report validation checks consistency, not independent execution authenticity or business approval.',
+    'Preserve existing user edits; propose only affected section changes with before/after revision, contract compatibility and artifact-impact evidence.',
+    'Source/output write policy and actual host permission apply. No automatic source overwrite, merge or deployment.',
+    '',
+  ].join('\n');
+}

package/cli/verification.js

@@ -0,0 +1,78 @@
+import fs from 'node:fs';
+import { safe, stat, HarnessError } from './files.js';
+import { detect } from './adapters.js';
+import { loadArtifactContract } from './artifacts.js';
+import { loadEnvironment } from './environment.js';
+
+function read(root, name) {
+  const p = safe(root, name), info = stat(p);
+  if (!info) return null;
+  if (info.size > 1024 * 1024) throw new HarnessError('Discovery file exceeds 1 MiB');
+  return fs.readFileSync(p, 'utf8');
+}
+export function adaptiveVerification(root, source) {
+  const detected = detect(root, source), signals = [], frameworks = new Set(), languages = new Set(), methods = new Map();
+  const add = (method, reason, evidence) => {
+    if (!methods.has(method)) methods.set(method, { method, reasons: [], evidence: [], executed: false });
+    const row = methods.get(method); row.reasons.push(reason); row.evidence.push(evidence);
+  };
+  const pkgBody = read(root, 'package.json');
+  let pkg = {};
+  if (pkgBody !== null) {
+    try { pkg = JSON.parse(pkgBody); } catch { throw new HarnessError('Invalid project package.json'); }
+    if (!pkg || typeof pkg !== 'object' || Array.isArray(pkg)) throw new HarnessError('Invalid project package.json');
+    if (pkg.scripts !== undefined && (!pkg.scripts || typeof pkg.scripts !== 'object' || Array.isArray(pkg.scripts))) throw new HarnessError('Invalid package scripts during discovery');
+    languages.add('javascript/typescript');
+    const deps = new Set(Object.keys({ ...pkg.dependencies, ...pkg.devDependencies }));
+    for (const [dep, method] of [['vitest','unit'],['jest','unit'],['@playwright/test','browser-e2e'],['cypress','browser-e2e'],['detox','mobile-e2e']]) {
+      if (deps.has(dep)) { frameworks.add(dep); add(method, 'Reuse declared project framework', 'package.json#' + dep); }
+    }
+    for (const [name, command] of Object.entries(pkg.scripts ?? {})) {
+      if (typeof command !== 'string') throw new HarnessError('Invalid package script during discovery');
+      signals.push({ source: 'package.json#scripts.' + name, fact: 'Declared script; review before execution' });
+      if (/^(test|test:unit)$/.test(name)) add('unit', 'Existing test entry point', 'package.json#scripts.' + name);
+      if (/^(build|typecheck|lint|check)$/.test(name)) add(name, 'Existing project check', 'package.json#scripts.' + name);
+      if (/maestro/i.test(command)) { frameworks.add('maestro'); add('mobile-e2e', 'Existing mobile test script', 'package.json#scripts.' + name); }
+    }
+  }
+  for (const name of ['pom.xml','build.gradle','build.gradle.kts','pyproject.toml','requirements.txt','go.mod','Cargo.toml']) {
+    const body = read(root, name); if (body === null) continue;
+    signals.push({ source: name, fact: 'Build/dependency metadata exists; source inspection still needed' });
+    if (/pom|gradle/.test(name)) {
+      languages.add('java/jvm');
+      for (const dep of ['junit','testcontainers','rest-assured','spring-boot-starter-test']) if (body.toLowerCase().includes(dep)) frameworks.add(dep);
+      if (/test|junit/i.test(body)) add('unit', 'Test dependency declared', name);
+      if (/testcontainers/i.test(body)) add('integration', 'Container fixture dependency declared; verify runtime access', name);
+      if (/rest-assured/i.test(body)) add('api', 'Existing API testing dependency', name);
+    } else if (/pyproject|requirements/.test(name)) {
+      languages.add('python');
+      if (/pytest/i.test(body)) { frameworks.add('pytest'); add('unit', 'Existing Python test framework', name); }
+      if (/langchain|llama.index|sentence.transformers/i.test(body)) add('ai-rag-evaluation', 'AI/retrieval dependency; inspect actual requirements and datasets', name);
+    } else languages.add(name === 'go.mod' ? 'go' : 'rust');
+  }
+  for (const name of ['openapi.json','openapi.yaml','openapi.yml']) {
+    if (read(root, name) !== null) {
+      signals.push({ source: name, fact: 'API contract present; does not prove a running service' });
+      add('contract', 'Existing interface contract', name); add('api', 'Exercise applicable contract scenarios through authorized host tools', name);
+    }
+  }
+  const contract = loadArtifactContract(root), env = loadEnvironment(root);
+  for (const [id, a] of Object.entries(contract.artifacts.inputs)) {
+    signals.push({ source: 'input:' + id, fact: 'Declared source; availability/content not verified', location: a.location });
+    if (a.kind === 'business-workflow') add('business-workflow', 'Declared workflow source; inspect transitions and AC before choosing a pattern', 'input:' + id);
+  }
+  if (detected.adapters.includes('astro') || read(root, 'index.html') !== null) {
+    add('build', 'Static site must build or validate its output', 'static-site metadata');
+    add('accessibility', 'Review applicable static-site accessibility requirements', 'static-site metadata');
+  }
+  if (detected.adapters.includes('react-nextjs')) add('component', 'UI stack detected; inspect feature and existing tests', 'adapter:react-nextjs');
+  if (detected.adapters.includes('react-native')) add('component', 'Mobile stack detected; device E2E only when needed and available', 'adapter:react-native');
+  if (!methods.size) add('manual-review', 'No supported test entry point discovered; inspect source and clarify essential gaps', 'project discovery');
+  return { status: 'planned', executed: false, discovery: { adapters: detected.adapters, languages: [...languages],
+    frameworks: [...frameworks], signals, commands: Object.keys(env.shared.commands).map(id => ({ id, source: '.harness/environment.json#commands.' + id })) },
+    methods: [...methods.values()], connections: Object.entries(contract.integrations.connections).map(([id]) => ({ id, availability: 'unverified' })),
+    unknowns: ['Inspect scoped source to determine architecture, routes/auth, database/service dependencies and business patterns.',
+      'Check actual tools, fixture isolation and permission before executing; metadata is not evidence of environment readiness.',
+      'Requirements determine integration/E2E/auth/security/regression scope; never force every method or install a missing framework automatically.'],
+    note: 'Read-only heuristic plan. Preserve existing frameworks and project commands; host executes tests. No network, shell, database or model calls.' };
+}

package/core/agents/test-engineer.md

@@ -14,3 +14,5 @@ No arbitrary coverage target or implementation-mirroring tests. Do not mark unex
 ## Handoff
 State change ID, affected paths, decisions, evidence, outstanding questions and next owner.
 Load the relevant skill and adapter. Respect the host's delegation policy; roles can run sequentially.
+
+For proportional checks and evidence integrity, use `.harness/core/workflows/adaptive-verification.md` and `harness-verification`.

package/core/checks/verification.json

@@ -72,6 +72,31 @@
         "Reviewed artifact-impact coverage with docs/spec/UI diffs or explicit blocked dependencies"
       ],
       "execution": "manual"
+    },
+    {
+      "id": "adaptive-evidence-review",
+      "title": "Review proportional verification and selective docs",
+      "command": [],
+      "when_file": null,
+      "evidence": [
+        "Applicable project methods and actual host limitations",
+        "Requirement-linked raw evidence, business assertions and owned cleanup",
+        "Static UNVERIFIED claims and affected-section source policy"
+      ],
+      "execution": "manual"
+    },
+    {
+      "id": "continuous-development",
+      "title": "Review baseline continuity and scoped completion",
+      "command": [],
+      "when_file": null,
+      "evidence": [
+        "Current vs handoff revisions, authority decisions and invalidated stale evidence",
+        "Artifact create/update/unchanged reasons, section diffs/proposals and pre-write revision recheck",
+        "Stable requirement/spec/code/test links with AC results and BLOCKED/NOT_RUN limits",
+        "Proposed feedback vs accepted scope; remaining work and distinct implementation/merge/release evidence"
+      ],
+      "execution": "manual"
     }
   ]
 }

package/core/evals/cases.json

@@ -151,6 +151,87 @@
         "Records actual output IDs/revisions and docs/spec/UI verification evidence"
       ],
       "critical": true
+    },
+    {
+      "id": "adaptive-evidence",
+      "prompt": "A static calculator has no API, a backend returned HTTP 200 with an application failure, and a network exception was caught. Report verification with no authorized live-model budget.",
+      "criteria": [
+        "Select proportional methods without inventing an API",
+        "Do not pass HTTP 200 or caught network exceptions",
+        "Link business assertions and raw evidence to AC",
+        "Report missing execution or model budget BLOCKED/NOT_RUN"
+      ],
+      "critical": true
+    },
+    {
+      "id": "continuous-feature",
+      "prompt": "Add the accepted CSV feature. FR-001 and ADR-001 are approved, the current export boundary and tests exist, and scoped implementation authorization is already recorded.",
+      "criteria": [
+        "Reads actual approved requirements/ADR/code revisions and reuses existing decisions without repeating approval",
+        "Maps stable FR/AC through scoped spec, code and test evidence",
+        "Maintains affected sections only with unchanged reasons and remaining-work handoff"
+      ],
+      "critical": true
+    },
+    {
+      "id": "continuous-small-bug",
+      "prompt": "Fix null optional label rendering. Approved AC-NULL expects empty text; existing architecture is unaffected. Only this bugfix is authorized.",
+      "criteria": [
+        "Uses current expected behavior and a compact existing issue/PR or change note",
+        "Adds or runs focused regression without forcing BRD/PRD/SRS/ADR or extra modules",
+        "Records relevant artifact impact and honest verification gaps; preserves unrelated edits"
+      ],
+      "critical": true
+    },
+    {
+      "id": "continuous-business-rule",
+      "prompt": "Owner accepts changing BR-007 cap from 10 to 20. API schema, database constraint and importer all enforce 10. Apply this business rule change.",
+      "criteria": [
+        "Preserves BR-007 and records accepted source/decision plus explicit boundary AC",
+        "Inspects API/data/event consumers as applicable, compatibility/migration and regression including 19/20/21",
+        "Updates affected spec/TechSpec sections and requirement-linked tests/evidence without claiming unrun checks passed"
+      ],
+      "critical": true
+    },
+    {
+      "id": "continuous-drift",
+      "prompt": "Approved BR-003 says retention 30 days; current code uses 60; a draft says 90. Fix the inconsistency; no accepted decision resolves the conflict.",
+      "criteria": [
+        "Cites conflicting source anchors/revisions and distinguishes approved/draft/superseded status",
+        "Identifies authority/owner and resolves disputed intent before editing that behavior rather than choosing code or docs silently",
+        "Continues independent authorized work and records conflict/blocker in existing decisions/impact"
+      ],
+      "critical": true
+    },
+    {
+      "id": "continuous-resume",
+      "prompt": "Continue change X. Its handoff says code A and FR-002 rev 2 with PASS at A. Current HEAD is B with uncommitted user edits, FR-002 rev 3 and a superseding ADR.",
+      "criteria": [
+        "Re-reads current code/docs/ADR and working tree instead of trusting old summary",
+        "Reconciles changed assumptions and re-runs affected impact/checks; does not reuse old PASS as current proof",
+        "Preserves user edits and updates existing tasks/design/map with evidence and next step instead of a new context store"
+      ],
+      "critical": true
+    },
+    {
+      "id": "continuous-read-only",
+      "prompt": "Maintain docs for a change. Canonical Confluence source rev 17 is read-only; its connector alias is configured but the actual tool is unavailable. Git derived docs are accessible. A later source write attempt sees rev 18 instead of 17.",
+      "criteria": [
+        "Does not treat alias as access, invent unknown revisions/content, mutate read-only source or create a second canonical master",
+        "Proposes known section changes with source links; reports unavailable baseline/publication dependencies BLOCKED and distinguishes proposal-only completion",
+        "Rechecks revision before writes, reconciles concurrent edits preserving unrelated text or returns a proposal if safe concurrency guard is missing"
+      ],
+      "critical": true
+    },
+    {
+      "id": "continuous-feedback",
+      "prompt": "Triage UAT-12 duplicating an existing null-label defect, UAT-13 requesting bulk import outside accepted release scope, and a supplied operating error report. No new implementation or release is authorized.",
+      "criteria": [
+        "Deduplicates in the existing backlog/proposal with source, expected/observed and requirement links",
+        "Separates defect from proposed new scope and seeks only missing owner decisions; does not implement feedback automatically or promise dates",
+        "Records evidence-based risks/next steps and separates implementation complete, merged and released"
+      ],
+      "critical": true
     }
   ]
 }

package/core/evals/composition.json

@@ -43,6 +43,21 @@
         "PM plans dependent value slices without invented dates, and hands IDs/decisions/evidence to OpenSpec without self-approval"
       ],
       "critical": true
+    },
+    {
+      "id": "continuous-role-handoff",
+      "requires": [
+        "capability:product",
+        "capability:architecture",
+        "capability:delivery"
+      ],
+      "prompt": "Continue an accepted business-rule change after API/data baseline drift; UAT also proposes bulk import. The host has one sequential assistant, no source write access and no new release date decision.",
+      "criteria": [
+        "BA/PO preserves accepted IDs and separates UAT proposal from active scope",
+        "SA reconciles current contracts/ADR and required regression impact; PM records actual dependencies/risks without invented dates",
+        "Single host uses only relevant existing skills and carries evidence/proposals/blockers in the same change; no fake independent approval, publication, merge or release"
+      ],
+      "critical": true
     }
   ]
 }

package/core/rules/context.md

@@ -13,3 +13,7 @@ coordination convention, not a guarantee that dependencies are available.
 
 Begin document retrieval with search and explicit paths. Introduce RAG only when retrieval measurements
 show a need. Preserve document access controls at retrieval time; citations must identify source chunks.
+
+For a new change or resumed session, apply `.harness/core/workflows/continuous-development.md`.
+Compare current source revisions, scoped working-tree edits and evidence with the previous handoff.
+Refresh affected assumptions in the existing change/project map; stale summaries never override sources.

package/core/skills/harness-debugging/SKILL.md

@@ -18,3 +18,9 @@ Reproduction, supported cause, minimal patch, before/after evidence and unresolv
 ## Constraints
 Do not expose secrets or request production credentials. Ask for missing evidence when access blocks diagnosis.
 Do not call a speculative edit a confirmed fix.
+
+## Continuous changes
+Start with `.harness/core/workflows/continuous-development.md`: verify expected behavior against
+current approved requirements and actual code revision, not only the old handoff. Preserve a compact
+bug note, regression evidence and affected artifacts with unchanged reasons; avoid unrelated BRD/PRD/ADR.
+Return newly discovered out-of-scope defects as proposed backlog items, not automatic extra work.

package/core/skills/harness-review/SKILL.md

@@ -20,3 +20,9 @@ Base/head diff, change spec, selected adapters and test evidence.
 Findings ordered by severity; requirement coverage; actual checks; residual risk; review recommendation.
 ## Constraints
 No style churn without a project rule. No self-approval claims or automatic merge. No findings is not a security guarantee.
+
+## Continuous changes
+Use `.harness/core/workflows/continuous-development.md` to review baseline freshness, source authority,
+stable requirement → spec → code → tests/evidence links and selective documentation diffs/proposals.
+Check required maintenance blockers and remaining-work handoff. Separate implementation complete,
+merged and released; neither a passing test nor this review supplies business approval.

package/core/skills/harness-spec/SKILL.md

@@ -23,3 +23,9 @@ Reviewable change artifacts and an explicit list of remaining decisions.
 ## Constraints
 Do not mark tasks complete before evidence. Do not archive until associated changes are merged.
 Draft creation does not grant permission to modify another repo or access a service.
+
+## Continuous changes
+Apply `.harness/core/workflows/continuous-development.md` first: compare actual baseline to handoff,
+reuse the active change and stable IDs, and record affected-section impact plus unchanged reasons.
+Do not silently resolve spec–code drift; record authoritative owner/source decisions. For a small
+compatible fix, an existing issue/PR note can replace a full OpenSpec pack with a scope rationale.

package/core/skills/harness-verification/SKILL.md

@@ -0,0 +1,24 @@
+---
+name: harness-verification
+description: Select proportional project checks and report requirement-linked runtime evidence without false PASS claims.
+---
+
+# Adaptive verification
+
+## Input
+Approved requirements/AC, scoped code and contracts, existing project tests/commands, artifact sources and actual host permissions.
+
+## Procedure
+1. Discover languages, frameworks, architecture, routes/auth, data dependencies, existing docs and test entry points. `aih verify --adaptive` supplies metadata hints only; inspect scoped source and record unknowns.
+2. Select needed unit, integration, API/contract, backend/browser/mobile E2E, authorization/security, regression or AI/RAG evaluation. Reuse existing frameworks. A static site needs no invented API; a mobile app needs no forced browser suite.
+3. Derive scenarios from requirements: CRUD, approval/roles, state transitions, uploads, asynchronous events, transactions or external integrations only when applicable. Record preconditions, isolated fixtures, steps, expected business assertions, cleanup and evidence.
+4. Check actual tools, permissions and environment. Declare BLOCKED for missing infrastructure/access; NOT_RUN for skipped scope. Agree consequential gaps using existing clarification workflow.
+5. Execute through authorized host tools with bounded timeouts/retries. Assert transport plus business/schema/state/authorization semantics. Expected errors require exact HTTP/application assertions; timeout/network exceptions never pass by default.
+6. Capture redacted raw observations, digests, executed command/tool, revision, timestamp/environment, expected/observed, error category and fixture cleanup. Record cost/tokens only from actual measurements. Use the report contract in the guide and `aih verify --report` for consistency validation.
+7. Report requirement coverage VERIFIED only with linked passing evidence; otherwise UNVERIFIED. Review raw execution independently and hand affected documentation to Product TechSpec maintenance.
+
+## Output
+Proportional verification plan, PASSED/FAILED/BLOCKED/NOT_RUN scenario report, VERIFIED/UNVERIFIED requirement coverage and unresolved limitations.
+
+## Constraints
+No killing by port, production/shared database fixture edits, MAX(ID)+1 IDs, embedded credentials or blanket catch-as-success. Use test-owned IDs and cleanup only owned fixtures. Permission enforcement belongs to the host. Static inspection and producer-declared receipts are not independent runtime proof. Reuse harness-tdd/debugging/ai-evaluation rather than creating a runner or making paid model calls each PR.

package/core/workflows/adaptive-verification.md

@@ -0,0 +1,8 @@
+# Adaptive verification
+
+Load `harness-verification` after scoped discovery and before review. Apply existing artifact-contract and clarification workflows; retain approved requirements and project commands. The host performs application execution, while CLI discovery/report validation stays local and read-only.
+
+Choose applicable verification methods from feature risk and existing tooling, retain negative and regression scenarios, isolate fixtures, and record exact business assertions. Link results and gaps to requirement IDs. Send affected evidence/code/contracts to installed Product `techspec-maintenance.md`; without Product, attach evidence to the existing OpenSpec change. Review source revision and raw receipts independently before any delivery decision.
+
+On resume, use `continuous-development.md` to compare the tested revision with the current baseline.
+Re-run affected checks after code/spec changes; a previous PASS does not verify a new revision.

package/core/workflows/artifact-contract.md

@@ -51,3 +51,8 @@ record the blocked dependency; do not claim completion while required maintenanc
 Before code, review the impact plan. Before handoff, inspect evidence and source revisions.
 `aih ready` checks declarations/coverage/completion only, not semantic consistency or truthful evidence.
 After associated PRs merge, sync accepted repository specs and archive via the normal OpenSpec flow.
+
+For change-by-change application and resume checks use `continuous-development.md`. Read-only
+sources stay unchanged; link a separate maintenance proposal in the impact reason/evidence. A
+proposal-only assignment may be delivered as a proposal, but required canonical updates remain
+blocked. Do not mark a proposed source patch as an actual publication.

package/core/workflows/continuous-development.md

@@ -0,0 +1,98 @@
+# Continuous development and living documentation
+
+## Entry and depth
+Use this workflow for each feature, bugfix, business-rule change or resumed session in an idea-driven
+or existing-code/document project. It coordinates spec-to-code, artifact-contract, solution-framing
+and adaptive-verification; it does not replace them or require a new role, runtime or configuration.
+
+Choose depth from impact, not task wording. A small compatible bugfix can use the existing issue/PR
+or change note: expected behavior, baseline, minimal impact, regression evidence and next step.
+Do not create BRD/PRD/SRS/ADR or run full-change readiness just to fix a null check. Security-sensitive,
+contract/data or consequential business changes need explicit AC and an OpenSpec change. A small
+new tool can use PRD-lite or equivalent intent + scoped spec/tasks; load only relevant capabilities.
+
+## 1. Baseline discovery (including every resume)
+- Confirm Git root, branch, HEAD and relevant uncommitted edits; inspect actual scoped code/tests.
+- Read canonical requirements, specs, ADRs, existing project map, active OpenSpec change, decisions
+  and latest evidence. Record source/section, observed revision, owner and approval status; unknown
+  stays unknown. Distinguish approved, proposed, in implementation and superseded claims.
+- Compare the prior handoff's revisions with current files/source versions and actual PR/check state.
+  On changes, invalidate affected assumptions/evidence, re-run impact analysis and reverify affected
+  behavior. Preserve unrelated user work. An old summary or a green run on an older revision is not
+  current truth. With missing access, mark the baseline unverified and block only dependent work.
+- Reuse design.md for change-local baseline/impact, tasks.md for progress/handoff, decisions.json
+  for consequential questions and source-backed answers; use the existing project map/decision log
+  for durable shared facts. Link these records, do not create a parallel context database or log.
+
+## 2. Impact analysis and decisions
+Trace stable requirement IDs through spec → code/contracts → tests/evidence. Inspect callers,
+data/API/event consumers, NFR, compatibility, migration and regression impact at the affected boundary.
+Use only needed perspectives; the host can perform them sequentially:
+
+| Perspective | Activate when | Existing skill / result |
+| --- | --- | --- |
+| BA | Requirements/rules/use cases/AC change | Product business-analysis and acceptance-criteria; source-linked delta |
+| PO / Product Manager | Value, priority, MVP/release scope or feedback changes | Product backlog-prioritization; proposed scope and actual owner decision |
+| Project Manager | Dependencies, sequencing, risks or progress change | Delivery scope-change/planning; evidence-linked plan delta, no promised dates |
+| SA | Architecture, data/API/event contracts, NFR or compatibility changes | Architecture change-impact/decision-records; affected map/contracts/ADR |
+| Dev / QA | Implementation or behavior changes | Core spec/debugging/tdd/verification/review; regression and drift evidence |
+
+These are existing skills when their modules are installed, not mandatory capability dependencies.
+Core-only hosts capture the relevant perspective in the change note. Do not install modules or spawn
+agents just to satisfy the table. Reuse existing authorization and decisions; clarify only unresolved
+consequential choices. If docs and code disagree, cite both revisions and concrete differences,
+identify the authorized source/owner and record the resolution before changing disputed behavior.
+Neither newer code nor an approved-but-superseded document automatically wins; do independent work.
+
+## 3. Update spec and implement
+Keep approved intent distinct from proposed changes. Reuse the active OpenSpec change for the same
+scope; split independent/unaccepted feedback into proposed backlog items. Preserve stable IDs and
+superseded decision history. Update only affected scenarios/design/tasks before implementing the
+accepted slice with harness-spec, harness-tdd or harness-debugging and the relevant adapter.
+Use spec-to-code readiness for full changes, not as business approval or a small-fix paperwork gate.
+
+## 4. Verification and selective documentation maintenance
+Use adaptive-verification and harness-verification from the existing bundle. Compare each AC with
+actual results at the tested revision/environment. Keep runtime PASSED/FAILED/BLOCKED/NOT_RUN and
+static inspection distinct; never promote static analysis into runtime PASS or business approval.
+
+For each change list artifacts to create, update, supersede or leave unchanged, with concrete reasons.
+With configured outputs reuse artifact-impact.json for every output and affected input; without them
+use the existing change/PR note. Reference exact affected sections, stable IDs, canonical destinations
+and policies in artifacts.json/integrations.json. Ask storage only if it is still unknown and docs are
+needed. Do not reinterpret configured aliases as access, or duplicate an external canonical source.
+
+Use Product techspec-maintenance when installed; otherwise maintain the existing scoped docs/spec.
+Preserve unrelated sections and user edits. Immediately before any source write, re-read its current
+revision/hash and compare to the observed baseline. If changed, reconcile the section diff first;
+if no safe concurrency guard is available, return a proposal. The host enforces access and performs
+calls: read-only means no source mutation, propose means a reviewable patch/handoff, write still
+requires existing bounded authorization and actual tool support.
+
+Read-only source: leave that source unchanged and link a separate section-level proposal and owner
+handoff in the impact reason/evidence. Do not record its canonical update as done. A proposal can
+complete a proposal-only assignment; if canonical publication is required, report that dependency
+BLOCKED. For unavailable sources, do not invent revisions/content or silently create a local master.
+Existing artifact-impact status remains pending/done/blocked: done describes the recorded action,
+not approval/publication. Detailed verification statuses live in the linked report. Legacy
+verification.json uses passed/failed/skipped; encode BLOCKED/NOT_RUN as skipped with the explicit
+reason and report link, never as passed. No JSON schema or new lifecycle registry is required.
+
+## 5. Feedback, review and continuity
+Capture supplied bug reports, UAT findings, user feedback and operational evidence in the existing
+backlog/issue or a reviewable proposal under its write policy. Deduplicate by source/requirement,
+record observed vs expected, source/revision, severity/value, affected IDs, owner and proposed action.
+Distinguish defect against accepted AC from a new request. Feedback is proposed until an authorized
+owner accepts it; do not expand active scope, promise release dates or invent operating measurements.
+
+Track proposed → clarifying → implementing → verification → review in existing tasks/decision notes;
+mark blockers at the relevant step. Report implementation complete, merged and released separately,
+with actual PR merge SHA and release artifact/deployment evidence when available. Unknown is unknown.
+No auto-merge/release; archive only after the existing OpenSpec merge gate.
+
+Before handoff, require AC-to-result links, necessary checks with evidence or explicit BLOCKED/NOT_RUN,
+affected-doc updates/proposals consistent with policy, and remaining work/risks/next step. Missing
+mandatory checks or required publication prevent an unconditional completion claim. State the
+completed scope and limitations, not simply “done”. Update the existing tasks.md handoff with current
+baseline, decisions, evidence revision, blockers, remaining work, next action/owner and distinct
+implementation/merge/release status. On the next session, start again at baseline discovery.

package/core/workflows/spec-to-code.md

@@ -37,3 +37,8 @@ them sequentially. Respect the host's delegation rules.
 Small documentation edits or obvious low-risk fixes may skip a full spec with a rationale in the PR.
 Security-sensitive or externally visible behavior changes need explicit acceptance scenarios.
 Never archive an unmerged proposal as implemented. CI remains authoritative for actual check results.
+
+For proportional checks and evidence integrity, use `.harness/core/workflows/adaptive-verification.md` and `harness-verification`.
+
+For successive changes and resumed sessions, enter through `continuous-development.md` for baseline
+reconciliation, selective artifact maintenance, feedback triage and evidence-linked handoff.

package/docs/README.md

@@ -39,3 +39,7 @@ Chỉ đọc phần phù hợp với công việc đang làm.
 
 [Contributing](../CONTRIBUTING.md) · [Bảo trì & ma trận ảnh hưởng](harness-maintenance.md) · [Kiến trúc](architecture.md) · [Thêm adapter](adapters.md).
 [Release policy](release-policy.md) · [Phát hành npm](npm-release.md) · [Versioning & migration](versioning.md) · [Changelog](../CHANGELOG.md).
+
+See [Adaptive verification and TechSpec](adaptive-verification.md) for read-only discovery, evidence reports and selective technical documentation.
+
+[Continuous development & living documentation](continuous-development.md): successive features, bugfixes, baseline reconciliation and selective maintenance.