@gh-symphony/cli 0.3.0 → 0.4.1

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-GTNWFVFU.js → chunk-3EFLX75C.js}

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 import {
   workflow_init_default
-} from "./chunk-GL55AKBI.js";
+} from "./chunk-RU5GQG6A.js";
 import {
   fetchGithubProjectIssueByRepositoryAndNumber,
   inspectManagedProjectSelection,
   resolveTrackerAdapter
-} from "./chunk-VHEGRYK7.js";
+} from "./chunk-BBUCDKSL.js";
 import {
   GitHubApiError,
   createClient,
@@ -19,10 +19,10 @@ import {
   buildPromptVariables,
   parseWorkflowMarkdown,
   renderPrompt
-} from "./chunk-5HQLPZR5.js";
+} from "./chunk-YKC6CGD6.js";
 import {
   loadActiveProjectConfig
-} from "./chunk-4ICDSQCJ.js";
+} from "./chunk-YZP5N5XP.js";
 
 // src/commands/workflow.ts
 import { readFile } from "fs/promises";
@@ -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] [--dry-run]
+  workflow init [--non-interactive] [--project <id>] [--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/{chunk-RZ3WO7OV.js → chunk-3IRPSPAF.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   REPO_RUNTIME_DIR
-} from "./chunk-4ICDSQCJ.js";
+} from "./chunk-YZP5N5XP.js";
 
 // src/orchestrator-runtime.ts
 import { resolve } from "path";

package/dist/{chunk-VHEGRYK7.js → chunk-BBUCDKSL.js}

@@ -30,11 +30,11 @@ import {
   resolveWorkflowRuntimeTimeouts,
   safeReadDir,
   scheduleRetryAt
-} from "./chunk-5HQLPZR5.js";
+} from "./chunk-YKC6CGD6.js";
 import {
   loadGlobalConfig,
   loadProjectConfig
-} from "./chunk-4ICDSQCJ.js";
+} from "./chunk-YZP5N5XP.js";
 
 // ../tracker-github/src/adapter.ts
 import { createHash } from "crypto";
@@ -1865,7 +1865,9 @@ var linearTrackerAdapter = {
     return listLinearIssues(
       project,
       project.tracker.settings?.activeStates,
-      dependencies
+      dependencies,
+      void 0,
+      { applyPickupLabels: true }
     );
   },
   async listIssuesByStates(project, states, dependencies = {}) {
@@ -1914,7 +1916,7 @@ var linearTrackerAdapter = {
     };
   }
 };
-async function listLinearIssues(project, stateNamesInput, dependencies, issueIds) {
+async function listLinearIssues(project, stateNamesInput, dependencies, issueIds, options = {}) {
   const config = resolveLinearTrackerConfig(project, dependencies);
   const client = createLinearGraphqlClient(config, dependencies.fetchImpl);
   const stateNames = readStringArray(stateNamesInput);
@@ -1931,10 +1933,15 @@ async function listLinearIssues(project, stateNamesInput, dependencies, issueIds
     assignedOnly: config.assignedOnly,
     pageSize: config.pageSize
   });
-  const issues = result.nodes.map(
+  const fetchedIssues = result.nodes.map(
     (node) => normalizeLinearIssue(project, config.projectSlug, node, result.rateLimits)
   );
-  Object.defineProperty(issues, "rateLimits", {
+  const filteredIssues = options.applyPickupLabels ? filterIssuesByPickupLabels(
+    fetchedIssues,
+    config.pickupLabels,
+    config.projectSlug
+  ) : fetchedIssues;
+  Object.defineProperty(filteredIssues, "rateLimits", {
     configurable: true,
     enumerable: false,
     value: result.rateLimits,
@@ -1943,10 +1950,10 @@ async function listLinearIssues(project, stateNamesInput, dependencies, issueIds
   if (config.assignedOnly) {
     emitAssignedOnlyFilterEvent2({
       projectSlug: config.projectSlug,
-      includedCount: issues.length
+      includedCount: filteredIssues.length
     });
   }
-  return issues;
+  return filteredIssues;
 }
 async function fetchPaginatedLinearIssues(client, input) {
   const issues = [];
@@ -2100,6 +2107,7 @@ function resolveLinearTrackerConfig(project, dependencies) {
     endpoint: resolveLinearEndpoint(project.tracker),
     assignedOnly: resolveAssignedOnly2(project.tracker, dependencies),
     pageSize: readPositiveIntegerSetting(project.tracker, "pageSize") ?? DEFAULT_PAGE_SIZE2,
+    pickupLabels: resolvePickupLabels(project.tracker),
     projectSlug,
     token
   };
@@ -2155,6 +2163,24 @@ function readBooleanSetting(tracker, key) {
   const value = tracker.settings?.[key];
   return value === true || value === "true";
 }
+function resolvePickupLabels(tracker) {
+  const pickupLabels = readObjectSetting(tracker, "pickupLabels") ?? readObjectSetting(tracker, "pickup_labels");
+  return {
+    include: normalizeConfiguredLabels(
+      readStringArray(pickupLabels?.include) ?? []
+    ),
+    exclude: normalizeConfiguredLabels(
+      readStringArray(pickupLabels?.exclude) ?? []
+    )
+  };
+}
+function readObjectSetting(tracker, key) {
+  const value = tracker.settings?.[key];
+  if (value === void 0 || value === null || Array.isArray(value) || typeof value !== "object") {
+    return void 0;
+  }
+  return value;
+}
 function readStringArray(value) {
   if (value === void 0) {
     return void 0;
@@ -2167,6 +2193,35 @@ function readStringArray(value) {
   }
   return value.filter((entry) => typeof entry === "string");
 }
+function normalizeConfiguredLabels(labels) {
+  return Array.from(
+    new Set(
+      labels.map((label) => label.trim()).filter((label) => label.length > 0)
+    )
+  );
+}
+function filterIssuesByPickupLabels(issues, config, projectSlug) {
+  if (config.include.length === 0 && config.exclude.length === 0) {
+    return issues;
+  }
+  const includeLabels = new Set(config.include);
+  const excludeLabels = new Set(config.exclude);
+  const filtered = issues.filter((issue) => {
+    const issueLabels = new Set(issue.labels);
+    if (config.exclude.some((label) => issueLabels.has(label))) {
+      return false;
+    }
+    return includeLabels.size === 0 || config.include.some((label) => issueLabels.has(label));
+  });
+  emitPickupLabelFilterEvent({
+    projectSlug,
+    include: [...includeLabels],
+    exclude: [...excludeLabels],
+    includedCount: filtered.length,
+    excludedCount: issues.length - filtered.length
+  });
+  return filtered;
+}
 function emitAssignedOnlyFilterEvent2(input) {
   console.info(
     JSON.stringify({
@@ -2179,6 +2234,19 @@ function emitAssignedOnlyFilterEvent2(input) {
     })
   );
 }
+function emitPickupLabelFilterEvent(input) {
+  console.info(
+    JSON.stringify({
+      event: "tracker-pickup-label-filtered",
+      tracker: "linear",
+      projectSlug: input.projectSlug,
+      include: input.include,
+      exclude: input.exclude,
+      includedCount: input.includedCount,
+      excludedCount: input.excludedCount
+    })
+  );
+}
 function requireString(value, label) {
   if (typeof value !== "string" || value.length === 0) {
     throw new Error(`${label} is required.`);
@@ -2313,14 +2381,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 +2403,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 +2466,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 +2483,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 +2630,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 +3303,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 +3426,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 +3672,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 +3903,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 +3921,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 +3980,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 +3992,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 +4028,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 +4040,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(
@@ -4247,7 +4402,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."
@@ -4289,7 +4444,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 = {
@@ -4340,9 +4496,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",
@@ -4434,6 +4591,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)
@@ -4547,7 +4707,7 @@ var OrchestratorService = class {
       issueWorkspaceKey: workspaceKey,
       workspaceRuntimeDir,
       workflowPath: workflow.workflowPath,
-      retryKind: null,
+      retryKind: options.recovery ? "recovery" : null,
       threadId: null,
       cumulativeTurnCount: 0,
       lastTurnSummary: null,
@@ -4558,7 +4718,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) {
@@ -5182,6 +5343,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);
@@ -5758,9 +5979,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-A7EFL6EJ.js → chunk-GOR4JGJT.js}

@@ -10,7 +10,7 @@ import {
   resolveGitHubGraphQLToken,
   shouldReuseAgentCredentialCache,
   writeAgentCredentialCache
-} from "./chunk-5HQLPZR5.js";
+} from "./chunk-YKC6CGD6.js";
 
 // ../runtime-codex/src/runtime.ts
 import { spawn } from "child_process";

package/dist/{chunk-2ZIPQ7ZS.js → chunk-MUN7QSFF.js}

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 import {
   resolveRepoRuntimeRoot
-} from "./chunk-RZ3WO7OV.js";
+} from "./chunk-3IRPSPAF.js";
 import {
   parseWorkflowMarkdown
-} from "./chunk-5HQLPZR5.js";
+} from "./chunk-YKC6CGD6.js";
 import {
   saveGlobalConfig,
   saveProjectConfig
-} from "./chunk-4ICDSQCJ.js";
+} from "./chunk-YZP5N5XP.js";
 
 // src/repo-runtime.ts
 import { execFileSync } from "child_process";
@@ -68,6 +68,9 @@ async function initRepoRuntime(flags) {
     ...trackerAdapter === "linear" ? { activeStates: workflow.tracker.activeStates.join("\n") } : {},
     repository: `${repository.owner}/${repository.name}`
   };
+  if (trackerAdapter === "linear" && (workflow.tracker.pickupLabels.include.length > 0 || workflow.tracker.pickupLabels.exclude.length > 0)) {
+    trackerSettings.pickupLabels = workflow.tracker.pickupLabels;
+  }
   if (workflow.tracker.priorityFieldName) {
     trackerSettings.priorityFieldName = workflow.tracker.priorityFieldName;
   }