@gh-symphony/cli 0.4.2 → 0.4.4

package/dist/{chunk-OVE4KOBD.js → chunk-4ZHWEQQL.js}

@@ -326,10 +326,19 @@ ${promptBody}
 function buildFrontMatter(input) {
   const lines = [];
   lines.push("tracker:");
-  lines.push("  kind: github-project");
-  lines.push(`  project_id: ${input.projectId}`);
-  lines.push(`  state_field: ${input.stateFieldName}`);
-  lines.push(...buildPriorityFrontMatter(input));
+  if (input.tracker?.kind === "linear") {
+    lines.push("  kind: linear");
+    lines.push(
+      `  endpoint: ${input.tracker.endpoint ?? "https://api.linear.app/graphql"}`
+    );
+    lines.push(`  api_key: ${input.tracker.apiKey ?? "$LINEAR_API_KEY"}`);
+    lines.push(`  project_slug: ${input.tracker.projectSlug}`);
+  } else {
+    lines.push("  kind: github-project");
+    lines.push(`  project_id: ${input.projectId}`);
+    lines.push(`  state_field: ${input.stateFieldName}`);
+    lines.push(...buildPriorityFrontMatter(input));
+  }
   if (input.lifecycle.activeStates.length > 0) {
     lines.push("  active_states:");
     for (const state of input.lifecycle.activeStates) {
@@ -342,6 +351,25 @@ function buildFrontMatter(input) {
       lines.push(`    - ${state}`);
     }
   }
+  if (input.tracker?.kind === "linear") {
+    const include = input.tracker.pickupLabels?.include ?? [];
+    const exclude = input.tracker.pickupLabels?.exclude ?? [];
+    if (include.length > 0 || exclude.length > 0) {
+      lines.push("  pickup_labels:");
+      if (include.length > 0) {
+        lines.push("    include:");
+        for (const label of include) {
+          lines.push(`      - ${label}`);
+        }
+      }
+      if (exclude.length > 0) {
+        lines.push("    exclude:");
+        for (const label of exclude) {
+          lines.push(`      - ${label}`);
+        }
+      }
+    }
+  }
   lines.push(
     ...buildStringListFrontMatter(
       "blocker_check_states",
@@ -2152,6 +2180,14 @@ function parseInitFlags(args) {
         flags.project = next;
         i += 1;
         break;
+      case "--tracker":
+        flags.tracker = next;
+        i += 1;
+        break;
+      case "--linear-project-slug":
+        flags.linearProjectSlug = next;
+        i += 1;
+        break;
       case "--output":
         flags.output = next;
         i += 1;
@@ -2173,7 +2209,7 @@ function parseInitFlags(args) {
 function warnDeprecatedSkipContext() {
   p.log.warn(SKIP_CONTEXT_DEPRECATION);
 }
-async function runInitRuntimePreflight(runtime) {
+async function runInitRuntimePreflight(runtime, opts = {}) {
   if (!isClaudeRuntime(runtime)) {
     return true;
   }
@@ -2183,7 +2219,7 @@ async function runInitRuntimePreflight(runtime) {
     env: process.env,
     command: resolveClaudeCommandBinary(resolveRuntimeCommand(runtime)) ?? resolveRuntimeCommand(runtime),
     authMode: "local-or-api-key",
-    includeGhAuth: !hasGitHubGraphqlToken
+    includeGhAuth: opts.includeGhAuth ?? !hasGitHubGraphqlToken
   });
   const message = formatClaudePreflightText(report);
   if (report.ok) {
@@ -2202,6 +2238,27 @@ var handler = async (args, options) => {
     await runNonInteractive(flags, options);
     return;
   }
+  const trackerKind = resolveInitTrackerKind(flags);
+  if (trackerKind instanceof Error) {
+    process.stderr.write(`Error: ${trackerKind.message}
+`);
+    process.exitCode = 1;
+    return;
+  }
+  const trackerFlagError = validateInitTrackerFlags(flags, trackerKind);
+  if (trackerFlagError) {
+    process.stderr.write(`Error: ${trackerFlagError}
+`);
+    process.exitCode = 1;
+    return;
+  }
+  if (trackerKind === "linear") {
+    process.stderr.write(
+      "Error: Linear workflow init currently requires --non-interactive.\n"
+    );
+    process.exitCode = 1;
+    return;
+  }
   await runInteractive(flags, options);
 };
 var workflow_init_default = handler;
@@ -2668,6 +2725,143 @@ async function planWorkflowArtifacts(opts) {
     ecosystemPlan
   };
 }
+var LINEAR_DEFAULT_STATUS_FIELD = {
+  id: "linear-state",
+  name: "State",
+  options: [
+    {
+      id: "linear-todo",
+      name: "Todo",
+      description: null,
+      color: null
+    },
+    {
+      id: "linear-in-progress",
+      name: "In Progress",
+      description: null,
+      color: null
+    },
+    {
+      id: "linear-rework",
+      name: "Rework",
+      description: null,
+      color: null
+    },
+    {
+      id: "linear-human-review",
+      name: "Human Review",
+      description: null,
+      color: null
+    },
+    {
+      id: "linear-done",
+      name: "Done",
+      description: null,
+      color: null
+    },
+    {
+      id: "linear-canceled",
+      name: "Canceled",
+      description: null,
+      color: null
+    },
+    {
+      id: "linear-cancelled",
+      name: "Cancelled",
+      description: null,
+      color: null
+    },
+    {
+      id: "linear-duplicate",
+      name: "Duplicate",
+      description: null,
+      color: null
+    }
+  ]
+};
+var LINEAR_DEFAULT_MAPPINGS = {
+  Todo: { role: "active" },
+  "In Progress": { role: "active" },
+  Rework: { role: "active" },
+  "Human Review": { role: "wait" },
+  Done: { role: "terminal" },
+  Canceled: { role: "terminal" },
+  Cancelled: { role: "terminal" },
+  Duplicate: { role: "terminal" }
+};
+function buildLinearProjectDetail(projectSlug) {
+  return {
+    id: projectSlug,
+    title: `Linear project ${projectSlug}`,
+    url: "",
+    statusFields: [LINEAR_DEFAULT_STATUS_FIELD],
+    textFields: [],
+    linkedRepositories: []
+  };
+}
+function buildLinearWorkflowLifecycle() {
+  return toWorkflowLifecycleConfig("State", LINEAR_DEFAULT_MAPPINGS, {
+    blockerCheckStates: [],
+    planningStates: []
+  });
+}
+async function planLinearWorkflowArtifacts(opts) {
+  const environment = opts.environment ?? await detectEnvironment(opts.cwd);
+  const projectDetail = buildLinearProjectDetail(opts.projectSlug);
+  const lifecycle = buildLinearWorkflowLifecycle();
+  const workflowMd = generateWorkflowMarkdown({
+    projectId: opts.projectSlug,
+    tracker: {
+      kind: "linear",
+      projectSlug: opts.projectSlug
+    },
+    stateFieldName: LINEAR_DEFAULT_STATUS_FIELD.name,
+    priority: null,
+    mappings: LINEAR_DEFAULT_MAPPINGS,
+    lifecycle,
+    runtime: opts.runtime,
+    detectedEnvironment: environment
+  });
+  const workflowPlan = await planFileChange({
+    path: opts.outputPath,
+    label: "WORKFLOW.md",
+    content: workflowMd,
+    mode: "overwrite"
+  });
+  const ecosystemPlan = await planEcosystem({
+    cwd: opts.cwd,
+    projectDetail,
+    statusField: LINEAR_DEFAULT_STATUS_FIELD,
+    priorityField: null,
+    priority: buildDisabledPriority(),
+    lifecycle,
+    includePriorityTemplates: false,
+    runtime: opts.runtime,
+    skipSkills: opts.skipSkills,
+    skipContext: opts.skipContext,
+    environment
+  });
+  return {
+    outputPath: opts.outputPath,
+    workflowMd,
+    workflowPlan,
+    ecosystemPlan
+  };
+}
+async function writeLinearEcosystem(opts) {
+  return writeEcosystem({
+    cwd: opts.cwd,
+    projectDetail: buildLinearProjectDetail(opts.projectSlug),
+    statusField: LINEAR_DEFAULT_STATUS_FIELD,
+    priorityField: null,
+    priority: buildDisabledPriority(),
+    lifecycle: buildLinearWorkflowLifecycle(),
+    includePriorityTemplates: false,
+    runtime: opts.runtime,
+    skipSkills: opts.skipSkills,
+    skipContext: opts.skipContext
+  });
+}
 async function writeWorkflowPlan(workflowPlan) {
   return writePlannedFile(workflowPlan);
 }
@@ -2948,10 +3142,30 @@ async function runNonInteractive(flags, options) {
     process.exitCode = 1;
     return;
   }
-  if (!await runInitRuntimePreflight(runtime)) {
+  const trackerKind = resolveInitTrackerKind(flags);
+  if (trackerKind instanceof Error) {
+    process.stderr.write(`Error: ${trackerKind.message}
+`);
+    process.exitCode = 1;
+    return;
+  }
+  const trackerFlagError = validateInitTrackerFlags(flags, trackerKind);
+  if (trackerFlagError) {
+    process.stderr.write(`Error: ${trackerFlagError}
+`);
     process.exitCode = 1;
     return;
   }
+  if (!await runInitRuntimePreflight(runtime, {
+    includeGhAuth: trackerKind === "linear" ? false : void 0
+  })) {
+    process.exitCode = 1;
+    return;
+  }
+  if (trackerKind === "linear") {
+    await runLinearNonInteractive(flags, options, runtime);
+    return;
+  }
   let token;
   try {
     token = getGhTokenWithSource().token;
@@ -3085,6 +3299,79 @@ Run without --non-interactive for manual mapping.
     });
   }
 }
+function resolveInitTrackerKind(flags) {
+  const rawTracker = flags.tracker?.trim();
+  if (!rawTracker) {
+    return flags.linearProjectSlug ? "linear" : "github-project";
+  }
+  if (rawTracker === "github-project") {
+    if (flags.linearProjectSlug?.trim()) {
+      return new Error(
+        "--linear-project-slug is only supported for --tracker linear."
+      );
+    }
+    return "github-project";
+  }
+  if (rawTracker === "linear") {
+    return "linear";
+  }
+  return new Error(
+    `Unsupported tracker '${rawTracker}'. Choose one of: github-project, linear.`
+  );
+}
+function validateInitTrackerFlags(flags, trackerKind) {
+  if (trackerKind === "linear") {
+    if (!flags.linearProjectSlug?.trim()) {
+      return "--linear-project-slug is required when --tracker linear is used.";
+    }
+    if (flags.project) {
+      return "--project is only supported for --tracker github-project.";
+    }
+  }
+  return null;
+}
+async function runLinearNonInteractive(flags, options, runtime) {
+  const projectSlug = flags.linearProjectSlug.trim();
+  const outputPath = resolve(flags.output ?? "WORKFLOW.md");
+  const { workflowPlan, ecosystemPlan } = await planLinearWorkflowArtifacts({
+    cwd: process.cwd(),
+    outputPath,
+    projectSlug,
+    runtime,
+    skipSkills: flags.skipSkills,
+    skipContext: flags.skipContext
+  });
+  if (flags.dryRun) {
+    if (options.json) {
+      process.stdout.write(
+        JSON.stringify(
+          buildDryRunJsonResult(outputPath, workflowPlan, ecosystemPlan)
+        ) + "\n"
+      );
+      return;
+    }
+    printDryRunPreview(outputPath, workflowPlan, ecosystemPlan);
+    return;
+  }
+  await writeWorkflowPlan(workflowPlan);
+  const ecosystemResult = await writeLinearEcosystem({
+    cwd: process.cwd(),
+    projectSlug,
+    runtime,
+    skipSkills: flags.skipSkills,
+    skipContext: flags.skipContext
+  });
+  if (options.json) {
+    process.stdout.write(
+      JSON.stringify({ output: outputPath, status: workflowPlan.status }) + "\n"
+    );
+  } else {
+    printEcosystemSummary(ecosystemResult, outputPath, {
+      interactive: false,
+      nextSteps: "Run 'gh-symphony repo init' from the target repository."
+    });
+  }
+}
 async function runInteractive(flags, options) {
   p.intro("gh-symphony \u2014 WORKFLOW.md Setup");
   await runInteractiveStandalone(flags, options);

package/dist/{chunk-QHMT2V3X.js → chunk-I3CZXKS5.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   workflow_init_default
-} from "./chunk-OVE4KOBD.js";
+} from "./chunk-4ZHWEQQL.js";
 import {
   fetchGithubProjectIssueByRepositoryAndNumber,
   inspectManagedProjectSelection,
@@ -377,7 +377,7 @@ Commands:
   preview    Render the final worker prompt from a sample or live issue
 
 Options:
-  workflow init [--non-interactive] [--project <id>] [--output <path>] [--skip-skills] [--skip-context (deprecated no-op)] [--dry-run]
+  workflow init [--non-interactive] [--tracker <github-project|linear>] [--project <id>] [--linear-project-slug <slug>] [--output <path>] [--skip-skills] [--skip-context (deprecated no-op)] [--dry-run]
   workflow validate [--file <path>]
   workflow preview [issue] [--file <path>] [--issue <owner/repo#number|ENG-123>] [--project-id <projectId>] [--sample <json>] [--attempt <n>]
 

package/dist/{doctor-LT5UQG67.js → doctor-Y2AZZKGW.js}

@@ -5,8 +5,8 @@ import {
   parseIssueReference,
   readGitHubProjectBinding,
   renderIssueWorkflowPreview
-} from "./chunk-QHMT2V3X.js";
-import "./chunk-OVE4KOBD.js";
+} from "./chunk-I3CZXKS5.js";
+import "./chunk-4ZHWEQQL.js";
 import {
   fetchGithubProjectIssueByRepositoryAndNumber,
   fetchGithubProjectIssues,
@@ -766,6 +766,172 @@ function buildGithubTrackerConfig(input) {
     timeoutMs: typeof settings?.timeoutMs === "number" ? settings.timeoutMs : void 0
   };
 }
+async function checkLinearTrackerResolution(input) {
+  const tracker = input.projectConfig.projectConfig.tracker;
+  const projectSlug = readStringSetting(tracker.settings, "projectSlug")?.trim();
+  const activeStates = readLinearActiveStates(tracker.settings);
+  const pickupLabels = readLinearPickupLabels(tracker.settings);
+  if (!projectSlug) {
+    return failCheck(
+      "linear_tracker_resolution",
+      "Linear tracker resolution",
+      "Linear tracker resolution could not run because the project slug is missing.",
+      "Run 'gh-symphony repo init' with WORKFLOW.md field 'tracker.project_slug' configured, then re-run 'gh-symphony doctor'.",
+      {
+        reason: "missing_project_slug",
+        adapter: tracker.adapter
+      }
+    );
+  }
+  if (activeStates.length === 0) {
+    return failCheck(
+      "linear_tracker_resolution",
+      "Linear tracker resolution",
+      "Linear tracker resolution could not run because no active states are configured.",
+      "Add at least one active state to WORKFLOW.md under 'tracker.active_states', run 'gh-symphony repo init' again, then re-run 'gh-symphony doctor'.",
+      {
+        reason: "missing_active_states",
+        projectSlug
+      }
+    );
+  }
+  const token = process.env.LINEAR_API_KEY?.trim();
+  if (!token) {
+    return failCheck(
+      "linear_tracker_resolution",
+      "Linear tracker resolution",
+      "Linear tracker resolution could not run because LINEAR_API_KEY is not set.",
+      "Set LINEAR_API_KEY in the environment and re-run 'gh-symphony doctor'.",
+      {
+        reason: "missing_token",
+        projectSlug,
+        activeStates,
+        pickupLabels
+      }
+    );
+  }
+  try {
+    const project = await fetchLinearProjectBySlug({
+      endpoint: tracker.apiUrl?.trim() || "https://api.linear.app/graphql",
+      projectSlug,
+      token,
+      fetchImpl: input.deps.fetchImpl
+    });
+    if (!project) {
+      return failCheck(
+        "linear_tracker_resolution",
+        "Linear tracker resolution",
+        `Linear project "${projectSlug}" was not found or is not accessible.`,
+        "Confirm LINEAR_API_KEY can read the configured Linear project, then re-run 'gh-symphony doctor'.",
+        {
+          reason: "api_error",
+          projectSlug,
+          activeStates,
+          pickupLabels
+        }
+      );
+    }
+    return passCheck(
+      "linear_tracker_resolution",
+      "Linear tracker resolution",
+      `Resolved Linear project "${project.name}" (${project.slugId}). ${formatLinearConfigSummary(activeStates, pickupLabels)}`,
+      {
+        projectId: project.id,
+        projectSlug: project.slugId,
+        activeStates,
+        pickupLabels
+      }
+    );
+  } catch (error) {
+    return failCheck(
+      "linear_tracker_resolution",
+      "Linear tracker resolution",
+      `Failed to resolve configured Linear project "${projectSlug}".`,
+      "Confirm LINEAR_API_KEY, tracker endpoint, project slug, and network access, then re-run 'gh-symphony doctor'.",
+      {
+        reason: "api_error",
+        projectSlug,
+        activeStates,
+        pickupLabels,
+        error: formatSmokeError(error)
+      }
+    );
+  }
+}
+function readStringSetting(settings, key) {
+  const value = settings?.[key];
+  return typeof value === "string" ? value : null;
+}
+function readLinearActiveStates(settings) {
+  const value = settings?.activeStates;
+  if (Array.isArray(value)) {
+    return value.filter(
+      (state) => typeof state === "string" && state.trim().length > 0
+    );
+  }
+  if (typeof value === "string") {
+    return value.split(/\r?\n/).map((state) => state.trim()).filter((state) => state.length > 0);
+  }
+  return [];
+}
+function readLinearPickupLabels(settings) {
+  const value = settings?.pickupLabels;
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return { include: [], exclude: [] };
+  }
+  return {
+    include: readStringArraySetting(value, "include"),
+    exclude: readStringArraySetting(value, "exclude")
+  };
+}
+function readStringArraySetting(value, key) {
+  const field = value[key];
+  return Array.isArray(field) ? field.filter(
+    (item) => typeof item === "string" && item.trim().length > 0
+  ) : [];
+}
+function formatLinearConfigSummary(activeStates, pickupLabels) {
+  const labelSummary = pickupLabels.include.length > 0 || pickupLabels.exclude.length > 0 ? `Pickup labels include=[${pickupLabels.include.join(", ") || "none"}], exclude=[${pickupLabels.exclude.join(", ") || "none"}].` : "Pickup label filtering is not configured.";
+  return `Active states: ${activeStates.join(", ")}. ${labelSummary}`;
+}
+async function fetchLinearProjectBySlug(input) {
+  const response = await input.fetchImpl(input.endpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: input.token
+    },
+    body: JSON.stringify({
+      query: `query SymphonyLinearDoctorProject($slug: String!) {
+  projects(filter: { slugId: { eq: $slug } }, first: 1) {
+    nodes {
+      id
+      name
+      slugId
+    }
+  }
+}`,
+      variables: { slug: input.projectSlug }
+    })
+  });
+  if (!response.ok) {
+    throw new Error(`Linear GraphQL request failed with HTTP ${response.status}.`);
+  }
+  const payload = await response.json();
+  if (payload.errors?.length) {
+    const message = payload.errors.map((error) => error.message).filter(Boolean).join("; ") || "Unknown Linear GraphQL error";
+    throw new Error(`Linear GraphQL request failed: ${message}`);
+  }
+  const project = payload.data?.projects?.nodes?.[0];
+  if (!project || typeof project.id !== "string" || typeof project.name !== "string" || typeof project.slugId !== "string") {
+    return null;
+  }
+  return {
+    id: project.id,
+    name: project.name,
+    slugId: project.slugId
+  };
+}
 async function buildPriorityMappingChecks(input) {
   if (input.workflow.status !== "pass") {
     return [];
@@ -1475,7 +1641,14 @@ ${DOCTOR_USAGE}`);
       )
     );
   }
-  if (resolvedProjectConfig.kind === "resolved" && !auth) {
+  if (resolvedProjectConfig.kind === "resolved" && resolvedProjectConfig.projectConfig.tracker.adapter === "linear") {
+    checks.push(
+      await checkLinearTrackerResolution({
+        projectConfig: resolvedProjectConfig,
+        deps
+      })
+    );
+  } else if (resolvedProjectConfig.kind === "resolved" && !auth) {
     checks.push(
       failCheck(
         "github_project_resolution",
@@ -2069,6 +2242,19 @@ async function runDoctorFixes(report, deps, options) {
           )
         );
         break;
+      case "linear_tracker_resolution":
+        steps.push(
+          remediationStep(
+            `remediate_${check.id}`,
+            check.id,
+            check.title,
+            "manual",
+            check.remediation ?? "Fix the Linear tracker configuration or credentials.",
+            void 0,
+            check.details
+          )
+        );
+        break;
     }
   }
   return steps;

package/dist/index.js

@@ -417,13 +417,13 @@ function createRemovedCommandHandler(message) {
 
 // src/index.ts
 var COMMANDS = {
-  workflow: () => import("./workflow-R3G7IA3Z.js"),
-  setup: () => import("./setup-4ZBHGOXT.js"),
-  doctor: () => import("./doctor-LT5UQG67.js"),
-  upgrade: () => import("./upgrade-334S2JVT.js"),
+  workflow: () => import("./workflow-TQ7UZPGP.js"),
+  setup: () => import("./setup-DMYXHOCB.js"),
+  doctor: () => import("./doctor-Y2AZZKGW.js"),
+  upgrade: () => import("./upgrade-FJXX733J.js"),
   repo: () => import("./repo-2NS2AU3D.js"),
   config: () => import("./config-cmd-OIVIUKG7.js"),
-  version: () => import("./version-J6P6WDMA.js")
+  version: () => import("./version-FYAZ57WO.js")
 };
 function addGlobalOptions(command) {
   return command.option("--config <dir>", "Config directory").addOption(new Option("--config-dir <dir>").hideHelp()).option("-v, --verbose", "Enable verbose output").option("--json", "Output in JSON format").option("--no-color", "Disable color output");
@@ -525,7 +525,7 @@ function createProgram() {
     );
   });
   addGlobalOptions(
-    workflow.command("init").description("Generate WORKFLOW.md and workflow support files").option("--non-interactive", "Run without prompts").option("--project <id>", "GitHub Project ID or URL").option("--output <path>", "Write WORKFLOW.md to a custom path").option(
+    workflow.command("init").description("Generate WORKFLOW.md and workflow support files").option("--non-interactive", "Run without prompts").option("--tracker <kind>", "Tracker kind: github-project or linear").option("--project <id>", "GitHub Project ID or URL").option("--linear-project-slug <slug>", "Linear project slug").option("--output <path>", "Write WORKFLOW.md to a custom path").option(
       "--runtime <kind>",
       "Runtime preset: codex-app-server or claude-print"
     ).option("--skip-skills", "Skip runtime skill generation").option("--skip-context", "Deprecated no-op").option("--dry-run", "Preview generated files without writing them").allowExcessArguments(false)
@@ -534,7 +534,9 @@ function createProgram() {
     const values = this.optsWithGlobals();
     const args = ["init"];
     pushOption(args, "--non-interactive", values.nonInteractive);
+    pushOption(args, "--tracker", values.tracker);
     pushOption(args, "--project", values.project);
+    pushOption(args, "--linear-project-slug", values.linearProjectSlug);
     pushOption(args, "--output", values.output);
     pushOption(args, "--runtime", values.runtime);
     pushOption(args, "--skip-skills", values.skipSkills);

package/dist/{setup-4ZBHGOXT.js → setup-DMYXHOCB.js}

@@ -16,7 +16,7 @@ import {
   warnDeprecatedSkipContext,
   writeEcosystem,
   writeWorkflowPlan
-} from "./chunk-OVE4KOBD.js";
+} from "./chunk-4ZHWEQQL.js";
 import {
   initRepoRuntime
 } from "./chunk-34YCGQD2.js";

package/dist/{upgrade-334S2JVT.js → upgrade-FJXX733J.js}

@@ -16,8 +16,8 @@ function execFileAsync(file, args, execFileImpl = execFileCallback) {
   });
 }
 function resolveCurrentCliVersion() {
-  if ("0.4.2".length > 0) {
-    return "0.4.2";
+  if ("0.4.4".length > 0) {
+    return "0.4.4";
   }
   const pkg = JSON.parse(
     readFileSync(new URL("../../package.json", import.meta.url), "utf8")

package/dist/{version-J6P6WDMA.js → version-FYAZ57WO.js}

@@ -2,7 +2,7 @@
 
 // src/commands/version.ts
 var handler = async (_args, options) => {
-  const version = "0.4.2";
+  const version = "0.4.4";
   if (options.json) {
     process.stdout.write(JSON.stringify({ version }) + "\n");
   } else {

package/dist/{workflow-R3G7IA3Z.js → workflow-TQ7UZPGP.js}

@@ -6,8 +6,8 @@ import {
   resetWorkflowCommandDependenciesForTest,
   setWorkflowCommandDependenciesForTest,
   workflow_default
-} from "./chunk-QHMT2V3X.js";
-import "./chunk-OVE4KOBD.js";
+} from "./chunk-I3CZXKS5.js";
+import "./chunk-4ZHWEQQL.js";
 import "./chunk-HHBXGE23.js";
 import "./chunk-QBBJMCNC.js";
 import "./chunk-SMNIGNS3.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gh-symphony/cli",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "license": "MIT",
   "author": "hojinzs",
   "description": "Interactive CLI for GitHub Symphony orchestration",
@@ -41,13 +41,13 @@
   },
   "devDependencies": {
     "tsup": "^8.5.1",
-    "@gh-symphony/dashboard": "0.0.14",
     "@gh-symphony/control-plane": "0.0.15",
-    "@gh-symphony/orchestrator": "0.0.14",
+    "@gh-symphony/dashboard": "0.0.14",
     "@gh-symphony/tracker-github": "0.0.14",
-    "@gh-symphony/runtime-claude": "0.0.14",
     "@gh-symphony/core": "0.0.14",
-    "@gh-symphony/worker": "0.0.14"
+    "@gh-symphony/worker": "0.0.14",
+    "@gh-symphony/runtime-claude": "0.0.14",
+    "@gh-symphony/orchestrator": "0.0.14"
   },
   "scripts": {
     "build": "tsup",