portable-agent-layer 0.108.0 → 0.110.0

package/src/hooks/lib/correction-rates.ts

@@ -0,0 +1,151 @@
+/**
+ * How often each kind of correction happens, per 100 labelled turns. An opinion
+ * works when the rate of its kind drops after it is approved.
+ */
+
+import { type AdaptationRule, isOpinion } from "./adaptation-rules";
+import type { Turn } from "./adaptation-turns";
+import { hasCurrentKind } from "./correction-kind";
+
+interface KindRate {
+  kind: string;
+  count: number;
+  per100: number;
+  suggestions: string[];
+}
+
+export interface KindRates {
+  turns: number;
+  corrections: number;
+  unlabelled: number;
+  /** Labelled by an older prompt or kind set; backfill relabels them. */
+  stale: number;
+  kinds: KindRate[];
+}
+
+function confirmedCorrections(turns: Turn[]): Turn[] {
+  return turns.filter((turn) => turn.confirmed === true);
+}
+
+function per100(count: number, turns: number): number {
+  return turns === 0 ? 0 : Math.round((count / turns) * 1000) / 10;
+}
+
+function rateOf(kind: string, labelled: Turn[], turns: number): KindRate {
+  const ofKind = labelled.filter((turn) => turn.correctionKind?.kind === kind);
+  const suggestions = ofKind
+    .map((turn) => turn.correctionKind?.suggested ?? "")
+    .filter((name) => name !== "");
+  return {
+    kind,
+    count: ofKind.length,
+    per100: per100(ofKind.length, turns),
+    suggestions,
+  };
+}
+
+export function kindRates(turns: Turn[]): KindRates {
+  const corrections = confirmedCorrections(turns);
+  const labelled = corrections.filter((turn) => turn.correctionKind);
+  const kinds = [...new Set(labelled.map((turn) => turn.correctionKind?.kind ?? ""))]
+    .map((kind) => rateOf(kind, labelled, turns.length))
+    .sort((a, b) => b.count - a.count || a.kind.localeCompare(b.kind));
+  return {
+    turns: turns.length,
+    corrections: corrections.length,
+    unlabelled: corrections.length - labelled.length,
+    stale: labelled.filter((turn) => !hasCurrentKind(turn)).length,
+    kinds,
+  };
+}
+
+const MIN_TURNS_AFTER = 200;
+const MIN_CORRECTIONS_BEFORE = 5;
+const MAX_WINDOW_MS = 30 * 86_400_000;
+
+interface WindowRate {
+  turns: number;
+  count: number;
+  per100: number;
+}
+
+interface Windows {
+  before: WindowRate;
+  after: WindowRate;
+}
+
+export interface OpinionEffect extends Windows {
+  kind: string;
+  /** The kinds no opinion targets, over the same windows: what changed anyway. */
+  control: Windows;
+  verdict: "stale-labels" | "too-early" | "too-few" | "lower" | "not-lower";
+}
+
+function hasStaleLabels(turns: Turn[]): boolean {
+  return confirmedCorrections(turns).some((turn) => !hasCurrentKind(turn));
+}
+
+function windowRate(counts: (kind: string) => boolean, turns: Turn[]): WindowRate {
+  const count = kindRates(turns)
+    .kinds.filter((k) => counts(k.kind))
+    .reduce((sum, k) => sum + k.count, 0);
+  return { turns: turns.length, count, per100: per100(count, turns.length) };
+}
+
+function ratio({ before, after }: Windows): number {
+  return before.per100 === 0 ? 1 : after.per100 / before.per100;
+}
+
+function effectVerdict(own: Windows, control: Windows): OpinionEffect["verdict"] {
+  if (own.after.turns < MIN_TURNS_AFTER) return "too-early";
+  if (own.before.count < MIN_CORRECTIONS_BEFORE) return "too-few";
+  return ratio(own) < ratio(control) ? "lower" : "not-lower";
+}
+
+export function opinionEffect(
+  kind: string,
+  approvedAt: Date,
+  turns: Turn[],
+  opinionKinds: string[] = [kind],
+  now: Date = new Date()
+): OpinionEffect {
+  const cut = approvedAt.getTime();
+  const span = Math.min(MAX_WINDOW_MS, now.getTime() - cut);
+  const at = (turn: Turn) => Date.parse(turn.ts);
+  const beforeTurns = turns.filter((t) => at(t) >= cut - span && at(t) < cut);
+  const afterTurns = turns.filter((t) => at(t) >= cut && at(t) < cut + span);
+  const windows = (counts: (k: string) => boolean): Windows => ({
+    before: windowRate(counts, beforeTurns),
+    after: windowRate(counts, afterTurns),
+  });
+  const own = windows((k) => k === kind);
+  const control = windows((k) => k !== kind && !opinionKinds.includes(k));
+  const verdict = hasStaleLabels([...beforeTurns, ...afterTurns])
+    ? "stale-labels"
+    : effectVerdict(own, control);
+  return { kind, ...own, control, verdict };
+}
+
+export const EFFECT_WINDOW_DAYS = (2 * MAX_WINDOW_MS) / 86_400_000;
+
+export function opinionEffectOf(
+  rule: AdaptationRule,
+  rules: AdaptationRule[],
+  turns: Turn[],
+  now: Date = new Date()
+): OpinionEffect | null {
+  if (!isOpinion(rule) || !rule.kind || !rule.decidedAt) return null;
+  const opinionKinds = rules.filter(isOpinion).flatMap((r) => (r.kind ? [r.kind] : []));
+  return opinionEffect(rule.kind, new Date(rule.decidedAt), turns, opinionKinds, now);
+}
+
+export function splitRates(
+  turns: Turn[],
+  at: Date
+): { before: KindRates; after: KindRates } {
+  const cut = at.getTime();
+  return {
+    before: kindRates(turns.filter((turn) => Date.parse(turn.ts) < cut)),
+    after: kindRates(turns.filter((turn) => Date.parse(turn.ts) >= cut)),
+  };
+}

package/src/hooks/lib/inference.ts

@@ -62,6 +62,7 @@ import { logDebug, logError } from "./log";
 import {
   type FixedModelRoute,
   type InferenceTier,
+  inferenceEffort,
   inferenceModel,
   isFixedModelRoute,
 } from "./models";
@@ -224,10 +225,21 @@ export function plannedInferenceRoute(
   return { agent: previewRoute().agent, ...plannedRoute({ user: "", tier, caller }) };
 }
 
+function routeWithModel(
+  opts: InferenceOptions
+): ReturnType<typeof plannedRoute> | { error: string } {
+  try {
+    return plannedRoute(opts);
+  } catch (err) {
+    return { error: err instanceof Error ? err.message : String(err) };
+  }
+}
+
 export async function inference(opts: InferenceOptions): Promise<InferenceResult> {
+  const planned = routeWithModel(opts);
+  if ("error" in planned) return { success: false, error: planned.error };
   const started = performance.now();
   const result = await checkedInference(opts);
-  const planned = plannedRoute(opts);
   logInferenceCall(opts, planned, result, performance.now() - started);
   return { ...result, model: planned.model ?? undefined };
 }
@@ -524,9 +536,15 @@ export function buildCodexArgs(opts: InferenceOptions): string[] {
     "--ephemeral",
     "--json",
     ...(opts.web ? ["-c", "web_search=live"] : []),
+    ...codexEffortArgs(opts),
   ];
 }
 
+function codexEffortArgs(opts: InferenceOptions): string[] {
+  const effort = inferenceEffort("codex-spawn", opts.tier);
+  return effort ? ["-c", `model_reasoning_effort="${effort}"`] : [];
+}
+
 interface CodexItem {
   type?: string;
   text?: string;
@@ -1124,31 +1142,38 @@ async function inferenceViaApi(opts: InferenceOptions): Promise<InferenceResult>
 // structured-output schema for JSON-mode callers.
 // ─────────────────────────────────────────────────────────────────────────────
 
+export function buildOpenAiBody(opts: InferenceOptions): Record<string, unknown> {
+  const { system, user, maxTokens = 500, jsonSchema } = opts;
+  const messages: Array<{ role: string; content: string }> = [];
+  if (system) messages.push({ role: "system", content: system });
+  messages.push({ role: "user", content: user });
+
+  const body: Record<string, unknown> = {
+    model: modelFor("openai-api", opts),
+    max_tokens: maxTokens,
+    messages,
+  };
+  const effort = inferenceEffort("openai-api", opts.tier);
+  if (effort) body.reasoning_effort = effort;
+  if (jsonSchema) {
+    body.response_format = {
+      type: "json_schema",
+      json_schema: { name: "structured_response", strict: true, schema: jsonSchema },
+    };
+  }
+  return body;
+}
+
 async function inferenceViaOpenAiApi(opts: InferenceOptions): Promise<InferenceResult> {
   const apiKey = withPalEnv().PAL_OPENAI_API_KEY;
   if (!apiKey) return { success: false };
 
-  const { system, user, maxTokens = 500, timeout = 15000, jsonSchema } = opts;
+  const { timeout = 15000 } = opts;
 
   try {
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), timeout);
-
-    const messages: Array<{ role: string; content: string }> = [];
-    if (system) messages.push({ role: "system", content: system });
-    messages.push({ role: "user", content: user });
-
-    const body: Record<string, unknown> = {
-      model: modelFor("openai-api", opts),
-      max_tokens: maxTokens,
-      messages,
-    };
-    if (jsonSchema) {
-      body.response_format = {
-        type: "json_schema",
-        json_schema: { name: "structured_response", strict: true, schema: jsonSchema },
-      };
-    }
+    const body = buildOpenAiBody(opts);
 
     const response = await fetch("https://api.openai.com/v1/chat/completions", {
       method: "POST",

package/src/hooks/lib/models.ts

@@ -6,11 +6,13 @@ import type { AgentType } from "./agent";
 
 export const HAIKU_MODEL = "claude-haiku-4-5-20251001";
 export const HAIKU_5_5_MODEL = "claude-haiku-5-5";
-export const SONNET_MODEL = "claude-sonnet-5";
-export const FABLE_MODEL = "claude-fable-5";
+export const SONNET_MODEL = "claude-sonnet-5-5";
+export const OPUS_MODEL = "claude-opus-5-5";
+export const FABLE_MODEL = "claude-fable-5-1";
 
-export const INFERENCE_TIERS = ["small", "medium"] as const;
+export const INFERENCE_TIERS = ["small", "medium", "large", "flagship"] as const;
 export type InferenceTier = (typeof INFERENCE_TIERS)[number];
+type ReasoningEffort = "low" | "medium" | "high";
 
 export type FixedModelRoute =
   | "claude-spawn"
@@ -19,24 +21,37 @@ export type FixedModelRoute =
   | "openai-api"
   | "antigravity-spawn";
 
-/** `large` is the flagship that authors skills and subagents; without one, the agent authors inline. */
-type RouteModels = Record<InferenceTier, string> & { large?: string };
+type RouteModels = Record<"small" | "medium" | "large", string> & { flagship?: string };
 
 const ANTHROPIC_MODELS: RouteModels = {
   small: HAIKU_MODEL,
   medium: SONNET_MODEL,
-  large: FABLE_MODEL,
+  large: OPUS_MODEL,
+  flagship: FABLE_MODEL,
 };
 const OPENAI_MODELS: RouteModels = {
   small: "gpt-6-luna",
   medium: "gpt-6-sol",
-  large: "gpt-6-astra",
+  large: "gpt-6-sol",
+  flagship: "gpt-6-astra",
 };
-/** An Antigravity subagent's `model:` takes only a tier name, so `large` is `pro`. */
 const GEMINI_MODELS: RouteModels = {
   small: "gemini-3.8-flash-low",
-  medium: "gemini-3.8-flash-high",
-  large: "pro",
+  medium: "gemini-3.8-flash-medium",
+  large: "gemini-3.8-flash-high",
+};
+
+const OPENAI_EFFORTS: Partial<Record<InferenceTier, ReasoningEffort>> = { large: "high" };
+const INFERENCE_EFFORTS: Partial<
+  Record<FixedModelRoute, Partial<Record<InferenceTier, ReasoningEffort>>>
+> = {
+  "codex-spawn": OPENAI_EFFORTS,
+  "openai-api": OPENAI_EFFORTS,
+};
+
+/** An Antigravity subagent's `model:` takes only a tier name, never a model id. */
+const SUBAGENT_FLAGSHIP: Partial<Record<FixedModelRoute, string>> = {
+  "antigravity-spawn": "pro",
 };
 
 /**
@@ -56,12 +71,20 @@ export function isFixedModelRoute(route: string): route is FixedModelRoute {
   return Object.hasOwn(INFERENCE_MODELS, route);
 }
 
-/** Callers whose prompt has been evaluated on Haiku 5.5; the rest stay on HAIKU_MODEL until theirs is. */
-const ANTHROPIC_EVALUATED_ON_HAIKU_5_5 = new Set(["rule-drafter"]);
+/**
+ * Callers on Haiku 5.5: those whose prompt passed its eval there, and every new
+ * caller, whose eval is iterated on 5.5 until it passes. The rest stay on
+ * HAIKU_MODEL until theirs is evaluated.
+ */
+const ANTHROPIC_ON_HAIKU_5_5 = new Set(["rule-drafter", "correction-kind"]);
 
-function evaluatedModel(models: RouteModels, caller?: string): string | undefined {
-  const onAnthropic = models === ANTHROPIC_MODELS;
-  return onAnthropic && caller && ANTHROPIC_EVALUATED_ON_HAIKU_5_5.has(caller)
+function evaluatedModel(
+  models: RouteModels,
+  tier: InferenceTier,
+  caller?: string
+): string | undefined {
+  const onAnthropicSmall = models === ANTHROPIC_MODELS && tier === "small";
+  return onAnthropicSmall && caller && ANTHROPIC_ON_HAIKU_5_5.has(caller)
     ? HAIKU_5_5_MODEL
     : undefined;
 }
@@ -72,7 +95,17 @@ export function inferenceModel(
   caller?: string
 ): string {
   const models = INFERENCE_MODELS[route];
-  return evaluatedModel(models, caller) ?? models[tier];
+  const model = evaluatedModel(models, tier, caller) ?? models[tier];
+  if (!model) throw new Error(`${route} has no ${tier} model`);
+  return model;
+}
+
+/** The reasoning effort a tier asks of a model it shares with another tier; undefined keeps the model's default. */
+export function inferenceEffort(
+  route: FixedModelRoute,
+  tier: InferenceTier = "small"
+): ReasoningEffort | undefined {
+  return INFERENCE_EFFORTS[route]?.[tier];
 }
 
 const AGENT_SPAWN_ROUTE: Partial<Record<AgentType, FixedModelRoute>> = {
@@ -84,11 +117,13 @@ const AGENT_SPAWN_ROUTE: Partial<Record<AgentType, FixedModelRoute>> = {
 /**
  * The model an agent's `skill-author` / `subagent-author` runs on, or undefined
  * when `create-skill` and `create-subagent` should author inline. A new provider
- * needs a `large` model on its route and a platform block in assets/agents/*-author.md.
+ * needs a flagship model on its route and a platform block in assets/agents/*-author.md.
  */
 export function flagshipAuthorModel(agent: AgentType): string | undefined {
   const route = AGENT_SPAWN_ROUTE[agent];
-  return route ? INFERENCE_MODELS[route].large : undefined;
+  return route
+    ? (SUBAGENT_FLAGSHIP[route] ?? INFERENCE_MODELS[route].flagship)
+    : undefined;
 }
 
 export interface ModelPricing {
@@ -127,18 +162,31 @@ const withoutWritePremium = (
   cacheRead,
 });
 
+const withWritePremium = (
+  input: number,
+  cacheRead: number,
+  output: number
+): ModelPricing => ({
+  input,
+  output,
+  cacheWrite5m: input * 1.25,
+  cacheWrite1h: input * 1.25,
+  cacheRead,
+});
+
 /**
  * Standard-tier rates from https://developers.openai.com/api/docs/pricing; prompts over
- * 272K tokens cost more, and PAL's never get there. OpenAI bills no cache-write premium.
+ * 272K tokens cost more, and PAL's never get there. GPT-6 and GPT-5.6 bill cache writes
+ * at 1.25x input; older models publish no cache-write price, so writes bill as input.
  */
 const OPENAI_PRICING: Record<string, ModelPricing> = {
-  "gpt-6-astra": withoutWritePremium(10, 1, 50),
-  "gpt-6.1-sol": withoutWritePremium(2, 0.1, 10),
-  "gpt-6-sol": withoutWritePremium(2, 0.2, 10),
-  "gpt-6-luna": withoutWritePremium(0.1, 0.01, 0.5),
-  "gpt-5.6-sol": withoutWritePremium(4, 0.4, 20),
-  "gpt-5.6-terra": withoutWritePremium(2, 0.2, 12),
-  "gpt-5.6-luna": withoutWritePremium(0.2, 0.02, 1.2),
+  "gpt-6-astra": withWritePremium(10, 1, 50),
+  "gpt-6.1-sol": withWritePremium(2, 0.1, 10),
+  "gpt-6-sol": withWritePremium(2, 0.2, 10),
+  "gpt-6-luna": withWritePremium(0.1, 0.01, 0.5),
+  "gpt-5.6-sol": withWritePremium(4, 0.4, 20),
+  "gpt-5.6-terra": withWritePremium(2, 0.2, 12),
+  "gpt-5.6-luna": withWritePremium(0.2, 0.02, 1.2),
   "gpt-5.5": withoutWritePremium(5, 0.5, 30),
   "gpt-5.5-pro": withoutWritePremium(30, 30, 180),
   "gpt-5.4": withoutWritePremium(2.5, 0.25, 15),
@@ -172,14 +220,14 @@ export const MODEL_PRICING: Record<string, ModelPricing> = {
     cacheWrite1h: 0.2,
     cacheRead: 0.01,
   },
-  "claude-fable-5-1": {
+  [FABLE_MODEL]: {
     input: 10,
     output: 50,
     cacheWrite5m: 12.5,
     cacheWrite1h: 20,
     cacheRead: 0.25,
   },
-  [FABLE_MODEL]: {
+  "claude-fable-5": {
     input: 10,
     output: 50,
     cacheWrite5m: 12.5,

package/src/hooks/lib/opinion-gate.ts

@@ -0,0 +1,73 @@
+/**
+ * Whether a draft may be kept as an opinion. Opinions steer every session, so
+ * one is offered only once its kind has recurred enough to be measured, and
+ * only while no opinion or undecided draft already targets that kind: a second
+ * one would share its rate.
+ */
+
+import { type AdaptationRule, isOpinion, type OpinionGate } from "./adaptation-rules";
+import type { Turn } from "./adaptation-turns";
+import { hasCurrentKind } from "./correction-kind";
+import { type OpinionEffect, opinionEffectOf } from "./correction-rates";
+
+const MIN_KIND_CORRECTIONS = 5;
+
+function correctionsOfKind(kind: string, turns: Turn[]): number {
+  return turns.filter(
+    (turn) =>
+      turn.confirmed === true && hasCurrentKind(turn) && turn.correctionKind.kind === kind
+  ).length;
+}
+
+function offersOpinion(rule: AdaptationRule): boolean {
+  return rule.status === "draft" && !rule.widens && !rule.opinionGate;
+}
+
+function sameKind(kind: string, rules: AdaptationRule[]): AdaptationRule | undefined {
+  return rules.find((r) => r.kind === kind && (isOpinion(r) || offersOpinion(r)));
+}
+
+export function opinionGate(
+  kind: string,
+  rules: AdaptationRule[],
+  turns: Turn[]
+): OpinionGate | undefined {
+  const taken = sameKind(kind, rules);
+  if (taken) return { duplicates: taken.id };
+  const corrections = correctionsOfKind(kind, turns);
+  return corrections < MIN_KIND_CORRECTIONS ? { corrections } : undefined;
+}
+
+function opinionAdvice(id: string, effect: OpinionEffect | null): string {
+  if (effect?.verdict === "lower")
+    return `opinion ${id} lowers its kind, so this is a variant; promote ${id} to a lasting principle to free its slot`;
+  if (effect?.verdict === "not-lower")
+    return `opinion ${id} is not lowering its kind; reword ${id} instead of adding another`;
+  return `opinion ${id}'s effect is not measurable yet (${effect?.verdict ?? "no effect"}); held beside it`;
+}
+
+function duplicateAdvice(
+  id: string,
+  rules: AdaptationRule[],
+  turns: Turn[],
+  now: Date
+): string {
+  const target = rules.find((r) => r.id === id);
+  if (target && isOpinion(target))
+    return opinionAdvice(id, opinionEffectOf(target, rules, turns, now));
+  if (target?.status === "draft")
+    return `draft ${id} already offers an opinion for this kind; decide it first`;
+  return `${id} targeted this kind and is no longer active`;
+}
+
+export function gateAdvice(
+  rule: AdaptationRule,
+  rules: AdaptationRule[],
+  turns: Turn[],
+  now: Date = new Date()
+): string | undefined {
+  const gate = rule.status === "draft" ? rule.opinionGate : undefined;
+  if (!gate) return undefined;
+  if ("duplicates" in gate) return duplicateAdvice(gate.duplicates, rules, turns, now);
+  return `${gate.corrections} corrections of its kind so far; an opinion needs ${MIN_KIND_CORRECTIONS}`;
+}

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

@@ -1,12 +1,14 @@
 /**
  * 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.
+ * whether it repeats an earlier one and, if so, drafts the instruction that
+ * would have prevented them all: an opinion, or a rule when its optional
+ * trigger proves.
  */
 
 import type { CandidateInput } from "./adaptation-candidates";
-import type { RuleTrigger } from "./adaptation-rules";
+import { isTriggerRule, type RuleTrigger } from "./adaptation-rules";
 import { type RequestedTurn, type Turn, withRequests } from "./adaptation-turns";
+import { hasCurrentKind } from "./correction-kind";
 import { firesOn } from "./rule-proof";
 
 const MIN_CITED = 2;
@@ -18,14 +20,17 @@ type Correction = RequestedTurn;
 export interface KnownRule {
   id: string;
   when: string;
-  trigger: RuleTrigger;
+  trigger?: RuleTrigger;
   steering: string;
   check?: string;
   status: string;
+  delivery?: "always";
   widens?: string;
 }
 
-const DRAFTER_SYSTEM_PROMPT = `You turn an AI assistant's repeated mistakes into one rule that prevents them.
+type TriggeredRule = KnownRule & { trigger: RuleTrigger };
+
+const DRAFTER_SYSTEM_PROMPT = `You turn an AI assistant's repeated mistakes into one instruction 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.
 
@@ -37,9 +42,9 @@ Otherwise set widens to an empty string and decide whether the newest correction
 
 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.
+If it is, draft one instruction. It steers every session unless a trigger proves it can fire only when needed:
+- when: the situation, in one sentence, general enough to cover the next time and not tied to these corrections' topics.
+- side and pattern: optional. Leave both empty unless the situation always shows in the same words, in the user's request (side "prompt") or at the end of the assistant's reply (side "reply"). Then give a case-insensitive JavaScript regular expression that matches every cited correction on that side, would match the next one, and does not match ordinary turns. A pattern built from the words of these corrections or of the user's correcting message is worse than none.
 - 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.
@@ -52,7 +57,7 @@ const DRAFTER_SCHEMA = {
     widens: { type: "string" },
     reason: { type: "string" },
     when: { type: "string" },
-    side: { enum: ["prompt", "reply"] },
+    side: { enum: ["prompt", "reply", ""] },
     pattern: { type: "string" },
     steering: { type: "string" },
     check: { type: "string" },
@@ -80,12 +85,13 @@ export function canRepeat(corrections: Correction[]): boolean {
   return corrections.length >= MIN_CITED;
 }
 
-function missedApprovedRules(corrections: Correction[], known: KnownRule[]): KnownRule[] {
+function missedApprovedRules(
+  corrections: Correction[],
+  known: KnownRule[]
+): TriggeredRule[] {
   const newest = corrections.at(-1);
   if (!newest) return [];
-  return known.filter(
-    (rule) => rule.status === "approved" && !firesOn(rule.trigger, newest)
-  );
+  return known.filter(isTriggerRule).filter((rule) => !firesOn(rule.trigger, newest));
 }
 
 export function canWiden(corrections: Correction[], known: KnownRule[]): boolean {
@@ -99,9 +105,11 @@ function correctionBlock(correction: Correction, n: number, newest: boolean): st
 
 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}`;
+    return `- draft widening of rule ${rule.widens}: ${rule.trigger?.pattern}`;
+  if (!isTriggerRule(rule)) {
+    const label = rule.delivery === "always" ? `opinion ${rule.id}` : rule.status;
+    return `- ${label}: ${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}.`;
 }
@@ -134,7 +142,7 @@ interface DraftOutput {
   recurring: boolean;
   widens?: string;
   when: string;
-  side: "prompt" | "reply";
+  side: "prompt" | "reply" | "";
   pattern: string;
   steering: string;
   check: string;
@@ -185,23 +193,48 @@ function citedEvidence(cites: number[], corrections: Correction[]): string[] {
   });
 }
 
+function namedKindsOf(cited: Correction[]): string[] {
+  return cited
+    .filter(hasCurrentKind)
+    .map((c) => c.correctionKind.kind)
+    .filter((kind) => kind !== "other");
+}
+
+export function citedKind(
+  cites: number[],
+  corrections: Correction[]
+): string | undefined {
+  const newestFirst = namedKindsOf(cites.map((n) => corrections[n])).reverse();
+  const count = (kind: string) => newestFirst.filter((k) => k === kind).length;
+  const most = Math.max(...newestFirst.map(count));
+  return newestFirst.find((kind) => count(kind) === most);
+}
+
+function withKind<T extends CandidateInput>(candidate: T, kind: string | undefined): T {
+  return kind ? { ...candidate, kind } : candidate;
+}
+
+function optionalTrigger({ side, pattern }: DraftOutput): RuleTrigger | undefined {
+  if ((side !== "prompt" && side !== "reply") || !hasText(pattern)) return undefined;
+  const bare = bareExpression(pattern);
+  return isValidPattern(bare) ? { side, pattern: bare } : undefined;
+}
+
 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 {
+  if (!cites || !hasText(draft.when, draft.steering, draft.check)) return null;
+  const trigger = optionalTrigger(draft);
+  const candidate = {
     when: draft.when.trim(),
-    trigger: { side: draft.side, pattern },
+    ...(trigger && { trigger }),
     steering: draft.steering.trim(),
     check: draft.check.trim(),
     evidence: citedEvidence(cites, corrections),
   };
+  return withKind(candidate, citedKind(cites, corrections));
 }
 
 function parseWidening(

package/src/hooks/lib/semi-static.ts

@@ -8,8 +8,8 @@
 
 import { existsSync, readFileSync } from "node:fs";
 import { basename, resolve } from "node:path";
+import { opinionsContext } from "./adaptation-rules";
 import { type FailureEntry, readFailures } from "./learning-store";
-import { loadOpinionContext } from "./opinions";
 import { palHome, paths } from "./paths";
 import { type ProjectProgress, readAllProjects, resolveProjectFromCwd } from "./projects";
 import { readFramePrinciples } from "./wisdom";
@@ -148,7 +148,7 @@ export function getSemiStaticSources(): SemiStaticSource[] {
       writesDigest: true,
       load: () => {
         try {
-          return loadOpinionContext();
+          return opinionsContext();
         } catch {
           return "";
         }