timsquad 3.6.0 → 3.7.1

package/dist/commands/workflow.js

@@ -1,781 +0,0 @@
-import path from 'path';
-import fs from 'fs-extra';
-import { colors, printHeader, printError, printSuccess, printKeyValue } from '../utils/colors.js';
-import { findProjectRoot } from '../lib/project.js';
-import { getTimestamp } from '../utils/date.js';
-import { loadWorkflowState, saveWorkflowState, isSequenceComplete, findSequenceForAgent, } from '../lib/workflow-state.js';
-import { getSequencesDir, getPhasesDir, buildSequenceLogData, buildPhaseGateData, loadSequenceTaskLogs, hasSemantic, } from './log.js';
-import { queryDaemon } from '../daemon/meta-cache.js';
-import { writeContext } from '../daemon/context-writer.js';
-import { parseAgentPrerequisites, checkStale, loadManifest } from '../lib/compiler.js';
-const LOG_SCHEMA_VERSION = '1.0.0';
-export function registerWorkflowCommand(program) {
-    const wfCmd = program
-        .command('workflow')
-        .alias('wf')
-        .description('Manage automated workflow (sequences, phases, automation toggles)');
-    // tsq workflow set-phase <phase-id>
-    wfCmd
-        .command('set-phase <phase-id>')
-        .description('Set the current active phase')
-        .option('--force', 'Force phase transition even if gate conditions are not met')
-        .action(async (phaseId, options) => {
-        try {
-            await setPhase(phaseId, options.force);
-        }
-        catch (error) {
-            printError(error.message);
-            process.exit(1);
-        }
-    });
-    // tsq workflow add-sequence <seq-id>
-    wfCmd
-        .command('add-sequence <seq-id>')
-        .description('Register a sequence for workflow tracking')
-        .requiredOption('--agents <list>', 'Comma-separated expected agent types (e.g. developer,dba)')
-        .option('--phase <id>', 'Phase ID (defaults to current phase)')
-        .action(async (seqId, options) => {
-        try {
-            await addSequence(seqId, options);
-        }
-        catch (error) {
-            printError(error.message);
-            process.exit(1);
-        }
-    });
-    // tsq workflow remove-sequence <seq-id>
-    wfCmd
-        .command('remove-sequence <seq-id>')
-        .description('Remove a sequence from tracking')
-        .action(async (seqId) => {
-        try {
-            await removeSequence(seqId);
-        }
-        catch (error) {
-            printError(error.message);
-            process.exit(1);
-        }
-    });
-    // tsq workflow status
-    wfCmd
-        .command('status')
-        .description('Show workflow state and automation status')
-        .action(async () => {
-        try {
-            await showStatus();
-        }
-        catch (error) {
-            printError(error.message);
-            process.exit(1);
-        }
-    });
-    // tsq workflow config <key> <value>
-    wfCmd
-        .command('config <key> <value>')
-        .description('Toggle automation settings (e.g. sequence_log on/off)')
-        .action(async (key, value) => {
-        try {
-            await setConfig(key, value);
-        }
-        catch (error) {
-            printError(error.message);
-            process.exit(1);
-        }
-    });
-    // tsq task start --agent <agent> --scope <paths>
-    wfCmd
-        .command('task-start')
-        .description('Prepare task context for a sub-agent (creates task-context.json)')
-        .requiredOption('--agent <type>', 'Agent type (developer, qa, dba, etc.)')
-        .option('--scope <paths>', 'Comma-separated scope paths (e.g. "src/auth,src/models")')
-        .action(async (options) => {
-        try {
-            await taskStart(options);
-        }
-        catch (error) {
-            printError(error.message);
-            process.exit(1);
-        }
-    });
-    // tsq workflow track-task <agent> <task-log-path> (internal — called by hook)
-    wfCmd
-        .command('track-task <agent> <task-log-path>')
-        .description('(internal) Track a completed task in workflow state')
-        .action(async (agent, taskLogPath) => {
-        try {
-            await trackTask(agent, taskLogPath);
-        }
-        catch {
-            // Silent fail for hook usage — don't break the hook chain
-            process.exit(0);
-        }
-    });
-    // tsq workflow check (internal — called by hook on SessionEnd)
-    wfCmd
-        .command('check')
-        .description('(internal) Check workflow state and auto-create L2/L3/gate/retro')
-        .action(async () => {
-        try {
-            await checkAndAutomate();
-        }
-        catch {
-            // Silent fail for hook usage
-            process.exit(0);
-        }
-    });
-}
-// ============================================================
-// Commands
-// ============================================================
-async function setPhase(phaseId, force) {
-    const projectRoot = await findProjectRoot();
-    if (!projectRoot)
-        throw new Error('Not a TimSquad project');
-    const state = await loadWorkflowState(projectRoot);
-    // Phase Gate enforcement: check current phase before transitioning
-    if (state.current_phase && state.current_phase.id !== phaseId && state.automation.phase_gate) {
-        const gateResult = await buildPhaseGateData(projectRoot, state.current_phase.id);
-        if (!gateResult.can_transition) {
-            if (force) {
-                console.log(colors.warning(`\n  ⚠ Phase gate BLOCKED for "${state.current_phase.id}" — forced override`));
-                for (const condition of gateResult.blocking_conditions) {
-                    console.log(colors.dim(`    - ${condition}`));
-                }
-                for (const report of gateResult.missing_reports) {
-                    console.log(colors.dim(`    - Missing report: ${report}`));
-                }
-                console.log('');
-            }
-            else {
-                const lines = [
-                    `Phase gate BLOCKED for "${state.current_phase.id}". Cannot transition to "${phaseId}".`,
-                ];
-                if (gateResult.blocking_conditions.length > 0) {
-                    lines.push('Blocking conditions:');
-                    for (const c of gateResult.blocking_conditions) {
-                        lines.push(`  - ${c}`);
-                    }
-                }
-                if (gateResult.missing_reports.length > 0) {
-                    lines.push('Missing reports:');
-                    for (const r of gateResult.missing_reports) {
-                        lines.push(`  - ${r}`);
-                    }
-                }
-                lines.push('', 'Use --force to override.');
-                throw new Error(lines.join('\n'));
-            }
-        }
-    }
-    // Archive current phase if exists
-    if (state.current_phase && state.current_phase.id !== phaseId) {
-        state.completed_phases.push(state.current_phase.id);
-    }
-    state.current_phase = {
-        id: phaseId,
-        started_at: getTimestamp(),
-        sequences: [],
-    };
-    // Atomic sync: update workflow.json and current-phase.json together
-    await syncPhaseFiles(projectRoot, state);
-    printSuccess(`Phase set: ${phaseId}`);
-    printKeyValue('Automation', formatAutomation(state.automation));
-}
-/**
- * Atomically sync workflow.json and current-phase.json
- * Uses write-to-temp + rename pattern to prevent desync on failure
- */
-async function syncPhaseFiles(projectRoot, state) {
-    const stateDir = path.join(projectRoot, '.timsquad', 'state');
-    await fs.ensureDir(stateDir);
-    const workflowPath = path.join(stateDir, 'workflow.json');
-    const phasePath = path.join(stateDir, 'current-phase.json');
-    const workflowTmp = workflowPath + '.tmp';
-    const phaseTmp = phasePath + '.tmp';
-    const phaseData = state.current_phase
-        ? { current: state.current_phase.id, startedAt: state.current_phase.started_at, progress: 0 }
-        : { current: 'planning', startedAt: getTimestamp(), progress: 0 };
-    try {
-        // 1. Write both temp files
-        await fs.writeJson(workflowTmp, state, { spaces: 2 });
-        await fs.writeJson(phaseTmp, phaseData, { spaces: 2 });
-        // 2. Rename atomically (rename is atomic on POSIX filesystems)
-        await fs.rename(workflowTmp, workflowPath);
-        await fs.rename(phaseTmp, phasePath);
-    }
-    catch (err) {
-        // Cleanup temp files on failure
-        await fs.remove(workflowTmp).catch(() => { });
-        await fs.remove(phaseTmp).catch(() => { });
-        throw new Error(`Phase sync failed: ${err.message}`);
-    }
-}
-async function addSequence(seqId, options) {
-    const projectRoot = await findProjectRoot();
-    if (!projectRoot)
-        throw new Error('Not a TimSquad project');
-    const state = await loadWorkflowState(projectRoot);
-    const phaseId = options.phase || state.current_phase?.id;
-    if (!phaseId) {
-        throw new Error('No active phase. Run `tsq workflow set-phase <phase-id>` first.');
-    }
-    if (state.sequences[seqId]) {
-        throw new Error(`Sequence ${seqId} already exists. Remove it first to re-add.`);
-    }
-    const agents = options.agents.split(',').map(a => a.trim());
-    state.sequences[seqId] = {
-        status: 'pending',
-        phase: phaseId,
-        expected_agents: agents,
-        completed_tasks: [],
-        report_path: null,
-        l2_created: false,
-    };
-    // Add to current phase's sequence list
-    if (state.current_phase && !state.current_phase.sequences.includes(seqId)) {
-        state.current_phase.sequences.push(seqId);
-    }
-    await saveWorkflowState(projectRoot, state);
-    printSuccess(`Sequence added: ${seqId}`);
-    printKeyValue('Phase', phaseId);
-    printKeyValue('Expected agents', agents.join(', '));
-}
-async function removeSequence(seqId) {
-    const projectRoot = await findProjectRoot();
-    if (!projectRoot)
-        throw new Error('Not a TimSquad project');
-    const state = await loadWorkflowState(projectRoot);
-    if (!state.sequences[seqId]) {
-        throw new Error(`Sequence ${seqId} not found`);
-    }
-    delete state.sequences[seqId];
-    if (state.current_phase) {
-        state.current_phase.sequences = state.current_phase.sequences.filter(s => s !== seqId);
-    }
-    await saveWorkflowState(projectRoot, state);
-    printSuccess(`Sequence removed: ${seqId}`);
-}
-async function showStatus() {
-    const projectRoot = await findProjectRoot();
-    if (!projectRoot)
-        throw new Error('Not a TimSquad project');
-    const state = await loadWorkflowState(projectRoot);
-    printHeader('Workflow Status');
-    // Automation toggles
-    console.log(colors.subheader('  Automation'));
-    for (const [key, val] of Object.entries(state.automation)) {
-        const icon = val ? colors.success('ON') : colors.dim('OFF');
-        console.log(`    ${key.padEnd(16)} ${icon}`);
-    }
-    // Current phase
-    console.log(colors.subheader('\n  Phase'));
-    if (state.current_phase) {
-        printKeyValue('  Current', state.current_phase.id);
-        printKeyValue('  Started', state.current_phase.started_at);
-        printKeyValue('  Sequences', state.current_phase.sequences.join(', ') || '(none)');
-    }
-    else {
-        console.log(colors.dim('    No active phase. Run `tsq wf set-phase <id>`'));
-    }
-    // Sequences
-    const seqEntries = Object.entries(state.sequences);
-    if (seqEntries.length > 0) {
-        console.log(colors.subheader('\n  Sequences'));
-        for (const [seqId, seq] of seqEntries) {
-            const statusIcon = seq.status === 'completed'
-                ? colors.success('✓')
-                : seq.status === 'in_progress'
-                    ? colors.warning('▸')
-                    : seq.status === 'blocked'
-                        ? colors.error('✗')
-                        : colors.dim('○');
-            const l2Icon = seq.l2_created ? colors.success('[L2]') : colors.dim('[--]');
-            const completedAgents = seq.completed_tasks.map(t => t.agent);
-            const remaining = seq.expected_agents.filter(a => !completedAgents.includes(a));
-            console.log(`    ${statusIcon} ${colors.agent(seqId)} ${l2Icon} ${colors.dim(`[${seq.phase}]`)}`);
-            console.log(`      agents: ${seq.expected_agents.map(a => completedAgents.includes(a) ? colors.success(a) : colors.dim(a)).join(', ')}`);
-            if (remaining.length > 0 && seq.status !== 'completed') {
-                console.log(`      ${colors.dim(`waiting: ${remaining.join(', ')}`)}`);
-            }
-        }
-    }
-    // Completed phases
-    if (state.completed_phases.length > 0) {
-        console.log(colors.subheader('\n  Completed Phases'));
-        console.log(`    ${state.completed_phases.join(', ')}`);
-    }
-}
-async function setConfig(key, value) {
-    const projectRoot = await findProjectRoot();
-    if (!projectRoot)
-        throw new Error('Not a TimSquad project');
-    const state = await loadWorkflowState(projectRoot);
-    const validKeys = Object.keys(state.automation);
-    if (!validKeys.includes(key)) {
-        throw new Error(`Invalid key: ${key}. Valid: ${validKeys.join(', ')}`);
-    }
-    const boolVal = value === 'on' || value === 'true' || value === '1';
-    state.automation[key] = boolVal;
-    await saveWorkflowState(projectRoot, state);
-    printSuccess(`${key} = ${boolVal ? 'ON' : 'OFF'}`);
-}
-// ============================================================
-// Internal: Called by hooks
-// ============================================================
-/**
- * Prepare task context for a sub-agent.
- * Queries daemon IPC (or disk fallback) for scope data and writes task-context.json.
- */
-async function taskStart(options) {
-    const projectRoot = await findProjectRoot();
-    if (!projectRoot)
-        throw new Error('Not a TimSquad project');
-    const scopePaths = options.scope?.split(',').map(s => s.trim()) || [];
-    if (scopePaths.length === 0) {
-        printSuccess(`Task started for ${options.agent} (no scope filter)`);
-        return;
-    }
-    // SCR (Single Change Rule) enforcement: detect compound tasks (11-B)
-    const scrResult = analyzeScopeComplexity(scopePaths);
-    if (scrResult.compound) {
-        console.log(colors.warning(`\n  ⚠ SCR Warning: ${scrResult.reason}`));
-        if (scrResult.groups.length > 1) {
-            console.log(colors.dim('    Suggested splits:'));
-            scrResult.groups.forEach((g, i) => {
-                console.log(colors.dim(`      ${i + 1}. [${g.module}] ${g.paths.join(', ')}`));
-            });
-        }
-        console.log(colors.dim('    Consider splitting into sequential single-scope tasks.\n'));
-    }
-    // Prerequisite auto-validation (11-A): check agent prerequisites against compiled specs
-    await validateAgentPrerequisites(projectRoot, options.agent);
-    // 데몬 IPC로 scope 쿼리
-    let scopedData = null;
-    try {
-        const response = await queryDaemon(projectRoot, 'scope', { paths: scopePaths });
-        scopedData = response.context;
-    }
-    catch {
-        // 데몬 미실행 — fallback으로 MetaCache 사용
-        const { MetaCache } = await import('../daemon/meta-cache.js');
-        const cache = new MetaCache(projectRoot);
-        await cache.load();
-        scopedData = cache.filterByScope(scopePaths);
-    }
-    if (scopedData && Object.keys(scopedData.files).length > 0) {
-        const ctxPath = await writeContext(projectRoot, options.agent, scopedData);
-        printSuccess(`Task context created for ${options.agent}`);
-        printKeyValue('  Context', ctxPath);
-        printKeyValue('  Files', String(Object.keys(scopedData.files).length));
-    }
-    else {
-        console.log(colors.dim(`  No files matched scope: ${scopePaths.join(', ')}`));
-    }
-}
-/**
- * Track a completed task in workflow state.
- * Called by SubagentStop hook: tsq workflow track-task <agent> <task-log-path>
- * Creates L2 sequence log inline when sequence is completed (no daemon dependency).
- */
-async function trackTask(agent, taskLogPath) {
-    const projectRoot = await findProjectRoot();
-    if (!projectRoot)
-        return;
-    const state = await loadWorkflowState(projectRoot);
-    // Find matching sequence
-    const seqId = findSequenceForAgent(state, agent);
-    if (!seqId)
-        return; // No match or ambiguous — skip silently
-    const seq = state.sequences[seqId];
-    seq.completed_tasks.push({
-        agent,
-        task_log: taskLogPath,
-        completed_at: getTimestamp(),
-    });
-    // Update status
-    if (seq.status === 'pending') {
-        seq.status = 'in_progress';
-    }
-    if (isSequenceComplete(seq)) {
-        seq.status = 'completed';
-        // Inline L2 creation — don't wait for daemon or SessionEnd
-        if (state.automation.sequence_log && !seq.l2_created) {
-            try {
-                const entry = await buildSequenceLogData(projectRoot, seqId, {
-                    phase: seq.phase,
-                    report: seq.report_path || '(auto) no report',
-                    verdict: 'proceed',
-                });
-                const seqDir = getSequencesDir(projectRoot);
-                await fs.ensureDir(seqDir);
-                await fs.writeJson(path.join(seqDir, `${seqId}.json`), entry, { spaces: 2 });
-                seq.l2_created = true;
-                await appendWorkflowLog(projectRoot, `[AUTO] L2 sequence log created: ${seqId}`);
-            }
-            catch { /* L2 creation failure — checkAndAutomate fallback will retry */ }
-        }
-    }
-    await saveWorkflowState(projectRoot, state);
-}
-/**
- * Check workflow state and auto-create L2/L3/gate/retro.
- * Called by SessionEnd hook: tsq workflow check
- */
-async function checkAndAutomate() {
-    const projectRoot = await findProjectRoot();
-    if (!projectRoot)
-        return;
-    const state = await loadWorkflowState(projectRoot);
-    let stateChanged = false;
-    // 1. Auto-create L2 for completed sequences
-    if (state.automation.sequence_log) {
-        for (const [seqId, seq] of Object.entries(state.sequences)) {
-            if (seq.status === 'completed' && !seq.l2_created) {
-                try {
-                    const entry = await buildSequenceLogData(projectRoot, seqId, {
-                        phase: seq.phase,
-                        report: seq.report_path || `(auto) no report`,
-                        verdict: 'proceed',
-                    });
-                    const seqDir = getSequencesDir(projectRoot);
-                    await fs.ensureDir(seqDir);
-                    await fs.writeJson(path.join(seqDir, `${seqId}.json`), entry, { spaces: 2 });
-                    seq.l2_created = true;
-                    stateChanged = true;
-                    // Log the automation
-                    await appendWorkflowLog(projectRoot, `[AUTO] L2 sequence log created: ${seqId}`);
-                }
-                catch { /* skip on error */ }
-            }
-        }
-    }
-    // 2. Check if all sequences in current phase are completed
-    if (state.current_phase && (state.automation.phase_log || state.automation.phase_gate)) {
-        const phaseSeqs = state.current_phase.sequences;
-        const allCompleted = phaseSeqs.length > 0 && phaseSeqs.every(id => {
-            const seq = state.sequences[id];
-            return seq && seq.status === 'completed' && seq.l2_created;
-        });
-        if (allCompleted) {
-            const phaseId = state.current_phase.id;
-            // 2a. Auto phase gate
-            if (state.automation.phase_gate) {
-                try {
-                    const gateResult = await buildPhaseGateData(projectRoot, phaseId);
-                    await appendWorkflowLog(projectRoot, `[AUTO] Phase gate ${phaseId}: ${gateResult.can_transition ? 'PASSED' : 'BLOCKED'}`);
-                }
-                catch { /* skip */ }
-            }
-            // 2b. Auto create L3 phase log
-            if (state.automation.phase_log) {
-                const phaseDir = getPhasesDir(projectRoot);
-                const phaseLogPath = path.join(phaseDir, `${phaseId}.json`);
-                if (!await fs.pathExists(phaseLogPath)) {
-                    try {
-                        const phaseLog = await buildPhaseLogData(projectRoot, phaseId, phaseSeqs);
-                        await fs.ensureDir(phaseDir);
-                        await fs.writeJson(phaseLogPath, phaseLog, { spaces: 2 });
-                        await appendWorkflowLog(projectRoot, `[AUTO] L3 phase log created: ${phaseId}`);
-                        stateChanged = true;
-                    }
-                    catch { /* skip */ }
-                }
-            }
-            // 2c. Auto retro (basic KPT collection)
-            if (state.automation.retro) {
-                try {
-                    await autoRetro(projectRoot, phaseId, phaseSeqs, state);
-                    await appendWorkflowLog(projectRoot, `[AUTO] Retro generated: ${phaseId}`);
-                }
-                catch { /* skip */ }
-            }
-        }
-    }
-    // 3. Auto metrics (already handled by auto-metrics.sh, but log)
-    if (state.automation.metrics) {
-        // auto-metrics.sh handles this — no-op here
-    }
-    // 4. Pending feedback cleanup
-    if (state.automation.feedback) {
-        const feedbackDir = path.join(projectRoot, '.timsquad', 'feedback');
-        const cleanedPending = [];
-        for (const fbId of state.pending_feedback || []) {
-            const fbPath = path.join(feedbackDir, `${fbId}.json`);
-            if (await fs.pathExists(fbPath)) {
-                try {
-                    const fb = await fs.readJson(fbPath);
-                    if (fb.status === 'open' || fb.status === 'in_review') {
-                        cleanedPending.push(fbId);
-                    }
-                }
-                catch { /* skip */ }
-            }
-        }
-        if (cleanedPending.length !== (state.pending_feedback || []).length) {
-            state.pending_feedback = cleanedPending;
-            stateChanged = true;
-        }
-        if (cleanedPending.length > 0) {
-            await appendWorkflowLog(projectRoot, `[AUTO] ${cleanedPending.length} pending feedback(s) blocking phase gate`);
-        }
-    }
-    if (stateChanged) {
-        await saveWorkflowState(projectRoot, state);
-    }
-}
-// ============================================================
-// Internal helpers
-// ============================================================
-export async function buildPhaseLogData(projectRoot, phaseId, seqIds) {
-    const seqDir = getSequencesDir(projectRoot);
-    const now = getTimestamp();
-    const seqLogs = [];
-    let completed = 0, blocked = 0;
-    for (const id of seqIds) {
-        const seqPath = path.join(seqDir, `${id}.json`);
-        if (await fs.pathExists(seqPath)) {
-            const data = await fs.readJson(seqPath);
-            seqLogs.push(data);
-            if (data.execution.status === 'completed')
-                completed++;
-            else
-                blocked++;
-        }
-        else {
-            blocked++;
-        }
-    }
-    let totalTasks = 0, totalSuccess = 0, totalRework = 0, totalFiles = 0;
-    let totalIssues1 = 0, totalIssues2 = 0, totalIssues3 = 0;
-    const durations = [];
-    for (const seq of seqLogs) {
-        totalTasks += seq.tasks.total;
-        totalSuccess += seq.tasks.success;
-        totalRework += seq.tasks.rework;
-        durations.push(seq.execution.duration_ms);
-        for (const axis of Object.values(seq.analysis)) {
-            const r = axis;
-            for (const issue of r.issues || []) {
-                if (issue.level === 1)
-                    totalIssues1++;
-                else if (issue.level === 2)
-                    totalIssues2++;
-                else
-                    totalIssues3++;
-            }
-        }
-    }
-    for (const seqId of seqIds) {
-        const taskLogs = await loadSequenceTaskLogs(projectRoot, seqId);
-        for (const { data } of taskLogs) {
-            totalFiles += data.mechanical?.files?.length || 0;
-        }
-    }
-    const timestamps = seqLogs
-        .map(s => [new Date(s.execution.started_at).getTime(), new Date(s.execution.completed_at).getTime()])
-        .flat()
-        .filter(t => t > 0);
-    const leadTime = timestamps.length >= 2 ? Math.max(...timestamps) - Math.min(...timestamps) : 0;
-    return {
-        schema_version: LOG_SCHEMA_VERSION,
-        trace: { phase_id: phaseId },
-        execution: {
-            status: blocked > 0 ? 'aborted' : 'completed',
-            started_at: seqLogs[0]?.execution.started_at || now,
-            completed_at: now,
-            duration_ms: leadTime,
-            sessions_count: seqLogs.length,
-        },
-        sequences: { total: seqIds.length, completed, blocked, ids: seqIds },
-        aggregate_metrics: {
-            total_tasks: totalTasks,
-            task_success_rate: totalTasks > 0 ? totalSuccess / totalTasks : 0,
-            task_rework_rate: totalTasks > 0 ? totalRework / totalTasks : 0,
-            total_files_changed: totalFiles,
-            total_issues: { level_1: totalIssues1, level_2: totalIssues2, level_3: totalIssues3 },
-            ssot_conformance_rate: 0,
-            mean_sequence_duration_ms: durations.length > 0 ? durations.reduce((a, b) => a + b, 0) / durations.length : 0,
-        },
-        dora_derived: {
-            lead_time_ms: leadTime,
-            change_failure_rate: totalTasks > 0 ? (totalTasks - totalSuccess) / totalTasks : 0,
-            mean_recovery_time_ms: null,
-        },
-        planning: {
-            original_sequences: seqIds,
-            added_sequences: [],
-            removed_sequences: [],
-            scope_changes: [],
-            plan_adherence_rate: 1,
-        },
-        retrospective: { keep: [], problem: [], try: [] },
-        knowledge_extracted: [],
-    };
-}
-/**
- * Auto-generate a basic retrospective from task/sequence data
- */
-async function autoRetro(projectRoot, phaseId, seqIds, state) {
-    const retroDir = path.join(projectRoot, '.timsquad', 'retrospective', 'cycles');
-    await fs.ensureDir(retroDir);
-    const retroPath = path.join(retroDir, `${phaseId}-auto.md`);
-    if (await fs.pathExists(retroPath))
-        return; // Already exists
-    const keep = [];
-    const problem = [];
-    const tryItems = [];
-    // Analyze task logs for patterns
-    let totalTasks = 0, tasksWithSemantic = 0, totalRework = 0;
-    for (const seqId of seqIds) {
-        const taskLogs = await loadSequenceTaskLogs(projectRoot, seqId);
-        for (const { data } of taskLogs) {
-            totalTasks++;
-            if (hasSemantic(data.semantic))
-                tasksWithSemantic++;
-            if (data.semantic?.issues?.length) {
-                for (const issue of data.semantic.issues) {
-                    if (issue.level >= 2) {
-                        problem.push(`[${seqId}] ${issue.description}`);
-                    }
-                }
-            }
-        }
-        const seq = state.sequences[seqId];
-        if (seq) {
-            const reworkCount = seq.completed_tasks.length - seq.expected_agents.length;
-            if (reworkCount > 0)
-                totalRework += reworkCount;
-        }
-    }
-    // Generate observations
-    const semanticCoverage = totalTasks > 0 ? Math.round((tasksWithSemantic / totalTasks) * 100) : 0;
-    if (semanticCoverage >= 80) {
-        keep.push(`Semantic coverage ${semanticCoverage}% — good documentation discipline`);
-    }
-    else if (semanticCoverage < 50) {
-        problem.push(`Semantic coverage ${semanticCoverage}% — agents not consistently enriching logs`);
-        tryItems.push('Enforce tsq log enrich in agent protocols');
-    }
-    if (totalRework === 0) {
-        keep.push('No rework detected — first-pass quality was high');
-    }
-    else {
-        problem.push(`${totalRework} rework tasks detected`);
-        tryItems.push('Review SSOT alignment before implementation starts');
-    }
-    if (seqIds.length > 0) {
-        keep.push(`${seqIds.length} sequences completed in phase ${phaseId}`);
-    }
-    // Write retro markdown
-    const content = `# Retrospective: ${phaseId} (Auto-generated)
-
-> Generated at ${getTimestamp()} by tsq workflow check
-
-## Keep
-${keep.map(k => `- ${k}`).join('\n') || '- (none detected)'}
-
-## Problem
-${problem.map(p => `- ${p}`).join('\n') || '- (none detected)'}
-
-## Try
-${tryItems.map(t => `- ${t}`).join('\n') || '- (no suggestions)'}
-
----
-
-## Metrics
-- Total tasks: ${totalTasks}
-- Semantic coverage: ${semanticCoverage}%
-- Rework tasks: ${totalRework}
-- Sequences: ${seqIds.join(', ')}
-`;
-    await fs.writeFile(retroPath, content, 'utf-8');
-}
-/**
- * Append to workflow automation log (for debugging/auditing)
- */
-async function appendWorkflowLog(projectRoot, message) {
-    const logDir = path.join(projectRoot, '.timsquad', 'logs');
-    const logFile = path.join(logDir, 'workflow-automation.log');
-    await fs.ensureDir(logDir);
-    const line = `${getTimestamp()} ${message}\n`;
-    await fs.appendFile(logFile, line, 'utf-8');
-}
-function analyzeScopeComplexity(scopePaths) {
-    // Group by logical module (2nd-level dir or top-level for shallow paths)
-    const moduleMap = new Map();
-    for (const p of scopePaths) {
-        const parts = p.split('/').filter(Boolean);
-        // Use first 2 segments as module key (e.g. "src/commands", "src/lib", "tests/unit")
-        const moduleKey = parts.length >= 2 ? `${parts[0]}/${parts[1]}` : parts[0] || p;
-        if (!moduleMap.has(moduleKey))
-            moduleMap.set(moduleKey, []);
-        moduleMap.get(moduleKey).push(p);
-    }
-    const groups = [...moduleMap.entries()].map(([module, paths]) => ({ module, paths }));
-    // Exclude test-related modules from independent module count
-    const nonTestModules = groups.filter(g => !g.module.startsWith('tests/') && !g.module.startsWith('__tests__/'));
-    const topLevelDirs = new Set(scopePaths.map(p => p.split('/')[0]));
-    if (nonTestModules.length > 2) {
-        return {
-            compound: true,
-            reason: `Scope spans ${nonTestModules.length} independent modules (${nonTestModules.map(g => g.module).join(', ')})`,
-            groups,
-        };
-    }
-    if (topLevelDirs.size > 2) {
-        return {
-            compound: true,
-            reason: `Scope spans ${topLevelDirs.size} top-level directories (${[...topLevelDirs].join(', ')})`,
-            groups,
-        };
-    }
-    return { compound: false, reason: '', groups };
-}
-/**
- * Validate agent prerequisites against compiled specs (11-A).
- * Checks: agent file exists, prerequisites resolved, specs not stale.
- */
-async function validateAgentPrerequisites(projectRoot, agent) {
-    const agentPath = path.join(projectRoot, '.claude', 'agents', `${agent}.md`);
-    if (!await fs.pathExists(agentPath))
-        return; // No agent file — skip validation
-    const agentContent = await fs.readFile(agentPath, 'utf-8');
-    const prereqs = parseAgentPrerequisites(agentContent);
-    if (prereqs.length === 0)
-        return; // No prerequisites declared
-    const controllerDir = path.join(projectRoot, '.claude', 'skills', 'controller');
-    const manifest = await loadManifest(controllerDir);
-    if (!manifest) {
-        console.log(colors.warning('\n  ⚠ Prerequisite Warning: No compile manifest found'));
-        console.log(colors.dim('    Run `tsq compile` before delegating tasks.\n'));
-        return;
-    }
-    // Check missing prerequisites
-    const compiledSources = new Set(manifest.entries.map(e => e.source.replace('ssot/', '').replace('.md', '')));
-    const missing = prereqs.filter(p => !compiledSources.has(p));
-    if (missing.length > 0) {
-        console.log(colors.warning(`\n  ⚠ Missing prerequisites for agent "${agent}":`));
-        for (const m of missing) {
-            console.log(colors.dim(`    - ${m} (not compiled)`));
-        }
-        console.log(colors.dim('    Run `tsq compile` to resolve.\n'));
-    }
-    // Check stale specs
-    const staleItems = await checkStale(projectRoot, controllerDir);
-    const relevantStale = staleItems.filter(s => {
-        const source = s.source.replace('ssot/', '').replace('.md', '');
-        return prereqs.includes(source) || s.source === '*';
-    });
-    if (relevantStale.length > 0) {
-        console.log(colors.warning(`\n  ⚠ Stale specs detected for agent "${agent}":`));
-        for (const s of relevantStale) {
-            console.log(colors.dim(`    - ${s.source}: ${s.reason}`));
-        }
-        console.log(colors.dim('    Run `tsq compile` to refresh.\n'));
-    }
-}
-function formatAutomation(auto) {
-    const enabled = Object.entries(auto).filter(([, v]) => v).map(([k]) => k);
-    return enabled.length > 0 ? enabled.join(', ') : 'all OFF';
-}
-//# sourceMappingURL=workflow.js.map