sneakoscope 6.0.3 → 6.1.2

package/dist/core/commands/team-legacy-observe-command.js

@@ -1,18 +1,10 @@
 import path from 'node:path';
-import { ARTIFACT_FILES } from '../artifact-schemas.js';
-import { appendJsonlBounded, nowIso, readJson, readText, sksRoot, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
+import { readJson, readText, sksRoot } from '../fsx.js';
 import { loadMission } from '../mission.js';
 import { MIN_TEAM_REVIEWER_LANES } from '../team-review-policy.js';
-import { attachZellijSessionInteractive, launchTeamZellijView } from '../zellij/zellij-launcher.js';
 import { flag, readFlagValue } from './command-utils.js';
-const TEAM_SESSION_CLEANUP_ARTIFACT = 'team-session-cleanup.json';
-const TEAM_RUNTIME_TASKS_ARTIFACT = 'team-runtime-tasks.json';
-export const teamLegacySubcommands = new Set([
-    'log',
-    'tail',
-    'watch',
-    'lane',
-    'status',
+const READ_ONLY_TEAM_SUBCOMMANDS = new Set(['log', 'tail', 'watch', 'lane', 'status']);
+const REMOVED_TEAM_SUBCOMMANDS = new Set([
     'dashboard',
     'event',
     'message',
@@ -23,7 +15,10 @@ export const teamLegacySubcommands = new Set([
     'attach-tmux',
     'cleanup-tmux'
 ]);
+export const teamLegacySubcommands = new Set([...READ_ONLY_TEAM_SUBCOMMANDS, ...REMOVED_TEAM_SUBCOMMANDS]);
 export async function teamLegacyObserveCommand(sub, args = []) {
+    if (!READ_ONLY_TEAM_SUBCOMMANDS.has(sub))
+        return removedTeamSurface(sub, args);
     const root = await sksRoot();
     const missionArg = args[0] && !String(args[0]).startsWith('--') ? args[0] : 'latest';
     const { resolveMissionId } = await import('./command-utils.js');
@@ -34,367 +29,107 @@ export async function teamLegacyObserveCommand(sub, args = []) {
         return;
     }
     const { dir } = await loadMission(root, id);
-    if (sub === 'open-tmux' || sub === 'attach-tmux' || sub === 'cleanup-tmux') {
-        const result = { ok: false, status: 'removed_runtime', runtime: 'tmux', replacement: 'zellij', operator_actions: ['Use `sks team open-zellij`, `attach-zellij`, or `cleanup-zellij`.'] };
-        if (flag(args, '--json'))
-            return console.log(JSON.stringify(result, null, 2));
-        console.error('tmux runtime has been removed from SKS Team. Use Zellij commands instead.');
+    if (sub === 'status')
+        return renderStatus(id, dir, args);
+    if (sub === 'log')
+        return console.log(await readText(path.join(dir, 'team-live.md'), ''));
+    if (sub === 'lane')
+        return renderLane(id, dir, args);
+    return renderTailOrWatch(sub, id, dir, args);
+}
+function removedTeamSurface(sub, args) {
+    const result = {
+        schema: 'sks.team-legacy-observe.v1',
+        ok: false,
+        status: 'removed_non_read_only_surface',
+        subcommand: sub,
+        read_only_commands: [...READ_ONLY_TEAM_SUBCOMMANDS],
+        replacement: 'Use sks naruto status|subagents|proof for current official-subagent missions.'
+    };
+    process.exitCode = 2;
+    if (flag(args, '--json'))
+        console.log(JSON.stringify(result, null, 2));
+    else
+        console.error(`sks team ${sub} was removed because legacy Team commands are read-only. ${result.replacement}`);
+    return result;
+}
+async function renderStatus(id, dir, args) {
+    const dashboard = await readJson(path.join(dir, 'team-dashboard.json'), null);
+    if (!dashboard) {
+        const result = { schema: 'sks.team-legacy-observe.v1', ok: false, status: 'dashboard_missing', mission_id: id };
         process.exitCode = 2;
-        return;
-    }
-    if (sub === 'open-zellij' || sub === 'attach-zellij') {
-        const plan = await readJson(path.join(dir, 'team-plan.json'), null);
-        if (!plan) {
-            console.error(`Team plan missing for ${id}; cannot open Zellij Team view.`);
-            process.exitCode = 2;
-            return;
-        }
-        const slotCount = await inferTeamZellijSlotCount(dir, plan);
-        const zellij = await launchTeamZellijView({ root, missionId: id, ledgerRoot: path.join(dir, 'agents'), slotCount, dryRun: flag(args, '--json'), attach: false });
         if (flag(args, '--json'))
-            return console.log(JSON.stringify(zellij, null, 2));
-        if (!zellij.ok) {
-            console.error(`Zellij Team view blocked for ${id}: ${(zellij.blockers || []).join('; ') || 'Zellij launch failed'}`);
-            process.exitCode = 2;
-            return;
-        }
-        if (zellij.capability?.status === 'ok')
-            console.log(`Zellij: prepared Team lane(s) in ${zellij.session_name}`);
+            console.log(JSON.stringify(result, null, 2));
         else
-            console.log(`Zellij: optional live panes unavailable (${(zellij.warnings || []).join('; ') || zellij.capability?.status || 'unknown'})`);
-        if (zellij.capability?.status === 'ok' && (sub === 'attach-zellij' || shouldAutoAttachTeamZellij(args))) {
-            attachZellijSessionInteractive(zellij.session_name, { cwd: root, configPath: zellij.clipboard_config_path });
-        }
-        return;
-    }
-    if (sub === 'event') {
-        const message = readFlagValue(args, '--message', '');
-        if (!message) {
-            console.error('Usage: sks team event [mission-id|latest] --agent <name> --phase <phase> --message "..."');
-            process.exitCode = 1;
-            return;
-        }
-        const phase = readFlagValue(args, '--phase', 'general');
-        const record = await appendTeamEvent(dir, { agent: readFlagValue(args, '--agent', 'parent_orchestrator'), phase, type: readFlagValue(args, '--type', 'status'), artifact: readFlagValue(args, '--artifact', ''), message });
-        if (flag(args, '--json'))
-            return console.log(JSON.stringify(record, null, 2));
-        console.log(`${record.ts} [${record.phase}] ${record.agent}: ${record.message}`);
-        return;
-    }
-    if (sub === 'message') {
-        const message = readFlagValue(args, '--message', '');
-        if (!message) {
-            console.error('Usage: sks team message [mission-id|latest] --from <agent> --to <agent|all> --message "..."');
-            process.exitCode = 1;
-            return;
-        }
-        const record = await appendTeamEvent(dir, { agent: readFlagValue(args, '--from', readFlagValue(args, '--agent', 'parent_orchestrator')), to: readFlagValue(args, '--to', 'all'), phase: readFlagValue(args, '--phase', 'communication'), type: 'message', message });
-        if (flag(args, '--json'))
-            return console.log(JSON.stringify(record, null, 2));
-        console.log(`${record.ts} [${record.phase}] ${record.agent} -> ${record.to}: ${record.message}`);
-        return;
-    }
-    if (sub === 'cleanup-zellij') {
-        const control = await requestTeamSessionCleanup(dir, { missionId: id, agent: readFlagValue(args, '--agent', 'parent_orchestrator'), reason: readFlagValue(args, '--reason', 'Team session ended; clean up live follow panes.'), finalMessage: 'Team session ended.' });
-        await appendTeamEvent(dir, { agent: readFlagValue(args, '--agent', 'parent_orchestrator'), phase: 'session_cleanup', type: 'cleanup', message: control.cleanup_reason || 'Team session cleanup requested.' });
-        const cleanup = { ok: true, runtime: 'zellij', mission_id: id, control, close_requested: flag(args, '--close-session') || flag(args, '--close') };
-        await writeJsonAtomic(path.join(dir, 'zellij-session-cleanup.json'), cleanup);
-        if (flag(args, '--json'))
-            return console.log(JSON.stringify(cleanup, null, 2));
-        console.log('Zellij cleanup: marked complete.');
-        console.log(renderTeamCleanupSummary(control));
-        return;
-    }
-    if (sub === 'status') {
-        const dashboard = await readTeamDashboard(dir);
-        if (flag(args, '--json'))
-            return console.log(JSON.stringify(dashboard || {}, null, 2));
-        if (!dashboard) {
             console.error(`Team dashboard missing for ${id}.`);
-            process.exitCode = 2;
-            return;
-        }
-        console.log(`Team mission: ${id}`);
-        console.log(`Updated: ${dashboard.updated_at || 'unknown'}`);
-        console.log(`Agent sessions: ${dashboard.agent_session_count || MIN_TEAM_REVIEWER_LANES}`);
-        if (dashboard.role_counts)
-            console.log(`Role counts: ${formatRoleCounts(dashboard.role_counts)}`);
-        return;
-    }
-    if (sub === 'dashboard') {
-        await writeTeamDashboardState(dir, { missionId: id });
-        const state = await readJson(path.join(dir, ARTIFACT_FILES.team_dashboard_state), {});
-        if (flag(args, '--json'))
-            return console.log(JSON.stringify(state, null, 2));
-        console.log(renderTeamDashboardState(state));
-        return;
-    }
-    if (sub === 'log')
-        return console.log(await readTeamLive(dir));
-    if (sub === 'lane') {
-        const agent = readFlagValue(args, '--agent', 'parent_orchestrator');
-        const phase = readFlagValue(args, '--phase', '');
-        const lines = Number(readFlagValue(args, '--lines', '12'));
-        const text = await renderTeamAgentLane(dir, { missionId: id, agent, phase, lines });
-        if (flag(args, '--json'))
-            return console.log(JSON.stringify({ mission_id: id, agent, phase, lane: text }, null, 2));
-        console.log(text);
-        if (flag(args, '--follow') && !teamCleanupRequested(await readTeamControl(dir)) && !isTerminalTeamAgentStatus((await readTeamDashboard(dir).catch(() => null))?.agents?.[agent]?.status || '')) {
-            // Follow mode intentionally falls through only for interactive terminals in the full Zellij lane.
-        }
-        return;
-    }
-    if (sub === 'tail' || sub === 'watch') {
-        const lines = readFlagValue(args, '--lines', '20');
-        if (sub === 'watch' && !flag(args, '--raw'))
-            console.log(await renderTeamWatch(dir, { missionId: id, lines: Number(lines) }));
-        else
-            for (const line of await readTeamTranscriptTail(dir, Number(lines)))
-                console.log(line);
+        return result;
     }
-}
-async function inferTeamZellijSlotCount(dir, plan = {}) {
-    const scheduler = await readJson(path.join(dir, 'agents', 'agent-scheduler-state.json'), null);
-    const lanes = await readJson(path.join(dir, 'agents', 'agent-zellij-lanes.json'), null);
-    const candidates = [
-        plan?.bundle_size,
-        plan?.agent_session_count,
-        lanes?.lane_count,
-        plan?.target_active_slots,
-        scheduler?.target_active_slots
-    ].map((value) => Number(value)).filter((value) => Number.isFinite(value) && value > 0);
-    return Math.max(1, Math.min(100, Math.floor(candidates[0] || 5)));
-}
-function shouldAutoAttachTeamZellij(args = []) {
-    const list = (args || []).map((arg) => String(arg));
-    if (list.includes('--no-attach'))
-        return false;
-    if (list.includes('--json'))
-        return false;
-    if (process.env.SKS_NO_ZELLIJ_ATTACH === '1')
-        return false;
-    if (process.env.ZELLIJ)
-        return false;
-    if (list.includes('--attach'))
-        return true;
-    return Boolean(process.stdout.isTTY && process.stdin.isTTY);
-}
-function teamLogPaths(dir) {
-    return {
-        live: path.join(dir, 'team-live.md'),
-        transcript: path.join(dir, 'team-transcript.jsonl'),
-        dashboard: path.join(dir, 'team-dashboard.json'),
-        control: path.join(dir, 'team-control.json')
-    };
-}
-function defaultTeamControl(id) {
-    return {
-        schema_version: 1,
+    const result = {
+        schema: 'sks.team-legacy-observe.v1',
+        ok: true,
+        status: 'read_only',
         mission_id: id,
-        status: 'running',
-        cleanup_requested: false,
-        cleanup_requested_at: null,
-        cleanup_requested_by: null,
-        cleanup_reason: null,
-        final_message: null
-    };
-}
-function formatRoleCounts(roleCounts = {}) {
-    return Object.entries(roleCounts || {}).map(([role, count]) => `${role}:${count}`).join(' ');
-}
-async function readTeamDashboard(dir) {
-    return readJson(teamLogPaths(dir).dashboard, null);
-}
-async function readTeamLive(dir) {
-    return readText(teamLogPaths(dir).live, '');
-}
-async function readTeamTranscriptTail(dir, count = 20) {
-    const text = await readText(teamLogPaths(dir).transcript, '');
-    return text.split(/\n/).filter(Boolean).slice(-Math.max(1, Number(count) || 20));
-}
-async function readTeamControl(dir) {
-    const control = await readJson(teamLogPaths(dir).control, defaultTeamControl(path.basename(dir)));
-    const cleanup = await readJson(path.join(dir, TEAM_SESSION_CLEANUP_ARTIFACT), null).catch(() => null);
-    if (!cleanup || (cleanup.passed !== true && cleanup.live_transcript_finalized !== true && cleanup.all_sessions_closed !== true))
-        return control;
-    return {
-        ...defaultTeamControl(path.basename(dir)),
-        ...control,
-        status: 'ended',
-        cleanup_requested: true,
-        cleanup_requested_at: cleanup.updated_at || cleanup.completed_at || cleanup.closed_at || control.cleanup_requested_at || 'artifact',
-        cleanup_requested_by: cleanup.agent || control.cleanup_requested_by || 'parent_orchestrator',
-        cleanup_reason: cleanup.reason || control.cleanup_reason || `${TEAM_SESSION_CLEANUP_ARTIFACT} passed.`,
-        final_message: cleanup.final_message || control.final_message || 'Team session ended. Legacy observation lanes can stop.'
-    };
-}
-async function appendTeamEvent(dir, event) {
-    const files = teamLogPaths(dir);
-    const record = {
-        ts: event.ts || nowIso(),
-        agent: String(event.agent || 'parent_orchestrator'),
-        phase: String(event.phase || 'general'),
-        type: String(event.type || 'status'),
-        to: event.to ? String(event.to).slice(0, 200) : undefined,
-        message: String(event.message || '').slice(0, 4000),
-        artifact: event.artifact ? String(event.artifact) : undefined
+        updated_at: dashboard.updated_at || null,
+        agent_session_count: dashboard.agent_session_count || MIN_TEAM_REVIEWER_LANES,
+        role_counts: dashboard.role_counts || null
     };
-    await appendJsonlBounded(files.transcript, record, 1024 * 1024);
-    const dashboard = await readJson(files.dashboard, null);
-    if (dashboard) {
-        dashboard.updated_at = record.ts;
-        dashboard.latest_messages = [...(dashboard.latest_messages || []), record].slice(-20);
-        dashboard.agents ||= {};
-        dashboard.agents[record.agent] ||= {};
-        dashboard.agents[record.agent].status = isTerminalTeamAgentStatus(record.type) ? record.type : record.type || 'active';
-        dashboard.agents[record.agent].phase = record.phase;
-        dashboard.agents[record.agent].last_seen = record.ts;
-        await writeJsonAtomic(files.dashboard, dashboard);
+    if (flag(args, '--json'))
+        console.log(JSON.stringify(result, null, 2));
+    else {
+        console.log(`Team mission: ${id}`);
+        console.log(`Updated: ${result.updated_at || 'unknown'}`);
+        console.log(`Agent sessions: ${result.agent_session_count}`);
     }
-    const target = record.to ? ` -> ${record.to}` : '';
-    const current = await readText(files.live, '# SKS Team Live Transcript\n\n## Live Events\n');
-    const line = `\n- ${record.ts} [${record.phase}] ${record.agent}${target}: ${record.message}${record.artifact ? ` (${record.artifact})` : ''}\n`;
-    await writeTextAtomic(files.live, `${current.trimEnd()}${line}`);
-    return record;
-}
-async function requestTeamSessionCleanup(dir, opts = {}) {
-    const current = await readTeamControl(dir);
-    const next = {
-        ...defaultTeamControl(current?.mission_id || opts.missionId || path.basename(dir)),
-        ...current,
-        status: 'cleanup_requested',
-        cleanup_requested: true,
-        cleanup_requested_at: opts.ts || nowIso(),
-        cleanup_requested_by: opts.agent || 'parent_orchestrator',
-        cleanup_reason: opts.reason || 'Team session cleanup requested.',
-        final_message: opts.finalMessage || 'Team session ended.'
-    };
-    await writeJsonAtomic(teamLogPaths(dir).control, next);
-    return next;
-}
-function teamCleanupRequested(control = {}) {
-    return Boolean(control?.cleanup_requested || control?.status === 'cleanup_requested' || control?.status === 'ended');
-}
-function isTerminalTeamAgentStatus(status = '') {
-    return /(?:^|_)(?:done|complete|completed|closed|cleanup|cancelled|canceled|failed|ended|stopped)(?:_|$)/i.test(String(status || ''));
-}
-function renderTeamCleanupSummary(control = {}) {
-    if (!teamCleanupRequested(control))
-        return '';
-    return [
-        '# SKS Team Session Cleanup',
-        '',
-        `Status: ${control.status || 'cleanup_requested'}`,
-        `Requested at: ${control.cleanup_requested_at || 'unknown'}`,
-        `Requested by: ${control.cleanup_requested_by || 'unknown'}`,
-        `Reason: ${control.cleanup_reason || 'Team session cleanup requested.'}`,
-        '',
-        control.final_message || 'Team session ended.'
-    ].join('\n');
-}
-async function renderTeamAgentLane(dir, opts = {}) {
-    const agent = String(opts.agent || opts.agentId || 'parent_orchestrator');
-    const lines = Math.max(1, Number(opts.lines) || 12);
-    const dashboard = await readTeamDashboard(dir);
-    const control = await readTeamControl(dir);
-    const runtime = await readJson(path.join(dir, TEAM_RUNTIME_TASKS_ARTIFACT), null);
+    return result;
+}
+async function renderLane(id, dir, args) {
+    const agent = readFlagValue(args, '--agent', 'parent_orchestrator');
+    const lines = Math.max(1, Number(readFlagValue(args, '--lines', '12')) || 12);
+    const [dashboard, runtime, events] = await Promise.all([
+        readJson(path.join(dir, 'team-dashboard.json'), {}),
+        readJson(path.join(dir, 'team-runtime-tasks.json'), {}),
+        transcriptTail(dir, lines)
+    ]);
     const status = dashboard?.agents?.[agent] || {};
     const tasks = (Array.isArray(runtime?.tasks) ? runtime.tasks : []).filter((task) => task?.worker === agent || task?.agent_hint === agent);
-    const events = (await readTeamTranscriptTail(dir, lines)).map(parseTranscriptLine).filter((event) => event.raw || event.agent === agent || event.to === agent || event.to === 'all');
-    return [
-        '# SKS Team Agent Lane',
-        '',
-        `Mission: ${opts.missionId || dashboard?.mission_id || runtime?.mission_id || path.basename(dir)}`,
-        `Agent: ${agent}`,
-        teamCleanupRequested(control) ? `Cleanup: requested at ${control.cleanup_requested_at || 'unknown'}` : null,
-        '',
-        '## Agent Status',
-        `- status: ${status.status || 'pending'}`,
-        `- phase: ${status.phase || 'unknown'}`,
-        `- last_seen: ${status.last_seen || 'never'}`,
-        '',
-        '## Assigned Runtime Tasks',
-        ...formatRuntimeTasks(tasks),
-        '',
-        '## Recent Events',
-        ...(events.length ? events.map(formatTranscriptEvent) : ['- No matching events yet.']),
-        teamCleanupRequested(control) ? ['', renderTeamCleanupSummary(control)].join('\n') : null
-    ].filter((line) => line !== null).join('\n');
-}
-async function renderTeamWatch(dir, opts = {}) {
-    const lines = Math.max(1, Number(opts.lines) || 20);
-    const dashboard = await readTeamDashboard(dir);
-    const control = await readTeamControl(dir);
-    const runtime = await readJson(path.join(dir, TEAM_RUNTIME_TASKS_ARTIFACT), null);
-    const events = (await readTeamTranscriptTail(dir, lines)).map(parseTranscriptLine);
-    const agents = Object.entries(dashboard?.agents || {}).slice(0, Math.max(3, Number(dashboard?.agent_session_count) || 3));
-    return [
-        '# SKS Team Legacy Observation',
-        '',
-        `Mission: ${opts.missionId || dashboard?.mission_id || runtime?.mission_id || path.basename(dir)}`,
-        `Updated: ${dashboard?.updated_at || 'unknown'}`,
-        `Agent session budget: ${dashboard?.agent_session_count || 'unknown'}`,
-        dashboard?.role_counts ? `Role counts: ${formatRoleCounts(dashboard.role_counts)}` : null,
-        teamCleanupRequested(control) ? `Cleanup: requested at ${control.cleanup_requested_at || 'unknown'}` : null,
-        '',
-        '## Visible Agent Lanes',
-        ...(agents.length ? agents.map(([name, status]) => `- ${name}: ${status.status || 'pending'} | ${status.phase || 'unknown'} | last_seen:${status.last_seen || 'never'}`) : ['- No agent lanes registered yet.']),
-        '',
-        '## Runtime Task Snapshot',
-        ...formatRuntimeTasks((Array.isArray(runtime?.tasks) ? runtime.tasks : []).slice(0, 8)),
-        '',
-        '## Recent Mission Events',
-        ...(events.length ? events.map(formatTranscriptEvent) : ['- No transcript events yet.']),
-        teamCleanupRequested(control) ? ['', renderTeamCleanupSummary(control)].join('\n') : null
-    ].filter((line) => line !== null).join('\n');
-}
-async function writeTeamDashboardState(dir, opts = {}) {
-    const mission = await readJson(path.join(dir, 'mission.json'), {});
-    const dashboard = await readTeamDashboard(dir) || {};
-    const runtime = await readJson(path.join(dir, TEAM_RUNTIME_TASKS_ARTIFACT), {});
-    const gate = await readJson(path.join(dir, 'team-gate.json'), {});
-    const state = {
-        schema_version: 1,
-        updated_at: nowIso(),
-        mission: { id: mission.id || dashboard.mission_id || opts.missionId || 'unknown', route: mission.mode || 'team', phase: opts.phase || 'legacy_observe' },
-        gates: Object.entries(gate || {}).filter(([, value]) => typeof value === 'boolean').map(([name, value]) => ({ name, status: value ? 'pass' : 'fail', evidence: [] })),
-        agents: Object.entries(dashboard.agents || {}).map(([id, value]) => ({ id, role: value.role || null, status: value.status || 'pending', current_task: value.phase || null })),
-        tasks: (runtime.tasks || []).map((task) => ({ id: task.task_id, deps: task.depends_on || [], status: task.status || 'pending' })),
-        artifacts: ['team-plan.json', 'team-gate.json', 'team-live.md', 'team-dashboard.json', TEAM_RUNTIME_TASKS_ARTIFACT]
+    const result = {
+        schema: 'sks.team-legacy-observe.v1',
+        ok: true,
+        status: 'read_only',
+        mission_id: id,
+        agent,
+        agent_status: status,
+        tasks,
+        events
     };
-    await writeJsonAtomic(path.join(dir, ARTIFACT_FILES.team_dashboard_state), state);
-    return { ok: true, state };
-}
-function renderTeamDashboardState(state = {}) {
-    return [
-        `Mission: ${state.mission?.id || 'unknown'} (${state.mission?.route || 'team'})`,
-        `Phase: ${state.mission?.phase || 'unknown'}`,
-        '',
-        ...(state.gates || []).map((gate) => `[${gate.name}] ${gate.status}`),
-        ...(state.agents?.length ? [`Agents: ${state.agents.length}`] : []),
-        ...(state.tasks?.length ? [`Tasks: ${state.tasks.length}`] : [])
-    ].join('\n');
-}
-function parseTranscriptLine(line) {
-    try {
-        return JSON.parse(line);
+    if (flag(args, '--json'))
+        console.log(JSON.stringify(result, null, 2));
+    else {
+        console.log(`# SKS Team Agent Lane\n\nMission: ${id}\nAgent: ${agent}`);
+        console.log(`Status: ${status.status || 'pending'} | phase: ${status.phase || 'unknown'}`);
+        for (const task of tasks.slice(0, 12))
+            console.log(`- ${task.task_id || 'task'}: ${task.subject || task.symbolic_id || 'untitled'} (${task.status || 'pending'})`);
+        for (const event of events)
+            console.log(event);
     }
-    catch {
-        return { raw: String(line || '').slice(0, 1000) };
+    return result;
+}
+async function renderTailOrWatch(sub, id, dir, args) {
+    const lines = Math.max(1, Number(readFlagValue(args, '--lines', '20')) || 20);
+    const events = await transcriptTail(dir, lines);
+    const result = { schema: 'sks.team-legacy-observe.v1', ok: true, status: 'read_only', action: sub, mission_id: id, events };
+    if (flag(args, '--json'))
+        console.log(JSON.stringify(result, null, 2));
+    else {
+        if (sub === 'watch' && !flag(args, '--raw'))
+            console.log(`# SKS Team Legacy Observation\n\nMission: ${id}`);
+        for (const event of events)
+            console.log(event);
     }
+    return result;
 }
-function formatTranscriptEvent(event = {}) {
-    if (event.raw)
-        return `- ${event.raw}`;
-    const parts = [event.ts || 'no-ts', `[${event.phase || 'general'}]`, event.agent || 'unknown', event.to ? `-> ${event.to}` : null, event.type ? `(${event.type})` : null].filter(Boolean);
-    return `- ${parts.join(' ')}: ${String(event.message || '').slice(0, 500)}${event.artifact ? ` (${event.artifact})` : ''}`;
-}
-function formatRuntimeTasks(tasks = []) {
-    if (!tasks.length)
-        return ['- No assigned runtime tasks found.'];
-    return tasks.slice(0, 12).map((task) => {
-        const details = [task.status || 'pending', task.phase || task.role || 'team', task.depends_on?.length ? `deps:${task.depends_on.join(',')}` : null, task.file_paths?.length ? `files:${task.file_paths.slice(0, 3).join(',')}` : null].filter(Boolean).join(' | ');
-        return `- ${task.task_id || 'task'} ${task.subject || task.symbolic_id || 'untitled'} (${details})`;
-    });
+async function transcriptTail(dir, count) {
+    const text = await readText(path.join(dir, 'team-transcript.jsonl'), '');
+    return text.split(/\n/).filter(Boolean).slice(-count);
 }
 //# sourceMappingURL=team-legacy-observe-command.js.map