portable-agent-layer 0.69.0 → 0.71.0

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

@@ -0,0 +1,161 @@
+import type { DueBadge, RatingPoint, SignalView } from "../data";
+import { percent, tenths } from "./format";
+import { Panel, Pending, useLoaded } from "./panel";
+
+const LOW_RATING = 3;
+const W = 320;
+const H = 72;
+const PAD = 4;
+
+function sparkPath(points: RatingPoint[]): {
+  line: string;
+  area: string;
+  xy: [number, number][];
+} {
+  if (points.length === 0) return { line: "", area: "", xy: [] };
+  const step = points.length > 1 ? (W - PAD * 2) / (points.length - 1) : 0;
+  const xy = points.map<[number, number]>((p, i) => [
+    PAD + i * step,
+    H - PAD - ((p.rating - 1) / 9) * (H - PAD * 2),
+  ]);
+  const line = xy
+    .map(([x, y], i) => `${i === 0 ? "M" : "L"}${x.toFixed(1)} ${y.toFixed(1)}`)
+    .join(" ");
+  const area = `${line} L${xy.at(-1)?.[0].toFixed(1)} ${H} L${xy[0][0].toFixed(1)} ${H} Z`;
+  return { line, area, xy };
+}
+
+function Sparkline({ points }: { points: RatingPoint[] }) {
+  const { line, area, xy } = sparkPath(points);
+  const last = xy.at(-1);
+  const midY = H - PAD - (4 / 9) * (H - PAD * 2);
+  return (
+    <svg
+      className="spark"
+      viewBox={`0 0 ${W} ${H}`}
+      preserveAspectRatio="none"
+      role="img"
+      aria-label="ratings"
+    >
+      <title>ratings, oldest to newest</title>
+      <defs>
+        <linearGradient id="sparkfill" x1="0" x2="0" y1="0" y2="1">
+          <stop offset="0" stopColor="#f0b14a" stopOpacity="0.28" />
+          <stop offset="1" stopColor="#f0b14a" stopOpacity="0" />
+        </linearGradient>
+      </defs>
+      <line className="rule" x1={PAD} x2={W - PAD} y1={midY} y2={midY} />
+      <path className="area" d={area} />
+      <path className="line" d={line} />
+      {points.map((p, i) =>
+        p.rating <= LOW_RATING ? (
+          <circle key={p.ts} className="low" cx={xy[i][0]} cy={xy[i][1]} r="2" />
+        ) : null
+      )}
+      {last && <circle className="last" cx={last[0]} cy={last[1]} r="3" />}
+    </svg>
+  );
+}
+
+function Figure({ value, label, tone }: { value: string; label: string; tone?: string }) {
+  return (
+    <div className="figure">
+      <div className={`value ${tone ?? ""}`}>{value}</div>
+      <div className="label">{label}</div>
+    </div>
+  );
+}
+
+const BADGE_LOOK: Record<DueBadge["state"], { row: string; tag: string }> = {
+  due: { row: "due", tag: "amber" },
+  clear: { row: "clear", tag: "good" },
+  "n/a": { row: "na", tag: "ghost" },
+};
+
+function Due({ name, badge }: { name: string; badge: DueBadge }) {
+  const look = BADGE_LOOK[badge.state];
+  return (
+    <div className={`due-row ${look.row}`}>
+      <span className={`tag ${look.tag}`}>{badge.state}</span>
+      <span className="detail">
+        {name}
+        {badge.detail ? ` — ${badge.detail}` : ""}
+      </span>
+    </div>
+  );
+}
+
+function ratingTone(avg: number): string {
+  if (avg < 5) return "bad";
+  if (avg >= 7) return "good";
+  return "";
+}
+
+export function Signal() {
+  const view = useLoaded<SignalView>("/api/signal");
+  return (
+    <Panel
+      index="02 · feedback"
+      title="Signal"
+      span={4}
+      order={1}
+      aside={
+        view.state === "ready" && view.data.synthesizedAt
+          ? `synthesised ${view.data.synthesizedAt.slice(0, 10)}`
+          : ""
+      }
+    >
+      <Pending value={view} />
+      {view.state === "ready" && (
+        <>
+          <div className="figures">
+            <Figure
+              value={view.data.ratings ? tenths(view.data.ratings.recentAvg) : "–"}
+              label="last 10"
+              tone={view.data.ratings ? ratingTone(view.data.ratings.recentAvg) : ""}
+            />
+            <Figure
+              value={view.data.ratings ? tenths(view.data.ratings.avg) : "–"}
+              label={`avg of ${view.data.ratings?.count ?? 0}`}
+            />
+            <Figure
+              value={view.data.ratings ? String(view.data.ratings.lowCount) : "–"}
+              label="low (≤3)"
+              tone={view.data.ratings && view.data.ratings.lowCount > 5 ? "bad" : ""}
+            />
+          </div>
+          {view.data.series.length > 0 ? (
+            <Sparkline points={view.data.series} />
+          ) : (
+            <div className="empty">No ratings yet.</div>
+          )}
+          <div className="spark-caption">
+            <span>last {view.data.series.length} ratings</span>
+            <span>{view.data.ratings?.trend ?? ""}</span>
+          </div>
+          <div className="figures" style={{ marginTop: 16 }}>
+            <Figure
+              value={
+                view.data.algorithm ? String(view.data.algorithm.reflectionCount) : "–"
+              }
+              label="reflections"
+            />
+            <Figure
+              value={view.data.algorithm ? percent(view.data.algorithm.passRate) : "–"}
+              label="criteria pass"
+            />
+            <Figure
+              value={view.data.algorithm ? tenths(view.data.algorithm.avgSentiment) : "–"}
+              label="sentiment"
+            />
+          </div>
+          <div className="due">
+            <Due name="learning analysis" badge={view.data.due.analysis} />
+            <Due name="algorithm review" badge={view.data.due.algorithmReview} />
+            <Due name="relationship reflect" badge={view.data.due.relationshipReflect} />
+          </div>
+        </>
+      )}
+    </Panel>
+  );
+}

package/src/tools/ledger/query.ts

@@ -158,6 +158,24 @@ export function changeShape(entry: LedgerEntry): ChangeShape {
  * its before-state again. `reverted` is exactly that case, and there the delta
  * can be run forward for real, which is why it reports whether it did.
  */
+/** The change as a reader would want it summarised: a line count, or why there is none. */
+export function changedLines(entry: LedgerEntry): string {
+  const shape = changeShape(entry);
+  switch (shape.kind) {
+    case "redacted":
+      return "withheld";
+    case "truncated":
+      return "too large";
+    case "none":
+      return "no change";
+    default: {
+      const added = shape.delta.hunks.reduce((n, h) => n + h.insert.length, 0);
+      const removed = shape.delta.hunks.reduce((n, h) => n + h.remove, 0);
+      return `+${added} -${removed}`;
+    }
+  }
+}
+
 export type Standing =
   | { state: "in-place" }
   | { state: "reverted"; replays: boolean }

package/src/tools/ledger/view.ts

@@ -0,0 +1,130 @@
+/**
+ * The ledger as a page reads it: counts first, rows second, every field
+ * already in the words a person would use. Ids become labels, anchors become
+ * "project / path", deltas become line counts. Nothing here is computed in
+ * the browser, so the numbers on the page are the numbers the tests check.
+ */
+
+import {
+  type ActorRegistryEntry,
+  actorDisplayName,
+  loadActor,
+  readActorRegistry,
+} from "../../hooks/lib/actor";
+import type { LedgerEntry } from "../../hooks/lib/ledger";
+import { anchorSlugOf, changedLines, type LedgerFilter, queryLedger } from "./query";
+
+export const PAGE_OUTCOMES = ["applied", "failed", "denied", "blocked"] as const;
+export type PageOutcome = (typeof PAGE_OUTCOMES)[number];
+
+export interface OutcomeCount {
+  total: number;
+  byAuthority: Record<string, number>;
+  byRuntime: Record<string, number>;
+}
+
+export interface LedgerViewStats {
+  total: number;
+  refusals: number;
+  outcomes: Record<PageOutcome, OutcomeCount>;
+}
+
+export interface LedgerViewRow {
+  id: string;
+  ts: string;
+  actor: string;
+  authority: string;
+  runtime: string;
+  tool: string;
+  target: string;
+  change: string;
+  outcome: string;
+  reason?: string;
+}
+
+export interface LedgerView {
+  window: { since: string | null; until: string | null };
+  stats: LedgerViewStats;
+  rows: LedgerViewRow[];
+}
+
+function emptyCount(): OutcomeCount {
+  return { total: 0, byAuthority: {}, byRuntime: {} };
+}
+
+function bump(counts: Record<string, number>, key: string): void {
+  counts[key] = (counts[key] ?? 0) + 1;
+}
+
+function isPageOutcome(outcome: string): outcome is PageOutcome {
+  return (PAGE_OUTCOMES as readonly string[]).includes(outcome);
+}
+
+export function viewStats(entries: LedgerEntry[]): LedgerViewStats {
+  const outcomes = Object.fromEntries(
+    PAGE_OUTCOMES.map((outcome) => [outcome, emptyCount()])
+  ) as Record<PageOutcome, OutcomeCount>;
+
+  for (const entry of entries) {
+    if (!isPageOutcome(entry.outcome)) continue;
+    const count = outcomes[entry.outcome];
+    count.total++;
+    bump(count.byAuthority, entry.authority);
+    bump(count.byRuntime, entry.runtime);
+  }
+
+  return {
+    total: entries.length,
+    refusals: outcomes.denied.total + outcomes.blocked.total,
+    outcomes,
+  };
+}
+
+export function displayTarget(target: string): string {
+  const slug = anchorSlugOf(target);
+  if (!slug) return target;
+  const rest = target.slice(`{proj:${slug}}`.length);
+  return rest ? `${slug} ${rest}` : slug;
+}
+
+function toRow(entry: LedgerEntry, registry: ActorRegistryEntry[]): LedgerViewRow {
+  const row: LedgerViewRow = {
+    id: entry.id,
+    ts: entry.ts,
+    actor: actorDisplayName(entry.actor, registry),
+    authority: entry.authority,
+    runtime: entry.runtime,
+    tool: entry.tool,
+    target: displayTarget(entry.target),
+    change: changedLines(entry),
+    outcome: entry.outcome,
+  };
+  if (entry.reason) row.reason = entry.reason;
+  return row;
+}
+
+/** The local actor first: on a fresh install the registry may not list them yet. */
+function knownActors(): ActorRegistryEntry[] {
+  const self = loadActor();
+  return [{ id: self.id, label: self.label }, ...readActorRegistry()];
+}
+
+export function viewRows(entries: LedgerEntry[]): LedgerViewRow[] {
+  const registry = knownActors();
+  return entries
+    .slice()
+    .reverse()
+    .map((entry) => toRow(entry, registry));
+}
+
+export function ledgerView(filter: LedgerFilter = {}): LedgerView {
+  const entries = queryLedger(filter);
+  return {
+    window: {
+      since: filter.since?.toISOString() ?? null,
+      until: filter.until?.toISOString() ?? null,
+    },
+    stats: viewStats(entries),
+    rows: viewRows(entries),
+  };
+}

package/src/cli/setup-telos.ts

@@ -1,52 +0,0 @@
-/**
- * Interactive TELOS setup — prompts for personal context during `pal install`.
- * Skips any step whose TELOS file already has real content.
- */
-
-import { writeFileSync } from "node:fs";
-import { resolve } from "node:path";
-import * as clack from "@clack/prompts";
-import { palHome } from "../hooks/lib/paths";
-import { hasRealContent, SETUP_STEPS, STEP_ORDER } from "../hooks/lib/setup";
-
-/** Prompt for missing TELOS context. Skips any step whose file already has real content. */
-export async function promptTelos(): Promise<void> {
-  // Skip interactive prompts in non-TTY environments (tests, CI)
-  if (!process.stdin.isTTY) return;
-
-  const home = palHome();
-  const pending = STEP_ORDER.filter(
-    (key) => !hasRealContent(resolve(home, SETUP_STEPS[key].file))
-  );
-
-  if (pending.length === 0) {
-    clack.log.info("TELOS already configured");
-    return;
-  }
-
-  clack.intro("Personal Context Setup");
-  clack.note(
-    "Answer in a sentence or two — you can edit the files in ~/.pal/telos/ for more detail later.",
-    "Quick setup"
-  );
-
-  for (const key of pending) {
-    const step = SETUP_STEPS[key];
-    const title = key.charAt(0).toUpperCase() + key.slice(1);
-
-    const answer = await clack.text({
-      message: step.question,
-      placeholder: step.hint,
-    });
-
-    if (clack.isCancel(answer)) {
-      clack.cancel("Setup cancelled");
-      return;
-    }
-
-    const filePath = resolve(home, step.file);
-    writeFileSync(filePath, `# ${title}\n\n${answer}\n`, "utf-8");
-  }
-
-  clack.outro("Personal context saved ✓");
-}

package/src/hooks/lib/setup.ts

@@ -1,60 +0,0 @@
-/**
- * Setup state management for PAL first-run wizard.
- *
- * State lives in memory/state/setup.json. Each step maps to a TELOS file.
- * The AI is instructed to mark steps done after writing each file.
- */
-
-import { existsSync, readFileSync } from "node:fs";
-
-interface SetupStep {
-  done: boolean;
-  file: string;
-  question: string;
-  hint: string;
-}
-
-/** Ordered setup steps — defines the wizard flow */
-export const SETUP_STEPS: Record<string, Omit<SetupStep, "done">> = {
-  mission: {
-    file: "telos/MISSION.md",
-    question:
-      "What do you do? What's your role and core purpose? (~/.pal/telos/MISSION.md)",
-    hint: "e.g. Senior software engineer building developer tooling at Acme Corp",
-  },
-  goals: {
-    file: "telos/GOALS.md",
-    question:
-      "What are your current goals? (short-term, medium-term, long-term) (~/.pal/telos/GOALS.md)",
-    hint: "e.g. Ship v2 by Q3, learn Rust, get promoted to staff engineer",
-  },
-  beliefs: {
-    file: "telos/BELIEFS.md",
-    question: "What principles or values guide your work? (~/.pal/telos/BELIEFS.md)",
-    hint: "e.g. Simple code > clever code, ship early and iterate, always write tests",
-  },
-  challenges: {
-    file: "telos/CHALLENGES.md",
-    question: "What are your biggest current challenges? (~/.pal/telos/CHALLENGES.md)",
-    hint: "e.g. Context switching between projects, unclear requirements, work-life balance",
-  },
-};
-
-export const STEP_ORDER = Object.keys(SETUP_STEPS);
-
-/** Check if a TELOS file has real content (not just template scaffolding) */
-export function hasRealContent(filePath: string): boolean {
-  if (!existsSync(filePath)) return false;
-  try {
-    const content = readFileSync(filePath, "utf-8").trim();
-    return content.split("\n").some((l) => {
-      if (!l.trim()) return false;
-      if (l.startsWith("#")) return false;
-      if (l.startsWith("<!--") || l.startsWith("-->")) return false;
-      if (/^\s*-\s*$/.test(l)) return false;
-      return true; // includes table rows (| ... |) — counts as real content
-    });
-  } catch {
-    return false;
-  }
-}