@event4u/agent-config 14.21.0 → 14.22.0

package/src/scripts/_lib/subagent_capsule.ts

@@ -143,10 +143,68 @@ export const CAPSULE_SCHEMA_VERSION = 4;
  */
 export const ACCEPTED_CAPSULE_VERSIONS: readonly number[] = [3, 4];
 
-/** The two CHECKPOINT variants sharing this schema. */
-export const CAPSULE_VARIANTS = ['worker', 'main_session'] as const;
+/** The three CHECKPOINT variants sharing this schema. */
+export const CAPSULE_VARIANTS = ['worker', 'main_session', 'continuity_record'] as const;
 export type CapsuleVariant = (typeof CAPSULE_VARIANTS)[number];
 
+/**
+ * `continuity_record` — the DETERMINISTIC main-session variant.
+ *
+ * Why a variant and not a relaxed `main_session`. `main_session` requires
+ * `failed_approaches` and `successful_approaches` with at least one entry each,
+ * and requires the explicit token `none` when nothing failed or worked — the
+ * whole point of those fields being that silence and "nothing was abandoned"
+ * stay distinguishable. A writer that runs without model spend cannot know
+ * either. It could only write `none`, which asserts a judgement nobody made.
+ *
+ * The AI council of 2026-09-07 ruled exactly this: add a variant rather than
+ * stuffing absence markers into `main_session`, because explicit absence
+ * markers "misrepresent unavailable model judgments as values". This constant
+ * set is that ruling in code.
+ *
+ * The fields below are FORBIDDEN on this variant rather than optional, and the
+ * distinction is load-bearing. Optional would leave the door open for a later
+ * writer to fill one with a guess and for a reader to be unable to tell a
+ * derived record from a judged one. Forbidden makes the variant's meaning
+ * checkable: everything a `continuity_record` carries was computed from disk.
+ *
+ * Nothing here is invented — every name is an existing key of this same schema.
+ * The council's constraint was explicit: the required fields "must be derived
+ * from the existing validated envelope contract; this ruling does not authorize
+ * inventing parallel identity or directive fields."
+ *
+ * Version compatibility is unchanged and envelope-wide: a `continuity_record`
+ * declares the same `capsule_version`, and a reader that does not know the
+ * variant refuses it by name (see `validateRecycleEnvelope`) rather than
+ * guessing at its required set.
+ */
+export const CONTINUITY_RECORD_FORBIDDEN_KEYS: ReadonlySet<string> = new Set([
+    'decisions',
+    'constraints',
+    'do_not_touch',
+    'assumptions',
+    'failed_approaches',
+    'successful_approaches',
+    'open_questions',
+    'not_carried_forward',
+    'status_summary',
+    'suggested_skills',
+    'open_worker_envelopes',
+]);
+
+/** Required on a `continuity_record` — each one computable from on-disk state. */
+export const CONTINUITY_RECORD_REQUIRED_KEYS: readonly string[] = [
+    'capsule_version',
+    'variant',
+    'summary',
+    'task',
+    'workspace',
+    'written_at',
+    'acceptance_criteria',
+    'remaining',
+    'predecessor',
+];
+
 /** A single-line token no longer than `max` chars. Rejects any body-shaped value. */
 function isShortLine(value: unknown, max: number): value is string {
     return typeof value === 'string' && value.length > 0 && value.length <= max && !value.includes('\n');
@@ -757,6 +815,31 @@ export function validateRecycleEnvelope(input: unknown): string[] {
         }
     }
 
+    // VARIANT FIRST, then version. The order is the contract, not a style
+    // choice. Required fields are variant-specific, so a reader that does not
+    // recognise the variant cannot know what to demand — and a reader that
+    // reports twenty field violations against a variant it never understood has
+    // told the operator nothing useful and, worse, has implied the record was
+    // malformed when the truth is that the reader is old. One refusal naming
+    // the variant is the honest output, and it is what makes an old reader
+    // meeting a new record a legible event rather than a pile of noise.
+    const variant = e['variant'];
+    if (typeof variant !== 'string' || !(CAPSULE_VARIANTS as readonly string[]).includes(variant)) {
+        return [
+            `unknown variant ${JSON.stringify(variant)} — this reader knows ` +
+                `${CAPSULE_VARIANTS.join(' | ')}. A reader that does not know a variant must not ` +
+                'guess at its required fields, so no further field checks were run.',
+        ];
+    }
+    if (variant === 'worker') {
+        return [
+            "variant 'worker' is a subagent generation handover and is validated by the worker " +
+                'path, not by the main-session recycle validator — routing it here would apply ' +
+                'the wrong required set to a well-formed record.',
+        ];
+    }
+    const isDerived = variant === 'continuity_record';
+
     const version = e['capsule_version'];
     if (typeof version !== 'number' || !ACCEPTED_CAPSULE_VERSIONS.includes(version)) {
         errors.push(`capsule_version must be one of ${ACCEPTED_CAPSULE_VERSIONS.join(' | ')}`);
@@ -766,9 +849,35 @@ export function validateRecycleEnvelope(input: unknown): string[] {
     // Demanding the new fields of an already-written record would be a
     // retroactive requirement, which is the one thing the recorded schema lock
     // forbids ("add fields or variants, never repurpose or remove one").
-    const atV4 = version === 4;
-    if (e['variant'] !== 'main_session') {
-        errors.push("variant must be 'main_session'");
+    //
+    // A `continuity_record` is exempt from the two v4 judgement fields for the
+    // opposite reason: it is forbidden from carrying them at all (below), so
+    // requiring them would make the variant unsatisfiable.
+    const atV4 = version === 4 && !isDerived;
+
+    if (isDerived) {
+        // Forbidden, not merely absent: a derived record that carries a
+        // judgement field is either a `main_session` mislabelled, or a
+        // deterministic writer that invented a value. Both are worth refusing
+        // loudly, and neither is distinguishable after the fact.
+        for (const key of Object.keys(e)) {
+            if (CONTINUITY_RECORD_FORBIDDEN_KEYS.has(key)) {
+                errors.push(
+                    `field "${key}" is forbidden on variant 'continuity_record' — it carries a ` +
+                        'model judgement, and a record written without model spend cannot have made ' +
+                        "one. Use variant 'main_session' for a judged record.",
+                );
+            }
+        }
+        for (const key of CONTINUITY_RECORD_REQUIRED_KEYS) {
+            if (e[key] === undefined) {
+                errors.push(
+                    `field "${key}" is required on variant 'continuity_record' — it is computable ` +
+                        'from on-disk state, so its absence is a writer defect rather than an ' +
+                        'unavailable judgement.',
+                );
+            }
+        }
     }
     if (!isShortLine(e['summary'], MAX_LINE_CHARS)) {
         errors.push(`summary must be a single line of 1–${MAX_LINE_CHARS} chars`);
@@ -789,7 +898,7 @@ export function validateRecycleEnvelope(input: unknown): string[] {
         errors.push('acceptance_criteria must carry at least one entry — the successor cannot know "done" without it');
     }
     checkList(errors, 'remaining', e['remaining'], MAX_LINE_CHARS, true);
-    checkList(errors, 'not_carried_forward', e['not_carried_forward'], MAX_LINE_CHARS, true);
+    checkList(errors, 'not_carried_forward', e['not_carried_forward'], MAX_LINE_CHARS, !isDerived);
     checkList(errors, 'decisions', e['decisions'], MAX_LINE_CHARS, false);
     errors.push(...decisionTagErrors(e['decisions']));
     checkList(errors, 'constraints', e['constraints'], MAX_LINE_CHARS, false);
@@ -809,7 +918,7 @@ export function validateRecycleEnvelope(input: unknown): string[] {
 
     // Required with ≥ 1 entry (Phase 2.3): a session that abandoned nothing
     // writes `none`. Absence must never be readable as "nothing failed".
-    checkList(errors, 'failed_approaches', e['failed_approaches'], MAX_LINE_CHARS, true);
+    checkList(errors, 'failed_approaches', e['failed_approaches'], MAX_LINE_CHARS, !isDerived);
     if (Array.isArray(e['failed_approaches']) && e['failed_approaches'].length === 0) {
         errors.push(
             'failed_approaches must carry at least one entry — write "none" explicitly, so ' +
@@ -835,7 +944,7 @@ export function validateRecycleEnvelope(input: unknown): string[] {
     // is a reader waiting for something that will not arrive.
     const predecessor = e['predecessor'];
     if (predecessor === undefined) {
-        if (atV4) {
+        if (atV4 || isDerived) {
             errors.push(
                 'predecessor is required — name the session this one continues, or write "none" ' +
                     'explicitly for the first session in a workspace',

package/src/scripts/ai_council/api_transport.ts

@@ -47,6 +47,11 @@ export function curlJsonPost(url: string, extraHeaders: string[], body: unknown)
     // before the `spawnSync` timeout would kill it with an opaque ETIMEDOUT.
     // A full 16k-token generation legitimately runs several minutes, so the
     // ceiling is 300s, not 120s (the old value timed out long Anthropic calls).
+    // Both ceilings are PER CALL, never a run total. Members are iterated
+    // serially, so a run's worst case is members x passes x 290s, and nothing
+    // cancels a call mid-flight: `spawnSync` takes no signal, which is the
+    // synchronous contract the module docblock states. The only run-level bound
+    // is the USD cap, and it is checked AFTER a call returns.
     args.push('--connect-timeout', '30', '--max-time', '290');
     args.push('-w', '\n%{http_code}', '--data-binary', '@-');
     const r = spawnSync('curl', args, {

package/src/scripts/ai_council/deliberation_metrics.ts

@@ -0,0 +1,353 @@
+/**
+ * Two per-run deliberation measurements, both computed from outputs the run has
+ * already paid for: a per-correction stage attribution, and the
+ * `zero_marginal_value_call_rate`.
+ *
+ * Pure and offline. No model call, no new similarity measure — every judgement
+ * below reuses `is_near_duplicate` from `debate_gates.ts`, which is the
+ * repository's existing answer to "did this reply add anything", and the
+ * objection vocabulary that module already publishes. Forking a second
+ * similarity notion here would be two answers to one question, and the second
+ * is the one nobody updates.
+ *
+ * WHAT A CORRECTION IS, AND WHAT IT IS NOT.
+ *
+ * A correction is an objection-bearing sentence: one that carries a marker from
+ * {@link CORRECTION_MARKERS} and therefore names something it is pushing back
+ * on. Its FIRST STAGE is the earliest stage whose text contains that sentence
+ * or a near-duplicate of it — so a point raised in round 1 and repeated in
+ * round 3 is attributed to round 1, which is the whole question 10.2 asks.
+ *
+ * It decides ATTRIBUTION, never USEFULNESS. Whether a correction improved the
+ * verdict is a benchmark question and the benchmark has not run; a mechanism
+ * here that claimed to score usefulness would be inventing the number the
+ * forbidden-claims list exists to prevent. {@link attributeCorrections} answers
+ * "where did this first appear", and the word "useful" in the step it serves is
+ * a filter a human applies to the output, not one this code applies for them.
+ *
+ * WHAT ZERO MARGINAL VALUE IS.
+ *
+ * A call has zero marginal value when its text near-duplicates something the
+ * run had ALREADY received when the call was made. Not "duplicates the member's
+ * own prior round" — a member restating a peer's answer verbatim adds exactly
+ * as little, and the per-member reading would score it as novel. So the
+ * comparison set is every successful call that preceded it in run order.
+ *
+ * The first successful call is never zero-marginal: nothing preceded it. That
+ * makes the denominator at least 1 whenever the run produced any usable call,
+ * which is why the rate is a number rather than a `null` on every real run —
+ * and a run that produced NO usable call gets `null` with a stated reason,
+ * because zero calls is not a rate of zero.
+ *
+ * HONEST SCOPE. This measures textual novelty against an 0.8 Jaccard bar. It
+ * does not measure whether a call changed the verdict, and no consumer may read
+ * it as decision-quality evidence. The threshold is the shipped
+ * `NOVELTY_DUP_THRESHOLD`, inherited rather than tuned here; nothing has been
+ * benchmarked against it.
+ */
+import type { CouncilResponse } from './clients.js';
+import { is_near_duplicate, NOVELTY_DUP_THRESHOLD } from './debate_gates.js';
+
+/**
+ * Objection markers. Deliberately the same vocabulary the shipped dissent
+ * counter uses, kept as its own constant because that one counts members and
+ * this one classifies sentences.
+ */
+export const CORRECTION_MARKERS =
+    /\b(disagree|disagrees|object|objection|reject|rejects|however|but|flaw|flawed|wrong|incorrect|counter|counter-position|dissent|contradict|contradicts|refute|refutes|mistaken|overstates|understates)\b/i;
+
+/** One call the run made, in the order the run made it. */
+export interface DeliberationCall {
+    /** Stage the call belongs to — a round label, a phase name, whatever the caller uses. */
+    readonly stage: string;
+    /** `provider/model`, or any stable member identity. */
+    readonly member: string;
+    /** The reply text. Empty or error replies are not scored. */
+    readonly text: string;
+    /** True when the transport reported a failure; such a call is not scored. */
+    readonly failed?: boolean;
+}
+
+/** Where one correction first entered the deliberation. */
+export interface CorrectionAttribution {
+    /** The correction sentence, trimmed and whitespace-collapsed. */
+    readonly correction: string;
+    /** Stage label of the earliest call carrying it. */
+    readonly firstStage: string;
+    /** Zero-based index of that call in run order. */
+    readonly firstCallIndex: number;
+    /** Member whose call first carried it. */
+    readonly firstMember: string;
+    /** How many later calls restated it. 0 means it was said once. */
+    readonly restatements: number;
+}
+
+/**
+ * One deliberation stage and what it produced — the record shape
+ * `CouncilRouteRecord` carries, filled from a real run rather than by a test.
+ */
+export interface StageProduction {
+    readonly stage: string;
+    readonly produced: number;
+    readonly calls: number;
+}
+
+export interface ZeroMarginalValueReading {
+    /**
+     * Zero-marginal calls over scored calls, or `null` when the run produced no
+     * scorable call at all. `null` is "not measurable here", never zero.
+     */
+    readonly rate: number | null;
+    /** Why the rate is `null`. Empty string when it is not. */
+    readonly unavailableReason: string;
+    /** Every call the caller passed, failed and empty ones included. */
+    readonly callsTotal: number;
+    /** Calls that carried usable text — the denominator. */
+    readonly callsScored: number;
+    /** Calls that near-duplicated something already received — the numerator. */
+    readonly callsZeroMarginal: number;
+    /** The Jaccard bar used, published so the number can be re-derived. */
+    readonly threshold: number;
+}
+
+/** Decimals the published rate is rounded to, so a JSON round-trip is exact. */
+export const RATE_PRECISION = 6;
+
+function _round(value: number): number {
+    const f = 10 ** RATE_PRECISION;
+    return Math.round(value * f) / f;
+}
+
+function _usable(c: DeliberationCall): boolean {
+    return c.failed !== true && c.text.trim().length > 0;
+}
+
+/** Split a reply into sentences. Crude on purpose: no NLP, no dependency. */
+function _sentences(text: string): string[] {
+    return text
+        .split(/(?<=[.!?])\s+|\n+/)
+        .map((s) => s.replace(/\s+/g, ' ').trim())
+        .filter((s) => s.length > 0);
+}
+
+/**
+ * Correction sentences in one reply.
+ *
+ * A minimum length is applied because a bare "But." carries a marker and no
+ * position; the bar is characters rather than a judgement so it stays
+ * predictable.
+ */
+export const MIN_CORRECTION_CHARS = 25;
+
+export function correctionSentences(text: string): string[] {
+    return _sentences(text).filter(
+        (s) => s.length >= MIN_CORRECTION_CHARS && CORRECTION_MARKERS.test(s),
+    );
+}
+
+/**
+ * Attribute every correction to the earliest call that carried it.
+ *
+ * Calls are read in the order given, which must be run order — the attribution
+ * is only meaningful if "earlier in the list" means "earlier in the run".
+ */
+export function attributeCorrections(
+    calls: readonly DeliberationCall[],
+    threshold: number = NOVELTY_DUP_THRESHOLD,
+): CorrectionAttribution[] {
+    const out: CorrectionAttribution[] = [];
+    const restatements: number[] = [];
+
+    calls.forEach((call, idx) => {
+        if (!_usable(call)) return;
+        for (const sentence of correctionSentences(call.text)) {
+            const seen = out.findIndex(
+                (a) =>
+                    a.correction === sentence || is_near_duplicate(a.correction, sentence, threshold),
+            );
+            if (seen !== -1) {
+                restatements[seen] = (restatements[seen] ?? 0) + 1;
+                continue;
+            }
+            restatements.push(0);
+            out.push({
+                correction: sentence,
+                firstStage: call.stage,
+                firstCallIndex: idx,
+                firstMember: call.member,
+                restatements: 0,
+            });
+        }
+    });
+
+    return out.map((a, i) => ({ ...a, restatements: restatements[i] ?? 0 }));
+}
+
+/**
+ * Per-stage production, derived from the attribution so the two can never
+ * disagree: `produced` counts the corrections FIRST attributed to that stage.
+ */
+export function stageProduction(
+    calls: readonly DeliberationCall[],
+    attributions: readonly CorrectionAttribution[],
+): StageProduction[] {
+    const order: string[] = [];
+    const callCount = new Map<string, number>();
+    for (const c of calls) {
+        if (!callCount.has(c.stage)) {
+            order.push(c.stage);
+            callCount.set(c.stage, 0);
+        }
+        callCount.set(c.stage, (callCount.get(c.stage) ?? 0) + 1);
+    }
+    const produced = new Map<string, number>();
+    for (const a of attributions) {
+        produced.set(a.firstStage, (produced.get(a.firstStage) ?? 0) + 1);
+    }
+    return order.map((stage) => ({
+        stage,
+        produced: produced.get(stage) ?? 0,
+        calls: callCount.get(stage) ?? 0,
+    }));
+}
+
+/**
+ * The `zero_marginal_value_call_rate` for one run.
+ *
+ * Every scored call is compared against every scored call that preceded it. The
+ * comparison is O(n squared) in the number of calls, which is fine: a council
+ * run is single digits of calls per round.
+ */
+export function zeroMarginalValueRate(
+    calls: readonly DeliberationCall[],
+    threshold: number = NOVELTY_DUP_THRESHOLD,
+): ZeroMarginalValueReading {
+    const received: string[] = [];
+    let zero = 0;
+
+    for (const call of calls) {
+        if (!_usable(call)) continue;
+        const dup = received.some((prior) => is_near_duplicate(prior, call.text, threshold));
+        if (dup) zero += 1;
+        received.push(call.text);
+    }
+
+    if (received.length === 0) {
+        return {
+            rate: null,
+            unavailableReason:
+                'no scorable call — every call failed or returned empty text, and zero calls is not a rate of zero',
+            callsTotal: calls.length,
+            callsScored: 0,
+            callsZeroMarginal: 0,
+            threshold,
+        };
+    }
+
+    return {
+        rate: _round(zero / received.length),
+        unavailableReason: '',
+        callsTotal: calls.length,
+        callsZeroMarginal: zero,
+        callsScored: received.length,
+        threshold,
+    };
+}
+
+/** Everything this module emits for one run, ready to serialise. */
+export interface DeliberationMetrics {
+    readonly zero_marginal_value_call_rate: number | null;
+    readonly zero_marginal_value_unavailable_reason: string;
+    readonly calls_total: number;
+    readonly calls_scored: number;
+    readonly calls_zero_marginal: number;
+    readonly novelty_threshold: number;
+    readonly stage_outputs: readonly StageProduction[];
+    readonly correction_attributions: readonly CorrectionAttribution[];
+}
+
+/** Compute both measurements in one pass over the run's calls. */
+export function measureDeliberation(
+    calls: readonly DeliberationCall[],
+    threshold: number = NOVELTY_DUP_THRESHOLD,
+): DeliberationMetrics {
+    const attributions = attributeCorrections(calls, threshold);
+    const zmv = zeroMarginalValueRate(calls, threshold);
+    return {
+        zero_marginal_value_call_rate: zmv.rate,
+        zero_marginal_value_unavailable_reason: zmv.unavailableReason,
+        calls_total: zmv.callsTotal,
+        calls_scored: zmv.callsScored,
+        calls_zero_marginal: zmv.callsZeroMarginal,
+        novelty_threshold: zmv.threshold,
+        stage_outputs: stageProduction(calls, attributions),
+        correction_attributions: attributions,
+    };
+}
+
+/**
+ * The parts of one council run that made provider calls, in the order the run
+ * made them.
+ *
+ * Assembled here rather than at the call site because "which calls did this run
+ * make, and at which stage" is this module's own subject, and the CLI had the
+ * list only as a flat array with the stage boundaries implicit in the order.
+ * Both readings come out of one walk, so the billing total and the attribution
+ * can never be computed over different sets.
+ */
+export interface RunCallParts {
+    /** The deliberation responses `consult()` returned. */
+    readonly deliberation: readonly CouncilResponse[];
+    readonly peerReview?: readonly CouncilResponse[] | null;
+    readonly consensusExtraction?: readonly CouncilResponse[] | null;
+    readonly consensusScoring?: readonly CouncilResponse[] | null;
+    readonly chairman?: CouncilResponse | null;
+    readonly stanceRepairs?: readonly CouncilResponse[] | null;
+}
+
+/** The six stage labels, in run order. */
+export const RUN_STAGES = Object.freeze([
+    'deliberation',
+    'peer-review',
+    'consensus-extraction',
+    'consensus-scoring',
+    'chairman',
+    'stance-repair',
+] as const);
+
+export interface RunCalls {
+    /** Stage-labelled calls, for {@link measureDeliberation}. */
+    readonly calls: readonly DeliberationCall[];
+    /** The same calls as raw responses, in the same order, for cost aggregation. */
+    readonly responses: CouncilResponse[];
+}
+
+function _asCall(stage: string, r: CouncilResponse): DeliberationCall {
+    return {
+        stage,
+        member: `${r.provider}/${r.model}`,
+        text: r.text,
+        failed: r.error !== null && r.error !== undefined,
+    };
+}
+
+/** Walk one run's parts into stage-labelled calls plus the flat response list. */
+export function runCallsFrom(parts: RunCallParts): RunCalls {
+    const groups: ReadonlyArray<readonly [string, readonly CouncilResponse[]]> = [
+        ['deliberation', parts.deliberation],
+        ['peer-review', parts.peerReview ?? []],
+        ['consensus-extraction', parts.consensusExtraction ?? []],
+        ['consensus-scoring', parts.consensusScoring ?? []],
+        ['chairman', parts.chairman === null || parts.chairman === undefined ? [] : [parts.chairman]],
+        ['stance-repair', parts.stanceRepairs ?? []],
+    ];
+    const calls: DeliberationCall[] = [];
+    const responses: CouncilResponse[] = [];
+    for (const [stage, group] of groups) {
+        for (const r of group) {
+            calls.push(_asCall(stage, r));
+            responses.push(r);
+        }
+    }
+    return { calls, responses };
+}

package/src/scripts/ai_council/prompts.ts

@@ -25,6 +25,7 @@
 import { wrapUntrustedBlocks } from '../_lib/untrusted_content.js';
 
 import type { ProjectContext } from './project_context.js';
+import { RESOLVING_EVIDENCE_SECTION } from './synthesis_disagreement.js';
 
 // Python: NEUTRALITY_PREAMBLE = """\...""".strip()
 export const NEUTRALITY_PREAMBLE = `You are an independent reviewer. You have NOT seen any prior reasoning,
@@ -302,6 +303,8 @@ read it directly from a response.
 A single sentence: which course the host agent should advise the
 user to take, grounded in the strongest converged point.
 
+${RESOLVING_EVIDENCE_SECTION}
+
 ### Kill criteria
 Observable conditions that would falsify this recommendation without
 re-convening the council. Each entry names a threshold or a specific
@@ -329,6 +332,8 @@ and the host agent confirms are load-bearing. Maximum five.
 APPROVE / REQUEST_CHANGES / REJECT and a single sentence justifying
 the verdict, anchored on the strongest consensus or must-fix line.
 
+${RESOLVING_EVIDENCE_SECTION}
+
 ### Kill criteria
 Observable conditions that would falsify this verdict without re-convening
 the council (a failing check, a missing test, a regression signal). Each
@@ -363,6 +368,8 @@ separate certainty word for that; \`evidence:\` measures how well a
 finding is supported, and being alone in raising it is a different
 property the section already carries.
 
+${RESOLVING_EVIDENCE_SECTION}
+
 ### Kill criteria
 Observable conditions that would falsify the analysis's leading finding
 without re-convening the council. Each entry names a threshold or event.
@@ -381,6 +388,8 @@ export const CREATIVE_SYNTHESIS = `Write a free-form convergence / divergence
 synthesis of the council in prose — no fixed section shape for the body.
 Then close with exactly these two sections:
 
+${RESOLVING_EVIDENCE_SECTION}
+
 ### Kill criteria
 Observable conditions that would falsify the direction you converged on,
 without re-convening the council. Each entry names a threshold or event.