tmux-ide 2.6.0 → 2.7.0

package/scripts/perf-mirror.mjs

@@ -0,0 +1,313 @@
+#!/usr/bin/env bun
+/**
+ * perf-mirror — the M21 baseline harness.
+ *
+ * Drives the real unified app (`tmux-ide app`) against a scripted tmux session
+ * on the default socket, exercising the three mirror-pipeline taps that gate
+ * behind TMUX_IDE_ZZ_PERF, then prints a p50/p95 table for:
+ *   - feed-parse   ms per stdout chunk   (/tmp/zz-feed.log,  control-client)
+ *   - snapshot     ms per 8ms paint tick (/tmp/zz-perf.log,  app.tsx)
+ *   - input-echo   ms keystroke→echo→paint (/tmp/zz-input.log, perf-tap)
+ * across three scenarios: IDLE, FLOOD (scrolling), ALT (alt-screen redraw).
+ *
+ * Everything it creates is `zz-perf-*` on the default socket and is killed on
+ * exit (success OR failure). It NEVER touches any other session. Run it from
+ * the repo root:  bun scripts/perf-mirror.mjs
+ *
+ * Env knobs (all optional): PERF_FLOOD_MS, PERF_ALT_MS, PERF_IDLE_MS,
+ * PERF_KEYS (input samples), PERF_KEY_GAP_MS, PERF_WARMUP_MS.
+ */
+import { execFileSync } from "node:child_process";
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, resolve } from "node:path";
+import os from "node:os";
+import { summarize } from "../packages/daemon/src/tui/mirror/perf-tap.ts";
+
+const REPO = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const APP = "packages/daemon/src/tui/mirror/app.tsx";
+const TARGET = "zz-perf-target";
+const HOST = "zz-perf-host";
+const FEED_LOG = "/tmp/zz-feed.log";
+const SNAP_LOG = "/tmp/zz-perf.log";
+const INPUT_LOG = "/tmp/zz-input.log";
+
+const cfg = {
+  floodMs: num(process.env.PERF_FLOOD_MS, 6000),
+  altMs: num(process.env.PERF_ALT_MS, 6000),
+  idleMs: num(process.env.PERF_IDLE_MS, 4000),
+  keys: num(process.env.PERF_KEYS, 50),
+  keyGapMs: num(process.env.PERF_KEY_GAP_MS, 90),
+  warmupMs: num(process.env.PERF_WARMUP_MS, 5000),
+};
+
+function num(v, d) {
+  const n = Number(v);
+  return Number.isFinite(n) && n > 0 ? n : d;
+}
+
+/** tmux on the DEFAULT socket, un-nested (TMUX/TMUX_TMPDIR cleared) — the socket
+ *  the app's control client attaches to and where the user's real sessions live.
+ *  We only ever name zz-perf-* targets. */
+function tmux(args, opts = {}) {
+  return execFileSync("tmux", args, {
+    env: { ...process.env, TMUX: "", TMUX_TMPDIR: "" },
+    encoding: "utf8",
+    stdio: opts.inherit ? "inherit" : ["ignore", "pipe", "pipe"],
+    ...opts,
+  });
+}
+function tmuxQuiet(args) {
+  try {
+    return tmux(args);
+  } catch {
+    return "";
+  }
+}
+function sessionExists(name) {
+  try {
+    tmux(["has-session", "-t", name]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const truncate = (p) => writeFileSync(p, "");
+function readCol(path, col) {
+  if (!existsSync(path)) return [];
+  return readFileSync(path, "utf8")
+    .split("\n")
+    .filter(Boolean)
+    .map((l) => Number(l.trim().split(/\s+/)[col]))
+    .filter((n) => Number.isFinite(n));
+}
+
+// ── keystroke / flood injection ─────────────────────────────────────────────
+
+/** Type into the HOST (the app), which forwards to the focused target pane. */
+const sendHostKey = (key) => tmuxQuiet(["send-keys", "-t", HOST, key]);
+const sendHostChar = (ch) => tmuxQuiet(["send-keys", "-t", HOST, "-l", ch]);
+/** Run a command directly in the TARGET pane (bypasses the app — pure output). */
+function runInTarget(line) {
+  tmuxQuiet(["send-keys", "-t", TARGET, "-l", line]);
+  tmuxQuiet(["send-keys", "-t", TARGET, "Enter"]);
+}
+/** Interrupt whatever the target pane is running, back to a clean prompt. */
+function calmTarget() {
+  tmuxQuiet(["send-keys", "-t", TARGET, "C-c"]);
+  tmuxQuiet(["send-keys", "-t", TARGET, "-l", "printf '\\033[?1049l'"]);
+  tmuxQuiet(["send-keys", "-t", TARGET, "Enter"]);
+  tmuxQuiet(["send-keys", "-t", TARGET, "-l", "clear"]);
+  tmuxQuiet(["send-keys", "-t", TARGET, "Enter"]);
+}
+
+// ── lifecycle ───────────────────────────────────────────────────────────────
+
+function cleanup() {
+  for (const s of [HOST, TARGET]) {
+    if (sessionExists(s)) tmuxQuiet(["kill-session", "-t", s]);
+  }
+}
+
+async function setup() {
+  cleanup(); // clear any leftovers from a crashed prior run
+  truncate(FEED_LOG);
+  truncate(SNAP_LOG);
+  truncate(INPUT_LOG);
+
+  // Target: a plain shell on the default socket. The app mirrors this session;
+  // its control client (`tmux -C attach`, TMUX="") reaches the default socket.
+  tmux(["new-session", "-d", "-s", TARGET, "-x", "200", "-y", "50"]);
+  // A generous host so the app has room and never wraps the flood oddly.
+  tmux([
+    "new-session",
+    "-d",
+    "-s",
+    HOST,
+    "-x",
+    "220",
+    "-y",
+    "60",
+    // Forward TMUX_IDE_FB_PANES verbatim so the default incremental blit path
+    // (M21.4) and the `=0` StyledRun kill switch can be measured on the same
+    // harness/taps. Unset → the app's default (blit).
+    `cd ${REPO} && TMUX_IDE_ZZ_PERF=1 ${process.env.TMUX_IDE_FB_PANES !== undefined ? `TMUX_IDE_FB_PANES=${process.env.TMUX_IDE_FB_PANES} ` : ""}exec bun ${APP} --target=${TARGET}`,
+  ]);
+
+  process.stdout.write(`  warming up (${cfg.warmupMs}ms) — app attaching + seeding…\n`);
+  await sleep(cfg.warmupMs);
+  sendHostKey("F2"); // force the Terminal surface (pane-forward keyboard path)
+  await sleep(400);
+}
+
+/** Assert the mirror is actually live: a brief flood must grow the feed log. */
+async function assertLive() {
+  truncate(FEED_LOG);
+  runInTarget("for i in 1 2 3 4 5; do echo probe-$i; done");
+  await sleep(800);
+  const n = readCol(FEED_LOG, 1).length;
+  if (n === 0) {
+    const pane = tmuxQuiet(["capture-pane", "-t", HOST, "-p"]).slice(0, 800);
+    throw new Error(
+      `mirror never went live — no %output feed after a probe.\n--- host pane ---\n${pane}`,
+    );
+  }
+  calmTarget();
+  await sleep(500);
+}
+
+// ── scenarios ────────────────────────────────────────────────────────────────
+
+/** Idle: quiet pane; capture the low-water feed/snapshot floor. */
+async function scenarioIdle() {
+  calmTarget();
+  await sleep(600);
+  truncate(FEED_LOG);
+  truncate(SNAP_LOG);
+  await sleep(cfg.idleMs);
+  return { feed: readCol(FEED_LOG, 1), snap: readCol(SNAP_LOG, 0) };
+}
+
+/** Flood: a steady stream of new lines (scrollback growth + re-snapshot). */
+async function scenarioFlood() {
+  calmTarget();
+  await sleep(500);
+  truncate(FEED_LOG);
+  truncate(SNAP_LOG);
+  // ~200 lines/sec — a busy build/test log, not a fork bomb.
+  runInTarget(
+    'i=0; while true; do echo "flood line $i $(date +%s%N)"; i=$((i+1)); sleep 0.005; done',
+  );
+  await sleep(cfg.floodMs);
+  const out = { feed: readCol(FEED_LOG, 1), snap: readCol(SNAP_LOG, 0) };
+  calmTarget();
+  await sleep(500);
+  return out;
+}
+
+/** Alt-screen: an app that repaints in place (cursor addressing, no scrollback). */
+async function scenarioAlt() {
+  calmTarget();
+  await sleep(500);
+  truncate(FEED_LOG);
+  truncate(SNAP_LOG);
+  runInTarget(
+    "printf '\\033[?1049h'; while true; do printf '\\033[H\\033[2J'; date +%s.%N; seq 1 30; sleep 0.05; done",
+  );
+  await sleep(cfg.altMs);
+  const out = { feed: readCol(FEED_LOG, 1), snap: readCol(SNAP_LOG, 0) };
+  calmTarget();
+  await sleep(500);
+  return out;
+}
+
+/** Input latency: type single chars into the app at a shell prompt; each echoes. */
+async function scenarioInput() {
+  calmTarget();
+  await sleep(600);
+  truncate(INPUT_LOG);
+  const glyphs = "abcdefghijklmnopqrstuvwxyz0123456789";
+  for (let k = 0; k < cfg.keys; k++) {
+    sendHostChar(glyphs[k % glyphs.length]);
+    await sleep(cfg.keyGapMs);
+  }
+  await sleep(400);
+  const out = { echo: readCol(INPUT_LOG, 1), paint: readCol(INPUT_LOG, 2) };
+  // Drop the half-typed line by interrupting the TARGET pane directly. NEVER
+  // send C-c to the host: the app exits on ctrl-c, which would kill the mirror
+  // and silence every later scenario.
+  tmuxQuiet(["send-keys", "-t", TARGET, "C-c"]);
+  return out;
+}
+
+// ── reporting ────────────────────────────────────────────────────────────────
+
+function fmt(n) {
+  return n.toFixed(2).padStart(8);
+}
+function row(label, s) {
+  return `  ${label.padEnd(26)} ${String(s.count).padStart(6)} ${fmt(s.p50)} ${fmt(s.p95)} ${fmt(s.max)} ${fmt(s.mean)}`;
+}
+function table(rows) {
+  const head = `  ${"metric".padEnd(26)} ${"n".padStart(6)} ${"p50".padStart(8)} ${"p95".padStart(8)} ${"max".padStart(8)} ${"mean".padStart(8)}`;
+  return [head, "  " + "-".repeat(head.length - 2), ...rows].join("\n");
+}
+
+function machineInfo() {
+  const cpu = os.cpus()[0]?.model ?? "unknown";
+  let tmuxV = "unknown";
+  try {
+    tmuxV = tmux(["-V"]).trim();
+  } catch {
+    /* ignore */
+  }
+  let opentui = "unknown";
+  try {
+    const pkg = JSON.parse(readFileSync(resolve(REPO, "packages/daemon/package.json"), "utf8"));
+    opentui =
+      pkg.dependencies?.["@opentui/core"] ?? pkg.dependencies?.["@opentui/solid"] ?? "unknown";
+  } catch {
+    /* ignore */
+  }
+  return {
+    date: new Date().toISOString(),
+    platform: `${os.platform()} ${os.release()} (${os.arch()})`,
+    cpu: `${cpu} × ${os.cpus().length}`,
+    mem: `${(os.totalmem() / 1024 ** 3).toFixed(0)} GB`,
+    bun: process.versions.bun ?? "n/a",
+    node: process.versions.node,
+    tmux: tmuxV,
+    opentui,
+  };
+}
+
+async function main() {
+  const info = machineInfo();
+  process.stdout.write("perf-mirror — M21 baseline harness\n");
+  process.stdout.write(
+    `  ${info.platform} · ${info.cpu} · bun ${info.bun} · ${info.tmux} · @opentui ${info.opentui}\n\n`,
+  );
+
+  await setup();
+  await assertLive();
+
+  process.stdout.write("  running IDLE…\n");
+  const idle = await scenarioIdle();
+  process.stdout.write("  running INPUT…\n");
+  const input = await scenarioInput();
+  process.stdout.write("  running FLOOD…\n");
+  const flood = await scenarioFlood();
+  process.stdout.write("  running ALT-SCREEN…\n\n");
+  const alt = await scenarioAlt();
+
+  const rows = [
+    row("feed-parse ms/chunk [idle]", summarize(idle.feed)),
+    row("feed-parse ms/chunk [flood]", summarize(flood.feed)),
+    row("feed-parse ms/chunk [alt]", summarize(alt.feed)),
+    row("snapshot ms/tick [idle]", summarize(idle.snap)),
+    row("snapshot ms/tick [flood]", summarize(flood.snap)),
+    row("snapshot ms/tick [alt]", summarize(alt.snap)),
+    row("input echo ms (t1-t0)", summarize(input.echo)),
+    row("input paint ms (t2-t0)", summarize(input.paint)),
+  ];
+  process.stdout.write(table(rows) + "\n");
+
+  return { info, rows };
+}
+
+let exitCode = 0;
+try {
+  await main();
+} catch (err) {
+  exitCode = 1;
+  process.stderr.write(`\nperf-mirror FAILED: ${err?.stack ?? err}\n`);
+} finally {
+  cleanup();
+  // Best-effort confirmation the zz-perf-* sessions are gone.
+  const leftover = [HOST, TARGET].filter(sessionExists);
+  if (leftover.length)
+    process.stderr.write(`  WARNING leftover sessions: ${leftover.join(", ")}\n`);
+  else process.stdout.write("\n  cleanup: zz-perf-* sessions removed.\n");
+}
+process.exit(exitCode);

package/scripts/postinstall.js

@@ -1,7 +1,31 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { resolve, dirname } from "node:path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, symlinkSync } from "node:fs";
+import { resolve, dirname, relative } from "node:path";
 import { homedir } from "node:os";
 
+// ---------------------------------------------------------------------------
+// Workspace-package links — MUST run before the Claude gate below.
+//
+// The TUI sources (packages/daemon/src/**, run via bun) import the workspace
+// packages @tmux-ide/tmux-bridge and @tmux-ide/contracts. In a dev checkout
+// pnpm symlinks them into node_modules; an npm install has no such links, so
+// recreate them (their package.json mains point at shipped src/index.ts,
+// which bun runs directly). Best-effort: never fail an install.
+// ---------------------------------------------------------------------------
+try {
+  const pkgRoot = dirname(import.meta.dirname);
+  const scopeDir = resolve(pkgRoot, "node_modules", "@tmux-ide");
+  for (const name of ["tmux-bridge", "contracts"]) {
+    const target = resolve(pkgRoot, "packages", name);
+    const link = resolve(scopeDir, name);
+    if (!existsSync(target) || existsSync(link)) continue;
+    mkdirSync(scopeDir, { recursive: true });
+    // "junction" keeps Windows working without admin; ignored elsewhere.
+    symlinkSync(relative(scopeDir, target), link, "junction");
+  }
+} catch {
+  // linking is best-effort; the CLI's TUI fallback message covers the gap
+}
+
 const claudeDir = resolve(homedir(), ".claude");
 if (!shouldInstallClaudeIntegration() || !existsSync(claudeDir)) {
   process.exit(0);

package/skill/SKILL.md

@@ -123,6 +123,28 @@ One interaction grammar everywhere: `j`/`k` move, `enter` opens, `/` filters,
 `esc` backs out, `?` asks. Bare `tmux-ide` with no `ide.yml` opens the **home
 cockpit** (the fleet home screen). `tmux-ide cheatsheet` prints the full sheet.
 
+## The app — `tmux-ide app` (the terminal IDE)
+
+v2.7 adds a full-screen unified app: tmux stays the engine (PTYs, agents,
+persistence); the app is the IDE around it. Launch `tmux-ide app` (bare = home
+screen) or `tmux-ide app <session>`. Needs `bun`, or a downloaded binary:
+`tmux-ide update --tui-binary`.
+
+- **Tabs** `F1`–`F4`: Home (fleet, pick a session = set the workspace) ·
+  Terminal (the session mirrored live — it keeps streaming while you're on
+  other tabs) · Files (tree + built-in editor: `^s` save, `^z` undo, click to
+  place the cursor) · Diff (colored working-tree changes, `^e` opens the file
+  in the editor). `F5` = command palette (fuzzy everything).
+- **Mouse-native**: hover highlights; right-click = context menus (split/zoom/
+  kill panes, layouts, synchronize-panes, kill/rename sessions & windows —
+  destructive actions confirm); drag pane borders to resize; drag-select text →
+  clipboard via OSC52 (works through ssh); scrollbars; clickable buttons.
+- **tmux parity**: `[⛶]` zoom, window verbs, layout presets, `/` scrollback
+  search with `n`/`N`, paste-buffer picker. `^q` quits — the session is
+  untouched, like you were never there.
+- State persists across launches (~/.tmux-ide/app-state.json): last tab,
+  session, open file.
+
 ## ide.yml (optional)
 
 Adopt works on any session. If you'd rather have tmux-ide build the layout, describe

package/templates/AGENTS.md

@@ -5,16 +5,23 @@
 ## Boundaries
 
 - Stay within the scope of your assigned task
-- Report out-of-scope issues via --discovered-issues
+- Surface out-of-scope issues to the lead instead of silently expanding scope
 - Do not modify files outside your task scope without coordination
 
 ## Conventions
 
-- Run tests before marking tasks done
-- Use the project existing code style
-- Commit messages should reference the task ID
+- Run tests before reporting your work done
+- Use the project's existing code style
+- Reference the task or branch in commit messages
 
-## Completion Protocol
+## Status & Reporting
 
-- tmux-ide task done <ID> --proof "summary" --summary "key learnings"
-- Report issues: include --discovered-issues for anything out of scope
+Report your state so the fleet tabs show ground truth. Claude Code does this
+automatically once `tmux-ide integration install claude` is run; any agent can
+self-report the same way:
+
+    tmux set-option -p @agent_state "working:$(date +%s)"   # working|blocked|done|idle
+
+Coordinate with the lead or a teammate pane:
+
+    tmux-ide send <session-or-pane> "what changed, how you verified it, follow-ups"

package/templates/agent-team-monorepo.yml

@@ -1,8 +1,16 @@
 name: my-monorepo
 
+# Ground-truth agent status (working/blocked/done glyphs on the fleet tabs)
+# comes from Claude Code's lifecycle hooks. Wire them once with:
+#   tmux-ide integration install claude
+
 team:
   name: my-monorepo
 
+sidebar: true # fleet nav column — jump between agents (toggle: prefix b)
+
+before: pnpm install
+
 rows:
   - size: 70%
     panes:

package/templates/agent-team-nextjs.yml

@@ -1,8 +1,14 @@
 name: my-app
 
+# Ground-truth agent status (working/blocked/done glyphs on the fleet tabs)
+# comes from Claude Code's lifecycle hooks. Wire them once with:
+#   tmux-ide integration install claude
+
 team:
   name: my-app
 
+sidebar: true # fleet nav column — jump between agents (toggle: prefix b)
+
 before: pnpm install
 
 rows:
@@ -24,4 +30,6 @@ rows:
   - panes:
       - title: Next.js
         command: pnpm dev
+      - title: Changes
+        type: changes # live git changes widget
       - title: Shell

package/templates/agent-team.yml

@@ -1,8 +1,16 @@
 name: my-project
 
+# Ground-truth agent status (working/blocked/done glyphs on the fleet tabs)
+# comes from Claude Code's lifecycle hooks. Wire them once with:
+#   tmux-ide integration install claude
+
 team:
   name: my-project
 
+sidebar: true # fleet nav column — jump between agents (toggle: prefix b)
+
+# before: npm install
+
 rows:
   - size: 70%
     panes:
@@ -18,6 +26,8 @@ rows:
         role: teammate
 
   - panes:
+      - title: Changes
+        type: changes # live git changes widget
       - title: Dev Server
         # command: npm run dev
       - title: Shell

package/templates/convex.yml

@@ -1,5 +1,7 @@
 name: my-app
 
+before: pnpm install
+
 rows:
   - size: 70%
     panes:

package/templates/default.yml

@@ -1,6 +1,8 @@
 name: my-project
 
-# before: npm install  # optional pre-launch hook
+# before: npm install   # optional pre-launch hook (runs once, before panes start)
+
+# sidebar: true         # inject the fleet nav column (prefix b toggles it live)
 
 rows:
   - size: 70%
@@ -11,10 +13,14 @@ rows:
         command: claude
 
   - panes:
+      # Widget panes render native UI instead of a command:
+      #   type: explorer | changes | preview | config | sidebar
+      - title: Changes
+        type: changes # live git changes — no command, tmux-ide draws it
       - title: Dev Server
         # command: npm run dev
-        # dir: apps/web       # per-pane working directory
-        # env:                 # per-pane environment variables
-        #   PORT: 3000
+        # dir: apps/web          # per-pane working directory
+        # env:                   # per-pane environment variables
+        #   PORT: "3000"
       - title: Shell
-        # focus: true          # give this pane initial focus
+        focus: true # give this pane initial focus

package/templates/go.yml

@@ -1,5 +1,7 @@
 name: my-app
 
+before: go mod download
+
 rows:
   - size: 70%
     panes:
@@ -11,5 +13,7 @@ rows:
   - panes:
       - title: Go
         command: go run .
+      - title: Changes
+        type: changes # live git changes widget
       - title: Shell
         focus: true

package/templates/missions.yml

@@ -1,8 +1,14 @@
 name: project-name
 
+# Ground-truth agent status (working/blocked/done glyphs on the fleet tabs)
+# comes from Claude Code's lifecycle hooks. Wire them once with:
+#   tmux-ide integration install claude
+
 team:
   name: missions
 
+sidebar: true # fleet nav column — jump between agents (toggle: prefix b)
+
 rows:
   - size: 70%
     panes:

package/templates/nextjs.yml

@@ -1,5 +1,7 @@
 name: my-app
 
+before: pnpm install
+
 rows:
   - size: 70%
     panes:
@@ -13,5 +15,7 @@ rows:
   - panes:
       - title: Next.js
         command: pnpm dev
+      - title: Changes
+        type: changes # live git changes widget
       - title: Shell
         focus: true

package/templates/python.yml

@@ -1,5 +1,7 @@
 name: my-app
 
+# before: pip install -r requirements.txt   # or: uv sync / poetry install
+
 rows:
   - size: 70%
     panes:
@@ -11,5 +13,7 @@ rows:
   - panes:
       - title: Server
         # command: uvicorn main:app --reload
+      - title: Changes
+        type: changes # live git changes widget
       - title: Shell
         focus: true

package/templates/skills/backend.md

@@ -25,19 +25,12 @@ You are a backend development specialist.
 
 Your dispatch prompt includes relevant excerpts from the knowledge library (.tmux-ide/library/) and AGENTS.md. Use these for architectural decisions.
 
-## After Completion
+## Reporting
 
-When you finish, the orchestrator will:
+Self-report your state — this drives the fleet status glyphs (see AGENTS.md):
 
-- Notify the lead with your proof and summary
-- Run any configured after-run hooks (e.g., linting)
-- Auto-dispatch the next available task
-- Append your summary to the learnings library
+    tmux set-option -p @agent_state "done:$(date +%s)"   # working|blocked|done|idle
 
-## Completion Protocol
+Then report the result to the lead, and flag anything out of scope:
 
-When done, run:
-tmux-ide task done <TASK_ID> --proof "what changed and how you verified it" --summary "backend outcome"
-
-If you find out-of-scope issues, report them:
-tmux-ide task update <TASK_ID> --discovered-issues "description of issue"
+    tmux-ide send <lead-pane> "what changed, how you verified it, operational concerns"

package/templates/skills/frontend.md

@@ -25,19 +25,12 @@ You are a frontend development specialist.
 
 Your dispatch prompt includes relevant excerpts from the knowledge library (.tmux-ide/library/) and AGENTS.md. Use these for architectural decisions.
 
-## After Completion
+## Reporting
 
-When you finish, the orchestrator will:
+Self-report your state — this drives the fleet status glyphs (see AGENTS.md):
 
-- Notify the lead with your proof and summary
-- Run any configured after-run hooks (e.g., linting)
-- Auto-dispatch the next available task
-- Append your summary to the learnings library
+    tmux set-option -p @agent_state "done:$(date +%s)"   # working|blocked|done|idle
 
-## Completion Protocol
+Then report the result to the lead, and flag anything out of scope:
 
-When done, run:
-tmux-ide task done <TASK_ID> --proof "what changed and how you verified it" --summary "frontend outcome"
-
-If you find out-of-scope issues, report them:
-tmux-ide task update <TASK_ID> --discovered-issues "description of issue"
+    tmux-ide send <lead-pane> "what changed, what you verified, any follow-up risks"

package/templates/skills/general-worker.md

@@ -25,19 +25,12 @@ You are a general-purpose development agent.
 
 You are a general-purpose agent. Your dispatch prompt includes mission, goal, and task context along with relevant library excerpts. Follow the task description closely.
 
-## After Completion
+## Reporting
 
-When you finish, the orchestrator will:
+Self-report your state — this drives the fleet status glyphs (see AGENTS.md):
 
-- Notify the lead with your proof and summary
-- Run any configured after-run hooks (e.g., linting)
-- Auto-dispatch the next available task
-- Append your summary to the learnings library
+    tmux set-option -p @agent_state "done:$(date +%s)"   # working|blocked|done|idle
 
-## Completion Protocol
+Then report the result to the lead, and flag anything out of scope:
 
-When done, run:
-tmux-ide task done <TASK_ID> --proof "what you accomplished" --summary "key learnings for future tasks"
-
-If you discover out-of-scope issues, note them:
-tmux-ide task update <TASK_ID> --discovered-issues "description of issue"
+    tmux-ide send <lead-pane> "what you accomplished, how you verified it, follow-ups"