@gh-symphony/cli 0.0.17 → 0.0.19

package/dist/worker-entry.js

@@ -3,7 +3,7 @@ import {
   classifySessionExit,
   parseWorkflowMarkdown,
   readEnvFile
-} from "./chunk-TF3QNWNC.js";
+} from "./chunk-M3IFVLQS.js";
 
 // ../worker/dist/index.js
 import { spawn as spawn2 } from "child_process";
@@ -668,7 +668,29 @@ function normalizeContinuationVariable(value) {
   return normalized ? normalized : null;
 }
 function renderContinuationGuidance(template, variables) {
-  return template.replace(/\{\{\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\}\}/g, (match, key) => variables[key] ?? match);
+  if (template.includes("{%") || template.includes("%}")) {
+    throw new Error("template_parse_error: continuation guidance does not support Liquid tags.");
+  }
+  let rendered = "";
+  let lastIndex = 0;
+  const pattern = /\{\{\s*([a-zA-Z_][a-zA-Z0-9_.]*)\s*\}\}/g;
+  for (const match of template.matchAll(pattern)) {
+    const matchedText = match[0];
+    const expression = match[1];
+    const index = match.index ?? 0;
+    rendered += template.slice(lastIndex, index);
+    if (!(expression in variables)) {
+      throw new Error(`template_render_error: unsupported continuation guidance variable '${expression}'.`);
+    }
+    rendered += variables[expression] ?? "";
+    lastIndex = index + matchedText.length;
+  }
+  rendered += template.slice(lastIndex);
+  const strayLiquidExpression = rendered.match(/\{\{[^}]*\}\}/);
+  if (strayLiquidExpression) {
+    throw new Error(`template_parse_error: invalid continuation guidance expression '${strayLiquidExpression[0]}'.`);
+  }
+  return rendered;
 }
 
 // ../worker/dist/token-usage.js
@@ -770,7 +792,7 @@ function shutdown(signal) {
     }
     stopOrchestratorHeartbeatTimer();
     emitOrchestratorHeartbeat();
-    await persistTokenUsageArtifact(launcherEnv, runtimeState.tokenUsage);
+    await persistSessionTokenUsageArtifact(launcherEnv);
     await waitForPendingOrchestratorChannelFlush(resolveTerminalOrchestratorChannelFlushTimeoutMs());
     console.log(`Worker stopped on ${signal}`);
     process.exit(0);
@@ -854,7 +876,7 @@ function emitOrchestratorHeartbeat() {
     type: "heartbeat",
     issueId,
     lastEventAt: runtimeState.lastEventAt,
-    tokenUsage: { ...runtimeState.tokenUsage },
+    tokenUsage: resolveSessionTokenUsageDelta(),
     rateLimits: runtimeState.rateLimits ? { ...runtimeState.rateLimits } : null,
     sessionInfo: { ...runtimeState.sessionInfo },
     executionPhase: runtimeState.executionPhase,
@@ -890,7 +912,7 @@ function emitOrchestratorChannelEvent(event) {
     type: "codex_update",
     issueId,
     lastEventAt,
-    tokenUsage: { ...runtimeState.tokenUsage },
+    tokenUsage: resolveSessionTokenUsageDelta(),
     sessionInfo: { ...runtimeState.sessionInfo },
     executionPhase: runtimeState.executionPhase,
     runPhase: runtimeState.runPhase,
@@ -915,6 +937,12 @@ function resolveTurnTokenUsageDelta(baseline) {
     totalTokens: Math.max(0, runtimeState.tokenUsage.totalTokens - baseline.totalTokens)
   };
 }
+function resolveSessionTokenUsageDelta() {
+  return resolveTurnTokenUsageDelta(sessionBudgetState.tokenUsageBaseline);
+}
+async function persistSessionTokenUsageArtifact(env) {
+  await persistTokenUsageArtifact(env, resolveSessionTokenUsageDelta());
+}
 function emitTurnStartedEvent(turn) {
   const issueId = runtimeState.run?.issueId;
   if (!issueId) {
@@ -1014,7 +1042,7 @@ async function startAssignedRun() {
           runtimeState.run.lastError = code === 0 && !signal ? null : `codex app-server exited with ${signal ?? code ?? "unknown"}`;
         }
       }
-      void persistTokenUsageArtifact(launcherEnv, runtimeState.tokenUsage);
+      void persistSessionTokenUsageArtifact(launcherEnv);
     });
     childProcess.once("error", (error) => {
       runtimeState.status = "failed";
@@ -1022,7 +1050,7 @@ async function startAssignedRun() {
       if (runtimeState.run) {
         runtimeState.run.lastError = error.message;
       }
-      void persistTokenUsageArtifact(launcherEnv, runtimeState.tokenUsage);
+      void persistSessionTokenUsageArtifact(launcherEnv);
     });
   } catch (error) {
     runtimeState.status = "failed";
@@ -1030,7 +1058,7 @@ async function startAssignedRun() {
     if (runtimeState.run) {
       runtimeState.run.lastError = error instanceof Error ? error.message : "Unknown worker startup error";
     }
-    await persistTokenUsageArtifact(launcherEnv, runtimeState.tokenUsage);
+    await persistSessionTokenUsageArtifact(launcherEnv);
   }
 }
 async function runCodexClientProtocol(child, plan, env, options) {
@@ -1414,7 +1442,7 @@ async function runCodexClientProtocol(child, plan, env, options) {
       });
       stopOrchestratorHeartbeatTimer();
       emitOrchestratorHeartbeat();
-      await persistTokenUsageArtifact(env, runtimeState.tokenUsage);
+      await persistSessionTokenUsageArtifact(env);
       await waitForPendingOrchestratorChannelFlush(resolveTerminalOrchestratorChannelFlushTimeoutMs());
       setTimeout(() => {
         process.exit(0);
@@ -1600,7 +1628,7 @@ async function runCodexClientProtocol(child, plan, env, options) {
     });
     stopOrchestratorHeartbeatTimer();
     emitOrchestratorHeartbeat();
-    await persistTokenUsageArtifact(env, runtimeState.tokenUsage);
+    await persistSessionTokenUsageArtifact(env);
     await waitForPendingOrchestratorChannelFlush(resolveTerminalOrchestratorChannelFlushTimeoutMs());
     setTimeout(() => {
       process.exit(userInputRequired || turnTerminalFailurePhase ? 1 : 0);
@@ -1638,7 +1666,7 @@ async function runCodexClientProtocol(child, plan, env, options) {
     }
     stopOrchestratorHeartbeatTimer();
     emitOrchestratorHeartbeat();
-    await persistTokenUsageArtifact(env, runtimeState.tokenUsage);
+    await persistSessionTokenUsageArtifact(env);
     await waitForPendingOrchestratorChannelFlush(resolveTerminalOrchestratorChannelFlushTimeoutMs());
     setTimeout(() => {
       process.exit(1);

package/dist/workflow-TBIFY5MO.js

@@ -0,0 +1,497 @@
+#!/usr/bin/env node
+import {
+  init_default
+} from "./chunk-RN2PACNV.js";
+import {
+  buildPromptVariables,
+  parseWorkflowMarkdown,
+  renderPrompt
+} from "./chunk-M3IFVLQS.js";
+import "./chunk-TILHWBP6.js";
+import "./chunk-ROGRTUFI.js";
+
+// src/commands/workflow.ts
+import { readFile } from "fs/promises";
+import { resolve } from "path";
+var SAMPLE_ISSUE = {
+  id: "issue-157-sample",
+  identifier: "octo/hello-world#157",
+  number: 157,
+  title: "Add workflow validate and preview commands",
+  description: "Expose strict WORKFLOW.md validation and prompt preview flows in the CLI.",
+  priority: 1,
+  state: "In progress",
+  branchName: "feat/workflow-cli-preview",
+  url: "https://github.com/octo/hello-world/issues/157",
+  labels: ["enhancement", "cli"],
+  blockedBy: [
+    {
+      id: "issue-120",
+      identifier: "octo/hello-world#120",
+      state: "Done"
+    }
+  ],
+  createdAt: "2026-03-31T02:06:39Z",
+  updatedAt: "2026-04-03T02:28:21Z",
+  repository: {
+    owner: "octo",
+    name: "hello-world",
+    cloneUrl: "https://github.com/octo/hello-world.git",
+    url: "https://github.com/octo/hello-world"
+  },
+  tracker: {
+    adapter: "github-project",
+    bindingId: "sample-binding",
+    itemId: "sample-item"
+  },
+  metadata: {}
+};
+var SAMPLE_CONTINUATION_VARIABLES = {
+  lastTurnSummary: "Validated the prompt template and updated the CLI routing.",
+  cumulativeTurnCount: 3
+};
+function parseWorkflowArgs(args) {
+  const [subcommand, ...rest] = args;
+  if (!subcommand) {
+    return { args: [] };
+  }
+  if (subcommand === "init" || subcommand === "validate" || subcommand === "preview") {
+    return { subcommand, args: rest };
+  }
+  if (subcommand === "--help" || subcommand === "-h") {
+    return { args: ["--help"] };
+  }
+  return {
+    args: rest,
+    error: `Unknown workflow subcommand '${subcommand}'`
+  };
+}
+function parseValidateFlags(args) {
+  const flags = {};
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--file") {
+      const value = args[i + 1];
+      if (!value || value.startsWith("-")) {
+        throw new Error("Option '--file' argument missing");
+      }
+      flags.file = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("-")) {
+      throw new Error(`Unknown option '${arg}'`);
+    }
+  }
+  return flags;
+}
+function parsePreviewFlags(args) {
+  const flags = {
+    attempt: null
+  };
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    const value = args[i + 1];
+    switch (arg) {
+      case "--file":
+        if (!value || value.startsWith("-")) {
+          throw new Error("Option '--file' argument missing");
+        }
+        flags.file = value;
+        i += 1;
+        break;
+      case "--sample":
+        if (!value || value.startsWith("-")) {
+          throw new Error("Option '--sample' argument missing");
+        }
+        flags.sample = value;
+        i += 1;
+        break;
+      case "--attempt":
+        if (!value || value.startsWith("-")) {
+          throw new Error("Option '--attempt' argument missing");
+        }
+        flags.attempt = parseAttempt(value);
+        i += 1;
+        break;
+      default:
+        if (arg?.startsWith("-")) {
+          throw new Error(`Unknown option '${arg}'`);
+        }
+        break;
+    }
+  }
+  return flags;
+}
+function parseAttempt(value) {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed < 1) {
+    throw new Error("Option '--attempt' must be a positive integer");
+  }
+  return parsed;
+}
+function printWorkflowUsage() {
+  process.stdout.write(`Usage: gh-symphony workflow <command> [options]
+
+Commands:
+  init       Generate WORKFLOW.md and workflow support files
+  validate   Parse and strictly validate a WORKFLOW.md file
+  preview    Render the final worker prompt from a sample issue
+
+Options:
+  workflow init [--non-interactive] [--project <id>] [--output <path>] [--skip-skills] [--skip-context] [--dry-run]
+  workflow validate [--file <path>]
+  workflow preview [--file <path>] [--sample <json>] [--attempt <n>]
+`);
+}
+async function loadWorkflowMarkdown(workflowPath) {
+  const resolvedPath = resolve(workflowPath ?? "WORKFLOW.md");
+  const markdown = await readFile(resolvedPath, "utf8");
+  return {
+    workflowPath: resolvedPath,
+    markdown
+  };
+}
+function normalizeIssue(value) {
+  if (!value || typeof value !== "object") {
+    throw new Error("Sample JSON must be an object.");
+  }
+  const record = value;
+  const repositoryRecord = asRecord(record.repository, "repository");
+  const repositoryOwner = readRequiredString(
+    repositoryRecord.owner,
+    "repository.owner"
+  );
+  const repositoryName = readRequiredString(
+    repositoryRecord.name,
+    "repository.name"
+  );
+  const repositoryUrl = readOptionalString(repositoryRecord.url, "repository.url");
+  return {
+    id: readRequiredString(record.id, "id"),
+    identifier: readRequiredString(record.identifier, "identifier"),
+    number: readRequiredNumber(record.number, "number"),
+    title: readRequiredString(record.title, "title"),
+    description: readOptionalString(record.description, "description"),
+    priority: readOptionalNumber(record.priority, "priority"),
+    state: readRequiredString(record.state, "state"),
+    branchName: readOptionalString(
+      record.branchName ?? record.branch_name,
+      "branchName/branch_name"
+    ),
+    url: readOptionalString(record.url, "url"),
+    labels: readStringArray(record.labels, "labels"),
+    blockedBy: readBlockers(record.blockedBy ?? record.blocked_by),
+    createdAt: readOptionalString(
+      record.createdAt ?? record.created_at,
+      "createdAt/created_at"
+    ),
+    updatedAt: readOptionalString(
+      record.updatedAt ?? record.updated_at,
+      "updatedAt/updated_at"
+    ),
+    repository: {
+      owner: repositoryOwner,
+      name: repositoryName,
+      cloneUrl: readOptionalString(repositoryRecord.cloneUrl, "repository.cloneUrl") ?? `https://github.com/${repositoryOwner}/${repositoryName}.git`,
+      ...repositoryUrl ? { url: repositoryUrl } : {}
+    },
+    tracker: {
+      adapter: "github-project",
+      bindingId: "preview-sample",
+      itemId: readOptionalString(record.itemId, "itemId") ?? "preview-sample"
+    },
+    metadata: {}
+  };
+}
+function asRecord(value, field) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`Sample JSON field '${field}' must be an object.`);
+  }
+  return value;
+}
+function readRequiredString(value, field) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`Sample JSON field '${field}' must be a non-empty string.`);
+  }
+  return value;
+}
+function readOptionalString(value, field) {
+  if (value === null || value === void 0 || value === "") {
+    return null;
+  }
+  if (typeof value !== "string") {
+    throw new Error(`Sample JSON field '${field}' must be a string.`);
+  }
+  return value;
+}
+function readRequiredNumber(value, field) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error(`Sample JSON field '${field}' must be a number.`);
+  }
+  return value;
+}
+function readOptionalNumber(value, field) {
+  if (value === null || value === void 0 || value === "") {
+    return null;
+  }
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error(`Sample JSON field '${field}' must be a number.`);
+  }
+  return value;
+}
+function readStringArray(value, field) {
+  if (value === void 0) {
+    return [];
+  }
+  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) {
+    throw new Error(`Sample JSON field '${field}' must be an array of strings.`);
+  }
+  return value;
+}
+function readBlockers(value) {
+  if (value === void 0) {
+    return [];
+  }
+  if (!Array.isArray(value)) {
+    throw new Error("Sample JSON field 'blockedBy/blocked_by' must be an array.");
+  }
+  return value.map((entry, index) => {
+    const record = asRecord(entry, `blockedBy/blocked_by[${index}]`);
+    return {
+      id: readOptionalString(record.id, `blockedBy/blocked_by[${index}].id`),
+      identifier: readOptionalString(
+        record.identifier,
+        `blockedBy/blocked_by[${index}].identifier`
+      ),
+      state: readOptionalString(
+        record.state,
+        `blockedBy/blocked_by[${index}].state`
+      )
+    };
+  });
+}
+function validateContinuationGuidance(template) {
+  if (template.includes("{%") || template.includes("%}")) {
+    throw new Error(
+      "template_parse_error: continuation guidance does not support Liquid tags."
+    );
+  }
+  const pattern = /\{\{\s*([a-zA-Z_][a-zA-Z0-9_.]*)\s*\}\}/g;
+  let rendered = "";
+  let lastIndex = 0;
+  for (const match of template.matchAll(pattern)) {
+    const expression = match[1];
+    const index = match.index ?? 0;
+    rendered += template.slice(lastIndex, index);
+    if (!(expression in SAMPLE_CONTINUATION_VARIABLES)) {
+      throw new Error(
+        `template_render_error: unsupported continuation guidance variable '${expression}'.`
+      );
+    }
+    rendered += String(
+      SAMPLE_CONTINUATION_VARIABLES[expression]
+    );
+    lastIndex = index + match[0].length;
+  }
+  rendered += template.slice(lastIndex);
+  const strayLiquidExpression = rendered.match(/\{\{[^}]*\}\}/);
+  if (strayLiquidExpression) {
+    throw new Error(
+      `template_parse_error: invalid continuation guidance expression '${strayLiquidExpression[0]}'.`
+    );
+  }
+}
+async function loadSampleIssue(samplePath) {
+  if (!samplePath) {
+    return { issue: SAMPLE_ISSUE, sampleSource: "built-in" };
+  }
+  const resolvedPath = resolve(samplePath);
+  const raw = await readFile(resolvedPath, "utf8");
+  return {
+    issue: normalizeIssue(JSON.parse(raw)),
+    sampleSource: resolvedPath
+  };
+}
+function validateWorkflow(workflowPath, markdown) {
+  const workflow = parseWorkflowMarkdown(markdown);
+  const promptFreshVariables = buildPromptVariables(SAMPLE_ISSUE, {
+    attempt: null
+  });
+  const promptRetryVariables = buildPromptVariables(SAMPLE_ISSUE, {
+    attempt: 2
+  });
+  renderPrompt(workflow.promptTemplate, promptFreshVariables, { strict: true });
+  renderPrompt(workflow.promptTemplate, promptRetryVariables, { strict: true });
+  const continuationGuidanceStatus = workflow.continuationGuidance ? (() => {
+    validateContinuationGuidance(workflow.continuationGuidance);
+    return "pass";
+  })() : "skip";
+  return {
+    ok: true,
+    workflowPath,
+    format: workflow.format,
+    checks: {
+      promptFresh: "pass",
+      promptRetry: "pass",
+      continuationGuidance: continuationGuidanceStatus
+    },
+    summary: {
+      trackerKind: workflow.tracker.kind,
+      githubProjectId: workflow.githubProjectId,
+      stateFieldName: workflow.lifecycle.stateFieldName,
+      activeStates: workflow.lifecycle.activeStates,
+      terminalStates: workflow.lifecycle.terminalStates,
+      blockerCheckStates: workflow.lifecycle.blockerCheckStates,
+      pollingIntervalMs: workflow.polling.intervalMs,
+      workspaceRoot: workflow.workspace.root,
+      agentCommand: workflow.agentCommand,
+      maxConcurrentAgents: workflow.agent.maxConcurrentAgents,
+      maxFailureRetries: workflow.agent.maxFailureRetries,
+      maxTurns: workflow.agent.maxTurns,
+      retryBaseDelayMs: workflow.agent.retryBaseDelayMs,
+      maxRetryBackoffMs: workflow.agent.maxRetryBackoffMs,
+      codex: {
+        approvalPolicy: workflow.codex.approvalPolicy,
+        threadSandbox: workflow.codex.threadSandbox,
+        turnSandboxPolicy: workflow.codex.turnSandboxPolicy,
+        readTimeoutMs: workflow.codex.readTimeoutMs,
+        stallTimeoutMs: workflow.codex.stallTimeoutMs,
+        turnTimeoutMs: workflow.codex.turnTimeoutMs
+      },
+      hooks: {
+        afterCreate: workflow.hooks.afterCreate,
+        beforeRun: workflow.hooks.beforeRun,
+        afterRun: workflow.hooks.afterRun,
+        beforeRemove: workflow.hooks.beforeRemove,
+        timeoutMs: workflow.hooks.timeoutMs
+      }
+    }
+  };
+}
+function printValidationReport(report) {
+  process.stdout.write(`WORKFLOW.md validation passed
+Path: ${report.workflowPath}
+Format: ${report.format}
+Prompt checks: fresh=pass, retry=pass, continuation_guidance=${report.checks.continuationGuidance}
+
+Lifecycle
+  tracker.kind=${report.summary.trackerKind ?? "unset"}
+  tracker.project_id=${report.summary.githubProjectId ?? "unset"}
+  tracker.state_field=${report.summary.stateFieldName}
+  active_states=${report.summary.activeStates.join(", ") || "(none)"}
+  terminal_states=${report.summary.terminalStates.join(", ") || "(none)"}
+  blocker_check_states=${report.summary.blockerCheckStates.join(", ") || "(none)"}
+
+Runtime
+  polling.interval_ms=${report.summary.pollingIntervalMs}
+  workspace.root=${report.summary.workspaceRoot ?? "unset"}
+  codex.command=${report.summary.agentCommand}
+  agent.max_concurrent_agents=${report.summary.maxConcurrentAgents}
+  agent.max_failure_retries=${report.summary.maxFailureRetries}
+  agent.max_turns=${report.summary.maxTurns}
+  agent.retry_base_delay_ms=${report.summary.retryBaseDelayMs}
+  agent.max_retry_backoff_ms=${report.summary.maxRetryBackoffMs}
+  codex.approval_policy=${report.summary.codex.approvalPolicy ?? "unset"}
+  codex.thread_sandbox=${report.summary.codex.threadSandbox ?? "unset"}
+  codex.turn_sandbox_policy=${report.summary.codex.turnSandboxPolicy ?? "unset"}
+  codex.read_timeout_ms=${report.summary.codex.readTimeoutMs}
+  codex.stall_timeout_ms=${report.summary.codex.stallTimeoutMs}
+  codex.turn_timeout_ms=${report.summary.codex.turnTimeoutMs}
+
+Hooks
+  after_create=${report.summary.hooks.afterCreate ?? "unset"}
+  before_run=${report.summary.hooks.beforeRun ?? "unset"}
+  after_run=${report.summary.hooks.afterRun ?? "unset"}
+  before_remove=${report.summary.hooks.beforeRemove ?? "unset"}
+  hooks.timeout_ms=${report.summary.hooks.timeoutMs}
+`);
+}
+async function runValidate(args, options) {
+  const flags = parseValidateFlags(args);
+  const { workflowPath, markdown } = await loadWorkflowMarkdown(flags.file);
+  const report = validateWorkflow(workflowPath, markdown);
+  if (options.json) {
+    process.stdout.write(`${JSON.stringify(report, null, 2)}
+`);
+    return;
+  }
+  printValidationReport(report);
+}
+async function runPreview(args, options) {
+  const flags = parsePreviewFlags(args);
+  const { workflowPath, markdown } = await loadWorkflowMarkdown(flags.file);
+  const workflow = parseWorkflowMarkdown(markdown);
+  const { issue, sampleSource } = await loadSampleIssue(flags.sample);
+  const variables = buildPromptVariables(issue, {
+    attempt: flags.attempt
+  });
+  const renderedPrompt = renderPrompt(workflow.promptTemplate, variables, {
+    strict: true
+  });
+  if (options.json) {
+    process.stdout.write(
+      `${JSON.stringify(
+        {
+          workflowPath,
+          sampleSource,
+          attempt: flags.attempt,
+          renderedPrompt
+        },
+        null,
+        2
+      )}
+`
+    );
+    return;
+  }
+  process.stdout.write(`WORKFLOW.md prompt preview
+Path: ${workflowPath}
+Sample: ${sampleSource}
+Attempt: ${flags.attempt ?? "fresh"}
+
+${renderedPrompt}
+`);
+}
+var handler = async (args, options) => {
+  const parsed = parseWorkflowArgs(args);
+  if (parsed.error) {
+    process.stderr.write(`${parsed.error}
+`);
+    printWorkflowUsage();
+    process.exitCode = 1;
+    return;
+  }
+  if (parsed.args[0] === "--help" || parsed.args[0] === "-h") {
+    printWorkflowUsage();
+    return;
+  }
+  if (!parsed.subcommand) {
+    process.stderr.write("Missing workflow subcommand.\n");
+    printWorkflowUsage();
+    process.exitCode = 1;
+    return;
+  }
+  try {
+    switch (parsed.subcommand) {
+      case "init":
+        await init_default(parsed.args, options);
+        return;
+      case "validate":
+        await runValidate(parsed.args, options);
+        return;
+      case "preview":
+        await runPreview(parsed.args, options);
+        return;
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`Workflow command failed: ${message}
+`);
+    process.exitCode = 1;
+  }
+};
+var workflow_default = handler;
+export {
+  workflow_default as default
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gh-symphony/cli",
-  "version": "0.0.17",
+  "version": "0.0.19",
   "license": "MIT",
   "author": "hojinzs",
   "description": "Interactive CLI for GitHub Symphony orchestration",
@@ -42,10 +42,10 @@
   "devDependencies": {
     "tsup": "^8.5.1",
     "@gh-symphony/core": "0.0.14",
-    "@gh-symphony/tracker-github": "0.0.14",
-    "@gh-symphony/dashboard": "0.0.14",
     "@gh-symphony/orchestrator": "0.0.14",
-    "@gh-symphony/worker": "0.0.14"
+    "@gh-symphony/dashboard": "0.0.14",
+    "@gh-symphony/worker": "0.0.14",
+    "@gh-symphony/tracker-github": "0.0.14"
   },
   "scripts": {
     "build": "tsup",