agentic-orchestrator 0.1.6 → 0.1.8

package/apps/control-plane/src/cli/init-command-handler.ts

@@ -8,11 +8,17 @@ import { fileURLToPath } from 'node:url';
 import YAML from 'yaml';
 import { SchemaRegistry } from '../core/schemas.js';
 import { loadComposedPolicy } from '../application/services/policy-loader-service.js';
-import { AGENT_PROVIDER_SLOT, SCM_PROVIDER_SLOT, globalAdapterRegistry } from '../application/adapters/adapter-registry.js';
+import { readEnvFileValues, readNonEmptyEnvValue, upsertEnvFileValue } from './env-file.js';
+import {
+  AGENT_PROVIDER_SLOT,
+  SCM_PROVIDER_SLOT,
+  globalAdapterRegistry,
+} from '../application/adapters/adapter-registry.js';
 
 const execFileAsync = promisify(execFile);
 const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
 const TEMPLATE_ROOT = path.resolve(MODULE_DIR, '../../../../agentic/orchestrator');
+const GENERATED_CONFIG_ROOT = 'config/agentic/orchestrator';
 const DEFAULT_AGENT_PROVIDER = 'custom';
 const DEFAULT_AGENT_MODEL = 'local-default';
 const DEFAULT_SCM_PROVIDER = 'github';
@@ -42,6 +48,8 @@ interface WizardConfig {
   framework: TestFramework;
   defaultProvider: string;
   defaultModel: string;
+  providerConfigEnv: string | null;
+  providerCredentialBootstrapped: boolean;
   scmProvider: string;
   notifications: {
     desktop: boolean;
@@ -91,7 +99,7 @@ async function detectGitContext(repoRoot: string): Promise<GitContext> {
     const { stdout } = await execFileAsync(
       'git',
       ['-C', repoRoot, 'symbolic-ref', 'refs/remotes/origin/HEAD', '--short'],
-      { timeout: 3000 }
+      { timeout: 3000 },
     );
     const ref = stdout.trim();
     const parts = ref.split('/');
@@ -113,7 +121,7 @@ async function detectTestFramework(repoRoot: string): Promise<TestFramework> {
         : {}),
       ...(typeof pkg.devDependencies === 'object' && pkg.devDependencies !== null
         ? (pkg.devDependencies as Record<string, unknown>)
-        : {})
+        : {}),
     };
     if ('vitest' in deps) {
       return 'vitest';
@@ -130,7 +138,7 @@ async function detectTestFramework(repoRoot: string): Promise<TestFramework> {
     ['pyproject.toml', 'pytest'],
     ['pom.xml', 'maven'],
     ['build.gradle', 'gradle'],
-    ['build.gradle.kts', 'gradle']
+    ['build.gradle.kts', 'gradle'],
   ];
 
   for (const [file, framework] of buildFileChecks) {
@@ -145,7 +153,10 @@ async function detectTestFramework(repoRoot: string): Promise<TestFramework> {
   return 'vitest';
 }
 
-function buildGateCommands(framework: TestFramework): { test: string[]; testWithCoverage: string[] } {
+function buildGateCommands(framework: TestFramework): {
+  test: string[];
+  testWithCoverage: string[];
+} {
   switch (framework) {
     case 'jest':
       return { test: ['npx', 'jest'], testWithCoverage: ['npx', 'jest', '--coverage'] };
@@ -156,7 +167,10 @@ function buildGateCommands(framework: TestFramework): { test: string[]; testWith
     case 'gradle':
       return { test: ['./gradlew', 'test'], testWithCoverage: ['./gradlew', 'check'] };
     default:
-      return { test: ['npx', 'vitest', 'run'], testWithCoverage: ['npx', 'vitest', 'run', '--coverage'] };
+      return {
+        test: ['npx', 'vitest', 'run'],
+        testWithCoverage: ['npx', 'vitest', 'run', '--coverage'],
+      };
   }
 }
 
@@ -169,7 +183,8 @@ function escapeYamlString(value: string): string {
 }
 
 function generateLeanPolicyYaml(wizard: WizardConfig): string {
-  const notificationsEnabled = wizard.notifications.desktop || wizard.notifications.slack || wizard.notifications.webhook;
+  const notificationsEnabled =
+    wizard.notifications.desktop || wizard.notifications.slack || wizard.notifications.webhook;
   return `version: 1
 worktree:
   base_branch: ${wizard.baseBranch}
@@ -196,7 +211,8 @@ notifications:
 }
 
 function generateFullPolicyYaml(context: GitContext, wizard: WizardConfig): string {
-  const notificationsEnabled = wizard.notifications.desktop || wizard.notifications.slack || wizard.notifications.webhook;
+  const notificationsEnabled =
+    wizard.notifications.desktop || wizard.notifications.slack || wizard.notifications.webhook;
   return `version: 1
 commit_policy:
   allow_commit: false
@@ -222,7 +238,7 @@ locks:
     multiplier: 2
     jitter_ms: 150
 protected_areas:
-  - agentic/orchestrator/policy.yaml
+  - config/agentic/orchestrator/policy.yaml
 required_modes:
   - fast
   - full
@@ -389,20 +405,22 @@ capabilities:
 }
 
 function generateAgentsYaml(wizard: WizardConfig): string {
+  const providerConfigEnvLine = wizard.providerConfigEnv
+    ? `  provider_config_env: ${wizard.providerConfigEnv}\n`
+    : '';
   return `version: 1
 roles:
   planner:
-    system_prompt_path: agentic/orchestrator/prompts/planner.system.md
+    system_prompt_path: config/agentic/orchestrator/prompts/planner.system.md
   builder:
-    system_prompt_path: agentic/orchestrator/prompts/builder.system.md
+    system_prompt_path: config/agentic/orchestrator/prompts/builder.system.md
   qa:
-    system_prompt_path: agentic/orchestrator/prompts/qa.system.md
+    system_prompt_path: config/agentic/orchestrator/prompts/qa.system.md
 missing_prompt_behavior: ignore
 runtime:
   default_provider: ${wizard.defaultProvider}
   default_model: ${wizard.defaultModel}
-  provider_config_env: AOP_PROVIDER_CONFIG_ENV
-  role_provider_overrides: {}
+${providerConfigEnvLine}  role_provider_overrides: {}
 `;
 }
 
@@ -434,26 +452,45 @@ function parseInteger(raw: string, fallback: number, min: number, max: number):
 
 function parseFramework(raw: string, fallback: TestFramework): TestFramework {
   const value = raw.trim().toLowerCase();
-  if (value === 'vitest' || value === 'jest' || value === 'pytest' || value === 'maven' || value === 'gradle') {
+  if (
+    value === 'vitest' ||
+    value === 'jest' ||
+    value === 'pytest' ||
+    value === 'maven' ||
+    value === 'gradle'
+  ) {
     return value;
   }
   return fallback;
 }
 
-function parseNotificationChannels(raw: string): { desktop: boolean; slack: boolean; webhook: boolean } {
+function parseNotificationChannels(raw: string): {
+  desktop: boolean;
+  slack: boolean;
+  webhook: boolean;
+} {
   const normalized = raw.trim().toLowerCase();
   if (!normalized || normalized === 'none') {
     return { desktop: false, slack: false, webhook: false };
   }
-  const channels = new Set(normalized.split(',').map((token) => token.trim()).filter((token) => token.length > 0));
+  const channels = new Set(
+    normalized
+      .split(',')
+      .map((token) => token.trim())
+      .filter((token) => token.length > 0),
+  );
   return {
     desktop: channels.has('desktop'),
     slack: channels.has('slack'),
-    webhook: channels.has('webhook')
+    webhook: channels.has('webhook'),
   };
 }
 
-function parseAdapterName(raw: string, supportedNames: ReadonlySet<string>, fallback: string): string {
+function parseAdapterName(
+  raw: string,
+  supportedNames: ReadonlySet<string>,
+  fallback: string,
+): string {
   const value = raw.trim();
   if (supportedNames.has(value)) {
     return value;
@@ -471,12 +508,35 @@ function resolveActivityDetector(defaultProvider: string): string {
   return 'process-heuristic';
 }
 
-async function askWithDefault(prompt: PromptSession, label: string, defaultValue: string): Promise<string> {
+async function askWithDefault(
+  prompt: PromptSession,
+  label: string,
+  defaultValue: string,
+): Promise<string> {
   const raw = (await prompt.question(`${label} [${defaultValue}]: `)).trim();
   return raw.length > 0 ? raw : defaultValue;
 }
 
+function parseYesNo(raw: string, fallback: boolean): boolean {
+  const normalized = raw.trim().toLowerCase();
+  if (normalized === 'yes' || normalized === 'y' || normalized === 'true') {
+    return true;
+  }
+  if (normalized === 'no' || normalized === 'n' || normalized === 'false') {
+    return false;
+  }
+  return fallback;
+}
+
+function defaultProviderConfigEnvName(provider: string): string {
+  if (provider === 'gemini') {
+    return 'GEMINI_API_KEY';
+  }
+  return 'AOP_PROVIDER_CONFIG_ENV';
+}
+
 async function collectWizardConfig(
+  repoRoot: string,
   defaults: {
     branch: string;
     framework: TestFramework;
@@ -484,36 +544,42 @@ async function collectWizardConfig(
     defaultModel: string;
     defaultScmProvider: string;
   },
-  promptFactory: () => PromptSession
+  promptFactory: () => PromptSession,
 ): Promise<WizardConfig> {
   const prompt = promptFactory();
   try {
-    const supportedProviders = new Set(globalAdapterRegistry.list(AGENT_PROVIDER_SLOT.name).map((adapter) => adapter.name));
-    const supportedScmProviders = new Set(globalAdapterRegistry.list(SCM_PROVIDER_SLOT.name).map((adapter) => adapter.name));
+    const envFilePath = path.join(repoRoot, '.env');
+    const envFileValues = await readEnvFileValues(envFilePath);
+    const supportedProviders = new Set(
+      globalAdapterRegistry.list(AGENT_PROVIDER_SLOT.name).map((adapter) => adapter.name),
+    );
+    const supportedScmProviders = new Set(
+      globalAdapterRegistry.list(SCM_PROVIDER_SLOT.name).map((adapter) => adapter.name),
+    );
 
     const baseBranch = await askWithDefault(prompt, 'Worktree base branch', defaults.branch);
     const defaultProviderRaw = await askWithDefault(
       prompt,
       `Default agent provider (${Array.from(supportedProviders).join('|')})`,
-      defaults.defaultProvider
+      defaults.defaultProvider,
     );
     const defaultModel = await askWithDefault(prompt, 'Default model', defaults.defaultModel);
     const scmProviderRaw = await askWithDefault(
       prompt,
       `SCM provider (${Array.from(supportedScmProviders).join('|')})`,
-      defaults.defaultScmProvider
+      defaults.defaultScmProvider,
     );
     const maxParallelGateRunsRaw = await askWithDefault(prompt, 'Max parallel gate runs', '3');
     const dashboardPortRaw = await askWithDefault(prompt, 'Dashboard port', '3000');
     const channelsRaw = await askWithDefault(
       prompt,
       'Notification channels (comma-separated: desktop,slack,webhook,none)',
-      'none'
+      'none',
     );
     const frameworkRaw = await askWithDefault(
       prompt,
       'Test framework (vitest|jest|pytest|maven|gradle)',
-      defaults.framework
+      defaults.framework,
     );
 
     const channels = parseNotificationChannels(channelsRaw);
@@ -527,11 +593,57 @@ async function collectWizardConfig(
       webhookUrl = (await prompt.question('Webhook URL []: ')).trim();
     }
 
+    const localCliAnswer = await askWithDefault(
+      prompt,
+      'Will you use a local agent CLI (codex/claude-code/kiro-cli/copilot)? (yes/no)',
+      'yes',
+    );
+    const usesLocalCli = parseYesNo(localCliAnswer, true);
+
+    let providerConfigEnv: string | null = null;
+    let providerCredentialBootstrapped = false;
+
+    if (!usesLocalCli) {
+      const envVarName = await askWithDefault(
+        prompt,
+        'Provider config env var name',
+        defaultProviderConfigEnvName(defaultProviderRaw),
+      );
+      const envValue = readNonEmptyEnvValue(envVarName, process.env, envFileValues);
+
+      if (envValue) {
+        providerConfigEnv = envVarName;
+      } else {
+        output.write(
+          `Environment variable "${envVarName}" was not found in process env or ${envFilePath}.\n`,
+        );
+        let pastedKey = '';
+        while (pastedKey.length === 0) {
+          pastedKey = (
+            await prompt.question('Paste provider key to store in AOP_PROVIDER_CONFIG_ENV: ')
+          ).trim();
+        }
+        await upsertEnvFileValue(envFilePath, 'AOP_PROVIDER_CONFIG_ENV', pastedKey);
+        providerConfigEnv = 'AOP_PROVIDER_CONFIG_ENV';
+        providerCredentialBootstrapped = true;
+      }
+    }
+
     return {
       baseBranch,
-      defaultProvider: parseAdapterName(defaultProviderRaw, supportedProviders, defaults.defaultProvider),
+      defaultProvider: parseAdapterName(
+        defaultProviderRaw,
+        supportedProviders,
+        defaults.defaultProvider,
+      ),
       defaultModel,
-      scmProvider: parseAdapterName(scmProviderRaw, supportedScmProviders, defaults.defaultScmProvider),
+      providerConfigEnv,
+      providerCredentialBootstrapped,
+      scmProvider: parseAdapterName(
+        scmProviderRaw,
+        supportedScmProviders,
+        defaults.defaultScmProvider,
+      ),
       maxParallelGateRuns: parseInteger(maxParallelGateRunsRaw, 3, 1, 64),
       dashboardPort: parseInteger(dashboardPortRaw, 3000, 1, 65535),
       framework: parseFramework(frameworkRaw, defaults.framework),
@@ -540,8 +652,8 @@ async function collectWizardConfig(
         slack: channels.slack,
         webhook: channels.webhook,
         slackWebhook,
-        webhookUrl
-      }
+        webhookUrl,
+      },
     };
   } finally {
     prompt.close();
@@ -550,7 +662,7 @@ async function collectWizardConfig(
 
 async function loadTemplateFiles(
   subdir: 'prompts',
-  matcher: (filename: string) => boolean
+  matcher: (filename: string) => boolean,
 ): Promise<Array<{ rel: string; content: string }>> {
   const sourceDir = path.join(TEMPLATE_ROOT, subdir);
   const entries = await fs.readdir(sourceDir, { withFileTypes: true });
@@ -561,8 +673,8 @@ async function loadTemplateFiles(
     }
     const full = path.join(sourceDir, entry.name);
     templates.push({
-      rel: `agentic/orchestrator/${subdir}/${entry.name}`,
-      content: await fs.readFile(full, 'utf8')
+      rel: `${GENERATED_CONFIG_ROOT}/${subdir}/${entry.name}`,
+      content: await fs.readFile(full, 'utf8'),
     });
   }
   return templates.sort((a, b) => a.rel.localeCompare(b.rel));
@@ -585,6 +697,8 @@ export class InitCommandHandler {
           baseBranch: gitContext.defaultBranch,
           defaultProvider: DEFAULT_AGENT_PROVIDER,
           defaultModel: DEFAULT_AGENT_MODEL,
+          providerConfigEnv: null,
+          providerCredentialBootstrapped: false,
           scmProvider: DEFAULT_SCM_PROVIDER,
           maxParallelGateRuns: 3,
           dashboardPort: 3000,
@@ -594,21 +708,22 @@ export class InitCommandHandler {
             slack: false,
             webhook: false,
             slackWebhook: '',
-            webhookUrl: ''
-          }
+            webhookUrl: '',
+          },
         }
       : await collectWizardConfig(
+          this.repoRoot,
           {
             branch: gitContext.defaultBranch,
             framework,
             defaultProvider: DEFAULT_AGENT_PROVIDER,
             defaultModel: DEFAULT_AGENT_MODEL,
-            defaultScmProvider: DEFAULT_SCM_PROVIDER
+            defaultScmProvider: DEFAULT_SCM_PROVIDER,
           },
-          this.promptFactory
+          this.promptFactory,
         );
 
-    const orchestratorDir = path.join(this.repoRoot, 'agentic', 'orchestrator');
+    const orchestratorDir = path.join(this.repoRoot, 'config', 'agentic', 'orchestrator');
     await fs.mkdir(orchestratorDir, { recursive: true });
 
     const policyContent = options.advanced_policy
@@ -617,14 +732,16 @@ export class InitCommandHandler {
 
     const configFiles: Array<{ rel: string; content: string }> = [
       {
-        rel: 'agentic/orchestrator/policy.yaml',
-        content: policyContent
+        rel: `${GENERATED_CONFIG_ROOT}/policy.yaml`,
+        content: policyContent,
       },
-      { rel: 'agentic/orchestrator/gates.yaml', content: generateGatesYaml(wizard.framework) },
-      { rel: 'agentic/orchestrator/agents.yaml', content: generateAgentsYaml(wizard) },
-      { rel: 'agentic/orchestrator/adapters.yaml', content: generateAdaptersYaml(wizard) }
+      { rel: `${GENERATED_CONFIG_ROOT}/gates.yaml`, content: generateGatesYaml(wizard.framework) },
+      { rel: `${GENERATED_CONFIG_ROOT}/agents.yaml`, content: generateAgentsYaml(wizard) },
+      { rel: `${GENERATED_CONFIG_ROOT}/adapters.yaml`, content: generateAdaptersYaml(wizard) },
     ];
-    const templateFiles = await loadTemplateFiles('prompts', (filename) => filename.endsWith('.md'));
+    const templateFiles = await loadTemplateFiles('prompts', (filename) =>
+      filename.endsWith('.md'),
+    );
     const writableFiles = [...configFiles, ...templateFiles];
 
     const created: string[] = [];
@@ -660,19 +777,23 @@ export class InitCommandHandler {
 
     // Validate policy.yaml via composition loader (merges user policy over bundled defaults
     // then validates the merged result against the full schema).
-    const policyRel = 'agentic/orchestrator/policy.yaml';
+    const policyRel = `${GENERATED_CONFIG_ROOT}/policy.yaml`;
     if (!skipped.includes(policyRel)) {
       try {
-        await loadComposedPolicy(this.repoRoot, path.join(this.repoRoot, policyRel), schemaRegistry);
+        await loadComposedPolicy(
+          this.repoRoot,
+          path.join(this.repoRoot, policyRel),
+          schemaRegistry,
+        );
       } catch (err) {
         validationWarnings.push(`Failed to validate ${policyRel}: ${String(err)}`);
       }
     }
 
     const nonPolicyTargets: Array<{ schema: string; rel: string }> = [
-      { schema: 'gates.schema.json', rel: 'agentic/orchestrator/gates.yaml' },
-      { schema: 'agents.schema.json', rel: 'agentic/orchestrator/agents.yaml' },
-      { schema: 'adapters.schema.json', rel: 'agentic/orchestrator/adapters.yaml' }
+      { schema: 'gates.schema.json', rel: `${GENERATED_CONFIG_ROOT}/gates.yaml` },
+      { schema: 'agents.schema.json', rel: `${GENERATED_CONFIG_ROOT}/agents.yaml` },
+      { schema: 'adapters.schema.json', rel: `${GENERATED_CONFIG_ROOT}/adapters.yaml` },
     ];
 
     for (const { schema, rel } of nonPolicyTargets) {
@@ -695,12 +816,17 @@ export class InitCommandHandler {
     const policyMode = options.advanced_policy ? 'full (advanced)' : 'lean (common controls only)';
     const nextSteps = [
       `Generated policy.yaml in ${policyMode} mode`,
-      'Review generated files in agentic/orchestrator/{policy,gates,agents,adapters}.yaml',
-      'Verify prompts under agentic/orchestrator/prompts/',
-      'Run: aop run -fi <spec.md> to start orchestrating features'
+      'Review generated files in config/agentic/orchestrator/{policy,gates,agents,adapters}.yaml',
+      'Verify prompts under config/agentic/orchestrator/prompts/',
+      'Run: aop run -fi <spec.md> to start orchestrating features',
     ];
     if (!options.advanced_policy) {
-      nextSteps.push('To generate a full explicit policy with all advanced controls, re-run: aop init --advanced-policy --force');
+      nextSteps.push(
+        'To generate a full explicit policy with all advanced controls, re-run: aop init --advanced-policy --force',
+      );
+    }
+    if (wizard.providerCredentialBootstrapped) {
+      nextSteps.push('Stored provider credential in .env as AOP_PROVIDER_CONFIG_ENV.');
     }
 
     return {
@@ -711,8 +837,8 @@ export class InitCommandHandler {
         updated,
         skipped,
         validation_warnings: validationWarnings,
-        next_steps: nextSteps
-      }
+        next_steps: nextSteps,
+      },
     };
   }
 }

package/apps/control-plane/src/cli/io.ts

@@ -2,13 +2,17 @@ export function printPayload(payload: unknown): void {
   process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
 }
 
-export function printError(code: string, message: string, details: Record<string, unknown> = {}): void {
+export function printError(
+  code: string,
+  message: string,
+  details: Record<string, unknown> = {},
+): void {
   printPayload({
     ok: false,
     error: {
       code,
       message,
-      details
-    }
+      details,
+    },
   });
 }

package/apps/control-plane/src/cli/resume-command-handler.ts

@@ -97,15 +97,15 @@ export class ResumeCommandHandler {
           transport,
           resumed: false,
           recovery: recovery.data,
-          resume_plan: resumePlan
-        }
+          resume_plan: resumePlan,
+        },
       };
     }
 
     const selection = resolveProviderSelection({
       cli: options as unknown as Record<string, string | undefined>,
       env,
-      agentsConfig: kernel.getAgentsConfig()
+      agentsConfig: kernel.getAgentsConfig(),
     });
 
     const provider = new NullWorkerProvider(selection);
@@ -114,13 +114,13 @@ export class ResumeCommandHandler {
       max_parallel_gate_runs: 3,
       run_id: resumePlan.run_id,
       owner_instance_id: resumePlan.owner_instance_id,
-      takeover_stale_run: options.takeover_stale_run
+      takeover_stale_run: options.takeover_stale_run,
     });
 
     const startResult = await supervisor.start(
       resumePlan.features.map((feature) => ({
-        feature_id: feature.feature_id
-      }))
+        feature_id: feature.feature_id,
+      })),
     );
 
     return {
@@ -134,8 +134,8 @@ export class ResumeCommandHandler {
         runtime_status: startResult.status,
         run_metadata: startResult.run_metadata,
         dashboard: startResult.dashboard,
-        recovery: recovery.data
-      }
+        recovery: recovery.data,
+      },
     };
   }
 
@@ -177,7 +177,8 @@ export class ResumeCommandHandler {
       try {
         const state = await kernel.featureStateGet(featureId);
         const frontMatter = asRecord(state.data.front_matter);
-        const status = typeof frontMatter.status === 'string' ? frontMatter.status : STATUS.PLANNING;
+        const status =
+          typeof frontMatter.status === 'string' ? frontMatter.status : STATUS.PLANNING;
         if (isTerminalStatus(status)) {
           continue;
         }
@@ -186,7 +187,9 @@ export class ResumeCommandHandler {
           feature_id: featureId,
           status,
           resume_phase: toResumePhase(status),
-          sources: [...(sourcesByFeature.get(featureId) ?? new Set<string>())].sort((a, b) => a.localeCompare(b))
+          sources: [...(sourcesByFeature.get(featureId) ?? new Set<string>())].sort((a, b) =>
+            a.localeCompare(b),
+          ),
         });
       } catch (_error) {
         // Silently skip features with parse errors
@@ -201,7 +204,8 @@ export class ResumeCommandHandler {
       return a.feature_id.localeCompare(b.feature_id);
     });
 
-    const resolvedRunId = runtimeSessions.run_id !== 'none' ? runtimeSessions.run_id : fallbackRunId;
+    const resolvedRunId =
+      runtimeSessions.run_id !== 'none' ? runtimeSessions.run_id : fallbackRunId;
     const resolvedOwnerInstanceId =
       runtimeSessions.owner_instance_id !== 'none'
         ? runtimeSessions.owner_instance_id
@@ -210,11 +214,15 @@ export class ResumeCommandHandler {
     return {
       run_id: resolvedRunId,
       owner_instance_id: resolvedOwnerInstanceId,
-      features: resumable
+      features: resumable,
     };
   }
 
-  private addSource(sourcesByFeature: Map<string, Set<string>>, featureId: string, source: string): void {
+  private addSource(
+    sourcesByFeature: Map<string, Set<string>>,
+    featureId: string,
+    source: string,
+  ): void {
     if (!featureId) {
       return;
     }

package/apps/control-plane/src/cli/retry-command-handler.ts

@@ -41,14 +41,14 @@ export class RetryCommandHandler {
     if (!featureId) {
       invalidCliArgs({
         reason: '--feature-id is required for retry',
-        expected: '--feature-id <feature_id>'
+        expected: '--feature-id <feature_id>',
       });
     }
     if (!isValidFeatureId(featureId)) {
       invalidCliArgs({
         reason: 'Invalid --feature-id value',
         provided: featureId,
-        expected_pattern: '^[a-z0-9_][a-z0-9_-]*$'
+        expected_pattern: '^[a-z0-9_][a-z0-9_-]*$',
       });
     }
 
@@ -57,7 +57,7 @@ export class RetryCommandHandler {
     let forcedRetryExecuted = false;
 
     const current = await callCliTool(this.toolClient, this.runId, TOOLS.FEATURE_STATE_GET, {
-      feature_id: featureId
+      feature_id: featureId,
     });
     const statePayload = current.data as unknown as RetryFeatureStatePayload;
 
@@ -70,7 +70,8 @@ export class RetryCommandHandler {
           ? 'fast'
           : status === 'qa' || status === 'ready_to_merge'
             ? 'full'
-            : status === 'blocked' && statePayload.front_matter.status_reason?.includes('forced_retry:fast')
+            : status === 'blocked' &&
+                statePayload.front_matter.status_reason?.includes('forced_retry:fast')
               ? 'fast'
               : 'full';
 
@@ -78,14 +79,14 @@ export class RetryCommandHandler {
       invalidCliArgs({
         reason: 'Cannot retry a terminal feature status without --force',
         status,
-        expected_status: ['building', 'qa', 'ready_to_merge', 'blocked']
+        expected_status: ['building', 'qa', 'ready_to_merge', 'blocked'],
       });
     }
 
     if (force) {
       const frontMatterPatch: Record<string, unknown> = {
         gate_retry_count: 0,
-        last_retry_at: null
+        last_retry_at: null,
       };
       if (status === 'blocked') {
         frontMatterPatch.status =
@@ -103,8 +104,8 @@ export class RetryCommandHandler {
         feature_id: featureId,
         expected_version: statePayload.front_matter.version,
         patch: {
-          front_matter: frontMatterPatch
-        }
+          front_matter: frontMatterPatch,
+        },
       });
       retryCountReset = true;
       forcedRetryExecuted = true;
@@ -113,7 +114,7 @@ export class RetryCommandHandler {
     const gate = await callCliTool(this.toolClient, this.runId, TOOLS.GATES_RUN, {
       feature_id: featureId,
       profile: null,
-      mode: inferredMode
+      mode: inferredMode,
     });
     const retryExecuted = true;
     const retryMode = inferredMode;
@@ -128,8 +129,8 @@ export class RetryCommandHandler {
         retry_executed: retryExecuted,
         forced_retry_executed: forcedRetryExecuted,
         retry_mode: retryMode,
-        retry_outcome: retryOutcome
-      }
+        retry_outcome: retryOutcome,
+      },
     };
   }
 }