@hraness/slopcamera 3.7.0 → 3.8.1

package/apps/desktop/README.md

@@ -1,6 +1,6 @@
 # SlopCamera local host and CLI
 
-Slopcamera reads finished recording bundles from repository-local directories, combines independent camera and audio takes on one typed project clock, then applies non-destructive edits through the `slopcamera` CLI. The CLI is the product surface for agents. An optional unbundled `slopcamera menubar` companion surfaces the agent outputs directory in the macOS menu bar; it carries no capture or editing authority.
+Slopcamera reads finished recording bundles from repository-local directories, combines independent camera and audio takes on one typed project clock, then applies non-destructive edits through the `slopcamera` CLI. The CLI is the product surface for agents. `slopcamera status` and `slopcamera tui` show what is running, credits and the newest agent outputs in the terminal.
 
 ## Recording bundles
 
@@ -819,13 +819,6 @@ bun run test:html-overlay
 bun run benchmark:code-concurrency
 ```
 
-The optional Rust menu-bar companion lives under `desktop/` at the repository root and builds with Cargo:
-
-```sh
-cargo build --manifest-path desktop/menubar/Cargo.toml
-slopcamera menubar
-```
-
 `test:html-overlay` is portable and leaves the real-browser tests registered as
 skipped. `test:html-overlay:browser:macos` runs the real Chrome frame suite,
 including a declared PNG. `test:html-overlay:libraries:macos` additionally
@@ -847,4 +840,4 @@ The compiled smoke copies the executable away from the checkout and proves
 diagram initialization/rendering plus PNG-to-SVG vectorization without
 `node_modules`.
 
-Screen recording, microphone, camera, Input Monitoring, and Accessibility are separate macOS permissions. A missing optional source becomes a typed diagnostic; strict-input mode fails before recording begins. Slopcamera ships as a CLI with an unbundled menu-bar companion; it does not produce, install, sign, or notarize a desktop application.
+Screen recording, microphone, camera, Input Monitoring, and Accessibility are separate macOS permissions. A missing optional source becomes a typed diagnostic; strict-input mode fails before recording begins. Slopcamera ships as a CLI; it does not produce, install, sign, or notarize a desktop application.

package/apps/desktop/application/html-overlay-integrity.ts

@@ -24,6 +24,9 @@ import {
 } from "./html-overlay-browser-runtime";
 
 const Sha256Schema = z.string().regex(/^[a-f0-9]{64}$/u);
+const ExecutionContractVersionSchema = z.union([z.literal(1), z.literal(2)]);
+export type HtmlOverlayExecutionContractVersion = z.infer<typeof ExecutionContractVersionSchema>;
+
 const IntegrityLeafSchema = z.strictObject({
   key: z.string().min(1).max(512),
   sha256: Sha256Schema,
@@ -44,7 +47,7 @@ export const HtmlOverlayExecutionIntegritySchema = z.strictObject({
   }),
   rootSha256: Sha256Schema,
   runtimeSha256: Sha256Schema,
-  schemaVersion: z.literal(1),
+  schemaVersion: ExecutionContractVersionSchema,
 });
 export type HtmlOverlayExecutionIntegrity = Readonly<
   z.infer<typeof HtmlOverlayExecutionIntegritySchema>
@@ -185,7 +188,7 @@ function legacyHtmlOverlayRendererContract(profileInput?: HtmlOverlayExecutionPr
 }
 
 /** Fetch opt-in grants only the exact declared private paths and changes execution identity. */
-export function htmlOverlayRendererContract(
+function historicalHtmlOverlayRendererContract(
   profileInput?: HtmlOverlayExecutionProfile,
   resourcesInput: readonly HtmlOverlayDeclaredResource[] = [],
 ) {
@@ -204,6 +207,25 @@ export function htmlOverlayRendererContract(
   });
 }
 
+/** Historical receipts select v1 explicitly; all new execution binds clone prevention. */
+export function htmlOverlayRendererContract(
+  profileInput?: HtmlOverlayExecutionProfile,
+  resourcesInput: readonly HtmlOverlayDeclaredResource[] = [],
+  version: HtmlOverlayExecutionContractVersion = 2,
+) {
+  const contract = historicalHtmlOverlayRendererContract(profileInput, resourcesInput);
+  if (ExecutionContractVersionSchema.parse(version) === 1) return contract;
+  return Object.freeze({
+    ...contract,
+    launch: Object.freeze({
+      ...contract.launch,
+      args: Object.freeze(contract.launch.args.map(argument => argument.startsWith("--disable-features=")
+        ? `${argument},PaintHolding,MacAppCodeSignClone` : argument)),
+    }),
+    schemaVersion: 4,
+  });
+}
+
 export function assertHtmlOverlayExecutionProfileLibraries(
   libraries: readonly string[], profile?: HtmlOverlayExecutionProfile,
 ): void {
@@ -258,6 +280,7 @@ export function createHtmlOverlayExecutionBundle(
   authoringInput: HtmlOverlayAuthoringInput,
   browserRuntimeInput: HtmlOverlayBrowserRuntimeBinding,
   executionProfile?: HtmlOverlayExecutionProfile,
+  contractVersion: HtmlOverlayExecutionContractVersion = 2,
 ): HtmlOverlayExecutionBundle {
   const authoring = HtmlOverlayAuthoringInputSchema.parse(authoringInput);
   assertHtmlOverlayExecutionProfileLibraries(authoring.libraries, executionProfile);
@@ -290,7 +313,7 @@ export function createHtmlOverlayExecutionBundle(
       },
     },
     { key: "browser-runtime", value: browserRuntime },
-    { key: "renderer-contract", value: htmlOverlayRendererContract(executionProfile, authoring.resources) },
+    { key: "renderer-contract", value: htmlOverlayRendererContract(executionProfile, authoring.resources, contractVersion) },
     {
       key: "document",
       value: {
@@ -326,7 +349,7 @@ export function createHtmlOverlayExecutionBundle(
     leaves,
     rootSha256: merkleRoot(leaves),
     runtimeSha256,
-    schemaVersion: 1,
+    schemaVersion: contractVersion,
   });
   return Object.freeze({
     importMap,

package/apps/desktop/application/operation.ts

@@ -4,7 +4,7 @@ import type { z } from "zod";
 
 import type { ApplicationContext } from "./context";
 
-export const SLOPCAMERA_APPLICATION_TOOL_VERSION = "slopcamera-3.7.0" as const;
+export const SLOPCAMERA_APPLICATION_TOOL_VERSION = "slopcamera-3.8.1" as const;
 
 export const OPERATION_KINDS = [
   "scene.audit",

package/apps/desktop/application/operations/spatial-render.ts

@@ -381,7 +381,7 @@ export async function recoverSpatialRenderOutput(application: ApplicationContext
       mode: plan.request.mode, frameRate: plan.request.selection.kind === "video" ? plan.request.selection.frameRate : { numerator: 1, denominator: 1 }, preparedAssets: batch.preparedAssets });
     equal(batch.metadata, expectedBatch.metadata, "Spatial batch metadata differs from the exact scene samples.");
     equal(batch.metadataSha256, expectedBatch.metadataSha256, "Spatial batch metadata digest is invalid.");
-    const execution = createHtmlOverlayExecutionBundle(expectedBatch.authoring, input.browserRuntime, plan.request.executionProfile);
+    const execution = createHtmlOverlayExecutionBundle(expectedBatch.authoring, input.browserRuntime, plan.request.executionProfile, batch.executionIntegrity.schemaVersion);
     assertHtmlOverlayGpuEvidenceProfile(plan.request.executionProfile, batch.gpuEvidence);
     equal(batch.gpuEvidence, receipt.runtime.gpuEvidence, "Spatial batch hardware identity differs from its completion receipt.");
     equal(batch.executionIntegrity, execution.integrity, "Spatial batch execution integrity differs from its exact authored runtime.");

package/apps/desktop/application/spatial-assets.ts

@@ -459,7 +459,7 @@ export async function withPreparedSpatialAssets<Result>(
     }
     const decoded = await raster(bytes, interpretation.alpha === "opaque");
     if (decoded.width !== interpretation.width || decoded.height !== interpretation.height) throw new RangeError("Image dimensions differ from its interpretation.");
-    profiles.add("sdr-png-jpeg-sharp-0.35.3");
+    profiles.add("sdr-png-jpeg-sharp-0.35.4");
     return publishRaster(decoded);
   };
   const native = async (argv: readonly [string, ...string[]], maxOutputBytes = 16_384) => {

package/apps/desktop/cli/{menubar-status.ts → activity-status.ts}

@@ -5,18 +5,20 @@ import { join } from "node:path";
 import type { CliCommand } from "./args";
 
 /**
- * The small status file the menu bar reads: what Slopcamera is doing now,
+ * The small status file `slopcamera status` and `slopcamera tui` read: what Slopcamera is doing now,
  * how the last render ended, and the last credits balance a command saw.
  * It holds plain labels, times and fixed error codes only — never paths,
  * prompts, tokens or account identifiers. Writes are best effort: a status
  * that can't be saved never fails the command.
  */
-export const MENUBAR_STATUS_FILE = "menubar-status.json";
+// The on-disk name predates the menu bar's retirement and stays frozen, so a
+// rolled-back release and existing state keep reading the same file.
+export const ACTIVITY_STATUS_FILE = "menubar-status.json";
 const MAX_STATUS_BYTES = 16 * 1024;
 
 export type ActivityState = "running" | "done" | "failed";
 
-export interface MenubarActivity {
+export interface RecordedActivity {
   readonly state: ActivityState;
   readonly label: string;
   readonly startedAt: number;
@@ -24,16 +26,16 @@ export interface MenubarActivity {
   readonly error?: string;
 }
 
-export interface MenubarCredits {
+export interface RecordedCredits {
   readonly usd: string;
   readonly low: boolean;
   readonly checkedAt: number;
 }
 
-export interface MenubarStatus {
+export interface ActivityStatus {
   readonly schemaVersion: 1;
-  readonly activity?: MenubarActivity;
-  readonly credits?: MenubarCredits;
+  readonly activity?: RecordedActivity;
+  readonly credits?: RecordedCredits;
 }
 
 /** Plain labels for the commands that make media. Everything else leaves the status alone. */
@@ -58,13 +60,13 @@ export function activityLabel(command: CliCommand): string | undefined {
   }
 }
 
-function parse(text: string): MenubarStatus {
+function parse(text: string): ActivityStatus {
   try {
     const value: unknown = JSON.parse(text);
     if (typeof value !== "object" || value === null || (value as { schemaVersion?: unknown }).schemaVersion !== 1) return { schemaVersion: 1 };
     const record = value as Record<string, unknown>;
-    const activity = record.activity as MenubarActivity | undefined;
-    const credits = record.credits as MenubarCredits | undefined;
+    const activity = record.activity as RecordedActivity | undefined;
+    const credits = record.credits as RecordedCredits | undefined;
     return {
       schemaVersion: 1,
       ...(activity !== undefined && typeof activity === "object" && typeof activity.label === "string" ? { activity } : {}),
@@ -75,8 +77,8 @@ function parse(text: string): MenubarStatus {
   }
 }
 
-export function readMenubarStatus(stateRoot: string): MenubarStatus {
-  const path = join(stateRoot, MENUBAR_STATUS_FILE);
+export function readActivityStatus(stateRoot: string): ActivityStatus {
+  const path = join(stateRoot, ACTIVITY_STATUS_FILE);
   try {
     const info = lstatSync(path);
     if (!info.isFile() || info.size > MAX_STATUS_BYTES) return { schemaVersion: 1 };
@@ -86,7 +88,7 @@ export function readMenubarStatus(stateRoot: string): MenubarStatus {
   }
 }
 
-const LOCK_FILE = `.${MENUBAR_STATUS_FILE}.lock`;
+const LOCK_FILE = `.${ACTIVITY_STATUS_FILE}.lock`;
 /** A held lock blocks a write for this long before it is skipped. */
 const LOCK_BUDGET_MS = 250;
 /** A lock older than this is a crashed writer's and is reclaimed. */
@@ -128,14 +130,14 @@ function withStatusLock<T>(stateRoot: string, update: () => T): T | undefined {
 }
 
 /** Replaces the status file atomically with an owner-only file. Never throws. */
-export function writeMenubarStatus(stateRoot: string, update: (current: MenubarStatus) => MenubarStatus): void {
+export function writeActivityStatus(stateRoot: string, update: (current: ActivityStatus) => ActivityStatus): void {
   withStatusLock(stateRoot, () => {
-    const path = join(stateRoot, MENUBAR_STATUS_FILE);
-    const staged = join(stateRoot, `.${MENUBAR_STATUS_FILE}.${randomUUID()}.tmp`);
+    const path = join(stateRoot, ACTIVITY_STATUS_FILE);
+    const staged = join(stateRoot, `.${ACTIVITY_STATUS_FILE}.${randomUUID()}.tmp`);
     try {
       const root = lstatSync(stateRoot);
       if (!root.isDirectory()) return;
-      const text = `${JSON.stringify(update(readMenubarStatus(stateRoot)))}\n`;
+      const text = `${JSON.stringify(update(readActivityStatus(stateRoot)))}\n`;
       if (Buffer.byteLength(text) > MAX_STATUS_BYTES) return;
       const fd = openSync(staged, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
       try { writeSync(fd, text); } finally { closeSync(fd); }
@@ -147,10 +149,10 @@ export function writeMenubarStatus(stateRoot: string, update: (current: MenubarS
   });
 }
 
-export function recordActivity(stateRoot: string, activity: MenubarActivity): void {
-  writeMenubarStatus(stateRoot, (current) => ({ ...current, activity }));
+export function recordActivity(stateRoot: string, activity: RecordedActivity): void {
+  writeActivityStatus(stateRoot, (current) => ({ ...current, activity }));
 }
 
-export function recordCredits(stateRoot: string, credits: MenubarCredits): void {
-  writeMenubarStatus(stateRoot, (current) => ({ ...current, credits }));
+export function recordCredits(stateRoot: string, credits: RecordedCredits): void {
+  writeActivityStatus(stateRoot, (current) => ({ ...current, credits }));
 }

package/apps/desktop/cli/args.ts

@@ -335,7 +335,6 @@ export type CliCommand =
       readonly tint: number | undefined;
       readonly videoStreamIndex: number;
     } & JsonOption)
-  | ({ readonly kind: "menubar"; readonly action: "run" | "install" | "uninstall" | "status"; readonly mode: "foreground" | "background" } & JsonOption)
   | ({ readonly kind: "outputs" } & JsonOption)
   | ({ readonly kind: "credits-status" } & JsonOption)
   | ({
@@ -3716,15 +3715,8 @@ export function parseCliArgs(argv: readonly string[]): CliCommand {
     case "project": return parseProject(argv.slice(1));
     case "inspect": return parseInspect(argv.slice(1));
     case "events": return parseEvents(argv.slice(1));
-    case "menubar": {
-      const parsed = parseOptions(argv.slice(1), { ...JSON_SPEC, "--foreground": "flag", "--background": "flag" });
-      const positionals = parsed.positionals;
-      if (positionals.length > 1 || (positionals[0] !== undefined && !["install", "uninstall", "status", "start"].includes(positionals[0]))) throw new CliError("usage", "Use slopcamera menubar [--foreground|--background] or slopcamera menubar install|uninstall|status|start. See slopcamera help menubar.");
-      if (positionals[0] !== undefined && (optionFlag(parsed, "--foreground") || optionFlag(parsed, "--background"))) throw new CliError("usage", "Choose a menu-bar action or a run mode, not both.");
-      // `start` opens it now and returns, like --background; the login item's hints use it.
-      if (positionals[0] === "start") return { kind: "menubar", action: "run", mode: "background", json: optionFlag(parsed, "--json") };
-      return { kind: "menubar", action: (positionals[0] as "install" | "uninstall" | "status" | undefined) ?? "run", mode: optionFlag(parsed, "--background") ? "background" : "foreground", json: optionFlag(parsed, "--json") };
-    }
+    // Retired with the menu-bar companion; the old command name explains where it went.
+    case "menubar": throw new CliError("usage", "The menu bar was retired. Use slopcamera status or slopcamera tui to see what Slopcamera is doing, and slopcamera legacy retire to stop an old copy opening at login.");
     case "outputs": {
       const parsed = parseOptions(argv.slice(1), JSON_SPEC);
       exactPositionals(parsed, 0, "slopcamera outputs [--json]");

package/apps/desktop/cli/command-host-resources.ts

@@ -266,7 +266,6 @@ export function commandHostResourceClaims(
     case "help":
     case "capabilities":
     case "inspect":
-    case "menubar":
     case "operations-list":
     case "operations-show":
     case "outputs":

package/apps/desktop/cli/commands.ts

@@ -1,4 +1,4 @@
-import { activityLabel, recordActivity, recordCredits } from "./menubar-status";
+import { activityLabel, recordActivity, recordCredits } from "./activity-status";
 import { reportUsefulResult, type UsefulResultObserver } from "../../../src/support-completion";
 import { SlopcameraCloudError } from "../../../src/cloud-errors";
 import {
@@ -190,7 +190,8 @@ import { PlaywrightHtmlOverlayRenderer } from "./html-overlay-renderer";
 import { executeHtmlSceneCommand } from "./html-scene";
 import { executeHtmlFilmCommand, formatHtmlFilmResult } from "./html-film";
 import { BunProcessRunner, processIo, writeJson, writeLine, type CliIo, type ProcessRunner } from "./io";
-import { launchMenubar, manageMenubar, reportOutputsRoot } from "./menubar";
+import { reportOutputsRoot } from "./outputs";
+import { inspectLegacyLogin, retiredLegacyLogins } from "./legacy-login";
 import {
   codePreparationHostResourceClaims,
   combineHostResourceClaims,
@@ -364,7 +365,7 @@ import {
   workflowRunStore,
 } from "./workflow-runs";
 
-export const SLOPCAMERA_VERSION = "3.7.0";
+export const SLOPCAMERA_VERSION = "3.8.1";
 
 // Legacy direct renders predate per-target output contracts. Keep them
 // bounded generously enough for long-form production while preventing one
@@ -7984,6 +7985,10 @@ async function dispatch(context: CommandContext, command: CliCommand): Promise<v
         platform: { architecture: process.arch, macOSVersion: macVersion.stdout.trim(), name: context.io.platform },
         repositoryRoot: context.paths.repositoryRoot,
         tools: Object.fromEntries(capabilities.map((capability) => [capability.name, capability])),
+        legacyLoginItem: {
+          ...inspectLegacyLogin(context.io.env.HOME),
+          retired: retiredLegacyLogins(context.io.env.HOME),
+        },
         version: context.version,
       };
       writeValue(context.io, command.json, output, () => [
@@ -7992,6 +7997,12 @@ async function dispatch(context: CommandContext, command: CliCommand): Promise<v
         `platform ${output.platform.name} ${output.platform.macOSVersion}`,
         ...capabilities.map((item) => `${item.name} ${item.available ? item.version ?? item.command : "unavailable"}`),
         `emoji ${emoji.provenance} ${emoji.installedCount}/${emoji.catalogCount}; generate: ${emoji.generationCommand}`,
+        output.legacyLoginItem.state === "found"
+          ? "login the old menu bar still opens at login; run: slopcamera legacy retire"
+          : output.legacyLoginItem.state === "not-ours"
+            ? `login ${output.legacyLoginItem.label ?? "an item"} was changed outside Slopcamera and is left alone`
+            : "login nothing starts at login",
+        ...output.legacyLoginItem.retired.map((item) => `retired ${item.path}; restore: ${item.restore}`),
       ].join("\n"));
       return;
     }
@@ -8032,11 +8043,6 @@ async function dispatch(context: CommandContext, command: CliCommand): Promise<v
     case "credits-forget": await handleCreditsForget(context, command); return;
     case "media-audio": await handleMediaAudio(context, command); return;
     case "media-color": await handleMediaColor(context, command); return;
-    case "menubar": {
-      if (command.action === "run") await launchMenubar(context.io, context.paths.repositoryRoot, command.json, command.mode);
-      else await manageMenubar(context.io, context.paths.repositoryRoot, command.action, command.json);
-      return;
-    }
     case "outputs": {
       await reportOutputsRoot(context.io, context.stateRoot, command.json);
       return;
@@ -8365,7 +8371,6 @@ function commandMutationReference(command: CliCommand): MutationReference | unde
     case "fillers-list":
     case "emoji-search":
     case "emoji-resolve":
-    case "menubar":
     case "outputs":
     case "complete": return undefined;
     // Fresh projects write outside an existing mutable bundle and publish by

package/apps/desktop/cli/desktop-status.ts

@@ -0,0 +1,271 @@
+import { lstatSync, readdirSync } from "node:fs";
+import { extname, join } from "node:path";
+
+import { okEnvelope, type Envelope, type NextStep } from "@hraness/desktop-foundation/registry";
+import { box, clean, table, type View } from "@hraness/desktop-foundation/tui";
+
+import type { LegacyLoginReport } from "./legacy-login";
+import type { ActivityStatus } from "./activity-status";
+
+/**
+ * `slopcamera status` and `slopcamera tui`: what Slopcamera is doing, how
+ * the last job ended, the last credits balance a command saw, the newest
+ * outputs, and whether the retired menu bar still starts at login. Pure
+ * except `listOutputs`, so every state has a golden.
+ */
+export const STATUS_SCHEMA = "slopcamera.status/1";
+export const OUTPUTS_LIMIT = 3;
+/** A job still marked running after this long crashed or was killed. */
+export const STALE_RUNNING_MS = 6 * 60 * 60 * 1000;
+const MAX_LABEL_CHARS = 40;
+
+export type ActivityState = "idle" | "running" | "done" | "failed" | "stale";
+
+export interface StatusActivity {
+  readonly state: ActivityState;
+  readonly headline: string;
+  readonly detail: string;
+  readonly label?: string;
+  readonly startedAt?: string;
+  readonly finishedAt?: string;
+  readonly error?: string;
+}
+
+export interface StatusCredits {
+  readonly usd: string;
+  readonly low: boolean;
+  readonly checkedAt: string;
+}
+
+export interface StatusOutput {
+  readonly name: string;
+  readonly kind: string;
+  readonly bytes: number;
+  readonly modifiedAt: string;
+}
+
+export interface StatusOutputs {
+  readonly root: string;
+  readonly total: number;
+  readonly latest: readonly StatusOutput[];
+}
+
+export interface StatusData {
+  readonly product: "slopcamera";
+  readonly version: string;
+  readonly attention: boolean;
+  readonly activity: StatusActivity;
+  readonly credits: StatusCredits | null;
+  readonly outputs: StatusOutputs;
+  readonly legacyLoginItem: LegacyLoginReport;
+}
+
+export interface StatusInput {
+  readonly version: string;
+  readonly status: ActivityStatus;
+  readonly outputs: StatusOutputs;
+  readonly legacyLogin: LegacyLoginReport;
+  readonly now: Date;
+}
+
+export function ago(thenMs: number, nowMs: number): string {
+  const seconds = Math.max(0, Math.floor((nowMs - thenMs) / 1000));
+  if (seconds < 60) return "just now";
+  if (seconds < 3_600) return `${Math.floor(seconds / 60)} min ago`;
+  if (seconds < 7_200) return "1 hour ago";
+  if (seconds < 86_400) return `${Math.floor(seconds / 3_600)} hours ago`;
+  if (seconds < 172_800) return "yesterday";
+  return `${Math.floor(seconds / 86_400)} days ago`;
+}
+
+export function dollars(usd: string): string {
+  const bare = usd.replace(/^\$+/u, "");
+  return bare !== "" && /^[0-9.,]+$/u.test(bare) ? `$${bare}` : usd;
+}
+
+export function explain(code: string): string {
+  switch (code) {
+    case "cancelled": return "It was stopped before it finished";
+    case "not-found": return "A file it needed wasn't found";
+    case "unavailable": return "A tool it needed isn't available on this computer";
+    case "authorization-required": return "It needs more credits first";
+    case "subprocess": return "A render tool stopped with an error";
+    case "invalid-data":
+    case "incompatible": return "Its input wasn't in a form Slopcamera can use";
+    case "unsafe-path": return "It was asked to use a folder Slopcamera won't write to";
+    case "usage": return "The command had a typo or a missing option";
+    case "conflict": return "Something else was changing the same project";
+    default: return "Something went wrong. Run the command again to see why";
+  }
+}
+
+function plain(text: string, max: number): boolean {
+  return text !== "" && [...text].length <= max && /^[\p{L}\p{N} .,'$-]+$/u.test(text);
+}
+
+function iso(ms: number): string | undefined {
+  return Number.isFinite(ms) && ms >= 0 && ms <= 8.64e15 ? new Date(ms).toISOString() : undefined;
+}
+
+function activityOf(status: ActivityStatus, now: number): StatusActivity {
+  const activity = status.activity;
+  if (activity === undefined || !plain(activity.label, MAX_LABEL_CHARS) || !Number.isFinite(activity.startedAt)) {
+    return { state: "idle", headline: "Ready", detail: "Nothing rendered yet" };
+  }
+  const startedAt = iso(activity.startedAt);
+  const finishedMs = activity.finishedAt ?? activity.startedAt;
+  const finishedAt = activity.finishedAt === undefined ? undefined : iso(activity.finishedAt);
+  const times = { ...(startedAt === undefined ? {} : { startedAt }), ...(finishedAt === undefined ? {} : { finishedAt }) };
+  if (activity.state === "running") {
+    if (now - activity.startedAt < STALE_RUNNING_MS) {
+      return { state: "running", headline: activity.label, detail: `Started ${ago(activity.startedAt, now)}`, label: activity.label, ...times };
+    }
+    return { state: "stale", headline: "Last job stopped early", detail: `${activity.label} · started ${ago(activity.startedAt, now)}`, label: activity.label, ...times };
+  }
+  if (activity.state === "failed") {
+    const error = typeof activity.error === "string" && /^[a-z][a-z-]{0,40}$/u.test(activity.error) ? activity.error : "internal";
+    return { state: "failed", headline: "Last job didn't finish", detail: `${activity.label} · ${explain(error)}`, label: activity.label, error, ...times };
+  }
+  return { state: "done", headline: "Ready", detail: `Last job finished ${ago(finishedMs, now)}`, label: activity.label, ...times };
+}
+
+function creditsOf(status: ActivityStatus): StatusCredits | null {
+  const credits = status.credits;
+  if (credits === undefined || !plain(credits.usd, 16) || typeof credits.low !== "boolean") return null;
+  const checkedAt = iso(credits.checkedAt);
+  return checkedAt === undefined ? null : { usd: credits.usd, low: credits.low, checkedAt };
+}
+
+export function statusData(input: StatusInput): StatusData {
+  const now = input.now.getTime();
+  const activity = activityOf(input.status, now);
+  const credits = creditsOf(input.status);
+  return {
+    product: "slopcamera",
+    version: input.version,
+    attention: activity.state === "failed" || credits?.low === true || input.legacyLogin.state === "found",
+    activity,
+    credits,
+    outputs: input.outputs,
+    legacyLoginItem: input.legacyLogin,
+  };
+}
+
+export function statusNext(data: StatusData): NextStep[] {
+  const next: NextStep[] = [];
+  if (data.activity.state === "failed" || data.activity.state === "stale") {
+    next.push({ command: "slopcamera runs list --json", why: "See which run stopped and whether it can resume.", audience: "agent" });
+  }
+  if (data.credits?.low === true) {
+    next.push({ command: "slopcamera credits topup", why: "Credits are low; adding more opens a checkout for a person.", audience: "human" });
+  }
+  if (data.legacyLoginItem.state === "found") {
+    next.push({ command: "slopcamera legacy retire --json", why: "The retired menu bar still opens at login; this moves its login item aside.", audience: "agent" });
+  }
+  return next;
+}
+
+export function statusEnvelope(input: StatusInput): Envelope<StatusData> {
+  const data = statusData(input);
+  const next = statusNext(data);
+  return okEnvelope(STATUS_SCHEMA, data, next.length === 0 ? undefined : next, input.now);
+}
+
+function size(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`;
+  const units = ["KB", "MB", "GB", "TB"];
+  let value = bytes / 1024;
+  let unit = 0;
+  while (value >= 1024 && unit < units.length - 1) {
+    value /= 1024;
+    unit += 1;
+  }
+  return `${value < 10 ? Math.round(value * 10) / 10 : Math.round(value)} ${units[unit]}`;
+}
+
+function day(modifiedAt: string, now: number): string {
+  const then = Date.parse(modifiedAt);
+  const days = Math.floor((now - then) / 86_400_000);
+  if (days <= 0) return "today";
+  if (days === 1) return "yesterday";
+  return `${days} days ago`;
+}
+
+function mark(state: ActivityState): string {
+  switch (state) {
+    case "idle": return "○";
+    case "running": return "↻";
+    case "done": return "✓";
+    default: return "⚠";
+  }
+}
+
+function loginLine(report: LegacyLoginReport): string {
+  switch (report.state) {
+    case "found": return "⚠ The old menu bar still opens at login · run slopcamera legacy retire";
+    case "not-ours": return "– A menu bar login item changed outside Slopcamera is left alone";
+    default: return "✓ Nothing starts at login";
+  }
+}
+
+/** The one Status view, rendered by both `tui` and `tui --snapshot`. */
+export function statusViews(now: () => Date): View<StatusData>[] {
+  return [{
+    id: "status",
+    title: "Slopcamera",
+    render(data, width) {
+      const nowMs = now().getTime();
+      const lines = [`${mark(data.activity.state)} ${clean(data.activity.headline)} · ${clean(data.activity.detail)}`];
+      if (data.credits !== null) {
+        const checked = ago(Date.parse(data.credits.checkedAt), nowMs);
+        lines.push(data.credits.low
+          ? `⚠ Credits are low · ${dollars(data.credits.usd)} left · checked ${checked}`
+          : `✓ ${dollars(data.credits.usd)} in credits · Checked ${checked}`);
+      }
+      const outputs = data.outputs.latest.length === 0
+        ? ["No outputs yet · Agents save finished files here"]
+        : table(["Output", "Size", "Saved", "Type"], data.outputs.latest.map(item => [
+          clean(item.name), size(item.bytes), day(item.modifiedAt, nowMs), item.kind,
+        ]), width - 2);
+      const more = data.outputs.total > data.outputs.latest.length
+        ? [`${data.outputs.total} outputs · slopcamera outputs list --json`]
+        : ["slopcamera outputs open"];
+      return [
+        ...box("Now", lines, width),
+        ...box("Outputs", [...outputs, ...more], width),
+        ...box("Login", [loginLine(data.legacyLoginItem)], width),
+      ];
+    },
+  }];
+}
+
+function kindOf(name: string): string {
+  const extension = extname(name).slice(1);
+  return extension === "" || extension.length > 8 ? "File" : extension.toUpperCase();
+}
+
+/**
+ * The newest regular files at the top of the outputs folder. Hidden files,
+ * links and folders are skipped; a missing folder is an empty list.
+ */
+export function listOutputs(root: string, limit: number): StatusOutputs {
+  let names: string[];
+  try {
+    names = readdirSync(root);
+  } catch {
+    return { root, total: 0, latest: [] };
+  }
+  const files: StatusOutput[] = [];
+  for (const name of names) {
+    if (name.startsWith(".")) continue;
+    try {
+      const info = lstatSync(join(root, name));
+      if (!info.isFile()) continue;
+      files.push({ name, kind: kindOf(name), bytes: info.size, modifiedAt: new Date(info.mtimeMs).toISOString() });
+    } catch {
+      // Removed while listing.
+    }
+  }
+  files.sort((left, right) => right.modifiedAt.localeCompare(left.modifiedAt) || left.name.localeCompare(right.name));
+  return { root, total: files.length, latest: files.slice(0, limit) };
+}