kairos-chain 3.35.0 → 3.39.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 790cf38c2263e065c856211e0dce54a56a4e9599b2b028dbd3335405f78d069f
-  data.tar.gz: 3a568dc9d900c4aefc24572657043c82d94ea62027a349f6c3e20094d778cbb7
+  metadata.gz: 0da61a60c3ecd5e32e85052668638f65522376949dc5577a54ab5db754e7118a
+  data.tar.gz: fe8f12657d7032c9047368372dd6e49bc733e83804a55c83717608980d0017bc
 SHA512:
-  metadata.gz: a3d7d364ecfe3512de1ca75375eefe890002b4c228f7dd3245ea00277abe1552030261a3916ef27ec3c1e968381646ac73a0811672016a8d16d6fab282954c31
-  data.tar.gz: 1bc3370f34c14841d0b57c471ff9e71185521bfe36b583c788732f6513d453c619a07e53070bb6e4d674b6b3b2ae4ec716663f53247d65e9a380a968e942752c
+  metadata.gz: 6e466478fd4e87509d7b4efa1218813fba0f395ea2296852a69b4f2190070ddddf59b2a8961f4b1a34d71ad4d1666716df105ad609f21e6ac9f91e228a58dbf8
+  data.tar.gz: 4cf41c84ff411cb3e18de05683343eb3f84a3281c7f93461ec90c6ea4806919ebf58ae70694e0e629248189411b6b815d764cb3e10f6956d502f5222fc60cc46

data/CHANGELOG.md

@@ -4,6 +4,135 @@ All notable changes to the `kairos-chain` gem will be documented in this file.
 
 This project follows [Semantic Versioning](https://semver.org/).
 
+## [3.39.0] - 2026-07-05
+
+### Added — L1 `multi_llm_review_workflow` v3.5 → v3.6: Step 0.25 Unknowns Pass
+
+Adds a pre-draft unknown-discovery discipline to the multi-LLM review workflow,
+adapted from Thariq Shihipar's "A Field Guide to Fable: Finding Your Unknowns"
+(2026-07-03), techniques ① blindspot pass and ③ one-question-at-a-time interview.
+Bundled L1 knowledge only — no code paths changed.
+
+- **Step 0.25 (pre-draft, qualifying reviews only)**: before drafting a design or
+  knowledge/documentation artifact routed to full multi-LLM review, the orchestrator
+  enumerates its blind-spot questions (without self-answering) and interviews the human
+  one question at a time, then triages every surfaced unknown to Resolved / Declared /
+  Draft-deferred. Moves unknown discovery from the expensive channel (review rounds) to
+  the cheap channel (pre-draft dialogue).
+- **Five invariants INV-U1–U5**: front-load gate (no dispatch before the pass);
+  human gate (no orchestrator self-answering); constitutive recording (unconditional L2
+  record, incl. zero-result); bounded demotion of declared unknowns (provenance bound +
+  inverted default, closing a laundering channel); human-only classification authority.
+- **Unattended (autonomous loop) clause**: fail-closed — every surfaced unknown is
+  judgment-shaped by default and stops the run; only a human-authored mandate may
+  pre-classify categories as non-judgment-shaped, and unattended declarations gain no
+  reviewer-demotion power until human-ratified. Mandate expressiveness, ratification
+  protocol, and the pending-question queue are deferred to the Autonomous Growth Loop
+  guard track.
+- Three-location L1 sync (instance `.kairos/knowledge/`, gem `knowledge/`, gem
+  `templates/knowledge/`); change recorded to blockchain (hash a74a11b7…). One-line
+  cross-reference added to `design_to_implementation_workflow`.
+- Designed via its own 3-round self-referential multi-LLM review (R1 REVISE 2/6 →
+  R2 REVISE 2/6 → R3 4/6 APPROVE; design record
+  `docs/drafts/multi_llm_review_unknowns_pass_v0.3.1_FROZEN.md`).
+
+## [3.38.0] - 2026-07-05
+
+### Added — Synoptis L2 attestation: ACT-5 trigger sources + scan CLI (Slice 3b/3c)
+
+Makes the ACT-5 trigger point distinguishable and invocable from a session-end
+Stop hook, so firing + trigger-record logging can be guaranteed rather than relying
+on the orchestrator remembering to run the tool.
+
+- **Trigger source (3b)**: `l2_attestation_scan` gains a `trigger_source` argument
+  (`manual` / `orchestrator_session_end` / `session_end_hook`), recorded in the trigger
+  record (`AttestationChain#append_trigger(source:)`). ACT-5's "at least one defined
+  trigger point" is now distinguishable in the operational log, and the tool documents
+  its two auto-firing paths (orchestrator-at-session-end for delivery+approval; Stop hook
+  for a mechanical liveness guarantee).
+- **Scan CLI (3c)**: new `kairos-chain attestation scan [--session SID] [--source SRC]
+  [--data-dir DIR]`. It loads the constitutive criterion, proposes a session's
+  judgment-bearing contexts, and appends a trigger record — propose-only, never attests
+  (ACT-1 keeps attestation human-approved through the MCP tool). This is the shell
+  entry point a session-end Stop hook calls. Verified end-to-end.
+
+The two firing mechanisms are complementary: the orchestrator convention delivers
+proposals to a present human for approval; the Stop hook guarantees the trigger fires
+and is logged even when the orchestrator does not. The settings.json Stop-hook wiring is
+a per-project harness step (not shipped in the gem). 17 Slice-3 unit tests green (incl.
+trigger-source); Slices 1 (35) and 2 (25) unchanged.
+
+## [3.37.0] - 2026-07-05
+
+### Added — Synoptis L2 attestation: semantic criterion + snapshot (Slice 3a)
+
+Matures the ACT-2 selection criterion and adds the optional content snapshot
+(§Kinds), without embedding an LLM call inside the tool (selective-survival: the
+in-Ruby LLM scoring is deferred until the frontmatter criterion is observed to be
+insufficient).
+
+- **Semantic layer (ACT-2)**: `l2_attestation_scan` now attaches a bounded content
+  `preview` to each proposal and surfaces a `rubric` (config `semantic_rubric`). The
+  orchestrator applies the rubric to the previews to decide which frontmatter-filtered
+  candidates to propose to the human — the LLM-semantic judgment lives in the
+  orchestrator, not in the tool. The criterion stays inspectable and revisable by
+  editing config (`judgment_types`, `semantic_rubric`, `preview_chars`).
+- **Snapshot (§Kinds optional)**: `l2_attestation_commit(embed_snapshot: true)` embeds
+  the subject's current content in the entry, so audits needing the original wording
+  have it (LED-2a preserves it). The snapshot's SHA256 equals the entry digest, so it is
+  self-verifying. Bounded by `max_snapshot_bytes` (default 256KB); oversize content is
+  refused (`snapshot_too_large`) rather than truncated.
+- `SubjectRef` gains `content_text` / `content_preview`.
+
+Deferred (until observed need): in-Ruby `llm_client` scoring of candidates; session-end
+auto-firing of the trigger (ACT-5 liveness is currently satisfied by explicit/orchestrator
+scan). 12 Slice-3 unit tests + 4 tool integration tests green; Slices 1 (35) and 2 (25)
+unchanged.
+
+## [3.36.0] - 2026-07-05
+
+### Added — Synoptis L2 attestation: supersession + revocation (Slice 2)
+
+Records the rewrite/withdrawal lifecycle of a constitutive attestation by appending,
+never editing (the bank-ledger correction model). Completes §Kinds' two attestation-
+ledger entry kinds and satisfies LED-2b (lineage) and ACT-3 (approval binding).
+
+- **Supersession**: a re-attestation of an already-attested subject is now a
+  supersession — `l2_attestation_commit` auto-derives the current head and commits its
+  entry_id as `target_ref` (ContentAttestationEntry gains `target_ref`). The first
+  attestation about a subject carries none.
+- **Revocation-withdrawal**: new `RevocationWithdrawalEntry` kind (commits subject +
+  target_ref + moment, no digest/content) and a new `l2_attestation_revoke` tool. It
+  appends a withdrawal of the subject's current head; like any ledger entry it requires
+  human approval (ACT-1) and is itself append-only, so "claimed then withdrawn" survives.
+- **ACT-3 binding**: the commit/revoke proposal returns the digest and the target it
+  would act on; the approving call echoes them as `expected_digest` /
+  `expected_target_ref`. If the live content changed (digest_mismatch) or the head moved
+  (target_moved) between proposal and approval, the append is refused, not silent.
+- **Fold**: `AttestationChain#current_head` / `current_state` fold a subject's entries
+  (first → supersessions → withdrawals) into a status (none/attested/withdrawn); a new
+  read-only `l2_attestation_view` tool surfaces it. Fold ordering rule fixed per §11: a
+  revocation clears the head only when it targets the current head.
+
+Synoptis's trust engine (duplicate hard-reject, TTL, revocation store) is untouched —
+the constitutive ledger is a separate chain, so re-attest-as-supersession is native and
+no reconciliation was needed. 25 Slice-2 unit tests + 14 tool integration tests green;
+Slice 1 (35) unchanged.
+
+## [3.35.1] - 2026-07-05
+
+### Fixed — Synoptis L2 attestation: frontmatter parsing dropped all proposals
+
+`l2_attestation_scan` surfaced zero proposals against real L2 contexts because
+`SubjectRef.extract_frontmatter` used `YAML.safe_load` without permitting `Date`:
+a `date:` field (present in every real context's frontmatter) raised
+`Psych::DisallowedClass`, which was rescued to `nil`, so the `type` was never read
+and no context matched the criterion. Caught by live end-to-end verification, not
+by unit tests (whose fixtures lacked a `date:` field). Fix permits `[Date, Time]`
+and adds a regex fallback for the single `type` scalar so the criterion is robust
+against any frontmatter YAML that `safe_load` rejects. Unit fixtures now carry a
+`date:` field to guard the regression.
+
 ## [3.35.0] - 2026-07-05
 
 ### Added — Synoptis: L2 constitutive attestation (Slice 1)

data/bin/kairos-chain

@@ -343,6 +343,86 @@ when 'upgrade'
   end
   exit
 
+when 'attestation'
+  # Constitutive L2 attestation CLI (Slice 3c). Currently one action: `scan`, the
+  # ACT-5 trigger point invokable from a session-end Stop hook so that firing +
+  # trigger-record logging is guaranteed even when the orchestrator does not run the
+  # MCP tool. It proposes only and logs a trigger record; it never attests (ACT-1
+  # keeps attestation human-approved through the MCP tool).
+  ARGV.shift # Remove 'attestation'
+
+  $LOAD_PATH.unshift File.expand_path('../lib', __dir__)
+  require 'kairos_mcp'
+
+  if (idx = ARGV.index('--data-dir'))
+    KairosMcp.data_dir = File.expand_path(ARGV[idx + 1])
+    ARGV.delete_at(idx + 1)
+    ARGV.delete_at(idx)
+  end
+
+  action = ARGV.shift
+  case action
+  when 'scan'
+    require 'json'
+    require 'yaml'
+    require 'fileutils'
+
+    session = (i = ARGV.index('--session')) ? ARGV[i + 1] : nil
+    source  = (i = ARGV.index('--source')) ? ARGV[i + 1] : 'session_end_hook'
+
+    syn_lib = File.join(KairosMcp.skillsets_dir, 'synoptis', 'lib')
+    unless File.directory?(syn_lib)
+      puts JSON.generate(status: 'error', message: 'synoptis skillset not installed')
+      exit 0
+    end
+    $LOAD_PATH.unshift(syn_lib)
+    require 'synoptis/registry/file_registry'
+    require 'synoptis/constitutive/subject_ref'
+    require 'synoptis/constitutive/proposal_criterion'
+    require 'synoptis/constitutive/attestation_chain'
+
+    context_dir = KairosMcp.context_dir
+    session ||= if Dir.exist?(context_dir)
+                  Dir.children(context_dir)
+                     .select { |c| File.directory?(File.join(context_dir, c)) }
+                     .max_by { |c| File.mtime(File.join(context_dir, c)) }
+                end
+    unless session
+      puts JSON.generate(status: 'error', message: 'no session found to scan')
+      exit 0
+    end
+
+    cfg_path = File.join(KairosMcp.skillsets_dir, 'synoptis', 'config', 'synoptis.yml')
+    const_cfg = (File.exist?(cfg_path) ? (YAML.safe_load(File.read(cfg_path)) || {}) : {})['constitutive'] || {}
+
+    data_dir = File.join(KairosMcp.data_dir, 'synoptis_data')
+    FileUtils.mkdir_p(data_dir)
+    registry = Synoptis::Registry::FileRegistry.new(data_dir: data_dir)
+    chain = Synoptis::Constitutive::AttestationChain.new(registry: registry)
+    criterion = Synoptis::Constitutive::ProposalCriterion.new(
+      context_dir: context_dir,
+      judgment_types: const_cfg['judgment_types'] ||
+        Synoptis::Constitutive::ProposalCriterion::DEFAULT_JUDGMENT_TYPES,
+      preview_chars: const_cfg['preview_chars'] ||
+        Synoptis::Constitutive::ProposalCriterion::DEFAULT_PREVIEW_CHARS
+    )
+
+    proposals = criterion.propose(session_id: session)
+    chain.append_trigger(surfaced_count: proposals.length, source: source)
+    puts JSON.generate(
+      status: 'proposed',
+      session_id: session,
+      trigger_source: source,
+      surfaced_count: proposals.length,
+      proposals: proposals
+    )
+    exit 0
+  else
+    warn "Unknown attestation action: #{action.inspect}"
+    warn 'Usage: kairos-chain attestation scan [--session SID] [--source SRC] [--data-dir DIR]'
+    exit 1
+  end
+
 when 'mode'
   ARGV.shift # Remove 'mode' from ARGV
 

data/lib/kairos_mcp/version.rb

@@ -1,4 +1,4 @@
 module KairosMcp
-  VERSION = "3.35.0"
+  VERSION = "3.39.0"
   CHANGELOG_URL = "https://github.com/masaomi/KairosChain_2026/blob/main/CHANGELOG.md"
 end

data/templates/knowledge/design_to_implementation_workflow/design_to_implementation_workflow.md

@@ -65,6 +65,11 @@ different bugs.
 
 ### Design Phase
 
+#### Pre-draft: Unknowns Pass
+- For artifacts routed to full multi-LLM review, run the Unknowns Pass
+  (blindspot enumeration + human interview) **before** drafting v0.1 —
+  see `multi_llm_review_workflow` Step 0.25 (v3.6+).
+
 #### Solo Design (v0.1)
 - Single LLM (Opus-class) produces initial design
 - Include: architecture, component design, schema, error handling, phase boundaries

data/templates/knowledge/multi_llm_review_workflow/multi_llm_review_workflow.md

@@ -1,7 +1,7 @@
 ---
 name: multi_llm_review_workflow
 description: "Multi-LLM review methodology and execution — workflow pattern, CLI tooling, consensus analysis, Persona Assembly. Applicable to design, implementation, documentation, or any artifact."
-version: "3.5"
+version: "3.6"
 tags:
   - workflow
   - review
@@ -43,6 +43,154 @@ Codex (c)-class value-divergent REJECTs as blocking, which causes review loops t
 fail to converge. The cross-reference exists in `related:` frontmatter; this step
 makes it an explicit pre-condition rather than an implicit hint.
 
+## Step 0.25 — Unknowns Pass (pre-draft, qualifying reviews only)
+
+> **Numbering vs timing**: Step 0 and Step 0.5 execute at review time,
+> immediately before dispatch. Step 0.25 executes **pre-draft** — earlier in
+> wall-clock time than both. The numeric order is document order, not
+> execution order.
+
+**Applies to** artifacts that this workflow's decision heuristic routes to
+full multi-LLM review, in the design-phase and knowledge/documentation
+review types (design review, knowledge/documentation-update review, document
+review). Throughout this step, "qualifying review" means exactly this set.
+Artifacts below that threshold (single-LLM review, self-review, skip) are
+exempt — the pass inherits the existing tier heuristic rather than
+introducing a second gate. Implementation-phase reviews are out of scope.
+
+The problem this step solves: the workflow otherwise begins at "artifact
+exists," so unknowns the author never considered enter drafts undetected and
+are excavated by reviewers round by round, inflating round counts. The pass
+moves unknown discovery from the expensive channel (review rounds) to the
+cheap channel (pre-draft dialogue), and makes the residue explicit.
+(Source: Thariq Shihipar, "A Field Guide to Fable: Finding Your Unknowns,"
+2026-07-03 — techniques ① blindspot pass and ③ interview. Design record:
+`docs/drafts/multi_llm_review_unknowns_pass_v0.3.1_FROZEN.md`.)
+
+### Structure of the pass
+
+Step 0.25 runs after the decision to produce a qualifying artifact and
+before its first draft. Two moves, one triage:
+
+1. **Blindspot enumeration.** The orchestrator, holding full project
+   context, enumerates the questions most likely to change the design if
+   answered differently — *without answering them itself*. This is a bounded
+   search discipline, not a completeness guarantee: the pass is judged by
+   whether it reliably surfaces the highest-impact questions available to
+   the orchestrator's current context (nothing-missed is unachievable per
+   Prop 6).
+2. **Interview.** The orchestrator puts the enumerated questions to the
+   human, one question at a time, ordered by decision impact. The interview
+   ends when both parties judge that remaining questions will only be
+   answerable once a draft exists. Ending the interview does not discharge
+   the triage below: every enumerated unknown — including those the
+   interview never reached — still exits through it.
+
+**Triage.** Every surfaced unknown exits the pass in exactly one of two
+**terminal** states, possibly via one **transient** state:
+
+- **Resolved** (terminal) — answered by the human; the answer feeds the
+  Design Direction Block (Step 0.5).
+- **Declared** (terminal) — recorded in the artifact as an *Open Unknown*
+  and registered in the artifact's backlog section. A human's explicit
+  decision *not* to answer a question is itself a human judgment and routes
+  the unknown here — a legitimate attended outcome.
+- **Draft-deferred** (transient, non-terminal) — marked for mandatory
+  re-triage after drafting. Re-triage collapses each draft-deferred unknown
+  into Resolved or Declared **before review dispatch** (a precondition of
+  dispatch under INV-U1). INV-U2 applies at re-triage exactly as at the
+  interview: collapsing to Resolved requires the human's answer, so
+  unattended re-triage can only collapse to Declared.
+
+### Invariants
+
+**INV-U1 (front-load gate).** Round 1 of a qualifying review is not
+dispatched for an artifact that has not passed through the Unknowns Pass.
+At dispatch time, every unknown the pass surfaced is in a terminal state:
+resolved by the human, or declared in the artifact. A draft-deferred unknown
+still in its transient state blocks dispatch until re-triaged.
+
+**INV-U2 (human gate).** The answerer in the interview is the human. The
+orchestrator posing a question and answering it itself does not constitute
+resolution. (Same conceptual line as ACT-1 in L2 attestation — analogical,
+not a shared implementation: judgment-shaped decisions belong to the human.)
+
+**INV-U3 (constitutive recording).** The products of the pass — enumerated
+questions, human answers, declared Open Unknowns — are recorded to L2. A
+discovered unknown is an asset, not a consumable. The record is written
+unconditionally: a pass that surfaces no unknowns writes an explicit
+zero-result record, which is what makes a skipped pass distinguishable from
+a pass that surfaced nothing. The record is instance-local; outbound sharing
+is governed by the instance's existing outbound-sharing discipline — this
+invariant authorizes no new disclosure surface.
+
+**INV-U4 (declared unknowns are non-blocking — bounded).** A reviewer
+finding that merely restates a declared Open Unknown is classified (c)
+advisory by default, subject to two bounds:
+
+- *Provenance bound*: the demotion applies only to unknowns whose specific
+  declaration a human has seen — declared through an attended pass, or
+  ratified by a human at a subsequent attended session. Declarations made by
+  an orchestrator alone (including unattended declarations under a mandate's
+  category-level pre-classification) carry no demotion power until so
+  ratified.
+- *Inverted default*: when the orchestrator is uncertain whether a finding
+  merely restates a declared unknown or shows that the declared deferral is
+  itself unsafe, the finding is treated as blocking. This deliberately
+  inverts the usual "unsure between (b) and (c) → (c)" rule, because here
+  the doubt concerns whether a gate is being laundered, and gates fail
+  closed.
+
+Findings about the *integrity* of the design — internal contradiction,
+unrealizable invariant, an Open Unknown whose declared deferral is itself
+unsafe — remain (a)/(b) and block as before.
+
+**INV-U5 (classification authority).** The judgment-shaped /
+non-judgment-shaped classification of an unknown is a human prerogative.
+Attended, the human exercises it through the interview itself (answering,
+declining, or judging a question draft-answerable). Unattended, every
+surfaced unknown is judgment-shaped by default; only a human-authored
+mandate may pre-classify named categories as non-judgment-shaped for a given
+run. An orchestrator's self-classification has no force. (Fail-closed:
+unclassified ⇒ judgment-shaped ⇒ stop.)
+
+### Unattended execution (autonomous loops)
+
+In an unattended context, the "resolved" exit is unavailable. INV-U2 is
+preserved — the system does not self-answer — and INV-U5 governs
+classification:
+
+- **Judgment-shaped** (the unattended default for ALL unknowns): fail-closed
+  stop; the question is recorded and queued for the next attended session.
+- **Non-judgment-shaped** (only via human-authored mandate
+  pre-classification): declared as Open Unknown; the run proceeds, but per
+  INV-U4's provenance bound the declaration carries no demotion power until
+  human-ratified — reviewer restatements remain blocking.
+
+Consequence: an unattended run without a mandate cannot proceed past any
+surfaced unknown. This is intended — it makes "unattended design review
+without human pre-delegation" structurally inert rather than quietly
+self-certifying, and liberal declaring yields no convergence advantage.
+
+Stop semantics, as an invariant: repeated unattended encounters with the
+same pending question produce no new side effects and no forward motion —
+re-stopping is idempotent; forward motion requires a human answer. The
+mandate's expressive power, the ratification protocol, and the
+pending-question queue mechanism are owned by the Autonomous Growth Loop
+guard track (see the frozen design's §11 backlog).
+
+### Acceptance observation (selective survival)
+
+This step is a discipline under observation, not settled infrastructure.
+From adoption onward, during synthesis the orchestrator tags each blocking
+finding — and each finding demoted under INV-U4 — as kind `open-question`
+(unresolved design decision) or kind `defect` (flaw in a made decision),
+recorded in the round's L2 review record. Survival judgment (human's, on
+recorded counts): round-1 `open-question` counts should trend toward zero
+across the first 2–3 qualifying loops; no INV-U4-demoted finding re-tagged
+`defect` within its loop + next revision cycle; interviews staying within
+~5 questions.
+
 ## Step 0.5 — Design Direction Block (design / docs reviews only)
 
 For **design-phase** and **knowledge/documentation-update** reviews, prepend a
@@ -93,6 +241,10 @@ mistaken for genuine defects.
   (e.g., "invariant declaration > mechanism enumeration, per project
    design-by-invariant principle")
 
+**Declared Open Unknowns** (carried in from Step 0.25, if any):
+- <unknown>: declared open; findings that merely restate it are (c) advisory
+  per INV-U4 (subject to its provenance bound and inverted default)
+
 **Where to register additions/objections**:
 - New mechanisms or scope expansions → §11 backlog of the artifact, not body
 - Style/readability concerns not entailed by project principles → (c)
@@ -250,13 +402,21 @@ The user always has the final say.
 ## Workflow Pattern
 
 ```
+[0.25] Unknowns Pass (pre-draft; qualifying reviews only — see Step 0.25)
+         |
+         ├── blindspot enumeration + human interview
+         └── L2 context:    pass record (unconditional, incl. zero-result)
+         |
 [1] Primary LLM creates artifact → outputs artifact + review prompt
          |
          ├── artifact:      log/{name}_{llm}_{date}.md
+         ├── re-triage:     draft-deferred unknowns → Resolved or Declared
          ├── review prompt: log/{name}_review_prompt.md
          └── L2 context:    saved via context_save
          |
 [2] Orchestrator sends prompt → N reviewer LLMs execute in parallel
+    (for qualifying reviews, conditioned on INV-U1: pass record exists
+     and every surfaced unknown is terminal)
          |
          ├── Reviewer 1:   independent review
          ├── Reviewer 2:   independent review
@@ -269,6 +429,10 @@ The user always has the final say.
          └── L2 save:  consensus + revised artifact
          |
 [4] Classify findings as (a)/(b)/(c) per `multi_llm_reviewer_evaluation`
+    Apply INV-U4: findings merely restating a declared Open Unknown → (c)
+    advisory (provenance bound + inverted default apply — see Step 0.25)
+    Tag each blocking finding and each INV-U4-demoted finding as kind
+    `open-question` or `defect` in the round's L2 record
     If no (a)/(b) blocking findings → proceed to next phase
     If any (a)/(b) finding          → repeat from [2] with revised artifact
     (c) findings are recorded as advisory; non-blocking
@@ -375,9 +539,15 @@ When the orchestrator integrates N reviews:
 ## L2 Save Points
 
 Save to L2 context at these moments:
+- **After the Unknowns Pass** (Step 0.25; unconditional, including
+  zero-result passes, per INV-U3): enumerated questions, human answers,
+  declared Open Unknowns
 - After design/implementation complete (before review)
 - After synthesis of reviews (revised version)
 - After final convergence (implementation-ready / merge-ready)
+- **Per-round finding tagging** (Step 0.25 acceptance observation): each
+  blocking finding and each INV-U4-demoted finding tagged `open-question`
+  or `defect` in the round's review record
 - **After each review round**: capture per-reviewer observations — verdict,
   (a)/(b)/(c) classification breakdown, briefing-reaction shift (did the
   reviewer change verdict after Step 0.5 design direction?), anomalies
@@ -818,6 +988,15 @@ Compression ratio: parallel agent raw → Assembly ≈ 2:1
 - Self-referential review: v3.2 (4-reviewer update, 2026-04-19) reviewed with new 4-reviewer default (Opus 4.6 + 4.7 + Codex + Composer-2). 4/4 APPROVE WITH CHANGES R1. Findings integrated → v3.3
 - Roster update (v3.5, 2026-06-10): Fable 5 replaces Opus 4.7 as orchestrator/team slot; Opus 4.8 added as second subprocess CLI reviewer alongside Opus 4.6. 4.6 retained for its documented complementary bias (ambiguity-preserving, self-reference-friendly); 4.7 retired as its register is covered by 4.8 and Fable 5. 4.8/Fable 5 bias profiles uncalibrated — record (a)/(b)/(c) breakdowns per round until profiles accumulate in `multi_llm_reviewer_evaluation`
 - Self-referential review of v3.5 (2 rounds, 2026-06-10/11, first run of the 6-reviewer roster): R1 REVISE (1 APPROVE / 4 REJECT — stale pre-v3.5 passages) → fixes → R2 3/6 APPROVE (4.6, 4.8, codex 5.4) with Cursor contributing a code-grounded correction (subprocess strategy keeps the full roster). 4.6/4.8 verdicts split along the predicted lenient/strict axis in R1 and converged to APPROVE in R2
+- Step 0.25 Unknowns Pass added (v3.6, 2026-07-05): designed via its own
+  3-round self-referential review (R1 REVISE 2/6 → R2 REVISE 2/6 → R3 4/6
+  APPROVE; v0.3.1 FROZEN). The loop demonstrated the step's own thesis:
+  R1's two biggest blockers (unattended classification authority, INV-U4
+  demotion bounds) were exactly judgment-shaped unknowns a pre-draft
+  interview would have caught. Also observed: fix-verification requires
+  epistemic diversity — the personas that authored R1 findings all approved
+  their own fixes in R2, while subprocess reviewers caught the seams.
+  Design record: `docs/drafts/multi_llm_review_unknowns_pass_v0.3.1_FROZEN.md`
 
 **Key insight**: Design reviews and implementation reviews find
-**categorically different bugs**. Both phases are necessary.
+**categorically different bugs**. Both phases are necessary.

data/templates/skillsets/synoptis/config/synoptis.yml

@@ -56,6 +56,16 @@ constitutive:
     - handoff
     - decision
     - debrief
+  # ACT-2 semantic layer (Slice 3): the orchestrator applies this rubric to each
+  # proposal's preview before proposing to the human. Revisable — this is the criterion.
+  semantic_rubric: >
+    Propose a context for attestation when it records a judgment, decision, or outcome
+    whose "as recorded at the time" matters for a later audit — e.g. a handoff of state,
+    a design decision with rationale, or a debrief of what happened. Do NOT propose pure
+    scratch notes, transient status, or content with no decisional weight. When in doubt,
+    prefer proposing (the human gate, ACT-1, is the safeguard).
+  preview_chars: 300          # bounded excerpt surfaced per proposal
+  max_snapshot_bytes: 262144  # 256KB cap on an optional embedded snapshot
 
 challenge:
   response_timeout: 3600      # 1 hour

data/templates/skillsets/synoptis/lib/synoptis/constitutive/attestation_chain.rb

@@ -23,21 +23,71 @@ module Synoptis
         @registry = registry
       end
 
-      # ACT-1: append an approved content-attestation entry to the ledger.
+      # ACT-1: append an approved content-attestation entry to the ledger. A first
+      # attestation carries no target_ref; a supersession carries the entry_id of the
+      # entry it supersedes (LED-2b).
       def append_content_attestation(entry)
         @registry.append(LEDGER, entry.to_h)
       end
 
+      # ACT-1: append an approved revocation-withdrawal entry to the ledger. It withdraws
+      # the referenced target entry (§Kinds); it is itself append-only (LED-2), so the
+      # withdrawal is recorded, not an erasure.
+      def append_revocation_withdrawal(entry)
+        @registry.append(LEDGER, entry.to_h)
+      end
+
       def entries
         @registry.read(LEDGER)
       end
 
+      def entries_for(subject_id)
+        entries.select { |e| e[:subject_id] == subject_id }
+      end
+
+      # The current "head" of a subject: the fold (LED-2b, §11) over its entries'
+      # target references. Walking in append order, a content-attestation (first or
+      # supersession) becomes the head; a revocation-withdrawal that targets the current
+      # head clears it. Returns the head entry hash, or nil if the subject has never been
+      # attested or its latest attestation has been withdrawn.
+      #
+      # Ordering rule (fixed here per §11): a revocation-withdrawal only clears the head
+      # when it targets the current head; a withdrawal of an already-superseded (non-head)
+      # entry is recorded but does not change the head.
+      def current_head(subject_id)
+        head = nil
+        entries_for(subject_id).each do |e|
+          case e[:kind]
+          when 'content_attestation'
+            head = e
+          when 'revocation_withdrawal'
+            head = nil if head && e[:target_ref] == head[:entry_id]
+          end
+        end
+        head
+      end
+
+      # A human-readable fold of a subject's trajectory: current status + full history.
+      def current_state(subject_id)
+        history = entries_for(subject_id)
+        head = current_head(subject_id)
+        status =
+          if history.empty? then 'none'
+          elsif head.nil? then 'withdrawn'
+          else 'attested'
+          end
+        { subject_id: subject_id, status: status, head: head, history: history }
+      end
+
       # ACT-5: telemetry that the criterion fired and surfaced N proposals. Subject-free
       # and content-free, so it neither indexes L2 (LED-4) nor records a per-context
-      # verdict (ACT-4).
-      def append_trigger(surfaced_count:, moment: nil)
+      # verdict (ACT-4). `source` names which trigger point fired (manual /
+      # orchestrator_session_end / session_end_hook), so the "at least one defined trigger
+      # point" of ACT-5 is distinguishable in the operational log.
+      def append_trigger(surfaced_count:, source: 'manual', moment: nil)
         @registry.append(OPLOG, {
           record: 'trigger',
+          source: source,
           surfaced_count: surfaced_count,
           moment: moment || Time.now.utc.iso8601
         })

data/templates/skillsets/synoptis/lib/synoptis/constitutive/content_attestation_entry.rb

@@ -15,20 +15,31 @@ module Synoptis
     # (ACT-1), not crypto-gated, and an attestation entry does not expire (design §11).
     # This is posture parity with L0/L1 (LED-6), not a regression against Synoptis's
     # signed ProofEnvelope — it is a different kind for a different purpose.
+    #
+    # A `target_ref` (Slice 2, LED-2b) marks this entry a SUPERSESSION: it commits the
+    # entry_id of the prior entry it supersedes. The first content-attestation about a
+    # subject carries none; a re-attestation of an already-attested subject is a
+    # supersession (§Kinds).
     class ContentAttestationEntry
       KIND = 'content_attestation'
       DEFAULT_DIGEST_ALG = 'sha256'
 
-      attr_reader :entry_id, :subject_id, :digest, :digest_alg, :moment, :snapshot
+      attr_reader :entry_id, :subject_id, :digest, :digest_alg, :moment, :snapshot, :target_ref
 
       def initialize(subject_id:, digest:, moment:, digest_alg: DEFAULT_DIGEST_ALG,
-                     snapshot: nil, entry_id: nil)
+                     snapshot: nil, entry_id: nil, target_ref: nil)
         @entry_id = entry_id || SecureRandom.uuid
         @subject_id = subject_id
         @digest = digest
         @digest_alg = digest_alg
         @moment = moment
         @snapshot = snapshot
+        @target_ref = target_ref
+      end
+
+      # A supersession points at the entry it supersedes (LED-2b).
+      def supersession?
+        !@target_ref.nil?
       end
 
       def to_h
@@ -39,7 +50,8 @@ module Synoptis
           digest: @digest,
           digest_alg: @digest_alg,
           moment: @moment,
-          snapshot: @snapshot
+          snapshot: @snapshot,
+          target_ref: @target_ref
         }
       end
 
@@ -62,7 +74,8 @@ module Synoptis
           moment: hash[:moment],
           digest_alg: hash[:digest_alg] || DEFAULT_DIGEST_ALG,
           snapshot: hash[:snapshot],
-          entry_id: hash[:entry_id]
+          entry_id: hash[:entry_id],
+          target_ref: hash[:target_ref]
         )
       end
     end