feat(opencode): session-lineage mutation ledger

packages/app/src/pages/session/v2/adversarial-ui-e2e.test.ts

@@ -0,0 +1,135 @@
+import { describe, expect, test } from "bun:test"
+import { ProvenanceMatrix } from "@opencode-ai/schema/provenance-matrix"
+import {
+  applyLedgerKeyDown,
+  buildLedgerView,
+  describeLedgerStatus,
+  LEDGER_CAPABILITY_LABELS,
+  ledgerCapabilityLabel,
+  type LedgerStatusInput,
+  type LedgerStatusKind,
+} from "./lineage-ledger-view"
+
+/**
+ * The ui harness of the adversarial full-provenance matrix (amicode#1084).
+ *
+ * This cross-harness E2E fixture RUNS the ui-owned matrix rows against the REAL
+ * unified lineage-ledger view-model (#1082) — the same pure reducer + status
+ * descriptors the Files Changed surface renders — and records each row that
+ * produced its declared observable result as green. It proves the unified surface
+ * is operable by keyboard and legible in BOTH supported themes (its distinctions
+ * are text + icon, never color), then feeds the green set to the shared gate
+ * (`ProvenanceMatrix.gate`) exactly as the engine harness does.
+ */
+
+const green = new Set<string>()
+const ui = ProvenanceMatrix.subset("ui")
+
+// ── AC7a: keyboard operation ─────────────────────────────────────────────────
+
+function keyEvent(key: string) {
+  let prevented = false
+  return { event: { key, preventDefault: () => (prevented = true) }, prevented: () => prevented }
+}
+
+function runKeyboard(): void {
+  // Enter and Space on a focused row toggle it and prevent default (no page scroll).
+  for (const key of ["Enter", " "]) {
+    const e = keyEvent(key)
+    expect(applyLedgerKeyDown(e.event, { focusKind: "row", id: "res-1", expanded: false })).toEqual({
+      type: "toggle",
+      id: "res-1",
+    })
+    expect(e.prevented()).toBe(true)
+  }
+  // Escape inside expanded content collapses and returns focus to the row.
+  expect(applyLedgerKeyDown(keyEvent("Escape").event, { focusKind: "content", id: "res-1", expanded: true })).toEqual({
+    type: "collapse",
+    id: "res-1",
+    refocus: "res-1",
+  })
+  // Escape on an expanded row collapses it.
+  expect(applyLedgerKeyDown(keyEvent("Escape").event, { focusKind: "row", id: "res-1", expanded: true })).toEqual({
+    type: "collapse",
+    id: "res-1",
+    refocus: "res-1",
+  })
+  // Unrelated keys and collapsed-row escape are no-ops — the surface never traps the keyboard.
+  expect(applyLedgerKeyDown(keyEvent("a").event, { focusKind: "row", id: "res-1", expanded: false })).toEqual({
+    type: "none",
+  })
+  expect(applyLedgerKeyDown(keyEvent("Escape").event, { focusKind: "row", id: "res-1", expanded: false })).toEqual({
+    type: "none",
+  })
+}
+
+// ── AC7b: legibility across both supported themes (text + icon, never color) ──
+
+const STATUS_CASES: Array<{ input: LedgerStatusInput; kind: LedgerStatusKind }> = [
+  { input: { netState: "added", outcome: "succeeded" }, kind: "added" },
+  { input: { netState: "modified", outcome: "succeeded" }, kind: "modified" },
+  { input: { netState: "deleted", outcome: "succeeded" }, kind: "deleted" },
+  { input: { netState: "reverted", outcome: "succeeded" }, kind: "reverted" },
+  { input: { netState: "conflicted", outcome: "succeeded" }, kind: "conflicted" },
+  { input: { netState: "unavailable", outcome: "succeeded", evidenceState: "unavailable" }, kind: "unavailable" },
+  { input: { outcome: "opaque", netState: "opaque" }, kind: "opaque" },
+  { input: { outcome: "partial", netState: "added" }, kind: "partial" },
+]
+
+function runThemes(): void {
+  const descriptors = STATUS_CASES.map((c) => describeLedgerStatus(c.input))
+  // Each named state resolves to its kind.
+  for (const [index, c] of STATUS_CASES.entries()) expect(descriptors[index].kind).toBe(c.kind)
+  // Distinctions are TEXT + ICON — unique per state — so the surface is legible without relying on color.
+  expect(new Set(descriptors.map((d) => d.label)).size).toBe(STATUS_CASES.length)
+  expect(new Set(descriptors.map((d) => d.icon)).size).toBe(STATUS_CASES.length)
+  for (const d of descriptors) {
+    expect(d.label.length).toBeGreaterThan(0)
+    expect(d.icon.length).toBeGreaterThan(0)
+    // Tone is a semantic keyword, never a raw color literal — so no theme owns the meaning.
+    expect(["success", "danger", "warning", "neutral"]).toContain(d.tone)
+    expect(d.tone).not.toMatch(/#|rgb|hsl/i)
+  }
+  // Theme-independent by construction: the descriptor carries no theme branch or inline color.
+  expect(describeLedgerStatus({ netState: "deleted", outcome: "succeeded" })).toEqual(
+    describeLedgerStatus({ netState: "deleted", outcome: "succeeded" }),
+  )
+  // Screen-reader legibility (theme-agnostic): the accessible name carries execution + assessment + evidence.
+  const accessible = describeLedgerStatus({ outcome: "succeeded", netState: "added", evidenceState: "available" }).accessibleName.toLowerCase()
+  for (const token of ["succeeded", "added", "available"]) expect(accessible).toContain(token)
+  // The capability label is fixed explanatory text selected only by capability — surfaced on the built view.
+  for (const mode of ["full", "partial", "legacy"] as const)
+    expect(ledgerCapabilityLabel(mode)).toEqual(LEDGER_CAPABILITY_LABELS[mode])
+  expect(buildLedgerView({ capability: { mode: "legacy" }, records: [] }).capability).toEqual(
+    LEDGER_CAPABILITY_LABELS.legacy,
+  )
+}
+
+// ── Register the ui per-row tests ────────────────────────────────────────────
+
+describe("adversarial matrix — ui harness (unified Files Changed surface)", () => {
+  for (const row of ui.cases) {
+    test(row.id, () => {
+      if (row.id === "a11y:keyboard") runKeyboard()
+      else if (row.id === "a11y:themes") runThemes()
+      else throw new Error(`no ui executor for row ${row.id}`)
+      green.add(row.id)
+    })
+  }
+})
+
+describe("adversarial matrix — the ui-subset release gate (AC8)", () => {
+  test("every required ui case ran green — all_required_passed, enablement STILL off", () => {
+    const result = ProvenanceMatrix.gate(ui, green)
+    expect(result.missingRequired).toEqual([])
+    expect(result.all_required_passed).toBe(true)
+    expect(result.defaultEnablement).toBe("off")
+  })
+
+  test("dropping any one required ui case blocks the gate", () => {
+    const dropped = ProvenanceMatrix.requiredCaseIDs(ui)[0]
+    const minusOne = new Set(green)
+    minusOne.delete(dropped)
+    expect(ProvenanceMatrix.gate(ui, minusOne).all_required_passed).toBe(false)
+  })
+})

packages/app/src/pages/session/v2/lineage-ledger-panel.css

@@ -0,0 +1,125 @@
+/* Unified lineage-ledger panel (amicode#1082). Geometry + color come only from
+ * design-system tokens, so both themes are equal citizens and the status color
+ * is redundant to the icon + text label (color is never the only signal). */
+
+[data-component="lineage-ledger"] {
+  display: flex;
+  flex-direction: column;
+  gap: var(--space-2, 8px);
+}
+
+[data-component="lineage-ledger"] [data-slot="lineage-ledger-capability"] {
+  display: flex;
+  flex-direction: column;
+  gap: var(--space-1, 4px);
+  padding: var(--space-3, 12px);
+  border: 1px solid var(--v2-border-border-base);
+  border-radius: var(--radius-lg, 12px);
+  background: var(--v2-background-bg-layer-01);
+}
+
+[data-component="lineage-ledger"] [data-slot="lineage-ledger-capability"][data-mode="legacy"],
+[data-component="lineage-ledger"] [data-slot="lineage-ledger-capability"][data-mode="partial"] {
+  border-color: var(--v2-border-border-warning);
+}
+
+[data-component="lineage-ledger"] [data-slot="lineage-ledger-filter"] {
+  padding: var(--space-1, 4px) var(--space-2, 8px);
+  border: 1px solid var(--v2-border-border-base);
+  border-radius: var(--radius-md, 8px);
+  background: var(--v2-background-bg-layer-02);
+  color: var(--v2-text-text-base);
+}
+
+[data-component="lineage-ledger"] [data-slot="lineage-ledger-filter"]:focus-visible {
+  outline: 2px solid var(--v2-border-border-focus);
+  outline-offset: 1px;
+}
+
+[data-component="lineage-ledger"] [data-slot="lineage-ledger-resources"] {
+  display: flex;
+  flex-direction: column;
+  gap: var(--space-1, 4px);
+}
+
+[data-component="lineage-ledger"] [data-slot="lineage-ledger-resource-row"] {
+  display: flex;
+  align-items: center;
+  gap: var(--space-2, 8px);
+  width: 100%;
+  padding: var(--space-1, 4px) var(--space-2, 8px);
+  border-radius: var(--radius-md, 8px);
+  background: transparent;
+  text-align: left;
+  cursor: pointer;
+}
+
+[data-component="lineage-ledger"] [data-slot="lineage-ledger-resource-row"]:hover {
+  background: var(--v2-overlay-simple-overlay-hover);
+}
+
+[data-component="lineage-ledger"] [data-slot="lineage-ledger-resource-row"]:focus-visible {
+  outline: 2px solid var(--v2-border-border-focus);
+  outline-offset: -1px;
+}
+
+[data-component="lineage-ledger"] [data-slot="lineage-ledger-path"] {
+  flex: 1 1 auto;
+  min-width: 0;
+}
+
+[data-component="lineage-ledger"] [data-slot="lineage-ledger-status"] {
+  display: inline-flex;
+  align-items: center;
+  gap: var(--space-1, 4px);
+}
+
+[data-component="lineage-ledger"] [data-slot="lineage-ledger-status"][data-tone="success"] {
+  color: var(--v2-state-fg-success);
+}
+[data-component="lineage-ledger"] [data-slot="lineage-ledger-status"][data-tone="danger"] {
+  color: var(--v2-state-fg-danger);
+}
+[data-component="lineage-ledger"] [data-slot="lineage-ledger-status"][data-tone="warning"] {
+  color: var(--v2-state-fg-warning);
+}
+[data-component="lineage-ledger"] [data-slot="lineage-ledger-status"][data-tone="neutral"] {
+  color: var(--v2-text-text-muted);
+}
+
+[data-component="lineage-ledger"] [data-slot="lineage-ledger-history"] {
+  display: flex;
+  flex-direction: column;
+  gap: var(--space-1, 4px);
+  padding: var(--space-1, 4px) var(--space-2, 8px) var(--space-2, 8px) var(--space-5, 20px);
+}
+
+[data-component="lineage-ledger"] [data-slot="lineage-ledger-unknown"] {
+  display: flex;
+  flex-direction: column;
+  gap: var(--space-1, 4px);
+  padding: var(--space-2, 8px);
+  border: 1px solid var(--v2-border-border-warning);
+  border-radius: var(--radius-lg, 12px);
+}
+
+[data-component="lineage-ledger"] [data-slot="lineage-ledger-unknown-item"] {
+  display: flex;
+  align-items: center;
+  gap: var(--space-2, 8px);
+}
+
+[data-component="lineage-ledger"] [data-slot="lineage-ledger-more"] {
+  align-self: flex-start;
+  padding: var(--space-1, 4px) var(--space-2, 8px);
+  border: 1px solid var(--v2-border-border-base);
+  border-radius: var(--radius-md, 8px);
+  background: var(--v2-background-bg-layer-01);
+  color: var(--v2-text-text-base);
+  cursor: pointer;
+}
+
+[data-component="lineage-ledger"] [data-slot="lineage-ledger-more"]:focus-visible {
+  outline: 2px solid var(--v2-border-border-focus);
+  outline-offset: 1px;
+}

packages/app/src/pages/session/v2/lineage-ledger-panel.test.tsx

@@ -0,0 +1,71 @@
+import { describe, expect, test } from "bun:test"
+import { readFileSync } from "node:fs"
+import { resolve } from "node:path"
+
+// The lineage-ledger panel is authored in Solid JSX; bun's test transpiler does
+// not run Solid's dom-expressions transform, so (as elsewhere in this repo —
+// see vscode-explorer-file-icon.test.tsx) the component's behavioral substance
+// lives in pure, directly-tested functions (lineage-ledger-view.test.ts) and
+// this test proves the component wires the accessibility contract those
+// functions require. The Work Column design contract (amicode#1082 AC8) is:
+// Tab reaches each filter/row/continuation/unknown item, Enter/Space toggles a
+// resource, Escape returns focus to its row, and each status has an accessible
+// name plus a non-color signal.
+const source = readFileSync(resolve(__dirname, "lineage-ledger-panel.tsx"), "utf8")
+
+describe("LineageLedgerPanel — render + accessibility contract", () => {
+  test("renders from the projected view-model only (no tool/watcher inference — AC1)", () => {
+    expect(source).toContain("./lineage-ledger-view")
+    expect(source).toContain("props.view()")
+    expect(source).not.toMatch(/accumulate-diffs|toolDiffs|externalFileStatus|watcher/i)
+  })
+
+  test("surfaces the capability label as accessible status text (AC7)", () => {
+    expect(source).toContain('data-slot="lineage-ledger-capability"')
+    expect(source).toContain('role="status"')
+    expect(source).toContain("capability().label")
+    expect(source).toContain("capability().description")
+  })
+
+  test("each canonical resource is one focusable, toggleable row (AC2/AC8)", () => {
+    expect(source).toContain('data-slot="lineage-ledger-resource"')
+    expect(source).toContain("aria-expanded")
+    expect(source).toContain("aria-controls")
+    // a real <button> is natively Tab-reachable and Enter/Space-activatable
+    expect(source).toMatch(/<button[\s\S]*?onKeyDown/)
+  })
+
+  test("status carries an accessible name and a non-color signal (AC5)", () => {
+    expect(source).toContain('data-slot="lineage-ledger-status"')
+    expect(source).toContain("status.accessibleName")
+    expect(source).toContain("data-status={")
+    expect(source).toContain("data-tone={")
+    // icon + text label accompany the tone — color is never the only signal
+    expect(source).toContain("status.icon")
+    expect(source).toContain("status.label")
+  })
+
+  test("expanded history is a chronological region keyed to its row (AC3)", () => {
+    expect(source).toContain('data-slot="lineage-ledger-history"')
+    expect(source).toContain("history")
+    expect(source).toContain("assessments")
+  })
+
+  test("unknown mutation receipts render in a dedicated uncertainty group (AC4)", () => {
+    expect(source).toContain('data-slot="lineage-ledger-unknown"')
+    expect(source).toContain("Unknown Mutation Receipts")
+    expect(source).toContain("view().unknown")
+  })
+
+  test("keyboard: applyLedgerKeyDown drives toggle/collapse and Escape refocuses the row (AC8)", () => {
+    expect(source).toContain("applyLedgerKeyDown")
+    expect(source).toContain('"toggle"')
+    expect(source).toContain('"collapse"')
+    expect(source).toContain("focus()")
+  })
+
+  test("paging exposes a Tab-reachable continuation control (AC6)", () => {
+    expect(source).toContain('data-slot="lineage-ledger-more"')
+    expect(source).toContain("nextCursor")
+  })
+})