@logicseek/hello-cc 0.1.2 → 0.1.4

package/bin/hcc.mjs

@@ -5,23 +5,30 @@ import http from 'node:http';
 import path from 'node:path';
 import process from 'node:process';
 import os from 'node:os';
-import { createHash } from 'node:crypto';
+import { createHash, randomBytes } from 'node:crypto';
 import { spawn, spawnSync } from 'node:child_process';
 import { setTimeout as sleep } from 'node:timers/promises';
 import { URL, fileURLToPath } from 'node:url';
 import { DatabaseSync } from 'node:sqlite';
+import { readPackageMeta } from '../lib/package-meta.mjs';
+import {
+  removeGuidanceBlocks as removeGuidanceBlocksForRoot,
+  writeGuidance as writeGuidanceForRoot
+} from '../lib/guidance.mjs';
 
 // Lazy-load lib modules (they may import node-pty which needs to be optional)
 const _libDir = path.resolve(fileURLToPath(import.meta.url), '..', '..', 'lib');
 async function loadDiscover() { return import(path.join(_libDir, 'discover.mjs')); }
 async function loadSetup()    { return import(path.join(_libDir, 'setup.mjs')); }
 
-const VERSION = '0.1.2';
+const PACKAGE_META = readPackageMeta(path.resolve(fileURLToPath(import.meta.url), '..', '..'));
+const VERSION = PACKAGE_META.version;
 const PRODUCT_NAME = 'hello-cc';
 const CLI_NAME = 'hcc';
-const NPM_PACKAGE_NAME = '@logicseek/hello-cc';
+const NPM_PACKAGE_NAME = PACKAGE_META.name;
 const DEFAULT_LOCK_TTL = 900;
 const ACTIVE_PEER_TTL = 600;
+const DB_SCHEMA_VERSION = 4;
 // Directory under .hello-cc/ for optional external PTY buffer files.
 const BUFS_DIR_NAME = 'bufs';
 const WEB_CHILD_ENV = 'HCC_WEB_CHILD';
@@ -163,6 +170,10 @@ function shortHash(value) {
   return createHash('sha1').update(String(value)).digest('hex').slice(0, 8);
 }
 
+function providerSessionPeerId(kind, providerId) {
+  return `${kind}-${sanitizePeerPart(String(providerId || '').slice(0, 8), shortHash(providerId))}`;
+}
+
 function currentTtyName() {
   if (process.env.TTY) return process.env.TTY;
   const result = spawnSync('tty', [], {
@@ -385,6 +396,10 @@ function globalRuntimePath() {
   return path.join(globalStateDir(), 'runtime.json');
 }
 
+function globalWebTokenPath() {
+  return path.join(globalStateDir(), 'web-token');
+}
+
 function projectRegistryPath() {
   return path.join(globalStateDir(), 'projects.json');
 }
@@ -597,6 +612,70 @@ function runtimeUrlQuery(runtime, projectRoot = null) {
   return parts.length ? `?${parts.join('&')}` : '';
 }
 
+function readStoredWebToken() {
+  const file = globalWebTokenPath();
+  if (!fs.existsSync(file)) return '';
+  try {
+    return fs.readFileSync(file, 'utf8').trim();
+  } catch {
+    return '';
+  }
+}
+
+function writeStoredWebToken(token) {
+  if (!token) return '';
+  const file = globalWebTokenPath();
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${token}\n`, { mode: 0o600 });
+  fs.chmodSync(file, 0o600);
+  return file;
+}
+
+function makeWebToken(opts) {
+  validateWebTokenOpts(opts);
+  if (opts['no-token']) return '';
+  const explicitToken = opts.token || process.env.HCC_WEB_TOKEN || '';
+  if (explicitToken) {
+    writeStoredWebToken(explicitToken);
+    return explicitToken;
+  }
+  const stored = readStoredWebToken();
+  if (stored) return stored;
+  const generated = randomBytes(24).toString('base64url');
+  writeStoredWebToken(generated);
+  return generated;
+}
+
+function validateWebTokenOpts(opts) {
+  if (opts['no-token'] && (opts.token || process.env.HCC_WEB_TOKEN)) {
+    throw new CliError('BAD_ARGS', '--no-token cannot be combined with --token or HCC_WEB_TOKEN');
+  }
+}
+
+function expectedWebHost(opts) {
+  return opts.host || (opts.local ? '127.0.0.1' : '0.0.0.0');
+}
+
+function webRuntimeMatchesRequest(runtime, opts) {
+  if (!runtime) return false;
+  if (opts['no-token'] && (opts.token || process.env.HCC_WEB_TOKEN)) return false;
+  const expectedHost = expectedWebHost(opts);
+  if (runtime.host !== expectedHost) return false;
+  const expectedPort = intOpt(opts, 'port', 8787);
+  if (opts.port !== undefined && runtime.port !== expectedPort) return false;
+  const explicitToken = opts.token || process.env.HCC_WEB_TOKEN || '';
+  if (opts['no-token']) return !runtime.token;
+  if (explicitToken) return runtime.token === explicitToken;
+  return Boolean(runtime.token);
+}
+
+function rememberRuntimeToken(runtime, opts) {
+  if (!runtime?.token || opts['no-token']) return;
+  const explicitToken = opts.token || process.env.HCC_WEB_TOKEN || '';
+  if (explicitToken && runtime.token !== explicitToken) return;
+  writeStoredWebToken(runtime.token);
+}
+
 function publicRuntimeUrl(runtime, projectRoot = null) {
   const host = runtime.host === '0.0.0.0' || runtime.host === '::'
     ? '<machine-ip>'
@@ -915,6 +994,13 @@ function tmuxSendKeys(pane, keys) {
 
 function tmuxSendRawLiteral(pane, text) {
   if (!text) return;
+  // A tmux argument consisting solely of ';' is swallowed as a command
+  // separator even after '--', so a typed lone semicolon would vanish. Paste
+  // such runs through a buffer (which is parsed as data, not command args).
+  if (/^;+$/.test(text)) {
+    tmuxPasteBuffer(pane, text, { raw: true });
+    return;
+  }
   runTmux(['send-keys', '-t', pane, '-l', '--', text]);
 }
 
@@ -1036,18 +1122,26 @@ function tmuxSendLiteral(pane, text) {
   }
   if (current) chunks.push({ type: 'literal', text: current });
 
+  // Typed characters must arrive as real key presses, not clipboard pastes:
+  // send-keys -l is ~3x cheaper than the load-buffer/paste-buffer/delete-buffer
+  // cycle (one tmux spawn vs three) and the target program sees keystrokes
+  // rather than paste events — which bracketed-paste-aware TUIs (claude, codex)
+  // otherwise mishandle. paste-buffer is reserved for genuine bracketed pastes.
+  // Exit copy-mode once up front so send-keys isn't interpreted as copy commands.
+  if (tmuxInCopyMode(pane)) tmuxExitCopyMode(pane);
+
   let pendingText = '';
   for (const chunk of chunks) {
     if (chunk.type === 'literal') {
       pendingText += chunk.text;
     } else {
-      if (pendingText) { tmuxPasteBuffer(pane, pendingText, { raw: true }); pendingText = ''; }
+      if (pendingText) { tmuxSendRawLiteral(pane, pendingText); pendingText = ''; }
       if (chunk.type === 'key') tmuxSendKeys(pane, [chunk.key]);
       else if (chunk.type === 'paste') tmuxPasteBuffer(pane, chunk.text, { bracketed: true, raw: true });
       else tmuxSendRawLiteral(pane, chunk.text);
     }
   }
-  if (pendingText) tmuxPasteBuffer(pane, pendingText, { raw: true });
+  if (pendingText) tmuxSendRawLiteral(pane, pendingText);
 }
 
 function inferPeerKind(id, explicitKind, firstCommand) {
@@ -1397,6 +1491,9 @@ function execWithBusyRetry(db, sql, { attempts = 30, delayMs = 100, ignoreBusy =
   return false;
 }
 
+let projectMigrationFanoutDepth = 0;
+const migratedRegisteredProjectDbs = new Set();
+
 function connect(ctx) {
   fs.mkdirSync(path.dirname(ctx.dbPath), { recursive: true });
   const db = new DatabaseSync(ctx.dbPath, { timeout: 5000 });
@@ -1404,16 +1501,84 @@ function connect(ctx) {
   execWithBusyRetry(db, 'PRAGMA journal_mode = WAL;', { ignoreBusy: true });
   db.exec('PRAGMA foreign_keys = ON;');
   initSchema(db);
+  migrateRegisteredProjectDbs(ctx);
   return db;
 }
 
+function migrateRegisteredProjectDbs(ctx) {
+  if (projectMigrationFanoutDepth > 0) return;
+  projectMigrationFanoutDepth += 1;
+  try {
+    const currentDb = path.resolve(ctx.dbPath);
+    const seen = new Set([currentDb]);
+    for (const project of readProjectRegistry()) {
+      const root = path.resolve(project.root);
+      const dbPath = path.resolve(project.db || path.join(root, '.hello-cc', 'mesh.db'));
+      if (seen.has(dbPath)) continue;
+      seen.add(dbPath);
+      const cacheKey = `${dbPath}:${DB_SCHEMA_VERSION}`;
+      if (migratedRegisteredProjectDbs.has(cacheKey)) continue;
+      if (!fs.existsSync(root) || !fs.existsSync(dbPath)) continue;
+      let db = null;
+      try {
+        db = new DatabaseSync(dbPath, { timeout: 5000 });
+        db.exec('PRAGMA busy_timeout = 5000;');
+        execWithBusyRetry(db, 'PRAGMA journal_mode = WAL;', { ignoreBusy: true });
+        db.exec('PRAGMA foreign_keys = ON;');
+        initSchema(db);
+        migratedRegisteredProjectDbs.add(cacheKey);
+      } catch (err) {
+        throw new CliError('REGISTERED_DB_MIGRATION_FAILED', `Failed to migrate registered project database ${dbPath}: ${err?.message || err}`, {
+          db: dbPath,
+          code: err instanceof CliError ? err.code : undefined
+        });
+      } finally {
+        try { db?.close(); } catch {}
+      }
+    }
+  } finally {
+    projectMigrationFanoutDepth -= 1;
+  }
+}
+
 function initSchema(db) {
+  const existingVersion = readSchemaVersion(db);
+  if (existingVersion > DB_SCHEMA_VERSION) {
+    throw new CliError('DB_SCHEMA_TOO_NEW', `Database schema version ${existingVersion} is newer than this hcc (${DB_SCHEMA_VERSION})`, {
+      db_schema_version: existingVersion,
+      supported_schema_version: DB_SCHEMA_VERSION
+    });
+  }
+  createBaseSchema(db);
+  runSchemaMigrations(db);
+  dedupePeerBindings(db);
+  execWithBusyRetry(db, `
+    CREATE INDEX IF NOT EXISTS idx_peer_bindings_provider_session ON peer_bindings(provider, provider_session_id);
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_peer_bindings_provider_session_id_unique
+      ON peer_bindings(provider, provider_session_id)
+      WHERE provider_session_id IS NOT NULL;
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_peer_bindings_provider_session_name_unique
+      ON peer_bindings(provider, provider_session_name)
+      WHERE provider_session_name IS NOT NULL;
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_peer_bindings_runtime_target_unique
+      ON peer_bindings(runtime_target)
+      WHERE runtime_target IS NOT NULL;
+  `);
+}
+
+function createBaseSchema(db) {
   execWithBusyRetry(db, `
     CREATE TABLE IF NOT EXISTS meta (
       key TEXT PRIMARY KEY,
       value TEXT NOT NULL
     );
 
+    CREATE TABLE IF NOT EXISTS schema_migrations (
+      version INTEGER PRIMARY KEY,
+      name TEXT NOT NULL,
+      applied_at INTEGER NOT NULL
+    );
+
     CREATE TABLE IF NOT EXISTS peers (
       id TEXT PRIMARY KEY,
       kind TEXT NOT NULL,
@@ -1450,6 +1615,8 @@ function initSchema(db) {
       status TEXT NOT NULL DEFAULT 'pending',
       assignee TEXT,
       owner TEXT,
+      parent_id INTEGER,
+      team_role TEXT,
       priority INTEGER NOT NULL DEFAULT 100,
       created_by TEXT,
       claimed_at INTEGER,
@@ -1465,6 +1632,8 @@ function initSchema(db) {
       task_id INTEGER,
       kind TEXT NOT NULL DEFAULT 'note',
       body TEXT NOT NULL,
+      reply_to INTEGER,
+      thread_id INTEGER,
       created_at INTEGER NOT NULL
     );
 
@@ -1512,28 +1681,110 @@ function initSchema(db) {
     CREATE INDEX IF NOT EXISTS idx_events_id ON events(id);
     CREATE INDEX IF NOT EXISTS idx_locks_expires ON locks(expires_at);
   `);
+}
+
+function tableColumns(db, tableName) {
+  return new Set(db.prepare(`PRAGMA table_info(${tableName})`).all().map((col) => col.name));
+}
+
+function tableExists(db, tableName) {
+  return Boolean(db.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ? LIMIT 1").get(tableName));
+}
+
+function readSchemaVersion(db) {
+  const metaExists = tableExists(db, 'meta');
+  const metaVersion = metaExists ? Number(db.prepare("SELECT value FROM meta WHERE key = 'schema_version'").get()?.value || 0) : 0;
+  const pragmaVersion = Number(db.prepare('PRAGMA user_version').get()?.user_version || 0);
+  const migrationVersion = tableExists(db, 'schema_migrations')
+    ? Number(db.prepare('SELECT MAX(version) AS version FROM schema_migrations').get()?.version || 0)
+    : 0;
+  return Math.max(metaVersion, pragmaVersion, migrationVersion);
+}
+
+function writeSchemaVersion(db, version) {
+  db.prepare(`
+    INSERT INTO meta(key, value) VALUES ('schema_version', ?)
+    ON CONFLICT(key) DO UPDATE SET value = excluded.value
+  `).run(String(version));
+  db.exec(`PRAGMA user_version = ${Number(version)}`);
+}
+
+function recordSchemaMigration(db, version, name) {
   db.prepare(`
-    INSERT INTO meta(key, value) VALUES ('schema_version', '1')
-    ON CONFLICT(key) DO NOTHING
-  `).run();
+    INSERT INTO schema_migrations(version, name, applied_at)
+    VALUES (?, ?, ?)
+    ON CONFLICT(version) DO NOTHING
+  `).run(version, name, now());
+}
 
-  const peerBindingColumns = new Set(db.prepare('PRAGMA table_info(peer_bindings)').all().map((col) => col.name));
-  if (!peerBindingColumns.has('runtime_target')) {
-    db.exec('ALTER TABLE peer_bindings ADD COLUMN runtime_target TEXT');
+function addColumnIfMissing(db, tableName, columnName, ddl) {
+  const columns = tableColumns(db, tableName);
+  if (!columns.has(columnName)) db.exec(`ALTER TABLE ${tableName} ADD COLUMN ${ddl}`);
+}
+
+function runSchemaMigrations(db) {
+  const migrations = [
+    {
+      version: 1,
+      name: 'baseline',
+      up() {
+        // createBaseSchema already created the baseline tables.
+      }
+    },
+    {
+      version: 2,
+      name: 'peer binding runtime targets',
+      up(database) {
+        addColumnIfMissing(database, 'peer_bindings', 'runtime_target', 'runtime_target TEXT');
+      }
+    },
+    {
+      version: 3,
+      name: 'threaded messages',
+      up(database) {
+        addColumnIfMissing(database, 'messages', 'reply_to', 'reply_to INTEGER');
+        addColumnIfMissing(database, 'messages', 'thread_id', 'thread_id INTEGER');
+        database.exec(`
+          UPDATE messages SET thread_id = id WHERE thread_id IS NULL;
+          CREATE INDEX IF NOT EXISTS idx_messages_thread_id ON messages(thread_id, id);
+        `);
+      }
+    },
+    {
+      version: 4,
+      name: 'team task hierarchy',
+      up(database) {
+        addColumnIfMissing(database, 'tasks', 'parent_id', 'parent_id INTEGER');
+        addColumnIfMissing(database, 'tasks', 'team_role', 'team_role TEXT');
+        database.exec('CREATE INDEX IF NOT EXISTS idx_tasks_parent ON tasks(parent_id, priority, id);');
+      }
+    }
+  ];
+  let version = readSchemaVersion(db);
+  if (version > DB_SCHEMA_VERSION) {
+    throw new CliError('DB_SCHEMA_TOO_NEW', `Database schema version ${version} is newer than this hcc (${DB_SCHEMA_VERSION})`, {
+      db_schema_version: version,
+      supported_schema_version: DB_SCHEMA_VERSION
+    });
   }
-  dedupePeerBindings(db);
-  execWithBusyRetry(db, `
-    CREATE INDEX IF NOT EXISTS idx_peer_bindings_provider_session ON peer_bindings(provider, provider_session_id);
-    CREATE UNIQUE INDEX IF NOT EXISTS idx_peer_bindings_provider_session_id_unique
-      ON peer_bindings(provider, provider_session_id)
-      WHERE provider_session_id IS NOT NULL;
-    CREATE UNIQUE INDEX IF NOT EXISTS idx_peer_bindings_provider_session_name_unique
-      ON peer_bindings(provider, provider_session_name)
-      WHERE provider_session_name IS NOT NULL;
-    CREATE UNIQUE INDEX IF NOT EXISTS idx_peer_bindings_runtime_target_unique
-      ON peer_bindings(runtime_target)
-      WHERE runtime_target IS NOT NULL;
-  `);
+  const applied = new Set(db.prepare('SELECT version FROM schema_migrations').all().map((row) => Number(row.version)));
+  tx(db, () => {
+    for (const migration of migrations) {
+      if (version >= migration.version && applied.has(migration.version)) continue;
+      migration.up(db);
+      recordSchemaMigration(db, migration.version, migration.name);
+      applied.add(migration.version);
+      version = migration.version;
+      writeSchemaVersion(db, version);
+    }
+    if (version === 0) {
+      version = DB_SCHEMA_VERSION;
+    }
+    for (const migration of migrations) {
+      if (migration.version <= version) recordSchemaMigration(db, migration.version, migration.name);
+    }
+    writeSchemaVersion(db, version);
+  });
 }
 
 function peerBindingRuntimeRank(row) {
@@ -1900,23 +2151,32 @@ function touchCurrentPeer(db, ctx, resolved, status = null, kindHint = 'shell')
   });
 }
 
-function sendMessage(db, sender, recipient, taskId, kind, body) {
+function sendMessage(db, sender, recipient, taskId, kind, body, meta = {}) {
+  const replyTo = meta.reply_to || null;
+  const threadId = meta.thread_id || null;
   const info = db.prepare(`
-    INSERT INTO messages(sender, recipient, task_id, kind, body, created_at)
-    VALUES (?, ?, ?, ?, ?, ?)
-  `).run(sender, recipient || 'all', taskId || null, kind || 'note', body, now());
+    INSERT INTO messages(sender, recipient, task_id, kind, body, reply_to, thread_id, created_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(sender, recipient || 'all', taskId || null, kind || 'note', body, replyTo, threadId, now());
+  const messageId = Number(info.lastInsertRowid);
+  if (!threadId) {
+    db.prepare('UPDATE messages SET thread_id = ? WHERE id = ?').run(messageId, messageId);
+  }
   addEvent(db, 'message.sent', sender, taskId || null, {
-    message_id: Number(info.lastInsertRowid),
+    message_id: messageId,
     recipient: recipient || 'all',
-    kind: kind || 'note'
+    kind: kind || 'note',
+    reply_to: replyTo,
+    thread_id: threadId || messageId
   });
-  return Number(info.lastInsertRowid);
+  return messageId;
 }
 
 function queryInbox(db, peer, includeAll, limit) {
   return db.prepare(`
     SELECT
-      m.id, m.sender, m.recipient, m.task_id, m.kind, m.body, m.created_at, r.read_at
+      m.id, m.sender, m.recipient, m.task_id, m.kind, m.body,
+      m.reply_to, m.thread_id, m.created_at, r.read_at
     FROM messages m
     LEFT JOIN message_reads r
       ON r.message_id = m.id AND r.peer = ?
@@ -1928,6 +2188,417 @@ function queryInbox(db, peer, includeAll, limit) {
   `).all(peer, peer, includeAll ? 1 : 0, limit);
 }
 
+function queryTimelineMessages(db, peer, limit) {
+  if (!peer) {
+    return db.prepare(`
+      SELECT id, sender, recipient, task_id, kind, body, reply_to, thread_id, created_at
+      FROM messages
+      ORDER BY id DESC
+      LIMIT ?
+    `).all(limit).reverse();
+  }
+  return db.prepare(`
+    SELECT
+      m.id, m.sender, m.recipient, m.task_id, m.kind, m.body,
+      m.reply_to, m.thread_id, m.created_at, r.read_at
+    FROM messages m
+    LEFT JOIN message_reads r
+      ON r.message_id = m.id AND r.peer = ?
+    WHERE
+      m.sender = ?
+      OR m.recipient IS NULL
+      OR m.recipient = ''
+      OR m.recipient = 'all'
+      OR m.recipient = ?
+    ORDER BY m.id DESC
+    LIMIT ?
+  `).all(peer, peer, peer, limit).reverse();
+}
+
+function getMessage(db, id) {
+  return db.prepare(`
+    SELECT id, sender, recipient, task_id, kind, body, reply_to, thread_id, created_at
+    FROM messages
+    WHERE id = ?
+  `).get(id);
+}
+
+function queryMessageThread(db, messageId, limit) {
+  const message = getMessage(db, messageId);
+  if (!message) throw new CliError('NOT_FOUND', `Message #${messageId} does not exist`);
+  const threadId = message.thread_id || message.id;
+  const rows = db.prepare(`
+    SELECT id, sender, recipient, task_id, kind, body, reply_to, thread_id, created_at
+    FROM messages
+    WHERE id = ? OR thread_id = ?
+    ORDER BY id ASC
+    LIMIT ?
+  `).all(message.id, threadId, limit);
+  return { message, thread_id: threadId, messages: rows };
+}
+
+function parseEventPayload(row) {
+  try {
+    return row?.payload ? JSON.parse(row.payload) : {};
+  } catch {
+    return {};
+  }
+}
+
+function compactText(value, limit = 160) {
+  const text = String(value || '').replace(/\s+/g, ' ').trim();
+  return text.length > limit ? `${text.slice(0, limit - 1)}…` : text;
+}
+
+function uniqueList(values) {
+  return [...new Set(values.filter(Boolean).map(String))];
+}
+
+function messageParticipants(message) {
+  const participants = [message.sender];
+  if (message.recipient && !['all', ''].includes(message.recipient)) participants.push(message.recipient);
+  return uniqueList(participants);
+}
+
+function taskParticipants(task) {
+  return uniqueList([task.created_by, task.owner, task.assignee]);
+}
+
+function payloadParticipants(payload) {
+  const values = [];
+  for (const key of ['peer', 'from_peer', 'to_peer', 'assignee', 'owner', 'recipient', 'kept_peer', 'removed_peer', 'previous_owner']) {
+    if (payload?.[key] && payload[key] !== 'all') values.push(payload[key]);
+  }
+  return uniqueList(values);
+}
+
+function peerMatchesTimelineItem(item, peer) {
+  if (!peer) return true;
+  if (item.broadcast) return true;
+  return (item.peers || []).includes(peer);
+}
+
+function shouldHideTimelineMessage(message) {
+  if (message.kind === 'task' && /^Task #\d+ assigned: /.test(message.body || '')) return true;
+  if (message.kind === 'handoff' && /^Handoff #\d+: /.test(message.body || '')) return true;
+  return false;
+}
+
+const TIMELINE_EVENT_ALLOW = new Set([
+  'task.created',
+  'task.claimed',
+  'task.pending',
+  'task.running',
+  'task.review',
+  'task.blocked',
+  'task.done',
+  'task.abandoned',
+  'team.started',
+  'lock.acquired',
+  'lock.released',
+  'peer.registered',
+  'peer.joined',
+  'peer.auto_joined',
+  'peer.stopped',
+  'provider.session.merged',
+  'web.session.started',
+  'web.session.exited',
+  'tmux.session.attached',
+  'tmux.session.detached',
+  'tmux.session.exited',
+  'run.session.started',
+  'run.session.exited'
+]);
+
+function shouldHideTimelineEvent(event) {
+  if (['message.sent', 'message.ack', 'handoff.created', 'lock.renewed'].includes(event.type)) return true;
+  if (event.type && event.type.startsWith('hook.')) return true;
+  if (event.type && event.type.startsWith('web.session.input')) return true;
+  return !TIMELINE_EVENT_ALLOW.has(event.type);
+}
+
+function timelineDirection(message, peer) {
+  if (!peer) return message.recipient === 'all' ? 'broadcast' : 'project';
+  if (message.sender === peer && message.recipient === peer) return 'self';
+  if (message.sender === peer) return 'out';
+  if (message.recipient === 'all') return 'broadcast';
+  if (message.recipient === peer) return 'in';
+  return 'project';
+}
+
+function timelineFromRows({ messages = [], handoffs = [], tasks = [], locks = [], events = [] }, peer = null) {
+  const items = [];
+  for (const message of messages) {
+    if (shouldHideTimelineMessage(message)) continue;
+    const item = {
+      id: `message:${message.id}`,
+      source: 'message',
+      source_id: message.id,
+      ts: message.created_at,
+      actor: message.sender,
+      peers: messageParticipants(message),
+      task_id: message.task_id || null,
+      kind: message.kind || 'note',
+      title: `${message.sender} -> ${message.recipient || 'all'}`,
+      text: compactText(message.body),
+      unread: message.read_at === null || message.read_at === undefined,
+      direction: timelineDirection(message, peer),
+      thread_id: message.thread_id || message.id,
+      reply_to: message.reply_to || null,
+      broadcast: !message.recipient || message.recipient === 'all'
+    };
+    if (peerMatchesTimelineItem(item, peer)) items.push(item);
+  }
+  for (const handoff of handoffs) {
+    const item = {
+      id: `handoff:${handoff.id}`,
+      source: 'handoff',
+      source_id: handoff.id,
+      ts: handoff.created_at,
+      actor: handoff.from_peer,
+      peers: uniqueList([handoff.from_peer, handoff.to_peer]),
+      task_id: handoff.task_id || null,
+      kind: 'handoff',
+      title: `handoff ${handoff.from_peer}${handoff.to_peer ? ` -> ${handoff.to_peer}` : ''}`,
+      text: compactText(handoff.summary),
+      direction: 'project',
+      broadcast: !handoff.to_peer,
+      tests: handoff.tests || '',
+      risks: handoff.risks || ''
+    };
+    if (peerMatchesTimelineItem(item, peer)) items.push(item);
+  }
+  for (const task of tasks) {
+    const item = {
+      id: `task:${task.id}`,
+      source: 'task',
+      source_id: task.id,
+      ts: task.updated_at || task.created_at,
+      actor: task.owner || task.created_by || task.assignee || '',
+      peers: taskParticipants(task),
+      task_id: task.id,
+      kind: task.status,
+      title: `task #${task.id} ${task.status}${task.parent_id ? ` child of #${task.parent_id}` : ''}`,
+      text: compactText(task.title),
+      direction: 'project'
+    };
+    if (peerMatchesTimelineItem(item, peer)) items.push(item);
+  }
+  for (const lock of locks) {
+    const item = {
+      id: `lock:${lock.resource}`,
+      source: 'lock',
+      source_id: lock.resource,
+      ts: lock.created_at,
+      actor: lock.owner,
+      peers: uniqueList([lock.owner]),
+      task_id: lock.task_id || null,
+      kind: 'active',
+      title: `lock ${lock.resource}`,
+      text: compactText(lock.reason || `owner=${lock.owner}`),
+      direction: 'project'
+    };
+    if (peerMatchesTimelineItem(item, peer)) items.push(item);
+  }
+  for (const event of events) {
+    if (shouldHideTimelineEvent(event)) continue;
+    const payload = parseEventPayload(event);
+    const item = {
+      id: `event:${event.id}`,
+      source: 'event',
+      source_id: event.id,
+      ts: event.created_at,
+      actor: event.actor || '',
+      peers: uniqueList([event.actor, ...payloadParticipants(payload)]),
+      task_id: event.task_id || null,
+      kind: event.type,
+      title: event.type,
+      text: compactText(payload.summary || payload.reason || payload.title || payload.resource || payload.peer || ''),
+      direction: 'project'
+    };
+    if (peerMatchesTimelineItem(item, peer)) items.push(item);
+  }
+  const order = { message: 10, handoff: 20, task: 30, lock: 40, event: 50 };
+  items.sort((a, b) =>
+    (a.ts || 0) - (b.ts || 0) ||
+    (order[a.source] || 99) - (order[b.source] || 99) ||
+    String(a.source_id).localeCompare(String(b.source_id), undefined, { numeric: true }));
+  return items.slice(-120);
+}
+
+function actionCommand(argv) {
+  if (!argv?.length) return '';
+  return [CLI_NAME, ...argv].map(shellQuoteArg).join(' ');
+}
+
+function makeAction(kind, argv, reason, mutates = true, extra = {}) {
+  return {
+    kind,
+    reason,
+    mutates,
+    argv,
+    command: actionCommand(argv),
+    ...extra
+  };
+}
+
+function looksLikeMultiTask(task) {
+  if (!task) return false;
+  const text = `${task.title || ''}\n${task.body || ''}`;
+  const bullets = text.split('\n').filter((line) => /^\s*(?:[-*]|\d+[.)])\s+\S+/.test(line)).length;
+  const separators = (text.match(/[,，;；、]/g) || []).length;
+  return bullets >= 2 || separators >= 3 || /多任务|并行|团队|分工|several tasks|multiple tasks|parallel|team/i.test(text);
+}
+
+function selectCurrentTask(tasks, peerId) {
+  if (!peerId) return null;
+  const statusRank = { running: 0, claimed: 1, review: 2, blocked: 3 };
+  const openTasks = (tasks || []).filter((task) => !['done', 'abandoned'].includes(task.status));
+  const ownedTasks = openTasks
+    .filter((task) => task.owner === peerId)
+    .sort((a, b) =>
+      (statusRank[a.status] ?? 9) - (statusRank[b.status] ?? 9) ||
+      Number(a.priority || 0) - Number(b.priority || 0) ||
+      Number(a.id || 0) - Number(b.id || 0));
+  return ownedTasks.find((task) => ['running', 'claimed', 'review', 'blocked'].includes(task.status)) || ownedTasks[0] || null;
+}
+
+function summarizeTask(task) {
+  if (!task) return null;
+  return {
+    id: task.id,
+    title: task.title,
+    status: task.status,
+    owner: task.owner || null,
+    assignee: task.assignee || null,
+    parent_id: task.parent_id || null,
+    team_role: task.team_role || null,
+    priority: task.priority
+  };
+}
+
+function deriveAutomation(snapshot, peer = null, opts = {}) {
+  const peerId = peer || '';
+  const t = Number(snapshot.now || now());
+  const peerRow = peerId ? snapshot.peers.find((row) => row.id === peerId) : null;
+  const openTasks = (snapshot.tasks || []).filter((task) => !['done', 'abandoned'].includes(task.status));
+  const assignedTasks = peerId ? openTasks.filter((task) => !task.owner && task.assignee === peerId) : [];
+  const availableTasks = openTasks.filter((task) => !task.owner && !task.assignee);
+  const ownedTask = selectCurrentTask(openTasks, peerId);
+  const resources = uniqueList(Array.isArray(opts.resources) ? opts.resources : (opts.resource ? [opts.resource] : []));
+  const ownLocks = peerId ? (snapshot.locks || []).filter((lock) => lock.owner === peerId) : [];
+  const requestedLocks = resources.map((resource) => {
+    const lock = (snapshot.locks || []).find((row) => row.resource === resource && Number(row.expires_at || 0) > t);
+    return { resource, lock };
+  });
+  const conflict = requestedLocks.find((entry) => entry.lock && entry.lock.owner !== peerId);
+  const missingLock = requestedLocks.find((entry) => !entry.lock);
+  const unread = peerId ? (snapshot.messages || []).filter((message) =>
+    message.read_at === null || message.read_at === undefined) : [];
+  const warnings = [];
+  if (peerId && !peerRow) warnings.push(`peer ${peerId} is not registered in this project`);
+  const lockActions = [];
+  const messageActions = [];
+  const taskActions = [];
+  const automation = {
+    schema_version: 1,
+    peer: peerId ? {
+      id: peerId,
+      known: Boolean(peerRow),
+      active: Boolean(peerRow && Number(peerRow.age_sec || 0) <= ACTIVE_PEER_TTL),
+      age_sec: peerRow ? Number(peerRow.age_sec || 0) : null
+      } : null,
+      current_task: summarizeTask(ownedTask),
+      phase: 'idle',
+      next_action: makeAction('none', [], 'no immediate coordination action', false),
+      actions: [],
+      finish_actions: [],
+      warnings
+    };
+
+  const orderedUnread = unread
+    .filter((message) => message.sender !== peerId)
+    .filter((message) => !shouldHideTimelineMessage(message))
+    .sort((a, b) => (a.kind === 'task' ? 1 : 0) - (b.kind === 'task' ? 1 : 0) || a.id - b.id);
+  for (const message of orderedUnread) {
+    if (ownedTask && message.kind === 'task') continue;
+    const kind = message.kind === 'task' ? 'msg.inbox' : 'msg.reply';
+    const argv = kind === 'msg.reply'
+      ? ['msg', 'reply', '--from', peerId, '--id', String(message.id), '--body', '<answer>']
+      : ['msg', 'inbox', '--peer', peerId];
+    messageActions.push(makeAction(kind, argv, `unread message #${message.id} from ${message.sender}`, kind !== 'msg.inbox', {
+      message_id: message.id,
+      task_id: message.task_id || null
+    }));
+  }
+
+  if (!ownedTask && assignedTasks.length) {
+    const task = assignedTasks[0];
+    taskActions.push(makeAction('task.claim', ['task', 'claim', '--peer', peerId, '--id', String(task.id)], `assigned task #${task.id}`, true, { task_id: task.id }));
+  } else if (!ownedTask && availableTasks.length) {
+    taskActions.push(makeAction('task.next', ['task', 'next', '--peer', peerId], 'available pending task exists', true));
+  }
+
+  if (ownedTask) {
+    if (conflict) {
+      lockActions.push(makeAction('msg.send', ['msg', 'send', '--from', peerId, '--to', conflict.lock.owner, '--task', String(ownedTask.id), '--body', `Please coordinate ${conflict.resource}; it is locked by ${conflict.lock.owner}.`], `${conflict.resource} is locked by ${conflict.lock.owner}`, true, { task_id: ownedTask.id, resource: conflict.resource, lock_owner: conflict.lock.owner }));
+    } else if (missingLock) {
+      lockActions.push(makeAction('lock.acquire', ['lock', 'acquire', '--peer', peerId, '--task', String(ownedTask.id), '--resource', missingLock.resource, '--ttl', String(DEFAULT_LOCK_TTL), '--reason', '<work>'], `task #${ownedTask.id} needs lock for ${missingLock.resource}`, true, { task_id: ownedTask.id, resource: missingLock.resource }));
+    }
+    if (ownedTask.status === 'claimed') {
+      taskActions.push(makeAction('task.update', ['task', 'update', '--peer', peerId, '--id', String(ownedTask.id), '--status', 'running', '--summary', '<started>'], `task #${ownedTask.id} is claimed but not running`, true, { task_id: ownedTask.id }));
+    }
+    if (!ownedTask.parent_id && looksLikeMultiTask(ownedTask)) {
+      const childCount = openTasks.filter((task) => task.parent_id === ownedTask.id && !['done', 'abandoned'].includes(task.status)).length;
+      if (!childCount) {
+        taskActions.push(makeAction('team.plan', ['team', 'plan', '--from-task', String(ownedTask.id)], `task #${ownedTask.id} looks splittable; plan explicit team subtasks`, false, { task_id: ownedTask.id }));
+      }
+    }
+    automation.finish_actions.push(makeAction('handoff.create', ['handoff', 'create', '--from', peerId, '--task', String(ownedTask.id), '--summary', '<summary>', '--tests', '<tests>', '--risks', '<risks>'], `handoff task #${ownedTask.id} before stopping`, true, { task_id: ownedTask.id }));
+    automation.finish_actions.push(makeAction('task.done', ['task', 'done', '--peer', peerId, '--id', String(ownedTask.id), '--summary', '<summary>'], `mark task #${ownedTask.id} done after handoff`, true, { task_id: ownedTask.id }));
+    for (const lock of ownLocks) {
+      automation.finish_actions.push(makeAction('lock.release', ['lock', 'release', '--peer', peerId, '--resource', lock.resource], `release ${lock.resource}`, true, { task_id: lock.task_id || null, resource: lock.resource }));
+    }
+  }
+  automation.actions.push(...lockActions, ...messageActions, ...taskActions);
+
+  if (opts.intent === 'finish' || opts.intent === 'stop') {
+    automation.phase = ownedTask ? 'handoff' : 'idle';
+    automation.next_action = automation.finish_actions[0] || automation.next_action;
+    return automation;
+  }
+  automation.next_action = automation.actions[0] || (ownedTask
+    ? makeAction('none', [], `continue task #${ownedTask.id}`, false, { task_id: ownedTask.id })
+    : automation.next_action);
+  if (automation.next_action.kind === 'msg.reply' || automation.next_action.kind === 'msg.inbox') automation.phase = 'reply_message';
+  else if (automation.next_action.kind === 'task.claim' || automation.next_action.kind === 'task.next') automation.phase = 'claim_task';
+  else if (automation.next_action.kind === 'lock.acquire') automation.phase = 'acquire_lock';
+  else if (automation.next_action.kind === 'msg.send') automation.phase = 'coordinate_lock';
+  else if (automation.next_action.kind === 'team.plan') automation.phase = 'team_plan';
+  else if (ownedTask) automation.phase = ownedTask.status === 'review' ? 'handoff' : 'work';
+  return automation;
+}
+
+function renderAutomationContext(automation) {
+  if (!automation) return '';
+  const lines = [
+    '[hello-cc next action]',
+    `phase: ${automation.phase}`,
+    automation.current_task ? `current_task: #${automation.current_task.id} ${automation.current_task.status} ${automation.current_task.title}` : null,
+    `next: ${automation.next_action.command || automation.next_action.kind}`,
+    `why: ${automation.next_action.reason}`
+  ].filter(Boolean);
+  if (automation.finish_actions?.length) {
+    lines.push('finish:');
+    for (const action of automation.finish_actions.slice(0, 4)) lines.push(`- ${action.command}`);
+  }
+  if (automation.warnings?.length) {
+    lines.push('warnings:');
+    for (const warning of automation.warnings.slice(0, 4)) lines.push(`- ${warning}`);
+  }
+  return lines.join('\n');
+}
+
 function queryOpenTasks(db, limit, peer = null) {
   const sql = `
     SELECT * FROM tasks
@@ -1970,29 +2641,81 @@ function formatHookEventName(hookType) {
   return known[compact] || String(hookType || 'unknown');
 }
 
-function buildHookCoordinationContext(db, peerId) {
-  const openTasks = queryOpenTasks(db, 8);
-  const unread = queryInbox(db, peerId, false, 5);
+function collectStateSnapshot(db, ctx, peer = null, opts = {}) {
   const t = now();
   const peers = db.prepare(`
-    SELECT id, kind, status, last_seen_at
+    SELECT id, kind, role, status, worktree, branch, pid, capabilities,
+           created_at, last_seen_at, (? - last_seen_at) AS age_sec
     FROM peers
     ORDER BY last_seen_at DESC, id ASC
-    LIMIT 8
-  `).all();
+    LIMIT 200
+  `).all(t);
+  const tasks = queryOpenTasks(db, 200);
+  const locks = db.prepare(`
+    SELECT resource, owner, task_id, reason, expires_at, created_at
+    FROM locks
+    WHERE expires_at > ?
+    ORDER BY resource ASC
+    LIMIT 200
+  `).all(t);
+  const messages = peer
+    ? queryInbox(db, peer, false, 50)
+    : db.prepare(`
+        SELECT id, sender, recipient, task_id, kind, body, reply_to, thread_id, created_at
+        FROM messages
+        ORDER BY id DESC
+        LIMIT 50
+      `).all().reverse();
+  const timelineMessages = queryTimelineMessages(db, peer, 80);
+  const handoffs = db.prepare(`
+    SELECT id, task_id, from_peer, to_peer, summary, changed_files, tests, risks, created_at
+    FROM handoffs
+    ORDER BY id DESC
+    LIMIT 50
+  `).all().reverse();
+  const events = db.prepare(`
+    SELECT id, type, actor, task_id, payload, created_at
+    FROM events
+    ORDER BY id DESC
+    LIMIT 80
+  `).all().reverse();
+  const snapshot = {
+    root: ctx.root,
+    db: ctx.dbPath,
+    now: t,
+    active_peer_ttl: ACTIVE_PEER_TTL,
+    peers,
+    tasks,
+    locks,
+    messages,
+    handoffs,
+    events
+  };
+  snapshot.timeline = timelineFromRows({ messages: timelineMessages, handoffs, tasks, locks, events }, peer);
+  snapshot.automation = deriveAutomation(snapshot, peer, opts);
+  return snapshot;
+}
+
+function buildHookCoordinationContext(db, ctx, peerId) {
+  const snapshot = collectStateSnapshot(db, ctx, peerId);
+  const openTasks = snapshot.tasks.slice(0, 8);
+  const unread = snapshot.messages.slice(0, 5);
+  const peers = snapshot.peers.slice(0, 8);
   const parts = [
     '[hello-cc coordination]',
     `peer: ${peerId}`,
     'This is live project coordination context injected by hello-cc.',
     'You are not isolated for project coordination: hcc is the source of truth for other Claude/Codex/shell sessions in this project.',
-    'If the user asks what other sessions are doing, what tasks exist, or whether you can see other sessions, do not answer from generic model knowledge and do not say sessions are isolated. Run hcc status, hcc peers, hcc task list, hcc msg inbox, and hcc lock list, then answer from those results.',
-    'Tasks are project work facts, not read/unread items. Open tasks stay relevant to every session until they are marked done or abandoned. Messages are the unread/ack notification channel.'
+    'If the user asks what other sessions are doing, what tasks exist, or whether you can see other sessions, do not answer from generic model knowledge and do not say sessions are isolated. Run hcc status, hcc state, hcc peers, hcc task list, hcc msg inbox, and hcc lock list, then answer from those results.',
+    'Tasks are project work facts, not read/unread items. Open tasks stay relevant to every session until they are marked done or abandoned. Messages are the unread/ack notification channel.',
+    'If you already own a current task, continue that task until handoff/done/blocked; do not claim a different task just because a new prompt arrived.',
+    'When a hello-cc message asks for a response, reply with hcc msg reply --id <message-id> --body "<answer>" so the answer stays in the same thread.'
   ];
 
   if (peers.length > 0) {
     parts.push('[hello-cc known peers]');
     parts.push(...peers.map((peer) => {
-      const age = Math.max(0, t - Number(peer.last_seen_at || 0));
+      const age = Math.max(0, snapshot.now - Number(peer.last_seen_at || 0));
       const active = age <= ACTIVE_PEER_TTL ? 'active' : 'stale';
       return `- ${peer.id} ${peer.kind || 'other'} ${peer.status || 'idle'} ${active}`;
     }));
@@ -2000,6 +2723,12 @@ function buildHookCoordinationContext(db, peerId) {
     parts.push('[hello-cc known peers]\n(none)');
   }
 
+  if (snapshot.automation.current_task) {
+    const task = snapshot.automation.current_task;
+    parts.push('[hello-cc current task]');
+    parts.push(`#${task.id} ${task.status}: ${task.title}`);
+  }
+
   if (openTasks.length > 0) {
     parts.push('[hello-cc open tasks]');
     parts.push(...openTasks.map((task) => `- ${formatOpenTaskLine(task)}`));
@@ -2010,12 +2739,22 @@ function buildHookCoordinationContext(db, peerId) {
   if (unread.length > 0) {
     parts.push('[hello-cc unread messages]');
     parts.push(...unread.map((m) =>
-      `- #${m.id} from ${m.sender}${m.task_id ? ` task #${m.task_id}` : ''}: ${m.body}`
+      `- #${m.id} from ${m.sender}${m.task_id ? ` task #${m.task_id}` : ''}${m.reply_to ? ` reply #${m.reply_to}` : ''}: ${m.body}`
     ));
   } else {
     parts.push('[hello-cc unread messages]\n(none)');
   }
 
+  if (snapshot.locks.length > 0) {
+    parts.push('[hello-cc active locks]');
+    parts.push(...snapshot.locks.slice(0, 8).map((lock) =>
+      `- ${lock.resource} owner=${lock.owner}${lock.task_id ? ` task #${lock.task_id}` : ''}`));
+  } else {
+    parts.push('[hello-cc active locks]\n(none)');
+  }
+
+  parts.push(renderAutomationContext(snapshot.automation));
+
   return { text: parts.join('\n'), messages: unread };
 }
 
@@ -2061,78 +2800,11 @@ function table(rows, columns) {
 }
 
 function writeGuidance(ctx) {
-  const guidePath = path.join(ctx.root, '.hello-cc', 'HCC.md');
-  fs.mkdirSync(path.dirname(guidePath), { recursive: true });
-  const content = `# hello-cc Coordination Rules
-
-This project may be edited by multiple Claude Code and Codex CLI sessions.
-
-Use \`hcc\` as the source of truth for cross-session coordination. If the user
-asks what other sessions are doing, do not answer from generic model knowledge.
-Run the project-local commands below and summarize the result.
-
-Each terminal session must use a stable peer id, for example codex-a,
-codex-b, claude-a, claude-b, or gpu-runner-a.
-
-Status checks:
-- \`hcc peers\` shows known Claude/Codex/shell sessions.
-- \`hcc task list\` shows all open tasks. Tasks stay visible until \`done\` or
-  \`abandoned\`; they are not read/unread items.
-- \`hcc msg inbox\` shows unread messages for this session.
-- \`hcc lock list\` shows active advisory locks.
-- \`hcc status\` summarizes peers, tasks, locks, inbox, and recent events.
-
-Before work:
-- Register with hcc.
-- Read current status with \`hcc status\`, \`hcc task list\`, and \`hcc msg inbox\`.
-- Claim one task before editing.
-
-Before editing:
-- Acquire an advisory lock for the file, directory, module, or shared resource.
-- If another live peer holds the lock, message that peer instead of editing.
-
-During work:
-- Keep changes scoped to the claimed task.
-- Send progress messages when another session needs context.
-
-Before stopping:
-- Mark the task done or blocked.
-- Create a handoff with changed files, tests, and remaining risks.
-- Release locks you no longer need.
-`;
-  fs.writeFileSync(guidePath, content);
-  const clause = `\n<!-- hello-cc:start -->\n\n${content}\n<!-- hello-cc:end -->\n`;
-  for (const file of ['CLAUDE.md', 'AGENTS.md']) {
-    const target = path.join(ctx.root, file);
-    if (!fs.existsSync(target)) {
-      fs.writeFileSync(target, clause.trimStart());
-      continue;
-    }
-    const existing = fs.readFileSync(target, 'utf8');
-    const updated = existing.includes('<!-- hello-cc:start -->')
-      ? existing.replace(/<!-- hello-cc:start -->[\s\S]*?<!-- hello-cc:end -->/, clause.trim())
-      : `${existing.trimEnd()}\n${clause}`;
-    fs.writeFileSync(target, updated);
-  }
-  return guidePath;
+  return writeGuidanceForRoot(ctx.root);
 }
 
 function removeGuidanceBlocks(ctx) {
-  const changed = [];
-  for (const file of ['CLAUDE.md', 'AGENTS.md']) {
-    const target = path.join(ctx.root, file);
-    if (!fs.existsSync(target)) continue;
-    const existing = fs.readFileSync(target, 'utf8');
-    const updated = existing
-      .replace(/\n?<!-- hello-cc:start -->[\s\S]*?<!-- hello-cc:end -->\n?/g, '\n')
-      .replace(/\n{3,}/g, '\n\n')
-      .trimEnd();
-    if (updated !== existing) {
-      fs.writeFileSync(target, updated ? `${updated}\n` : '');
-      changed.push(target);
-    }
-  }
-  return changed;
+  return removeGuidanceBlocksForRoot(ctx.root);
 }
 
 function normalizeListText(value, fallback = []) {
@@ -2316,22 +2988,28 @@ async function taskCreate(ctx, args) {
   const createdBy = identity.id;
   const assignee = opts.to || opts.assignee || null;
   const priority = intOpt(opts, 'priority', 100);
+  const parentId = intOpt(opts, 'parent', null);
+  const teamRole = opts.role || opts['team-role'] || null;
   const db = connect(ctx);
   touchCurrentPeer(db, ctx, identity, null, 'shell');
   const t = now();
   const id = tx(db, () => {
+    if (parentId && !db.prepare('SELECT id FROM tasks WHERE id = ?').get(parentId)) {
+      throw new CliError('NOT_FOUND', `Parent task #${parentId} does not exist`);
+    }
     const info = db.prepare(`
-      INSERT INTO tasks(title, body, status, assignee, owner, priority, created_by, created_at, updated_at)
-      VALUES (?, ?, 'pending', ?, NULL, ?, ?, ?, ?)
-    `).run(title, body, assignee, priority, createdBy, t, t);
+      INSERT INTO tasks(title, body, status, assignee, owner, parent_id, team_role, priority, created_by, created_at, updated_at)
+      VALUES (?, ?, 'pending', ?, NULL, ?, ?, ?, ?, ?, ?)
+    `).run(title, body, assignee, parentId, teamRole, priority, createdBy, t, t);
     const taskId = Number(info.lastInsertRowid);
-    addEvent(db, 'task.created', createdBy, taskId, { title, assignee, priority });
+    addEvent(db, 'task.created', createdBy, taskId, { title, assignee, priority, parent_id: parentId, team_role: teamRole });
     if (assignee) {
       sendMessage(db, createdBy, assignee, taskId, 'task', `Task #${taskId} assigned: ${title}`);
     }
     return taskId;
   });
-  printResult(ctx, { id, title, assignee, priority }, (data) => `created task #${data.id}: ${data.title}${data.assignee ? ` -> ${data.assignee}` : ''}`);
+  printResult(ctx, { id, title, assignee, priority, parent_id: parentId, team_role: teamRole },
+    (data) => `created task #${data.id}: ${data.title}${data.assignee ? ` -> ${data.assignee}` : ''}${data.parent_id ? ` (child of #${data.parent_id})` : ''}`);
 }
 
 async function taskList(ctx, args) {
@@ -2369,6 +3047,8 @@ async function taskList(ctx, args) {
     { label: 'prio', value: (r) => r.priority },
     { label: 'assignee', value: (r) => r.assignee || '' },
     { label: 'owner', value: (r) => r.owner || '' },
+    { label: 'parent', value: (r) => r.parent_id ? `#${r.parent_id}` : '' },
+    { label: 'role', value: (r) => r.team_role || '' },
     { label: 'title', value: (r) => r.title }
   ]));
 }
@@ -2406,31 +3086,18 @@ async function taskClaim(ctx, args) {
 }
 
 async function taskNext(ctx, args) {
-  const opts = parseOpts(args);
+  const opts = parseOpts(args, { booleans: ['force'] });
   const identity = resolveCurrentPeer(ctx, opts, 'peer', 'shell');
   const peer = identity.id;
   const db = connect(ctx);
   touchCurrentPeer(db, ctx, identity, 'working', 'shell');
-  const task = tx(db, () => {
-    const row = db.prepare(`
-      SELECT * FROM tasks
-      WHERE status = 'pending'
-        AND owner IS NULL
-        AND (assignee IS NULL OR assignee = ?)
-      ORDER BY CASE WHEN assignee = ? THEN 0 ELSE 1 END, priority ASC, id ASC
-      LIMIT 1
-    `).get(peer, peer);
-    if (!row) return null;
-    const t = now();
-    db.prepare(`
-      UPDATE tasks
-      SET owner = ?, status = 'claimed', claimed_at = ?, updated_at = ?
-      WHERE id = ? AND owner IS NULL AND status = 'pending'
-    `).run(peer, t, t, row.id);
-    addEvent(db, 'task.claimed', peer, row.id, { next: true });
-    return db.prepare('SELECT * FROM tasks WHERE id = ?').get(row.id);
+  const task = claimNextTaskForPeer(db, peer, Boolean(opts.force));
+  printResult(ctx, task, (data) => {
+    if (!data) return 'no pending task';
+    return data.current
+      ? `current task #${data.id}: ${data.title} (${data.status})`
+      : `claimed task #${data.id}: ${data.title}`;
   });
-  printResult(ctx, task, (data) => data ? `claimed task #${data.id}: ${data.title}` : 'no pending task');
 }
 
 async function taskUpdate(ctx, args) {
@@ -2474,33 +3141,245 @@ async function taskDone(ctx, args) {
   return taskUpdate(ctx, args.concat(['--status', 'done']));
 }
 
-async function cmdMsg(ctx, args) {
-  const sub = args[0];
-  if (!sub || wantsHelp(args)) return helpMsg();
-  if (sub === 'send') return msgSend(ctx, args.slice(1));
-  if (sub === 'inbox') return msgInbox(ctx, args.slice(1));
-  if (sub === 'ack') return msgAck(ctx, args.slice(1));
-  throw new CliError('BAD_ARGS', `Unknown msg command: ${sub}`);
+function splitCsvList(value) {
+  if (Array.isArray(value)) return value.flatMap((item) => splitCsvList(item));
+  return String(value || '').split(',').map((item) => item.trim()).filter(Boolean);
 }
 
-async function msgSend(ctx, args) {
-  const opts = parseOpts(args);
-  const identity = resolveCurrentPeer(ctx, opts, 'from', 'shell');
-  const sender = identity.id;
-  const recipient = opts.to || 'all';
-  const body = required(opts, 'body');
-  const taskId = intOpt(opts, 'task', null);
-  const kind = opts.kind || 'note';
-  const db = connect(ctx);
-  touchCurrentPeer(db, ctx, identity, null, 'shell');
-  const id = sendMessage(db, sender, recipient, taskId, kind, body);
-  printResult(ctx, { id, sender, recipient, task_id: taskId, kind, body }, (data) => `sent message #${data.id} ${data.sender} -> ${data.recipient}`);
+function parseTeamItems(opts) {
+  const rawItems = [
+    ...splitCsvList(opts.item || []),
+    ...splitCsvList(opts.items || [])
+  ];
+  return rawItems.map((raw, index) => {
+    const parts = String(raw).split(':').map((part) => part.trim());
+    let assignee = null;
+    let role = null;
+    let title = raw.trim();
+    if (parts.length >= 3) {
+      assignee = parts.shift() || null;
+      role = parts.shift() || null;
+      title = parts.join(':').trim();
+    } else if (parts.length === 2) {
+      role = parts[0] || null;
+      title = parts[1] || title;
+    }
+    if (!title) title = `subtask ${index + 1}`;
+    return { title, role: role || `worker-${index + 1}`, assignee };
+  });
 }
 
-async function msgInbox(ctx, args) {
-  const opts = parseOpts(args, { booleans: ['all'] });
-  const identity = resolveCurrentPeer(ctx, opts, 'peer', 'shell');
-  const peer = identity.id;
+function inferTeamItems(task, opts) {
+  const explicit = parseTeamItems(opts);
+  if (explicit.length) return explicit;
+  const count = Math.max(1, intOpt(opts, 'count', 3));
+  const baseTitle = task?.title || 'team task';
+  return Array.from({ length: count }, (_, index) => ({
+    title: `${baseTitle} / subtask ${index + 1}`,
+    role: `worker-${index + 1}`,
+    assignee: null
+  }));
+}
+
+function expandTeamWorkers(workers, parentId) {
+  const expanded = [];
+  for (const token of splitCsvList(workers || [])) {
+    const match = token.match(/^([A-Za-z][A-Za-z0-9._-]*):([1-9][0-9]*)$/);
+    if (!match) {
+      expanded.push(token);
+      continue;
+    }
+    const kind = sanitizePeerPart(match[1], 'peer');
+    const count = Number.parseInt(match[2], 10);
+    for (let i = 1; i <= count; i += 1) expanded.push(`${kind}-team-${parentId}-${i}`);
+  }
+  return expanded;
+}
+
+function assignTeamWorkers(items, workers, parentId) {
+  const workerList = expandTeamWorkers(workers, parentId);
+  if (!workerList.length) return items;
+  return items.map((item, index) => ({
+    ...item,
+    assignee: item.assignee || workerList[index % workerList.length]
+  }));
+}
+
+function teamChildren(db, parentId) {
+  return db.prepare(`
+    SELECT *
+    FROM tasks
+    WHERE parent_id = ?
+    ORDER BY priority ASC, id ASC
+  `).all(parentId);
+}
+
+function taskById(db, id) {
+  return db.prepare('SELECT * FROM tasks WHERE id = ?').get(id);
+}
+
+function teamSummary(db, parentId) {
+  const parent = taskById(db, parentId);
+  if (!parent) throw new CliError('NOT_FOUND', `Task #${parentId} does not exist`);
+  const children = teamChildren(db, parentId);
+  const handoffs = db.prepare(`
+    SELECT *
+    FROM handoffs
+    WHERE task_id = ? OR task_id IN (SELECT id FROM tasks WHERE parent_id = ?)
+    ORDER BY id ASC
+  `).all(parentId, parentId);
+  const counts = {};
+  for (const child of children) counts[child.status] = (counts[child.status] || 0) + 1;
+  return { parent, children, handoffs, counts };
+}
+
+async function cmdTeam(ctx, args) {
+  const sub = args[0];
+  if (!sub || wantsHelp(args)) return helpTeam();
+  if (sub === 'plan') return teamPlan(ctx, args.slice(1));
+  if (sub === 'start') return teamStart(ctx, args.slice(1));
+  if (sub === 'status') return teamStatus(ctx, args.slice(1));
+  throw new CliError('BAD_ARGS', `Unknown team command: ${sub}`);
+}
+
+async function teamPlan(ctx, args) {
+  const opts = parseOpts(args, { arrays: ['item'] });
+  const parentId = intOpt(opts, 'from-task', intOpt(opts, 'task', intOpt({ task: opts._[0] }, 'task')));
+  if (!parentId) throw new CliError('BAD_ARGS', 'Missing --from-task');
+  const db = connect(ctx);
+  const parent = taskById(db, parentId);
+  if (!parent) throw new CliError('NOT_FOUND', `Task #${parentId} does not exist`);
+  const items = assignTeamWorkers(inferTeamItems(parent, opts), opts.workers, parentId);
+  const data = { parent, items };
+  printResult(ctx, data, (plan) => {
+    const lines = [`team plan for task #${plan.parent.id}: ${plan.parent.title}`];
+    plan.items.forEach((item, index) => {
+      lines.push(`${index + 1}. ${item.role}: ${item.title}${item.assignee ? ` -> ${item.assignee}` : ''}`);
+    });
+    lines.push('', `start: ${CLI_NAME} team start --from-task ${plan.parent.id} ${plan.items.map((item) => `--item ${shellQuoteArg(`${item.assignee ? `${item.assignee}:` : ''}${item.role}:${item.title}`)}`).join(' ')}`.trim());
+    return lines.join('\n');
+  });
+}
+
+async function teamStart(ctx, args) {
+  const opts = parseOpts(args, { arrays: ['item'], booleans: ['force'] });
+  const identity = resolveCurrentPeer(ctx, opts, 'from', 'shell');
+  const actor = identity.id;
+  const parentId = intOpt(opts, 'from-task', intOpt(opts, 'task', intOpt({ task: opts._[0] }, 'task')));
+  if (!parentId) throw new CliError('BAD_ARGS', 'Missing --from-task');
+  const priorityBase = intOpt(opts, 'priority', 100);
+  const db = connect(ctx);
+  touchCurrentPeer(db, ctx, identity, null, 'shell');
+  const result = tx(db, () => {
+    const parent = taskById(db, parentId);
+    if (!parent) throw new CliError('NOT_FOUND', `Task #${parentId} does not exist`);
+    const existing = teamChildren(db, parentId);
+    if (existing.length && !opts.force) {
+      throw new CliError('TEAM_EXISTS', `Task #${parentId} already has ${existing.length} team subtask(s); use --force to add more`, {
+        parent_id: parentId,
+        children: existing.map((task) => task.id)
+      });
+    }
+    const items = assignTeamWorkers(inferTeamItems(parent, opts), opts.workers, parentId);
+    const t = now();
+    const children = [];
+    items.forEach((item, index) => {
+      const info = db.prepare(`
+        INSERT INTO tasks(title, body, status, assignee, owner, parent_id, team_role, priority, created_by, created_at, updated_at)
+        VALUES (?, ?, 'pending', ?, NULL, ?, ?, ?, ?, ?, ?)
+      `).run(
+        item.title,
+        opts.body || `Subtask for #${parentId}: ${parent.title}`,
+        item.assignee || null,
+        parentId,
+        item.role || `worker-${index + 1}`,
+        priorityBase + index,
+        actor,
+        t,
+        t
+      );
+      const taskId = Number(info.lastInsertRowid);
+      addEvent(db, 'task.created', actor, taskId, {
+        title: item.title,
+        assignee: item.assignee || null,
+        priority: priorityBase + index,
+        parent_id: parentId,
+        team_role: item.role || null
+      });
+      if (item.assignee) sendMessage(db, actor, item.assignee, taskId, 'task', `Task #${taskId} assigned: ${item.title}`);
+      children.push(taskById(db, taskId));
+    });
+    addEvent(db, 'team.started', actor, parentId, {
+      child_tasks: children.map((task) => task.id),
+      workers: expandTeamWorkers(opts.workers || [], parentId)
+    });
+    return { parent, children };
+  });
+  printResult(ctx, result, (data) => {
+    const lines = [`started team for task #${data.parent.id}: ${data.children.length} subtask${data.children.length === 1 ? '' : 's'}`];
+    for (const child of data.children) {
+      lines.push(`- #${child.id} ${child.team_role || 'worker'}${child.assignee ? ` -> ${child.assignee}` : ''}: ${child.title}`);
+    }
+    return lines.join('\n');
+  });
+}
+
+async function teamStatus(ctx, args) {
+  const opts = parseOpts(args);
+  const parentId = intOpt(opts, 'task', intOpt(opts, 'from-task', intOpt({ task: opts._[0] }, 'task')));
+  if (!parentId) throw new CliError('BAD_ARGS', 'Missing --task');
+  const db = connect(ctx);
+  const data = teamSummary(db, parentId);
+  printResult(ctx, data, (summary) => {
+    const countText = Object.entries(summary.counts).map(([status, count]) => `${status}:${count}`).join(', ') || 'none';
+    const lines = [
+      `team task #${summary.parent.id}: ${summary.parent.title}`,
+      `parent status: ${summary.parent.status}`,
+      `subtasks: ${summary.children.length} (${countText})`
+    ];
+    for (const child of summary.children) {
+      lines.push(`- #${child.id} ${child.status} ${child.team_role || 'worker'}${child.owner ? ` owner=${child.owner}` : ''}${child.assignee ? ` assignee=${child.assignee}` : ''}: ${child.title}`);
+    }
+    if (summary.handoffs.length) {
+      lines.push('handoffs:');
+      for (const handoff of summary.handoffs.slice(-8)) {
+        lines.push(`- #${handoff.id} task #${handoff.task_id || ''} ${handoff.from_peer}${handoff.to_peer ? ` -> ${handoff.to_peer}` : ''}: ${handoff.summary}`);
+      }
+    }
+    return lines.join('\n');
+  });
+}
+
+async function cmdMsg(ctx, args) {
+  const sub = args[0];
+  if (!sub || wantsHelp(args)) return helpMsg();
+  if (sub === 'send') return msgSend(ctx, args.slice(1));
+  if (sub === 'inbox') return msgInbox(ctx, args.slice(1));
+  if (sub === 'ack') return msgAck(ctx, args.slice(1));
+  if (sub === 'reply') return msgReply(ctx, args.slice(1));
+  if (sub === 'thread') return msgThread(ctx, args.slice(1));
+  throw new CliError('BAD_ARGS', `Unknown msg command: ${sub}`);
+}
+
+async function msgSend(ctx, args) {
+  const opts = parseOpts(args);
+  const identity = resolveCurrentPeer(ctx, opts, 'from', 'shell');
+  const sender = identity.id;
+  const recipient = opts.to || 'all';
+  const body = required(opts, 'body');
+  const taskId = intOpt(opts, 'task', null);
+  const kind = opts.kind || 'note';
+  const db = connect(ctx);
+  touchCurrentPeer(db, ctx, identity, null, 'shell');
+  const id = sendMessage(db, sender, recipient, taskId, kind, body);
+  printResult(ctx, { id, sender, recipient, task_id: taskId, kind, body, reply_to: null, thread_id: id },
+    (data) => `sent message #${data.id} ${data.sender} -> ${data.recipient}`);
+}
+
+async function msgInbox(ctx, args) {
+  const opts = parseOpts(args, { booleans: ['all'] });
+  const identity = resolveCurrentPeer(ctx, opts, 'peer', 'shell');
+  const peer = identity.id;
   const waitSec = intOpt(opts, 'wait', 0);
   const limit = intOpt(opts, 'limit', 20);
   const includeAll = Boolean(opts.all);
@@ -2517,6 +3396,8 @@ async function msgInbox(ctx, args) {
     { label: 'from', value: (r) => r.sender },
     { label: 'kind', value: (r) => r.kind },
     { label: 'task', value: (r) => r.task_id ? `#${r.task_id}` : '' },
+    { label: 'reply', value: (r) => r.reply_to ? `#${r.reply_to}` : '' },
+    { label: 'thread', value: (r) => r.thread_id ? `#${r.thread_id}` : '' },
     { label: 'time', value: (r) => iso(r.created_at) },
     { label: 'body', value: (r) => r.body }
   ]));
@@ -2532,13 +3413,73 @@ async function msgAck(ctx, args) {
   touchCurrentPeer(db, ctx, identity, null, 'shell');
   const message = db.prepare('SELECT * FROM messages WHERE id = ?').get(id);
   if (!message) throw new CliError('NOT_FOUND', `Message #${id} does not exist`);
+  ackMessage(db, peer, message);
+  printResult(ctx, { id, peer }, (data) => `acknowledged message #${data.id} for ${data.peer}`);
+}
+
+function ackMessage(db, peer, message) {
   db.prepare(`
     INSERT INTO message_reads(message_id, peer, read_at)
     VALUES (?, ?, ?)
     ON CONFLICT(message_id, peer) DO UPDATE SET read_at = excluded.read_at
-  `).run(id, peer, now());
-  addEvent(db, 'message.ack', peer, message.task_id || null, { message_id: id });
-  printResult(ctx, { id, peer }, (data) => `acknowledged message #${data.id} for ${data.peer}`);
+  `).run(message.id, peer, now());
+  addEvent(db, 'message.ack', peer, message.task_id || null, { message_id: message.id });
+}
+
+async function msgReply(ctx, args) {
+  const opts = parseOpts(args);
+  const id = intOpt(opts, 'id', intOpt({ id: opts._[0] }, 'id'));
+  if (!id) throw new CliError('BAD_ARGS', 'Missing --id');
+  const body = required(opts, 'body');
+  const db = connect(ctx);
+  const original = getMessage(db, id);
+  if (!original) throw new CliError('NOT_FOUND', `Message #${id} does not exist`);
+  const identity = resolveCurrentPeer(ctx, opts, 'from', 'shell');
+  const sender = identity.id;
+  touchCurrentPeer(db, ctx, identity, null, 'shell');
+  const recipient = opts.to || original.sender;
+  const taskId = intOpt(opts, 'task', original.task_id || null);
+  const kind = opts.kind || 'reply';
+  const threadId = original.thread_id || original.id;
+  const replyId = sendMessage(db, sender, recipient, taskId, kind, body, {
+    reply_to: original.id,
+    thread_id: threadId
+  });
+  ackMessage(db, sender, original);
+  printResult(ctx, {
+    id: replyId,
+    sender,
+    recipient,
+    task_id: taskId,
+    kind,
+    body,
+    reply_to: original.id,
+    thread_id: threadId
+  }, (data) => `sent reply #${data.id} to #${data.reply_to} ${data.sender} -> ${data.recipient}`);
+}
+
+async function msgThread(ctx, args) {
+  const opts = parseOpts(args);
+  const id = intOpt(opts, 'id', intOpt({ id: opts._[0] }, 'id'));
+  if (!id) throw new CliError('BAD_ARGS', 'Missing --id');
+  const limit = intOpt(opts, 'limit', 50);
+  const db = connect(ctx);
+  const data = queryMessageThread(db, id, limit);
+  printResult(ctx, data, (thread) => {
+    const lines = [`thread #${thread.thread_id} (${thread.messages.length} message${thread.messages.length === 1 ? '' : 's'})`];
+    for (const message of thread.messages) {
+      const parts = [
+        `#${message.id}`,
+        `${message.sender} -> ${message.recipient || 'all'}`,
+        message.task_id ? `task #${message.task_id}` : '',
+        message.reply_to ? `reply #${message.reply_to}` : '',
+        message.kind || 'note',
+        iso(message.created_at)
+      ].filter(Boolean).join(' ');
+      lines.push(`${parts}\n  ${message.body}`);
+    }
+    return lines.join('\n');
+  });
 }
 
 async function cmdAsk(ctx, args) {
@@ -2626,9 +3567,13 @@ async function peerList(ctx, args) {
     } finally {
       db.close();
     }
-    const rows = (data.sessions || []).map((session) => ({ ...session, binding: bindings.get(session.id) || null }));
+    const rows = (data.sessions || []).map((session) => ({
+      ...session,
+      binding: bindings.get(session.peer_id || session.id) || bindings.get(session.id) || null
+    }));
     printResult(ctx, rows, (items) => table(items, [
       { label: 'id', value: (r) => r.id },
+      { label: 'peer', value: (r) => r.peer_id && r.peer_id !== r.id ? r.peer_id : '' },
       { label: 'kind', value: (r) => r.kind },
       { label: 'role', value: (r) => r.role || '' },
       { label: 'status', value: (r) => r.status },
@@ -2932,35 +3877,85 @@ async function cmdStatus(ctx, args) {
   const opts = parseOpts(args);
   const identity = resolveCurrentPeer(ctx, opts, 'peer', 'shell');
   const peer = identity.id;
+  const data = statusSummary(ctx, peer, identity);
+  printResult(ctx, data, (s) => renderStatusSummary(s, peer));
+}
+
+function statusSummary(ctx, peer = null, identity = null) {
   const db = connect(ctx);
-  touchCurrentPeer(db, ctx, identity, null, 'shell');
-  const t = now();
-  const activePeers = db.prepare('SELECT COUNT(*) AS n FROM peers WHERE last_seen_at >= ?').get(t - ACTIVE_PEER_TTL).n;
-  const stalePeers = db.prepare('SELECT COUNT(*) AS n FROM peers WHERE last_seen_at < ?').get(t - ACTIVE_PEER_TTL).n;
-  const taskRows = db.prepare('SELECT status, COUNT(*) AS n FROM tasks GROUP BY status ORDER BY status').all();
-  const locks = db.prepare('SELECT COUNT(*) AS n FROM locks WHERE expires_at > ?').get(t).n;
-  const unread = peer ? queryInbox(db, peer, false, 1000).length : null;
-  const recent = db.prepare('SELECT * FROM events ORDER BY id DESC LIMIT 8').all().reverse();
-  const data = { root: ctx.root, db: ctx.dbPath, active_peers: activePeers, stale_peers: stalePeers, tasks: taskRows, active_locks: locks, unread, recent_events: recent };
-  printResult(ctx, data, (s) => {
-    const taskSummary = s.tasks.length ? s.tasks.map((r) => `${r.status}:${r.n}`).join(', ') : 'none';
-    return [
-      `root: ${s.root}`,
-      `db: ${s.db}`,
-      `peers: active=${s.active_peers}, stale=${s.stale_peers}`,
-      `tasks: ${taskSummary}`,
-      `locks: active=${s.active_locks}`,
-      peer ? `inbox(${peer}): unread=${s.unread}` : null,
-      '',
-      'recent events:',
-      table(s.recent_events, [
-        { label: 'id', value: (r) => `#${r.id}` },
-        { label: 'type', value: (r) => r.type },
-        { label: 'actor', value: (r) => r.actor || '' },
-        { label: 'task', value: (r) => r.task_id ? `#${r.task_id}` : '' },
-        { label: 'time', value: (r) => iso(r.created_at) }
-      ])
-    ].filter((line) => line !== null).join('\n');
+  try {
+    if (identity) touchCurrentPeer(db, ctx, identity, null, 'shell');
+    const t = now();
+    const activePeers = db.prepare('SELECT COUNT(*) AS n FROM peers WHERE last_seen_at >= ?').get(t - ACTIVE_PEER_TTL).n;
+    const stalePeers = db.prepare('SELECT COUNT(*) AS n FROM peers WHERE last_seen_at < ?').get(t - ACTIVE_PEER_TTL).n;
+    const taskRows = db.prepare('SELECT status, COUNT(*) AS n FROM tasks GROUP BY status ORDER BY status').all();
+    const locks = db.prepare('SELECT COUNT(*) AS n FROM locks WHERE expires_at > ?').get(t).n;
+    const unread = peer ? queryInbox(db, peer, false, 1000).length : null;
+    const recent = db.prepare('SELECT * FROM events ORDER BY id DESC LIMIT 8').all().reverse();
+    return { root: ctx.root, db: ctx.dbPath, active_peers: activePeers, stale_peers: stalePeers, tasks: taskRows, active_locks: locks, unread, recent_events: recent };
+  } finally {
+    db.close();
+  }
+}
+
+function renderStatusSummary(s, peer = null) {
+  const taskSummary = s.tasks.length ? s.tasks.map((r) => `${r.status}:${r.n}`).join(', ') : 'none';
+  return [
+    `root: ${s.root}`,
+    `db: ${s.db}`,
+    `peers: active=${s.active_peers}, stale=${s.stale_peers}`,
+    `tasks: ${taskSummary}`,
+    `locks: active=${s.active_locks}`,
+    peer ? `inbox(${peer}): unread=${s.unread}` : null,
+    '',
+    'recent events:',
+    table(s.recent_events, [
+      { label: 'id', value: (r) => `#${r.id}` },
+      { label: 'type', value: (r) => r.type },
+      { label: 'actor', value: (r) => r.actor || '' },
+      { label: 'task', value: (r) => r.task_id ? `#${r.task_id}` : '' },
+      { label: 'time', value: (r) => iso(r.created_at) }
+    ])
+  ].filter((line) => line !== null).join('\n');
+}
+
+function normalizeStateResources(values) {
+  const list = Array.isArray(values) ? values : [values];
+  return uniqueList(list.flatMap((value) => String(value || '').split(',').map((part) => part.trim())));
+}
+
+async function cmdState(ctx, args) {
+  if (wantsHelp(args)) return helpState();
+  const opts = parseOpts(args, { arrays: ['resource'] });
+  const identity = resolveCurrentPeer(ctx, opts, 'peer', 'shell');
+  const peer = identity.id;
+  const resources = normalizeStateResources(opts.resource || opts.resources || []);
+  const snapshot = statusSnapshot(ctx, peer, { resources, intent: opts.intent || null });
+  printResult(ctx, snapshot, (data) => {
+    const automation = data.automation;
+    const lines = [
+      `root: ${data.root}`,
+      `peer: ${peer}`,
+      automation.current_task ? `current task: #${automation.current_task.id} ${automation.current_task.status} ${automation.current_task.title}` : null,
+      `phase: ${automation.phase}`,
+      `next: ${automation.next_action.command || automation.next_action.kind}`,
+      `why: ${automation.next_action.reason}`
+    ].filter(Boolean);
+    if (automation.finish_actions.length) {
+      lines.push('', 'finish actions:');
+      lines.push(...automation.finish_actions.map((action) => `- ${action.command}`));
+    }
+    if (automation.warnings.length) {
+      lines.push('', 'warnings:');
+      lines.push(...automation.warnings.map((warning) => `- ${warning}`));
+    }
+    if (data.timeline.length) {
+      lines.push('', 'timeline:');
+      for (const item of data.timeline.slice(-8)) {
+        lines.push(`- ${iso(item.ts)} ${item.source}:${item.source_id} ${item.title}${item.text ? ` — ${item.text}` : ''}`);
+      }
+    }
+    return lines.join('\n');
   });
 }
 
@@ -2978,11 +3973,13 @@ project uses a flat peer mesh: there is no required main/worker hierarchy.
 Run these commands before changing files:
 
 ${cmd} register --peer ${peer} --kind ${kind} --role ${role}
+${cmd} state --peer ${peer}
 ${cmd} msg inbox --peer ${peer}
 ${cmd} task next --peer ${peer}
 
 Coordination rules:
 - Claim exactly one task before editing.
+- If state shows a current task for ${peer}, continue that task before claiming another pending task.
 - Before editing a file, directory, module, or shared test resource, run:
   ${cmd} lock acquire --peer ${peer} --resource <path-or-module> --task <task-id>
 - If a lock is held by another peer, message that peer instead of editing:
@@ -3203,19 +4200,25 @@ async function prepareLocalBus(ctx, opts = {}) {
 }
 
 async function startWebBackground(ctx, args) {
-  const opts = parseOpts(args, { booleans: ['local', 'no-guidance', 'no-discover'] });
-  validateOpts('web', opts, ['host', 'port', 'token', 'local', 'no-guidance', 'no-discover']);
+  const opts = parseOpts(args, { booleans: ['local', 'no-token', 'no-guidance', 'no-discover'] });
+  validateOpts('web', opts, ['host', 'port', 'token', 'local', 'no-token', 'no-guidance', 'no-discover']);
+  validateWebTokenOpts(opts);
   ensureTmuxAvailable({ autoInstall: true });
   const setup = await prepareLocalBus(ctx, { ...opts, installShims: true });
   registerProject(ctx);
 
   const existing = await readHealthyGlobalRuntime();
   if (existing) {
-    try {
-      await runtimeRequest(ctx, 'POST', '/api/projects', { root: ctx.root, db: ctx.dbPath }, existing);
-    } catch {}
-    writeRuntime(ctx, { ...existing, root: ctx.root, db: ctx.dbPath, project_root: ctx.root, global_runtime: true });
-    return printWebRuntime(ctx, existing, { already: true, logFile: webLogPath(ctx), setup });
+    if (webRuntimeMatchesRequest(existing, opts)) {
+      rememberRuntimeToken(existing, opts);
+      try {
+        await runtimeRequest(ctx, 'POST', '/api/projects', { root: ctx.root, db: ctx.dbPath }, existing);
+      } catch {}
+      writeRuntime(ctx, { ...existing, root: ctx.root, db: ctx.dbPath, project_root: ctx.root, global_runtime: true });
+      return printWebRuntime(ctx, existing, { already: true, logFile: webLogPath(ctx), setup });
+    }
+    try { await runtimeRequest(ctx, 'POST', '/api/runtime/stop', {}, existing); } catch {}
+    await sleep(250);
   }
 
   try { fs.rmSync(runtimePath(ctx), { force: true }); } catch {}
@@ -3340,57 +4343,10 @@ async function cmdDown(ctx, args) {
   printResult(ctx, { runtime: runtime.source || runtime.base_url }, () => `${PRODUCT_NAME} runtime stopped`);
 }
 
-function statusSnapshot(ctx, peer = null) {
+function statusSnapshot(ctx, peer = null, opts = {}) {
   const db = connect(ctx);
   try {
-    const t = now();
-    const peers = db.prepare(`
-      SELECT id, kind, role, status, worktree, branch, pid, capabilities,
-             created_at, last_seen_at, (? - last_seen_at) AS age_sec
-      FROM peers
-      ORDER BY last_seen_at DESC, id ASC
-      LIMIT 200
-    `).all(t);
-    const tasks = queryOpenTasks(db, 200);
-    const locks = db.prepare(`
-      SELECT resource, owner, task_id, reason, expires_at, created_at
-      FROM locks
-      WHERE expires_at > ?
-      ORDER BY resource ASC
-      LIMIT 200
-    `).all(t);
-    const messages = peer
-      ? queryInbox(db, peer, false, 50)
-      : db.prepare(`
-          SELECT id, sender, recipient, task_id, kind, body, created_at
-          FROM messages
-          ORDER BY id DESC
-          LIMIT 50
-        `).all().reverse();
-    const handoffs = db.prepare(`
-      SELECT id, task_id, from_peer, to_peer, summary, changed_files, tests, risks, created_at
-      FROM handoffs
-      ORDER BY id DESC
-      LIMIT 50
-    `).all().reverse();
-    const events = db.prepare(`
-      SELECT id, type, actor, task_id, payload, created_at
-      FROM events
-      ORDER BY id DESC
-      LIMIT 80
-    `).all().reverse();
-    return {
-      root: ctx.root,
-      db: ctx.dbPath,
-      now: t,
-      active_peer_ttl: ACTIVE_PEER_TTL,
-      peers,
-      tasks,
-      locks,
-      messages,
-      handoffs,
-      events
-    };
+    return collectStateSnapshot(db, ctx, peer, opts);
   } finally {
     try {
       db.close();
@@ -3400,6 +4356,161 @@ function statusSnapshot(ctx, peer = null) {
   }
 }
 
+function webPeerRegister(projectCtx, peer, input = {}) {
+  const db = connect(projectCtx);
+  const row = {
+    id: peer,
+    kind: input.kind || 'other',
+    role: input.role || 'peer',
+    worktree: path.resolve(input.worktree || projectCtx.cwd),
+    branch: input.branch || detectBranch(projectCtx.cwd),
+    pid: intOpt(input, 'pid', process.ppid),
+    status: input.status || 'idle',
+    capabilities: Array.isArray(input.cap) ? input.cap.join(',') : (input.cap || input.capabilities || 'web')
+  };
+  try {
+    upsertPeer(db, row);
+    addEvent(db, 'peer.registered', peer, null, { ...row, source: 'web' });
+  } finally {
+    db.close();
+  }
+  return { peer: row, summary: `registered ${row.id} (${row.kind}${row.role ? `, ${row.role}` : ''})` };
+}
+
+function webPeerHeartbeat(projectCtx, peer, input = {}) {
+  const ttl = intOpt(input, 'ttl', DEFAULT_LOCK_TTL);
+  const status = input.status || null;
+  const renewLocks = input['renew-locks'] !== false && input.renew_locks !== false;
+  const db = connect(projectCtx);
+  const t = now();
+  let renewed = 0;
+  try {
+    touchPeer(db, peer, status);
+    if (renewLocks) {
+      renewed = db.prepare(`
+        UPDATE locks SET expires_at = ?
+        WHERE owner = ? AND expires_at > ?
+      `).run(t + ttl, peer, t).changes;
+    }
+    addEvent(db, 'peer.heartbeat', peer, null, { status, renewed, source: 'web' });
+  } finally {
+    db.close();
+  }
+  return {
+    peer,
+    status,
+    renewed,
+    summary: `heartbeat ${peer}${renewed ? `, renewed locks: ${renewed}` : ''}`
+  };
+}
+
+function claimNextTaskForPeer(db, peer, force = false) {
+  return tx(db, () => {
+    if (!force) {
+      const current = db.prepare(`
+        SELECT * FROM tasks
+        WHERE owner = ?
+          AND status IN ('claimed', 'running', 'review', 'blocked')
+        ORDER BY
+          CASE status
+            WHEN 'running' THEN 0
+            WHEN 'claimed' THEN 1
+            WHEN 'review' THEN 2
+            WHEN 'blocked' THEN 3
+            ELSE 4
+          END,
+          priority ASC,
+          id ASC
+        LIMIT 1
+      `).get(peer);
+      if (current) return { ...current, current: true };
+    }
+    const row = db.prepare(`
+      SELECT * FROM tasks
+      WHERE status = 'pending'
+        AND owner IS NULL
+        AND (assignee IS NULL OR assignee = ?)
+      ORDER BY CASE WHEN assignee = ? THEN 0 ELSE 1 END, priority ASC, id ASC
+      LIMIT 1
+    `).get(peer, peer);
+    if (!row) return null;
+    const t = now();
+    db.prepare(`
+      UPDATE tasks
+      SET owner = ?, status = 'claimed', claimed_at = ?, updated_at = ?
+      WHERE id = ? AND owner IS NULL AND status = 'pending'
+    `).run(peer, t, t, row.id);
+    addEvent(db, 'task.claimed', peer, row.id, { next: true });
+    return db.prepare('SELECT * FROM tasks WHERE id = ?').get(row.id);
+  });
+}
+
+function webPeerTaskNext(projectCtx, peer, input = {}) {
+  const db = connect(projectCtx);
+  try {
+    touchPeer(db, peer, 'working');
+    const task = claimNextTaskForPeer(db, peer, Boolean(input.force));
+    if (!task) return { peer, task: null, summary: 'no pending task' };
+    return {
+      peer,
+      task,
+      current: Boolean(task.current),
+      summary: task.current
+        ? `current task #${task.id}: ${task.title} (${task.status})`
+        : `claimed task #${task.id}: ${task.title}`
+    };
+  } finally {
+    db.close();
+  }
+}
+
+function webPeerInbox(projectCtx, peer, input = {}) {
+  const db = connect(projectCtx);
+  try {
+    const messages = queryInbox(db, peer, Boolean(input.all), intOpt(input, 'limit', 20));
+    return {
+      peer,
+      messages,
+      summary: messages.length ? `${messages.length} message${messages.length === 1 ? '' : 's'}` : 'no messages'
+    };
+  } finally {
+    db.close();
+  }
+}
+
+function webPeerAction(projectCtx, peer, action, input = {}) {
+  const normalized = String(action || '').replace(/_/g, '-');
+  if (!peer) throw new CliError('BAD_REQUEST', 'peer required');
+  if (normalized === 'status') {
+    const status = statusSummary(projectCtx, peer);
+    return { ok: true, action: normalized, peer, summary: `active=${status.active_peers}, stale=${status.stale_peers}, locks=${status.active_locks}, unread=${status.unread ?? 0}`, data: status };
+  }
+  if (normalized === 'state') {
+    const data = statusSnapshot(projectCtx, peer, {
+      resources: normalizeStateResources(input.resource || input.resources || []),
+      intent: input.intent || null
+    });
+    return { ok: true, action: normalized, peer, summary: data.automation?.next_action?.reason || 'state loaded', data };
+  }
+  if (normalized === 'inbox') {
+    const data = webPeerInbox(projectCtx, peer, input);
+    return { ok: true, action: normalized, peer, summary: data.summary, data };
+  }
+  if (normalized === 'task-next') {
+    const data = webPeerTaskNext(projectCtx, peer, input);
+    return { ok: true, action: normalized, peer, summary: data.summary, data };
+  }
+  if (normalized === 'heartbeat') {
+    const data = webPeerHeartbeat(projectCtx, peer, input);
+    return { ok: true, action: normalized, peer, summary: data.summary, data };
+  }
+  if (normalized === 'register') {
+    const data = webPeerRegister(projectCtx, peer, input);
+    return { ok: true, action: normalized, peer, summary: data.summary, data };
+  }
+  throw new CliError('BAD_REQUEST', `Unknown peer action: ${action}`);
+}
+
 function webIndexHtml() {
   return `<!doctype html>
 <html lang="en">
@@ -3465,11 +4576,72 @@ function webIndexHtml() {
       font-size: 12px;
     }
     .app {
+      position: relative;
       height: 100vh;
       display: grid;
-      grid-template-columns: 320px 1fr 360px;
-      min-width: 980px;
-    }
+      --left-width: 320px;
+      --right-width: 360px;
+      grid-template-columns: var(--left-width) minmax(0, 1fr) var(--right-width);
+      min-width: 640px;
+      transition: grid-template-columns .18s ease;
+    }
+    .app.resizing { transition: none; }
+    .app.left-collapsed  { grid-template-columns: 0 minmax(0, 1fr) var(--right-width); }
+    .app.right-collapsed { grid-template-columns: var(--left-width) minmax(0, 1fr) 0; }
+    .app.left-collapsed.right-collapsed { grid-template-columns: 0 minmax(0, 1fr) 0; }
+    /* Hide sidebar borders when collapsed so no 1px seam remains. */
+    .app.left-collapsed .sidebar { border-right-width: 0; }
+    .app.right-collapsed .inspector { border-left-width: 0; }
+    .edge-resizer {
+      position: absolute;
+      top: 0;
+      bottom: 0;
+      z-index: 55;
+      width: 12px;
+      cursor: col-resize;
+      touch-action: none;
+      user-select: none;
+      background: transparent;
+      transition: left .18s ease, right .18s ease, background .12s;
+    }
+    .edge-resizer:hover,
+    .app.resizing .edge-resizer {
+      background: rgba(126, 231, 215, .08);
+    }
+    .app.resizing .edge-resizer { transition: none; }
+    .edge-resizer-left  { left: var(--left-width); transform: translateX(-50%); }
+    .edge-resizer-right { right: var(--right-width); transform: translateX(50%); }
+    .app.left-collapsed  .edge-resizer-left  { left: 0; }
+    .app.right-collapsed .edge-resizer-right { right: 0; }
+    /* Small collapse handles centered vertically on each divider border.
+       They are children of .app (no overflow clip) and track the column edge. */
+    .edge-toggle {
+      position: absolute;
+      top: 50%;
+      z-index: 60;
+      width: 16px;
+      height: 44px;
+      padding: 0;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      font-size: 11px;
+      line-height: 1;
+      color: var(--muted);
+      background: var(--panel);
+      border: 1px solid var(--border);
+      border-radius: 6px;
+      cursor: col-resize;
+      touch-action: none;
+      user-select: none;
+      transition: left .18s ease, right .18s ease, color .12s, border-color .12s, background .12s;
+    }
+    .app.resizing .edge-toggle { transition: none; }
+    .edge-toggle:hover { color: var(--text); border-color: var(--accent); background: #1b1f26; }
+    .edge-left  { left: var(--left-width); transform: translate(-50%, -50%); }
+    .edge-right { right: var(--right-width); transform: translate(50%, -50%); }
+    .app.left-collapsed  .edge-left  { left: 0;  transform: translate(0, -50%); }
+    .app.right-collapsed .edge-right { right: 0; transform: translate(0, -50%); }
     .sidebar, .inspector {
       min-height: 0;
       min-width: 0;
@@ -3531,6 +4703,14 @@ function webIndexHtml() {
       gap: 8px;
       align-items: end;
     }
+    .start-options {
+      display: grid;
+      grid-template-columns: 1fr 1fr;
+      gap: 8px;
+    }
+    .start-options label[data-resume-field] {
+      grid-column: 1 / -1;
+    }
     .session-header {
       border-bottom: 1px solid var(--border);
       padding: 8px 10px;
@@ -3616,16 +4796,107 @@ function webIndexHtml() {
       overflow: hidden;
     }
     .toolbar .title {
-      min-width: 180px;
+      flex: 1 1 auto;
+      min-width: 0;
       display: grid;
       gap: 2px;
     }
+    .toolbar .title strong {
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+    }
     .quick {
       display: flex;
-      gap: 6px;
-      flex-wrap: wrap;
-      justify-content: flex-end;
+      gap: 8px;
+      flex-wrap: nowrap;
+      align-items: center;
+      flex: 0 0 auto;
+    }
+    /* Toolbar edge toggles for collapsing the side panels. */
+    .icon-btn {
+      flex: 0 0 auto;
+      width: 30px;
+      height: 30px;
+      padding: 0;
+      display: inline-flex;
+      align-items: center;
+      justify-content: center;
+      font-size: 15px;
+      line-height: 1;
+      color: var(--muted);
+      background: transparent;
+      border: 1px solid var(--border);
+      border-radius: 7px;
+      cursor: pointer;
+    }
+    .icon-btn:hover { color: var(--text); border-color: var(--accent); }
+    /* Compact actions dropdown so the top bar stays a single tidy row. */
+    .menu-wrap { position: relative; display: inline-flex; }
+    .menu-btn { white-space: nowrap; }
+    .menu {
+      position: fixed;
+      z-index: 1000;
+      min-width: 150px;
+      padding: 5px;
+      display: grid;
+      gap: 2px;
+      background: var(--panel);
+      border: 1px solid var(--border);
+      border-radius: 8px;
+      box-shadow: 0 8px 24px rgba(0,0,0,.45);
+    }
+    .menu[hidden] { display: none; }
+    .menu button {
       width: 100%;
+      text-align: left;
+      border: 0;
+      background: transparent;
+      padding: 7px 9px;
+      border-radius: 6px;
+      color: var(--text);
+    }
+    .menu button:hover { background: #1b1f26; }
+    .menu .divider {
+      height: 1px;
+      margin: 4px 2px;
+      background: var(--border);
+    }
+    .action-result {
+      position: fixed;
+      right: 16px;
+      top: 64px;
+      z-index: 1200;
+      width: min(520px, calc(100vw - 32px));
+      max-height: min(68vh, 640px);
+      display: grid;
+      grid-template-rows: auto minmax(0, 1fr);
+      background: var(--panel);
+      border: 1px solid var(--border);
+      border-radius: 8px;
+      box-shadow: 0 12px 32px rgba(0,0,0,.5);
+      overflow: hidden;
+    }
+    .action-result[hidden] { display: none; }
+    .action-result header {
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      gap: 10px;
+      padding: 9px 10px;
+      border-bottom: 1px solid var(--border);
+    }
+    .action-result header strong { font-size: 13px; }
+    .action-result pre {
+      margin: 0;
+      padding: 10px;
+      overflow: auto;
+      white-space: pre-wrap;
+      word-break: break-word;
+      font-family: var(--mono);
+      font-size: 11px;
+      color: var(--text);
+      background: #0d0f12;
     }
     #terminal {
       min-height: 0;
@@ -3659,6 +4930,9 @@ function webIndexHtml() {
       display: grid;
       grid-template-rows: auto minmax(0, 1fr);
     }
+    .card.state-card.state-card-collapsed {
+      grid-template-rows: auto 0;
+    }
     .card h2 {
       margin: 0;
       padding: 8px 10px;
@@ -3670,6 +4944,44 @@ function webIndexHtml() {
       align-items: center;
       gap: 8px;
     }
+    .state-card-toggle {
+      width: 100%;
+      min-width: 0;
+      border: 0;
+      border-bottom: 1px solid var(--border);
+      border-radius: 0;
+      background: transparent;
+      color: inherit;
+      padding: 8px 10px;
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      gap: 8px;
+      cursor: pointer;
+      text-align: left;
+    }
+    .state-card-toggle:hover { background: #151922; }
+    .state-card-toggle-title {
+      min-width: 0;
+      display: flex;
+      align-items: center;
+      gap: 8px;
+      overflow: hidden;
+    }
+    .state-card-toggle-title strong {
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+    }
+    .state-card-chevron {
+      flex: 0 0 auto;
+      color: var(--muted);
+      font-size: 12px;
+      line-height: 1;
+    }
+    .state-card.state-card-collapsed .state-card-chevron {
+      transform: rotate(-90deg);
+    }
     .card .body {
       padding: 8px 10px;
       display: grid;
@@ -3684,6 +4996,9 @@ function webIndexHtml() {
       scrollbar-width: thin;
       scrollbar-color: #3a3f4a transparent;
     }
+    .state-card.state-card-collapsed .body {
+      display: none;
+    }
     .state-card .body::-webkit-scrollbar { width: 8px; }
     .state-card .body::-webkit-scrollbar-track { background: transparent; }
     .state-card .body::-webkit-scrollbar-thumb { background: #3a3f4a; border-radius: 4px; }
@@ -3712,22 +5027,30 @@ function webIndexHtml() {
           <strong>hello-cc</strong>
           <div class="path" id="rootPath"></div>
         </div>
-        <span id="connState">offline</span>
+        <span id="connState" data-i18n="conn.offline">offline</span>
       </div>
       <div class="form" style="padding-top:10px;padding-bottom:10px">
-        <label>Project<select id="projectSelect"></select></label>
-        <label>Project path<input id="projectPath" placeholder="/path/to/project"></label>
-        <button id="addProjectBtn" type="button">Register Project</button>
+        <div class="grid2">
+          <label><span data-i18n="project">Project</span><select id="projectSelect"></select></label>
+          <label><span data-i18n="language">Language</span><select id="langSelect"><option value="en">English</option><option value="zh">中文</option></select></label>
+        </div>
+        <label><span data-i18n="projectPath">Project path</span><input id="projectPath" data-i18n-placeholder="projectPathPlaceholder" placeholder="/path/to/project"></label>
+        <button id="addProjectBtn" type="button" data-i18n="registerProject">Register Project</button>
       </div>
       <form class="form" id="startForm">
         <div class="start-row">
-          <label>New session<select id="kind"><option value="codex">codex</option><option value="claude">claude</option><option value="shell">shell</option></select></label>
-          <button class="primary" type="submit">Start</button>
+          <label><span data-i18n="newSession">New session</span><select id="kind"><option value="codex">codex</option><option value="claude">claude</option><option value="shell" data-i18n="kind.shell">shell</option></select></label>
+          <button class="primary" type="submit" data-i18n="start">Start</button>
+        </div>
+        <div class="start-options">
+          <label><span data-i18n="mode">Mode</span><select id="startMode"><option value="new" data-i18n="mode.new">new</option><option value="resume" data-i18n="mode.resume">resume</option><option value="last" data-i18n="mode.last">last</option><option value="continue" data-i18n="mode.continue">continue</option></select></label>
+          <label data-resume-field><span data-i18n="session">Session</span><select id="resumeSelect"></select></label>
+          <label data-resume-field data-resume-custom style="display:none"><span data-i18n="sessionId">Session id</span><input id="resumeArg" data-i18n-placeholder="sessionIdPlaceholder" placeholder="session id or name"></label>
         </div>
       </form>
       <div class="session-header">
-        <strong>Sessions</strong>
-        <label>View<select id="sessionKindFilter"><option value="all">all</option><option value="claude">claude</option><option value="codex">codex</option><option value="shell">shell</option><option value="other">other</option></select></label>
+        <strong data-i18n="sessions">Sessions</strong>
+        <label><span data-i18n="view">View</span><select id="sessionKindFilter"><option value="all" data-i18n="kind.all">all</option><option value="claude">claude</option><option value="codex">codex</option><option value="shell" data-i18n="kind.shell">shell</option><option value="other" data-i18n="kind.other">other</option></select></label>
       </div>
       <div class="sessions" id="sessions"></div>
     </aside>
@@ -3735,29 +5058,50 @@ function webIndexHtml() {
     <main class="main">
       <div class="toolbar">
         <div class="title">
-          <strong id="activeTitle">No session selected</strong>
-          <span class="path" id="activeMeta">Start or select a session from the left panel</span>
+          <strong id="activeTitle" data-i18n="noSessionSelected">No session selected</strong>
+          <span class="path" id="activeMeta" data-i18n="startOrSelect">Start or select a session from the left panel</span>
         </div>
         <div class="quick" id="quickBar">
-          <button data-send="register">register</button>
-          <button data-send="inbox">inbox</button>
-          <button data-send="next">next task</button>
-          <button data-send="status">status</button>
-          <button data-send="heartbeat">heartbeat</button>
-          <button class="danger" id="stopBtn" type="button">stop</button>
+          <div class="menu-wrap">
+            <button class="menu-btn" id="actionsBtn" type="button" aria-haspopup="true" aria-expanded="false"><span data-i18n="actions">Actions</span> ▾</button>
+            <div class="menu" id="actionsMenu" hidden>
+              <button data-action="state" data-i18n="action.state">state</button>
+              <button data-action="status" data-i18n="action.status">status</button>
+              <button data-action="inbox" data-i18n="action.inbox">inbox</button>
+              <button data-action="task-next" data-i18n="action.claimNextTask">claim next task</button>
+              <button data-action="heartbeat" data-i18n="action.renewHeartbeat">renew heartbeat</button>
+              <div class="divider" role="separator"></div>
+              <button data-action="register" data-i18n="action.reregister">re-register peer</button>
+              <button data-terminal-action="status" data-i18n="action.runStatusTerminal">run status in terminal</button>
+            </div>
+          </div>
+          <button class="danger" id="stopBtn" type="button" data-i18n="stop">stop</button>
         </div>
       </div>
       <div id="terminal" style="min-height:0;flex:1"></div>
       <div id="detectedPanel" style="display:none;overflow:auto;flex:1"></div>
     </main>
 
+    <section class="action-result" id="actionResult" hidden aria-live="polite">
+      <header>
+        <strong id="actionResultTitle"></strong>
+        <button id="actionResultClose" type="button" aria-label="Close">×</button>
+      </header>
+      <pre id="actionResultBody"></pre>
+    </section>
+
     <aside class="inspector">
       <div class="brand">
-        <strong>Project State</strong>
-        <button id="refreshBtn" type="button">Refresh</button>
+        <strong data-i18n="projectState">Project State</strong>
+        <button id="refreshBtn" type="button" data-i18n="refresh">Refresh</button>
       </div>
       <div class="state" id="state"></div>
     </aside>
+
+    <button class="edge-toggle edge-left" id="toggleLeft" type="button" data-i18n-title="collapseSidebar" data-i18n-aria="toggleLeftSidebar" title="Collapse sidebar" aria-label="Toggle left sidebar">⟨</button>
+    <button class="edge-toggle edge-right" id="toggleRight" type="button" data-i18n-title="collapseStatePanel" data-i18n-aria="toggleRightPanel" title="Collapse state panel" aria-label="Toggle right panel">⟩</button>
+    <div class="edge-resizer edge-resizer-left" id="resizeLeft" role="separator" aria-orientation="vertical" data-i18n-aria="resizeLeftSidebar" data-i18n-title="resizeLeftSidebar" aria-label="Resize left sidebar" title="Resize left sidebar"></div>
+    <div class="edge-resizer edge-resizer-right" id="resizeRight" role="separator" aria-orientation="vertical" data-i18n-aria="resizeRightPanel" data-i18n-title="resizeRightPanel" aria-label="Resize right panel" title="Resize right panel"></div>
   </div>
 
   <script src="/assets/xterm.js"></script>
@@ -3770,6 +5114,7 @@ function webIndexHtml() {
     let sessionKindFilter = initialParams.get('kind') || 'all';
     let sessions  = [];    // managed (PTY) sessions
     let detected  = [];    // coordination-only peers (from hooks/watcher)
+    let resumableCache = []; // provider sessions available to resume (from /api/resumable)
     let active    = null;  // active managed session id
     let activeDetected = null; // active detected peer id
     let activeType = 'managed'; // 'managed' | 'detected'
@@ -3778,6 +5123,284 @@ function webIndexHtml() {
     let lastStateRoot = '';
     let ws        = null;
     let wsReconnectTimer = null;
+    const i18n = {
+      en: {
+        language: 'Language',
+        project: 'Project',
+        projectPath: 'Project path',
+        projectPathPlaceholder: '/path/to/project',
+        registerProject: 'Register Project',
+        newSession: 'New session',
+        start: 'Start',
+        mode: 'Mode',
+        'mode.new': 'new',
+        'mode.resume': 'resume',
+        'mode.last': 'last',
+        'mode.continue': 'continue',
+        session: 'Session',
+        sessionId: 'Session id',
+        sessionIdPlaceholder: 'session id or name',
+        sessions: 'Sessions',
+        view: 'View',
+        'kind.all': 'all',
+        'kind.shell': 'shell',
+        'kind.other': 'other',
+        noSessionSelected: 'No session selected',
+        startOrSelect: 'Start or select a session from the left panel',
+        actions: 'Actions',
+        'action.state': 'state',
+        'action.inbox': 'inbox',
+        'action.claimNextTask': 'claim next task',
+        'action.status': 'status',
+        'action.renewHeartbeat': 'renew heartbeat',
+        'action.reregister': 're-register peer',
+        'action.runStatusTerminal': 'run status in terminal',
+        actionResult: 'Action Result',
+        stop: 'stop',
+        projectState: 'Project State',
+        refresh: 'Refresh',
+        managed: 'Managed',
+        detected: 'Detected',
+        running: 'running',
+        noActiveSessions: 'No active sessions.',
+        startOneAbove: 'Start one above',
+        orRunTerminal: 'or run in any terminal:',
+        noDetectedPeers: 'No detected peers.',
+        viewFilter: 'View filter',
+        noTasks: 'No tasks.',
+        noPeers: 'No peers.',
+        noActiveLocks: 'No active locks.',
+        noMessages: 'No messages.',
+        noTimelineItems: 'No timeline items.',
+        nextAction: 'Next Action',
+        timeline: 'Timeline',
+        messages: 'Messages',
+        peers: 'Peers',
+        tasks: 'Tasks',
+        locks: 'Locks',
+        owner: 'owner',
+        assignee: 'assignee',
+        task: 'task',
+        all: 'all',
+        next: 'next',
+        finish: 'finish',
+        warnings: 'warnings',
+        noImmediateAction: 'No immediate coordination action',
+        detectedSession: 'Detected Session',
+        sendMessage: 'Send Message',
+        messageHelp: "Message will appear in the peer's <code>hcc msg inbox</code> and be injected on next hook fire.",
+        messageBodyPlaceholder: 'Message body...',
+        send: 'Send',
+        peer: 'peer',
+        kind: 'kind',
+        status: 'status',
+        cwd: 'cwd',
+        pid: 'pid',
+        unknown: 'unknown',
+        lastSeen: 'last seen',
+        secondsAgo: 's ago',
+        age: 'age',
+        branch: 'branch',
+        runtime: 'runtime',
+        thread: 'thread',
+        reply: 'reply',
+        'status.active': 'active',
+        'status.stale': 'stale',
+        'status.unknown': 'unknown',
+        'status.running': 'running',
+        'status.idle': 'idle',
+        'status.exited': 'exited',
+        'status.claimed': 'claimed',
+        'status.review': 'review',
+        'status.blocked': 'blocked',
+        'status.done': 'done',
+        'status.abandoned': 'abandoned',
+        'status.pending': 'pending',
+        'conn.offline': 'offline',
+        'conn.online': 'online',
+        'conn.attached': 'attached',
+        'conn.reconnecting': 'reconnecting...',
+        'conn.coordinationOnly': 'coordination only',
+        'conn.error': 'error',
+        show: 'Show',
+        collapse: 'Collapse',
+        sidebar: 'sidebar',
+        statePanel: 'state panel',
+        dragToResize: 'drag to resize',
+        collapseSidebar: 'Collapse sidebar',
+        collapseStatePanel: 'Collapse state panel',
+        toggleLeftSidebar: 'Toggle left sidebar',
+        toggleRightPanel: 'Toggle right panel',
+        resizeLeftSidebar: 'Resize left sidebar',
+        resizeRightPanel: 'Resize right panel',
+        customSession: 'custom session id...'
+      },
+      zh: {
+        language: '语言',
+        project: '项目',
+        projectPath: '项目路径',
+        projectPathPlaceholder: '/项目/路径',
+        registerProject: '注册项目',
+        newSession: '新会话',
+        start: '启动',
+        mode: '模式',
+        'mode.new': '新建',
+        'mode.resume': '恢复',
+        'mode.last': '最近',
+        'mode.continue': '继续',
+        session: '会话',
+        sessionId: '会话 ID',
+        sessionIdPlaceholder: '会话 ID 或名称',
+        sessions: '会话',
+        view: '视图',
+        'kind.all': '全部',
+        'kind.shell': 'shell',
+        'kind.other': '其他',
+        noSessionSelected: '未选择会话',
+        startOrSelect: '从左侧面板启动或选择一个会话',
+        actions: '操作',
+        'action.state': '状态详情',
+        'action.inbox': '收件箱',
+        'action.claimNextTask': '认领下个任务',
+        'action.status': '状态',
+        'action.renewHeartbeat': '续期心跳',
+        'action.reregister': '重新注册协作方',
+        'action.runStatusTerminal': '在终端运行状态命令',
+        actionResult: '操作结果',
+        stop: '停止',
+        projectState: '项目状态',
+        refresh: '刷新',
+        managed: '托管',
+        detected: '检测到',
+        running: '运行中',
+        noActiveSessions: '没有活动会话。',
+        startOneAbove: '在上方启动一个会话',
+        orRunTerminal: '或在任意终端运行：',
+        noDetectedPeers: '没有检测到的协作方。',
+        viewFilter: '视图过滤',
+        noTasks: '没有任务。',
+        noPeers: '没有协作方。',
+        noActiveLocks: '没有活动锁。',
+        noMessages: '没有消息。',
+        noTimelineItems: '没有时间线条目。',
+        nextAction: '下一步',
+        timeline: '时间线',
+        messages: '消息',
+        peers: '协作方',
+        tasks: '任务',
+        locks: '锁',
+        owner: '负责人',
+        assignee: '执行者',
+        task: '任务',
+        all: '全部',
+        next: '下一步',
+        finish: '收尾',
+        warnings: '警告',
+        noImmediateAction: '当前没有需要立即处理的协作动作',
+        detectedSession: '检测到的会话',
+        sendMessage: '发送消息',
+        messageHelp: '消息会出现在该 peer 的 <code>hcc msg inbox</code> 中，并在下一次 hook 触发时注入。',
+        messageBodyPlaceholder: '消息内容...',
+        send: '发送',
+        peer: '协作方',
+        kind: '类型',
+        status: '状态',
+        cwd: '工作目录',
+        pid: 'PID',
+        unknown: '未知',
+        lastSeen: '最后出现',
+        secondsAgo: ' 秒前',
+        age: '时长',
+        branch: '分支',
+        runtime: '运行时',
+        thread: '线程',
+        reply: '回复',
+        'status.active': '活跃',
+        'status.stale': '过期',
+        'status.unknown': '未知',
+        'status.running': '运行中',
+        'status.idle': '空闲',
+        'status.exited': '已退出',
+        'status.claimed': '已认领',
+        'status.review': '审查中',
+        'status.blocked': '阻塞',
+        'status.done': '完成',
+        'status.abandoned': '已放弃',
+        'status.pending': '待处理',
+        'conn.offline': '离线',
+        'conn.online': '在线',
+        'conn.attached': '已连接',
+        'conn.reconnecting': '重连中...',
+        'conn.coordinationOnly': '仅协作',
+        'conn.error': '错误',
+        show: '显示',
+        collapse: '折叠',
+        sidebar: '侧栏',
+        statePanel: '状态面板',
+        dragToResize: '拖动调整大小',
+        collapseSidebar: '折叠侧栏',
+        collapseStatePanel: '折叠状态面板',
+        toggleLeftSidebar: '切换左侧栏',
+        toggleRightPanel: '切换右侧面板',
+        resizeLeftSidebar: '调整左侧栏宽度',
+        resizeRightPanel: '调整右侧面板宽度',
+        customSession: '自定义会话 ID...'
+      }
+    };
+    let lang = localStorage.getItem('hcc.lang') || ((navigator.language || '').toLowerCase().startsWith('zh') ? 'zh' : 'en');
+    if (!i18n[lang]) lang = 'en';
+
+    function tr(key, fallback = '') {
+      return i18n[lang]?.[key] || i18n.en[key] || fallback || key;
+    }
+
+    function setText(id, key) {
+      const el = document.getElementById(id);
+      if (el) el.textContent = tr(key);
+    }
+
+    function connText(key) {
+      const el = document.getElementById('connState');
+      if (el) {
+        el.dataset.stateKey = key;
+        el.textContent = tr('conn.' + key);
+      }
+    }
+
+    function applyLanguage() {
+      document.documentElement.lang = lang === 'zh' ? 'zh-CN' : 'en';
+      localStorage.setItem('hcc.lang', lang);
+      const sel = document.getElementById('langSelect');
+      if (sel) sel.value = lang;
+      document.querySelectorAll('[data-i18n]').forEach((el) => { el.textContent = tr(el.dataset.i18n); });
+      document.querySelectorAll('[data-i18n-placeholder]').forEach((el) => { el.placeholder = tr(el.dataset.i18nPlaceholder); });
+      document.querySelectorAll('[data-i18n-title]').forEach((el) => { el.title = tr(el.dataset.i18nTitle); });
+      document.querySelectorAll('[data-i18n-aria]').forEach((el) => { el.setAttribute('aria-label', tr(el.dataset.i18nAria)); });
+      if (!active && !activeDetected) {
+        setText('activeTitle', 'noSessionSelected');
+        setText('activeMeta', 'startOrSelect');
+      }
+      const stateKey = document.getElementById('connState')?.dataset.stateKey || 'offline';
+      connText(stateKey);
+      syncStartModeOptions();
+      renderSections();
+      if (activeType === 'detected' && activeDetected) {
+        const draft = document.getElementById('detMsg')?.value || '';
+        const peer = detected.find((p) => p.id === activeDetected) || { id: activeDetected };
+        document.getElementById('activeTitle').textContent = activeDetected + ' (' + tr('detected') + ')';
+        renderDetectedPanel(peer);
+        const detMsg = document.getElementById('detMsg');
+        if (detMsg && draft) detMsg.value = draft;
+      } else if (activeType === 'managed' && active) {
+        const meta = sessions.find((s) => s.id === active);
+        if (meta) {
+          document.getElementById('activeTitle').textContent = sessionPeerId(meta) || active;
+          document.getElementById('activeMeta').textContent = sessionMetaText(meta);
+        }
+      }
+      if (lastStateRoot) refreshCurrentState().catch(console.error);
+      syncToggleIcons();
+    }
 
     function requestQuery(extra = {}) {
       const params = new URLSearchParams();
@@ -3862,6 +5485,50 @@ function webIndexHtml() {
       return sessionKindFilter === 'all' || kind === sessionKindFilter;
     }
 
+    function syncStartModeOptions() {
+      const kind = document.getElementById('kind').value;
+      const modeSelect = document.getElementById('startMode');
+      const current = modeSelect.value;
+      const modes = kind === 'claude'
+        ? [['new', 'new'], ['resume', 'resume'], ['continue', 'continue']]
+        : kind === 'codex'
+          ? [['new', 'new'], ['resume', 'resume'], ['last', 'last']]
+          : [['new', 'new']];
+      modeSelect.innerHTML = modes.map(([value]) => '<option value="' + value + '">' + tr('mode.' + value, value) + '</option>').join('');
+      modeSelect.value = modes.some(([value]) => value === current) ? current : 'new';
+      const isResume = modeSelect.value === 'resume';
+      document.querySelector('[data-resume-field]:not([data-resume-custom])').style.display = isResume ? '' : 'none';
+      if (isResume) loadResumable();
+      else document.querySelector('[data-resume-custom]').style.display = 'none';
+    }
+
+    // Fetch provider sessions hcc knows about and fill the resume dropdown.
+    async function loadResumable() {
+      try { const d = await api('/api/resumable'); resumableCache = d.resumable || []; }
+      catch { resumableCache = []; }
+      populateResumeSelect();
+    }
+    function populateResumeSelect() {
+      const kind = document.getElementById('kind').value;
+      const sel = document.getElementById('resumeSelect');
+      const prev = sel.value;
+      const items = resumableCache.filter((r) => r.provider === kind);
+      const opts = items.map((r) => {
+        const resume = r.resume || r.session_id || r.session_name || '';
+        const shortResume = resume.length > 14 ? resume.slice(0, 10) + '…' : resume;
+        const label = (r.name && r.name !== resume ? r.name + ' · ' : '') + shortResume + ' (' + r.peer + ')';
+        return '<option value="' + esc(resume) + '">' + esc(label) + '</option>';
+      });
+      opts.push('<option value="__custom__">' + esc(tr('customSession')) + '</option>');
+      sel.innerHTML = opts.join('');
+      if (prev && [...sel.options].some((o) => o.value === prev)) sel.value = prev;
+      toggleResumeCustom();
+    }
+    function toggleResumeCustom() {
+      const sel = document.getElementById('resumeSelect');
+      document.querySelector('[data-resume-custom]').style.display = sel.value === '__custom__' ? '' : 'none';
+    }
+
     async function loadProjects() {
       const data = await api('/api/projects');
       projects = data.projects || [];
@@ -3878,8 +5545,8 @@ function webIndexHtml() {
       activeType = 'managed';
       if (ws) { clearTimeout(wsReconnectTimer); ws.close(); ws = null; }
       term.reset();
-      document.getElementById('activeTitle').textContent = 'No session selected';
-      document.getElementById('activeMeta').textContent = 'Start or select a session from the left panel';
+      document.getElementById('activeTitle').textContent = tr('noSessionSelected');
+      document.getElementById('activeMeta').textContent = tr('startOrSelect');
       await Promise.all([refreshSessions(), refreshDetected(), refreshState()]);
       const first = sessions.find(s => s.status === 'running');
       if (first) connectManaged(first.id);
@@ -3900,7 +5567,30 @@ function webIndexHtml() {
 
     function fmtAge(age) {
       const n = Number(age);
-      return Number.isFinite(n) ? Math.max(0, Math.round(n)) + 's' : '?';
+      if (!Number.isFinite(n)) return '?';
+      return Math.max(0, Math.round(n)) + (lang === 'zh' ? '秒' : 's');
+    }
+
+    function sessionPeerId(session) {
+      return session?.peer_id || session?.id || '';
+    }
+
+    function sessionRuntimeNote(session) {
+      const peerId = sessionPeerId(session);
+      return session?.id && peerId && session.id !== peerId ? tr('runtime') + '=' + session.id + ' · ' : '';
+    }
+
+    function sessionMetaText(session) {
+      return sessionRuntimeNote(session) + (session.command || '') + (session.pane ? ' · ' + session.pane : '') + ' · ' + (session.cwd || '');
+    }
+
+    function statusText(status) {
+      const value = String(status || 'unknown');
+      return tr('status.' + value.toLowerCase(), value);
+    }
+
+    function managedPeerId(id) {
+      return sessionPeerId(sessions.find((s) => s.id === id)) || id;
     }
 
     function peerIsActive(peer, basisNow = lastStateNow) {
@@ -3915,28 +5605,83 @@ function webIndexHtml() {
       const activity = peer?.status || 'unknown';
       const liveness = peerIsActive(peer, basisNow) ? 'active' : 'stale';
       const age = fmtAge(peer?.age_sec);
-      const branch = peer?.branch ? ' branch=' + peer.branch : '';
+      const branch = peer?.branch ? ' ' + tr('branch') + '=' + peer.branch : '';
       if (runtime) {
         return {
           label: runtime.status || 'running',
-          detail: 'peer=' + activity + ' ' + liveness + ' age=' + age + branch
+          detail: tr('peer') + '=' + statusText(activity) + ' ' + statusText(liveness) + ' ' + tr('age') + '=' + age + branch
         };
       }
       if (liveness === 'stale') {
         return {
           label: 'stale',
-          detail: 'last=' + activity + ' age=' + age + branch
+          detail: tr('lastSeen') + '=' + statusText(activity) + ' ' + tr('age') + '=' + age + branch
         };
       }
       return {
         label: activity,
-        detail: liveness + ' age=' + age + branch
+        detail: statusText(liveness) + ' ' + tr('age') + '=' + age + branch
       };
     }
 
+    function bodyPinned(el) {
+      if (!el) return false;
+      return el.scrollTop + el.clientHeight >= el.scrollHeight - 8;
+    }
+
+    function stateCardCollapsed(section) {
+      return localStorage.getItem('hcc.stateCard.' + section + '.collapsed') === '1';
+    }
+
+    function stateCardHtml(section, title, count, bodyHtml) {
+      const collapsed = stateCardCollapsed(section);
+      return \`
+          <div class="card state-card \${collapsed ? 'state-card-collapsed' : ''}" data-section="\${esc(section)}">
+            <button class="state-card-toggle" type="button" aria-expanded="\${collapsed ? 'false' : 'true'}">
+              <span class="state-card-toggle-title"><strong>\${esc(title)}</strong> <span class="badge">\${esc(count)}</span></span>
+              <span class="state-card-chevron">⌄</span>
+            </button>
+            <div class="body">\${bodyHtml}</div>
+          </div>\`;
+    }
+
+    function bindStateCardToggles() {
+      document.querySelectorAll('.state-card[data-section] .state-card-toggle').forEach((button) => {
+        button.addEventListener('click', () => {
+          const card = button.closest('.state-card[data-section]');
+          if (!card) return;
+          const section = card.dataset.section || '';
+          const collapsed = !card.classList.contains('state-card-collapsed');
+          card.classList.toggle('state-card-collapsed', collapsed);
+          button.setAttribute('aria-expanded', collapsed ? 'false' : 'true');
+          localStorage.setItem('hcc.stateCard.' + section + '.collapsed', collapsed ? '1' : '0');
+        });
+      });
+    }
+
+    function renderTimelineItem(item) {
+      const meta = [
+        item.source + ':' + item.source_id,
+        item.task_id ? tr('task') + ' #' + item.task_id : '',
+        item.thread_id ? tr('thread') + ' #' + item.thread_id : '',
+        item.direction || '',
+        fmtTime(item.ts)
+      ].filter(Boolean).join(' · ');
+      return \`
+          <div class="item timeline-item">
+            <strong>\${esc(item.title || item.kind || item.source)} <span class="badge">\${esc(item.kind || item.source)}</span></strong>
+            <span>\${esc(meta)}</span>
+            \${item.text ? '<span>' + esc(item.text) + '</span>' : ''}
+          </div>\`;
+    }
+
     document.getElementById('projectSelect').addEventListener('change', (event) => {
       switchProject(event.target.value).catch(console.error);
     });
+    document.getElementById('langSelect').addEventListener('change', (event) => {
+      lang = event.target.value === 'zh' ? 'zh' : 'en';
+      applyLanguage();
+    });
     document.getElementById('sessionKindFilter').addEventListener('change', (event) => {
       sessionKindFilter = event.target.value || 'all';
       updateLocationProject();
@@ -3957,33 +5702,36 @@ function webIndexHtml() {
       const box = document.getElementById('sessions');
       const visibleSessions = sessions.filter(kindMatches);
       const visibleDetected = detected.filter(kindMatches);
-      const filterNote = sessionKindFilter === 'all' ? '' : '<br><br>View filter: ' + esc(sessionKindFilter);
+      const filterNote = sessionKindFilter === 'all' ? '' : '<br><br>' + esc(tr('viewFilter')) + ': ' + esc(sessionKindFilter);
       const manHtml = visibleSessions.length
-        ? visibleSessions.map((s) => \`
+        ? visibleSessions.map((s) => {
+          const peerId = sessionPeerId(s);
+          return \`
           <div class="session \${active === s.id && activeType === 'managed' ? 'active' : ''}" data-id="\${esc(s.id)}" data-type="managed">
-            <div class="row"><strong>\${esc(s.id)}</strong><span class="badge \${esc(s.status)}">\${esc(s.status)}</span></div>
+            <div class="row"><strong>\${esc(peerId)}</strong><span class="badge \${badgeClass(s.status)}">\${esc(statusText(s.status))}</span></div>
             <div class="row"><span class="badge">\${esc(s.kind)}</span><span class="badge \${s.type === 'external' || s.type === 'tmux' ? 'warn' : ''}">\${s.type === 'external' ? 'external' : s.type === 'tmux' ? 'tmux' : 'pty'}</span></div>
-            <div class="path">\${esc(s.command)}</div>
-          </div>\`).join('')
-        : '<div class="empty">No active sessions.' + filterNote + '<br><br>Start one above<br>or run in any terminal:<br><code>hcc peer start X -- claude</code></div>';
+            <div class="path">\${esc(sessionRuntimeNote(s) + (s.command || ''))}</div>
+          </div>\`;
+        }).join('')
+        : '<div class="empty">' + esc(tr('noActiveSessions')) + filterNote + '<br><br>' + esc(tr('startOneAbove')) + '<br>' + esc(tr('orRunTerminal')) + '<br><code>hcc peer start X -- claude</code></div>';
 
       const detHtml = visibleDetected.length
         ? visibleDetected.map((p) => {
           const state = peerStateView(p);
           return \`
           <div class="session \${activeDetected === p.id && activeType === 'detected' ? 'active' : ''}" data-id="\${esc(p.id)}" data-type="detected">
-            <div class="row"><strong>\${esc(p.id)}</strong><span class="badge" style="color:var(--warn);border-color:#6b5a20">detected</span></div>
-            <div class="row"><span class="badge">\${esc(p.kind)}</span><span class="badge \${badgeClass(state.label)}" title="\${esc(state.detail)}">\${esc(state.label)}</span></div>
+            <div class="row"><strong>\${esc(p.id)}</strong><span class="badge" style="color:var(--warn);border-color:#6b5a20">\${esc(tr('detected'))}</span></div>
+            <div class="row"><span class="badge">\${esc(p.kind)}</span><span class="badge \${badgeClass(state.label)}" title="\${esc(state.detail)}">\${esc(statusText(state.label))}</span></div>
             <div class="path" title="\${esc(p.worktree || '')}">\${esc((p.worktree || '').split('/').slice(-2).join('/'))}</div>
           </div>\`;
         }).join('')
-        : '<div class="empty">No detected peers.' + filterNote + '</div>';
+        : '<div class="empty">' + esc(tr('noDetectedPeers')) + filterNote + '</div>';
 
       const savedScroll = box.scrollTop;
       box.innerHTML = \`
-        <div class="sec-label">Managed <span class="badge">\${visibleSessions.filter(s=>s.status==='running').length} running</span></div>
+        <div class="sec-label">\${esc(tr('managed'))} <span class="badge">\${visibleSessions.filter(s=>s.status==='running').length} \${esc(tr('running'))}</span></div>
         \${manHtml}
-        <div class="sec-label" style="margin-top:10px">Detected <span class="badge" style="color:var(--warn)">\${visibleDetected.length}</span></div>
+        <div class="sec-label" style="margin-top:10px">\${esc(tr('detected'))} <span class="badge" style="color:var(--warn)">\${visibleDetected.length}</span></div>
         \${detHtml}
       \`;
       box.scrollTop = savedScroll;
@@ -3999,7 +5747,14 @@ function webIndexHtml() {
       const data = await api('/api/sessions');
       sessions = data.sessions || [];
       renderSections();
-      document.getElementById('connState').textContent = 'online';
+      if (active && activeType === 'managed') {
+        const meta = sessions.find((s) => s.id === active);
+        if (meta) {
+          document.getElementById('activeTitle').textContent = sessionPeerId(meta) || active;
+          document.getElementById('activeMeta').textContent = sessionMetaText(meta);
+        }
+      }
+      connText('online');
     }
 
     async function refreshDetected() {
@@ -4025,52 +5780,71 @@ function webIndexHtml() {
         ? new Map(
           [...state.querySelectorAll('.state-card[data-section]')].map((card) => [
             card.dataset.section,
-            card.querySelector('.body')?.scrollTop || 0
+            {
+              top: card.querySelector('.body')?.scrollTop || 0,
+              pinned: bodyPinned(card.querySelector('.body'))
+            }
           ])
         )
         : new Map();
-      const runtimeById = new Map((sessions || []).map((s) => [s.id, s]));
+      const runtimeById = new Map();
+      for (const session of sessions || []) {
+        runtimeById.set(session.id, session);
+        const peerId = sessionPeerId(session);
+        if (peerId) runtimeById.set(peerId, session);
+      }
       const tasksData = data.tasks || [];
       const peersData = data.peers || [];
       const locksData = data.locks || [];
       const messagesData = data.messages || [];
-      const eventsData = data.events || [];
+      const timelineData = data.timeline || [];
+      const automation = data.automation || {};
+      const nextAction = automation.next_action || {};
       const tasks = tasksData.map((t) => \`
-        <div class="item"><strong>#\${t.id} \${esc(t.title)}</strong><span>\${esc(t.status)} owner=\${esc(t.owner || '')} assignee=\${esc(t.assignee || '')}</span></div>
-      \`).join('') || '<div class="empty">No tasks.</div>';
+          <div class="item"><strong>#\${t.id} \${esc(t.title)}</strong><span>\${esc(statusText(t.status))} \${esc(tr('owner'))}=\${esc(t.owner || '')} \${esc(tr('assignee'))}=\${esc(t.assignee || '')}</span></div>
+        \`).join('') || '<div class="empty">' + esc(tr('noTasks')) + '</div>';
       const peers = peersData.map((a) => {
         const peerRuntime = runtimeById.get(a.id);
         const peerState = peerStateView(a, peerRuntime, data.now);
         return \`
-        <div class="item"><strong>\${esc(a.id)} <span class="badge">\${esc(a.kind)}</span> <span class="badge \${badgeClass(peerState.label)}">\${esc(peerState.label)}</span></strong><span>\${esc(peerState.detail)}</span></div>
+        <div class="item"><strong>\${esc(a.id)} <span class="badge">\${esc(a.kind)}</span> <span class="badge \${badgeClass(peerState.label)}">\${esc(statusText(peerState.label))}</span></strong><span>\${esc(peerState.detail)}</span></div>
       \`;
-      }).join('') || '<div class="empty">No peers.</div>';
+      }).join('') || '<div class="empty">' + esc(tr('noPeers')) + '</div>';
       const locks = locksData.map((l) => \`
-        <div class="item"><strong>\${esc(l.resource)}</strong><span>owner=\${esc(l.owner)} task=\${l.task_id ? '#' + l.task_id : ''}</span></div>
-      \`).join('') || '<div class="empty">No active locks.</div>';
+          <div class="item"><strong>\${esc(l.resource)}</strong><span>\${esc(tr('owner'))}=\${esc(l.owner)} \${esc(tr('task'))}=\${l.task_id ? '#' + l.task_id : ''}</span></div>
+        \`).join('') || '<div class="empty">' + esc(tr('noActiveLocks')) + '</div>';
       const messages = messagesData.map((m) => \`
-        <div class="item"><strong>#\${m.id} \${esc(m.sender)} → \${esc(m.recipient || 'all')}</strong><span>\${esc(m.body)}</span></div>
-      \`).join('') || '<div class="empty">No messages.</div>';
-      const events = eventsData.map((e) => \`
-        <div class="item"><strong>#\${e.id} \${esc(e.type)}</strong><span>\${esc(e.actor || '')} \${e.task_id ? '#' + e.task_id : ''} \${fmtTime(e.created_at)}</span></div>
-      \`).join('') || '<div class="empty">No events.</div>';
-      state.innerHTML = \`
-        <div class="card state-card" data-section="peers"><h2>Peers <span class="badge">\${peersData.length}</span></h2><div class="body">\${peers}</div></div>
-        <div class="card state-card" data-section="tasks"><h2>Tasks <span class="badge">\${tasksData.length}</span></h2><div class="body">\${tasks}</div></div>
-        <div class="card state-card" data-section="locks"><h2>Locks <span class="badge">\${locksData.length}</span></h2><div class="body">\${locks}</div></div>
-        <div class="card state-card" data-section="messages"><h2>Messages <span class="badge">\${messagesData.length}</span></h2><div class="body">\${messages}</div></div>
-        <div class="card state-card" data-section="events"><h2>Events <span class="badge">\${eventsData.length}</span></h2><div class="body">\${events}</div></div>
-      \`;
+          <div class="item"><strong>#\${m.id} \${esc(m.sender)} → \${esc(m.recipient || tr('all'))}\${m.reply_to ? ' ' + esc(tr('reply')) + ' #' + m.reply_to : ''}</strong><span>\${esc(m.body)}</span></div>
+        \`).join('') || '<div class="empty">' + esc(tr('noMessages')) + '</div>';
+      const timeline = timelineData.map(renderTimelineItem).join('') || '<div class="empty">' + esc(tr('noTimelineItems')) + '</div>';
+      const actionLines = [
+        '<div class="item"><strong>' + esc(statusText(automation.phase || 'idle')) + '</strong><span>' + esc(nextAction.reason || tr('noImmediateAction')) + '</span></div>',
+        nextAction.command ? '<div class="item"><strong>' + esc(tr('next')) + '</strong><span class="mono">' + esc(nextAction.command) + '</span></div>' : '',
+        (automation.finish_actions || []).length ? '<div class="item"><strong>' + esc(tr('finish')) + '</strong><span>' + esc(automation.finish_actions.map((a) => a.command).join(' | ')) + '</span></div>' : '',
+        (automation.warnings || []).length ? '<div class="item"><strong>' + esc(tr('warnings')) + '</strong><span>' + esc(automation.warnings.join(' | ')) + '</span></div>' : ''
+      ].filter(Boolean).join('');
+      state.innerHTML = [
+        stateCardHtml('automation', tr('nextAction'), statusText(automation.phase || 'idle'), actionLines),
+        stateCardHtml('timeline', tr('timeline'), timelineData.length, timeline),
+        stateCardHtml('messages', tr('messages'), messagesData.length, messages),
+        stateCardHtml('peers', tr('peers'), peersData.length, peers),
+        stateCardHtml('tasks', tr('tasks'), tasksData.length, tasks),
+        stateCardHtml('locks', tr('locks'), locksData.length, locks)
+      ].join('');
       state.scrollTop = savedStateScroll;
-      for (const [section, top] of savedCardScroll) {
+      for (const [section, saved] of savedCardScroll) {
         const body = state.querySelector('.state-card[data-section="' + section + '"] .body');
-        if (body) body.scrollTop = top;
+        if (!body) continue;
+        if (section === 'timeline' && saved.pinned) body.scrollTop = body.scrollHeight;
+        else body.scrollTop = saved.top;
       }
+      bindStateCardToggles();
       lastStateRoot = stateRoot;
     }
 
     async function refreshState() {
-      const p = active ? '/api/state?peer=' + encodeURIComponent(active) : '/api/state';
+      const peer = active ? managedPeerId(active) : null;
+      const p = peer ? '/api/state?peer=' + encodeURIComponent(peer) : '/api/state';
       const data = await api(p);
       renderState(data);
     }
@@ -4081,15 +5855,21 @@ function webIndexHtml() {
       renderState(data);
     }
 
+    async function refreshCurrentState() {
+      if (activeType === 'detected') return refreshDetectedState();
+      return refreshState();
+    }
+
     // ── Connect to managed (PTY) session ─────────────────────────────────
     function connectManaged(id) {
       const meta = sessions.find((s) => s.id === id);
+      const peerId = sessionPeerId(meta) || id;
       active = id;
       activeDetected = null;
       activeType = 'managed';
       renderSections();
-      document.getElementById('activeTitle').textContent = id;
-      document.getElementById('activeMeta').textContent = meta ? meta.command + (meta.pane ? ' · ' + meta.pane : '') + ' · ' + (meta.cwd || '') : '';
+      document.getElementById('activeTitle').textContent = peerId;
+      document.getElementById('activeMeta').textContent = meta ? sessionMetaText(meta) : '';
       document.getElementById('terminal').style.display = '';
       document.getElementById('detectedPanel').style.display = 'none';
       document.getElementById('quickBar').style.display = '';
@@ -4105,7 +5885,7 @@ function webIndexHtml() {
       ws = new WebSocket(proto + '://' + location.host + '/ws/terminal/' + encodeURIComponent(id) + requestQuery());
       ws.onopen = () => {
         resizeTerm();
-        document.getElementById('connState').textContent = 'attached';
+        connText('attached');
       };
       ws.onmessage = (event) => {
         const msg = JSON.parse(event.data);
@@ -4122,12 +5902,12 @@ function webIndexHtml() {
         if (msg.type === 'exit') { refreshSessions().catch(console.error); }
       };
       ws.onclose = () => {
-        document.getElementById('connState').textContent = 'reconnecting...';
+        connText('reconnecting');
         // Auto-reconnect if session is still in the list and running
         wsReconnectTimer = setTimeout(() => {
           const s = sessions.find((s) => s.id === id);
           if (s && s.status === 'running' && active === id) openWs(id);
-          else document.getElementById('connState').textContent = 'online';
+          else connText('online');
         }, 2000);
       };
     }
@@ -4140,12 +5920,12 @@ function webIndexHtml() {
       activeType = 'detected';
       if (ws) { clearTimeout(wsReconnectTimer); ws.close(); ws = null; }
       renderSections();
-      document.getElementById('activeTitle').textContent = id + ' (detected)';
+      document.getElementById('activeTitle').textContent = id + ' (' + tr('detected') + ')';
       document.getElementById('activeMeta').textContent = peer ? peer.kind + ' · ' + (peer.worktree || '') : '';
       document.getElementById('terminal').style.display = 'none';
       document.getElementById('detectedPanel').style.display = '';
       document.getElementById('quickBar').style.display = 'none';
-      document.getElementById('connState').textContent = 'coordination only';
+      connText('coordinationOnly');
       renderDetectedPanel(peer || { id });
       refreshDetectedState().catch(console.error);
     }
@@ -4155,22 +5935,22 @@ function webIndexHtml() {
       dp.innerHTML = \`
         <div style="padding:16px;display:grid;gap:12px">
           <div class="card">
-            <h2>Detected Session</h2>
+            <h2>\${esc(tr('detectedSession'))}</h2>
             <div class="body">
-              <div class="item"><strong>peer</strong><span class="mono">\${esc(peer.id)}</span></div>
-              <div class="item"><strong>kind</strong><span>\${esc(peer.kind || '')}</span></div>
-              <div class="item"><strong>status</strong><span>\${esc(peer.status || '')}</span></div>
-              <div class="item"><strong>cwd</strong><span class="mono" style="font-size:11px">\${esc(peer.worktree || '')}</span></div>
-              <div class="item"><strong>pid</strong><span>\${esc(peer.pid || 'unknown')}</span></div>
-              <div class="item"><strong>last seen</strong><span>\${peer.age_sec != null ? peer.age_sec + 's ago' : ''}</span></div>
+              <div class="item"><strong>\${esc(tr('peer'))}</strong><span class="mono">\${esc(peer.id)}</span></div>
+              <div class="item"><strong>\${esc(tr('kind'))}</strong><span>\${esc(peer.kind || '')}</span></div>
+              <div class="item"><strong>\${esc(tr('status'))}</strong><span>\${esc(peer.status || '')}</span></div>
+              <div class="item"><strong>\${esc(tr('cwd'))}</strong><span class="mono" style="font-size:11px">\${esc(peer.worktree || '')}</span></div>
+              <div class="item"><strong>\${esc(tr('pid'))}</strong><span>\${esc(peer.pid || tr('unknown'))}</span></div>
+              <div class="item"><strong>\${esc(tr('lastSeen'))}</strong><span>\${peer.age_sec != null ? esc(peer.age_sec + tr('secondsAgo')) : ''}</span></div>
             </div>
           </div>
           <div class="card">
-            <h2>Send Message</h2>
+            <h2>\${esc(tr('sendMessage'))}</h2>
             <div class="body" style="gap:8px">
-              <div style="font-size:12px;color:var(--muted)">Message will appear in the peer's <code>hcc msg inbox</code> and be injected on next hook fire.</div>
-              <textarea id="detMsg" rows="3" style="width:100%;background:#0d0f12;border:1px solid var(--border);color:var(--text);border-radius:6px;padding:8px;font:inherit;resize:vertical" placeholder="Message body..."></textarea>
-              <button class="primary" id="sendDetMsg">Send</button>
+              <div style="font-size:12px;color:var(--muted)">\${tr('messageHelp')}</div>
+              <textarea id="detMsg" rows="3" style="width:100%;background:#0d0f12;border:1px solid var(--border);color:var(--text);border-radius:6px;padding:8px;font:inherit;resize:vertical" placeholder="\${esc(tr('messageBodyPlaceholder'))}"></textarea>
+              <button class="primary" id="sendDetMsg">\${esc(tr('send'))}</button>
             </div>
           </div>
         </div>
@@ -4181,10 +5961,11 @@ function webIndexHtml() {
         await api('/api/detected/' + encodeURIComponent(peer.id) + '/msg', {
           method: 'POST',
           body: JSON.stringify({ body, from: 'web' })
+          });
+          document.getElementById('detMsg').value = '';
+          await refreshDetectedState();
         });
-        document.getElementById('detMsg').value = '';
-      });
-    }
+      }
 
     // ── Helpers ───────────────────────────────────────────────────────────
     function sendLine(text) {
@@ -4193,40 +5974,291 @@ function webIndexHtml() {
     }
 
     // ── Start session form ────────────────────────────────────────────────
+    document.getElementById('kind').addEventListener('change', syncStartModeOptions);
+    document.getElementById('startMode').addEventListener('change', syncStartModeOptions);
+    document.getElementById('resumeSelect').addEventListener('change', toggleResumeCustom);
+    syncStartModeOptions();
+
     document.getElementById('startForm').addEventListener('submit', async (event) => {
       event.preventDefault();
-      const payload = {
-        kind: document.getElementById('kind').value
-      };
+      const kind = document.getElementById('kind').value;
+      const mode = document.getElementById('startMode').value;
+      const sel = document.getElementById('resumeSelect');
+      const resume = (sel.value && sel.value !== '__custom__')
+        ? sel.value
+        : document.getElementById('resumeArg').value.trim();
+      if (mode === 'resume' && !resume) return;
+      const payload = { kind, mode };
+      if (mode === 'resume') payload.resume = resume;
       const data = await api('/api/sessions', { method: 'POST', body: JSON.stringify(payload) });
       await refreshSessions();
       connectManaged(data.session.id);
     });
 
-    document.querySelectorAll('[data-send]').forEach((button) => {
+    function activePeerInfo() {
+      if (!active) return null;
+      const session = sessions.find((s) => s.id === active) || { id: active, kind: 'other', role: 'peer' };
+      return {
+        session,
+        peerId: sessionPeerId(session) || active
+      };
+    }
+
+    function terminalCommandForAction(action, info) {
+      const session = info.session || {};
+      const peerId = info.peerId;
+      const lines = {
+        register: \`hcc register --peer \${peerId} --kind \${session.kind || 'other'} --role \${session.role || 'peer'}\`,
+        inbox:    \`hcc msg inbox --peer \${peerId}\`,
+        'task-next': \`hcc task next --peer \${peerId}\`,
+        state:    \`hcc state --peer \${peerId}\`,
+        status:   \`hcc status --peer \${peerId}\`,
+        heartbeat:\`hcc heartbeat --peer \${peerId} --renew-locks\`
+      };
+      return lines[action] || lines.status;
+    }
+
+    function formatActionResult(result) {
+      if (!result) return '';
+      const data = result.data || {};
+      if (result.action === 'status') {
+        const tasks = (data.tasks || []).map((row) => row.status + ':' + row.n).join(', ') || 'none';
+        return [
+          data.root,
+          'peers active=' + data.active_peers + ' stale=' + data.stale_peers,
+          'tasks ' + tasks,
+          'locks active=' + data.active_locks,
+          'unread ' + (data.unread ?? 0)
+        ].filter(Boolean).join('\\n');
+      }
+      if (result.action === 'state') {
+        const automation = data.automation || {};
+        const next = automation.next_action || {};
+        return [
+          'phase: ' + (automation.phase || 'idle'),
+          'next: ' + (next.command || next.kind || 'none'),
+          'why: ' + (next.reason || tr('noImmediateAction')),
+          ...(automation.warnings || []).map((w) => 'warning: ' + w)
+        ].join('\\n');
+      }
+      if (result.action === 'inbox') {
+        const messages = data.messages || [];
+        return messages.length
+          ? messages.map((m) => '#' + m.id + ' ' + m.sender + ' -> ' + (m.recipient || 'all') + ': ' + m.body).join('\\n')
+          : tr('noMessages');
+      }
+      if (result.action === 'task-next') {
+        return data.task
+          ? (data.current ? 'current ' : 'claimed ') + '#' + data.task.id + ' ' + data.task.title + ' (' + data.task.status + ')'
+          : result.summary;
+      }
+      return result.summary || JSON.stringify(result, null, 2);
+    }
+
+    function showActionResult(result) {
+      const panel = document.getElementById('actionResult');
+      document.getElementById('actionResultTitle').textContent = (result.action || tr('actionResult')) + ' · ' + (result.peer || '');
+      document.getElementById('actionResultBody').textContent = formatActionResult(result);
+      panel.hidden = false;
+    }
+
+    async function runPeerAction(action) {
+      const info = activePeerInfo();
+      if (!info) return;
+      const payload = action === 'register'
+        ? { kind: info.session.kind || 'other', role: info.session.role || 'peer', worktree: info.session.cwd || currentProject }
+        : action === 'heartbeat'
+          ? { renew_locks: true }
+          : {};
+      const readOnly = ['status', 'state', 'inbox'].includes(action);
+      const result = await api('/api/peers/' + encodeURIComponent(info.peerId) + '/actions/' + encodeURIComponent(action), readOnly
+        ? {}
+        : { method: 'POST', body: JSON.stringify(payload) });
+      showActionResult(result);
+      await Promise.all([refreshSessions(), refreshDetected(), refreshCurrentState()]);
+    }
+
+    document.querySelectorAll('[data-action]').forEach((button) => {
       button.addEventListener('click', () => {
-        if (!active) return;
-        const session = sessions.find((s) => s.id === active) || { kind: 'other', role: 'peer' };
-        const lines = {
-          register: \`hcc register --peer \${active} --kind \${session.kind || 'other'} --role \${session.role || 'peer'}\`,
-          inbox:    \`hcc msg inbox --peer \${active}\`,
-          next:     \`hcc task next --peer \${active}\`,
-          status:   \`hcc status --peer \${active}\`,
-          heartbeat:\`hcc heartbeat --peer \${active} --renew-locks\`
-        };
-        sendLine(lines[button.dataset.send]);
+        closeActionsMenu();
+        runPeerAction(button.dataset.action).catch((err) => {
+          showActionResult({ action: button.dataset.action, peer: activePeerInfo()?.peerId || '', summary: err.message, data: { error: err.message } });
+        });
+      });
+    });
+    document.querySelectorAll('[data-terminal-action]').forEach((button) => {
+      button.addEventListener('click', () => {
+        const info = activePeerInfo();
+        if (!info) return;
+        sendLine(terminalCommandForAction(button.dataset.terminalAction, info));
+        closeActionsMenu();
       });
     });
+    document.getElementById('actionResultClose').addEventListener('click', () => {
+      document.getElementById('actionResult').hidden = true;
+    });
+
+    // ── Actions dropdown (declutters the toolbar) ─────────────────────────
+    const actionsBtn = document.getElementById('actionsBtn');
+    const actionsMenu = document.getElementById('actionsMenu');
+    function closeActionsMenu() {
+      actionsMenu.hidden = true;
+      actionsBtn.setAttribute('aria-expanded', 'false');
+    }
+    actionsBtn.addEventListener('click', (e) => {
+      e.stopPropagation();
+      const open = actionsMenu.hidden;
+      actionsMenu.hidden = !open;
+      actionsBtn.setAttribute('aria-expanded', String(open));
+      if (open) {
+        // Position as a fixed layer so it escapes the toolbar/main overflow clip.
+        const r = actionsBtn.getBoundingClientRect();
+        actionsMenu.style.top = (r.bottom + 6) + 'px';
+        actionsMenu.style.left = Math.max(8, r.right - actionsMenu.offsetWidth) + 'px';
+      }
+    });
+    document.addEventListener('click', (e) => {
+      if (!actionsMenu.hidden && !e.target.closest('.menu-wrap')) closeActionsMenu();
+    });
+    document.addEventListener('keydown', (e) => { if (e.key === 'Escape') closeActionsMenu(); });
+
+    // ── Collapsible side panels ───────────────────────────────────────────
+    const appEl = document.querySelector('.app');
+    const toggleLeftBtn = document.getElementById('toggleLeft');
+    const toggleRightBtn = document.getElementById('toggleRight');
+    const resizeLeftHandle = document.getElementById('resizeLeft');
+    const resizeRightHandle = document.getElementById('resizeRight');
+    const sideDefaults = { left: 320, right: 360 };
+    const sideMin = { left: 220, right: 240 };
+    const sideMax = { left: 560, right: 640 };
+    const sideWidthKey = { left: 'hcc.sidebar.left.width', right: 'hcc.sidebar.right.width' };
+    const dragState = { side: null, startX: 0, startWidth: 0, moved: false, suppressClick: false };
+    function sideIsCollapsed(side) {
+      return appEl.classList.contains(side + '-collapsed') || localStorage.getItem('hcc.collapse.' + side) === '1';
+    }
+    function storedSideWidth(side) {
+      const raw = Number(localStorage.getItem(sideWidthKey[side]));
+      return Number.isFinite(raw) && raw > 0 ? raw : sideDefaults[side];
+    }
+    function effectiveOppositeWidth(side) {
+      const opposite = side === 'left' ? 'right' : 'left';
+      return sideIsCollapsed(opposite) ? 0 : storedSideWidth(opposite);
+    }
+    function clampSideWidth(side, width) {
+      const viewport = Math.max(640, window.innerWidth || appEl.clientWidth || 0);
+      const opposite = effectiveOppositeWidth(side);
+      const maxByViewport = Math.max(sideMin[side], viewport - opposite - 280);
+      return Math.max(sideMin[side], Math.min(sideMax[side], maxByViewport, Math.round(width)));
+    }
+    function readSideWidth(side) {
+      return clampSideWidth(side, storedSideWidth(side));
+    }
+    function setSideWidth(side, width, persist = true) {
+      const value = clampSideWidth(side, width);
+      appEl.style.setProperty('--' + side + '-width', value + 'px');
+      if (persist) localStorage.setItem(sideWidthKey[side], String(value));
+      return value;
+    }
+    function applySideWidths() {
+      setSideWidth('left', readSideWidth('left'), false);
+      setSideWidth('right', readSideWidth('right'), false);
+    }
+    function syncToggleIcons() {
+      const l = appEl.classList.contains('left-collapsed');
+      const r = appEl.classList.contains('right-collapsed');
+      toggleLeftBtn.textContent = l ? '⟩' : '⟨';
+      toggleLeftBtn.title = (l ? tr('show') : tr('collapse')) + ' ' + tr('sidebar') + '; ' + tr('dragToResize');
+      toggleRightBtn.textContent = r ? '⟨' : '⟩';
+      toggleRightBtn.title = (r ? tr('show') : tr('collapse')) + ' ' + tr('statePanel') + '; ' + tr('dragToResize');
+    }
+    function applyCollapseState() {
+      appEl.classList.toggle('left-collapsed', localStorage.getItem('hcc.collapse.left') === '1');
+      appEl.classList.toggle('right-collapsed', localStorage.getItem('hcc.collapse.right') === '1');
+      applySideWidths();
+      syncToggleIcons();
+    }
+    function toggleSide(side) {
+      const cls = side + '-collapsed';
+      const on = appEl.classList.toggle(cls);
+      localStorage.setItem('hcc.collapse.' + side, on ? '1' : '0');
+      applySideWidths();
+      syncToggleIcons();
+      // Refit the terminal after the grid transition so xterm uses the new width.
+      setTimeout(() => { try { resizeTerm(); } catch {} }, 200);
+    }
+    function beginSideDrag(side, event) {
+      if (event.button !== undefined && event.button !== 0) return;
+      dragState.side = side;
+      dragState.startX = event.clientX;
+      dragState.startWidth = readSideWidth(side);
+      dragState.moved = false;
+      dragState.suppressClick = false;
+      appEl.classList.add('resizing');
+      event.currentTarget.setPointerCapture?.(event.pointerId);
+      event.preventDefault();
+    }
+    function moveSideDrag(event) {
+      if (!dragState.side) return;
+      const delta = event.clientX - dragState.startX;
+      if (!dragState.moved && Math.abs(delta) <= 3) return;
+      dragState.moved = true;
+      const width = dragState.side === 'left'
+        ? dragState.startWidth + delta
+        : dragState.startWidth - delta;
+      setSideWidth(dragState.side, width);
+      if (dragState.side === 'left') {
+        appEl.classList.remove('left-collapsed');
+        localStorage.setItem('hcc.collapse.left', '0');
+      } else {
+        appEl.classList.remove('right-collapsed');
+        localStorage.setItem('hcc.collapse.right', '0');
+      }
+      syncToggleIcons();
+      try { resizeTerm(); } catch {}
+      event.preventDefault();
+    }
+    function endSideDrag(event) {
+      if (!dragState.side) return;
+      dragState.suppressClick = dragState.moved;
+      event.currentTarget.releasePointerCapture?.(event.pointerId);
+      dragState.side = null;
+      appEl.classList.remove('resizing');
+      setTimeout(() => { dragState.suppressClick = false; }, 0);
+      try { resizeTerm(); } catch {}
+    }
+    function bindSideHandle(handle, side, clickAction = null) {
+      handle.addEventListener('pointerdown', (event) => beginSideDrag(side, event));
+      handle.addEventListener('pointermove', moveSideDrag);
+      handle.addEventListener('pointerup', endSideDrag);
+      handle.addEventListener('pointercancel', endSideDrag);
+      handle.addEventListener('click', (event) => {
+        if (dragState.suppressClick) {
+          event.preventDefault();
+          return;
+        }
+        if (clickAction) clickAction(side);
+      });
+    }
+    bindSideHandle(resizeLeftHandle, 'left');
+    bindSideHandle(resizeRightHandle, 'right');
+    bindSideHandle(toggleLeftBtn, 'left', toggleSide);
+    bindSideHandle(toggleRightBtn, 'right', toggleSide);
+    window.addEventListener('resize', () => {
+      applySideWidths();
+      setTimeout(() => { try { resizeTerm(); } catch {} }, 50);
+    });
+    applyCollapseState();
 
     document.getElementById('stopBtn').addEventListener('click', async () => {
       if (!active) return;
       await api('/api/sessions/' + encodeURIComponent(active) + '/stop', { method: 'POST', body: '{}' });
       await refreshSessions();
     });
-    document.getElementById('refreshBtn').addEventListener('click', () => {
-      Promise.all([refreshSessions(), refreshDetected(), refreshState()]).catch(console.error);
-    });
+      document.getElementById('refreshBtn').addEventListener('click', () => {
+        Promise.all([refreshSessions(), refreshDetected(), refreshCurrentState()]).catch(console.error);
+      });
 
+    applyLanguage();
     loadProjects().then(() => Promise.all([refreshSessions(), refreshDetected(), refreshState()])).then(() => {
       // Auto-connect to first running managed session on load
       if (!active && !activeDetected) {
@@ -4234,7 +6266,7 @@ function webIndexHtml() {
         if (first) connectManaged(first.id);
       }
     }).catch((err) => {
-      document.getElementById('connState').textContent = 'error';
+      connText('error');
       console.error(err);
     });
     // ── Auto-poll state ──────────────────────────────────────────────────
@@ -4255,12 +6287,12 @@ function webIndexHtml() {
 async function cmdWeb(ctx, args, startMeta = {}) {
   if (args[0] === '--help' || args[0] === '-h') return helpWeb();
   if (process.env[WEB_CHILD_ENV] !== '1') return startWebBackground(ctx, args);
-  const opts = parseOpts(args, { booleans: ['local', 'no-guidance', 'no-discover'] });
-  validateOpts('web', opts, ['host', 'port', 'token', 'local', 'no-guidance', 'no-discover']);
-  const host = opts.host || (opts.local ? '127.0.0.1' : '0.0.0.0');
+  const opts = parseOpts(args, { booleans: ['local', 'no-token', 'no-guidance', 'no-discover'] });
+  validateOpts('web', opts, ['host', 'port', 'token', 'local', 'no-token', 'no-guidance', 'no-discover']);
+  validateWebTokenOpts(opts);
+  const host = expectedWebHost(opts);
   const port = intOpt(opts, 'port', 8787);
-  const explicitToken = opts.token || process.env.HCC_WEB_TOKEN || '';
-  const token = explicitToken;
+  const token = makeWebToken(opts);
   ensureTmuxAvailable({ autoInstall: false });
   const ptyModule = await import('node-pty');
   const { WebSocketServer } = await import('ws');
@@ -4306,8 +6338,18 @@ async function cmdWeb(ctx, args, startMeta = {}) {
     return [...sessions.values()].filter((session) => session.root === projectCtx.root);
   }
 
-  function getSession(projectCtx, id) {
-    return sessions.get(sessionKey(projectCtx, id));
+  function getSession(projectCtx, id, db = null) {
+    const direct = sessions.get(sessionKey(projectCtx, id));
+    if (direct) return direct;
+    for (const session of sessionsForProject(projectCtx)) {
+      if (session.peerId === id) return session;
+    }
+    if (db) {
+      for (const session of sessionsForProject(projectCtx)) {
+        if (resolveSessionPeerId(db, session) === id) return session;
+      }
+    }
+    return null;
   }
 
   function knownPeerIds(projectCtx) {
@@ -4350,6 +6392,7 @@ async function cmdWeb(ctx, args, startMeta = {}) {
 
     const session = {
       id,
+      peerId: id,
       root: pctx.root,
       ctx: pctx,
       kind: meta.kind || 'external',
@@ -4478,9 +6521,58 @@ async function cmdWeb(ctx, args, startMeta = {}) {
   const autoAttachPoller = setInterval(scanAndAttachDetectedPeers, 5000);
 
   // ── Serialize + broadcast helpers ─────────────────────────────────────────
-  function serializeSession(session) {
+  function resolveSessionPeerId(db, session) {
+    if (!session) return null;
+    if (!db) return session.peerId || session.id || null;
+
+    if (session.type === 'tmux' && session.pane) {
+      const byTarget = db.prepare(`
+        SELECT peer
+        FROM peer_bindings
+        WHERE runtime_target = ?
+        ORDER BY updated_at DESC, created_at DESC
+        LIMIT 1
+      `).get(session.pane);
+      if (byTarget?.peer) {
+        session.peerId = byTarget.peer;
+        return byTarget.peer;
+      }
+    }
+
+    if (session.id) {
+      const byRuntime = db.prepare(`
+        SELECT peer
+        FROM peer_bindings
+        WHERE runtime_session_id = ?
+        ORDER BY updated_at DESC, created_at DESC
+        LIMIT 1
+      `).get(session.id);
+      if (byRuntime?.peer) {
+        session.peerId = byRuntime.peer;
+        return byRuntime.peer;
+      }
+
+      const byPeer = db.prepare(`
+        SELECT peer
+        FROM peer_bindings
+        WHERE peer = ?
+        LIMIT 1
+      `).get(session.id);
+      if (byPeer?.peer) {
+        session.peerId = byPeer.peer;
+        return byPeer.peer;
+      }
+    }
+
+    session.peerId = session.peerId || session.id || null;
+    return session.peerId;
+  }
+
+  function serializeSession(session, db = null) {
+    const peerId = resolveSessionPeerId(db, session);
     return {
       id: session.id,
+      peer_id: peerId,
       kind: session.kind,
       role: session.role,
       command: session.command,
@@ -4526,9 +6618,18 @@ async function cmdWeb(ctx, args, startMeta = {}) {
     sessions.delete(sessionKey(pctx, session.id));
     const db = connect(pctx);
     try {
-      db.prepare('UPDATE peers SET status = ?, last_seen_at = ? WHERE id = ?').run(status, now(), session.id);
-      db.prepare('UPDATE peer_bindings SET runtime_target = NULL, updated_at = ? WHERE peer = ?').run(now(), session.id);
-      addEvent(db, status === 'exited' ? 'tmux.session.exited' : 'tmux.session.detached', session.id, null, {
+      const t = now();
+      const peerId = resolveSessionPeerId(db, session) || session.id;
+      db.prepare('UPDATE peers SET status = ?, last_seen_at = ? WHERE id IN (?, ?)').run(status, t, session.id, peerId);
+      db.prepare(`
+        UPDATE peer_bindings
+        SET runtime_target = NULL, updated_at = ?
+        WHERE peer IN (?, ?)
+           OR runtime_session_id = ?
+           OR (? IS NOT NULL AND runtime_target = ?)
+      `).run(t, session.id, peerId, session.id, session.pane || null, session.pane || null);
+      addEvent(db, status === 'exited' ? 'tmux.session.exited' : 'tmux.session.detached', peerId, null, {
+        runtime_session_id: session.id,
         pane: session.pane
       });
     } finally {
@@ -4577,6 +6678,10 @@ async function cmdWeb(ctx, args, startMeta = {}) {
     const safeId = String(session.id).replace(/[^A-Za-z0-9_.-]/g, '_');
     const pipeFile = path.join(bufsDir, `tmux-${safePane}-${safeId}.pipe`);
     session.pipeFile = pipeFile;
+    // Restored panes may still have pipe-pane writers from a previous runtime.
+    // Disable first so tmux tears down the stale writer before this runtime
+    // installs its own FIFO reader.
+    try { runTmux(['pipe-pane', '-t', session.pane]); } catch {}
     // Capture the existing screen once for the initial paint; pipe-pane only
     // forwards output produced after it is enabled.
     try {
@@ -4645,6 +6750,7 @@ async function cmdWeb(ctx, args, startMeta = {}) {
   function stopTmuxStream(session) {
     if (session.streamPoller) { clearInterval(session.streamPoller); session.streamPoller = null; }
     if (session.replaceTimer) { clearTimeout(session.replaceTimer); session.replaceTimer = null; }
+    if (session.inputRefreshTimer) { clearTimeout(session.inputRefreshTimer); session.inputRefreshTimer = null; }
     // Turn piping back off for this pane (no command toggles it off).
     try { runTmux(['pipe-pane', '-t', session.pane]); } catch {}
     if (session.streamFd !== null && session.streamFd !== undefined) {
@@ -4688,6 +6794,7 @@ async function cmdWeb(ctx, args, startMeta = {}) {
     const captured = tmuxCapturePane(info.pane);
     const session = {
       id,
+      peerId: id,
       root: pctx.root,
       ctx: pctx,
       kind,
@@ -4737,7 +6844,7 @@ async function cmdWeb(ctx, args, startMeta = {}) {
         capabilities: 'tmux'
       });
       const binding = input.binding || {};
-      upsertCanonicalPeerBinding(db, {
+      const canonical = upsertCanonicalPeerBinding(db, {
         peer: id,
         provider: binding.provider || kind,
         provider_session_id: binding.provider_session_id || null,
@@ -4749,6 +6856,7 @@ async function cmdWeb(ctx, args, startMeta = {}) {
         runtime_session_id: id,
         runtime_target: info.pane
       }, Boolean(input.force));
+      session.peerId = canonical.peer;
       addEvent(db, 'tmux.session.attached', id, null, { pane: info.pane, command, cwd, pid: info.pid });
     } finally {
       db.close();
@@ -4761,11 +6869,21 @@ async function cmdWeb(ctx, args, startMeta = {}) {
       try { fs.appendFileSync(session.inFile, data); } catch {}
     } else if (session.type === 'tmux') {
       tmuxSendLiteral(session.pane, data);
+      scheduleTmuxInputRefresh(session);
     } else {
       session.pty.write(data);
     }
   }
 
+  function scheduleTmuxInputRefresh(session) {
+    if (session.type !== 'tmux' || !session.pane) return;
+    if (session.inputRefreshTimer) return;
+    session.inputRefreshTimer = setTimeout(() => {
+      session.inputRefreshTimer = null;
+      if (session.status === 'running') broadcast(session, { type: 'replace', data: refreshTmuxSnapshot(session) });
+    }, 80);
+  }
+
   function resizeSession(session, cols, rows) {
     if (session.type === 'external') {
       try { fs.appendFileSync(session.resizeFile, JSON.stringify({ cols, rows }) + '\n'); } catch {}
@@ -4959,6 +7077,7 @@ async function cmdWeb(ctx, args, startMeta = {}) {
     });
     const session = {
       id,
+      peerId: id,
       root: pctx.root,
       ctx: pctx,
       kind,
@@ -4986,7 +7105,7 @@ async function cmdWeb(ctx, args, startMeta = {}) {
         status: 'running',
         capabilities: 'web-pty'
       });
-      upsertCanonicalPeerBinding(db, {
+      const canonical = upsertCanonicalPeerBinding(db, {
         peer: id,
         provider: input.binding?.provider || kind,
         provider_session_id: input.binding?.provider_session_id || null,
@@ -4997,6 +7116,7 @@ async function cmdWeb(ctx, args, startMeta = {}) {
         transport: 'web-pty',
         runtime_session_id: id
       }, Boolean(input.force));
+      session.peerId = canonical.peer;
       addEvent(db, 'web.session.started', id, null, { command, cwd, pid: child.pid });
     } finally {
       db.close();
@@ -5021,9 +7141,60 @@ async function cmdWeb(ctx, args, startMeta = {}) {
     return session;
   }
 
+  function webSessionBuildOptions(input) {
+    const mode = input.mode || 'new';
+    if (mode === 'new') return {};
+    if (mode === 'resume') {
+      const resume = String(input.resume || '').trim();
+      if (!resume) throw new CliError('BAD_REQUEST', 'resume session required');
+      return { resume };
+    }
+    if (mode === 'last') return { last: true };
+    if (mode === 'continue') return { continue: true };
+    throw new CliError('BAD_REQUEST', `Unsupported session mode: ${mode}`);
+  }
+
+  function webSessionPeerId(projectCtx, kind, opts, input) {
+    if (input.id) return input.id;
+    if (opts.resume) return providerSessionPeerId(kind, opts.resume);
+    return nextProjectSessionId(projectCtx, kind);
+  }
+
+  function normalizeWebSessionInput(input) {
+    const pctx = input.projectCtx || ctx;
+    const kind = input.kind || 'shell';
+    if (!['claude', 'codex', 'shell'].includes(kind)) {
+      throw new CliError('BAD_REQUEST', `Unsupported session kind: ${kind}`);
+    }
+    if (input.command || input.binding) return { ...input, kind, projectCtx: pctx };
+
+    const opts = webSessionBuildOptions(input);
+    if (kind === 'shell' && hasResumeOpts(opts)) {
+      throw new CliError('BAD_REQUEST', 'Resume modes are only supported for codex and claude sessions');
+    }
+    if (kind !== 'claude' && opts.continue) {
+      throw new CliError('BAD_REQUEST', 'continue is only supported for claude sessions');
+    }
+    if (kind !== 'codex' && opts.last) {
+      throw new CliError('BAD_REQUEST', 'last is only supported for codex sessions');
+    }
+
+    const id = webSessionPeerId(pctx, kind, opts, input);
+    const built = buildPeerCommand(id, kind, opts, []);
+    return {
+      ...input,
+      id,
+      kind,
+      command: built.command,
+      binding: built.binding,
+      projectCtx: pctx
+    };
+  }
+
   function startSession(input) {
-    if (input.backend === 'pty') return startPtySession(input);
-    return startTmuxManagedSession(input);
+    const normalized = normalizeWebSessionInput(input);
+    if (normalized.backend === 'pty') return startPtySession(normalized);
+    return startTmuxManagedSession(normalized);
   }
 
   for (const projectCtx of projectContexts.values()) {
@@ -5076,13 +7247,43 @@ async function cmdWeb(ctx, args, startMeta = {}) {
         return;
       }
       if (req.method === 'GET' && url.pathname === '/api/state') {
-        sendJson(res, 200, statusSnapshot(reqCtx, url.searchParams.get('peer')));
+        const resources = normalizeStateResources([
+          ...url.searchParams.getAll('resource'),
+          url.searchParams.get('resources') || ''
+        ]);
+        sendJson(res, 200, statusSnapshot(reqCtx, url.searchParams.get('peer'), {
+          resources,
+          intent: url.searchParams.get('intent') || null
+        }));
+        return;
+      }
+      const peerActionMatch = url.pathname.match(/^\/api\/peers\/([^/]+)\/actions\/([^/]+)$/);
+      if (peerActionMatch) {
+        const peer = decodeURIComponent(peerActionMatch[1]);
+        const action = decodeURIComponent(peerActionMatch[2]);
+        const readOnly = ['status', 'state', 'inbox'].includes(action);
+        if (readOnly && req.method !== 'GET') {
+          sendJson(res, 405, { ok: false, error: { code: 'METHOD_NOT_ALLOWED', message: 'Use GET for read-only peer actions' } });
+          return;
+        }
+        if (!readOnly && req.method !== 'POST') {
+          sendJson(res, 405, { ok: false, error: { code: 'METHOD_NOT_ALLOWED', message: 'Use POST for mutating peer actions' } });
+          return;
+        }
+        const input = readOnly
+          ? {
+              ...Object.fromEntries(url.searchParams.entries()),
+              resource: url.searchParams.getAll('resource')
+            }
+          : await readJsonRequest(req);
+        sendJson(res, 200, webPeerAction(reqCtx, peer, action, input));
         return;
       }
       // Detected sessions: peers registered via hooks/watcher but without PTY
       if (req.method === 'GET' && url.pathname === '/api/detected') {
         const db = connect(reqCtx);
         let detected = [];
+        const managedIds = new Set();
         const t = now();
         try {
           detected = db.prepare(`
@@ -5092,11 +7293,15 @@ async function cmdWeb(ctx, args, startMeta = {}) {
             ORDER BY last_seen_at DESC, id ASC
             LIMIT 100
           `).all(t);
+          for (const session of sessionsForProject(reqCtx)) {
+            managedIds.add(session.id);
+            const peerId = resolveSessionPeerId(db, session);
+            if (peerId) managedIds.add(peerId);
+          }
         } finally {
           db.close();
         }
         // Exclude peers that are already in the managed sessions Map
-        const managedIds = new Set(sessionsForProject(reqCtx).map((s) => s.id));
         sendJson(res, 200, {
           now: t,
           active_peer_ttl: ACTIVE_PEER_TTL,
@@ -5104,6 +7309,44 @@ async function cmdWeb(ctx, args, startMeta = {}) {
         });
         return;
       }
+      if (req.method === 'GET' && url.pathname === '/api/resumable') {
+        // Provider sessions hcc has seen (via hooks/detection) that carry a real
+        // provider session id or resumable provider session name.
+        const db = connect(reqCtx);
+        let rows = [];
+        try {
+          rows = db.prepare(`
+            SELECT b.provider, b.provider_session_id, b.provider_session_name, b.peer,
+                   p.last_seen_at
+            FROM peer_bindings b
+            LEFT JOIN peers p ON p.id = b.peer
+            WHERE (b.provider_session_id IS NOT NULL AND b.provider_session_id != '')
+               OR (b.provider_session_name IS NOT NULL AND b.provider_session_name != '')
+            ORDER BY p.last_seen_at DESC, b.updated_at DESC
+          `).all();
+        } finally {
+          db.close();
+        }
+        const seen = new Set();
+        const resumable = [];
+        for (const r of rows) {
+          const resumeValue = r.provider_session_id || r.provider_session_name || '';
+          if (!resumeValue) continue;
+          const key = `${r.provider}:${resumeValue}`;
+          if (seen.has(key)) continue;
+          seen.add(key);
+          resumable.push({
+            provider: r.provider,
+            session_id: r.provider_session_id,
+            session_name: r.provider_session_name || null,
+            resume: resumeValue,
+            name: r.provider_session_name || null,
+            peer: r.peer
+          });
+        }
+        sendJson(res, 200, { resumable });
+        return;
+      }
       if (req.method === 'GET' && url.pathname === '/api/runtime') {
         sendJson(res, 200, {
           product: PRODUCT_NAME,
@@ -5122,7 +7365,14 @@ async function cmdWeb(ctx, args, startMeta = {}) {
         return;
       }
       if (req.method === 'GET' && url.pathname === '/api/sessions') {
-        sendJson(res, 200, { sessions: sessionsForProject(reqCtx).map(serializeSession) });
+        const db = connect(reqCtx);
+        try {
+          sendJson(res, 200, {
+            sessions: sessionsForProject(reqCtx).map((session) => serializeSession(session, db))
+          });
+        } finally {
+          db.close();
+        }
         return;
       }
       if (req.method === 'POST' && url.pathname === '/api/sessions') {
@@ -5140,7 +7390,13 @@ async function cmdWeb(ctx, args, startMeta = {}) {
       const inputMatch = url.pathname.match(/^\/api\/sessions\/([^/]+)\/input$/);
       if (req.method === 'POST' && inputMatch) {
         const id = decodeURIComponent(inputMatch[1]);
-        const session = getSession(reqCtx, id);
+        const lookupDb = connect(reqCtx);
+        let session;
+        try {
+          session = getSession(reqCtx, id, lookupDb);
+        } finally {
+          lookupDb.close();
+        }
         if (!session) {
           sendJson(res, 404, { ok: false, error: { code: 'NOT_FOUND', message: 'Session not found' } });
           return;
@@ -5165,7 +7421,13 @@ async function cmdWeb(ctx, args, startMeta = {}) {
       const stopMatch = url.pathname.match(/^\/api\/sessions\/([^/]+)\/stop$/);
       if (req.method === 'POST' && stopMatch) {
         const id = decodeURIComponent(stopMatch[1]);
-        const session = getSession(reqCtx, id);
+        const lookupDb = connect(reqCtx);
+        let session;
+        try {
+          session = getSession(reqCtx, id, lookupDb);
+        } finally {
+          lookupDb.close();
+        }
         if (!session) {
           sendJson(res, 404, { ok: false, error: { code: 'NOT_FOUND', message: 'Session not found' } });
           return;
@@ -5227,7 +7489,13 @@ async function cmdWeb(ctx, args, startMeta = {}) {
     }
     const reqCtx = projectFromRequest(req, url);
     const id = decodeURIComponent(match[1]);
-    const session = getSession(reqCtx, id);
+    const lookupDb = connect(reqCtx);
+    let session;
+    try {
+      session = getSession(reqCtx, id, lookupDb);
+    } finally {
+      lookupDb.close();
+    }
     if (!session) {
       socket.write('HTTP/1.1 404 Not Found\r\n\r\n');
       socket.destroy();
@@ -5557,6 +7825,7 @@ Commands:
   heartbeat [--peer ID]        Mark the current peer alive, optionally renew locks
   peers                        List known peers
   status [--peer ID]           Show project coordination state
+  state [--peer ID]            Show timeline and next coordination action
   scan [--register]            Detect existing Claude/Codex sessions
   prompt --peer ID             Print copy/paste session instructions
   run --peer ID -- COMMAND     Register a peer and run a command in this terminal
@@ -5565,6 +7834,7 @@ Commands:
   ask PEER MESSAGE             Send a direct work request to one peer
   broadcast MESSAGE            Send a work request to all peers
   task <subcommand>            Create, list, claim, update, finish tasks
+  team <subcommand>            Plan, start, and inspect explicit task teams
   msg <subcommand>             Send, read, and ack messages
   lock <subcommand>            Acquire, renew, release, and list advisory locks
   handoff <subcommand>         Create and list handoffs
@@ -5579,7 +7849,7 @@ Environment:
   HCC_ROOT               Override project root
   HCC_DB                 Override database path
   HCC_PEER               Default peer id; inferred automatically when absent
-  HCC_WEB_TOKEN          Optional web access token
+  HCC_WEB_TOKEN          Replace and save the stable web access token
 `);
 }
 
@@ -5588,21 +7858,60 @@ function helpTask() {
 
 Usage:
   ${CLI_NAME} task create --title TEXT [--body TEXT] [--from ID] [--to ID] [--priority N]
+  ${CLI_NAME} task create --title TEXT --parent N [--team-role ROLE]
   ${CLI_NAME} task list [--status pending|claimed|running|review|blocked|done|abandoned] [--peer ID] [--all]
   ${CLI_NAME} task claim [--peer ID] --id N
-  ${CLI_NAME} task next [--peer ID]
+  ${CLI_NAME} task next [--peer ID] [--force]
   ${CLI_NAME} task update [--peer ID] --id N --status STATUS [--summary TEXT] [--body TEXT] [--to ID]
   ${CLI_NAME} task done [--peer ID] --id N --summary TEXT
 
 Default task list shows all project tasks that are not done or abandoned.
 --peer is an explicit filter; HCC_PEER does not hide other open tasks.
 Messages use per-peer unread ack state; tasks do not.
+task next returns your existing claimed/running/review/blocked task before
+claiming another pending task. Use --force only when intentionally taking
+another pending task.
 
 If --peer/--from and HCC_PEER are absent, hcc auto-joins the current terminal
 as a stable project-local peer.
 `);
 }
 
+function helpTeam() {
+  console.log(`${CLI_NAME} team
+
+Usage:
+  ${CLI_NAME} team plan --from-task N [--item ROLE:TITLE] [--item PEER:ROLE:TITLE] [--workers A,B|codex:2,claude:1]
+  ${CLI_NAME} team start --from-task N [--item ROLE:TITLE] [--item PEER:ROLE:TITLE] [--workers A,B|codex:2,claude:1] [--force]
+  ${CLI_NAME} team status --task N
+
+team plan is read-only. team start creates explicit child tasks under the parent
+task and optionally assigns them to workers. It does not silently spawn model
+processes or override the current-task rule.
+workers may be explicit peer ids or kind counts such as codex:2,claude:1.
+`);
+}
+
+function helpState() {
+  console.log(`${CLI_NAME} state
+
+Usage:
+  ${CLI_NAME} state [--peer ID] [--resource PATH] [--intent work|stop|finish]
+
+Shows the current collaboration timeline plus a machine-readable coordination
+state machine. With --json, the response includes automation.next_action.argv so
+agents can execute the suggested hcc command explicitly and leave an audit trail.
+automation.current_task shows the peer's active claimed/running/review/blocked
+task when one exists.
+If a current task looks splittable, automation may suggest hcc team plan; this
+is read-only until hcc team start is run explicitly.
+
+State does not execute coordination actions: it does not ack messages, claim
+tasks, acquire locks, send messages, create handoffs, or mark tasks done. Opening
+state may still perform normal SQLite schema maintenance for known project DBs.
+`);
+}
+
 function helpJoin() {
   console.log(`${CLI_NAME} join
 
@@ -5640,8 +7949,11 @@ Usage:
   ${CLI_NAME} msg send [--from ID] [--to ID|all] --body TEXT [--task N] [--kind note|task|handoff]
   ${CLI_NAME} msg inbox [--peer ID] [--wait SEC] [--all] [--limit N]
   ${CLI_NAME} msg ack [--peer ID] --id N
+  ${CLI_NAME} msg reply [--from ID] --id N --body TEXT [--to ID] [--kind reply]
+  ${CLI_NAME} msg thread --id N [--limit N]
 
 If --peer/--from and HCC_PEER are absent, hcc auto-joins the current terminal.
+Use msg reply when answering a message so the response stays in the same thread.
 `);
 }
 
@@ -5813,19 +8125,22 @@ function helpWeb() {
   console.log(`${CLI_NAME} web
 
 Usage:
-  ${CLI_NAME} web [--host HOST] [--port N] [--token TEXT] [--local] [--no-discover] [--no-guidance]
+  ${CLI_NAME} web [--host HOST] [--port N] [--token TEXT] [--local] [--no-token] [--no-discover] [--no-guidance]
 
 Examples:
   ${CLI_NAME} web
-  HCC_WEB_TOKEN='long-token' ${CLI_NAME} web --host 0.0.0.0 --port 8787
+  HCC_WEB_TOKEN='long-token' ${CLI_NAME} web --port 8787
+  ${CLI_NAME} web --local
 
 This is the default one-command entrypoint. It prepares local coordination,
 installs Claude/Codex hooks and shims, ensures tmux is available, starts the
 browser terminal console as a background runtime, prints the URL, PID, runtime
 file, and log file, then returns the terminal to you.
 
-Web token auth is disabled by default. Pass --token or set HCC_WEB_TOKEN to
-require a token.
+By default, the web runtime listens on 0.0.0.0 and uses a saved token,
+generating one on first use. Use HCC_WEB_TOKEN or --token to replace the saved
+token, --local to bind only to 127.0.0.1, or --no-token only for a trusted
+local/test environment.
 
 After hcc web, plain claude/codex commands started from a new shell are wrapped
 as local tmux-backed terminals. Existing ordinary terminals can communicate
@@ -5905,7 +8220,7 @@ async function cmdHook(ctx, args) {
   if (!peerId) {
     resumeId = providerSession.resumeId || readParentResumeId(kind);
     if (resumeId) {
-      peerId = `${kind}-${sanitizePeerPart(resumeId.slice(0, 8), shortHash(resumeId))}`;
+      peerId = providerSessionPeerId(kind, resumeId);
     }
   }
   if (!peerId) {
@@ -5962,7 +8277,7 @@ async function cmdHook(ctx, args) {
     addEvent(db, `hook.${hookKey}`, peerId, null, { session_id: sessionId, cwd: hookCwd });
 
     if (['sessionstart', 'userpromptsubmit'].includes(hookKey)) {
-      const snapshot = buildHookCoordinationContext(db, peerId);
+      const snapshot = buildHookCoordinationContext(db, hookCtx, peerId);
       ackMessages(db, peerId, snapshot.messages);
       process.stdout.write(JSON.stringify({
         hookSpecificOutput: {
@@ -5971,7 +8286,7 @@ async function cmdHook(ctx, args) {
         }
       }) + '\n');
     } else if (['posttooluse', 'stop'].includes(hookKey)) {
-      const snapshot = buildHookCoordinationContext(db, peerId);
+      const snapshot = buildHookCoordinationContext(db, hookCtx, peerId);
       if (snapshot.messages.length > 0) {
         ackMessages(db, peerId, snapshot.messages);
         process.stdout.write(JSON.stringify({
@@ -6404,6 +8719,7 @@ async function dispatch(ctx, rest) {
   if (command === 'heartbeat') return cmdHeartbeat(ctx, args);
   if (command === 'peers') return cmdPeers(ctx, args);
   if (command === 'status') return cmdStatus(ctx, args);
+  if (command === 'state') return cmdState(ctx, args);
   if (command === 'prompt') return cmdPrompt(ctx, args);
   if (command === 'run') return cmdRun(ctx, args);
   if (command === 'peer') return cmdPeer(ctx, args);
@@ -6411,6 +8727,7 @@ async function dispatch(ctx, rest) {
   if (command === 'ask') return cmdAsk(ctx, args);
   if (command === 'broadcast') return cmdBroadcast(ctx, args);
   if (command === 'task') return cmdTask(ctx, args);
+  if (command === 'team') return cmdTeam(ctx, args);
   if (command === 'msg') return cmdMsg(ctx, args);
   if (command === 'lock') return cmdLock(ctx, args);
   if (command === 'handoff') return cmdHandoff(ctx, args);