zigrix 0.1.0-alpha.8 → 0.1.0

package/dist/orchestration/dispatch.d.ts

@@ -1,5 +1,7 @@
+import type { ZigrixConfig } from '../config/schema.js';
 import { type ZigrixPaths } from '../state/paths.js';
-export declare function dispatchTask(paths: ZigrixPaths, params: {
+export declare function resolveConfiguredProjectDir(config: ZigrixConfig, explicitProjectDir?: string): string | undefined;
+export declare function dispatchTask(paths: ZigrixPaths, config: ZigrixConfig, params: {
     title: string;
     description: string;
     scale: string;

package/dist/orchestration/dispatch.js

@@ -1,18 +1,118 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { ROLE_HINTS } from '../agents/roles.js';
+import { resolveAbsolutePath } from '../config/defaults.js';
 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 ───────────────────────────────────────────────
+import { ensureBaseState } from '../state/paths.js';
+const BASELINE_REQUIRED_ROLES = ['orchestrator', 'qa'];
+const CANDIDATE_ROLE_ORDER = ['frontend', 'backend', 'system', 'security'];
+function unique(items) {
+    return [...new Set(items)];
+}
+function listEligibleAgentsByRole(config) {
+    const byRole = new Map();
+    const participants = new Set(config.agents.orchestration.participants);
+    const excluded = new Set(config.agents.orchestration.excluded);
+    const participantMode = participants.size > 0;
+    for (const [agentId, agent] of Object.entries(config.agents.registry).sort(([a], [b]) => a.localeCompare(b))) {
+        if (!agent.enabled)
+            continue;
+        if (excluded.has(agentId))
+            continue;
+        if (participantMode && !participants.has(agentId))
+            continue;
+        const role = agent.role;
+        const row = byRole.get(role) ?? [];
+        row.push(agentId);
+        byRole.set(role, row);
+    }
+    return byRole;
+}
+function pickRequiredAgentByRole(params) {
+    if (params.role === 'orchestrator') {
+        if (params.roleAgents.length === 0) {
+            throw new Error('dispatch validation failed: no eligible agent for required role "orchestrator"');
+        }
+        if (!params.roleAgents.includes(params.orchestratorId)) {
+            throw new Error(`dispatch validation failed: configured orchestratorId '${params.orchestratorId}' is not eligible (available: ${params.roleAgents.join(', ')})`);
+        }
+        return params.orchestratorId;
+    }
+    const picked = params.roleAgents[0];
+    if (!picked) {
+        throw new Error(`dispatch validation failed: no eligible agent for required role "${params.role}"`);
+    }
+    return picked;
+}
+function resolveAgentSelection(config, scale) {
+    const scalePolicy = config.rules.scales[scale];
+    if (!scalePolicy) {
+        throw new Error(`unknown scale: ${scale}`);
+    }
+    const requiredRoles = unique([...BASELINE_REQUIRED_ROLES, ...scalePolicy.requiredRoles]);
+    const optionalRoles = unique(scalePolicy.optionalRoles.filter((role) => !requiredRoles.includes(role)));
+    const eligibleByRole = listEligibleAgentsByRole(config);
+    const requiredAgents = [];
+    const roleAgentMap = {};
+    for (const role of requiredRoles) {
+        const roleAgents = eligibleByRole.get(role) ?? [];
+        roleAgentMap[role] = [...roleAgents];
+        const picked = pickRequiredAgentByRole({
+            role,
+            roleAgents,
+            orchestratorId: config.agents.orchestration.orchestratorId,
+        });
+        requiredAgents.push(picked);
+    }
+    const candidateRoles = unique([...optionalRoles, ...CANDIDATE_ROLE_ORDER.filter((role) => !requiredRoles.includes(role))]);
+    const candidateAgents = [];
+    for (const role of candidateRoles) {
+        const roleAgents = eligibleByRole.get(role) ?? [];
+        roleAgentMap[role] = [...roleAgents];
+        for (const agentId of roleAgents) {
+            if (requiredAgents.includes(agentId))
+                continue;
+            if (!candidateAgents.includes(agentId))
+                candidateAgents.push(agentId);
+        }
+    }
+    const selectionHints = {};
+    for (const [role, agentIds] of Object.entries(roleAgentMap)) {
+        const hint = ROLE_HINTS[role] ?? 'role-based selection';
+        for (const agentId of agentIds) {
+            selectionHints[agentId] = `${hint} (role: ${role})`;
+        }
+    }
+    const qaAgentId = requiredAgents.find((agentId) => {
+        const role = config.agents.registry[agentId]?.role;
+        return role === 'qa';
+    });
+    if (!qaAgentId) {
+        throw new Error('dispatch validation failed: no selected QA agent');
+    }
+    return {
+        requiredRoles,
+        optionalRoles,
+        requiredAgents,
+        candidateAgents,
+        roleAgentMap,
+        selectionHints,
+        orchestratorId: config.agents.orchestration.orchestratorId,
+        qaAgentId,
+    };
+}
+export function resolveConfiguredProjectDir(config, explicitProjectDir) {
+    const explicit = explicitProjectDir?.trim();
+    if (explicit) {
+        return resolveAbsolutePath(explicit);
+    }
+    const configured = config.workspace.projectsBaseDir?.trim();
+    if (configured && configured.length > 0) {
+        return resolveAbsolutePath(configured);
+    }
+    return undefined;
+}
 function defaultWorkPackages(scale) {
     return [
         { id: 'WP1', key: 'planning', title: 'planning', parallel: false },
@@ -21,33 +121,33 @@ function defaultWorkPackages(scale) {
         { id: 'WP4', key: 'release', title: 'release', parallel: false },
     ];
 }
-function defaultExecutionUnits(scale) {
+function defaultExecutionUnits(scale, owners) {
     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' },
+            { id: 'U1', title: 'spec confirmation', kind: 'planning', owner: owners.orchestratorId, workPackage: 'planning', dependsOn: [], parallel: false, status: 'OPEN', dod: 'scope / constraints / edge cases fixed' },
+            { id: 'U2', title: 'implementation planning / work package split', kind: 'planning', owner: owners.orchestratorId, workPackage: 'planning', dependsOn: ['U1'], parallel: false, status: 'OPEN', dod: 'execution units and work packages fixed' },
+            { id: 'U3', title: 'implementation slices', kind: 'implementation', owner: owners.orchestratorId, workPackage: 'implementation', dependsOn: ['U2'], parallel: true, status: 'OPEN', dod: 'required work packages complete' },
+            { id: 'U4', title: 'qa / regression', kind: 'verification', owner: owners.qaAgentId, workPackage: 'verification', dependsOn: ['U3'], parallel: false, status: 'OPEN', dod: 'qa evidence attached' },
+            { id: 'U5', title: 'report / deploy / wrap-up', kind: 'reporting', owner: owners.orchestratorId, 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' },
+        { id: 'U1', title: 'spec confirmation', kind: 'planning', owner: owners.orchestratorId, workPackage: 'planning', dependsOn: [], parallel: false, status: 'OPEN', dod: 'scope / constraints / edge cases fixed' },
+        { id: 'U2', title: 'implementation slice', kind: 'implementation', owner: owners.orchestratorId, workPackage: 'implementation', dependsOn: ['U1'], parallel: false, status: 'OPEN', dod: 'main implementation slice complete' },
+        { id: 'U3', title: 'qa / regression', kind: 'verification', owner: owners.qaAgentId, workPackage: 'verification', dependsOn: ['U2'], parallel: false, status: 'OPEN', dod: 'qa evidence attached' },
     ];
 }
-// ─── Boot prompt ────────────────────────────────────────────────────────────
-function buildBootPrompt(task) {
+function buildBootPrompt(task, options) {
     return `## Orchestration Task Boot: ${task.taskId}
 - **Title:** ${task.title}
 - **Scale:** ${task.scale}
+- **Orchestrator:** ${options.orchestratorId}
 
 ---
 
-## ⚠️ 절대 규칙: qa-zig 호출 필수 (모든 스케일)
+## ⚠️ 절대 규칙: QA 역할 워커 호출 필수
 
-**scale이 simple이든 normal이든 risky든 large든, qa-zig 워커는 반드시 호출해야 한다.**
+**이 태스크는 QA 역할(${options.qaAgentId}) 워커 완료가 필수다.**
 
 ---
 
@@ -78,24 +178,32 @@ zigrix task finalize ${task.taskId} --json
 \`\`\`
 `;
 }
-// ─── Dispatch ───────────────────────────────────────────────────────────────
-export function dispatchTask(paths, params) {
+export function dispatchTask(paths, config, params) {
     ensureBaseState(paths);
-    // Create the task
+    const selection = resolveAgentSelection(config, params.scale);
+    const projectDir = resolveConfiguredProjectDir(config, params.projectDir);
     const task = createTask(paths, {
         title: params.title,
         description: params.description,
         scale: params.scale,
-        requiredAgents: [...BASELINE_REQUIRED],
-        projectDir: params.projectDir,
+        requiredAgents: [...selection.requiredAgents],
+        projectDir,
         requestedBy: params.requestedBy,
     });
-    // Enrich with orchestration metadata
-    task.selectedAgents = [...BASELINE_REQUIRED];
+    task.selectedAgents = [...selection.requiredAgents];
     task.workPackages = defaultWorkPackages(params.scale);
-    task.executionUnits = defaultExecutionUnits(params.scale);
+    task.executionUnits = defaultExecutionUnits(params.scale, {
+        orchestratorId: selection.orchestratorId,
+        qaAgentId: selection.qaAgentId,
+    });
+    task.baselineRequiredAgents = [...selection.requiredAgents];
+    task.candidateAgents = [...selection.candidateAgents];
+    task.requiredRoles = [...selection.requiredRoles];
+    task.optionalRoles = [...selection.optionalRoles];
+    task.roleAgentMap = selection.roleAgentMap;
+    task.orchestratorId = selection.orchestratorId;
+    task.qaAgentId = selection.qaAgentId;
     saveTask(paths, task);
-    // Write dispatch prompt
     const promptPath = path.join(paths.promptsDir, `${task.taskId}-dispatch.md`);
     const dispatchPrompt = [
         `## Orchestration Task: ${task.taskId}`,
@@ -103,19 +211,30 @@ export function dispatchTask(paths, params) {
         '### 기본 정보',
         `- **Title:** ${task.title}`,
         `- **Scale:** ${task.scale}`,
-        `- **Baseline Required Agents:** ${BASELINE_REQUIRED.join(', ')}`,
-        `- **Candidate Agents:** ${CANDIDATE_AGENTS.join(', ')}`,
-        params.projectDir ? `- **Project Dir:** ${params.projectDir}` : '',
+        `- **Orchestrator:** ${selection.orchestratorId}`,
+        `- **Baseline Required Agents:** ${selection.requiredAgents.join(', ')}`,
+        `- **Candidate Agents:** ${selection.candidateAgents.length > 0 ? selection.candidateAgents.join(', ') : '(none)'}`,
+        `- **Required Roles:** ${selection.requiredRoles.join(', ')}`,
+        `- **Optional Roles:** ${selection.optionalRoles.length > 0 ? selection.optionalRoles.join(', ') : '(none)'}`,
+        projectDir ? `- **Project Dir:** ${projectDir}` : '',
         '',
         '### 요청 내용',
         params.description,
         params.constraints ? `\n### 제약사항\n${params.constraints}` : '',
         '',
+        '### 역할 매핑',
+        ...Object.entries(selection.roleAgentMap)
+            .filter(([, agentIds]) => agentIds.length > 0)
+            .map(([role, agentIds]) => `- ${role}: ${agentIds.join(', ')}`),
+        '',
         '### 선택 규칙',
-        ...Object.entries(SELECTION_HINTS).map(([k, v]) => `- ${k}: ${v}`),
+        ...Object.entries(selection.selectionHints).map(([agentId, hint]) => `- ${agentId}: ${hint}`),
     ].filter(Boolean).join('\n');
     fs.writeFileSync(promptPath, `${dispatchPrompt}\n`, 'utf8');
-    const bootPrompt = buildBootPrompt(task);
+    const orchestratorPrompt = buildBootPrompt(task, {
+        orchestratorId: selection.orchestratorId,
+        qaAgentId: selection.qaAgentId,
+    });
     appendEvent(paths.eventsFile, {
         event: 'task_dispatched',
         taskId: task.taskId,
@@ -124,9 +243,13 @@ export function dispatchTask(paths, params) {
         status: 'OPEN',
         payload: {
             scale: task.scale,
-            baselineRequiredAgents: BASELINE_REQUIRED,
-            candidateAgents: CANDIDATE_AGENTS,
-            projectDir: params.projectDir ?? null,
+            orchestratorId: selection.orchestratorId,
+            baselineRequiredAgents: selection.requiredAgents,
+            candidateAgents: selection.candidateAgents,
+            requiredRoles: selection.requiredRoles,
+            optionalRoles: selection.optionalRoles,
+            roleAgentMap: selection.roleAgentMap,
+            projectDir: projectDir ?? null,
         },
     });
     rebuildIndex(paths);
@@ -135,12 +258,17 @@ export function dispatchTask(paths, params) {
         taskId: task.taskId,
         title: task.title,
         scale: task.scale,
-        baselineRequiredAgents: BASELINE_REQUIRED,
-        candidateAgents: CANDIDATE_AGENTS,
+        orchestratorId: selection.orchestratorId,
+        qaAgentId: selection.qaAgentId,
+        baselineRequiredAgents: selection.requiredAgents,
+        candidateAgents: selection.candidateAgents,
+        requiredRoles: selection.requiredRoles,
+        optionalRoles: selection.optionalRoles,
+        roleAgentMap: selection.roleAgentMap,
         specPath: path.join(paths.tasksDir, `${task.taskId}.md`),
         metaPath: path.join(paths.tasksDir, `${task.taskId}.meta.json`),
         promptPath,
-        proZigPrompt: bootPrompt,
-        projectDir: params.projectDir ?? null,
+        orchestratorPrompt,
+        projectDir: projectDir ?? null,
     };
 }

package/dist/orchestration/evidence.js

@@ -32,6 +32,31 @@ function extractEvidence(rows) {
     }
     return { lastAssistant, toolResults: toolResults.slice(-3) };
 }
+function resolveQaAgentId(task) {
+    if (typeof task.qaAgentId === 'string' && task.qaAgentId.trim().length > 0) {
+        return task.qaAgentId.trim();
+    }
+    const roleMap = task.roleAgentMap;
+    if (roleMap && typeof roleMap === 'object') {
+        const qaAgents = roleMap.qa;
+        if (Array.isArray(qaAgents) && qaAgents.length > 0) {
+            const fromRoleMap = String(qaAgents[0]).trim();
+            if (fromRoleMap.length > 0)
+                return fromRoleMap;
+        }
+    }
+    const required = Array.isArray(task.requiredAgents) ? task.requiredAgents : [];
+    if (required.length === 1) {
+        const only = String(required[0]).trim();
+        if (only.length > 0)
+            return only;
+    }
+    const orchestratorId = typeof task.orchestratorId === 'string' && task.orchestratorId.trim().length > 0
+        ? task.orchestratorId.trim()
+        : null;
+    const fallback = required.find((agentId) => String(agentId).trim().length > 0 && String(agentId).trim() !== orchestratorId);
+    return fallback ? String(fallback).trim() : null;
+}
 export function collectEvidence(paths, params) {
     ensureBaseState(paths);
     const task = loadTask(paths, params.taskId);
@@ -83,9 +108,11 @@ export function mergeEvidence(paths, params) {
     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 qaAgentId = resolveQaAgentId(task);
+    const qaPresent = qaAgentId ? presentAgents.includes(qaAgentId) : false;
+    const qaRequiredSatisfied = !(params.requireQa ?? false) || (qaAgentId !== null && qaPresent);
+    const complete = missingAgents.length === 0 && qaRequiredSatisfied;
+    const merged = { ts: nowIso(), taskId: params.taskId, requiredAgents, presentAgents, missingAgents, qaAgentId, qaPresent, complete, items };
     const outPath = path.join(taskDir, '_merged.json');
     fs.writeFileSync(outPath, `${JSON.stringify(merged, null, 2)}\n`, 'utf8');
     appendEvent(paths.eventsFile, {
@@ -93,5 +120,5 @@ export function mergeEvidence(paths, params) {
         payload: { requiredAgents, missingAgents, complete, mergedPath: outPath, qaPresent },
     });
     rebuildIndex(paths);
-    return { ok: true, taskId: params.taskId, complete, missingAgents, mergedPath: outPath };
+    return { ok: true, taskId: params.taskId, complete, missingAgents, qaAgentId, qaPresent, mergedPath: outPath };
 }

package/dist/orchestration/finalize.d.ts

@@ -1,6 +1,7 @@
 import { type ZigrixPaths } from '../state/paths.js';
 export declare function finalizeTask(paths: ZigrixPaths, params: {
     taskId: string;
+    /** Auto-transition to REPORTED when complete. Defaults to true. */
     autoReport?: boolean;
     secIssues?: boolean;
     qaIssues?: boolean;

package/dist/orchestration/finalize.js

@@ -15,8 +15,10 @@ function autoCloseCompletedUnits(task) {
         if (s.status === 'done')
             doneAgents.add(agentId);
     }
-    // pro-zig is always "done" at finalize time
-    doneAgents.add('pro-zig');
+    // orchestrator is always "done" at finalize time when identifiable
+    if (typeof task.orchestratorId === 'string' && task.orchestratorId.trim().length > 0) {
+        doneAgents.add(task.orchestratorId.trim());
+    }
     let changed = false;
     for (const unit of units) {
         if (['OPEN', 'IN_PROGRESS'].includes(unit.status.toUpperCase()) && doneAgents.has(unit.owner)) {
@@ -130,7 +132,7 @@ export function finalizeTask(paths, params) {
         steps,
     };
     if (complete) {
-        result.nextAction = 'sessions_send(sessionKey: "agent:main:main", message: "<taskId> 완료: <요약>")';
+        result.nextAction = 'send final task report to the requesting channel/thread';
     }
     return result;
 }

package/dist/orchestration/report.js

@@ -44,7 +44,15 @@ function collectRisks(merged) {
 }
 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 미실행';
+    const qaAgentId = typeof merged.qaAgentId === 'string' && merged.qaAgentId.trim().length > 0
+        ? merged.qaAgentId
+        : null;
+    if (!qaAgentId) {
+        return '- QA 역할 에이전트가 식별되지 않음 (config.agents.registry role=qa 확인 필요)';
+    }
+    return present.has(qaAgentId)
+        ? `- ${qaAgentId} evidence 존재, QA 수행됨`
+        : `- ${qaAgentId} evidence 없음 또는 별도 QA 미실행`;
 }
 export function renderReport(paths, params) {
     const task = loadTask(paths, params.taskId);

package/dist/orchestration/worker.d.ts

@@ -1,6 +1,6 @@
 import { type ZigrixPaths } from '../state/paths.js';
 import { type ZigrixTask } from '../state/tasks.js';
-export declare const DEFAULT_REQUIRED_AGENTS: string[];
+export declare const DEFAULT_REQUIRED_ROLES: readonly ["orchestrator", "qa"];
 export declare function resolveRequiredAgents(task: Partial<ZigrixTask> & Record<string, unknown>): string[];
 export declare function prepareWorker(paths: ZigrixPaths, params: {
     taskId: string;

package/dist/orchestration/worker.js

@@ -2,8 +2,38 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { appendEvent } from '../state/events.js';
 import { ensureBaseState } from '../state/paths.js';
-import { loadTask, saveTask } from '../state/tasks.js';
-export const DEFAULT_REQUIRED_AGENTS = ['pro-zig', 'qa-zig'];
+import { loadTask, resolveTaskPaths, saveTask } from '../state/tasks.js';
+export const DEFAULT_REQUIRED_ROLES = ['orchestrator', 'qa'];
+function firstNonEmpty(...values) {
+    for (const value of values) {
+        if (typeof value === 'string' && value.trim().length > 0) {
+            return value.trim();
+        }
+    }
+    return null;
+}
+function roleFallback(task, role) {
+    const roleMap = task.roleAgentMap;
+    if (roleMap && typeof roleMap === 'object') {
+        const mapped = roleMap[role];
+        if (Array.isArray(mapped) && mapped.length > 0) {
+            const first = firstNonEmpty(mapped[0]);
+            if (first)
+                return first;
+        }
+    }
+    return null;
+}
+function resolveDefaultRequiredAgents(task) {
+    const resolvedByRole = {
+        orchestrator: firstNonEmpty(task.orchestratorId) ?? roleFallback(task, 'orchestrator'),
+        qa: firstNonEmpty(task.qaAgentId) ?? roleFallback(task, 'qa'),
+    };
+    const resolved = DEFAULT_REQUIRED_ROLES
+        .map((role) => resolvedByRole[role])
+        .filter((item) => Boolean(item && item.length > 0));
+    return [...new Set(resolved)];
+}
 export function resolveRequiredAgents(task) {
     for (const key of ['requiredAgents', 'selectedAgents', 'baselineRequiredAgents']) {
         const value = task[key];
@@ -15,7 +45,7 @@ export function resolveRequiredAgents(task) {
     if (workers && typeof workers === 'object' && Object.keys(workers).length > 0) {
         return Object.keys(workers).sort();
     }
-    return [...DEFAULT_REQUIRED_AGENTS];
+    return resolveDefaultRequiredAgents(task);
 }
 function renderPrompt(params) {
     const sections = [
@@ -39,7 +69,7 @@ function renderPrompt(params) {
     if (params.unitId || params.workPackage) {
         sections.push('', '### Execution Context', `- unitId: ${params.unitId ?? 'N/A'}`, `- workPackage: ${params.workPackage ?? 'N/A'}`);
     }
-    sections.push('', '### Completion', '작업 완료 후 결과와 근거를 명확히 보고하라.');
+    sections.push('', '### Completion', '작업 완료 후 다음 순서를 반드시 따르라:', '', '1. **증적(evidence) 수집** — 작업 결과 증적을 먼저 기록한다:', '   ```bash', `   zigrix evidence collect --task-id ${params.task.taskId} --agent-id ${params.agentId} --summary "<작업 결과 요약>"`, '   ```', '2. **결과 보고** — 증적 수집 완료 후 결과와 근거를 명확히 보고하라.', '', '⚠️ 증적 없이 완료하면 finalize에서 incomplete 판정된다.');
     return sections.join('\n');
 }
 export function prepareWorker(paths, params) {
@@ -73,18 +103,38 @@ export function prepareWorker(paths, params) {
         workPackage: params.workPackage,
         payload: { agentId: params.agentId, description: params.description, constraints: params.constraints ?? '', dod: params.dod ?? '', promptPath },
     });
-    return { ok: true, taskId: params.taskId, agentId: params.agentId, promptPath, prompt, unitId: params.unitId, workPackage: params.workPackage };
+    return {
+        ok: true,
+        taskId: params.taskId,
+        agentId: params.agentId,
+        promptPath,
+        prompt,
+        unitId: params.unitId,
+        workPackage: params.workPackage,
+        projectDir: projectDir ?? null,
+        ...resolveTaskPaths(paths, params.taskId),
+    };
+}
+/**
+ * Extract sessionId from a sessionKey of the form `agent:<agentId>:subagent:<sessionId>`.
+ * Returns null if the sessionKey does not match the expected pattern.
+ */
+function parseSessionIdFromKey(sessionKey) {
+    const matched = sessionKey.match(/^agent:[^:]+:subagent:([^:\s]+)$/);
+    return matched?.[1] ?? null;
 }
 export function registerWorker(paths, params) {
     const task = loadTask(paths, params.taskId);
     if (!task)
         return null;
+    // Resolve sessionId: use provided value, or fall back to parsing it from sessionKey
+    const resolvedSessionId = params.sessionId || parseSessionIdFromKey(params.sessionKey) || null;
     task.workerSessions[params.agentId] = {
         ...(task.workerSessions[params.agentId] ?? {}),
         status: 'dispatched',
         sessionKey: params.sessionKey,
         runId: params.runId ?? '',
-        sessionId: params.sessionId ?? null,
+        sessionId: resolvedSessionId,
         unitId: params.unitId,
         workPackage: params.workPackage,
         reason: params.reason ?? '',
@@ -96,10 +146,10 @@ export function registerWorker(paths, params) {
     saveTask(paths, task);
     appendEvent(paths.eventsFile, {
         event: 'worker_dispatched', taskId: params.taskId, phase: 'execution', actor: 'zigrix', targetAgent: params.agentId, status: 'IN_PROGRESS',
-        sessionKey: params.sessionKey, sessionId: params.sessionId ?? null, unitId: params.unitId, workPackage: params.workPackage,
+        sessionKey: params.sessionKey, sessionId: resolvedSessionId, unitId: params.unitId, workPackage: params.workPackage,
         payload: { agentId: params.agentId, runId: params.runId ?? '', reason: params.reason ?? '' },
     });
-    return { ok: true, taskId: params.taskId, agentId: params.agentId, sessionKey: params.sessionKey, runId: params.runId ?? '', sessionId: params.sessionId ?? null, unitId: params.unitId, workPackage: params.workPackage, status: 'dispatched' };
+    return { ok: true, taskId: params.taskId, agentId: params.agentId, sessionKey: params.sessionKey, runId: params.runId ?? '', sessionId: resolvedSessionId, unitId: params.unitId, workPackage: params.workPackage, status: 'dispatched' };
 }
 export function completeWorker(paths, params) {
     const task = loadTask(paths, params.taskId);

package/dist/rules/templates.js

@@ -1,3 +1,4 @@
+import { STANDARD_AGENT_ROLES } from '../agents/roles.js';
 export const TEMPLATE_PLACEHOLDERS = {
     workerPrompt: ['taskId', 'title', 'scale', 'agentId', 'description', 'constraints', 'requiredRoles', 'workPackage', 'unitId'],
     finalReport: ['taskId', 'title', 'scale', 'status', 'summary', 'missingAgents'],
@@ -36,12 +37,8 @@ export function validateTemplate(kind, body) {
 }
 export function validateRules(config) {
     const knownRoles = new Set(Object.values(config.agents.registry).map((agent) => agent.role));
-    knownRoles.add('orchestrator');
-    knownRoles.add('qa');
-    knownRoles.add('frontend');
-    knownRoles.add('backend');
-    knownRoles.add('security');
-    knownRoles.add('infra');
+    for (const role of STANDARD_AGENT_ROLES)
+        knownRoles.add(role);
     const invalidRoles = new Set();
     for (const scale of Object.values(config.rules.scales)) {
         for (const role of [...scale.requiredRoles, ...scale.optionalRoles]) {

package/dist/state/tasks.d.ts

@@ -31,9 +31,21 @@ export type ZigrixTask = {
     selectedAgents?: string[];
     workPackages?: WorkPackage[];
     executionUnits?: ExecutionUnit[];
+    baselineRequiredAgents?: string[];
+    candidateAgents?: string[];
+    requiredRoles?: string[];
+    optionalRoles?: string[];
+    roleAgentMap?: Record<string, string[]>;
+    orchestratorId?: string;
+    qaAgentId?: string;
     orchestratorSessionKey?: string;
     orchestratorSessionId?: string;
 };
+export declare function resolveTaskPaths(paths: ZigrixPaths, taskId: string): {
+    specPath: string;
+    metaPath: string;
+    legacyPath: string;
+};
 export declare function nextTaskId(paths: ZigrixPaths, prefix?: string): string;
 export declare function saveTask(paths: ZigrixPaths, task: ZigrixTask): ZigrixTask;
 export declare function loadTask(paths: ZigrixPaths, taskId: string): ZigrixTask | null;

package/dist/state/tasks.js

@@ -14,6 +14,13 @@ function specPath(paths, taskId) {
 function legacyPath(paths, taskId) {
     return path.join(paths.tasksDir, `${taskId}.json`);
 }
+export function resolveTaskPaths(paths, taskId) {
+    return {
+        specPath: specPath(paths, taskId),
+        metaPath: metaPath(paths, taskId),
+        legacyPath: legacyPath(paths, taskId),
+    };
+}
 // ─── Read helpers ───────────────────────────────────────────────────────────
 function readJson(filePath) {
     try {

package/package.json

@@ -1,9 +1,29 @@
 {
   "name": "zigrix",
-  "version": "0.1.0-alpha.8",
+  "version": "0.1.0",
   "type": "module",
   "description": "Multi-project parallel task orchestration CLI for agent-assisted development",
   "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/owen-ever/zigrix.git"
+  },
+  "homepage": "https://github.com/owen-ever/zigrix",
+  "bugs": {
+    "url": "https://github.com/owen-ever/zigrix/issues"
+  },
+  "author": "Chanho Jeon",
+  "keywords": [
+    "zigrix",
+    "cli",
+    "openclaw",
+    "multi-agent",
+    "agent-orchestration",
+    "task-orchestration",
+    "agent-matrix",
+    "task-matrix",
+    "workflow"
+  ],
   "bin": {
     "zigrix": "./dist/index.js"
   },
@@ -23,7 +43,8 @@
     "prebuild": "npm run clean",
     "prepack": "npm run build && npm run build:dashboard",
     "publish:check": "npm run build && npm run build:dashboard && npm run test && npm run smoke && bash scripts/release-smoke.sh && npm pack --dry-run",
-    "smoke": "node dist/index.js --version && node dist/index.js config validate --json",
+    "release": "tsx scripts/release.ts",
+    "smoke": "node dist/index.js --version",
     "pretest": "npm run build",
     "test": "vitest run",
     "typecheck": "tsc -p tsconfig.json --noEmit"