@hraness/slopcamera 3.7.0 → 3.8.0

package/README.md

@@ -103,15 +103,16 @@ Native engines install separately. The [source-install guide](docs/how-to/use-cu
 explains workspace placement and durable-run identity; the
 [capability reference](docs/reference/capabilities.md) names runtime requirements.
 
-SlopCamera is a CLI. On macOS, an optional unbundled menu-bar companion shows
-what SlopCamera is rendering, how the last job ended, your last known credits
-balance and the newest files in the agent outputs directory; `slopcamera menubar` runs a prebuilt
-companion directly and does not install or launch an application bundle. The
-companion is a thin product binary over the shared
-[desktop-foundation](https://github.com/hraness/desktop-foundation) crate, pinned
-by immutable tag. Build it explicitly with
-`cargo build --release --manifest-path desktop/menubar/Cargo.toml`
-when working from source.
+SlopCamera is a CLI with no menu-bar app or background process.
+`slopcamera status` shows what is running, how the last job ended, your last
+known credits balance, the newest outputs and whether the retired menu-bar
+companion still opens at login. `slopcamera tui` keeps
+that screen open and refreshes it; `slopcamera tui --snapshot` prints it once
+and `--json` returns the data. `slopcamera outputs list|open|reveal` lists the
+newest outputs or opens one on this Mac, `slopcamera commands --json` lists
+every command with what it may change, and `slopcamera legacy retire` stops
+the retired menu-bar companion opening at login by moving its LaunchAgent aside; it
+deletes nothing, and `slopcamera doctor` prints the command that restores it.
 
 <details>
 <summary>Historical Atet release evidence</summary>

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/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.0" as const;
 
 export const OPERATION_KINDS = [
   "scene.audit",

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.0";
 
 // 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) };
+}

package/apps/desktop/cli/help.ts

@@ -39,6 +39,11 @@ Commands:
                                  Buy and inspect hosted generation credits
   media audio|color              Apply local non-destructive audio and video effects
   outputs                        Print the agent outputs directory
+  outputs list|open|reveal       List the newest outputs or open one on this Mac
+  status                         What Slopcamera is doing, credits and newest outputs
+  tui [--snapshot]               The status screen; --snapshot prints it once
+  commands [--json]              List every command with what it may change
+  legacy retire                  Stop the old menu bar opening at login
   recordings list               List recording bundles
   projects list|create           List projects or create one from a recording
   project inspect|add|edit|render
@@ -65,28 +70,6 @@ ${slopcameraSupportHelpLine()}`;
 
 const HELP: Readonly<Record<string, string>> = {
   advanced: `${slopcameraSupportAdvancedHelp()}`,
-  menubar: `Usage:
-  slopcamera menubar [--foreground|--background] [--json]
-  slopcamera menubar install|uninstall|status|start [--json]
-
-Shows what Slopcamera is doing in the menu bar: a render in progress, how the
-last job ended and your last known credits balance, plus your newest outputs.
-It only reads that status and the outputs folder (slopcamera outputs).
-
-  menubar               Open it now; it closes when this command ends
-  menubar start         Open it now and return (same as --background)
-  menubar install       Open it every time you log in
-  menubar uninstall     Stop opening it at login and remove the installed copy
-  menubar status        Check whether it opens at login and is running
-
-If it's already in your menu bar, starting it again says so and succeeds.
-macOS shows a notice that slopcamera-menubar can open at login. Turn it off any
-time in System Settings › General › Login Items & Extensions.
-
-The menu bar isn't in released packages yet, so it isn't listed in
-slopcamera help. In a Slopcamera checkout, build it with
-cargo build --release --manifest-path desktop/Cargo.toml and slopcamera finds
-it; elsewhere, set SLOPCAMERA_MENUBAR to the built file.`,
   capabilities: `Usage: slopcamera capabilities [--json]
 
 Print the exact statically assembled capability manifest for this CLI build. Each module owns named operation, workflow, MCP-tool, command, and runtime-profile identities. The manifest includes trust classes, resource/effect policies, runtime requirements, qualification status, and a canonical SHA-256. It reads no workspace source, loads no plugin, probes no runtime, and grants no authority. Use doctor separately to inspect this machine's currently available executables.`,
@@ -729,7 +712,7 @@ export function commandHelp(topic: readonly string[]): string {
 
 export function completions(words: readonly string[]): readonly string[] {
   const topLevel = [
-    "capabilities", "operations", "diagram", "direct", "studio", "image", "html", "style", "workflows", "code", "runs", "doctor", "ai", "credits", "media", "menubar", "support", "outputs", "recordings", "projects", "project", "scene", "inspect", "events", "edit", "analyze", "align", "faces", "fillers", "render", "assets",
+    "capabilities", "operations", "diagram", "direct", "studio", "image", "html", "style", "workflows", "code", "runs", "doctor", "ai", "credits", "media", "support", "outputs", "status", "tui", "commands", "legacy", "recordings", "projects", "project", "scene", "inspect", "events", "edit", "analyze", "align", "faces", "fillers", "render", "assets",
   ];
   if (words.length <= 1) return topLevel;
   const command = words[0];
@@ -755,7 +738,8 @@ export function completions(words: readonly string[]): readonly string[] {
     if (words[1] === "direction") return ["check", "plan", "gallery"];
     if (words[1] === "effects") return ["check", "plan", "bake"];
     if (words[1] === "behavior") return ["check", "bake", "gallery", "audit"];
-    return ["init", "check", "inspect", "diff", "patch", "evaluate", "audit", "render-audit", "solve", "review", "camera-track", "generate", "plan", "render", "direction", "effects", "behavior", "temporal-audit"];
+    if (words[1] === "design") return ["catalog", "init", "inspect", "set", "compile", "gallery"];
+    return ["init", "check", "inspect", "diff", "patch", "evaluate", "audit", "render-audit", "solve", "review", "camera-track", "generate", "plan", "render", "direction", "effects", "behavior", "design", "temporal-audit"];
   }
   if (command === "edit") return ["init", "show", "trim", "cut", "speed", "zoom", "overlay", "cursor", "clicks", "keystrokes", "typed-text"];
   if (command === "analyze") return ["faces", "inactivity", "zooms", "music", "scenes", "speech"];
@@ -767,5 +751,7 @@ export function completions(words: readonly string[]): readonly string[] {
   if (command === "media") return ["audio", "color"];
   if (command === "render") return ["plan", "run"];
   if (command === "assets") return ["emoji"];
+  if (command === "outputs") return ["list", "open", "reveal"];
+  if (command === "legacy") return ["retire"];
   return [];
 }