timsquad 2.1.0 → 3.4.0

package/dist/commands/log.js

@@ -4,7 +4,9 @@ import { colors, printHeader, printError, printSuccess, printKeyValue } from '..
 import { findProjectRoot } from '../lib/project.js';
 import { exists, readFile, writeFile, listFiles } from '../utils/fs.js';
 import { getDateString, getTimeString, getTimestamp } from '../utils/date.js';
+import { loadWorkflowState } from '../lib/workflow-state.js';
 const LOG_TYPES = ['work', 'decision', 'error', 'feedback', 'handoff'];
+const LOG_SCHEMA_VERSION = '1.0.0';
 export function registerLogCommand(program) {
     const logCmd = program
         .command('log')
@@ -102,6 +104,173 @@ export function registerLogCommand(program) {
             process.exit(1);
         }
     });
+    // ── tsq log enrich <agent> ──
+    logCmd
+        .command('enrich <agent>')
+        .description('Enrich latest task log with semantic data')
+        .requiredOption('--json <data>', 'Semantic data as JSON string')
+        .action(async (agent, options) => {
+        try {
+            await enrichTaskLog(agent, options.json);
+        }
+        catch (error) {
+            printError(error.message);
+            process.exit(1);
+        }
+    });
+    // ── tsq log task <subcommand> ──
+    const taskCmd = logCmd
+        .command('task')
+        .description('L1 Task log management');
+    taskCmd
+        .command('list')
+        .description('List task logs')
+        .option('--agent <name>', 'Filter by agent')
+        .action(async (options) => {
+        try {
+            await listTaskLogs(options.agent);
+        }
+        catch (error) {
+            printError(error.message);
+            process.exit(1);
+        }
+    });
+    taskCmd
+        .command('view <file>')
+        .description('View a task log')
+        .action(async (file) => {
+        try {
+            await viewTaskLog(file);
+        }
+        catch (error) {
+            printError(error.message);
+            process.exit(1);
+        }
+    });
+    taskCmd
+        .command('stats')
+        .description('Task log statistics')
+        .action(async () => {
+        try {
+            await showTaskStats();
+        }
+        catch (error) {
+            printError(error.message);
+            process.exit(1);
+        }
+    });
+    // ── tsq log sequence <subcommand> ──
+    const seqCmd = logCmd
+        .command('sequence')
+        .description('L2 Sequence log management');
+    seqCmd
+        .command('list')
+        .description('List sequence logs')
+        .action(async () => {
+        try {
+            await listSequenceLogs();
+        }
+        catch (error) {
+            printError(error.message);
+            process.exit(1);
+        }
+    });
+    seqCmd
+        .command('view <seq-id>')
+        .description('View a sequence log')
+        .action(async (seqId) => {
+        try {
+            await viewSequenceLog(seqId);
+        }
+        catch (error) {
+            printError(error.message);
+            process.exit(1);
+        }
+    });
+    seqCmd
+        .command('create <seq-id>')
+        .description('Create sequence log from task logs')
+        .requiredOption('--phase <id>', 'Phase ID')
+        .requiredOption('--report <path>', 'Architect report path')
+        .option('--verdict <v>', 'proceed or hold', 'proceed')
+        .option('--conditions <c>', 'Comma-separated conditions')
+        .action(async (seqId, options) => {
+        try {
+            await createSequenceLog(seqId, options);
+        }
+        catch (error) {
+            printError(error.message);
+            process.exit(1);
+        }
+    });
+    seqCmd
+        .command('check <seq-id>')
+        .description('Check task log completeness for a sequence')
+        .action(async (seqId) => {
+        try {
+            await checkSequence(seqId);
+        }
+        catch (error) {
+            printError(error.message);
+            process.exit(1);
+        }
+    });
+    // ── tsq log phase <subcommand> ──
+    const phaseCmd = logCmd
+        .command('phase')
+        .description('L3 Phase log management');
+    phaseCmd
+        .command('list')
+        .description('List phase logs')
+        .action(async () => {
+        try {
+            await listPhaseLogs();
+        }
+        catch (error) {
+            printError(error.message);
+            process.exit(1);
+        }
+    });
+    phaseCmd
+        .command('view <phase-id>')
+        .description('View a phase log')
+        .action(async (phaseId) => {
+        try {
+            await viewPhaseLog(phaseId);
+        }
+        catch (error) {
+            printError(error.message);
+            process.exit(1);
+        }
+    });
+    phaseCmd
+        .command('create <phase-id>')
+        .description('Create phase log')
+        .requiredOption('--sequences <ids>', 'Comma-separated sequence IDs')
+        .option('--retro-keep <items>', 'Retrospective: keep (comma-separated)')
+        .option('--retro-problem <items>', 'Retrospective: problems (comma-separated)')
+        .option('--retro-try <items>', 'Retrospective: try (comma-separated)')
+        .action(async (phaseId, options) => {
+        try {
+            await createPhaseLog(phaseId, options);
+        }
+        catch (error) {
+            printError(error.message);
+            process.exit(1);
+        }
+    });
+    phaseCmd
+        .command('gate <phase-id>')
+        .description('Check phase transition gate')
+        .action(async (phaseId) => {
+        try {
+            await checkPhaseGate(phaseId);
+        }
+        catch (error) {
+            printError(error.message);
+            process.exit(1);
+        }
+    });
 }
 async function addLog(agent, type, message) {
     const projectRoot = await findProjectRoot();
@@ -468,4 +637,800 @@ function formatSize(bytes) {
         return `${(bytes / 1024).toFixed(1)}KB`;
     return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
 }
+// ============================================================
+// Task Log Helpers
+// ============================================================
+export function getTasksDir(projectRoot) {
+    return path.join(projectRoot, '.timsquad', 'logs', 'tasks');
+}
+export function getSequencesDir(projectRoot) {
+    return path.join(projectRoot, '.timsquad', 'logs', 'sequences');
+}
+export function getPhasesDir(projectRoot) {
+    return path.join(projectRoot, '.timsquad', 'logs', 'phases');
+}
+async function findLatestTaskLog(projectRoot, agent) {
+    const tasksDir = getTasksDir(projectRoot);
+    if (!await exists(tasksDir))
+        return null;
+    // Flat structure: *-{agent}.json
+    const flatFiles = await listFiles(`*-${agent}.json`, tasksDir);
+    // Nested structure: look inside subdirectories
+    const nestedFiles = [];
+    try {
+        const entries = await fs.readdir(tasksDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                const subFiles = await listFiles(`*-${agent}.json`, path.join(tasksDir, entry.name));
+                nestedFiles.push(...subFiles.map(f => path.join(entry.name, f)));
+            }
+        }
+    }
+    catch { /* no subdirectories */ }
+    const allFiles = [...flatFiles, ...nestedFiles].sort().reverse();
+    return allFiles.length > 0 ? allFiles[0] : null;
+}
+export async function loadAllTaskLogs(projectRoot, agent) {
+    const tasksDir = getTasksDir(projectRoot);
+    if (!await exists(tasksDir))
+        return [];
+    const pattern = agent ? `*-${agent}.json` : '*.json';
+    const files = await listFiles(pattern, tasksDir);
+    const results = [];
+    for (const file of files) {
+        try {
+            const data = await fs.readJson(path.join(tasksDir, file));
+            results.push({ file, data });
+        }
+        catch { /* skip malformed */ }
+    }
+    return results.sort((a, b) => a.file.localeCompare(b.file));
+}
+function mergeSemantic(existing, incoming) {
+    return {
+        summary: incoming.summary ?? existing.summary,
+        techniques: incoming.techniques ?? existing.techniques,
+        ssot_refs: incoming.ssot_refs ?? existing.ssot_refs,
+        decisions: incoming.decisions ?? existing.decisions,
+        issues: incoming.issues ?? existing.issues,
+    };
+}
+export function hasSemantic(sem) {
+    if (!sem)
+        return false;
+    return !!(sem.summary || sem.techniques?.length || sem.ssot_refs?.length ||
+        sem.decisions?.length || sem.issues?.length);
+}
+// ============================================================
+// Step 2: tsq log enrich
+// ============================================================
+async function enrichTaskLog(agent, jsonData) {
+    const projectRoot = await findProjectRoot();
+    if (!projectRoot)
+        throw new Error('Not a TimSquad project');
+    const latestFile = await findLatestTaskLog(projectRoot, agent);
+    if (!latestFile) {
+        throw new Error(`No task log found for agent: ${agent}`);
+    }
+    const filePath = path.join(getTasksDir(projectRoot), latestFile);
+    let incoming;
+    try {
+        incoming = JSON.parse(jsonData);
+    }
+    catch {
+        throw new Error('Invalid JSON data');
+    }
+    const taskLog = await fs.readJson(filePath);
+    taskLog.semantic = mergeSemantic(taskLog.semantic || {}, incoming);
+    await fs.writeJson(filePath, taskLog, { spaces: 2 });
+    printSuccess(`Enriched: ${latestFile}`);
+    if (taskLog.semantic.summary) {
+        printKeyValue('Summary', taskLog.semantic.summary);
+    }
+    if (taskLog.semantic.techniques?.length) {
+        printKeyValue('Techniques', taskLog.semantic.techniques.map(t => t.name).join(', '));
+    }
+    // Auto-feedback: L2/L3 이슈 → 자동 피드백 라우팅
+    await autoFeedbackFromIssues(projectRoot, taskLog.semantic);
+}
+// ============================================================
+// Step 3: tsq log task (L1 views)
+// ============================================================
+async function listTaskLogs(agent) {
+    const projectRoot = await findProjectRoot();
+    if (!projectRoot)
+        throw new Error('Not a TimSquad project');
+    const logs = await loadAllTaskLogs(projectRoot, agent);
+    if (logs.length === 0) {
+        console.log(colors.dim('No task logs found'));
+        return;
+    }
+    printHeader(`Task Logs (${logs.length})`);
+    for (const { file, data } of logs.reverse()) {
+        const sem = hasSemantic(data.semantic) ? '✓' : '○';
+        const status = data.status === 'completed' ? colors.success('✓') : colors.error('✗');
+        const agentName = colors.agent(data.agent || '?');
+        const date = file.slice(0, 10);
+        console.log(`  ${status} ${sem} ${colors.dim(date)} ${agentName}  ${colors.dim(file)}`);
+        if (data.semantic?.summary) {
+            console.log(`      ${colors.dim(data.semantic.summary.slice(0, 80))}`);
+        }
+    }
+}
+async function viewTaskLog(file) {
+    const projectRoot = await findProjectRoot();
+    if (!projectRoot)
+        throw new Error('Not a TimSquad project');
+    const filePath = path.join(getTasksDir(projectRoot), file);
+    if (!await exists(filePath)) {
+        throw new Error(`Task log not found: ${file}`);
+    }
+    const data = await fs.readJson(filePath);
+    printHeader(`Task Log: ${file}`);
+    // Basic info
+    printKeyValue('Agent', data.agent);
+    printKeyValue('Status', data.status);
+    printKeyValue('Completed', data.completed_at || 'N/A');
+    if (data.duration_ms)
+        printKeyValue('Duration', `${(data.duration_ms / 1000).toFixed(1)}s`);
+    // Mechanical
+    console.log(colors.subheader('\n  Mechanical'));
+    if (data.mechanical?.files?.length) {
+        for (const f of data.mechanical.files) {
+            console.log(`    ${f.action}: ${colors.path(f.path)}`);
+        }
+    }
+    else {
+        console.log(colors.dim('    (no file changes)'));
+    }
+    // Semantic
+    console.log(colors.subheader('\n  Semantic'));
+    if (hasSemantic(data.semantic)) {
+        if (data.semantic.summary)
+            printKeyValue('  Summary', data.semantic.summary);
+        if (data.semantic.techniques?.length) {
+            console.log('    Techniques:');
+            for (const t of data.semantic.techniques) {
+                console.log(`      - ${t.name}: ${colors.dim(t.reason)}`);
+            }
+        }
+        if (data.semantic.ssot_refs?.length) {
+            console.log('    SSOT Refs:');
+            for (const r of data.semantic.ssot_refs) {
+                const icon = r.status === 'aligned' ? '✓' : r.status === 'misaligned' ? '✗' : '~';
+                console.log(`      ${icon} ${r.doc} → ${r.section} (${r.status})`);
+            }
+        }
+        if (data.semantic.decisions?.length) {
+            console.log('    Decisions:');
+            for (const d of data.semantic.decisions) {
+                console.log(`      - ${d.decision}`);
+                console.log(`        ${colors.dim(d.rationale)}`);
+            }
+        }
+        if (data.semantic.issues?.length) {
+            console.log('    Issues:');
+            for (const i of data.semantic.issues) {
+                console.log(`      L${i.level}: ${i.description}`);
+            }
+        }
+    }
+    else {
+        console.log(colors.dim('    (empty — run tsq log enrich to populate)'));
+    }
+}
+async function showTaskStats() {
+    const projectRoot = await findProjectRoot();
+    if (!projectRoot)
+        throw new Error('Not a TimSquad project');
+    const logs = await loadAllTaskLogs(projectRoot);
+    if (logs.length === 0) {
+        console.log(colors.dim('No task logs found'));
+        return;
+    }
+    const stats = {
+        total: logs.length,
+        completed: 0, failed: 0, successRate: 0,
+        byAgent: {},
+        totalFilesChanged: 0, avgFilesPerTask: 0, fileActions: {},
+        withErrors: 0, errorTypes: {},
+        withSemantic: 0, semanticCoverage: 0,
+    };
+    for (const { data } of logs) {
+        // Status
+        if (data.status === 'completed' || data.status === 'success')
+            stats.completed++;
+        else
+            stats.failed++;
+        // By agent
+        const a = data.agent || 'unknown';
+        if (!stats.byAgent[a])
+            stats.byAgent[a] = { total: 0, completed: 0, failed: 0 };
+        stats.byAgent[a].total++;
+        if (data.status === 'completed' || data.status === 'success')
+            stats.byAgent[a].completed++;
+        else
+            stats.byAgent[a].failed++;
+        // Files
+        const files = data.mechanical?.files || [];
+        stats.totalFilesChanged += files.length;
+        for (const f of files) {
+            stats.fileActions[f.action] = (stats.fileActions[f.action] || 0) + 1;
+        }
+        // Errors
+        if (data.error) {
+            stats.withErrors++;
+            const t = data.error.type || 'unknown';
+            stats.errorTypes[t] = (stats.errorTypes[t] || 0) + 1;
+        }
+        // Semantic
+        if (hasSemantic(data.semantic))
+            stats.withSemantic++;
+    }
+    stats.successRate = Math.round((stats.completed / stats.total) * 100);
+    stats.avgFilesPerTask = Math.round((stats.totalFilesChanged / stats.total) * 10) / 10;
+    stats.semanticCoverage = Math.round((stats.withSemantic / stats.total) * 100);
+    printHeader('Task Log Statistics');
+    printKeyValue('Total Tasks', String(stats.total));
+    printKeyValue('Success Rate', `${stats.successRate}% (${stats.completed}/${stats.total})`);
+    printKeyValue('Semantic Coverage', `${stats.semanticCoverage}% (${stats.withSemantic}/${stats.total})`);
+    printKeyValue('Files Changed', `${stats.totalFilesChanged} (avg ${stats.avgFilesPerTask}/task)`);
+    if (Object.keys(stats.byAgent).length > 1) {
+        console.log(colors.subheader('\n  By Agent'));
+        for (const [agent, s] of Object.entries(stats.byAgent)) {
+            const rate = Math.round((s.completed / s.total) * 100);
+            console.log(`    ${colors.agent(agent)}: ${s.total} tasks, ${rate}% success`);
+        }
+    }
+    if (stats.withErrors > 0) {
+        console.log(colors.subheader('\n  Errors'));
+        printKeyValue('  Tasks with errors', String(stats.withErrors));
+        for (const [type, count] of Object.entries(stats.errorTypes)) {
+            console.log(`    ${type}: ${count}`);
+        }
+    }
+}
+// ============================================================
+// Step 4: tsq log sequence (L2)
+// ============================================================
+export async function loadSequenceTaskLogs(projectRoot, seqId) {
+    const tasksDir = getTasksDir(projectRoot);
+    if (!await exists(tasksDir))
+        return [];
+    const results = [];
+    // 1. Check nested directory: tasks/{SEQ-ID}/*.json
+    const seqDir = path.join(tasksDir, seqId);
+    if (await exists(seqDir)) {
+        const files = await listFiles('*.json', seqDir);
+        for (const file of files) {
+            try {
+                const data = await fs.readJson(path.join(seqDir, file));
+                results.push({ file: path.join(seqId, file), data });
+            }
+            catch { /* skip */ }
+        }
+    }
+    // 2. Check flat files with trace.sequence_id matching
+    const flatFiles = await listFiles('*.json', tasksDir);
+    for (const file of flatFiles) {
+        try {
+            const data = await fs.readJson(path.join(tasksDir, file));
+            if (data.trace?.sequence_id === seqId) {
+                // Avoid duplicates from nested
+                if (!results.some(r => r.file === file)) {
+                    results.push({ file, data });
+                }
+            }
+        }
+        catch { /* skip */ }
+    }
+    return results.sort((a, b) => a.file.localeCompare(b.file));
+}
+function aggregateSequenceStats(taskLogs) {
+    let success = 0, failure = 0, error = 0, rework = 0;
+    const durations = [];
+    for (const { file, data } of taskLogs) {
+        const s = data.status;
+        if (s === 'completed' || s === 'success')
+            success++;
+        else if (s === 'failure')
+            failure++;
+        else if (s === 'error')
+            error++;
+        if (data.duration_ms)
+            durations.push(data.duration_ms);
+        // Simple rework detection: same agent + file overlap with earlier task
+        const changedFiles = new Set(data.mechanical?.files?.map(f => f.path) || []);
+        for (const other of taskLogs) {
+            if (other.file === file)
+                continue;
+            if (other.data.agent === data.agent && other.file < file) {
+                const otherFiles = other.data.mechanical?.files?.map(f => f.path) || [];
+                if (otherFiles.some(f => changedFiles.has(f))) {
+                    rework++;
+                    break;
+                }
+            }
+        }
+    }
+    const total = taskLogs.length;
+    return {
+        total, success, failure, error, rework,
+        first_pass_success_rate: total > 0 ? Math.round(((success) / total) * 100) / 100 : 0,
+        final_success_rate: total > 0 ? Math.round(((success) / total) * 100) / 100 : 0,
+        durations,
+    };
+}
+export function makeAxisPlaceholder() {
+    return { verdict: 'n/a', details: 'See architect report', issues: [] };
+}
+async function listSequenceLogs() {
+    const projectRoot = await findProjectRoot();
+    if (!projectRoot)
+        throw new Error('Not a TimSquad project');
+    const seqDir = getSequencesDir(projectRoot);
+    if (!await exists(seqDir)) {
+        console.log(colors.dim('No sequence logs found'));
+        return;
+    }
+    const files = await listFiles('*.json', seqDir);
+    if (files.length === 0) {
+        console.log(colors.dim('No sequence logs found'));
+        return;
+    }
+    printHeader(`Sequence Logs (${files.length})`);
+    for (const file of files.sort()) {
+        try {
+            const data = await fs.readJson(path.join(seqDir, file));
+            const seqId = data.trace.sequence_id;
+            const status = data.execution.status;
+            const verdict = data.verdict.proceed ? colors.success('PROCEED') : colors.error('HOLD');
+            const tasks = `${data.tasks.success}/${data.tasks.total} tasks`;
+            console.log(`  ${verdict} ${colors.agent(seqId)} [${status}] ${tasks} ${colors.dim(data.trace.phase_id)}`);
+        }
+        catch {
+            console.log(`  ${colors.dim(file)} (unreadable)`);
+        }
+    }
+}
+async function viewSequenceLog(seqId) {
+    const projectRoot = await findProjectRoot();
+    if (!projectRoot)
+        throw new Error('Not a TimSquad project');
+    const filePath = path.join(getSequencesDir(projectRoot), `${seqId}.json`);
+    if (!await exists(filePath)) {
+        throw new Error(`Sequence log not found: ${seqId}`);
+    }
+    const data = await fs.readJson(filePath);
+    printHeader(`Sequence: ${seqId}`);
+    printKeyValue('Phase', data.trace.phase_id);
+    printKeyValue('Status', data.execution.status);
+    printKeyValue('Duration', `${(data.execution.duration_ms / 1000).toFixed(1)}s`);
+    printKeyValue('Verdict', data.verdict.proceed ? 'PROCEED' : 'HOLD');
+    console.log(colors.subheader('\n  Tasks'));
+    printKeyValue('  Total', String(data.tasks.total));
+    printKeyValue('  Success', String(data.tasks.success));
+    printKeyValue('  Failure', String(data.tasks.failure));
+    printKeyValue('  Rework', String(data.tasks.rework));
+    printKeyValue('  Success Rate', `${(data.tasks.final_success_rate * 100).toFixed(0)}%`);
+    console.log(colors.subheader('\n  Analysis'));
+    for (const [axis, result] of Object.entries(data.analysis)) {
+        const r = result;
+        const icon = r.verdict === 'pass' ? '✓' : r.verdict === 'fail' ? '✗' : r.verdict === 'warn' ? '!' : '–';
+        console.log(`    ${icon} ${axis}: ${r.verdict} — ${colors.dim(r.details)}`);
+    }
+    console.log(colors.subheader('\n  DORA'));
+    printKeyValue('  Change Failure Rate', `${(data.dora_derived.change_failure_rate * 100).toFixed(0)}%`);
+    printKeyValue('  Rework Rate', `${(data.dora_derived.rework_rate * 100).toFixed(0)}%`);
+    printKeyValue('  Mean Task Duration', `${(data.dora_derived.mean_task_duration_ms / 1000).toFixed(1)}s`);
+    if (data.verdict.conditions.length > 0) {
+        console.log(colors.subheader('\n  Conditions'));
+        for (const c of data.verdict.conditions) {
+            console.log(`    - ${c}`);
+        }
+    }
+    printKeyValue('\n  Report', data.verdict.report_path);
+}
+/**
+ * Core: build SequenceLogEntry data (no I/O side effects except reading task logs)
+ */
+export async function buildSequenceLogData(projectRoot, seqId, options) {
+    const taskLogs = await loadSequenceTaskLogs(projectRoot, seqId);
+    if (taskLogs.length === 0) {
+        const tasksDir = getTasksDir(projectRoot);
+        if (await exists(tasksDir)) {
+            const allFiles = await listFiles('*.json', tasksDir);
+            for (const file of allFiles) {
+                if (file.toLowerCase().includes(seqId.toLowerCase())) {
+                    try {
+                        const data = await fs.readJson(path.join(tasksDir, file));
+                        taskLogs.push({ file, data });
+                    }
+                    catch { /* skip */ }
+                }
+            }
+        }
+    }
+    const stats = aggregateSequenceStats(taskLogs);
+    const now = getTimestamp();
+    const timestamps = taskLogs
+        .map(t => t.data.completed_at ? new Date(t.data.completed_at).getTime() : 0)
+        .filter(t => t > 0);
+    const startedAt = taskLogs[0]?.data.started_at || taskLogs[0]?.data.completed_at || now;
+    const duration = timestamps.length >= 2
+        ? Math.max(...timestamps) - Math.min(...timestamps)
+        : 0;
+    const meanDuration = stats.durations.length > 0
+        ? stats.durations.reduce((a, b) => a + b, 0) / stats.durations.length
+        : 0;
+    return {
+        schema_version: LOG_SCHEMA_VERSION,
+        trace: { phase_id: options.phase, sequence_id: seqId },
+        execution: {
+            status: stats.failure > 0 ? 'partial' : 'completed',
+            started_at: startedAt,
+            completed_at: now,
+            duration_ms: duration,
+        },
+        tasks: {
+            total: stats.total,
+            success: stats.success,
+            failure: stats.failure,
+            error: stats.error,
+            rework: stats.rework,
+            first_pass_success_rate: stats.first_pass_success_rate,
+            final_success_rate: stats.final_success_rate,
+        },
+        analysis: {
+            axis_1_consistency: makeAxisPlaceholder(),
+            axis_2_ssot_conformance: makeAxisPlaceholder(),
+            axis_3_cross_sequence: { ...makeAxisPlaceholder(), prev_sequence: null },
+        },
+        dora_derived: {
+            change_failure_rate: stats.total > 0 ? stats.failure / stats.total : 0,
+            rework_rate: stats.total > 0 ? stats.rework / stats.total : 0,
+            mean_task_duration_ms: meanDuration,
+            recovery_time_ms: null,
+        },
+        verdict: {
+            proceed: options.verdict !== 'hold',
+            conditions: options.conditions ? options.conditions.split(',').map(c => c.trim()) : [],
+            report_path: options.report,
+        },
+    };
+}
+/**
+ * Auto-feedback: L2/L3 이슈가 enrich로 들어오면 자동 피드백 라우팅
+ */
+async function autoFeedbackFromIssues(projectRoot, semantic) {
+    const issues = semantic.issues || [];
+    const l2l3Issues = issues.filter(i => i.level >= 2);
+    if (l2l3Issues.length === 0)
+        return;
+    try {
+        const state = await loadWorkflowState(projectRoot);
+        if (!state.automation.feedback)
+            return;
+        for (const issue of l2l3Issues) {
+            try {
+                const { execSync } = await import('child_process');
+                execSync(`npx tsq feedback route "${issue.description.replace(/"/g, '\\"')}"`, { cwd: projectRoot, timeout: 10000, stdio: 'ignore' });
+            }
+            catch { /* 피드백 라우팅 실패 무시 */ }
+        }
+    }
+    catch { /* 자동 피드백 실패 무시 */ }
+}
+/**
+ * Core: build PhaseGateResult (no I/O side effects except reading sequence logs)
+ */
+export async function buildPhaseGateData(projectRoot, phaseId) {
+    const seqDir = getSequencesDir(projectRoot);
+    const result = {
+        phase_id: phaseId,
+        can_transition: true,
+        missing_sequences: [],
+        missing_reports: [],
+        blocking_conditions: [],
+    };
+    if (!await exists(seqDir)) {
+        result.can_transition = false;
+        result.blocking_conditions.push('No sequence logs directory');
+        return result;
+    }
+    const files = await listFiles('*.json', seqDir);
+    const phaseSeqs = [];
+    for (const file of files) {
+        try {
+            const data = await fs.readJson(path.join(seqDir, file));
+            if (data.trace.phase_id === phaseId) {
+                phaseSeqs.push(data);
+            }
+        }
+        catch { /* skip */ }
+    }
+    if (phaseSeqs.length === 0) {
+        result.can_transition = false;
+        result.blocking_conditions.push('No sequence logs found for this phase');
+        return result;
+    }
+    for (const seq of phaseSeqs) {
+        if (!seq.verdict.proceed) {
+            result.can_transition = false;
+            result.blocking_conditions.push(`${seq.trace.sequence_id}: verdict is HOLD`);
+        }
+        if (seq.verdict.report_path) {
+            const reportPath = path.resolve(projectRoot, seq.verdict.report_path);
+            if (!await exists(reportPath)) {
+                result.can_transition = false;
+                result.missing_reports.push(seq.verdict.report_path);
+            }
+        }
+        if (seq.verdict.conditions.length > 0) {
+            for (const c of seq.verdict.conditions) {
+                result.blocking_conditions.push(`${seq.trace.sequence_id}: condition "${c}"`);
+            }
+        }
+    }
+    // Check unresolved L2/L3 feedback
+    try {
+        const state = await loadWorkflowState(projectRoot);
+        if (state.pending_feedback?.length > 0) {
+            const feedbackDir = path.join(projectRoot, '.timsquad', 'feedback');
+            for (const fbId of state.pending_feedback) {
+                const fbPath = path.join(feedbackDir, `${fbId}.json`);
+                if (await exists(fbPath)) {
+                    const fb = await fs.readJson(fbPath);
+                    if (!fb.status || fb.status === 'open' || fb.status === 'in_review') {
+                        result.can_transition = false;
+                        result.blocking_conditions.push(`Unresolved L${fb.level} feedback: ${fbId} (${fb.trigger})`);
+                    }
+                }
+            }
+        }
+    }
+    catch { /* workflow state unavailable — skip feedback check */ }
+    return result;
+}
+async function createSequenceLog(seqId, options) {
+    const projectRoot = await findProjectRoot();
+    if (!projectRoot)
+        throw new Error('Not a TimSquad project');
+    const entry = await buildSequenceLogData(projectRoot, seqId, options);
+    const seqDir = getSequencesDir(projectRoot);
+    await fs.ensureDir(seqDir);
+    await fs.writeJson(path.join(seqDir, `${seqId}.json`), entry, { spaces: 2 });
+    printSuccess(`Sequence log created: ${seqId}.json`);
+    printKeyValue('Tasks', `${entry.tasks.success}/${entry.tasks.total} success`);
+    printKeyValue('Verdict', entry.verdict.proceed ? 'PROCEED' : 'HOLD');
+}
+async function checkSequence(seqId) {
+    const projectRoot = await findProjectRoot();
+    if (!projectRoot)
+        throw new Error('Not a TimSquad project');
+    const taskLogs = await loadSequenceTaskLogs(projectRoot, seqId);
+    printHeader(`Sequence Check: ${seqId}`);
+    printKeyValue('Task Logs Found', String(taskLogs.length));
+    if (taskLogs.length === 0) {
+        console.log(colors.dim('  No task logs found for this sequence'));
+        return;
+    }
+    let withSemantic = 0;
+    for (const { file, data } of taskLogs) {
+        const sem = hasSemantic(data.semantic) ? colors.success('✓ semantic') : colors.warning('○ no semantic');
+        const status = data.status === 'completed' ? '✓' : '✗';
+        console.log(`  ${status} ${colors.agent(data.agent || '?')} ${sem} ${colors.dim(file)}`);
+        if (hasSemantic(data.semantic))
+            withSemantic++;
+    }
+    const coverage = Math.round((withSemantic / taskLogs.length) * 100);
+    console.log('');
+    printKeyValue('Semantic Coverage', `${coverage}% (${withSemantic}/${taskLogs.length})`);
+    if (coverage < 100) {
+        console.log(colors.warning('\n  ⚠ Run tsq log enrich for tasks missing semantic data'));
+    }
+}
+// ============================================================
+// Step 5: tsq log phase (L3) + Gate
+// ============================================================
+async function listPhaseLogs() {
+    const projectRoot = await findProjectRoot();
+    if (!projectRoot)
+        throw new Error('Not a TimSquad project');
+    const phaseDir = getPhasesDir(projectRoot);
+    if (!await exists(phaseDir)) {
+        console.log(colors.dim('No phase logs found'));
+        return;
+    }
+    const files = await listFiles('*.json', phaseDir);
+    if (files.length === 0) {
+        console.log(colors.dim('No phase logs found'));
+        return;
+    }
+    printHeader(`Phase Logs (${files.length})`);
+    for (const file of files.sort()) {
+        try {
+            const data = await fs.readJson(path.join(phaseDir, file));
+            const phaseId = data.trace.phase_id;
+            const status = data.execution.status;
+            const seqs = `${data.sequences.completed}/${data.sequences.total} sequences`;
+            console.log(`  ${colors.agent(phaseId)} [${status}] ${seqs}`);
+        }
+        catch {
+            console.log(`  ${colors.dim(file)} (unreadable)`);
+        }
+    }
+}
+async function viewPhaseLog(phaseId) {
+    const projectRoot = await findProjectRoot();
+    if (!projectRoot)
+        throw new Error('Not a TimSquad project');
+    const filePath = path.join(getPhasesDir(projectRoot), `${phaseId}.json`);
+    if (!await exists(filePath)) {
+        throw new Error(`Phase log not found: ${phaseId}`);
+    }
+    const data = await fs.readJson(filePath);
+    printHeader(`Phase: ${phaseId}`);
+    printKeyValue('Status', data.execution.status);
+    printKeyValue('Duration', `${(data.execution.duration_ms / 1000 / 60).toFixed(1)} min`);
+    printKeyValue('Sessions', String(data.execution.sessions_count));
+    console.log(colors.subheader('\n  Sequences'));
+    printKeyValue('  Total', String(data.sequences.total));
+    printKeyValue('  Completed', String(data.sequences.completed));
+    printKeyValue('  Blocked', String(data.sequences.blocked));
+    console.log(`    IDs: ${data.sequences.ids.join(', ')}`);
+    console.log(colors.subheader('\n  Metrics'));
+    printKeyValue('  Tasks', String(data.aggregate_metrics.total_tasks));
+    printKeyValue('  Success Rate', `${(data.aggregate_metrics.task_success_rate * 100).toFixed(0)}%`);
+    printKeyValue('  Rework Rate', `${(data.aggregate_metrics.task_rework_rate * 100).toFixed(0)}%`);
+    printKeyValue('  Files Changed', String(data.aggregate_metrics.total_files_changed));
+    printKeyValue('  SSOT Conformance', `${(data.aggregate_metrics.ssot_conformance_rate * 100).toFixed(0)}%`);
+    console.log(colors.subheader('\n  DORA'));
+    printKeyValue('  Lead Time', `${(data.dora_derived.lead_time_ms / 1000 / 60).toFixed(1)} min`);
+    printKeyValue('  Change Failure Rate', `${(data.dora_derived.change_failure_rate * 100).toFixed(0)}%`);
+    if (data.retrospective.keep.length || data.retrospective.problem.length || data.retrospective.try.length) {
+        console.log(colors.subheader('\n  Retrospective'));
+        if (data.retrospective.keep.length) {
+            console.log('    Keep:');
+            data.retrospective.keep.forEach(k => console.log(`      + ${k}`));
+        }
+        if (data.retrospective.problem.length) {
+            console.log('    Problem:');
+            data.retrospective.problem.forEach(p => console.log(`      - ${p}`));
+        }
+        if (data.retrospective.try.length) {
+            console.log('    Try:');
+            data.retrospective.try.forEach(t => console.log(`      → ${t}`));
+        }
+    }
+}
+async function createPhaseLog(phaseId, options) {
+    const projectRoot = await findProjectRoot();
+    if (!projectRoot)
+        throw new Error('Not a TimSquad project');
+    const seqIds = options.sequences.split(',').map(s => s.trim());
+    const seqDir = getSequencesDir(projectRoot);
+    const now = getTimestamp();
+    // Load sequence logs
+    const seqLogs = [];
+    let completed = 0, blocked = 0;
+    for (const id of seqIds) {
+        const seqPath = path.join(seqDir, `${id}.json`);
+        if (await exists(seqPath)) {
+            const data = await fs.readJson(seqPath);
+            seqLogs.push(data);
+            if (data.execution.status === 'completed')
+                completed++;
+            else
+                blocked++;
+        }
+        else {
+            blocked++;
+        }
+    }
+    // Aggregate
+    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);
+        // Count issues from analysis axes
+        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++;
+            }
+        }
+    }
+    // Collect total files from task logs
+    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;
+    const entry = {
+        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, // Placeholder — from architect reports
+            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: options.retroKeep ? options.retroKeep.split(',').map(s => s.trim()) : [],
+            problem: options.retroProblem ? options.retroProblem.split(',').map(s => s.trim()) : [],
+            try: options.retroTry ? options.retroTry.split(',').map(s => s.trim()) : [],
+        },
+        knowledge_extracted: [],
+    };
+    const phaseDir = getPhasesDir(projectRoot);
+    await fs.ensureDir(phaseDir);
+    await fs.writeJson(path.join(phaseDir, `${phaseId}.json`), entry, { spaces: 2 });
+    printSuccess(`Phase log created: ${phaseId}.json`);
+    printKeyValue('Sequences', `${completed}/${seqIds.length} completed`);
+    printKeyValue('Tasks', `${totalSuccess}/${totalTasks} success`);
+}
+async function checkPhaseGate(phaseId) {
+    const projectRoot = await findProjectRoot();
+    if (!projectRoot)
+        throw new Error('Not a TimSquad project');
+    const result = await buildPhaseGateData(projectRoot, phaseId);
+    printHeader(`Phase Gate: ${phaseId}`);
+    if (result.can_transition) {
+        console.log(colors.success('\n  ✓ PASSED — Phase transition allowed'));
+    }
+    else {
+        console.log(colors.error('\n  ✗ BLOCKED — Phase transition denied'));
+        if (result.missing_reports.length > 0) {
+            console.log(colors.subheader('\n  Missing Reports'));
+            for (const r of result.missing_reports) {
+                console.log(`    - ${r}`);
+            }
+        }
+        if (result.blocking_conditions.length > 0) {
+            console.log(colors.subheader('\n  Blocking Conditions'));
+            for (const c of result.blocking_conditions) {
+                console.log(`    - ${c}`);
+            }
+        }
+    }
+}
 //# sourceMappingURL=log.js.map