portable-agent-layer 0.86.3 → 0.88.0

package/src/hooks/lib/rule-drafter.ts

@@ -0,0 +1,240 @@
+/**
+ * The rule drafter: after a confirmed correction, the small model decides
+ * whether it repeats an earlier one and, if so, drafts a rule that would have
+ * prevented them all.
+ */
+
+import type { CandidateInput } from "./adaptation-candidates";
+import type { RuleTrigger } from "./adaptation-rules";
+import { type RequestedTurn, type Turn, withRequests } from "./adaptation-turns";
+import { firesOn } from "./rule-proof";
+
+const MIN_CITED = 2;
+const MIN_CITED_FOR_WIDENING = 1;
+const EVIDENCE_MESSAGE_MAX = 200;
+
+type Correction = RequestedTurn;
+
+export interface KnownRule {
+  id: string;
+  when: string;
+  trigger: RuleTrigger;
+  steering: string;
+  check?: string;
+  status: string;
+  widens?: string;
+}
+
+const DRAFTER_SYSTEM_PROMPT = `You turn an AI assistant's repeated mistakes into one rule that prevents them.
+
+You get the corrections the user made recently, numbered and oldest first. Each has the end of the assistant's reply the user corrected, the user's correcting message, what the reply got wrong, and, when known, the user's request the reply answered. The newest one just happened. Then the known rules; an approved rule shows its trigger and whether that trigger fires on the newest correction.
+
+First check the approved rules. If one would have prevented the newest correction but its trigger does not fire on it, widen that rule: set recurring to true, widens to its id, pattern to a case-insensitive JavaScript regular expression on the rule's side that matches the newest correction (it is added to the rule's trigger as an alternative, so do not repeat the existing trigger), cites to the corrections the widened rule would have prevented, including the newest, and reason. Leave when, steering and check empty.
+
+If an approved rule would have prevented it and its trigger fires on it, the rule fired and was not followed; a new rule will not help. Set recurring to false.
+
+Otherwise set widens to an empty string and decide whether the newest correction is the same kind of mistake as at least one earlier correction. Same kind means one instruction would have prevented both, not that they share a topic.
+
+If it is not, or another known rule already covers it, set recurring to false, say why in reason in one sentence, leave the text fields empty and set cites to [].
+
+If it is, draft one rule:
+- when: the situation, in one sentence.
+- side and pattern: a case-insensitive JavaScript regular expression for that situation. Side "reply" matches the end of the assistant's reply; side "prompt" matches the user's request. It must match the cited corrections, stay general enough to catch the next one, and not match ordinary turns.
+- steering: the instruction to the assistant, imperative, at most two sentences.
+- check: how to tell from a reply whether the instruction was followed, in one sentence.
+- cites: the numbers of the corrections this rule would have prevented, including the newest.
+- reason: why these corrections are the same mistake, in one sentence.`;
+
+const DRAFTER_SCHEMA = {
+  type: "object",
+  properties: {
+    recurring: { type: "boolean" },
+    widens: { type: "string" },
+    reason: { type: "string" },
+    when: { type: "string" },
+    side: { enum: ["prompt", "reply"] },
+    pattern: { type: "string" },
+    steering: { type: "string" },
+    check: { type: "string" },
+    cites: { type: "array", items: { type: "integer" } },
+  },
+  required: [
+    "recurring",
+    "widens",
+    "reason",
+    "when",
+    "side",
+    "pattern",
+    "steering",
+    "check",
+    "cites",
+  ],
+  additionalProperties: false,
+} as const;
+
+export function correctionsToDraftFrom(turns: Turn[]): Correction[] {
+  return withRequests(turns).filter((turn) => turn.confirmed === true);
+}
+
+export function canRepeat(corrections: Correction[]): boolean {
+  return corrections.length >= MIN_CITED;
+}
+
+function missedApprovedRules(corrections: Correction[], known: KnownRule[]): KnownRule[] {
+  const newest = corrections.at(-1);
+  if (!newest) return [];
+  return known.filter(
+    (rule) => rule.status === "approved" && !firesOn(rule.trigger, newest)
+  );
+}
+
+export function canWiden(corrections: Correction[], known: KnownRule[]): boolean {
+  return missedApprovedRules(corrections, known).length > 0;
+}
+
+function correctionBlock(correction: Correction, n: number, newest: boolean): string {
+  const request = correction.prompt ? `<request>${correction.prompt}</request>\n` : "";
+  return `<correction n="${n}"${newest ? ' newest="true"' : ""}>\n${request}<reply_end>${correction.replyEnd}</reply_end>\n<user_message>${correction.message}</user_message>\n<what_was_wrong>${correction.issue}</what_was_wrong>\n</correction>`;
+}
+
+function knownRuleLine(rule: KnownRule, newest: Correction | undefined): string {
+  if (rule.widens)
+    return `- draft widening of rule ${rule.widens}: ${rule.trigger.pattern}`;
+  if (rule.status !== "approved")
+    return `- ${rule.status}: ${rule.when}. ${rule.steering}`;
+  const fires = newest && firesOn(rule.trigger, newest) ? "yes" : "no";
+  return `- approved rule ${rule.id}: ${rule.when}. ${rule.steering} Trigger on the ${rule.trigger.side}: ${rule.trigger.pattern}. Fires on the newest correction: ${fires}.`;
+}
+
+function knownRulesBlock(known: KnownRule[], newest: Correction | undefined): string {
+  const lines = known.map((rule) => knownRuleLine(rule, newest));
+  return `Known rules:\n${lines.length ? lines.join("\n") : "none"}`;
+}
+
+export function drafterRequest(
+  corrections: Correction[],
+  known: KnownRule[],
+  sessionId?: string
+) {
+  const last = corrections.length - 1;
+  const blocks = corrections.map((c, n) => correctionBlock(c, n, n === last));
+  return {
+    system: DRAFTER_SYSTEM_PROMPT,
+    user: `${blocks.join("\n\n")}\n\n${knownRulesBlock(known, corrections[last])}`,
+    tier: "small" as const,
+    maxTokens: 600,
+    timeout: 90_000,
+    jsonSchema: DRAFTER_SCHEMA,
+    caller: "rule-drafter",
+    sessionId,
+  };
+}
+
+interface DraftOutput {
+  recurring: boolean;
+  widens?: string;
+  when: string;
+  side: "prompt" | "reply";
+  pattern: string;
+  steering: string;
+  check: string;
+  cites: number[];
+}
+
+const REGEX_LITERAL = /^\/(.+)\/[a-z]*$/s;
+
+function bareExpression(pattern: string): string {
+  return REGEX_LITERAL.exec(pattern)?.[1] ?? pattern;
+}
+
+function isValidPattern(pattern: string): boolean {
+  try {
+    new RegExp(pattern, "i");
+    return pattern.trim() !== "";
+  } catch {
+    return false;
+  }
+}
+
+function validCites(cites: unknown, count: number, minCited: number): number[] | null {
+  if (!Array.isArray(cites)) return null;
+  const distinct = [...new Set(cites)];
+  const inRange = distinct.every((n) => Number.isInteger(n) && n >= 0 && n < count);
+  const citesNewest = distinct.includes(count - 1);
+  return inRange && citesNewest && distinct.length >= minCited
+    ? (distinct as number[]).sort((a, b) => a - b)
+    : null;
+}
+
+function parseOutput(output: string): DraftOutput | null {
+  try {
+    return JSON.parse(output) as DraftOutput;
+  } catch {
+    return null;
+  }
+}
+
+function hasText(...fields: unknown[]): boolean {
+  return fields.every((field) => typeof field === "string" && field.trim() !== "");
+}
+
+function citedEvidence(cites: number[], corrections: Correction[]): string[] {
+  return cites.map((n) => {
+    const cited = corrections[n];
+    return `${cited.issue}: ${cited.message.slice(0, EVIDENCE_MESSAGE_MAX)}`;
+  });
+}
+
+function parseNewRule(
+  draft: DraftOutput,
+  corrections: Correction[]
+): CandidateInput | null {
+  const cites = validCites(draft.cites, corrections.length, MIN_CITED);
+  const sideOk = draft.side === "prompt" || draft.side === "reply";
+  if (!cites || !sideOk || !hasText(draft.pattern)) return null;
+  const pattern = bareExpression(draft.pattern);
+  if (!isValidPattern(pattern)) return null;
+  if (!hasText(draft.when, draft.steering, draft.check)) return null;
+  return {
+    when: draft.when.trim(),
+    trigger: { side: draft.side, pattern },
+    steering: draft.steering.trim(),
+    check: draft.check.trim(),
+    evidence: citedEvidence(cites, corrections),
+  };
+}
+
+function parseWidening(
+  draft: DraftOutput,
+  corrections: Correction[],
+  known: KnownRule[]
+): CandidateInput | null {
+  const rule = missedApprovedRules(corrections, known).find((r) => r.id === draft.widens);
+  const cites = validCites(draft.cites, corrections.length, MIN_CITED_FOR_WIDENING);
+  if (!rule || !cites || !hasText(draft.pattern)) return null;
+  const addition = bareExpression(draft.pattern);
+  if (!isValidPattern(addition)) return null;
+  const trigger = { ...rule.trigger, pattern: `${rule.trigger.pattern}|${addition}` };
+  const newest = corrections.at(-1);
+  if (!newest || !firesOn(trigger, newest)) return null;
+  return {
+    when: rule.when,
+    trigger,
+    steering: rule.steering,
+    check: rule.check ?? "",
+    evidence: citedEvidence(cites, corrections),
+    widens: rule.id,
+  };
+}
+
+export function parseDraft(
+  output: string | null | undefined,
+  corrections: Correction[],
+  known: KnownRule[] = []
+): CandidateInput | null {
+  const draft = output ? parseOutput(output) : null;
+  if (draft?.recurring !== true) return null;
+  return draft.widens
+    ? parseWidening(draft, corrections, known)
+    : parseNewRule(draft, corrections);
+}

package/src/hooks/lib/rule-effect.ts

@@ -0,0 +1,87 @@
+/**
+ * What an approved rule did: how often it fired, and whether the user still
+ * corrected the reply it steered. A turn is stamped with when its message was
+ * sent, so the first turn in a session after a fire judges the steered reply.
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import type { RuleTrigger } from "./adaptation-rules";
+import type { Turn } from "./adaptation-turns";
+import { paths } from "./paths";
+
+const WINDOW_DAYS = 30;
+const DAY_MS = 86_400_000;
+
+export interface RuleEvent {
+  ts: string;
+  rule: string;
+  side: RuleTrigger["side"];
+  session: string;
+  sentBack?: boolean;
+}
+
+export interface RuleEffect {
+  fired: number;
+  sentBack: number;
+  /** Fires followed by a labelled turn in the same session. */
+  judged: number;
+  correctedAfter: number;
+}
+
+export function ruleEventsPath(): string {
+  return resolve(paths.adaptation(), "rule-events.jsonl");
+}
+
+function parseLine(line: string): RuleEvent | null {
+  try {
+    const parsed = JSON.parse(line) as RuleEvent;
+    return typeof parsed.ts === "string" && typeof parsed.rule === "string"
+      ? parsed
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+export function readRuleEvents(days = WINDOW_DAYS, now = new Date()): RuleEvent[] {
+  const path = ruleEventsPath();
+  if (!existsSync(path)) return [];
+  const cutoff = now.getTime() - days * DAY_MS;
+  return readFileSync(path, "utf-8")
+    .split("\n")
+    .map(parseLine)
+    .filter((e): e is RuleEvent => e !== null && Date.parse(e.ts) >= cutoff);
+}
+
+function turnAfter(event: RuleEvent, turns: Turn[]): Turn | undefined {
+  return turns.find((t) => t.session === event.session && t.ts > event.ts);
+}
+
+function isConfirmedCorrection(turn: Turn | undefined): boolean {
+  return turn?.confirmed === true;
+}
+
+const emptyEffect = (): RuleEffect => ({
+  fired: 0,
+  sentBack: 0,
+  judged: 0,
+  correctedAfter: 0,
+});
+
+export function ruleEffects(
+  events: RuleEvent[],
+  turns: Turn[]
+): Record<string, RuleEffect> {
+  const effects: Record<string, RuleEffect> = {};
+  for (const event of events) {
+    const effect = effects[event.rule] ?? emptyEffect();
+    const judge = turnAfter(event, turns);
+    effect.fired += 1;
+    if (event.sentBack) effect.sentBack += 1;
+    if (judge) effect.judged += 1;
+    if (isConfirmedCorrection(judge)) effect.correctedAfter += 1;
+    effects[event.rule] = effect;
+  }
+  return effects;
+}

package/src/hooks/lib/rule-proof.ts

@@ -0,0 +1,65 @@
+/**
+ * The proof: replay a candidate's trigger over the turn log. A trigger earns a
+ * draft when it fires on repeated corrections and stays quiet on ordinary turns.
+ */
+
+import type { RuleTrigger, TriggerProof } from "./adaptation-rules";
+import type { RequestedTurn } from "./adaptation-turns";
+
+const MIN_FIRED_CORRECTIONS = 2;
+const MIN_FIRED_FOR_WIDENING = 1;
+const MAX_ORDINARY_FIRE_RATE = 0.1;
+const MIN_ORDINARY_TURNS = 20;
+
+export type ProofVerdict = "passed" | "failed" | "waiting";
+
+const CORRECTION_REACTIONS = new Set(["corrected", "repeated"]);
+
+function isConfirmedCorrection(turn: RequestedTurn): boolean {
+  return CORRECTION_REACTIONS.has(turn.reaction) && turn.confirmed === true;
+}
+
+function isOrdinary(turn: RequestedTurn): boolean {
+  return !CORRECTION_REACTIONS.has(turn.reaction);
+}
+
+function triggerText(trigger: RuleTrigger, turn: RequestedTurn): string {
+  return trigger.side === "reply" ? turn.replyEnd : turn.prompt;
+}
+
+export function firesOn(trigger: RuleTrigger, turn: RequestedTurn): boolean {
+  return new RegExp(trigger.pattern, "i").test(triggerText(trigger, turn));
+}
+
+export function proveTrigger(trigger: RuleTrigger, turns: RequestedTurn[]): TriggerProof {
+  const testable = turns.filter((turn) => triggerText(trigger, turn) !== "");
+  const fires = (turn: RequestedTurn) => firesOn(trigger, turn);
+  const corrections = testable.filter(isConfirmedCorrection);
+  const ordinary = testable.filter(isOrdinary);
+  return {
+    firedCorrections: corrections.filter(fires).length,
+    corrections: corrections.length,
+    firedOrdinary: ordinary.filter(fires).length,
+    ordinary: ordinary.length,
+  };
+}
+
+export function ordinaryTurnsNeeded(proof: TriggerProof): number {
+  return Math.max(0, MIN_ORDINARY_TURNS - proof.ordinary);
+}
+
+export function proofVerdict(proof: TriggerProof): ProofVerdict {
+  return verdictFiringOn(MIN_FIRED_CORRECTIONS, proof);
+}
+
+export function widenedProofVerdict(proof: TriggerProof): ProofVerdict {
+  return verdictFiringOn(MIN_FIRED_FOR_WIDENING, proof);
+}
+
+function verdictFiringOn(minFiredCorrections: number, proof: TriggerProof): ProofVerdict {
+  if (proof.firedCorrections < minFiredCorrections) return "failed";
+  if (proof.ordinary < MIN_ORDINARY_TURNS) return "waiting";
+  return proof.firedOrdinary <= proof.ordinary * MAX_ORDINARY_FIRE_RATE
+    ? "passed"
+    : "failed";
+}

package/src/hooks/lib/token-usage.ts

@@ -10,6 +10,7 @@ import { ensureDir, paths } from "./paths";
 
 type TokenCaller =
   | "rating"
+  | "rule-drafter"
   | "failure"
   | "session-name"
   | "session-intelligence"

package/src/targets/opencode/plugin.ts

@@ -179,11 +179,12 @@ const PALPlugin: Plugin = async ({ directory, client }: PluginInput) => {
       const text = partsToText(output.parts ?? []);
       if (!text.trim()) return;
 
+      const sentAt = new Date();
       const injectedText = (await getPromptContext(text, input.sessionID)) ?? "";
       logPromptSnapshot(text, injectedText || null);
 
       await Promise.allSettled([
-        captureRating(text, input.sessionID),
+        captureRating(text, input.sessionID, sentAt),
         captureSessionName(text, input.sessionID),
       ]);
 

package/src/tools/control-room/attention.ts

@@ -9,6 +9,7 @@
 
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
+import { readRules } from "../../hooks/lib/adaptation-rules";
 import { ensureDir, paths } from "../../hooks/lib/paths";
 import { readAllProjects } from "../../hooks/lib/projects";
 import { queryLedger } from "../ledger/query";
@@ -127,10 +128,27 @@ function unranked(): AttentionItem[] {
     }));
 }
 
+function ruleDrafts(): AttentionItem[] {
+  return readRules()
+    .filter((rule) => rule.status === "draft")
+    .map((rule) => ({
+      id: `rule:${rule.id}`,
+      source: "rules" as const,
+      severity: "waiting" as const,
+      title: `Rule draft waiting: ${rule.when}`,
+      detail: rule.steering,
+      at: rule.createdAt,
+      project: null,
+      href: "/relationship",
+      read: false,
+    }));
+}
+
 const SOURCES: Record<AttentionSource, (now: Date) => AttentionItem[]> = {
   refusals,
   waiting,
   unranked: () => unranked(),
+  rules: () => ruleDrafts(),
 };
 
 export function attention(now: Date = new Date()): AttentionView {

package/src/tools/control-room/prefs.ts

@@ -14,7 +14,7 @@ import {
   write as writeSettings,
 } from "../../hooks/lib/settings";
 
-const ATTENTION_SOURCES = ["refusals", "waiting", "unranked"] as const;
+const ATTENTION_SOURCES = ["refusals", "waiting", "unranked", "rules"] as const;
 export type AttentionSource = (typeof ATTENTION_SOURCES)[number];
 
 export interface ControlRoomPrefs {
@@ -28,7 +28,7 @@ const PREF_DEFAULTS: ControlRoomPrefs = {
   quietAfterDays: PROJECT_STALE_DAYS_DEFAULT,
   urgentWithinDays: 14,
   rankGoals: true,
-  attention: { refusals: true, waiting: true, unranked: true },
+  attention: { refusals: true, waiting: true, unranked: true, rules: true },
 };
 
 const DAY_LIMIT = 365;

package/src/tools/control-room/relationship.ts

@@ -0,0 +1,101 @@
+/**
+ * The Relationship tab: the rule drafts waiting on the user, what the approved
+ * rules did, the candidates still being proven, and the last 30 days of labelled
+ * turns. A decision goes through `decideRule`, the same rule the CLI and the
+ * rule-review skill use.
+ */
+
+import { type Candidate, readCandidates } from "../../hooks/lib/adaptation-candidates";
+import {
+  type AdaptationRule,
+  decideRule,
+  readRules,
+} from "../../hooks/lib/adaptation-rules";
+import { readTurns, type Turn } from "../../hooks/lib/adaptation-turns";
+import {
+  type RuleEffect,
+  readRuleEvents,
+  ruleEffects,
+} from "../../hooks/lib/rule-effect";
+import { ordinaryTurnsNeeded } from "../../hooks/lib/rule-proof";
+import type { WriteOutcome } from "./writes";
+
+const WINDOW_DAYS = 30;
+const RECENT_CORRECTIONS = 10;
+
+export interface ActiveRule extends AdaptationRule {
+  effect: RuleEffect;
+}
+
+export interface PipelineCandidate extends Candidate {
+  ordinaryNeeded: number;
+}
+
+interface TurnStats {
+  total: number;
+  byReaction: Record<string, number>;
+  confirmedCorrections: number;
+  recentCorrections: { ts: string; issue: string; message: string }[];
+}
+
+export interface RelationshipView {
+  windowDays: number;
+  drafts: AdaptationRule[];
+  active: ActiveRule[];
+  denied: AdaptationRule[];
+  pipeline: PipelineCandidate[];
+  turns: TurnStats;
+}
+
+function turnStats(turns: Turn[]): TurnStats {
+  const byReaction: Record<string, number> = {};
+  for (const turn of turns)
+    byReaction[turn.reaction] = (byReaction[turn.reaction] ?? 0) + 1;
+  const confirmed = turns.filter((turn) => turn.confirmed === true);
+  return {
+    total: turns.length,
+    byReaction,
+    confirmedCorrections: confirmed.length,
+    recentCorrections: confirmed
+      .slice(-RECENT_CORRECTIONS)
+      .reverse()
+      .map(({ ts, issue, message }) => ({ ts, issue, message })),
+  };
+}
+
+const NO_EFFECT: RuleEffect = { fired: 0, sentBack: 0, judged: 0, correctedAfter: 0 };
+
+export function relationship(now: Date = new Date()): RelationshipView {
+  const rules = readRules();
+  const turns = readTurns(WINDOW_DAYS, now);
+  const effects = ruleEffects(readRuleEvents(WINDOW_DAYS, now), turns);
+  const withStatus = (status: AdaptationRule["status"]) =>
+    rules.filter((rule) => rule.status === status);
+  return {
+    windowDays: WINDOW_DAYS,
+    drafts: withStatus("draft"),
+    active: withStatus("approved").map((rule) => ({
+      ...rule,
+      effect: effects[rule.id] ?? NO_EFFECT,
+    })),
+    denied: withStatus("denied"),
+    pipeline: readCandidates()
+      .filter((candidate) => candidate.verdict !== "passed")
+      .map((candidate) => ({
+        ...candidate,
+        ordinaryNeeded:
+          candidate.verdict === "waiting" ? ordinaryTurnsNeeded(candidate.proof) : 0,
+      })),
+    turns: turnStats(turns),
+  };
+}
+
+export function decideFromPage(
+  id: string,
+  decision: "approved" | "denied"
+): WriteOutcome {
+  const known = readRules().some((rule) => rule.id === id);
+  const result = decideRule(id, decision);
+  if (result.ok) return { ok: true, changed: true };
+  return { ok: false, status: known ? 409 : 404, error: result.reason };
+}

package/src/tools/control-room/server.ts

@@ -18,6 +18,7 @@ import { agenda, agentsAtWork, board, handoffs, signal, summary } from "./data";
 import { projectDetail } from "./detail";
 import { matrix } from "./matrix";
 import { type PrefUpdate, readPrefs, validatePrefs, writePrefs } from "./prefs";
+import { decideFromPage, relationship } from "./relationship";
 import { DEFAULT_PORT, LOOPBACK } from "./server-config";
 import { MAX_SNOOZE_DAYS, setSnooze } from "./snooze";
 import { indexHtml, staticAsset } from "./static";
@@ -39,7 +40,14 @@ export { DEFAULT_PORT, LOOPBACK };
  * Every path the single-page app owns. Listed rather than wildcarded, because a
  * blanket "/*" outranks the fetch handler and would swallow /api as well.
  */
-const PAGE_ROUTES = ["/", "/projects", "/projects/:slug", "/log", "/settings"];
+const PAGE_ROUTES = [
+  "/",
+  "/projects",
+  "/projects/:slug",
+  "/log",
+  "/relationship",
+  "/settings",
+];
 
 export interface ServerStatus {
   pid: number;
@@ -284,7 +292,20 @@ async function prefsWrite(request: Request): Promise<Response> {
   return failure ? json({ error: failure }, 400) : json(writePrefs(body as PrefUpdate));
 }
 
+/** Approve or deny a rule draft — the same rule `pal cli rule` reaches. */
+async function ruleWrite(request: Request): Promise<Response> {
+  const body = await readBody(request);
+  if (!body) return json({ error: "expected a JSON body" }, 400);
+  const { id, decision } = body;
+  if (typeof id !== "string" || !id) return json({ error: "id is required" }, 400);
+  if (decision !== "approved" && decision !== "denied") {
+    return json({ error: "decision must be approved or denied" }, 400);
+  }
+  return answer(decideFromPage(id, decision), { id, decision });
+}
+
 const WRITES: Record<string, (request: Request) => Promise<Response>> = {
+  "/api/rule": ruleWrite,
   "/api/serves": overrideServes,
   "/api/isc": iscWrite,
   "/api/placement": placementWrite,
@@ -340,6 +361,8 @@ export function startControlRoom(port: number = DEFAULT_PORT) {
           return json(autoUpdateStatus());
         case "/api/attention":
           return json(attention());
+        case "/api/relationship":
+          return json(relationship());
         case "/api/status":
           return status(server.port ?? port, startedAt);
         default:

package/src/tools/control-room/ui/app.tsx

@@ -22,6 +22,7 @@ import {
   STATUS_FILTERS,
   type StatusFilter,
 } from "./screens/projects";
+import { Relationship } from "./screens/relationship";
 import { Settings } from "./screens/settings";
 import { isLayout, LAYOUTS, type Layout, Today } from "./screens/today";
 
@@ -126,6 +127,23 @@ function LogRoute() {
   );
 }
 
+function RelationshipRoute() {
+  return (
+    <Screen
+      title="Relationship"
+      aside={
+        <span className="text-[12px] text-neutral-700">
+          rules drafted from your corrections, and what they did
+        </span>
+      }
+    >
+      <Scroller className={MARK_ROOM}>
+        <Relationship />
+      </Scroller>
+    </Screen>
+  );
+}
+
 function SettingsRoute() {
   return (
     <Screen title="Settings">
@@ -140,6 +158,7 @@ const TABS = [
   { to: "/", label: "Today", end: true },
   { to: "/projects", label: "Projects", end: false },
   { to: "/log", label: "Action log", end: false },
+  { to: "/relationship", label: "Relationship", end: false },
   { to: "/settings", label: "Settings", end: false },
 ] as const;
 
@@ -194,6 +213,7 @@ function App() {
             <Route path="/projects" element={<ProjectsRoute />} />
             <Route path="/projects/:slug" element={<ProjectDetailRoute />} />
             <Route path="/log" element={<LogRoute />} />
+            <Route path="/relationship" element={<RelationshipRoute />} />
             <Route path="/settings" element={<SettingsRoute />} />
             <Route path="*" element={<Navigate to="/" replace />} />
           </Routes>