chati-dev 4.4.1 → 4.5.2

package/node_modules/@chati/release-lane/README.md

@@ -0,0 +1,24 @@
+# CHATI Release Lane
+
+Fixture-only C-11 contract. This package accepts only `FakeReleaseTransport` and has no network client, credential loader, Git command, deployment command or timer.
+
+`ReleaseLane` creates immutable hash-chained records. A release needs non-empty source completion references verified by an injected C-06 completion verifier as `merged` and bound to the same immutable reference, an immutable plan reference, passed fake smoke evidence and a human authorization whose `scope_hash` matches the exact release scope. Rollback is a separate attempt with a separate human authorization and scope hash. The package rejects accessors and non-plain nested inputs before it canonicalizes or records them.
+
+## Legacy removal readiness
+
+| Legacy surface | Replacement in G3 | Parity and migration evidence | Rollback | Responsibility | Status |
+| --- | --- | --- | --- | --- | --- |
+| BUILD agent | `chati-rail` execution attempt | G3-4 fixtures, G3-9 pending | legacy remains intact | Gabriel, technical policy | not-ready |
+| QA Implementation | `chati-review-council` plus RAIL completion | G3-5 fixtures, G3-9 pending | legacy remains intact | Gabriel, technical policy | ready-for-shadow |
+| QA Visual | browser capability contract | G3-7B fixtures, real visual parity pending | legacy remains intact | Gabriel, browser policy | not-ready |
+| DevOps / release | this fake-only release lane | C-11 tests below, real release deliberately absent | legacy remains intact | Gabriel, release policy | ready-for-shadow |
+| Legacy hooks | provider-neutral policy and adapters | G3-9 migration fixture pending | legacy remains intact | Gabriel, CHATI core | not-ready |
+| Provider maps | provider registry and harness adapters | G3-1 to G3-3 tests, parity pending | legacy remains intact | Gabriel, CHATI core | ready-for-shadow |
+
+No row is `ready-for-removal`. This matrix is not authorization to delete or deploy.
+
+## Verification
+
+```sh
+npm -w @chati/release-lane test
+```

package/node_modules/@chati/release-lane/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@chati/release-lane",
+  "version": "0.1.0",
+  "private": true,
+  "description": "Local, fake-only release and rollback authorization contract for CHATI",
+  "type": "module",
+  "exports": "./src/index.js",
+  "dependencies": {
+    "@chati/core": "0.1.0"
+  },
+  "scripts": {
+    "test": "node --test test/**/*.test.js"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}

package/node_modules/@chati/release-lane/src/index.js

@@ -0,0 +1,172 @@
+import { ContractError, canonicalize, sha256 } from '@chati/core';
+
+const RFC3339 = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/;
+const FAKE_TRANSPORT_CAPABILITIES = new WeakMap();
+
+function fail(code, message, details = {}) { throw new ContractError(code, message, details); }
+
+function plainData(value, code, label, ancestors = new Set()) {
+  if (value === null || ['string', 'boolean', 'number'].includes(typeof value)) return;
+  if (!value || typeof value !== 'object') fail(code, `${label} must be JSON-compatible data`);
+  if (ancestors.has(value)) fail(code, `${label} must not contain cycles`);
+  ancestors.add(value);
+  if (Array.isArray(value)) {
+    for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value))) {
+      if (key === 'length') continue;
+      if (descriptor.get || descriptor.set) fail(code, `${label}[${key}] must not be an accessor`);
+      plainData(descriptor.value, code, `${label}[${key}]`, ancestors);
+    }
+  } else {
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) fail(code, `${label} must be a plain object`);
+    for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value))) {
+      if (descriptor.get || descriptor.set) fail(code, `${label}.${key} must not be an accessor`);
+      plainData(descriptor.value, code, `${label}.${key}`, ancestors);
+    }
+  }
+  ancestors.delete(value);
+}
+
+function deepFreeze(value) {
+  if (value && typeof value === 'object' && !Object.isFrozen(value)) {
+    for (const item of Object.values(value)) deepFreeze(item);
+    Object.freeze(value);
+  }
+  return value;
+}
+function freezeData(value, code = 'UNSAFE_DATA', label = 'value') { plainData(value, code, label); return deepFreeze(canonicalize(value)); }
+function object(value, code, label) { plainData(value, code, label); if (!value || typeof value !== 'object' || Array.isArray(value)) fail(code, `${label} must be an object`); }
+function string(value, code, label) { if (typeof value !== 'string' || value.trim() === '') fail(code, `${label} must be a non-empty string`); }
+function strings(value, code, label, { empty = false } = {}) { plainData(value, code, label); if (!Array.isArray(value) || (!empty && value.length === 0) || !value.every((item) => typeof item === 'string' && item.trim())) fail(code, `${label} must be an array of non-empty strings`); }
+function at(clock) {
+  if (typeof clock !== 'function') fail('MISSING_CLOCK', 'a deterministic clock is required');
+  const result = clock();
+  const iso = result instanceof Date ? result.toISOString() : result;
+  if (typeof iso !== 'string' || !RFC3339.test(iso) || Number.isNaN(Date.parse(iso))) fail('INVALID_CLOCK', 'clock must return a valid RFC3339 timestamp or Date');
+  return iso;
+}
+function releaseScope(request) { return freezeData({ action: 'release', environment: request.environment, release_attempt_id: request.release_attempt_id, release_plan_ref: request.release_plan_ref, rollback_plan_ref: request.rollback_plan_ref, source_completion_refs: [...request.source_completion_refs] }); }
+function rollbackScope(request) { return freezeData({ action: 'rollback', release_attempt_id: request.release_attempt_id, rollback_attempt_id: request.rollback_attempt_id, rollback_plan_ref: request.rollback_plan_ref }); }
+function authorization(input, scopeHash) {
+  object(input, 'MISSING_HUMAN_AUTHORIZATION', 'authorization');
+  if (input.actor_type === undefined) fail('MISSING_HUMAN_AUTHORIZATION', 'authorization.actor_type is required');
+  if (input.actor_type !== 'human') fail('AUTHORIZATION_ACTOR_NOT_HUMAN', 'release authorization must be issued by a human actor');
+  string(input.authorized_by, 'MISSING_HUMAN_AUTHORIZATION', 'authorization.authorized_by');
+  string(input.authorized_at, 'INVALID_HUMAN_AUTHORIZATION', 'authorization.authorized_at');
+  if (!RFC3339.test(input.authorized_at) || Number.isNaN(Date.parse(input.authorized_at))) fail('INVALID_HUMAN_AUTHORIZATION', 'authorization.authorized_at must be RFC3339');
+  string(input.scope_hash, 'MISSING_HUMAN_AUTHORIZATION', 'authorization.scope_hash');
+  if (input.scope_hash !== scopeHash) fail('AUTHORIZATION_SCOPE_MISMATCH', 'authorization scope_hash does not match the immutable operation scope');
+  return freezeData(input, 'INVALID_HUMAN_AUTHORIZATION', 'authorization');
+}
+function smoke(input) { object(input, 'MISSING_SMOKE_EVIDENCE', 'smoke'); if (input.verdict !== 'passed') fail('SMOKE_EVIDENCE_FAILED', 'release or rollback requires passed smoke evidence'); strings(input.evidence_refs, 'MISSING_SMOKE_EVIDENCE', 'smoke.evidence_refs'); return freezeData(input, 'MISSING_SMOKE_EVIDENCE', 'smoke'); }
+function fakeAdapter(adapter) { const capability = FAKE_TRANSPORT_CAPABILITIES.get(adapter); if (!capability) fail('EXTERNAL_TRANSPORT_FORBIDDEN', 'G3 release lane accepts only a capability minted by FakeReleaseTransport'); return capability; }
+
+/** C-11 fixture-only release authority. No network, credentials, Git command or deployment command exists here. */
+export class ReleaseLane {
+  #clock;
+  #verifyCompletion;
+  #records = [];
+  #releases = new Map();
+  #rollbacks = new Map();
+
+  constructor({ clock, verify_completion } = {}) {
+    if (typeof verify_completion !== 'function') fail('MISSING_COMPLETION_VERIFIER', 'verify_completion must validate C-06 completion evidence');
+    this.#clock = clock;
+    this.#verifyCompletion = verify_completion;
+  }
+  get records() { return freezeData([...this.#records]); }
+  #record(type, payload) {
+    const previous_hash = this.#records.at(-1)?.chain_hash ?? 'GENESIS';
+    const material = freezeData({ schema_version: 1, sequence: this.#records.length + 1, type, occurred_at: at(this.#clock), payload });
+    const recordHash = sha256(material);
+    const record = freezeData({ ...material, record_hash: recordHash, previous_hash, chain_hash: sha256({ previous_hash, record_hash: recordHash }) });
+    this.#records.push(record);
+    return record;
+  }
+  #verifyCompletions(refs) {
+    return freezeData(refs.map((ref) => {
+      const completion = this.#verifyCompletion(ref);
+      object(completion, 'UNVERIFIABLE_SOURCE_COMPLETION', `completion ${ref}`);
+      if (completion.state !== 'merged') fail('SOURCE_COMPLETION_NOT_MERGED', 'source completion must be C-06 merged evidence', { ref });
+      string(completion.completion_id, 'UNVERIFIABLE_SOURCE_COMPLETION', `completion ${ref}.completion_id`);
+      string(completion.immutable_ref, 'UNVERIFIABLE_SOURCE_COMPLETION', `completion ${ref}.immutable_ref`);
+      if (completion.immutable_ref !== ref) fail('SOURCE_COMPLETION_REF_MISMATCH', 'completion verifier did not bind the requested immutable reference', { ref });
+      return { completion_id: completion.completion_id, immutable_ref: completion.immutable_ref, state: completion.state };
+    }));
+  }
+  createReleaseAttempt(request = {}) {
+    object(request, 'INVALID_RELEASE_ATTEMPT', 'release request');
+    for (const field of ['release_attempt_id', 'environment', 'release_plan_ref', 'rollback_plan_ref']) string(request[field], 'INVALID_RELEASE_ATTEMPT', field);
+    strings(request.source_completion_refs, 'INVALID_RELEASE_ATTEMPT', 'source_completion_refs');
+    if (this.#releases.has(request.release_attempt_id)) fail('RELEASE_ATTEMPT_EXISTS', 'release_attempt_id already exists');
+    const verifiedCompletions = this.#verifyCompletions(request.source_completion_refs);
+    const scope = releaseScope(request);
+    const attempt = freezeData({ ...request, verified_completions: verifiedCompletions, scope, scope_hash: sha256(scope), state: 'created' });
+    this.#releases.set(attempt.release_attempt_id, attempt);
+    this.#record('release_attempt_created', { attempt });
+    return attempt;
+  }
+  executeRelease({ release_attempt_id, authorization: approval, smoke: smokeInput, adapter } = {}) {
+    string(release_attempt_id, 'INVALID_RELEASE_ATTEMPT', 'release_attempt_id');
+    const attempt = this.#releases.get(release_attempt_id);
+    if (!attempt) fail('RELEASE_ATTEMPT_NOT_FOUND', 'release attempt does not exist');
+    if (attempt.state !== 'created') fail('RELEASE_ATTEMPT_TERMINAL', 'release attempt is no longer executable');
+    try {
+      const humanAuthorization = authorization(approval, attempt.scope_hash);
+      const smokeEvidence = smoke(smokeInput);
+      const capability = fakeAdapter(adapter);
+      this.#record('release_authorized', { release_attempt_id, authorization: humanAuthorization });
+      this.#record('release_smoke_verified', { release_attempt_id, smoke: smokeEvidence });
+      const receipt = capability.release(freezeData({ attempt, authorization: humanAuthorization, smoke: smokeEvidence }));
+      string(receipt?.receipt_ref, 'INVALID_FAKE_RECEIPT', 'fake release receipt_ref');
+      const released = freezeData({ ...attempt, state: 'released', authorization: humanAuthorization, smoke: smokeEvidence, receipt_ref: receipt.receipt_ref });
+      this.#releases.set(release_attempt_id, released);
+      this.#record('release_completed', { release_attempt_id, receipt_ref: receipt.receipt_ref });
+      return released;
+    } catch (error) {
+      this.#releases.set(release_attempt_id, freezeData({ ...attempt, state: 'rejected', rejection_code: error.code ?? 'RELEASE_EXECUTION_FAILED' }));
+      this.#record('release_rejected', { release_attempt_id, code: error.code ?? 'RELEASE_EXECUTION_FAILED' });
+      throw error;
+    }
+  }
+  executeRollback({ rollback_attempt_id, release_attempt_id, rollback_plan_ref, authorization: approval, smoke: smokeInput, adapter } = {}) {
+    string(rollback_attempt_id, 'INVALID_ROLLBACK_ATTEMPT', 'rollback_attempt_id');
+    string(release_attempt_id, 'INVALID_ROLLBACK_ATTEMPT', 'release_attempt_id');
+    string(rollback_plan_ref, 'INVALID_ROLLBACK_ATTEMPT', 'rollback_plan_ref');
+    if (this.#rollbacks.has(rollback_attempt_id)) fail('ROLLBACK_ATTEMPT_EXISTS', 'rollback_attempt_id already exists');
+    const release = this.#releases.get(release_attempt_id);
+    if (!release || release.state !== 'released') fail('ROLLBACK_SOURCE_NOT_RELEASED', 'rollback requires a separately recorded released attempt');
+    const scope = rollbackScope({ rollback_attempt_id, release_attempt_id, rollback_plan_ref });
+    const attempt = freezeData({ rollback_attempt_id, release_attempt_id, rollback_plan_ref, scope, scope_hash: sha256(scope), state: 'created' });
+    this.#rollbacks.set(rollback_attempt_id, attempt);
+    this.#record('rollback_attempt_created', { attempt });
+    try {
+      const humanAuthorization = authorization(approval, attempt.scope_hash);
+      const smokeEvidence = smoke(smokeInput);
+      const capability = fakeAdapter(adapter);
+      this.#record('rollback_authorized', { rollback_attempt_id, authorization: humanAuthorization });
+      this.#record('rollback_smoke_verified', { rollback_attempt_id, smoke: smokeEvidence });
+      const receipt = capability.rollback(freezeData({ attempt, release, authorization: humanAuthorization, smoke: smokeEvidence }));
+      string(receipt?.receipt_ref, 'INVALID_FAKE_RECEIPT', 'fake rollback receipt_ref');
+      const rolledBack = freezeData({ ...attempt, state: 'rolled_back', authorization: humanAuthorization, smoke: smokeEvidence, receipt_ref: receipt.receipt_ref });
+      this.#rollbacks.set(rollback_attempt_id, rolledBack);
+      this.#record('rollback_completed', { rollback_attempt_id, receipt_ref: receipt.receipt_ref });
+      return rolledBack;
+    } catch (error) {
+      this.#rollbacks.set(rollback_attempt_id, freezeData({ ...attempt, state: 'rejected', rejection_code: error.code ?? 'ROLLBACK_EXECUTION_FAILED' }));
+      this.#record('rollback_rejected', { rollback_attempt_id, code: error.code ?? 'ROLLBACK_EXECUTION_FAILED' });
+      throw error;
+    }
+  }
+}
+
+export class FakeReleaseTransport {
+  #attempts = [];
+  constructor() {
+    FAKE_TRANSPORT_CAPABILITIES.set(this, Object.freeze({
+      release: (input) => { this.#attempts.push(freezeData({ operation: 'release', release_attempt_id: input.attempt.release_attempt_id })); return freezeData({ receipt_ref: `fake://release/${input.attempt.release_attempt_id}` }); },
+      rollback: (input) => { this.#attempts.push(freezeData({ operation: 'rollback', rollback_attempt_id: input.attempt.rollback_attempt_id })); return freezeData({ receipt_ref: `fake://rollback/${input.attempt.rollback_attempt_id}` }); },
+    }));
+  }
+  get attempts() { return freezeData([...this.#attempts]); }
+}

package/node_modules/@chati/review-council/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@chati/review-council",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "exports": "./src/index.js",
+  "dependencies": {
+    "@chati/core": "0.1.0",
+    "@chati/provider-registry": "0.1.0"
+  },
+  "scripts": {
+    "test": "node --test test/**/*.test.js"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}

package/node_modules/@chati/review-council/src/index.js

@@ -0,0 +1,264 @@
+import { ContractError, canonicalize } from '@chati/core';
+import { assertEligibleInvocation } from '@chati/provider-registry';
+
+const LEVELS = new Set(['A', 'B', 'C']);
+const SEVERITIES = new Set(['critical', 'high', 'medium', 'low']);
+const DISPOSITIONS = new Set(['accepted', 'rejected', 'unresolved']);
+const VERDICTS = new Set(['accept', 'rework', 'required-human-decision', 'blocked']);
+const AUTHORITY_REASONS = new Set(['scope', 'security', 'privacy', 'cost', 'external-action']);
+const IMPASSE_KINDS = new Set(['none', 'technical']);
+
+function fail(code, message, details = {}) {
+  throw new ContractError(code, message, details);
+}
+
+function assertObject(value, code, label) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) fail(code, `${label} must be an object`);
+}
+
+function assertString(value, code, label) {
+  if (typeof value !== 'string' || value.trim() === '') fail(code, `${label} must be a non-empty string`);
+}
+
+function assertRef(value, code, label) {
+  assertString(value, code, label);
+}
+
+function freeze(value) {
+  if (value && typeof value === 'object' && !Object.isFrozen(value)) {
+    Object.freeze(value);
+    for (const nested of Object.values(value)) freeze(nested);
+  }
+  return value;
+}
+
+function validateIdentity(identity, label) {
+  assertObject(identity, 'INVALID_REVIEW_IDENTITY', label);
+  for (const field of ['provider_id', 'model_id']) assertString(identity[field], 'INVALID_REVIEW_IDENTITY', `${label}.${field}`);
+  return identity;
+}
+
+function validateFinding(finding) {
+  assertObject(finding, 'INVALID_REVIEW_FINDING', 'finding');
+  assertString(finding.finding_id, 'INVALID_REVIEW_FINDING', 'finding.finding_id');
+  if (!SEVERITIES.has(finding.severity)) fail('INVALID_REVIEW_FINDING', 'finding.severity is invalid');
+  assertRef(finding.location_ref, 'INVALID_REVIEW_FINDING', 'finding.location_ref');
+  if (!Array.isArray(finding.evidence_refs) || !finding.evidence_refs.every((ref) => typeof ref === 'string' && ref.trim() !== '')) {
+    fail('INVALID_REVIEW_FINDING', 'finding.evidence_refs must be an array of non-empty strings');
+  }
+  if (!DISPOSITIONS.has(finding.disposition)) fail('INVALID_REVIEW_FINDING', 'finding.disposition is invalid');
+  assertRef(finding.disposition_reason_ref, 'INVALID_REVIEW_FINDING', 'finding.disposition_reason_ref');
+  if (finding.root_cause_taxonomy !== undefined) assertString(finding.root_cause_taxonomy, 'INVALID_REVIEW_FINDING', 'finding.root_cause_taxonomy');
+}
+
+/** Validates the normalized C-05 review record without invoking a model. */
+export function validateReviewRecord(review) {
+  assertObject(review, 'INVALID_REVIEW', 'review');
+  for (const field of ['review_id', 'attempt_id', 'reviewer_invocation_ref', 'rubric_ref']) assertString(review[field], 'INVALID_REVIEW', field);
+  if (!Number.isInteger(review.review_round) || review.review_round < 1) fail('INVALID_REVIEW', 'review_round must be a positive integer');
+  for (const field of ['required_independence_level', 'attained_independence_level']) {
+    if (!LEVELS.has(review[field])) fail('INVALID_REVIEW', `${field} must be A, B or C`);
+  }
+  validateIdentity(review.builder_identity, 'builder_identity');
+  validateIdentity(review.reviewer_identity, 'reviewer_identity');
+  if (review.clean_context !== true) fail('REVIEW_CONTEXT_NOT_CLEAN', 'review requires a declared clean context');
+  assertObject(review.degradation, 'INVALID_REVIEW_DEGRADATION', 'degradation');
+  if (!['none', 'approved'].includes(review.degradation.status)) fail('INVALID_REVIEW_DEGRADATION', 'degradation.status is invalid');
+  if (review.degradation.status === 'approved') {
+    assertString(review.degradation.approved_by, 'INVALID_REVIEW_DEGRADATION', 'degradation.approved_by');
+    assertRef(review.degradation.reason_ref, 'INVALID_REVIEW_DEGRADATION', 'degradation.reason_ref');
+  }
+  if (!Array.isArray(review.findings)) fail('INVALID_REVIEW', 'findings must be an array');
+  const findingIds = new Set();
+  for (const finding of review.findings) {
+    validateFinding(finding);
+    if (findingIds.has(finding.finding_id)) fail('DUPLICATE_REVIEW_FINDING', 'finding_id is duplicated');
+    findingIds.add(finding.finding_id);
+  }
+  if (!VERDICTS.has(review.verdict)) fail('INVALID_REVIEW', 'verdict is invalid');
+  if (review.findings.some((finding) => finding.disposition === 'accepted') && review.verdict !== 'rework') {
+    fail('ACCEPTED_FINDINGS_REQUIRE_REWORK', 'any accepted finding requires verdict rework');
+  }
+  assertObject(review.impasse, 'INVALID_REVIEW_IMPASSE', 'impasse');
+  if (!IMPASSE_KINDS.has(review.impasse.kind)) fail('INVALID_REVIEW_IMPASSE', 'impasse.kind is invalid');
+  if (review.impasse.kind === 'technical') assertRef(review.impasse.evidence_ref, 'INVALID_REVIEW_IMPASSE', 'impasse.evidence_ref');
+  if (review.impasse.kind === 'none' && review.impasse.evidence_ref !== undefined) fail('INVALID_REVIEW_IMPASSE', 'impasse.evidence_ref is only valid for technical impasse');
+  if (review.verdict === 'required-human-decision') {
+    if (!AUTHORITY_REASONS.has(review.authority_reason)) {
+      fail('HUMAN_DECISION_NOT_AUTHORITY', 'required-human-decision requires an enumerated authority reason');
+    }
+    assertRef(review.authority_reason_ref, 'HUMAN_DECISION_NOT_AUTHORITY', 'authority_reason_ref');
+  } else if (review.authority_reason !== undefined || review.authority_reason_ref !== undefined) {
+    fail('UNEXPECTED_AUTHORITY_REASON', 'authority reason is only valid for required-human-decision');
+  }
+  return freeze(canonicalize(review));
+}
+
+/** Computes the declared independence level from the two model identities. */
+export function computeIndependenceLevel({ builder_identity, reviewer_identity }) {
+  validateIdentity(builder_identity, 'builder_identity');
+  validateIdentity(reviewer_identity, 'reviewer_identity');
+  if (builder_identity.provider_id !== reviewer_identity.provider_id) return 'A';
+  if (builder_identity.model_id !== reviewer_identity.model_id) return 'B';
+  return 'C';
+}
+
+/** C-05: A/B may never silently degrade to C. */
+export function assertReviewIndependence(review) {
+  const validated = validateReviewRecord(review);
+  const computed = computeIndependenceLevel(validated);
+  if (computed !== validated.attained_independence_level) {
+    fail('INDEPENDENCE_LEVEL_MISMATCH', 'attained_independence_level does not match the declared identities', { computed, attained: validated.attained_independence_level });
+  }
+  const order = { A: 3, B: 2, C: 1 };
+  if (order[validated.attained_independence_level] < order[validated.required_independence_level] && validated.degradation.status !== 'approved') {
+    fail('INDEPENDENCE_UNAVAILABLE', 'required independent review is unavailable without an explicit approved degradation');
+  }
+  return validated;
+}
+
+/**
+ * Derives cycles from evidence, not caller-supplied review objects. Every
+ * history record is bound to the same attempt and proves C-01/C-02 reviewer
+ * eligibility before it may affect a rework metric.
+ */
+function inspectReviewHistory({ review_evidence, attempt_id, installation, snapshot, clock }) {
+  if (!Array.isArray(review_evidence)) fail('INVALID_REVIEW_HISTORY', 'review_evidence must be an array');
+  assertString(attempt_id, 'INVALID_REVIEW_HISTORY', 'attempt_id');
+  const reviewIds = new Set();
+  const rounds = new Set();
+  const reworkCycles = review_evidence.reduce((count, entry) => {
+    assertObject(entry, 'INVALID_REVIEW_HISTORY', 'review evidence entry');
+    const validated = acceptReview({ review: entry.review, invocation: entry.invocation, installation, snapshot, clock });
+    if (validated.attempt_id !== attempt_id) fail('REVIEW_ATTEMPT_MISMATCH', 'review history may only contain the current attempt', { expected_attempt_id: attempt_id, actual_attempt_id: validated.attempt_id });
+    if (reviewIds.has(validated.review_id)) fail('DUPLICATE_REVIEW_ID', 'review history cannot repeat review_id within an attempt', { attempt_id, review_id: validated.review_id });
+    if (rounds.has(validated.review_round)) fail('DUPLICATE_REVIEW_ROUND', 'review history cannot repeat review_round within an attempt', { attempt_id, review_round: validated.review_round });
+    reviewIds.add(validated.review_id);
+    rounds.add(validated.review_round);
+    return count + (validated.findings.some((finding) => finding.disposition === 'accepted') ? 1 : 0);
+  }, 0);
+  return { reworkCycles, reviewIds, rounds };
+}
+
+export function countReworkCycles(input) {
+  return inspectReviewHistory(input).reworkCycles;
+}
+
+function assertReviewerEligible({ review, invocation, installation, snapshot, clock }) {
+  if (!invocation) fail('MISSING_REVIEWER_INVOCATION', 'reviewer invocation is required to prove eligibility');
+  const eligible = assertEligibleInvocation({ installation, snapshot, invocation, clock });
+  if (invocation.action !== 'review') fail('INVALID_REVIEWER_ACTION', 'reviewer invocation action must be review');
+  if (invocation.invocation_id !== review.reviewer_invocation_ref) {
+    fail('REVIEWER_INVOCATION_REFERENCE_MISMATCH', 'reviewer invocation must match review.reviewer_invocation_ref');
+  }
+  if (invocation.provider_id !== review.reviewer_identity.provider_id || invocation.model_pin.model_id !== review.reviewer_identity.model_id) {
+    fail('REVIEWER_IDENTITY_MISMATCH', 'reviewer identity must match the eligible invocation');
+  }
+  return eligible;
+}
+
+/** Validates review independence and selected-only reviewer eligibility. */
+export function acceptReview({ review, invocation, installation, snapshot, clock }) {
+  const validated = assertReviewIndependence(review);
+  assertReviewerEligible({ review: validated, invocation, installation, snapshot, clock });
+  return validated;
+}
+
+/**
+ * Selects one top-tier adjudicator per installation-selected harness. A
+ * project may use one, two or three providers, but never gains an unselected
+ * vendor merely because a rework loop escalated.
+ */
+export function selectAdjudicationInvocations({ installation, snapshot }) {
+  const invocations = [];
+  const missing = [];
+  for (const binding of installation.enabled_providers) {
+    const eligibleModels = snapshot.models
+      .filter((model) => model.provider_id === binding.provider_id
+        && binding.allowed_models.includes(model.model_id)
+        && model.actions.includes('adjudication')
+        && typeof model.highest_reasoning_configuration === 'string'
+        && model.highest_reasoning_configuration.trim() !== ''
+        && binding.allowed_reasoning_configurations?.includes(model.highest_reasoning_configuration))
+      .sort((left, right) => (right.adjudication_priority ?? 0) - (left.adjudication_priority ?? 0)
+        || left.model_id.localeCompare(right.model_id));
+    const selected = eligibleModels[0];
+    if (!selected) {
+      missing.push({ provider_id: binding.provider_id, harness_id: binding.harness_id, reason_code: 'NO_SELECTED_ADJUDICATION_MODEL' });
+      continue;
+    }
+    invocations.push({
+      provider_id: binding.provider_id,
+      harness_id: binding.harness_id,
+      action: 'adjudication',
+      model_pin: {
+        model_id: selected.model_id,
+        catalog_snapshot_ref: snapshot.snapshot_id,
+        reasoning_configuration: selected.highest_reasoning_configuration,
+      },
+    });
+  }
+  return { invocations, missing };
+}
+
+/**
+ * Creates the local-only AI adjudication plan after two completed normal
+ * rework cycles and a third technical impasse. It never executes a CLI.
+ */
+export function decideReviewProgress({ prior_review_evidence = [], current_review, reviewer_invocation, installation, snapshot, clock }) {
+  const current = acceptReview({ review: current_review, invocation: reviewer_invocation, installation, snapshot, clock });
+  const history = inspectReviewHistory({ review_evidence: prior_review_evidence, attempt_id: current.attempt_id, installation, snapshot, clock });
+  if (history.reviewIds.has(current.review_id)) fail('DUPLICATE_REVIEW_ID', 'current review_id already exists in this attempt history', { attempt_id: current.attempt_id, review_id: current.review_id });
+  if (history.rounds.has(current.review_round)) fail('DUPLICATE_REVIEW_ROUND', 'current review_round already exists in this attempt history', { attempt_id: current.attempt_id, review_round: current.review_round });
+  const priorCycles = history.reworkCycles;
+  if (current.verdict === 'required-human-decision') return freeze(canonicalize({ decision: 'required-human-decision', authority_reason: current.authority_reason }));
+  if (current.verdict !== 'rework') return freeze(canonicalize({ decision: current.verdict, rework_cycles: priorCycles }));
+  if (priorCycles < 2) {
+    return freeze(canonicalize({
+      decision: 'normal-rework',
+      rework_cycles: priorCycles + (current.findings.some((finding) => finding.disposition === 'accepted') ? 1 : 0),
+    }));
+  }
+  if (current.impasse.kind !== 'technical') {
+    return freeze(canonicalize({
+      decision: 'blocked',
+      reason: 'TECHNICAL_IMPASSE_EVIDENCE_REQUIRED',
+      requires: 'policy-or-handoff-revision',
+      rework_cycles: priorCycles + (current.findings.some((finding) => finding.disposition === 'accepted') ? 1 : 0),
+    }));
+  }
+
+  const { invocations, missing } = selectAdjudicationInvocations({ installation, snapshot });
+  for (const invocation of invocations) {
+    try {
+      assertEligibleInvocation({ installation, snapshot, invocation, clock });
+    } catch (error) {
+      missing.push({ provider_id: invocation.provider_id, model_id: invocation.model_pin.model_id, reason_code: error.code ?? 'NOT_ELIGIBLE' });
+    }
+  }
+  if (missing.length > 0 || invocations.length === 0) return freeze(canonicalize({ decision: 'blocked', reason: 'AI_ADJUDICATION_UNAVAILABLE', missing }));
+  return freeze(canonicalize({
+    decision: 'AI_ADJUDICATION',
+    rework_cycles: priorCycles + (current.findings.some((finding) => finding.disposition === 'accepted') ? 1 : 0),
+    adjudicators: invocations,
+    allowed_outcomes: ['bounded-correction', 'handoff-revision', 'blocked-authority'],
+  }));
+}
+
+/** Validates the bounded output of the three-model local adjudication step. */
+export function validateAdjudicationDecision(decision) {
+  assertObject(decision, 'INVALID_ADJUDICATION_DECISION', 'decision');
+  if (!['bounded-correction', 'handoff-revision', 'blocked-authority'].includes(decision.outcome)) {
+    fail('INVALID_ADJUDICATION_DECISION', 'outcome must be bounded-correction, handoff-revision or blocked-authority');
+  }
+  assertRef(decision.decision_ref, 'INVALID_ADJUDICATION_DECISION', 'decision_ref');
+  if (decision.outcome === 'bounded-correction') assertRef(decision.correction_ref, 'INVALID_ADJUDICATION_DECISION', 'correction_ref');
+  if (decision.outcome === 'handoff-revision') assertRef(decision.handoff_revision_ref, 'INVALID_ADJUDICATION_DECISION', 'handoff_revision_ref');
+  if (decision.outcome === 'blocked-authority') {
+    if (!AUTHORITY_REASONS.has(decision.authority_reason)) fail('HUMAN_DECISION_NOT_AUTHORITY', 'blocked authority requires an enumerated authority reason');
+    assertRef(decision.authority_reason_ref, 'HUMAN_DECISION_NOT_AUTHORITY', 'authority_reason_ref');
+  }
+  return freeze(canonicalize(decision));
+}
+
+export const authorityReasons = AUTHORITY_REASONS;

package/node_modules/@chati/tracking-clickup/README.md

@@ -0,0 +1,55 @@
+# @chati/tracking-clickup
+
+Local, deterministic implementation of G3 contract C-07.
+
+It owns a durable JSON outbox and versioned, derivable `Project Evolution`
+snapshots. Delivery and reconciliation are distinct state dimensions. A caller
+may inject a fake transport in tests or an independently authorized ClickUp
+adapter at an outer boundary.
+
+## Guarantees
+
+- A projection is persisted before `transport.send()` can run.
+- Every remote effect has a unique durable idempotency key.
+- Enqueue requires verified immutable handoff and journal references, resolved
+  through an injected reference resolver into a phase and canonical task view.
+  Decisions and receipts are likewise verified references, and are retained in
+  the derived `Project Evolution` snapshot.
+- `confirmed` requires a persisted immutable receipt reference.
+- Reconciliation cannot run before delivery confirmation and does not erase
+  delivery receipts.
+- `watchOnce()` is intentionally a one-shot replay operation. Its exported
+  interval contract is exactly hourly (`HOURLY_WATCHER_INTERVAL_MS`); hosting
+  that scheduler is outside this package, so no local timer is created.
+- ClickUp outages produce a replayable local backlog. They never pause local
+  dispatch or overwrite canonical RAIL completion.
+- A `close` projection requires an injected C-06 completion verifier. This
+  package cannot invent task completion. The same rule blocks `update`
+  payloads that try to set terminal status or an end date.
+- Schema and authorization/token preflight gates must approve before any
+  injected transport call. `sent_unconfirmed` is never resent until an
+  idempotency lookup returns `not_found`.
+- Human effort, AI processing and rework cycles must be supplied as their
+  own facts. The package never derives them from elapsed pipeline time.
+
+## Explicit limits
+
+This package has no ClickUp SDK, network client, token handling, timer,
+provider invocation, RAIL journal mutation, Brain write path, release path or
+real external action. It neither reads nor writes a real ClickUp task.
+
+`Project Evolution` is intentionally derivative. Construction and
+`rederiveProjectEvolution()` regenerate it from the durable outbox after an
+interrupted local artifact write, retaining handoff, journal, decision and
+receipt references held by the outbox. Its digest excludes its own derived
+reference and has no generated-at timestamp, so recovery recreates the same
+immutable reference until canonical source evidence changes.
+
+When a project-level projection has no execution attempt, its persisted
+canonical attempt id is `project:<project_id>:no-attempt`; it is never absent.
+
+Run its deterministic test suite with:
+
+```sh
+npm -w packages/chati-tracking-clickup test
+```

package/node_modules/@chati/tracking-clickup/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@chati/tracking-clickup",
+  "version": "0.1.0",
+  "private": true,
+  "description": "Durable, local ClickUp projection outbox for CHATI",
+  "type": "module",
+  "exports": "./src/index.js",
+  "dependencies": {
+    "@chati/core": "0.1.0"
+  },
+  "scripts": {
+    "test": "node --test test/**/*.test.js"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}