@gh-symphony/cli 0.2.5 → 0.4.0

package/README.md

@@ -88,7 +88,7 @@ whether `WORKFLOW.md`, `.gh-symphony/context.yaml`,
 `.gh-symphony/reference-workflow.md`, and runtime skill files would be created,
 updated, or left unchanged, and then exits without modifying the repository.
 
-The same detected environment data is applied to the generated artifacts, so `WORKFLOW.md`, `.gh-symphony/reference-workflow.md`, and the runtime skill templates already include repository-aware validation guidance for the detected package manager, monorepo layout, and explicit validation commands when they exist.
+The same detected environment data is applied to the generated artifacts, so `WORKFLOW.md`, `.gh-symphony/reference-workflow.md`, and the runtime skill templates already include repository-aware validation guidance for the detected package manager, monorepo layout, and explicit validation commands when they exist. The `/gh-symphony` skill also ships a `references/` directory with workflow schema details and composable prompt-body postures for implementation, review, and maintenance workflows.
 
 The detector is language-agnostic by default:
 
@@ -102,7 +102,7 @@ Examples of generated validation guidance include `make test`, `just build`, `uv
 
 ### Customizing Agent Behavior
 
-`gh-symphony workflow init` generates skill files under `.codex/skills/` (or `.claude/skills/` for Claude Code). These skills define how the AI agent handles commits, pushes, pulls, and project status transitions.
+`gh-symphony workflow init` generates skill files under `.codex/skills/` (or `.claude/skills/` for Claude Code). These skills define how the AI agent handles commits, pushes, pulls, and project status transitions. The generated `/gh-symphony` skill includes `references/` files that can be customized or extended without adding CLI flags.
 
 You can further customize the agent's behavior by editing `WORKFLOW.md` — this is the policy layer that controls what the agent does at each workflow phase.
 

package/dist/{chunk-3SKN5L3I.js → chunk-6OPRRC2J.js}

@@ -5,7 +5,8 @@ var DEFAULT_WORKFLOW_LIFECYCLE = {
   stateFieldName: "Status",
   activeStates: ["Todo", "In Progress"],
   terminalStates: ["Done"],
-  blockerCheckStates: ["Todo"]
+  blockerCheckStates: [],
+  planningStates: []
 };
 function isStateActive(state, lifecycle) {
   return matchesWorkflowState(state, lifecycle.activeStates);
@@ -15,7 +16,9 @@ function isStateTerminal(state, lifecycle) {
 }
 function matchesWorkflowState(state, candidates) {
   const normalizedState = normalizeWorkflowState(state);
-  return candidates.some((candidate) => normalizeWorkflowState(candidate) === normalizedState);
+  return candidates.some(
+    (candidate) => normalizeWorkflowState(candidate) === normalizedState
+  );
 }
 function normalizeWorkflowState(state) {
   return state.trim().toLowerCase();
@@ -55,7 +58,8 @@ var DEFAULT_WORKFLOW_TRACKER = {
   stateFieldName: DEFAULT_WORKFLOW_LIFECYCLE.stateFieldName,
   priority: null,
   priorityFieldName: null,
-  blockerCheckStates: DEFAULT_WORKFLOW_LIFECYCLE.blockerCheckStates
+  blockerCheckStates: DEFAULT_WORKFLOW_LIFECYCLE.blockerCheckStates,
+  planningStates: DEFAULT_WORKFLOW_LIFECYCLE.planningStates
 };
 var DEFAULT_WORKFLOW_WORKSPACE = {
   root: null
@@ -135,6 +139,7 @@ function parseWorkflowMarkdown(markdown, env = process.env, options = {}) {
   const activeStates = readStringList(tracker, "active_states") ?? DEFAULT_WORKFLOW_TRACKER.activeStates;
   const terminalStates = readStringList(tracker, "terminal_states") ?? DEFAULT_WORKFLOW_TRACKER.terminalStates;
   const blockerCheckStates = readStringList(tracker, "blocker_check_states") ?? DEFAULT_WORKFLOW_TRACKER.blockerCheckStates;
+  const planningStates = readStringList(tracker, "planning_states") ?? blockerCheckStates;
   const maxConcurrentAgentsByState = readNumberMap(
     agent,
     "max_concurrent_agents_by_state"
@@ -172,7 +177,8 @@ function parseWorkflowMarkdown(markdown, env = process.env, options = {}) {
       stateFieldName: readOptionalString(tracker, "state_field", env) ?? DEFAULT_WORKFLOW_TRACKER.stateFieldName,
       priority: readPriorityConfig(tracker, env),
       priorityFieldName: readOptionalString(tracker, "priority_field", env),
-      blockerCheckStates
+      blockerCheckStates,
+      planningStates
     },
     polling: {
       intervalMs: readOptionalIntegerLike(polling, "interval_ms") ?? DEFAULT_POLL_INTERVAL_MS
@@ -201,7 +207,8 @@ function parseWorkflowMarkdown(markdown, env = process.env, options = {}) {
       stateFieldName: readOptionalString(tracker, "state_field", env) ?? DEFAULT_WORKFLOW_TRACKER.stateFieldName,
       activeStates,
       terminalStates,
-      blockerCheckStates
+      blockerCheckStates,
+      planningStates
     },
     format: "front-matter",
     githubProjectId: readOptionalString(tracker, "project_id", env),
@@ -451,7 +458,9 @@ function parseScalar(value) {
         return parsed;
       }
     } catch {
-      throw new Error(`Invalid quoted workflow front matter scalar "${value}".`);
+      throw new Error(
+        `Invalid quoted workflow front matter scalar "${value}".`
+      );
     }
   }
   if (value.startsWith("'") && value.endsWith("'")) {
@@ -880,7 +889,8 @@ var SESSION_EXIT_CLASSIFICATIONS = [
   "max-turns-reached",
   "user-input-required",
   "timeout",
-  "error"
+  "error",
+  "incomplete-turn-dirty-workspace"
 ];
 function isSessionExitClassification(value) {
   return typeof value === "string" && SESSION_EXIT_CLASSIFICATIONS.includes(value);
@@ -1462,11 +1472,30 @@ function buildProjectSnapshot(input) {
       retryKind: run.retryKind ?? "failure",
       nextRetryAt: run.nextRetryAt
     })),
+    recovery: findLatestRecovery([...allRuns ?? [], ...activeRuns]),
     lastError,
     codexTotals: aggregateTokenUsage(allRuns ?? activeRuns, lastTickAt),
     rateLimits: rateLimits ?? null
   };
 }
+function findLatestRecovery(runs) {
+  return [...runs].filter((run) => isUnresolvedRecoveryRun(run, runs)).sort((left, right) => {
+    const leftTime = new Date(left.updatedAt).getTime();
+    const rightTime = new Date(right.updatedAt).getTime();
+    return rightTime - leftTime;
+  }).find((run) => run.recovery)?.recovery ?? null;
+}
+function isUnresolvedRecoveryRun(run, runs) {
+  if (!run.recovery) {
+    return false;
+  }
+  if (run.status === "suppressed" && runs.some(
+    (candidate) => candidate.runId !== run.runId && candidate.retryKind === "recovery" && candidate.recovery?.runId === run.recovery?.runId && new Date(candidate.updatedAt).getTime() > new Date(run.updatedAt).getTime() && candidate.status !== "running" && candidate.status !== "retrying"
+  )) {
+    return false;
+  }
+  return run.status === "suppressed" || run.retryKind === "recovery" && (run.status === "running" || run.status === "retrying");
+}
 function aggregateTokenUsageByIssue(runs) {
   const totals = /* @__PURE__ */ new Map();
   for (const run of runs) {

package/dist/{chunk-NRABQNAX.js → chunk-B6G3KGBB.js}

@@ -30,7 +30,7 @@ import {
   resolveWorkflowRuntimeTimeouts,
   safeReadDir,
   scheduleRetryAt
-} from "./chunk-3SKN5L3I.js";
+} from "./chunk-6OPRRC2J.js";
 import {
   loadGlobalConfig,
   loadProjectConfig
@@ -2313,14 +2313,21 @@ async function syncRepositoryForRun(input) {
   });
 }
 async function ensureIssueWorkspaceRepository(input) {
-  const repositoryDirectory = input.existingWorkspace ? await syncExistingIssueWorkspaceRepository({
-    ...input,
-    skipPull: Boolean(input.pullRequestBranch)
-  }) : await cloneRepositoryForRun({
+  let dirtyExistingWorkspaceAllowed = false;
+  const repositoryDirectory = input.existingWorkspace ? await syncExistingIssueWorkspaceRepository(
+    {
+      ...input,
+      skipPull: Boolean(input.pullRequestBranch),
+      allowDirty: input.allowDirtyExistingWorkspace
+    },
+    (dirtyAllowed) => {
+      dirtyExistingWorkspaceAllowed = dirtyAllowed;
+    }
+  ) : await cloneRepositoryForRun({
     repository: input.repository,
     targetDirectory: input.issueWorkspacePath
   });
-  if (input.pullRequestBranch) {
+  if (input.pullRequestBranch && !dirtyExistingWorkspaceAllowed) {
     await checkoutPullRequestBranch(
       repositoryDirectory,
       input.pullRequestBranch
@@ -2328,6 +2335,20 @@ async function ensureIssueWorkspaceRepository(input) {
   }
   return repositoryDirectory;
 }
+async function inspectIssueWorkspaceDirtyStatus(input) {
+  const repositoryDirectory = join(input.issueWorkspacePath, "repository");
+  const hasGit = await pathExists(join(repositoryDirectory, ".git"));
+  if (!hasGit) {
+    return null;
+  }
+  const status = await readGitStatusPorcelain(repositoryDirectory);
+  return {
+    repositoryDirectory,
+    dirty: status.trim().length > 0,
+    dirtyFiles: parseGitStatusFiles(status),
+    summary: status.trim() ? summarizeGitStatus(status) : null
+  };
+}
 async function loadRepositoryWorkflow(repositoryDirectory, _repository) {
   const workflowPath = join(repositoryDirectory, "WORKFLOW.md");
   try {
@@ -2377,7 +2398,7 @@ async function readGitHead(repositoryDirectory) {
     return null;
   }
 }
-async function syncExistingIssueWorkspaceRepository(input) {
+async function syncExistingIssueWorkspaceRepository(input, onDirtyAllowed) {
   await mkdir(input.issueWorkspacePath, { recursive: true });
   const repositoryDirectory = join(input.issueWorkspacePath, "repository");
   const lockDirectory = join(input.issueWorkspacePath, "repository.lock");
@@ -2394,6 +2415,10 @@ async function syncExistingIssueWorkspaceRepository(input) {
           `could not be inspected: ${formatCommandError(error, "git status --porcelain failed")}`
         );
       }
+      if (dirtyStatus.trim() && input.allowDirty) {
+        onDirtyAllowed?.(true);
+        return repositoryDirectory;
+      }
       if (dirtyStatus.trim()) {
         throw createIssueWorkspacePreservedError(
           repositoryDirectory,
@@ -2537,6 +2562,9 @@ function summarizeGitStatus(status) {
   const summary = lines.slice(0, 5).join("; ");
   return lines.length > 5 ? `${summary}; ...` : summary;
 }
+function parseGitStatusFiles(status) {
+  return status.trim().split(/\r?\n/).map((line) => line.slice(3).trim()).filter(Boolean);
+}
 function normalizeWhitespace(value) {
   return value.replace(/\s+/g, " ").trim();
 }
@@ -3207,6 +3235,25 @@ function explainRuntimeOwnership(issue, issueRecords, runs) {
       };
     }
   }
+  if (latestRun?.status === "suppressed" && latestRun.recovery?.kind === "incomplete-turn-dirty-workspace") {
+    return {
+      id: "runtime_ownership",
+      status: "warn",
+      message: "Latest run has a recoverable incomplete-turn dirty workspace; dispatch will start a recovery turn.",
+      details: {
+        runId: latestRun.recovery.runId,
+        issueId: latestRun.recovery.issueId,
+        workspacePath: latestRun.recovery.workspacePath,
+        dirtyFiles: latestRun.recovery.dirtyFiles,
+        lastEvent: latestRun.recovery.lastEvent,
+        lastEventAt: latestRun.recovery.lastEventAt,
+        sessionId: latestRun.recovery.sessionId,
+        threadId: latestRun.recovery.threadId,
+        suggestedCommand: latestRun.recovery.suggestedCommand
+      },
+      hint: latestRun.recovery.suggestedCommand
+    };
+  }
   return {
     id: "runtime_ownership",
     status: "pass",
@@ -3311,6 +3358,7 @@ var CONTINUATION_RETRY_DELAY_MS = 1e3;
 var DEFAULT_WORKER_COMMAND = "node packages/worker/dist/index.js";
 var DEFAULT_MAX_NONPRODUCTIVE_TURNS = 3;
 var LOW_RATE_LIMIT_WARNING_THRESHOLD = 0.05;
+var MAX_RECOVERY_DIRTY_FILES_IN_CONTEXT = 50;
 var MAX_FAILURE_RETRIES_EXCEEDED_REASON2 = "max_failure_retries_exceeded";
 var LINKED_PR_ACTIVE_ISSUE_INACTIVE_MARKER_PREFIX = "gh-symphony:linked-pr-active-while-issue-inactive";
 var STUCK_WORKER_TIMEOUT_MS = 30 * 60 * 1e3;
@@ -3556,6 +3604,7 @@ var OrchestratorService = class {
         kind: currentRun?.retryKind ?? null,
         error: currentRun?.lastError ?? issueRecord.retryEntry?.error ?? null
       } : null,
+      recovery: currentRun?.recovery ?? null,
       logs: {
         codex_session_logs: currentRun === null ? [] : [
           {
@@ -3786,6 +3835,12 @@ var OrchestratorService = class {
           },
           issue.identifier
         );
+        const recoveryContext = await this.resolveIncompleteTurnRecoveryContext(
+          tenant,
+          issue,
+          latestRunsByIssueId.get(issue.id) ?? null,
+          preferredWorkspaceKey
+        );
         issueRecords = upsertIssueOrchestration(issueRecords, {
           issueId: issue.id,
           identifier: issue.identifier,
@@ -3798,7 +3853,9 @@ var OrchestratorService = class {
         });
         let run;
         try {
-          run = await this.startRun(tenant, issue);
+          run = await this.startRun(tenant, issue, {
+            recovery: recoveryContext
+          });
         } catch (error) {
           issueRecords = releaseIssueOrchestration(issueRecords, issue.id, now);
           throw error;
@@ -3855,6 +3912,11 @@ var OrchestratorService = class {
           const activeWorkerPid = activeRun.processId;
           this.sendSignal(activeWorkerPid, "SIGTERM");
           this.retireWorkerPid(activeWorkerPid);
+          const recovery = await this.classifyIncompleteTurnDirtyWorkspace(
+            tenant,
+            activeRun,
+            now
+          );
           const suppressedRun = {
             ...activeRun,
             status: "suppressed",
@@ -3862,7 +3924,17 @@ var OrchestratorService = class {
             completedAt: now.toISOString(),
             updatedAt: now.toISOString(),
             runPhase: "canceled_by_reconciliation",
-            lastError: "Run suppressed because the tracker issue is no longer tracked."
+            runtimeSession: recovery ? buildRuntimeSession(
+              activeRun.runtimeSession,
+              recovery.sessionId,
+              recovery.threadId,
+              "completed",
+              activeRun.runtimeSession?.startedAt ?? activeRun.startedAt ?? now.toISOString(),
+              now.toISOString(),
+              "incomplete-turn-dirty-workspace"
+            ) : activeRun.runtimeSession,
+            recovery,
+            lastError: recovery ? "Run suppressed with recoverable incomplete-turn dirty workspace." : "Run suppressed because the tracker issue is no longer tracked."
           };
           await this.store.saveRun(suppressedRun);
           this.logVerbose(
@@ -3888,6 +3960,11 @@ var OrchestratorService = class {
         }
         if (activeRun) {
           const terminalState = isStateTerminal(issue.state, lifecycle);
+          const recovery = terminalState ? null : await this.classifyIncompleteTurnDirtyWorkspace(
+            tenant,
+            activeRun,
+            now
+          );
           const suppressedRun = {
             ...activeRun,
             status: "suppressed",
@@ -3895,7 +3972,17 @@ var OrchestratorService = class {
             completedAt: now.toISOString(),
             updatedAt: now.toISOString(),
             runPhase: "canceled_by_reconciliation",
-            lastError: terminalState ? "Run suppressed because the tracker issue moved to a terminal state." : "Run suppressed because the tracker state is no longer actionable."
+            runtimeSession: recovery ? buildRuntimeSession(
+              activeRun.runtimeSession,
+              recovery.sessionId,
+              recovery.threadId,
+              "completed",
+              activeRun.runtimeSession?.startedAt ?? activeRun.startedAt ?? now.toISOString(),
+              now.toISOString(),
+              "incomplete-turn-dirty-workspace"
+            ) : activeRun.runtimeSession,
+            recovery,
+            lastError: recovery ? "Run suppressed with recoverable incomplete-turn dirty workspace." : terminalState ? "Run suppressed because the tracker issue moved to a terminal state." : "Run suppressed because the tracker state is no longer actionable."
           };
           await this.store.saveRun(suppressedRun);
           this.logVerbose(
@@ -4156,7 +4243,8 @@ var OrchestratorService = class {
         stateFieldName: "Status",
         activeStates: ["Todo", "In Progress"],
         terminalStates: ["Done"],
-        blockerCheckStates: ["Todo"]
+        blockerCheckStates: ["Todo"],
+        planningStates: ["Todo"]
       }
     };
   }
@@ -4246,7 +4334,7 @@ var OrchestratorService = class {
       true
     );
   }
-  async startRun(tenant, issue) {
+  async startRun(tenant, issue, options = {}) {
     if (this.shuttingDown || !this.running) {
       throw new Error(
         "Orchestrator is shutting down and cannot start new runs."
@@ -4288,7 +4376,8 @@ var OrchestratorService = class {
       repository: issue.repository,
       issueWorkspacePath,
       existingWorkspace: Boolean(existingWorkspaceRecord),
-      pullRequestBranch
+      pullRequestBranch,
+      allowDirtyExistingWorkspace: options.recovery?.kind === "incomplete-turn-dirty-workspace"
     });
     if (!existingWorkspaceRecord) {
       const workspaceRecord = {
@@ -4339,9 +4428,10 @@ var OrchestratorService = class {
       attempt: null
       // first execution
     });
-    const renderedPrompt = renderPrompt(
+    const renderedPrompt = appendIncompleteTurnRecoveryPrompt(
       workflow.promptTemplate,
-      promptVariables
+      promptVariables,
+      options.recovery ?? null
     );
     await this.runHook(
       "before_run",
@@ -4433,6 +4523,9 @@ var OrchestratorService = class {
           SYMPHONY_CUMULATIVE_OUTPUT_TOKENS: "0",
           SYMPHONY_CUMULATIVE_TOTAL_TOKENS: "0",
           SYMPHONY_LAST_TURN_SUMMARY: "",
+          SYMPHONY_RECOVERY_KIND: options.recovery?.kind ?? "",
+          SYMPHONY_RECOVERY_DIRTY_FILES: options.recovery ? formatRecoveryDirtyFilesForContext(options.recovery.dirtyFiles) : "",
+          SYMPHONY_RECOVERY_SUGGESTED_COMMAND: options.recovery?.suggestedCommand ?? "",
           SYMPHONY_SESSION_STARTED_AT: "",
           SYMPHONY_READ_TIMEOUT_MS: String(runtimeTimeouts.readTimeoutMs),
           SYMPHONY_TURN_TIMEOUT_MS: String(runtimeTimeouts.turnTimeoutMs)
@@ -4546,7 +4639,7 @@ var OrchestratorService = class {
       issueWorkspaceKey: workspaceKey,
       workspaceRuntimeDir,
       workflowPath: workflow.workflowPath,
-      retryKind: null,
+      retryKind: options.recovery ? "recovery" : null,
       threadId: null,
       cumulativeTurnCount: 0,
       lastTurnSummary: null,
@@ -4557,7 +4650,8 @@ var OrchestratorService = class {
       lastError: null,
       nextRetryAt: null,
       runPhase: "preparing_workspace",
-      rateLimits: issue.rateLimits ?? null
+      rateLimits: issue.rateLimits ?? null,
+      recovery: options.recovery ?? null
     };
   }
   async syncActiveRunIssueStates(tenant, trackerAdapter, activeRuns, now) {
@@ -5181,6 +5275,66 @@ var OrchestratorService = class {
     );
     return issue ? { issue, issues } : null;
   }
+  async classifyIncompleteTurnDirtyWorkspace(tenant, run, now) {
+    if (run.runtimeSession?.status !== "active" || run.runtimeSession.exitClassification !== null || run.lastEvent === "turn_completed") {
+      return null;
+    }
+    const workspaceKey = run.issueWorkspaceKey ?? deriveIssueWorkspaceKey(
+      {
+        adapter: tenant.tracker.adapter,
+        issueSubjectId: run.issueSubjectId
+      },
+      run.issueIdentifier
+    );
+    const issueWorkspacePath = resolveIssueWorkspaceDirectory(
+      this.store.projectDir(tenant.projectId),
+      workspaceKey
+    );
+    const dirtyStatus = await inspectIssueWorkspaceDirtyStatus({
+      issueWorkspacePath
+    });
+    if (!dirtyStatus?.dirty) {
+      return null;
+    }
+    return {
+      kind: "incomplete-turn-dirty-workspace",
+      runId: run.runId,
+      issueId: run.issueId,
+      issueIdentifier: run.issueIdentifier,
+      workspacePath: dirtyStatus.repositoryDirectory,
+      dirtyFiles: dirtyStatus.dirtyFiles,
+      lastEvent: run.lastEvent ?? null,
+      lastEventAt: run.lastEventAt ?? null,
+      sessionId: run.runtimeSession.sessionId ?? null,
+      threadId: run.threadId ?? run.runtimeSession.threadId ?? null,
+      suggestedCommand: `cd ${shellQuote(dirtyStatus.repositoryDirectory)} && git status --short && git diff`,
+      detectedAt: now.toISOString()
+    };
+  }
+  async resolveIncompleteTurnRecoveryContext(tenant, issue, latestRun, preferredWorkspaceKey) {
+    const recovery = latestRun?.recovery;
+    if (latestRun?.status !== "suppressed" || recovery?.kind !== "incomplete-turn-dirty-workspace" || latestRun.runtimeSession?.exitClassification !== "incomplete-turn-dirty-workspace") {
+      return null;
+    }
+    const workspaceKey = latestRun.issueWorkspaceKey ?? preferredWorkspaceKey;
+    const dirtyStatus = await inspectIssueWorkspaceDirtyStatus({
+      issueWorkspacePath: resolveIssueWorkspaceDirectory(
+        this.store.projectDir(tenant.projectId),
+        workspaceKey
+      )
+    });
+    if (!dirtyStatus?.dirty) {
+      return null;
+    }
+    return {
+      ...recovery,
+      issueId: issue.id,
+      issueIdentifier: issue.identifier,
+      workspacePath: dirtyStatus.repositoryDirectory,
+      dirtyFiles: dirtyStatus.dirtyFiles,
+      suggestedCommand: `cd ${shellQuote(dirtyStatus.repositoryDirectory)} && git status --short && git diff`
+    };
+  }
   async fetchWorkerRunInfo(run) {
     const latestRun = await this.store.loadRun(run.runId, run.projectId) ?? run;
     const persistedTokenUsage = await this.readPersistedWorkerTokenUsage(latestRun);
@@ -5757,9 +5911,50 @@ function buildRuntimeSession(existing, sessionId, threadId, status, startedAt, u
     exitClassification: exitClassification === void 0 ? existing?.exitClassification ?? null : exitClassification
   };
 }
+function appendIncompleteTurnRecoveryPrompt(promptTemplate, promptVariables, recovery) {
+  const renderedPrompt = renderPrompt(promptTemplate, promptVariables);
+  if (!recovery) {
+    return renderedPrompt;
+  }
+  return [
+    renderedPrompt,
+    "",
+    "## Recovery Context \u2014 Incomplete Turn Dirty Workspace",
+    "",
+    `Previous run: ${recovery.runId}`,
+    `Workspace: ${recovery.workspacePath}`,
+    `Last event: ${recovery.lastEvent ?? "unknown"}`,
+    `Last event time: ${recovery.lastEventAt ?? "unknown"}`,
+    `Session id: ${recovery.sessionId ?? "unknown"}`,
+    `Thread id: ${recovery.threadId ?? "unknown"}`,
+    "",
+    "Dirty files:",
+    ...formatRecoveryDirtyFileLinesForPrompt(recovery.dirtyFiles),
+    "",
+    "Inspect the dirty diff before editing. If the partial work is correct, validate it, commit it, and push it. If it is invalid, revert it explicitly and record a blocker/comment with the reason. Do not discard uncommitted work without making an intentional recovery decision.",
+    `Suggested operator command: ${recovery.suggestedCommand}`
+  ].join("\n");
+}
+function formatRecoveryDirtyFilesForContext(dirtyFiles) {
+  return formatRecoveryDirtyFiles(dirtyFiles).join("\n");
+}
+function formatRecoveryDirtyFileLinesForPrompt(dirtyFiles) {
+  return formatRecoveryDirtyFiles(dirtyFiles).map((file) => `- ${file}`);
+}
+function formatRecoveryDirtyFiles(dirtyFiles) {
+  const visibleFiles = dirtyFiles.slice(0, MAX_RECOVERY_DIRTY_FILES_IN_CONTEXT);
+  const remaining = dirtyFiles.length - visibleFiles.length;
+  if (remaining <= 0) {
+    return visibleFiles;
+  }
+  return [...visibleFiles, `... and ${remaining} more`];
+}
 function resolvePersistedCumulativeTurnCount(run) {
   return run.cumulativeTurnCount ?? run.turnCount ?? 0;
 }
+function shellQuote(value) {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
 function resolveCumulativeTurnCount(run, turnCount) {
   const carriedTotal = resolvePersistedCumulativeTurnCount(run);
   if (turnCount === null) {

package/dist/{chunk-DLZ2XHWY.js → chunk-QOX5UGUE.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-RZ3WO7OV.js";
 import {
   parseWorkflowMarkdown
-} from "./chunk-3SKN5L3I.js";
+} from "./chunk-6OPRRC2J.js";
 import {
   saveGlobalConfig,
   saveProjectConfig

package/dist/{chunk-5U36B7FC.js → chunk-TTVGBHZI.js}

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 import {
   workflow_init_default
-} from "./chunk-DTPIJO6S.js";
+} from "./chunk-ZPS4CQZJ.js";
 import {
   fetchGithubProjectIssueByRepositoryAndNumber,
   inspectManagedProjectSelection,
   resolveTrackerAdapter
-} from "./chunk-NRABQNAX.js";
+} from "./chunk-B6G3KGBB.js";
 import {
   GitHubApiError,
   createClient,
@@ -19,7 +19,7 @@ import {
   buildPromptVariables,
   parseWorkflowMarkdown,
   renderPrompt
-} from "./chunk-3SKN5L3I.js";
+} from "./chunk-6OPRRC2J.js";
 import {
   loadActiveProjectConfig
 } from "./chunk-4ICDSQCJ.js";
@@ -705,7 +705,9 @@ async function loadLinearIssue(issueIdentifier, workflow, options) {
     repository: projectConfig.repository,
     tracker: projectConfig.tracker
   };
-  const trackerAdapter = workflowCommandDependencies.resolveTrackerAdapter(projectConfig.tracker);
+  const trackerAdapter = workflowCommandDependencies.resolveTrackerAdapter(
+    projectConfig.tracker
+  );
   const [issue] = await trackerAdapter.fetchIssueStatesByIds(
     orchestratorProject,
     [issueIdentifier.trim().toUpperCase()],
@@ -752,6 +754,7 @@ function validateWorkflow(workflowPath, markdown) {
       activeStates: workflow.lifecycle.activeStates,
       terminalStates: workflow.lifecycle.terminalStates,
       blockerCheckStates: workflow.lifecycle.blockerCheckStates,
+      planningStates: workflow.lifecycle.planningStates,
       pollingIntervalMs: workflow.polling.intervalMs,
       workspaceRoot: workflow.workspace.root,
       agentCommand: workflow.agentCommand,
@@ -791,6 +794,7 @@ Lifecycle
   active_states=${report.summary.activeStates.join(", ") || "(none)"}
   terminal_states=${report.summary.terminalStates.join(", ") || "(none)"}
   blocker_check_states=${report.summary.blockerCheckStates.join(", ") || "(none)"}
+  planning_states=${report.summary.planningStates.join(", ") || "(none)"}
 
 Runtime
   polling.interval_ms=${report.summary.pollingIntervalMs}

package/dist/{chunk-FAU72YC2.js → chunk-Z7CDL3T2.js}

@@ -10,7 +10,7 @@ import {
   resolveGitHubGraphQLToken,
   shouldReuseAgentCredentialCache,
   writeAgentCredentialCache
-} from "./chunk-3SKN5L3I.js";
+} from "./chunk-6OPRRC2J.js";
 
 // ../runtime-codex/src/runtime.ts
 import { spawn } from "child_process";