harnery 0.32.0 → 0.33.0

package/dist/lib/instructions/bundle.d.ts

@@ -0,0 +1,33 @@
+import type { Adapter } from "../../core/hooks/events/schema.js";
+export type InstructionComponentRole = "always_loaded" | "just_in_time" | "runtime_config";
+export interface InstructionBundleComponent {
+    path: string;
+    role: InstructionComponentRole;
+    bytes: number;
+    sha256: string;
+}
+export interface InstructionBundle {
+    schema_version: 1;
+    adapter: Adapter;
+    coord_root: string;
+    profile_root: string;
+    instruction_roots: string[];
+    instruction_bundle_id: string;
+    canonical_source_id: string;
+    components: InstructionBundleComponent[];
+    canonical_sources: InstructionBundleComponent[];
+}
+interface BuildBundleOptions {
+    coordRoot: string;
+    cwd: string;
+    adapter: Adapter;
+}
+/**
+ * Build the content identity for the repo-authored instruction surface an
+ * adapter can load at one working path. The identity intentionally excludes
+ * timestamps and git revisions: two checkouts with byte-identical effective
+ * instructions belong to the same cohort.
+ */
+export declare function buildInstructionBundle(options: BuildBundleOptions): InstructionBundle;
+export {};
+//# sourceMappingURL=bundle.d.ts.map

package/dist/lib/instructions/bundle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle.d.ts","sourceRoot":"","sources":["../../../src/lib/instructions/bundle.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mCAAmC,CAAC;AAEjE,MAAM,MAAM,wBAAwB,GAAG,eAAe,GAAG,cAAc,GAAG,gBAAgB,CAAC;AAE3F,MAAM,WAAW,0BAA0B;IACzC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,wBAAwB,CAAC;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,iBAAiB;IAChC,cAAc,EAAE,CAAC,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,qBAAqB,EAAE,MAAM,CAAC;IAC9B,mBAAmB,EAAE,MAAM,CAAC;IAC5B,UAAU,EAAE,0BAA0B,EAAE,CAAC;IACzC,iBAAiB,EAAE,0BAA0B,EAAE,CAAC;CACjD;AAED,UAAU,kBAAkB;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,OAAO,CAAC;CAClB;AAOD;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,kBAAkB,GAAG,iBAAiB,CAyBrF"}

package/dist/lib/instructions/bundle.js

@@ -0,0 +1,149 @@
+import { createHash } from "node:crypto";
+import { existsSync, lstatSync, readdirSync, readFileSync } from "node:fs";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+/**
+ * Build the content identity for the repo-authored instruction surface an
+ * adapter can load at one working path. The identity intentionally excludes
+ * timestamps and git revisions: two checkouts with byte-identical effective
+ * instructions belong to the same cohort.
+ */
+export function buildInstructionBundle(options) {
+    const coordRoot = resolve(options.coordRoot);
+    const cwd = resolve(options.cwd);
+    const roots = resolveInstructionRoots(coordRoot, cwd);
+    const profileRoot = roots.at(-1) ?? coordRoot;
+    const components = dedupeCandidates(roots.flatMap((root) => adapterCandidates(root, options.adapter)), coordRoot);
+    const canonicalSources = dedupeCandidates(roots.flatMap((root) => canonicalCandidates(root)), coordRoot);
+    return {
+        schema_version: 1,
+        adapter: options.adapter,
+        coord_root: coordRoot,
+        profile_root: relativePath(coordRoot, profileRoot),
+        instruction_roots: roots.map((root) => relativePath(coordRoot, root)),
+        instruction_bundle_id: identity("instruction-bundle-v1", options.adapter, components),
+        canonical_source_id: identity("instruction-source-v1", null, canonicalSources),
+        components,
+        canonical_sources: canonicalSources,
+    };
+}
+function resolveInstructionRoots(coordRoot, cwd) {
+    const roots = [coordRoot];
+    if (!isWithin(coordRoot, cwd))
+        return roots;
+    const ancestors = [];
+    let cursor = cwd;
+    while (cursor !== coordRoot) {
+        if (existsSync(join(cursor, "AGENTS.md")) || existsSync(join(cursor, "CLAUDE.md"))) {
+            ancestors.push(cursor);
+        }
+        const parent = dirname(cursor);
+        if (parent === cursor)
+            break;
+        cursor = parent;
+    }
+    roots.push(...ancestors.reverse().filter((root) => root !== coordRoot));
+    return roots;
+}
+function adapterCandidates(root, adapter) {
+    const candidates = [];
+    const addFile = (path, role) => {
+        if (existsSync(path) && lstatSync(path).isFile())
+            candidates.push({ absolutePath: path, role });
+    };
+    const addTree = (path, role) => {
+        for (const file of walkFiles(path))
+            candidates.push({ absolutePath: file, role });
+    };
+    if (adapter === "claude-code") {
+        addFile(join(root, "CLAUDE.md"), "always_loaded");
+        addTree(join(root, ".claude", "rules"), "always_loaded");
+        addTree(join(root, ".claude", "skills"), "just_in_time");
+        addFile(join(root, ".claude", "settings.json"), "runtime_config");
+        addFile(join(root, ".claude", "settings.local.json"), "runtime_config");
+    }
+    else if (adapter === "cursor") {
+        addFile(join(root, "AGENTS.md"), "always_loaded");
+        addTree(join(root, ".cursor", "rules"), "always_loaded");
+        addTree(join(root, ".agents", "skills"), "just_in_time");
+        addTree(join(root, ".cursor", "skills"), "just_in_time");
+        addFile(join(root, ".cursor", "hooks.json"), "runtime_config");
+    }
+    else {
+        addFile(join(root, "AGENTS.md"), "always_loaded");
+        addTree(join(root, ".harnery", "skills"), "just_in_time");
+        addFile(join(root, ".codex", "hooks.json"), "runtime_config");
+    }
+    // Harnery's host configuration governs hook enforcement for all adapters.
+    addFile(join(root, ".harnery", "config.jsonc"), "runtime_config");
+    return candidates;
+}
+function canonicalCandidates(root) {
+    const candidates = [];
+    const agents = join(root, "AGENTS.md");
+    if (existsSync(agents) && lstatSync(agents).isFile()) {
+        candidates.push({ absolutePath: agents, role: "always_loaded" });
+    }
+    for (const file of walkFiles(join(root, ".agents"))) {
+        candidates.push({ absolutePath: file, role: "just_in_time" });
+    }
+    return candidates;
+}
+function walkFiles(root) {
+    if (!existsSync(root) || !lstatSync(root).isDirectory())
+        return [];
+    const files = [];
+    const visit = (dir) => {
+        for (const entry of readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+            const path = join(dir, entry.name);
+            if (entry.isDirectory())
+                visit(path);
+            else if (entry.isFile())
+                files.push(path);
+        }
+    };
+    visit(root);
+    return files;
+}
+function dedupeCandidates(candidates, coordRoot) {
+    const byPath = new Map();
+    for (const candidate of candidates) {
+        const key = resolve(candidate.absolutePath);
+        const prior = byPath.get(key);
+        if (!prior || roleRank(candidate.role) < roleRank(prior.role))
+            byPath.set(key, candidate);
+    }
+    return [...byPath.values()]
+        .map(({ absolutePath, role }) => {
+        const bytes = readFileSync(absolutePath);
+        return {
+            path: relativePath(coordRoot, absolutePath),
+            role,
+            bytes: bytes.byteLength,
+            sha256: createHash("sha256").update(bytes).digest("hex"),
+        };
+    })
+        .sort((a, b) => a.path.localeCompare(b.path) || a.role.localeCompare(b.role));
+}
+function identity(prefix, adapter, components) {
+    const body = components.map(({ path, role, sha256 }) => ({ path, role, sha256 }));
+    return `sha256:${createHash("sha256")
+        .update(JSON.stringify({ prefix, ...(adapter ? { adapter } : {}), components: body }))
+        .digest("hex")}`;
+}
+function relativePath(root, path) {
+    const rel = relative(root, path);
+    return rel === "" ? "." : rel.split(sep).join("/");
+}
+function isWithin(root, path) {
+    if (!isAbsolute(root) || !isAbsolute(path))
+        return false;
+    const rel = relative(root, path);
+    return rel === "" || (!rel.startsWith(`..${sep}`) && rel !== "..");
+}
+function roleRank(role) {
+    if (role === "always_loaded")
+        return 0;
+    if (role === "runtime_config")
+        return 1;
+    return 2;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "harnery",
-  "version": "0.32.0",
+  "version": "0.33.0",
   "description": "Multi-agent coordination for AI coding agents - Claude Code, Cursor, and Codex.",
   "license": "MIT",
   "author": "Ryan Kelly",
@@ -185,7 +185,7 @@
     "check:layering": "bun run scripts/check-layering.ts",
     "lint:fix": "bun x @biomejs/biome check --write src",
     "format": "bun x @biomejs/biome format --write src",
-    "test": "bun test src tests",
+    "test": "bun run scripts/test.mjs",
     "test:web": "cd web && bun install && bun test",
     "test:integration": "bash tests/integration/run.sh",
     "smoke": "node scripts/smoke-test.mjs",

package/src/commander.ts

@@ -44,6 +44,7 @@ import { registerFileHistoryCommand } from "./commands/file-history.ts";
 import { registerGovernorCommand } from "./commands/governor.ts";
 import { registerGrepCommand } from "./commands/grep.ts";
 import { registerInitCommand } from "./commands/init.ts";
+import { registerInstructionsCommand } from "./commands/instructions.ts";
 import { registerJournalCommand } from "./commands/journal.ts";
 import { registerOutlineCommand } from "./commands/outline.ts";
 import { registerPolicyCommand } from "./commands/policy.ts";
@@ -294,10 +295,11 @@ export function createHarneryProgram(opts: HarneryContextOpts = {}): Command {
   registerAgentsCommand(program, emit, opts.context);
   registerCouncilCommands(program);
   registerDoctorCommand(program, emit);
+  registerInstructionsCommand(program, emit);
   registerInitCommand(program, emit, opts.binName);
   registerDeinitCommand(program, emit, opts.binName);
   registerBackupCommand(program, emit);
-  registerClaudeDesktopCommand(program, emit);
+  registerClaudeDesktopCommand(program, emit, opts.context);
   registerSyncCommand(program, emit);
   registerWorkflowCommand(program, emit);
   registerWorkCommand(program, emit);

package/src/commands/agents.ts

@@ -46,7 +46,15 @@ import {
   resolveOwnerBySessionEnv,
   resolveOwnerWithSource,
 } from "../core/agents/index.ts";
-import { buildSuggestedName } from "../core/agents/state/heartbeat-writer.ts";
+import {
+  buildLifecycleSuggestedName,
+  buildSuggestedName,
+} from "../core/agents/state/heartbeat-writer.ts";
+import {
+  type AgentActivity,
+  foldSessionState,
+  type TaskState,
+} from "../core/agents/state/session-state.ts";
 import { coordFreshnessSeconds, resolveBinName } from "../core/config.ts";
 import { type RemoteMachine, readRemoteMachines } from "../core/presence/index.ts";
 import { registerContextCommand } from "./context.ts";
@@ -182,6 +190,12 @@ interface Row {
   last_tool?: string | null;
   last_tool_target?: string | null;
   task?: string | null;
+  activity: AgentActivity;
+  activity_updated_at?: string | null;
+  activity_source?: string | null;
+  task_state: TaskState;
+  task_state_updated_at?: string | null;
+  task_state_reason?: string | null;
   turn_summary?: string | null;
   turn_summary_updated_at?: string | null;
   platform?: string | null;
@@ -190,6 +204,19 @@ interface Row {
   machine?: string | null;
 }
 
+function activityOf(hb: Pick<Heartbeat, "activity">): AgentActivity {
+  return hb.activity ?? "unknown";
+}
+
+function taskStateOf(hb: Pick<Heartbeat, "task_state">): TaskState {
+  return hb.task_state ?? "active";
+}
+
+function lifecycleLabel(hb: Pick<Heartbeat, "task_state" | "task_state_reason">): string {
+  const state = taskStateOf(hb);
+  return state === "blocked" && hb.task_state_reason ? `${state}: ${hb.task_state_reason}` : state;
+}
+
 let emit: EmitContext;
 
 export function registerAgentsCommand(
@@ -317,6 +344,18 @@ export function registerAgentsCommand(
       runSetTask(text.join(" "), opts);
     });
 
+  cmd
+    .command("lifecycle <state>")
+    .description("Declare this session's task lifecycle: active, blocked, or done")
+    .option("--reason <text>", "Explain the lifecycle declaration")
+    .option(
+      "--session-id <id>",
+      "Target the heartbeat with this session_id directly, bypassing the ppid walk.",
+    )
+    .action((state: string, opts: { reason?: string; sessionId?: string }) => {
+      runLifecycle(state, opts);
+    });
+
   cmd
     .command("release-claim <path>")
     .description(
@@ -901,6 +940,12 @@ function runWhoami(opts: { json?: boolean }): void {
     last_tool: hb.last_tool ?? null,
     last_tool_target: hb.last_tool_target ?? null,
     task: hb.task ?? null,
+    activity: activityOf(hb),
+    activity_updated_at: hb.activity_updated_at ?? null,
+    activity_source: hb.activity_source ?? null,
+    task_state: taskStateOf(hb),
+    task_state_updated_at: hb.task_state_updated_at ?? null,
+    task_state_reason: hb.task_state_reason ?? null,
     turn_summary: hb.turn_summary ?? null,
     turn_summary_updated_at: hb.turn_summary_updated_at ?? null,
     platform: hb.platform ?? "claude-code",
@@ -999,6 +1044,12 @@ function runList(opts: { all?: boolean; stale?: boolean; json?: boolean }): void
         last_tool: h.last_tool ?? null,
         last_tool_target: h.last_tool_target ?? null,
         task: h.task ?? null,
+        activity: activityOf(h),
+        activity_updated_at: h.activity_updated_at ?? null,
+        activity_source: h.activity_source ?? null,
+        task_state: taskStateOf(h),
+        task_state_updated_at: h.task_state_updated_at ?? null,
+        task_state_reason: h.task_state_reason ?? null,
         turn_summary: h.turn_summary ?? null,
         turn_summary_updated_at: h.turn_summary_updated_at ?? null,
         platform: h.platform ?? "claude-code",
@@ -1024,6 +1075,12 @@ function runList(opts: { all?: boolean; stale?: boolean; json?: boolean }): void
       last_tool: h.last_tool ?? null,
       last_tool_target: h.last_tool_target ?? null,
       task: h.task ?? null,
+      activity: activityOf(h),
+      activity_updated_at: h.activity_updated_at ?? null,
+      activity_source: h.activity_source ?? null,
+      task_state: taskStateOf(h),
+      task_state_updated_at: h.task_state_updated_at ?? null,
+      task_state_reason: h.task_state_reason ?? null,
       turn_summary: h.turn_summary ?? null,
       turn_summary_updated_at: h.turn_summary_updated_at ?? null,
       platform: h.platform ?? "claude-code",
@@ -1052,6 +1109,12 @@ function runList(opts: { all?: boolean; stale?: boolean; json?: boolean }): void
         last_tool: a.last_tool ?? null,
         last_tool_target: null,
         task: a.task ?? null,
+        activity: a.activity ?? "unknown",
+        activity_updated_at: null,
+        activity_source: null,
+        task_state: a.task_state ?? "active",
+        task_state_updated_at: null,
+        task_state_reason: a.task_state_reason ?? null,
         turn_summary: a.turn_summary ?? null,
         turn_summary_updated_at: null,
         platform: a.platform ?? "claude-code",
@@ -1319,6 +1382,12 @@ async function runShow(name: string, opts: { json?: boolean }): Promise<void> {
     age_secs: ageSecs,
     last_heartbeat_secs_ago: heartbeatAgeSecs,
     task: hb.task ?? null,
+    activity: activityOf(hb),
+    activity_updated_at: hb.activity_updated_at ?? null,
+    activity_source: hb.activity_source ?? null,
+    task_state: taskStateOf(hb),
+    task_state_updated_at: hb.task_state_updated_at ?? null,
+    task_state_reason: hb.task_state_reason ?? null,
     turn_summary: hb.turn_summary ?? null,
     turn_summary_updated_at: hb.turn_summary_updated_at ?? null,
     title: report?.title ?? null,
@@ -1350,6 +1419,10 @@ async function runShow(name: string, opts: { json?: boolean }): Promise<void> {
     `  session  ${formatAge(ageSecs)} old · kind=${data.kind} · session_id=${data.session_id.slice(0, 8)}…`,
   );
   lines.push(`  last heartbeat: ${formatAge(heartbeatAgeSecs)} ago`);
+  lines.push(`  activity:       ${data.activity}`);
+  lines.push(
+    `  lifecycle:      ${data.task_state}${data.task_state === "blocked" && data.task_state_reason ? `: ${data.task_state_reason}` : ""}`,
+  );
   if (data.last_tool) {
     const target = data.last_tool_target ? ` ${truncate(data.last_tool_target, 80)}` : "";
     lines.push(`  last activity:  ${data.last_tool}${target}`);
@@ -1526,6 +1599,11 @@ function runSetTask(task: string, opts?: { sessionId?: string }): void {
   // heartbeat-writer.setTask. This call is the naming call exactly when the
   // stamp appears across the mutation.
   const priorHb = readHeartbeat(myOwner);
+  const normalizedTask = task.length > 0 ? task : undefined;
+  const lifecycleWarning =
+    priorHb && (priorHb.task_state ?? "active") !== "active" && priorHb.task !== normalizedTask
+      ? `Task text changed while lifecycle is ${priorHb.task_state}; run \`${resolveBinName(root)} agents lifecycle active\` to reopen it explicitly.`
+      : null;
 
   // Heartbeat mutation goes through agent-coord (atomic temp+rename).
   const helper = agentCoordOrExit(root);
@@ -1573,6 +1651,7 @@ function runSetTask(task: string, opts?: { sessionId?: string }): void {
     cleared: !task || task.length === 0,
     first_of_session: firstOfSession,
     suggested_session_name: suggestedName,
+    ...(lifecycleWarning ? { warning: lifecycleWarning } : {}),
     // Right-time instruction: the UserPromptSubmit nudge fires before the name
     // exists; this result is the moment the model holds the string.
     ...(suggestedName
@@ -1583,6 +1662,147 @@ function runSetTask(task: string, opts?: { sessionId?: string }): void {
   });
 }
 
+function runLifecycle(rawState: string, opts: { reason?: string; sessionId?: string }): void {
+  const state = rawState.trim().toLowerCase();
+  if (state !== "active" && state !== "blocked" && state !== "done") {
+    emit.error({
+      code: "invalid_lifecycle_state",
+      message: "lifecycle state must be one of: active, blocked, done",
+    });
+    process.exitCode = 1;
+    return;
+  }
+
+  const root = monorepoRoot();
+  if (!root) {
+    emit.error({
+      code: "not_in_repo",
+      message: "not in an agent session; coord_root() returned null",
+    });
+    process.exitCode = 1;
+    return;
+  }
+  if (!opts.sessionId) ensureCursorSession(root);
+  const myOwner = opts.sessionId ?? resolveOwner();
+  if (!myOwner) {
+    emit.error({
+      code: "no_pidmap_entry",
+      message:
+        "not in an agent session; ppid walk found no pid-map entry (pass --session-id to bypass)",
+    });
+    process.exitCode = 1;
+    return;
+  }
+
+  const hb = readHeartbeat(myOwner);
+  if (!hb) {
+    emit.error({ code: "no_heartbeat", message: noHeartbeatMessage(myOwner) });
+    process.exitCode = 1;
+    return;
+  }
+  if (hb.kind === "subagent" || hb.kind === "transient" || hb.workflow_run_id) {
+    emit.error({
+      code: "lifecycle_not_human_facing",
+      message: "task lifecycle declarations are limited to human-facing sessions",
+    });
+    process.exitCode = 1;
+    return;
+  }
+
+  const reason = opts.reason?.trim() || undefined;
+  if (state === "blocked" && !reason) {
+    emit.error({
+      code: "blocked_reason_required",
+      message: "lifecycle blocked requires --reason <text>",
+    });
+    process.exitCode = 1;
+    return;
+  }
+  if (state === "done" && !hb.task) {
+    emit.error({
+      code: "task_required_for_done",
+      message: "declare a current task with agents set-task before marking it done",
+    });
+    process.exitCode = 1;
+    return;
+  }
+
+  const priorState: TaskState = hb.task_state ?? "active";
+  const priorReason = hb.task_state_reason || undefined;
+  if (priorState === state && priorReason === reason) {
+    emit.data({
+      instance_id: myOwner,
+      task_state: state,
+      reason: reason ?? null,
+      changed: false,
+      name_reminted: false,
+      git_finalization_checked: false,
+    });
+    return;
+  }
+
+  let finalization: GitFinalizationResult | null = null;
+  if (state === "done") {
+    const history = readSessionWriteClaims(root, hb.instance_id, hb.session_id ?? myOwner);
+    const touchedPaths = [...new Set([...(hb.files_touched ?? []), ...history.paths])];
+    finalization = checkGitFinalization(root, touchedPaths, {
+      claimHistoryComplete: history.complete,
+    });
+    if (!finalization.ok) {
+      emit.error({
+        code: "git_not_finalized",
+        message: formatGitFinalizationFailure(finalization, resolveBinName(root)).replace(
+          "the status box was not issued",
+          "lifecycle was not changed",
+        ),
+      });
+      process.exitCode = 1;
+      return;
+    }
+  }
+
+  const suggestedName = buildLifecycleSuggestedName(hb.name ?? "unknown", hb.task, state);
+  const nameReminted = suggestedName !== null && suggestedName !== hb.suggested_session_name;
+  const emitted = emitCanonical({
+    type: "state.task_state",
+    owner: myOwner,
+    session: hb.session_id ?? myOwner,
+    adapter: normalizeAdapter(hb.platform),
+    data: {
+      state,
+      reason: reason ?? null,
+      prior_state: priorState,
+      name_reminted: nameReminted,
+      git_finalization_checked: finalization !== null,
+      ...(nameReminted ? { suggested_session_name: suggestedName } : {}),
+    },
+  });
+  if (!emitted) {
+    emit.error({
+      code: "lifecycle_event_failed",
+      message: "the lifecycle event could not be recorded; heartbeat state was left unchanged",
+    });
+    process.exitCode = 1;
+    return;
+  }
+
+  emit.data({
+    instance_id: myOwner,
+    task_state: state,
+    prior_state: priorState,
+    reason: reason ?? null,
+    changed: true,
+    name_reminted: nameReminted,
+    suggested_session_name: nameReminted ? suggestedName : null,
+    git_finalization_checked: finalization !== null,
+    ...(nameReminted
+      ? {
+          note: "Reproduce suggested_session_name verbatim, by itself, in a fenced code block at the top of your reply — the operator copies it as the session/tab title.",
+        }
+      : {}),
+  });
+}
+
 function runSuggestName(
   descriptionParts: string[],
   opts: { json?: boolean; sessionId?: string },
@@ -1790,6 +2010,12 @@ function runStatus(opts: { endTurn?: boolean; json?: boolean; sessionId?: string
     instance_id: hb.instance_id,
     kind: normalizeKind(hb.kind),
     session_age_secs: ageSecs,
+    activity: activityOf(hb),
+    activity_updated_at: hb.activity_updated_at ?? null,
+    activity_source: hb.activity_source ?? null,
+    task_state: taskStateOf(hb),
+    task_state_updated_at: hb.task_state_updated_at ?? null,
+    task_state_reason: hb.task_state_reason ?? null,
     files_held: filesHeld,
     peers_live: livePeers.length,
     peers_stale: peersStale,
@@ -1803,6 +2029,9 @@ function runStatus(opts: { endTurn?: boolean; json?: boolean; sessionId?: string
       agents: m.agents.map((a) => ({
         name: a.name || "unnamed",
         task: a.task ?? null,
+        activity: a.activity ?? "unknown",
+        task_state: a.task_state ?? "active",
+        task_state_reason: a.task_state_reason ?? null,
         files: a.files_touched?.length ?? 0,
       })),
     })),
@@ -1822,6 +2051,8 @@ function runStatus(opts: { endTurn?: boolean; json?: boolean; sessionId?: string
 
   const rows: Array<[string, string]> = [
     ["session", formatAge(ageSecs)],
+    ["activity", activityOf(hb)],
+    ["lifecycle", lifecycleLabel(hb)],
     ["context", ctxStr],
     ["files", filesStr],
     ["peers", peersStr],
@@ -2573,6 +2804,12 @@ function traceLine(ev: CanonicalEvent, allTools: boolean): TraceEntry | null {
     case "state.task_set":
       detail = d.cleared ? "(cleared)" : clip(s("task"));
       break;
+    case "state.task_state":
+      detail = `${s("prior_state") || "active"} → ${s("state") || "active"}${s("reason") ? ` · ${clip(s("reason"), 55)}` : ""}`;
+      break;
+    case "interaction.input_requested":
+      detail = s("request_kind") || s("tool_name") || "operator input requested";
+      break;
     case "state.status_checked":
       detail = "status box rendered";
       break;
@@ -2693,6 +2930,7 @@ function runTrace(
   }
 
   const events = byId.get(resolvedId) ?? [];
+  const state = foldSessionState(events, { instance_id: resolvedId });
   const lines = events
     .map((ev) => traceLine(ev, !!opts.allTools))
     .filter((l): l is TraceEntry => l !== null)
@@ -2707,6 +2945,12 @@ function runTrace(
     instance_id: resolvedId,
     other_instances: candidateIds.filter((id) => id !== resolvedId),
     total_events: events.length,
+    activity: state.activity,
+    activity_updated_at: state.activity_updated_at ?? null,
+    activity_source: state.activity_source ?? null,
+    task_state: state.task_state,
+    task_state_updated_at: state.task_state_updated_at ?? null,
+    task_state_reason: state.task_state_reason ?? null,
     shown: shown.length,
     entries: shown,
   };
@@ -2718,6 +2962,9 @@ function runTrace(
   emit.data(result);
   const header = `Trace: agent-${displayName}  (${resolvedId.slice(0, 8)}…)  ${events.length} events${result.other_instances.length ? ` · ${result.other_instances.length} older instance(s) of this name` : ""}`;
   process.stdout.write(`${header}\n`); // lint-ok-emission: human trace view
+  process.stdout.write(
+    `  activity=${state.activity} · lifecycle=${state.task_state}${state.task_state === "blocked" && state.task_state_reason ? `: ${state.task_state_reason}` : ""}\n`,
+  ); // lint-ok-emission: human trace view
   if (shown.length === 0) {
     process.stdout.write("  (no events)\n"); // lint-ok-emission: human trace view
     return;