zigrix 0.1.0-alpha.0

package/dist/orchestration/dispatch.js

@@ -0,0 +1,146 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { appendEvent } from '../state/events.js';
+import { ensureBaseState } from '../state/paths.js';
+import { createTask, rebuildIndex, saveTask } from '../state/tasks.js';
+// ─── Constants ──────────────────────────────────────────────────────────────
+const BASELINE_REQUIRED = ['pro-zig', 'qa-zig'];
+const CANDIDATE_AGENTS = ['front-zig', 'back-zig', 'sys-zig', 'sec-zig'];
+const SELECTION_HINTS = {
+    'front-zig': 'UI / styling / client-side integration when present',
+    'back-zig': 'API / DB / server-side logic when present',
+    'sys-zig': 'architecture / infra / system-wide change when present',
+    'sec-zig': 'security-sensitive scope or risky changes when present',
+};
+// ─── Execution unit skeletons ───────────────────────────────────────────────
+function defaultWorkPackages(scale) {
+    return [
+        { id: 'WP1', key: 'planning', title: 'planning', parallel: false },
+        { id: 'WP2', key: 'implementation', title: 'implementation', parallel: ['normal', 'risky', 'large'].includes(scale) },
+        { id: 'WP3', key: 'verification', title: 'verification', parallel: false },
+        { id: 'WP4', key: 'release', title: 'release', parallel: false },
+    ];
+}
+function defaultExecutionUnits(scale) {
+    if (['normal', 'risky', 'large'].includes(scale)) {
+        return [
+            { id: 'U1', title: 'spec confirmation', kind: 'planning', owner: 'pro-zig', workPackage: 'planning', dependsOn: [], parallel: false, status: 'OPEN', dod: 'scope / constraints / edge cases fixed' },
+            { id: 'U2', title: 'implementation planning / work package split', kind: 'planning', owner: 'pro-zig', workPackage: 'planning', dependsOn: ['U1'], parallel: false, status: 'OPEN', dod: 'execution units and work packages fixed' },
+            { id: 'U3', title: 'implementation slices', kind: 'implementation', owner: 'pro-zig', workPackage: 'implementation', dependsOn: ['U2'], parallel: true, status: 'OPEN', dod: 'required work packages complete' },
+            { id: 'U4', title: 'qa / regression', kind: 'verification', owner: 'qa-zig', workPackage: 'verification', dependsOn: ['U3'], parallel: false, status: 'OPEN', dod: 'qa evidence attached' },
+            { id: 'U5', title: 'report / deploy / wrap-up', kind: 'reporting', owner: 'pro-zig', workPackage: 'release', dependsOn: ['U4'], parallel: false, status: 'OPEN', dod: 'final report prepared and deployment decision recorded' },
+        ];
+    }
+    return [
+        { id: 'U1', title: 'spec confirmation', kind: 'planning', owner: 'pro-zig', workPackage: 'planning', dependsOn: [], parallel: false, status: 'OPEN', dod: 'scope / constraints / edge cases fixed' },
+        { id: 'U2', title: 'implementation slice', kind: 'implementation', owner: 'pro-zig', workPackage: 'implementation', dependsOn: ['U1'], parallel: false, status: 'OPEN', dod: 'main implementation slice complete' },
+        { id: 'U3', title: 'qa / regression', kind: 'verification', owner: 'qa-zig', workPackage: 'verification', dependsOn: ['U2'], parallel: false, status: 'OPEN', dod: 'qa evidence attached' },
+    ];
+}
+// ─── Boot prompt ────────────────────────────────────────────────────────────
+function buildBootPrompt(task) {
+    return `## Orchestration Task Boot: ${task.taskId}
+- **Title:** ${task.title}
+- **Scale:** ${task.scale}
+
+---
+
+## ⚠️ 절대 규칙: qa-zig 호출 필수 (모든 스케일)
+
+**scale이 simple이든 normal이든 risky든 large든, qa-zig 워커는 반드시 호출해야 한다.**
+
+---
+
+## ⚡ 필수 첫 단계 (건너뛰기 금지)
+
+아래 명령을 **가장 먼저** 실행하라:
+
+\`\`\`bash
+zigrix task start ${task.taskId} --json
+\`\`\`
+
+그 후 태스크 메타를 확인하라:
+
+\`\`\`bash
+zigrix task status ${task.taskId} --json
+\`\`\`
+
+워커 호출 시:
+\`\`\`bash
+zigrix worker prepare --task-id ${task.taskId} --agent-id <workerId> --description "..." --json
+zigrix worker register --task-id ${task.taskId} --agent-id <workerId> --session-key <key> --json
+zigrix worker complete --task-id ${task.taskId} --agent-id <workerId> --session-key <key> --run-id <rid> --json
+\`\`\`
+
+최종 완료:
+\`\`\`bash
+zigrix task finalize ${task.taskId} --json
+\`\`\`
+`;
+}
+// ─── Dispatch ───────────────────────────────────────────────────────────────
+export function dispatchTask(paths, params) {
+    ensureBaseState(paths);
+    // Create the task
+    const task = createTask(paths, {
+        title: params.title,
+        description: params.description,
+        scale: params.scale,
+        requiredAgents: [...BASELINE_REQUIRED],
+        projectDir: params.projectDir,
+        requestedBy: params.requestedBy,
+    });
+    // Enrich with orchestration metadata
+    task.selectedAgents = [...BASELINE_REQUIRED];
+    task.workPackages = defaultWorkPackages(params.scale);
+    task.executionUnits = defaultExecutionUnits(params.scale);
+    saveTask(paths, task);
+    // Write dispatch prompt
+    const promptPath = path.join(paths.promptsDir, `${task.taskId}-dispatch.md`);
+    const dispatchPrompt = [
+        `## Orchestration Task: ${task.taskId}`,
+        '',
+        '### 기본 정보',
+        `- **Title:** ${task.title}`,
+        `- **Scale:** ${task.scale}`,
+        `- **Baseline Required Agents:** ${BASELINE_REQUIRED.join(', ')}`,
+        `- **Candidate Agents:** ${CANDIDATE_AGENTS.join(', ')}`,
+        params.projectDir ? `- **Project Dir:** ${params.projectDir}` : '',
+        '',
+        '### 요청 내용',
+        params.description,
+        params.constraints ? `\n### 제약사항\n${params.constraints}` : '',
+        '',
+        '### 선택 규칙',
+        ...Object.entries(SELECTION_HINTS).map(([k, v]) => `- ${k}: ${v}`),
+    ].filter(Boolean).join('\n');
+    fs.writeFileSync(promptPath, `${dispatchPrompt}\n`, 'utf8');
+    const bootPrompt = buildBootPrompt(task);
+    appendEvent(paths.eventsFile, {
+        event: 'task_dispatched',
+        taskId: task.taskId,
+        phase: 'dispatch',
+        actor: 'zigrix',
+        status: 'OPEN',
+        payload: {
+            scale: task.scale,
+            baselineRequiredAgents: BASELINE_REQUIRED,
+            candidateAgents: CANDIDATE_AGENTS,
+            projectDir: params.projectDir ?? null,
+        },
+    });
+    rebuildIndex(paths);
+    return {
+        ok: true,
+        taskId: task.taskId,
+        title: task.title,
+        scale: task.scale,
+        baselineRequiredAgents: BASELINE_REQUIRED,
+        candidateAgents: CANDIDATE_AGENTS,
+        specPath: path.join(paths.tasksDir, `${task.taskId}.md`),
+        metaPath: path.join(paths.tasksDir, `${task.taskId}.meta.json`),
+        promptPath,
+        proZigPrompt: bootPrompt,
+        projectDir: params.projectDir ?? null,
+    };
+}

package/dist/orchestration/evidence.d.ts

@@ -0,0 +1,19 @@
+import { type ZigrixPaths } from '../state/paths.js';
+export declare function collectEvidence(paths: ZigrixPaths, params: {
+    taskId: string;
+    agentId: string;
+    runId?: string;
+    unitId?: string;
+    sessionKey?: string;
+    sessionId?: string;
+    transcript?: string;
+    summary?: string;
+    toolResults?: string[];
+    notes?: string;
+    limit?: number;
+}): Record<string, unknown> | null;
+export declare function mergeEvidence(paths: ZigrixPaths, params: {
+    taskId: string;
+    requiredAgents?: string[];
+    requireQa?: boolean;
+}): Record<string, unknown> | null;

package/dist/orchestration/evidence.js

@@ -0,0 +1,97 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { appendEvent, nowIso } from '../state/events.js';
+import { ensureBaseState } from '../state/paths.js';
+import { loadTask, rebuildIndex } from '../state/tasks.js';
+import { resolveRequiredAgents } from './worker.js';
+function readTranscript(transcriptPath, limit = 40) {
+    if (!transcriptPath || !fs.existsSync(transcriptPath))
+        return [];
+    return fs.readFileSync(transcriptPath, 'utf8')
+        .split(/\r?\n/)
+        .filter(Boolean)
+        .slice(-limit)
+        .flatMap((line) => {
+        try {
+            const parsed = JSON.parse(line);
+            return [parsed];
+        }
+        catch {
+            return [];
+        }
+    });
+}
+function extractEvidence(rows) {
+    let lastAssistant = null;
+    const toolResults = [];
+    for (const row of rows) {
+        if (row.role === 'assistant' && row.content)
+            lastAssistant = row.content;
+        if (row.role === 'toolResult')
+            toolResults.push(row.content);
+    }
+    return { lastAssistant, toolResults: toolResults.slice(-3) };
+}
+export function collectEvidence(paths, params) {
+    ensureBaseState(paths);
+    const task = loadTask(paths, params.taskId);
+    if (!task)
+        return null;
+    const transcriptRows = params.transcript ? readTranscript(path.resolve(params.transcript), params.limit ?? 40) : [];
+    const extracted = extractEvidence(transcriptRows);
+    if (params.summary) {
+        extracted.summary = params.summary;
+        extracted.lastAssistant = params.summary;
+    }
+    if (params.toolResults?.length)
+        extracted.toolResults = [...params.toolResults];
+    if (params.notes)
+        extracted.notes = params.notes;
+    const outDir = path.join(paths.evidenceDir, params.taskId);
+    fs.mkdirSync(outDir, { recursive: true });
+    const outPath = path.join(outDir, `${params.agentId}.json`);
+    const payload = {
+        ts: nowIso(), taskId: params.taskId, agentId: params.agentId, unitId: params.unitId ?? null,
+        runId: params.runId ?? '', sessionKey: params.sessionKey ?? null, sessionId: params.sessionId ?? null,
+        transcriptPath: params.transcript ? path.resolve(params.transcript) : null, evidence: extracted,
+    };
+    fs.writeFileSync(outPath, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
+    appendEvent(paths.eventsFile, {
+        event: 'evidence_collected', taskId: params.taskId, phase: 'verification', actor: params.agentId, status: 'IN_PROGRESS', unitId: params.unitId ?? null,
+        sessionKey: params.sessionKey ?? null, payload: { agentId: params.agentId, runId: params.runId ?? '', evidencePath: outPath },
+    });
+    rebuildIndex(paths);
+    return { ok: true, taskId: params.taskId, agentId: params.agentId, evidencePath: outPath, sessionId: params.sessionId ?? null, unitId: params.unitId ?? null };
+}
+export function mergeEvidence(paths, params) {
+    const task = loadTask(paths, params.taskId);
+    if (!task)
+        return null;
+    const taskDir = path.join(paths.evidenceDir, params.taskId);
+    fs.mkdirSync(taskDir, { recursive: true });
+    const files = fs.readdirSync(taskDir).filter((name) => name.endsWith('.json') && name !== '_merged.json').sort();
+    const items = files.flatMap((file) => {
+        try {
+            const data = JSON.parse(fs.readFileSync(path.join(taskDir, file), 'utf8'));
+            const agentId = String(data.agentId ?? path.basename(file, '.json'));
+            return [{ agentId, unitId: data.unitId, runId: data.runId, sessionKey: data.sessionKey, sessionId: data.sessionId, transcriptPath: data.transcriptPath, evidence: data.evidence ?? {} }];
+        }
+        catch {
+            return [];
+        }
+    });
+    const presentAgents = [...new Set(items.map((item) => String(item.agentId)))].sort();
+    const requiredAgents = [...(params.requiredAgents?.length ? params.requiredAgents : resolveRequiredAgents(task))];
+    const missingAgents = requiredAgents.filter((agentId) => !presentAgents.includes(agentId));
+    const qaPresent = presentAgents.includes('qa-zig');
+    const complete = missingAgents.length === 0 && (!(params.requireQa ?? false) || qaPresent);
+    const merged = { ts: nowIso(), taskId: params.taskId, requiredAgents, presentAgents, missingAgents, qaPresent, complete, items };
+    const outPath = path.join(taskDir, '_merged.json');
+    fs.writeFileSync(outPath, `${JSON.stringify(merged, null, 2)}\n`, 'utf8');
+    appendEvent(paths.eventsFile, {
+        event: 'evidence_merged', taskId: params.taskId, phase: 'verification', actor: 'zigrix', status: complete ? 'DONE_PENDING_REPORT' : 'IN_PROGRESS',
+        payload: { requiredAgents, missingAgents, complete, mergedPath: outPath, qaPresent },
+    });
+    rebuildIndex(paths);
+    return { ok: true, taskId: params.taskId, complete, missingAgents, mergedPath: outPath };
+}

package/dist/orchestration/finalize.d.ts

@@ -0,0 +1,7 @@
+import { type ZigrixPaths } from '../state/paths.js';
+export declare function finalizeTask(paths: ZigrixPaths, params: {
+    taskId: string;
+    autoReport?: boolean;
+    secIssues?: boolean;
+    qaIssues?: boolean;
+}): Record<string, unknown> | null;

package/dist/orchestration/finalize.js

@@ -0,0 +1,136 @@
+import { appendEvent } from '../state/events.js';
+import { loadTask, rebuildIndex, saveTask } from '../state/tasks.js';
+import { mergeEvidence } from './evidence.js';
+import { renderReport } from './report.js';
+import { resolveRequiredAgents } from './worker.js';
+// ─── Unit completeness ─────────────────────────────────────────────────────
+function autoCloseCompletedUnits(task) {
+    const units = task.executionUnits;
+    if (!units?.length)
+        return false;
+    // Build set of agents that have completed their work
+    const doneAgents = new Set();
+    for (const [agentId, session] of Object.entries(task.workerSessions)) {
+        const s = session;
+        if (s.status === 'done')
+            doneAgents.add(agentId);
+    }
+    // pro-zig is always "done" at finalize time
+    doneAgents.add('pro-zig');
+    let changed = false;
+    for (const unit of units) {
+        if (['OPEN', 'IN_PROGRESS'].includes(unit.status.toUpperCase()) && doneAgents.has(unit.owner)) {
+            unit.status = 'DONE';
+            changed = true;
+        }
+    }
+    return changed;
+}
+function summarizeUnits(task) {
+    const units = task.executionUnits;
+    if (!units?.length) {
+        return { hasUnits: false, complete: true, missingUnits: [], missingWorkPackages: [] };
+    }
+    const missing = [];
+    const missingWp = new Set();
+    for (const unit of units) {
+        if (unit.status.toUpperCase() !== 'DONE') {
+            missing.push({ id: unit.id, title: unit.title, status: unit.status, owner: unit.owner ?? null });
+            if (unit.workPackage)
+                missingWp.add(unit.workPackage);
+        }
+    }
+    return {
+        hasUnits: true,
+        complete: missing.length === 0,
+        missingUnits: missing,
+        missingWorkPackages: [...missingWp].sort(),
+    };
+}
+// ─── Finalize ───────────────────────────────────────────────────────────────
+export function finalizeTask(paths, params) {
+    const task = loadTask(paths, params.taskId);
+    if (!task)
+        return null;
+    const steps = [];
+    const reqAgents = resolveRequiredAgents(task);
+    // Auto-close units whose owners have completed
+    if (autoCloseCompletedUnits(task)) {
+        saveTask(paths, task);
+    }
+    // Merge evidence
+    const merged = mergeEvidence(paths, { taskId: params.taskId, requiredAgents: reqAgents, requireQa: true });
+    steps.push({ step: 'merge_evidence', result: merged });
+    const agentComplete = Boolean(merged?.complete);
+    const missingAgents = Array.isArray(merged?.missingAgents) ? merged.missingAgents : [];
+    // Unit completeness
+    const unitSummary = summarizeUnits(task);
+    steps.push({
+        step: 'unit_completeness',
+        hasUnits: unitSummary.hasUnits,
+        complete: unitSummary.complete,
+        missingUnits: unitSummary.missingUnits,
+        missingWorkPackages: unitSummary.missingWorkPackages,
+    });
+    const complete = agentComplete && unitSummary.complete;
+    if (params.autoReport && complete) {
+        if (params.secIssues || params.qaIssues) {
+            // Needs owner confirmation
+            task.status = 'DONE_PENDING_REPORT';
+            saveTask(paths, task);
+            appendEvent(paths.eventsFile, {
+                event: 'owner_confirmation_required',
+                taskId: params.taskId,
+                phase: 'reporting',
+                actor: 'zigrix',
+                status: 'DONE_PENDING_REPORT',
+                payload: { securityIssues: params.secIssues, qaIssues: params.qaIssues },
+            });
+            steps.push({ step: 'owner_confirmation_required', ok: true });
+        }
+        else {
+            // Auto report
+            const report = renderReport(paths, { taskId: params.taskId, recordEvents: true });
+            steps.push({ step: 'report_render', result: report });
+            task.status = 'REPORTED';
+            saveTask(paths, task);
+            appendEvent(paths.eventsFile, {
+                event: 'reported',
+                taskId: params.taskId,
+                phase: 'reporting',
+                actor: 'zigrix',
+                status: 'REPORTED',
+                payload: { note: 'auto_report by finalize', requiredAgents: reqAgents },
+            });
+            steps.push({ step: 'reported', ok: true });
+        }
+    }
+    else if (!complete) {
+        steps.push({
+            step: 'incomplete',
+            missingAgents,
+            missingUnits: unitSummary.missingUnits,
+            missingWorkPackages: unitSummary.missingWorkPackages,
+        });
+    }
+    else {
+        // Complete but no auto-report
+        task.status = 'DONE_PENDING_REPORT';
+        saveTask(paths, task);
+    }
+    rebuildIndex(paths);
+    const result = {
+        ok: true,
+        taskId: params.taskId,
+        requiredAgents: reqAgents,
+        complete,
+        missingAgents,
+        missingUnits: unitSummary.missingUnits,
+        missingWorkPackages: unitSummary.missingWorkPackages,
+        steps,
+    };
+    if (complete) {
+        result.nextAction = 'sessions_send(sessionKey: "agent:main:main", message: "<taskId> 완료: <요약>")';
+    }
+    return result;
+}

package/dist/orchestration/pipeline.d.ts

@@ -0,0 +1,11 @@
+import { type ZigrixPaths } from '../state/paths.js';
+export declare function runPipeline(paths: ZigrixPaths, params: {
+    title: string;
+    description: string;
+    scale?: string;
+    requiredAgents?: string[];
+    evidenceSummaries?: string[];
+    requireQa?: boolean;
+    autoReport?: boolean;
+    recordFeedback?: boolean;
+}): Record<string, unknown>;

package/dist/orchestration/pipeline.js

@@ -0,0 +1,26 @@
+import { collectEvidence, mergeEvidence } from './evidence.js';
+import { renderReport } from './report.js';
+import { createTask, updateTaskStatus } from '../state/tasks.js';
+export function runPipeline(paths, params) {
+    const steps = [];
+    const task = createTask(paths, { title: params.title, description: params.description, scale: params.scale ?? 'normal', requiredAgents: params.requiredAgents ?? [] });
+    const taskId = task.taskId;
+    steps.push({ step: 'task_create', result: task });
+    steps.push({ step: 'task_start', result: updateTaskStatus(paths, taskId, 'IN_PROGRESS') });
+    for (const raw of params.evidenceSummaries ?? []) {
+        if (!raw.includes('='))
+            throw new Error(`invalid evidence summary format: ${raw} (expected agentId=summary)`);
+        const [agentId, summary] = raw.split(/=(.*)/s, 2);
+        steps.push({ step: 'evidence_collect', agentId: agentId.trim(), result: collectEvidence(paths, { taskId, agentId: agentId.trim(), summary: summary.trim() }) });
+    }
+    const merged = mergeEvidence(paths, { taskId, requiredAgents: params.requiredAgents, requireQa: params.requireQa });
+    steps.push({ step: 'evidence_merge', result: merged });
+    if (merged?.complete) {
+        steps.push({ step: 'task_finalize', result: updateTaskStatus(paths, taskId, 'DONE_PENDING_REPORT') });
+        if (params.autoReport) {
+            steps.push({ step: 'report_render', result: renderReport(paths, { taskId, recordEvents: params.recordFeedback }) });
+            steps.push({ step: 'task_report', result: updateTaskStatus(paths, taskId, 'REPORTED') });
+        }
+    }
+    return { ok: true, taskId, complete: Boolean(merged?.complete), missingAgents: Array.isArray(merged?.missingAgents) ? merged.missingAgents : [], steps };
+}

package/dist/orchestration/report.d.ts

@@ -0,0 +1,5 @@
+import { type ZigrixPaths } from '../state/paths.js';
+export declare function renderReport(paths: ZigrixPaths, params: {
+    taskId: string;
+    recordEvents?: boolean;
+}): Record<string, unknown> | null;

package/dist/orchestration/report.js

@@ -0,0 +1,92 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { appendEvent } from '../state/events.js';
+import { loadTask, rebuildIndex } from '../state/tasks.js';
+function readJson(filePath) {
+    try {
+        return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    }
+    catch {
+        return {};
+    }
+}
+function summarizeAgents(merged) {
+    const items = Array.isArray(merged.items) ? merged.items : [];
+    const fromItems = items.flatMap((item) => typeof item === 'object' && item && 'agentId' in item ? [String(item.agentId)] : []);
+    if (fromItems.length > 0)
+        return fromItems;
+    return Array.isArray(merged.presentAgents) ? merged.presentAgents.map(String) : [];
+}
+function collectAgentLines(merged) {
+    const items = Array.isArray(merged.items) ? merged.items : [];
+    const lines = items.flatMap((item) => {
+        if (!item || typeof item !== 'object')
+            return [];
+        const row = item;
+        const evidence = (row.evidence && typeof row.evidence === 'object' ? row.evidence : {});
+        const summary = evidence.summary ?? evidence.lastAssistant ?? evidence.verdict ?? '수행 기록 있음';
+        return [`- ${String(row.agentId ?? 'unknown')}: ${String(summary)}`];
+    });
+    return lines.length > 0 ? lines : ['- 참여 에이전트 기록 없음'];
+}
+function collectRisks(merged) {
+    const risks = new Set();
+    const items = Array.isArray(merged.items) ? merged.items : [];
+    for (const item of items) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const evidence = (item.evidence ?? {});
+        const entries = Array.isArray(evidence.risks) ? evidence.risks : [];
+        for (const risk of entries)
+            risks.add(String(risk));
+    }
+    return [...risks];
+}
+function qaLine(merged) {
+    const present = new Set(Array.isArray(merged.presentAgents) ? merged.presentAgents.map(String) : []);
+    return present.has('qa-zig') ? '- qa-zig evidence 존재, QA 수행됨' : '- qa-zig evidence 없음 또는 별도 QA 미실행';
+}
+export function renderReport(paths, params) {
+    const task = loadTask(paths, params.taskId);
+    if (!task)
+        return null;
+    const merged = readJson(path.join(paths.evidenceDir, params.taskId, '_merged.json'));
+    const title = String(task.title ?? params.taskId);
+    const scale = String(task.scale ?? 'unknown');
+    const agents = summarizeAgents(merged);
+    const agentLines = collectAgentLines(merged);
+    const risks = collectRisks(merged);
+    const missing = Array.isArray(merged.missingAgents) ? merged.missingAgents.map(String) : [];
+    const complete = Boolean(merged.complete ?? false);
+    const finalState = complete ? '완료(REPORTED)' : '부분완료/추가확인필요';
+    const summaryLines = [`- 태스크: \`${params.taskId}\` / ${title}`, `- 상태: ${finalState}`];
+    if (agents.length > 0)
+        summaryLines.push(`- 참여 에이전트: ${agents.join(', ')}`);
+    const riskLines = [...(missing.length > 0 ? [`- 누락 에이전트: ${missing.join(', ')}`] : []), ...risks.map((risk) => `- ${risk}`)];
+    if (riskLines.length === 0)
+        riskLines.push('- 특이 리스크 없음');
+    const report = [
+        `작업유형: ${scale}`,
+        '',
+        '진행 요약',
+        ...summaryLines,
+        '',
+        '에이전트별 수행 내역',
+        ...agentLines,
+        '',
+        'QA 결과',
+        qaLine(merged),
+        '',
+        '남은 리스크 / 후속 액션',
+        ...riskLines,
+        '',
+        '피드백 요청',
+        '- 만족도(1~5), 좋았던 점, 개선할 점 있으면 짧게 주세요.',
+    ].join('\n');
+    if (params.recordEvents) {
+        appendEvent(paths.eventsFile, { event: 'user_report_prepared', taskId: params.taskId, phase: 'reporting', actor: 'zigrix', payload: { preview: report.slice(0, 300) } });
+        appendEvent(paths.eventsFile, { event: 'feedback_requested', taskId: params.taskId, phase: 'reporting', actor: 'zigrix', payload: { questions: ['만족도(1~5)는?', '좋았던 점은?', '개선할 점은?'] } });
+        rebuildIndex(paths);
+    }
+    return { ok: true, taskId: params.taskId, complete, missingAgents: missing, report };
+}

package/dist/orchestration/worker.d.ts

@@ -0,0 +1,34 @@
+import { type ZigrixPaths } from '../state/paths.js';
+import { type ZigrixTask } from '../state/tasks.js';
+export declare const DEFAULT_REQUIRED_AGENTS: string[];
+export declare function resolveRequiredAgents(task: Partial<ZigrixTask> & Record<string, unknown>): string[];
+export declare function prepareWorker(paths: ZigrixPaths, params: {
+    taskId: string;
+    agentId: string;
+    description: string;
+    constraints?: string;
+    unitId?: string;
+    workPackage?: string;
+    dod?: string;
+    projectDir?: string;
+}): Record<string, unknown> | null;
+export declare function registerWorker(paths: ZigrixPaths, params: {
+    taskId: string;
+    agentId: string;
+    sessionKey: string;
+    runId?: string;
+    sessionId?: string;
+    unitId?: string;
+    workPackage?: string;
+    reason?: string;
+}): Record<string, unknown> | null;
+export declare function completeWorker(paths: ZigrixPaths, params: {
+    taskId: string;
+    agentId: string;
+    sessionKey: string;
+    runId: string;
+    result?: 'done' | 'blocked' | 'skipped';
+    sessionId?: string;
+    unitId?: string;
+    workPackage?: string;
+}): Record<string, unknown> | null;