@raquezha/notrace 0.0.5 → 0.0.7

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @raquezha/notrace
 
+## 0.0.7
+
+### Patch Changes
+
+- 5a3e563: Improve session reports by rendering the session ID as a copyable chip under the notrace logo.
+- 5a3e563: Enhance the trace header to include the active git branch alongside the repository name, and clarify the capture setting label.
+- 7664e50: Polish notrace reliability and installed-package ergonomics: add review/compare package CLIs, validate run records before writing, atomically write private artifacts, recover from corrupt index JSON, and verify capture modes.
+
+## 0.0.6
+
+### Patch Changes
+
+- d349d36: Refresh the notrace UI and sample session rendering separately from the antigravity billing fix.
+- 51fda83: fix: preserve assistant toolCall blocks in noheadroom compression and expose notrace failure metadata
+- 7afa746: Package updates for antigravity, norpiv, and notrace.
+
 ## 0.0.5
 
 ### Patch Changes

package/README.md

@@ -1,101 +1,171 @@
+<p align="center">
+  <img src="./assets/notrace-logo.svg" alt="notrace logo" width="240" />
+</p>
+
 # notrace
 
-Phase 0 / POC local-first trace capture for the Pi Coding Agent. It captures execution traces for workflow debugging — LLM calls, tool executions, token usage, costs — and writes both an interactive HTML report and a machine-readable `notrace.json` run record to your active task workspace at session end.
+**Traces in, lessons out.**
 
-> **Security warning:** notrace is local-first and now redacts common secrets by default, escapes report rendering, blocks network access in generated reports, and writes private report files. Reports can still contain sensitive prompts, tool payloads, outputs, and local paths. Do not publish generated reports.
+`notrace` is a local-first retrospective engine for the Pi Coding Agent.
+It captures session evidence, writes a versioned `notrace.json` run record, renders a human-readable HTML report, and supports review/compare flows for workflow R&D.
 
-## Boundary with RPIV
+## What notrace owns
 
-The relationship is intentionally optional both ways:
+When enabled, `notrace` is the durable retrospective layer for a session.
+It aggregates:
+- core Pi session telemetry
+- workflow/task context
+- optional dynamic extension telemetry
 
-- **notrace without RPIV**: should work; notrace-owned artifacts belong under `.notrace/`
-- **RPIV without notrace**: should work; `WORK.md` remains the source of truth without any notrace dependency
-- **together**: RPIV `WORK.md [LOG]` may reference notrace artifacts, but `.workflow/` should not own them
+Today, Pi is the first harness adapter.
+The canonical run schema is designed so other harness adapters can be added later, but multi-harness support is not implemented in this package yet.
 
-Neither package should require the other to function.
+## What notrace does not own
 
-## Features
+`notrace` is **not**:
+- the live Pi footer
+- the Pi resume/session-switch UX
+- a scraper of terminal status strings
 
-- **Session timeline**: Every turn, tool call, and LLM completion rendered as an expandable card
-- **Metrics dashboard**: Total tokens, input/output split, cache reads, cost (USD), duration
-- **Machine-readable run record**: Normalized `notrace.json` sidecar for future retrospective/compare flows
-- **Clickable `file://` links**: Artifact paths printed to console at session end for instant browser access
-- **Workdir aware**: notrace-owned artifacts are planned to live under `.notrace/` for the root execution directory
-- **RPIV attachment**: When a task has a `WORK.md`, notrace appends artifact/review references into `[LOG]`
-- **HTML report**: Self-contained/offline report with a restrictive CSP and no remote font/network loads
-- **Safer defaults**: Secret-key/value redaction, bounded payload sizes, metadata-only mode, private file permissions, and `.workflow`-confined artifact writes
+Live footer output, resume hints, and extension footer badges may appear near `notrace` output during shutdown, but they are separate producers.
 
-## Output
+## Retrospective spine
 
+1. **Capture evidence**: `notrace.json`
+2. **Inspect**: `notrace.html`
+3. **Review outcome**: `notrace.review.json`
+4. **Compare attempts**: `compare:notrace`
+
+## Storage
+
+```text
+.notrace/
+  index.json
+  index.html
+  sessions/
+    <session-id>/
+      notrace.json
+      notrace.html
+      notrace.review.json
 ```
-🔍 [notrace] Observability artifacts generated:
-📂 file:///path/to/.notrace/sessions/<session-id>/notrace.html
-📂 file:///path/to/.notrace/sessions/<session-id>/notrace.json
-```
 
-## Usage
+## Canonical run model
+
+Generated `notrace.json` is the source of truth for runtime output, HTML rendering, and downstream tooling.
+The record is versioned and centers on:
+- `kind`
+- `schemaVersion`
+- `traceId`
+- `repository`
+- `session`
+- `task`
+- `captureMode`
+- `conditions`
+- `activity`
+- `telemetry`
+- `events`
+
+Key rule:
+- **consumed tokens** and **saved tokens** are separate metric families
+- optimization telemetry belongs under `telemetry.extensions.*`
+- presentation-only UI strings are not canonical evidence
+
+## Dynamic extension telemetry
+
+`notrace` can include optional structured telemetry from dynamic extensions.
+Current first target is `noheadroom`.
+
+If an extension is absent, `notrace` should still succeed.
+If an extension is present, it can contribute a structured summary such as:
+- loaded / enabled / active state
+- optimization attempts
+- tokens saved
+- last applied compression summary
+
+## Capture modes
+
+Default capture mode is **full**.
 
 ```bash
-# Load directly
 pi --extension ./packages/notrace
-
-# Via nothing mindset (dev, rpiv)
-pi --dev
 ```
 
-## NPM
+Optional modes:
 
 ```bash
-npm install -g @raquezha/notrace
+NOTRACE_CAPTURE=redacted pi --extension ./packages/notrace
+NOTRACE_CAPTURE=metadata pi --extension ./packages/notrace
+NOTRACE_CAPTURE=full pi --extension ./packages/notrace
 ```
 
-## Add a human review
+Mode meanings:
+- `full`: full captured payloads; best for local debugging; highest sensitivity
+- `redacted`: captured payloads with common secret-like values redacted
+- `metadata`: minimal capture, no prompt/tool bodies
+
+**Security warning:** `full` reports can contain prompts, tool arguments, tool outputs, local paths, model payloads, and secrets returned by tools. `redacted` mode removes common secret-shaped values and sensitive keys, but redaction is best-effort and can miss project-specific secrets. `metadata` mode is safest for sharing because prompt/tool bodies are omitted, but reports can still reveal repository names, paths, timing, models, providers, and workflow metadata. Do not publish generated reports without review.
+
+## Review
+
+From this monorepo:
 
 ```bash
-npm run review:notrace -- path/to/notrace.json \
+npm run review:notrace -- \
+  .notrace/sessions/<id>/notrace.json \
   --outcome partial \
   --friction high \
   --lesson "Headroom reduced tokens but needed manual steering." \
   --next-change "Try same task with RepoScry enabled."
 ```
 
-This writes an adjacent review sidecar. For normal runs that means `notrace.review.json` next to `notrace.json`.
+From an installed package:
 
-If the run is attached to an RPIV task folder with `WORK.md`, the review is also logged into that task's `[LOG]` section as a reference to the notrace artifact.
+```bash
+npx -p @raquezha/notrace notrace-review \
+  .notrace/sessions/<id>/notrace.json \
+  --outcome partial \
+  --friction high \
+  --lesson "Headroom reduced tokens but needed manual steering." \
+  --next-change "Try same task with RepoScry enabled."
+```
 
 Review fields:
-
 - `outcome`: `success`, `partial`, `failed`, `abandoned`, `inconclusive`
 - `friction`: `low`, `medium`, `high`
-- `lesson`: short human conclusion
-- `nextChange`: what to try next run
+- `lesson`
+- `nextChange`
+
+## Compare
 
-## Compare two runs
+From this monorepo:
 
 ```bash
 npm run compare:notrace -- \
-  path/to/baseline/notrace.json \
-  path/to/candidate/notrace.json
+  .notrace/sessions/<baseline-id>/notrace.json \
+  .notrace/sessions/<candidate-id>/notrace.json
 ```
 
-This prints a small retrospective diff for:
+From an installed package:
+
+```bash
+npx -p @raquezha/notrace notrace-compare \
+  .notrace/sessions/<baseline-id>/notrace.json \
+  .notrace/sessions/<candidate-id>/notrace.json
+```
 
-- total/input/output tokens
-- duration
-- LLM calls
-- tool calls
-- tool errors
-- total cost
-- model/provider mix
-- review sidecar outcome/friction/lesson when present
+## Templates
 
-## Capture controls
+HTML source-of-truth lives in `templates/`:
+- `dashboard.sample.json`
+- `session.sample.json`
+- `dashboard.sample.html`
+- `session.sample.html`
 
-By default, notrace uses `NOTRACE_CAPTURE=redacted`: it captures useful payloads but redacts common secret keys/values and truncates very large values.
+Refresh previews after renderer changes:
 
 ```bash
-NOTRACE_CAPTURE=metadata pi --dev   # no prompt/tool payload bodies
-NOTRACE_CAPTURE=full pi --dev       # unsafe: raw payloads for local debugging only
+cd packages/notrace
+npm run render:samples
 ```
 
 ## Build

package/assets/notrace-logo.svg

@@ -0,0 +1,20 @@
+<svg viewBox="0 0 420 138" xmlns="http://www.w3.org/2000/svg" role="img" aria-label="notrace">
+  <title>notrace logo</title>
+  <desc>Signal icon above and slightly overlapping the notrace wordmark.</desc>
+  <defs>
+    <linearGradient id="fadeGrad" x1="0%" y1="0%" x2="100%" y2="0%">
+      <stop offset="0%" stop-color="#E2754A"/>
+      <stop offset="100%" stop-color="#EDE2D2"/>
+    </linearGradient>
+  </defs>
+  <g id="trace-icon" transform="translate(1 -5) scale(0.93)">
+    <path d="M6,50 C16,18 26,18 36,50 C46,82 54,82 60,50 C64,30 68,30 71,50"
+      fill="none" stroke="url(#fadeGrad)" stroke-width="4" stroke-linecap="round"/>
+    <line x1="74" y1="50" x2="79" y2="50" stroke="#D9C9B5" stroke-width="4" stroke-linecap="round" stroke-opacity="0.6"/>
+    <circle cx="85" cy="50" r="2.2" fill="#D9C9B5" opacity="0.5"/>
+    <circle cx="90" cy="50" r="1.4" fill="#EDE2D2" opacity="0.32"/>
+    <circle cx="94" cy="50" r="0.9" fill="#EDE2D2" opacity="0.15"/>
+  </g>
+  <text x="0" y="114" fill="#ECE3DA" style="fill:#ECE3DA" font-family="Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, sans-serif" font-size="96" font-weight="900" letter-spacing="-7">no</text>
+  <text x="82" y="114" fill="#D88462" font-family="Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, sans-serif" font-size="96" font-weight="900" letter-spacing="-7">trace</text>
+</svg>

package/assets/notrace-mark.svg

@@ -0,0 +1,18 @@
+<svg width="100" height="100" viewBox="0 0 100 100" xmlns="http://www.w3.org/2000/svg" role="img">
+  <title>notrace logo mark</title>
+  <desc>A wave that smooths into a flat line, then fades into dots — color shifts from trace orange to no cream as it dissolves.</desc>
+  <defs>
+    <linearGradient id="fadeGrad" x1="0%" y1="0%" x2="100%" y2="0%">
+      <stop offset="0%" stop-color="#E2754A"/>
+      <stop offset="100%" stop-color="#EDE2D2"/>
+    </linearGradient>
+  </defs>
+  <g id="trace-icon">
+    <path d="M6,50 C16,18 26,18 36,50 C46,82 54,82 60,50 C64,30 68,30 71,50"
+          fill="none" stroke="url(#fadeGrad)" stroke-width="4" stroke-linecap="round"/>
+    <line x1="74" y1="50" x2="79" y2="50" stroke="#D9C9B5" stroke-width="4" stroke-linecap="round" stroke-opacity="0.6"/>
+    <circle cx="85" cy="50" r="2.2" fill="#D9C9B5" opacity="0.5"/>
+    <circle cx="90" cy="50" r="1.4" fill="#EDE2D2" opacity="0.32"/>
+    <circle cx="94" cy="50" r="0.9" fill="#EDE2D2" opacity="0.15"/>
+  </g>
+</svg>

package/assets/notrace-wordmark.svg

@@ -0,0 +1,4 @@
+<svg viewBox="0 0 420 96" xmlns="http://www.w3.org/2000/svg" role="img" aria-label="notrace wordmark">
+  <text x="0" y="76" fill="#ECE3DA" font-family="Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, sans-serif" font-size="96" font-weight="900" letter-spacing="-7">no</text>
+  <text x="82" y="76" fill="#D88462" font-family="Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, sans-serif" font-size="96" font-weight="900" letter-spacing="-7">trace</text>
+</svg>

package/bin/notrace-compare.mjs

@@ -0,0 +1,153 @@
+#!/usr/bin/env node
+import { readFileSync } from "node:fs";
+import { resolve, relative, dirname, basename, extname, join } from "node:path";
+
+function usage() {
+  console.error("Usage: notrace-compare <baseline-notrace.json> <candidate-notrace.json>");
+  process.exit(1);
+}
+
+const [, , baselineArg, candidateArg] = process.argv;
+if (!baselineArg || !candidateArg) usage();
+
+function loadReview(runPath) {
+  const reviewPath = join(dirname(runPath), `${basename(runPath, extname(runPath))}.review.json`);
+  try {
+    const data = JSON.parse(readFileSync(reviewPath, "utf8"));
+    if (data?.kind !== "notrace-review") return null;
+    return data;
+  } catch {
+    return null;
+  }
+}
+
+function loadRun(filePath) {
+  const absolutePath = resolve(filePath);
+  const data = JSON.parse(readFileSync(absolutePath, "utf8"));
+  if (data?.kind !== "notrace-run") {
+    throw new Error(`${filePath} is not a notrace run record`);
+  }
+  return { path: absolutePath, data, review: loadReview(absolutePath) };
+}
+
+function fmtNumber(value) {
+  return Number(value || 0).toLocaleString();
+}
+
+function fmtUsd(value) {
+  return `$${Number(value || 0).toFixed(5)}`;
+}
+
+function fmtMs(value) {
+  const ms = Number(value || 0);
+  if (ms < 1000) return `${ms}ms`;
+  return `${(ms / 1000).toFixed(2)}s`;
+}
+
+function fmtDelta(delta, formatter = fmtNumber, invertGood = false) {
+  const good = invertGood ? delta > 0 : delta < 0;
+  const bad = invertGood ? delta < 0 : delta > 0;
+  const sign = delta > 0 ? "+" : "";
+  const text = `${sign}${formatter(delta)}`;
+  if (good) return `${text} better`;
+  if (bad) return `${text} worse`;
+  return `${text} same`;
+}
+
+function list(value) {
+  return Array.isArray(value) && value.length ? value.join(", ") : "-";
+}
+
+const baseline = loadRun(baselineArg);
+const candidate = loadRun(candidateArg);
+
+const a = baseline.data;
+const b = candidate.data;
+const aReview = baseline.review;
+const bReview = candidate.review;
+const aActivity = a.activity || {};
+const bActivity = b.activity || {};
+const aTotals = aActivity.totals || {};
+const bTotals = bActivity.totals || {};
+
+const rows = [
+  {
+    label: "Total tokens",
+    baseline: fmtNumber(aTotals.totalTokens),
+    candidate: fmtNumber(bTotals.totalTokens),
+    delta: fmtDelta((bTotals.totalTokens || 0) - (aTotals.totalTokens || 0))
+  },
+  {
+    label: "Input tokens",
+    baseline: fmtNumber(aTotals.inputTokens),
+    candidate: fmtNumber(bTotals.inputTokens),
+    delta: fmtDelta((bTotals.inputTokens || 0) - (aTotals.inputTokens || 0))
+  },
+  {
+    label: "Output tokens",
+    baseline: fmtNumber(aTotals.outputTokens),
+    candidate: fmtNumber(bTotals.outputTokens),
+    delta: fmtDelta((bTotals.outputTokens || 0) - (aTotals.outputTokens || 0))
+  },
+  {
+    label: "Duration",
+    baseline: fmtMs(aActivity.durationMs),
+    candidate: fmtMs(bActivity.durationMs),
+    delta: fmtDelta((bActivity.durationMs || 0) - (aActivity.durationMs || 0), fmtMs)
+  },
+  {
+    label: "LLM calls",
+    baseline: fmtNumber(aActivity.llmCallCount),
+    candidate: fmtNumber(bActivity.llmCallCount),
+    delta: fmtDelta((bActivity.llmCallCount || 0) - (aActivity.llmCallCount || 0))
+  },
+  {
+    label: "Tool calls",
+    baseline: fmtNumber(aActivity.toolCallCount),
+    candidate: fmtNumber(bActivity.toolCallCount),
+    delta: fmtDelta((bActivity.toolCallCount || 0) - (aActivity.toolCallCount || 0))
+  },
+  {
+    label: "Tool errors",
+    baseline: fmtNumber(aActivity.toolErrorCount),
+    candidate: fmtNumber(bActivity.toolErrorCount),
+    delta: fmtDelta((bActivity.toolErrorCount || 0) - (aActivity.toolErrorCount || 0))
+  },
+  {
+    label: "Cost (USD)",
+    baseline: fmtUsd(aTotals.totalCostUsd),
+    candidate: fmtUsd(bTotals.totalCostUsd),
+    delta: fmtDelta((bTotals.totalCostUsd || 0) - (aTotals.totalCostUsd || 0), fmtUsd)
+  }
+];
+
+const labelWidth = Math.max(...rows.map((row) => row.label.length));
+const baselineWidth = Math.max("Baseline".length, ...rows.map((row) => row.baseline.length));
+const candidateWidth = Math.max("Candidate".length, ...rows.map((row) => row.candidate.length));
+
+function pad(value, width) {
+  return String(value).padEnd(width);
+}
+
+console.log("notrace compare\n");
+console.log(`Baseline : ${relative(process.cwd(), baseline.path) || baseline.path}`);
+console.log(`Candidate: ${relative(process.cwd(), candidate.path) || candidate.path}`);
+console.log("");
+console.log(`Task      : ${b.task?.id || a.task?.id || "(none)"}`);
+console.log(`Capture   : ${a.captureMode} -> ${b.captureMode}`);
+console.log(`Models    : ${list(a.conditions?.models)} -> ${list(b.conditions?.models)}`);
+console.log(`Providers : ${list(a.conditions?.providers)} -> ${list(b.conditions?.providers)}`);
+console.log("");
+console.log(`Review    : ${(aReview?.outcome || "-")}/${(aReview?.friction || "-")} -> ${(bReview?.outcome || "-")}/${(bReview?.friction || "-")}`);
+if (aReview?.lesson || bReview?.lesson) {
+  console.log(`Lessons   : ${(aReview?.lesson || "-")} -> ${(bReview?.lesson || "-")}`);
+}
+if (aReview?.nextChange || bReview?.nextChange) {
+  console.log(`Next      : ${(aReview?.nextChange || "-")} -> ${(bReview?.nextChange || "-")}`);
+}
+console.log("");
+console.log(`${pad("Metric", labelWidth)} | ${pad("Baseline", baselineWidth)} | ${pad("Candidate", candidateWidth)} | Delta`);
+console.log(`${"-".repeat(labelWidth)}-+-${"-".repeat(baselineWidth)}-+-${"-".repeat(candidateWidth)}-+-${"-".repeat(24)}`);
+for (const row of rows) {
+  console.log(`${pad(row.label, labelWidth)} | ${pad(row.baseline, baselineWidth)} | ${pad(row.candidate, candidateWidth)} | ${row.delta}`);
+}

package/bin/notrace-review.mjs

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve, relative, dirname, basename, extname, join } from "node:path";
+
+const VALID_OUTCOMES = new Set(["success", "partial", "failed", "abandoned", "inconclusive"]);
+const VALID_FRICTION = new Set(["low", "medium", "high"]);
+
+function appendWorkLogEntry(taskDir, message) {
+  const workMd = join(taskDir, "WORK.md");
+  if (!existsSync(workMd)) return;
+
+  const text = readFileSync(workMd, "utf8");
+  const entry = `- ${new Date().toISOString()}: ${message}`;
+
+  if (!/^(## )?\[LOG\]\s*$/m.test(text)) {
+    writeFileSync(workMd, `${text.trimEnd()}\n\n## [LOG]\n${entry}\n`, { encoding: "utf8" });
+    return;
+  }
+
+  const lines = text.split("\n");
+  const logIndex = lines.findIndex((line) => /^(## )?\[LOG\]\s*$/.test(line));
+  if (logIndex === -1) return;
+
+  let nextSectionIndex = lines.length;
+  for (let i = logIndex + 1; i < lines.length; i++) {
+    if (/^(## )?\[[A-Z0-9_-]+\]\s*$/.test(lines[i])) {
+      nextSectionIndex = i;
+      break;
+    }
+  }
+
+  const before = lines.slice(0, nextSectionIndex);
+  const after = lines.slice(nextSectionIndex);
+  while (before.length > logIndex + 1 && before[before.length - 1]?.trim() === "") {
+    before.pop();
+  }
+  before.push(entry);
+
+  writeFileSync(workMd, `${[...before, ...after].join("\n").replace(/\n*$/, "\n")}`, { encoding: "utf8" });
+}
+
+function usage() {
+  console.error("Usage: notrace-review <notrace.json> [--outcome value] [--friction value] [--lesson text] [--next-change text]");
+  process.exit(1);
+}
+
+const args = process.argv.slice(2);
+if (!args.length) usage();
+
+const runPath = resolve(args[0]);
+const flags = args.slice(1);
+
+function takeFlag(name) {
+  const index = flags.indexOf(name);
+  if (index === -1) return undefined;
+  const value = flags[index + 1];
+  if (!value || value.startsWith("--")) {
+    throw new Error(`Missing value for ${name}`);
+  }
+  return value;
+}
+
+const outcome = takeFlag("--outcome");
+const friction = takeFlag("--friction");
+const lesson = takeFlag("--lesson");
+const nextChange = takeFlag("--next-change");
+
+if (!existsSync(runPath)) {
+  throw new Error(`Run record not found: ${runPath}`);
+}
+
+const run = JSON.parse(readFileSync(runPath, "utf8"));
+if (run?.kind !== "notrace-run") {
+  throw new Error(`Not a notrace run record: ${runPath}`);
+}
+
+if (outcome && !VALID_OUTCOMES.has(outcome)) {
+  throw new Error(`Invalid outcome: ${outcome}`);
+}
+if (friction && !VALID_FRICTION.has(friction)) {
+  throw new Error(`Invalid friction: ${friction}`);
+}
+
+const reviewPath = join(dirname(runPath), `${basename(runPath, extname(runPath))}.review.json`);
+const existing = existsSync(reviewPath)
+  ? JSON.parse(readFileSync(reviewPath, "utf8"))
+  : {
+      schemaVersion: 1,
+      kind: "notrace-review",
+      traceId: run.traceId,
+      runRecord: basename(runPath),
+      outcome: null,
+      friction: null,
+      lesson: "",
+      nextChange: ""
+    };
+
+const review = {
+  ...existing,
+  traceId: run.traceId,
+  runRecord: basename(runPath),
+  outcome: outcome ?? existing.outcome ?? null,
+  friction: friction ?? existing.friction ?? null,
+  lesson: lesson ?? existing.lesson ?? "",
+  nextChange: nextChange ?? existing.nextChange ?? ""
+};
+
+writeFileSync(reviewPath, `${JSON.stringify(review, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+
+if (run.repository?.cwd && (run.task?.dir || run.task?.path)) {
+  const taskDir = run.task?.dir
+    ? resolve(run.task.dir)
+    : resolve(run.repository.cwd, run.task.path);
+  appendWorkLogEntry(taskDir, `notrace review recorded: outcome=${review.outcome ?? "-"}, friction=${review.friction ?? "-"}, review=${relative(taskDir, reviewPath)}`);
+} else {
+  appendWorkLogEntry(dirname(runPath), `notrace review recorded: outcome=${review.outcome ?? "-"}, friction=${review.friction ?? "-"}, review=${basename(reviewPath)}`);
+}
+
+console.log(`notrace review ✓ ${reviewPath}`);
+console.log(`  outcome   : ${review.outcome ?? "-"}`);
+console.log(`  friction  : ${review.friction ?? "-"}`);
+console.log(`  lesson    : ${review.lesson || "-"}`);
+console.log(`  nextChange: ${review.nextChange || "-"}`);

package/dist/notrace/adapters.d.ts

@@ -0,0 +1,32 @@
+import type { WorkflowContext } from "./types.js";
+export interface WorkflowAdapter {
+    name: string;
+    detect(cwd: string): boolean;
+    getContext(cwd: string): WorkflowContext | null;
+    attach(context: WorkflowContext, artifacts: {
+        html: string;
+        record: string;
+    }): void;
+}
+export declare class NorpivAdapter implements WorkflowAdapter {
+    name: string;
+    detect(cwd: string): boolean;
+    getContext(cwd: string): WorkflowContext | null;
+    attach(context: WorkflowContext, artifacts: {
+        html: string;
+        record: string;
+    }): void;
+}
+export declare class ResearchAdapter implements WorkflowAdapter {
+    name: string;
+    detect(cwd: string): boolean;
+    getContext(cwd: string): WorkflowContext | null;
+    attach(): void;
+}
+export declare class GenericAdapter implements WorkflowAdapter {
+    name: string;
+    detect(): boolean;
+    getContext(): null;
+    attach(): void;
+}
+export declare function getActiveAdapter(cwd: string): WorkflowAdapter;