pi-minimal 0.2.2 → 0.3.0

package/test/footer-activity.test.ts

@@ -0,0 +1,93 @@
+import assert from "node:assert/strict"
+import test from "node:test"
+import { visibleWidth } from "@earendil-works/pi-tui"
+import { renderFooterActivity, activityNeedsAnimation } from "../src/footer-activity.js"
+import { ACTIVITY_STATES, type ActivitySnapshot } from "../src/footer-contributions.js"
+
+const theme = { fg: (_color: string, text: string) => text }
+const snapshot = (): ActivitySnapshot => ({ revision: 0, rows: [{ key: "1", agent: "worker", state: "running", text: "Last: tests" }], omitted: 0, motion: "spinner", format: "icons" })
+
+test("matches pi-minimal spinner/check/failure and explicit other state glyphs", () => {
+  const glyphs = ["○", "◐", "!", "Ⅱ", "!", "✓", "✗", "⊘", "?"]
+  for (const [i, state] of ACTIVITY_STATES.entries()) {
+    const input = { ...snapshot(), rows: [{ ...snapshot().rows[0], state }] }
+    const [line] = renderFooterActivity(input, 80, theme, 0)
+    assert.ok(line.startsWith(glyphs[i]+" "), line)
+    const plain = renderFooterActivity({ ...input, format: "plain" }, 80, theme, 1)[0]
+    assert.ok(plain.includes(`[${state}]`))
+  }
+  assert.ok(renderFooterActivity(snapshot(), 80, theme, 1)[0].startsWith("◓"))
+  assert.ok(renderFooterActivity({ ...snapshot(), motion: "static" }, 80, theme, 1)[0].startsWith("◐"))
+})
+
+test("caps rows, reports overflow, and only animates visible running rows", () => {
+  const rows = Array.from({ length: 6 }, (_, i) => ({ key: `${i}`, agent: "agent", state: "completed" as const, text: "Done" }))
+  const input: ActivitySnapshot = { ...snapshot(), rows, omitted: 2 }
+  const lines = renderFooterActivity(input, 80, theme)
+  assert.equal(lines.length, 5)
+  assert.ok(lines[4].includes("4 more"))
+  assert.equal(activityNeedsAnimation(input), false)
+  assert.equal(activityNeedsAnimation({ ...input, rows: [...rows, snapshot().rows[0]] }), false)
+  assert.equal(activityNeedsAnimation(snapshot()), true)
+  assert.equal(activityNeedsAnimation({ ...snapshot(), format: "plain" }), false)
+  assert.equal(activityNeedsAnimation({ ...snapshot(), motion: "static" }), false)
+  assert.deepEqual(renderFooterActivity(undefined, 80, theme), [])
+  assert.deepEqual(renderFooterActivity({ ...snapshot(), rows: [] }, 80, theme), [])
+})
+
+test("bounds Unicode visible widths, strips controls, and limits nested indentation", () => {
+  const input: ActivitySnapshot = { ...snapshot(), rows: [{ key: "p", agent: "工人👩‍💻é", state: "running", text: "\u001b[31mhello\nworld\u001b[0m" },
+    { key: "c", parentKey: "p", agent: "child", state: "running", text: "test" }] }
+  for (const width of [0, 1, 2, 20, 60, 80, 120]) {
+    for (const format of ["icons", "plain"] as const) {
+      for (const line of renderFooterActivity({ ...input, format }, width, theme)) {
+        assert.ok(visibleWidth(line) <= width, `${width}: ${line}`)
+        assert.ok(!line.includes("\n") && !line.includes("\u001b[31m"))
+        // pi-tui adds its own safe SGR reset when truncating plain text.
+        assert.ok(!line.replaceAll("\u001b[0m", "").includes("\u001b"))
+      }
+    }
+  }
+  assert.ok(renderFooterActivity(input, 80, theme)[1].startsWith("  ◐"))
+})
+
+test("right-aligns metrics and drops tokens then time before truncating activity", () => {
+  const input: ActivitySnapshot = { ...snapshot(), rows: [{ ...snapshot().rows[0], metrics: { elapsedMs: 134000, tokens: 8200 }, task: { planId: "P12", id: "T3", status: "in_progress" } }] }
+  const full = renderFooterActivity(input, 80, theme)[0]
+  assert.ok(full.includes("T3 · Last: tests"))
+  assert.ok(full.endsWith("2m 14s · 8.2k tok"))
+  assert.equal(visibleWidth(full), 80)
+  const timeOnly = renderFooterActivity(input, 40, theme)[0]
+  assert.ok(timeOnly.endsWith("2m 14s"), timeOnly)
+  assert.ok(!timeOnly.includes("tok"))
+  const narrow = renderFooterActivity(input, 30, theme)[0]
+  assert.ok(narrow.includes("T3 · Last: tests"))
+  assert.ok(!narrow.includes("2m"))
+})
+
+test("missing metrics are not zero and completed elapsed values do not advance", () => {
+  const input: ActivitySnapshot = { ...snapshot(), rows: [{ ...snapshot().rows[0], state: "completed", metrics: {} }] }
+  assert.ok(renderFooterActivity(input, 80, theme)[0].endsWith("— · — tok"))
+  const ended: ActivitySnapshot = { ...input, rows: [{ ...input.rows[0], metrics: { elapsedMs: 66000, tokens: 0 } }] }
+  assert.ok(renderFooterActivity(ended, 80, theme, 0)[0].endsWith("1m 06s · 0 tok"))
+  assert.equal(renderFooterActivity(ended, 80, theme, 0)[0], renderFooterActivity(ended, 80, theme, 1)[0])
+})
+
+test("task status is independent of agent status and plain mode keeps task labels", () => {
+  for (const [status, marker] of [["blocked", "!"], ["in_review", "◇"], ["done", "✓"]] as const) {
+    const input: ActivitySnapshot = { ...snapshot(), rows: [{ ...snapshot().rows[0], state: "completed", task: { planId: "P12", id: "T3", status } }] }
+    assert.ok(renderFooterActivity(input, 80, theme)[0].includes(`${marker} T3`))
+    const plain = renderFooterActivity({ ...input, format: "plain" }, 100, theme)[0]
+    assert.ok(plain.includes(`[${status}] T3`))
+    assert.ok(plain.includes("[completed]"))
+  }
+})
+
+test("uses current semantic theme and never caches colored text", () => {
+  const colors: string[] = []
+  const themed = { fg: (color: string, text: string) => { colors.push(color); return text } }
+  renderFooterActivity(snapshot(), 80, themed)
+  assert.ok(colors.includes("warning"))
+  const changed = renderFooterActivity(snapshot(), 80, { fg: (_c, text) => `<${text}>` })
+  assert.ok(changed[0].includes("<◐>"))
+})

package/test/footer-composition.test.ts

@@ -0,0 +1,129 @@
+import assert from "node:assert/strict"
+import test from "node:test"
+import { initTheme, type ExtensionContext } from "@earendil-works/pi-coding-agent"
+import { installFooter } from "../src/footer.js"
+import { createFooterContributions, type ActivitySnapshot } from "../src/footer-contributions.js"
+
+initTheme("dark", false)
+
+type Factory = NonNullable<Parameters<ExtensionContext["ui"]["setFooter"]>[0]>
+function fixture() {
+  let factory: Factory | undefined
+  let renders = 0, branchSubscriptions = 0
+  const ctx = { ui: { setFooter: (f: Factory) => { factory = f } }, sessionManager: { getBranch: () => [] } } as unknown as ExtensionContext
+  const args = [
+    { requestRender: () => { renders++ } },
+    { fg: (_color: string, text: string) => text },
+    { onBranchChange: () => { branchSubscriptions++; return () => { branchSubscriptions-- } } },
+  ] as unknown as Parameters<Factory>
+  return { ctx, mount: () => { assert.ok(factory); return factory(...args) },
+    get renders() { return renders }, get branchSubscriptions() { return branchSubscriptions } }
+}
+const data = (revision: number, motion: "spinner" | "static" = "spinner"): ActivitySnapshot => ({
+  revision, rows: [{ key: "1", agent: "worker", state: "running", text: "Last: tests" }], omitted: 0, motion, format: "icons",
+})
+const sources = { busy: () => false, editorText: () => "", contextPct: () => 10 }
+
+test("no contributor preserves existing footer; activity is last even while typing/busy", () => {
+  const f = fixture(), registry = createFooterContributions("S1")
+  installFooter(f.ctx, sources)
+  const baseline = f.mount(); const expected = baseline.render(80); baseline.dispose?.()
+  const dispose = installFooter(f.ctx, sources, registry)
+  const component = f.mount()
+  assert.deepEqual(component.render(80), expected)
+  const result = registry.register({ sessionId: "S1", owner: "activity" }); assert.ok(result.ok)
+  result.registration.publish(data(0, "static"))
+  const lines = component.render(80)
+  assert.deepEqual(lines.slice(0, -1), ["", ...expected, ""])
+  assert.ok(lines.at(-1)?.includes("◐ worker"))
+  dispose(); component.dispose?.()
+  const busyDispose = installFooter(f.ctx, { ...sources, busy: () => true, editorText: () => "draft" }, registry)
+  const busy = f.mount()
+  assert.equal(busy.render(80).length, 2)
+  assert.equal(busy.render(80)[0], "")
+  busyDispose()
+})
+
+test("updates invalidate; replacement disposes old mount but preserves session rows", (t) => {
+  t.mock.timers.enable({ apis: ["setInterval"] })
+  const f = fixture(), registry = createFooterContributions("S1")
+  const result = registry.register({ sessionId: "S1", owner: "activity" }); assert.ok(result.ok)
+  const stop = installFooter(f.ctx, sources, registry)
+  const old = f.mount()
+  result.registration.publish(data(0))
+  const initial = f.renders
+  t.mock.timers.tick(400)
+  assert.equal(f.renders, initial + 1)
+  assert.ok(old.render(80).at(-1)?.includes("◓"))
+  stop(); old.dispose?.()
+  assert.equal(f.branchSubscriptions, 0)
+  const stopped = f.renders
+  t.mock.timers.tick(800)
+  assert.equal(f.renders, stopped)
+  const stopNext = installFooter(f.ctx, sources, registry)
+  const next = f.mount()
+  assert.ok(next.render(80).at(-1)?.includes("worker"))
+  result.registration.publish(data(1, "static"))
+  const staticCount = f.renders
+  t.mock.timers.tick(800)
+  assert.equal(f.renders, staticCount)
+  registry.reset(null)
+  assert.deepEqual(next.render(80), next.render(80).filter(line => !line.includes("worker")))
+  stopNext()
+  assert.equal(f.branchSubscriptions, 0)
+})
+
+test("no spinner timer when terminal has no activity space", (t) => {
+  t.mock.timers.enable({ apis: ["setInterval"] })
+  const f = fixture(), registry = createFooterContributions("S1")
+  const result = registry.register({ sessionId: "S1", owner: "activity" }); assert.ok(result.ok)
+  result.registration.publish(data(0))
+  const stop = installFooter(f.ctx, { ...sources, busy: () => true }, registry)
+  const component = f.mount()
+  component.render(0)
+  const before = f.renders
+  t.mock.timers.tick(800)
+  assert.equal(f.renders, before)
+  component.render(80)
+  t.mock.timers.tick(400)
+  assert.equal(f.renders, before + 1)
+  stop()
+})
+
+test("plan appears between hints and activity with exactly one blank row between groups", () => {
+  const f = fixture(), registry = createFooterContributions("S1")
+  const activity = registry.register({ sessionId: "S1", owner: "activity" })
+  const plan = registry.registerPlan({ sessionId: "S1", owner: "tracker" })
+  assert.ok(activity.ok && plan.ok)
+  activity.registration.publish(data(0, "static"))
+  plan.registration.publish({ revision: 0, format: "icons", plan: { id: "P12", accepted: 3, total: 7, inReview: 1, blocked: 0 } })
+  const stop = installFooter(f.ctx, sources, registry)
+  const component = f.mount()
+  const lines = component.render(80)
+  assert.equal(lines.length, 6)
+  assert.equal(lines[0], "")
+  assert.ok(lines[1].includes("send"))
+  assert.equal(lines[2], "")
+  assert.ok(lines[3].includes("▰▰▰▱▱▱▱ 3/7"))
+  assert.equal(lines[4], "")
+  assert.ok(lines[5].includes("worker"))
+  activity.registration.dispose()
+  assert.equal(component.render(80).length, 4, "no trailing spacer for absent activity")
+  plan.registration.dispose()
+  assert.equal(component.render(80).length, 1, "legacy footer restored without empty groups")
+  stop()
+})
+
+test("legacy task summary precedes activity", () => {
+  const f = fixture(), registry = createFooterContributions("S1")
+  f.ctx.sessionManager.getBranch = () => [{ type: "message", message: { role: "toolResult", toolName: "plan_tracker", details: { tasks: [{ name: "Legacy task", status: "in_progress" }] } } }] as unknown as ReturnType<ExtensionContext["sessionManager"]["getBranch"]>
+  const result = registry.register({ sessionId: "S1", owner: "activity" }); assert.ok(result.ok)
+  result.registration.publish(data(0, "static"))
+  const dispose = installFooter(f.ctx, sources, registry)
+  const component = f.mount()
+  const lines = component.render(80)
+  assert.ok(lines.at(-3)?.includes("Legacy task"))
+  assert.equal(lines.at(-2), "")
+  assert.ok(lines.at(-1)?.includes("worker"))
+  dispose()
+})

package/test/footer-contribution-events.test.ts

@@ -0,0 +1,67 @@
+import assert from "node:assert/strict"
+import test from "node:test"
+import { EventEmitter } from "node:events"
+import { createFooterContributions } from "../src/footer-contributions.js"
+import { bindFooterContributionEvents, FOOTER_EVENTS, type RegisterRequest } from "../src/footer-contribution-events.js"
+
+function bus() {
+  const emitter = new EventEmitter()
+  return { emit: (name: string, value: unknown) => { emitter.emit(name, value) },
+    on: (name: string, handler: (value: unknown) => void) => { emitter.on(name, handler); return () => { emitter.off(name, handler) } } }
+}
+const request = (): RegisterRequest => ({ version: 1, sessionId: "S1", owner: "activity", slot: "activity" })
+
+test("consumer-before-host registers on ready; host-before-consumer registers directly", () => {
+  for (const consumerFirst of [true, false]) {
+    const events = bus(), registry = createFooterContributions(), req = request()
+    const register = () => events.emit(FOOTER_EVENTS.register, req)
+    if (consumerFirst) events.on(FOOTER_EVENTS.ready, register)
+    const dispose = bindFooterContributionEvents(events, registry, "S1", "tui")
+    if (!consumerFirst) register()
+    assert.equal(req.result?.ok, true)
+    dispose()
+    assert.equal(registry.read(), undefined)
+  }
+})
+
+test("rejects foreign session, invalid version/slot and non-TUI requests", () => {
+  const events = bus(), registry = createFooterContributions()
+  let stop = bindFooterContributionEvents(events, registry, "S1", "tui")
+  for (const changes of [{ sessionId: "S2" }, { version: 2 }, { slot: "sidebar" }]) {
+    const req = { ...request(), ...changes }
+    events.emit(FOOTER_EVENTS.register, req)
+    assert.equal(req.result?.ok, false)
+  }
+  stop()
+  stop = bindFooterContributionEvents(events, registry, "S1", "print")
+  const req = request(); events.emit(FOOTER_EVENTS.register, req)
+  assert.deepEqual(req.result, { ok: false, code: "not-tui" })
+  stop()
+})
+
+test("summary and activity register independently through the public event", () => {
+  const events = bus(), registry = createFooterContributions()
+  const stop = bindFooterContributionEvents(events, registry, "S1", "tui")
+  const activity = request(), plan: RegisterRequest = { ...request(), slot: "summary", owner: "tracker" }
+  events.emit(FOOTER_EVENTS.register, activity)
+  events.emit(FOOTER_EVENTS.register, plan)
+  assert.ok(activity.result?.ok && plan.result?.ok)
+  assert.ok(plan.result.registration.publish({ revision: 0, format: "icons", plan: { id: "P12", accepted: 3, total: 7, inReview: 1, blocked: 0 } }).ok)
+  assert.equal(registry.readPlan()?.plan?.accepted, 3)
+  stop()
+})
+
+test("shutdown removes listeners, invalidates handles and emits unavailable once", () => {
+  const events = bus(), registry = createFooterContributions()
+  let unavailable = 0
+  events.on(FOOTER_EVENTS.unavailable, () => { unavailable++ })
+  const stop = bindFooterContributionEvents(events, registry, "S1", "tui")
+  const req = request(); events.emit(FOOTER_EVENTS.register, req)
+  assert.ok(req.result?.ok)
+  const handle = req.result.registration
+  stop(); stop()
+  assert.equal(unavailable, 1)
+  const fresh = request(); events.emit(FOOTER_EVENTS.register, fresh)
+  assert.equal(fresh.result, undefined)
+  assert.deepEqual(handle.publish({}), { ok: false, code: "disposed" })
+})

package/test/footer-contributions.test.ts

@@ -0,0 +1,105 @@
+import assert from "node:assert/strict"
+import test from "node:test"
+import { createFooterContributions, type ActivitySnapshot } from "../src/footer-contributions.js"
+
+const snapshot = (revision = 0): ActivitySnapshot => ({
+  revision, rows: [{ key: "child", agent: "worker", state: "running", text: "Last: tests" }],
+  omitted: 0, motion: "spinner", format: "icons",
+})
+
+function owner() {
+  const registry = createFooterContributions("S1")
+  const result = registry.register({ sessionId: "S1", owner: "activity" })
+  assert.equal(result.ok, true)
+  return { registry, handle: result.registration }
+}
+
+test("empty registry, exclusive ownership and immutable snapshots", () => {
+  const { registry, handle } = owner()
+  assert.equal(registry.read(), undefined)
+  assert.deepEqual(registry.register({ sessionId: "S2", owner: "other" }), { ok: false, code: "wrong-session" })
+  assert.deepEqual(registry.register({ sessionId: "S1", owner: "other" }), { ok: false, code: "occupied" })
+  const input = snapshot()
+  assert.deepEqual(handle.publish(input), { ok: true })
+  assert.notEqual(registry.read(), input)
+  assert.ok(Object.isFrozen(registry.read()))
+  assert.ok(Object.isFrozen(registry.read()?.rows[0]))
+  assert.ok(Object.isFrozen(registry.read()?.rows))
+})
+
+test("rejects stale revisions and invalid payloads without replacing last good state", () => {
+  const { registry, handle } = owner()
+  handle.publish(snapshot(2))
+  const good = registry.read()
+  for (const invalid of [null, {}, snapshot(1), snapshot(2), { ...snapshot(3), revision: Infinity },
+    { ...snapshot(3), omitted: -1 }, { ...snapshot(3), motion: "fast" },
+    { ...snapshot(3), rows: [{ ...snapshot().rows[0], state: "invented" }] },
+    { ...snapshot(3), rows: Array(65).fill(snapshot().rows[0]) },
+    { ...snapshot(3), rows: [snapshot().rows[0], snapshot().rows[0]] },
+    { ...snapshot(3), rows: [{ ...snapshot().rows[0], agent: "a".repeat(97) }] },
+    { ...snapshot(3), rows: [{ ...snapshot().rows[0], parentKey: "missing" }] },
+    { ...snapshot(3), rows: [{ ...snapshot().rows[0], parentKey: "child" }] },
+    { ...snapshot(3), rows: [{ key: "a", parentKey: "b", agent: "x", text: "", state: "running" }, { key: "b", parentKey: "a", agent: "y", text: "", state: "running" }] },
+  ]) {
+    assert.equal(handle.publish(invalid).ok, false)
+    assert.equal(registry.read(), good)
+  }
+})
+
+test("sanitizes display controls, retains Unicode and clones caller data", () => {
+  const { registry, handle } = owner()
+  const input = { ...snapshot(), rows: [{ key: "c", agent: "工人", state: "running", text: "\u001b[31mtests\u001b[0m\nnext\u001b]0;evil\u0007\u202e" }] }
+  assert.equal(handle.publish(input).ok, true)
+  input.rows[0].text = "changed"
+  assert.equal(registry.read()?.rows[0].text, "tests next")
+  assert.equal(registry.read()?.rows[0].agent, "工人")
+})
+
+test("reset and stale disposer cannot change a newer owner, including the same session ID", () => {
+  const { registry, handle } = owner()
+  handle.publish(snapshot())
+  registry.reset("S1")
+  const next = registry.register({ sessionId: "S1", owner: "activity" })
+  assert.ok(next.ok)
+  if (!next.ok) return
+  next.registration.publish(snapshot(0))
+  handle.dispose()
+  assert.equal(handle.publish(snapshot(99)).ok, false)
+  assert.ok(registry.read())
+  next.registration.dispose()
+  next.registration.dispose()
+  assert.equal(registry.read(), undefined)
+  registry.reset(null)
+  assert.equal(registry.register({ sessionId: "S1", owner: "activity" }).ok, false)
+})
+
+test("optional metrics and task links are validated, cloned and frozen", () => {
+  const { registry, handle } = owner()
+  const input = { ...snapshot(), rows: [{ ...snapshot().rows[0], metrics: { elapsedMs: 134000, tokens: 8200 }, task: { planId: "P12", id: "T3", status: "in_review" } }] }
+  assert.ok(handle.publish(input).ok)
+  assert.deepEqual(registry.read()?.rows[0].metrics, input.rows[0].metrics)
+  assert.deepEqual(registry.read()?.rows[0].task, input.rows[0].task)
+  assert.ok(Object.isFrozen(registry.read()?.rows[0].metrics))
+  assert.ok(Object.isFrozen(registry.read()?.rows[0].task))
+  input.rows[0].metrics.tokens = 9000
+  assert.equal(registry.read()?.rows[0].metrics?.tokens, 8200)
+  for (const fields of [
+    { metrics: { tokens: -1 } }, { metrics: { tokens: 1.5 } }, { metrics: { elapsedMs: Infinity } },
+    { metrics: null }, { task: { id: "T3", status: "done" } },
+    { task: { planId: "P12", id: "T3", status: "invented" } },
+  ]) assert.equal(handle.publish({ ...snapshot(1), rows: [{ ...snapshot().rows[0], ...fields }] }).ok, false)
+  assert.ok(handle.publish({ ...snapshot(1), rows: [{ ...snapshot().rows[0], metrics: {} }] }).ok)
+})
+
+test("subscriptions observe valid changes only; one failing observer cannot break publication", () => {
+  const { registry, handle } = owner()
+  let changes = 0
+  const stop = registry.subscribe(() => { changes++ })
+  const stopBad = registry.subscribe(() => { throw new Error("disposed UI") })
+  assert.equal(handle.publish(snapshot()).ok, true)
+  handle.publish(snapshot())
+  assert.equal(changes, 1)
+  stop(); stopBad()
+  handle.dispose()
+  assert.equal(changes, 1)
+})

package/test/footer-plan.test.ts

@@ -0,0 +1,53 @@
+import assert from "node:assert/strict"
+import test from "node:test"
+import { visibleWidth } from "@earendil-works/pi-tui"
+import { createFooterContributions } from "../src/footer-contributions.js"
+import { renderFooterPlan, type PlanSnapshot } from "../src/footer-plan.js"
+
+const sample: PlanSnapshot = { revision: 0, format: "icons", plan: { id: "P12", accepted: 3, total: 7, inReview: 1, blocked: 1 } }
+const theme = { fg: (_color: string, text: string) => text }
+
+test("plan slot is independent of activity and rejects invalid/stale snapshots", () => {
+  const registry = createFooterContributions("S1")
+  const activity = registry.register({ sessionId: "S1", owner: "activity" })
+  const result = registry.registerPlan({ sessionId: "S1", owner: "tracker" })
+  assert.ok(activity.ok && result.ok)
+  assert.ok(result.registration.publish(sample).ok)
+  assert.deepEqual(registry.readPlan(), sample)
+  assert.ok(Object.isFrozen(registry.readPlan()?.plan))
+  for (const payload of [sample, { ...sample, revision: 1, plan: { ...sample.plan, accepted: 8 } },
+    { ...sample, revision: 1, plan: { ...sample.plan, total: -1 } },
+    { ...sample, revision: 1, plan: { ...sample.plan, id: "bad\nlabel" } },
+    { ...sample, revision: 1, plan: { ...sample.plan, inReview: 9 } },
+    { ...sample, revision: 1, format: "html" }]) assert.equal(result.registration.publish(payload).ok, false)
+  assert.equal(registry.read(), undefined)
+  assert.ok(result.registration.publish({ revision: 1, format: "plain" }).ok)
+  assert.equal(registry.readPlan()?.plan, undefined)
+  registry.reset("S2")
+  assert.equal(result.registration.publish({ ...sample, revision: 3 }).ok, false)
+  assert.equal(registry.readPlan(), undefined)
+})
+
+test("violet slanted segments and exact count, with bounded large-plan progress", () => {
+  const calls: string[] = []
+  const colored = { fg: (color: string, text: string) => { calls.push(`${color}:${text}`); return text } }
+  const [line] = renderFooterPlan(sample, 80, colored)
+  assert.ok(line.includes("▰▰▰▱▱▱▱ 3/7"))
+  assert.ok(calls.includes("accent:▰▰▰"))
+  assert.ok(calls.includes("accent:Plan P12"))
+  assert.ok(calls.includes("muted:▱▱▱▱"))
+  const large = renderFooterPlan({ ...sample, plan: { id: "P12", accepted: 27, total: 100, inReview: 0, blocked: 0 } }, 80, theme)[0]
+  assert.ok(large.includes("▰▰▱▱▱▱▱▱▱▱ 27/100"))
+  assert.ok(renderFooterPlan({ ...sample, format: "plain" }, 80, theme)[0].includes("###.... 3/7"))
+})
+
+test("narrow layout drops segments before counts; empty plans and missing contributions are distinct", () => {
+  const narrow = renderFooterPlan(sample, 45, theme)[0]
+  assert.ok(!narrow.includes("▰") && narrow.includes("3/7"))
+  for (const width of [0, 1, 20, 40, 60, 80, 120]) {
+    for (const line of renderFooterPlan(sample, width, theme)) assert.ok(visibleWidth(line) <= width)
+  }
+  assert.deepEqual(renderFooterPlan(undefined, 80, theme), [])
+  assert.deepEqual(renderFooterPlan({ revision: 0, format: "icons" }, 80, theme), [])
+  assert.ok(renderFooterPlan({ ...sample, plan: { id: "P12", accepted: 0, total: 0, inReview: 0, blocked: 0 } }, 80, theme)[0].includes("No tasks yet"))
+})

package/test/index.test.ts

@@ -9,6 +9,8 @@ import {
 	type ExtensionContext,
 } from "@earendil-works/pi-coding-agent"
 import install from "../src/index.js"
+import { EventEmitter } from "node:events"
+import { FOOTER_EVENTS, type RegisterRequest } from "../src/footer-contribution-events.js"
 
 type Call = { method: string; args: unknown[] }
 type SessionMode = "tui" | "rpc" | "json" | "print"
@@ -44,6 +46,11 @@ function createFake(options: {
 	const execCalls: Call[] = []
 	const registerCalls: Call[] = []
 	const allCalls: Call[] = []
+	const emitter = new EventEmitter()
+	const events = {
+		emit: (name: string, value: unknown) => { emitter.emit(name, value) },
+		on: (name: string, handler: (value: unknown) => void) => { emitter.on(name, handler); return () => { emitter.off(name, handler) } },
+	}
 
 	const record = (target: Call[], method: string, args: unknown[]) => {
 		const call = { method, args }
@@ -66,11 +73,12 @@ function createFake(options: {
 		mode: options.mode ?? "tui",
 		cwd: options.cwd,
 		isProjectTrusted: () => options.projectTrusted ?? false,
-		sessionManager: { getBranch: () => [] },
+		sessionManager: { getBranch: () => [], getSessionId: () => "S1" },
 		ui,
 	} as unknown as ExtensionContext
 
 	const pi = {
+		events,
 		on(event: string, handler: (event: unknown, ctx: ExtensionContext) => unknown) {
 			const list = handlers.get(event) ?? []
 			list.push(handler)
@@ -110,7 +118,7 @@ function createFake(options: {
 		}
 	}
 
-	return { pi, ctx, uiCalls, execCalls, registerCalls, allCalls, emit }
+	return { pi, ctx, uiCalls, execCalls, registerCalls, allCalls, emit, events }
 }
 
 function widgetCalls(uiCalls: Call[], key: string): Call[] {
@@ -275,6 +283,31 @@ test.describe("session chrome", { concurrency: 1 }, () => {
 	})
 })
 
+test("footer registration survives chrome reinstalls and becomes inert on shutdown", async (t) => {
+	const { agentDir, cwd } = setupDirs(t)
+	process.env[AGENT_DIR_ENV] = agentDir
+	delete process.env.HERDR_ENV
+	t.after(restoreEnv)
+	const { pi, emit, events, uiCalls } = createFake({ cwd })
+	install(pi)
+	t.after(() => emit("session_shutdown"))
+	await emit("session_start")
+	const req: RegisterRequest = { version: 1, owner: "activity", sessionId: "S1", slot: "activity" }
+	events.emit(FOOTER_EVENTS.register, req)
+	assert.ok(req.result?.ok)
+	const handle = req.result.registration
+	const data = { revision: 0, rows: [], omitted: 0, motion: "static", format: "icons" }
+	assert.equal(handle.publish(data).ok, true)
+	await emit("turn_end")
+	await emit("tool_execution_end")
+	assert.equal(handle.publish({ ...data, revision: 1 }).ok, true)
+	await emit("session_shutdown")
+	assert.equal(handle.publish({ ...data, revision: 2 }).ok, false)
+	const count = uiCalls.length
+	await new Promise(resolve => setTimeout(resolve, 70))
+	assert.equal(uiCalls.length, count, "settle callbacks must not reinstall after shutdown")
+})
+
 test("agent_end appends a turn summary entry in TUI mode", async (t) => {
 	const { agentDir, cwd } = setupDirs(t)
 	process.env[AGENT_DIR_ENV] = agentDir

package/test/package.test.ts

@@ -5,7 +5,11 @@ import { readFileSync } from "node:fs"
 test("package manifest exposes the committed extension", () => {
 	const pkg = JSON.parse(readFileSync("package.json", "utf8"))
 	assert.equal(pkg.name, "pi-minimal")
-	assert.equal(pkg.version, "0.2.2")
+	assert.equal(pkg.version, "0.3.0")
+	const lock = JSON.parse(readFileSync("package-lock.json", "utf8"))
+	assert.equal(lock.version, pkg.version, "lockfile root version matches package")
+	assert.equal(lock.packages[""].version, pkg.version, "lockfile package version matches package")
+	assert.ok(readFileSync("CHANGELOG.md", "utf8").includes(`## [${pkg.version}] - `), "version has a dated release entry")
 	assert.equal(pkg.license, "MIT")
 	assert.equal(pkg.type, "module")
 	assert.deepEqual(pkg.engines, { node: ">=22.19.0" })

package/test/theme.test.ts

@@ -43,3 +43,31 @@ test("minimal-dark frames code quietly and neutralises tool backgrounds", () =>
 	assert.equal(theme.colors.toolSuccessBg, theme.colors.toolPendingBg)
 	assert.notEqual(theme.colors.mdHeading, theme.colors.warning)
 })
+
+const lightness = (value: string) => {
+	const resolved = value in theme.vars ? theme.vars[value] : value
+	const m = /okhsl\(\s*[\d.]+\s+[\d.]+%\s+([\d.]+)%\s*\)/.exec(resolved)
+	assert.ok(m, `okhsl literal for ${value}`)
+	return Number(m![1]) / 100
+}
+
+test("minimal-dark keeps a readable grey ladder: text > muted > thinking > dim > faint", () => {
+	const ladder = [theme.vars.text, theme.vars.muted, theme.colors.thinkingText, theme.vars.dim, theme.vars.faint].map(lightness)
+	for (let i = 1; i < ladder.length; i++) assert.ok(ladder[i] < ladder[i - 1], `step ${i}: ${ladder.join(" > ")}`)
+	// Readable tiers stay at or above L .56 (~4.4:1 on bg L .11, estimating Y ≈ L³).
+	assert.ok(lightness(theme.vars.dim) >= 0.56)
+	assert.ok(lightness(theme.colors.thinkingText) >= 0.56)
+})
+
+test("minimal-dark keeps status hues out of syntax colours", () => {
+	const status = new Set([theme.colors.success, theme.colors.warning, theme.colors.error])
+	for (const role of ["syntaxFunction", "syntaxNumber", "syntaxString", "syntaxVariable"]) {
+		assert.ok(!status.has(theme.colors[role]), `${role} reuses a status colour`)
+	}
+})
+
+test("minimal-dark draws no slab behind tool rows; only failures get a background", () => {
+	assert.equal(theme.colors.toolSuccessBg, "bg")
+	assert.equal(theme.colors.toolPendingBg, "bg")
+	assert.notEqual(theme.colors.toolErrorBg, "bg")
+})