zigrix 0.1.0-alpha.9 → 0.1.0

package/dist/orchestration/dispatch.js

@@ -1,6 +1,7 @@
 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 { createTask, rebuildIndex, saveTask } from '../state/tasks.js';
 import { ensureBaseState } from '../state/paths.js';
@@ -101,6 +102,17 @@ function resolveAgentSelection(config, scale) {
         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 },
@@ -169,12 +181,13 @@ zigrix task finalize ${task.taskId} --json
 export function dispatchTask(paths, config, params) {
     ensureBaseState(paths);
     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: [...selection.requiredAgents],
-        projectDir: params.projectDir,
+        projectDir,
         requestedBy: params.requestedBy,
     });
     task.selectedAgents = [...selection.requiredAgents];
@@ -203,7 +216,7 @@ export function dispatchTask(paths, config, params) {
         `- **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)'}`,
-        params.projectDir ? `- **Project Dir:** ${params.projectDir}` : '',
+        projectDir ? `- **Project Dir:** ${projectDir}` : '',
         '',
         '### 요청 내용',
         params.description,
@@ -236,7 +249,7 @@ export function dispatchTask(paths, config, params) {
             requiredRoles: selection.requiredRoles,
             optionalRoles: selection.optionalRoles,
             roleAgentMap: selection.roleAgentMap,
-            projectDir: params.projectDir ?? null,
+            projectDir: projectDir ?? null,
         },
     });
     rebuildIndex(paths);
@@ -256,7 +269,6 @@ export function dispatchTask(paths, config, params) {
         metaPath: path.join(paths.tasksDir, `${task.taskId}.meta.json`),
         promptPath,
         orchestratorPrompt,
-        proZigPrompt: orchestratorPrompt,
-        projectDir: params.projectDir ?? null,
+        projectDir: projectDir ?? null,
     };
 }

package/dist/orchestration/evidence.js

@@ -34,16 +34,28 @@ function extractEvidence(rows) {
 }
 function resolveQaAgentId(task) {
     if (typeof task.qaAgentId === 'string' && task.qaAgentId.trim().length > 0) {
-        return task.qaAgentId;
+        return task.qaAgentId.trim();
     }
     const roleMap = task.roleAgentMap;
     if (roleMap && typeof roleMap === 'object') {
         const qaAgents = roleMap.qa;
         if (Array.isArray(qaAgents) && qaAgents.length > 0) {
-            return String(qaAgents[0]);
+            const fromRoleMap = String(qaAgents[0]).trim();
+            if (fromRoleMap.length > 0)
+                return fromRoleMap;
         }
     }
-    return 'qa-zig';
+    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);
@@ -97,8 +109,9 @@ export function mergeEvidence(paths, params) {
     const requiredAgents = [...(params.requiredAgents?.length ? params.requiredAgents : resolveRequiredAgents(task))];
     const missingAgents = requiredAgents.filter((agentId) => !presentAgents.includes(agentId));
     const qaAgentId = resolveQaAgentId(task);
-    const qaPresent = presentAgents.includes(qaAgentId);
-    const complete = missingAgents.length === 0 && (!(params.requireQa ?? false) || qaPresent);
+    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');

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);
     }
-    // orchestrator is always "done" at finalize time
-    doneAgents.add(task.orchestratorId ?? '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

@@ -46,7 +46,10 @@ function qaLine(merged) {
     const present = new Set(Array.isArray(merged.presentAgents) ? merged.presentAgents.map(String) : []);
     const qaAgentId = typeof merged.qaAgentId === 'string' && merged.qaAgentId.trim().length > 0
         ? merged.qaAgentId
-        : 'qa-zig';
+        : null;
+    if (!qaAgentId) {
+        return '- QA 역할 에이전트가 식별되지 않음 (config.agents.registry role=qa 확인 필요)';
+    }
     return present.has(qaAgentId)
         ? `- ${qaAgentId} evidence 존재, QA 수행됨`
         : `- ${qaAgentId} evidence 없음 또는 별도 QA 미실행`;

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: readonly ["orchestrator", "qa"];
+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,22 +2,37 @@ 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 = ['orchestrator', 'qa'];
-const DEFAULT_ORCHESTRATOR_ID = 'pro-zig';
-const DEFAULT_QA_AGENT_ID = '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 orchestratorId = typeof task.orchestratorId === 'string' && task.orchestratorId.trim().length > 0
-        ? task.orchestratorId
-        : DEFAULT_ORCHESTRATOR_ID;
-    const qaAgentId = typeof task.qaAgentId === 'string' && task.qaAgentId.trim().length > 0
-        ? task.qaAgentId
-        : DEFAULT_QA_AGENT_ID;
     const resolvedByRole = {
-        orchestrator: orchestratorId,
-        qa: qaAgentId,
+        orchestrator: firstNonEmpty(task.orchestratorId) ?? roleFallback(task, 'orchestrator'),
+        qa: firstNonEmpty(task.qaAgentId) ?? roleFallback(task, 'qa'),
     };
-    return [...new Set(DEFAULT_REQUIRED_AGENTS.map((role) => resolvedByRole[role]))];
+    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']) {
@@ -54,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) {
@@ -88,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 ?? '',
@@ -111,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/state/tasks.d.ts

@@ -41,6 +41,11 @@ export type ZigrixTask = {
     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.9",
+  "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"

package/rules/defaults/README.md

@@ -1,27 +1,27 @@
 # 6-Agent Orchestration Rule Templates
 
-이 폴더는 `pro-zig` 오케스트레이션 운영을 위한 **규칙 템플릿** 모음이다.
+이 폴더는 `orchestrator-agent` 오케스트레이션 운영을 위한 **규칙 템플릿** 모음이다.
 
 ## 파일 구성
-- `pro-zig.md` — 오케스트레이터 규칙 템플릿
+- `orchestrator-agent.md` — 오케스트레이터 규칙 템플릿
 - `worker-common.md` — 모든 워커 공통 규칙
-- `front-zig.md` — 프론트엔드 워커 규칙
-- `back-zig.md` — 백엔드 워커 규칙
-- `sys-zig.md` — 시스템 설계 워커 규칙
-- `sec-zig.md` — 보안 워커 규칙
-- `qa-zig.md` — QA 워커 규칙
+- `frontend-agent.md` — 프론트엔드 워커 규칙
+- `backend-agent.md` — 백엔드 워커 규칙
+- `system-agent.md` — 시스템 설계 워커 규칙
+- `security-agent.md` — 보안 워커 규칙
+- `qa-agent.md` — QA 워커 규칙
 
 ## 공통 운영 고정값
 - Scale: `simple | normal | risky | large`
 - QA: **모든 Scale 필수 포함**
 - Session visibility: `all` (운영 규칙으로 통제)
 - Thread mapping: `taskId` 기준 유연 매핑 (`primaryThreadId`, `relatedThreadIds[]`)
-- 명세문서 경로: `orchestration/tasks/<taskId>.md`
+- 명세문서 절대경로: `zigrix task status <taskId> --json`의 `specPath`
 - `normal|risky|large`: 명세문서 **미작성 시 진행 금지**
 - `simple`: 요약형 spec 허용(동일 경로 파일)
 
 ## 적용 순서
-1. `pro-zig.md`를 기준으로 작업 분류 + 작업 분배 수행
+1. `orchestrator-agent.md`를 기준으로 작업 분류 + 작업 분배 수행
 2. 각 워커는 `worker-common.md` + 자기 역할 파일을 함께 준수
 3. 결과는 반드시 `taskId`/`sessionKey`/`runId` 증적을 포함
 4. QA 게이트 통과 전 완료 보고 금지

package/rules/defaults/{back-zig.md → backend-agent.md}

@@ -1,10 +1,10 @@
-# back-zig Rules
+# backend-agent Rules
 
-> 공통 규칙: `orchestration/rules/worker-common.md` 참조
+> 공통 규칙: `worker-common.md` 참조
 
 ## Role
 - API, 비즈니스 로직, 데이터 처리, 서버 측 성능/안정성
-- pro-zig 지시(taskId 기반)만 수행
+- orchestrator-agent 지시(taskId 기반)만 수행
 
 ## In Scope
 - 엔드포인트/서비스 로직 구현
@@ -13,7 +13,7 @@
 
 ## Out of Scope
 - UI 결정
-- 보안 정책 최종 승인 (sec-zig 관할)
+- 보안 정책 최종 승인 (security-agent 관할)
 
 ## Required Deliverables
 - API 변경점 (요청/응답/에러코드)

package/rules/defaults/{front-zig.md → frontend-agent.md}

@@ -1,10 +1,10 @@
-# front-zig Rules
+# frontend-agent Rules
 
-> 공통 규칙: `orchestration/rules/worker-common.md` 참조
+> 공통 규칙: `worker-common.md` 참조
 
 ## Role
 - UI/UX, 프론트엔드 구현, 상태관리, API 연동(클라이언트 측)
-- pro-zig 지시(taskId 기반)만 수행
+- orchestrator-agent 지시(taskId 기반)만 수행
 
 ## In Scope
 - 컴포넌트/페이지 구현
@@ -13,7 +13,7 @@
 
 ## Out of Scope
 - 서버 인프라/DB 스키마 변경 단독 확정
-- 보안 정책 최종 승인 (sec-zig 관할)
+- 보안 정책 최종 승인 (security-agent 관할)
 
 ## Required Deliverables
 - 변경 파일 목록