@gh-symphony/cli 0.0.20 → 0.0.21

package/dist/{chunk-RN2PACNV.js → chunk-JN3TQVFV.js}

@@ -4,12 +4,18 @@ import {
   GitHubScopeError,
   checkRequiredScopes,
   createClient,
+  discoverUserProjects,
   getGhTokenWithSource,
   getProjectDetail,
   listUserProjects,
   resolveGitHubAuth,
   validateToken
-} from "./chunk-TILHWBP6.js";
+} from "./chunk-C67H3OUL.js";
+import {
+  formatClaudePreflightText,
+  resolveClaudeCommandBinary,
+  runClaudePreflight
+} from "./chunk-QEONJ5DZ.js";
 import {
   loadGlobalConfig,
   saveGlobalConfig,
@@ -18,8 +24,9 @@ import {
 
 // src/commands/init.ts
 import * as p from "@clack/prompts";
+import { spawnSync } from "child_process";
 import { createHash } from "crypto";
-import { mkdir as mkdir3, readFile as readFile3, rename as rename2, writeFile as writeFile3 } from "fs/promises";
+import { chmod, mkdir as mkdir3, readFile as readFile3, rename as rename2, writeFile as writeFile3 } from "fs/promises";
 import { basename, dirname as dirname2, join as join3, relative, resolve } from "path";
 
 // src/mapping/smart-defaults.ts
@@ -99,10 +106,243 @@ function validateStateMapping(mappings) {
   return { valid: errors.length === 0, errors, warnings };
 }
 
+// src/prompts/runtime-claude-constraints.ts
+var CLAUDE_RUNTIME_CONSTRAINTS_SECTION = `## Runtime Constraints
+
+1. This run uses \`claude-print\` (Claude Code CLI) in non-interactive mode via \`claude -p\`.
+2. Slash commands such as \`/commit\`, \`/push\`, \`/gh-project\`, \`/gh-pr-writeup\` are NOT available (CLI limitation, independent of isolation settings).
+3. Use \`gh\`, \`git\`, repository scripts, and configured MCP tools directly instead.
+4. If a required permission or tool is unavailable, post a blocker comment on the issue and exit. Do not wait for human input.`;
+var CLAUDE_PERMISSIVE_ISOLATION_NOTE = "<!-- Runtime trade-off note: Permissive preset requires an isolated workspace. Symphony runs each issue in `.runtime/symphony-workspaces/<workspace-id>/`, a throwaway clone. If you disable workspace isolation or mount host paths into worker containers, do not use this runtime in production. -->";
+var CLAUDE_ISOLATION_OFF_NOTE = "<!-- Runtime trade-off note: Isolation is off by default \u2014 the agent will pick up your `CLAUDE.md`, project skills, and personal MCPs from `~/.claude/`. Turn isolation on when running in multi-operator CI, shared infrastructure, or when reproducibility across machines matters. -->";
+var CLAUDE_RUNTIME_PROMPT_PREAMBLE = [
+  CLAUDE_RUNTIME_CONSTRAINTS_SECTION,
+  CLAUDE_PERMISSIVE_ISOLATION_NOTE,
+  CLAUDE_ISOLATION_OFF_NOTE
+].join("\n\n");
+
+// src/workflow/default-hooks.ts
+var DEFAULT_AFTER_CREATE_HOOK_PATH = "hooks/after_create.sh";
+var DEFAULT_AFTER_CREATE_HOOK_LABEL = "Workspace hook scaffold";
+var DEFAULT_AFTER_CREATE_HOOK_COMMENT = "scaffolded by workflow init; customize this script for repository setup";
+var DEFAULT_AFTER_CREATE_HOOK_CONTENT = `#!/usr/bin/env bash
+set -euo pipefail
+
+# Customize this hook to prepare a freshly created workspace.
+# This scaffold is intentionally a no-op so generated workflows run cleanly.
+exit 0
+`;
+
+// src/workflow/repository-guidance.ts
+function normalizeCommand(command) {
+  return command.replace(/\s+/g, " ").trim();
+}
+function renderInlineCode(command) {
+  const normalized = normalizeCommand(command);
+  const longestBacktickRun = Math.max(
+    0,
+    ...Array.from(normalized.matchAll(/`+/g), (match) => match[0].length)
+  );
+  const fence = "`".repeat(longestBacktickRun + 1);
+  const padded = normalized.startsWith("`") || normalized.endsWith("`") ? ` ${normalized} ` : normalized;
+  return `${fence}${padded}${fence}`;
+}
+function buildRunnableScriptCommand(packageManager, scriptName) {
+  switch (packageManager) {
+    case "pnpm":
+      return scriptName === "test" ? "pnpm test" : `pnpm ${scriptName}`;
+    case "npm":
+      return scriptName === "test" ? "npm test" : `npm run ${scriptName}`;
+    case "yarn":
+      return `yarn ${scriptName}`;
+    case "bun":
+      return `bun run ${scriptName}`;
+    default:
+      return null;
+  }
+}
+function formatDetectedCommand(label, rawCommand, packageManager) {
+  if (!rawCommand) {
+    return null;
+  }
+  const runnableCommand = buildRunnableScriptCommand(packageManager, label);
+  const normalizedRawCommand = normalizeCommand(rawCommand);
+  if (!runnableCommand) {
+    return `${label}: ${renderInlineCode(normalizedRawCommand)}`;
+  }
+  if (normalizeCommand(runnableCommand) === normalizedRawCommand) {
+    return `${label}: ${renderInlineCode(runnableCommand)}`;
+  }
+  return `${label}: ${renderInlineCode(runnableCommand)} (script: ${renderInlineCode(
+    normalizedRawCommand
+  )})`;
+}
+function buildRepositoryValidationGuidance(input) {
+  const lines = [];
+  const commands = [
+    formatDetectedCommand("test", input.testCommand, input.packageManager),
+    formatDetectedCommand("lint", input.lintCommand, input.packageManager),
+    formatDetectedCommand("build", input.buildCommand, input.packageManager)
+  ].filter((value) => value !== null);
+  if (commands.length > 0) {
+    lines.push(
+      `Detected repository validation commands: ${commands.join(" ; ")}.`
+    );
+    lines.push(
+      "Prefer these repository-defined commands over generic guesses when validating changes."
+    );
+    lines.push(
+      "Use the smallest relevant command during iteration, then run the full available validation sequence before handoff in this order when applicable: test, lint, build."
+    );
+  } else {
+    lines.push(
+      "No repository-specific test/lint/build scripts were detected. Keep the generic fallback posture: infer the smallest meaningful validation command from the files you changed, and explicitly report when no automated validation is available."
+    );
+  }
+  if (input.packageManager) {
+    lines.push(
+      `Use \`${input.packageManager}\` conventions for ad hoc install/run commands unless the repository clearly requires something else.`
+    );
+  }
+  if (input.monorepo) {
+    lines.push(
+      "This repository appears to be a monorepo. Infer the affected package or workspace first, prefer workspace-scoped validation when available, and avoid unnecessary full-repo runs unless cross-package changes require them."
+    );
+  }
+  return lines;
+}
+
+// src/workflow/workflow-runtime.ts
+var CODEX_RUNTIME_TOKENS = ["codex-app-server", "codex"];
+var CLAUDE_RUNTIME_TOKENS = ["claude-print", "claude-code"];
+var DEFAULT_CODEX_APP_SERVER_ARGS = ["app-server"];
+var DEFAULT_CLAUDE_PRINT_ARGS = [
+  "-p",
+  "--output-format",
+  "stream-json",
+  "--input-format",
+  "stream-json",
+  "--include-partial-messages",
+  "--verbose",
+  "--permission-mode",
+  "bypassPermissions"
+];
+function normalizeInitRuntime(runtime) {
+  if (runtime === "codex") {
+    return "codex-app-server";
+  }
+  if (runtime === "claude-code") {
+    return "claude-print";
+  }
+  return runtime;
+}
+function isSupportedInitRuntime(runtime) {
+  const normalized = normalizeInitRuntime(runtime);
+  return normalized === "codex-app-server" || normalized === "claude-print";
+}
+function containsRuntimeToken(runtime, tokens) {
+  return tokens.some((token) => {
+    const escaped = token.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return new RegExp(`(^|[\\s"'\\\`])${escaped}(?=$|[\\s"'\\\`])`).test(
+      runtime
+    );
+  });
+}
+function isCodexRuntime(runtime) {
+  return normalizeInitRuntime(runtime) === "codex-app-server" || containsRuntimeToken(runtime, CODEX_RUNTIME_TOKENS);
+}
+function isClaudeRuntime(runtime) {
+  return normalizeInitRuntime(runtime) === "claude-print" || containsRuntimeToken(runtime, CLAUDE_RUNTIME_TOKENS);
+}
+function resolveRuntimeCommand(runtime) {
+  const normalized = normalizeInitRuntime(runtime);
+  if (normalized === "codex-app-server") {
+    return "codex";
+  }
+  if (normalized === "claude-print") {
+    return "claude";
+  }
+  return runtime;
+}
+function resolveRuntimeArgs(runtime) {
+  const normalized = normalizeInitRuntime(runtime);
+  if (normalized === "codex-app-server") {
+    return DEFAULT_CODEX_APP_SERVER_ARGS;
+  }
+  if (normalized === "claude-print") {
+    return DEFAULT_CLAUDE_PRINT_ARGS;
+  }
+  return [];
+}
+function resolveRuntimeAgentCommand(runtime) {
+  const command = resolveRuntimeCommand(runtime);
+  const args = resolveRuntimeArgs(runtime);
+  return args.length === 0 ? command : [command, ...args].join(" ");
+}
+function resolveShellAgentCommand(runtime) {
+  if (/^\s*bash\s+-lc\s+/.test(runtime)) {
+    return runtime;
+  }
+  const normalized = normalizeInitRuntime(runtime);
+  if (normalized === "codex-app-server" || normalized === "claude-print") {
+    return `bash -lc ${resolveRuntimeAgentCommand(normalized)}`;
+  }
+  return runtime;
+}
+function buildRuntimeFrontMatter(runtime) {
+  const normalized = normalizeInitRuntime(runtime);
+  if (normalized === "codex-app-server") {
+    return [
+      "runtime:",
+      "  kind: codex-app-server",
+      "  command: codex",
+      "  args:",
+      "    - app-server",
+      "  isolation:",
+      "    bare: false",
+      "    strict_mcp_config: false",
+      "  timeouts:",
+      "    read_timeout_ms: 5000",
+      "    turn_timeout_ms: 3600000",
+      "    stall_timeout_ms: 300000"
+    ];
+  }
+  if (normalized === "claude-print") {
+    return [
+      "runtime:",
+      "  kind: claude-print",
+      "  command: claude",
+      "  args:",
+      ...DEFAULT_CLAUDE_PRINT_ARGS.map((arg) => `    - ${arg}`),
+      "  isolation:",
+      "    bare: false",
+      "    strict_mcp_config: false",
+      "  auth:",
+      "    env: ANTHROPIC_API_KEY",
+      "  timeouts:",
+      "    read_timeout_ms: 5000",
+      "    turn_timeout_ms: 3600000",
+      "    stall_timeout_ms: 900000"
+    ];
+  }
+  return [
+    "runtime:",
+    "  kind: custom",
+    `  command: ${runtime}`,
+    "  isolation:",
+    "    bare: false",
+    "    strict_mcp_config: false",
+    "  timeouts:",
+    "    read_timeout_ms: 5000",
+    "    turn_timeout_ms: 3600000",
+    "    stall_timeout_ms: 300000"
+  ];
+}
+
 // src/workflow/generate-workflow-md.ts
 function generateWorkflowMarkdown(input) {
   const frontMatter = buildFrontMatter(input);
-  const promptBody = buildPromptBody(input.mappings);
+  const promptBody = buildPromptBody(input);
   return `---
 ${frontMatter}---
 ${promptBody}
@@ -114,6 +354,9 @@ function buildFrontMatter(input) {
   lines.push("  kind: github-project");
   lines.push(`  project_id: ${input.projectId}`);
   lines.push(`  state_field: ${input.stateFieldName}`);
+  if (input.priorityFieldName) {
+    lines.push(`  priority_field: ${input.priorityFieldName}`);
+  }
   if (input.lifecycle.activeStates.length > 0) {
     lines.push("  active_states:");
     for (const state of input.lifecycle.activeStates) {
@@ -132,36 +375,26 @@ function buildFrontMatter(input) {
       lines.push(`    - ${state}`);
     }
   }
-  const agentCommand = resolveAgentCommand(input.runtime);
   lines.push("polling:");
   lines.push(`  interval_ms: ${input.pollIntervalMs ?? 3e4}`);
   lines.push("workspace:");
   lines.push("  root: .runtime/symphony-workspaces");
   lines.push("hooks:");
-  lines.push("  after_create: hooks/after_create.sh");
+  lines.push(`  after_create: ${DEFAULT_AFTER_CREATE_HOOK_PATH}`);
   lines.push("agent:");
   lines.push("  max_concurrent_agents: 10");
   lines.push("  max_retry_backoff_ms: 30000");
   lines.push("  retry_base_delay_ms: 10000");
-  lines.push("codex:");
-  lines.push(`  command: ${agentCommand}`);
-  lines.push("  read_timeout_ms: 5000");
-  lines.push("  turn_timeout_ms: 3600000");
+  lines.push(...buildRuntimeFrontMatter(input.runtime));
   return lines.join("\n") + "\n";
 }
-function resolveAgentCommand(runtime) {
-  switch (runtime) {
-    case "codex":
-      return "codex app-server";
-    case "claude-code":
-      return "claude-code";
-    default:
-      return runtime;
-  }
-}
-function buildPromptBody(mappings) {
-  const statusMap = generateStatusMapWithDescriptions(mappings);
-  const template = `${statusMap}
+function buildPromptBody(input) {
+  const statusMap = generateStatusMapWithDescriptions(input.mappings);
+  const validationGuidance = buildRepositoryValidationGuidance(
+    input.detectedEnvironment
+  );
+  const runtimePreamble = buildRuntimePromptPreamble(input.runtime);
+  const templateBody = `${statusMap}
 
 ## Agent Instructions
 
@@ -180,6 +413,10 @@ You are an AI coding agent working on issue {{issue.identifier}}: "{{issue.title
 2. Only abort early if there is a genuine blocker (missing required credentials or secrets).
 3. In your final message, report only what was completed and any blockers. Do not include "next steps".
 
+### Repository Validation Guidance
+
+${validationGuidance.map((line, index) => `${index + 1}. ${line}`).join("\n")}
+
 ### Workflow
 
 1. Read the issue description and understand the requirements.
@@ -218,7 +455,10 @@ Create a workpad comment on the issue with the following structure to track prog
 
 - Progress notes
 \`\`\``;
-  return template;
+  return [runtimePreamble, templateBody].filter(Boolean).join("\n\n");
+}
+function buildRuntimePromptPreamble(runtime) {
+  return isClaudeRuntime(runtime) ? CLAUDE_RUNTIME_PROMPT_PREAMBLE : "";
 }
 function generateStatusMapWithDescriptions(mappings) {
   const roleDescriptions = {
@@ -237,7 +477,7 @@ function generateStatusMapWithDescriptions(mappings) {
 }
 
 // src/detection/environment-detector.ts
-import { access, readFile } from "fs/promises";
+import { access, readFile, readdir } from "fs/promises";
 import { join } from "path";
 function isFileMissing(error) {
   return Boolean(
@@ -269,13 +509,25 @@ async function readJsonFile(path) {
     throw error;
   }
 }
+async function readTextFile(path) {
+  try {
+    return await readFile(path, "utf8");
+  } catch (error) {
+    if (isFileMissing(error)) {
+      return null;
+    }
+    throw error;
+  }
+}
 async function detectPackageManager(cwd) {
   const lockfiles = [
     { name: "pnpm-lock.yaml", manager: "pnpm" },
     { name: "bun.lock", manager: "bun" },
     { name: "bun.lockb", manager: "bun" },
     { name: "yarn.lock", manager: "yarn" },
-    { name: "package-lock.json", manager: "npm" }
+    { name: "package-lock.json", manager: "npm" },
+    { name: "uv.lock", manager: "uv" },
+    { name: "poetry.lock", manager: "poetry" }
   ];
   for (const { name, manager } of lockfiles) {
     const exists = await fileExists(join(cwd, name));
@@ -285,7 +537,32 @@ async function detectPackageManager(cwd) {
   }
   return { packageManager: null, lockfile: null };
 }
-async function detectScripts(cwd) {
+function normalizeCommand2(command) {
+  return command.replace(/\s+/g, " ").trim();
+}
+function addCandidate(candidates, label, command, priority) {
+  if (!command) {
+    return;
+  }
+  candidates[label].push({
+    command: normalizeCommand2(command),
+    priority
+  });
+}
+function resolveCommand(candidates, label) {
+  const entries = candidates[label];
+  if (entries.length === 0) {
+    return null;
+  }
+  const highestPriority = Math.max(...entries.map((entry) => entry.priority));
+  const highestPriorityCommands = [
+    ...new Set(
+      entries.filter((entry) => entry.priority === highestPriority).map((entry) => entry.command)
+    )
+  ];
+  return highestPriorityCommands.length === 1 ? highestPriorityCommands[0] : null;
+}
+async function detectNodeScripts(cwd) {
   const packageJson = await readJsonFile(join(cwd, "package.json"));
   if (!packageJson?.scripts) {
     return { testCommand: null, buildCommand: null, lintCommand: null };
@@ -296,6 +573,117 @@ async function detectScripts(cwd) {
     lintCommand: packageJson.scripts.lint ?? null
   };
 }
+async function detectMakeCommands(cwd) {
+  const makefile = await readTextFile(join(cwd, "Makefile")) ?? await readTextFile(join(cwd, "makefile"));
+  if (!makefile) {
+    return { testCommand: null, buildCommand: null, lintCommand: null };
+  }
+  const hasTarget = (target) => new RegExp(`^${target}\\s*::?(?:\\s|$)`, "m").test(makefile);
+  return {
+    testCommand: hasTarget("test") ? "make test" : null,
+    lintCommand: hasTarget("lint") ? "make lint" : null,
+    buildCommand: hasTarget("build") ? "make build" : null
+  };
+}
+async function detectJustCommands(cwd) {
+  const justfile = await readTextFile(join(cwd, "justfile")) ?? await readTextFile(join(cwd, ".justfile"));
+  if (!justfile) {
+    return { testCommand: null, buildCommand: null, lintCommand: null };
+  }
+  const hasRecipe = (name) => new RegExp(`^${name}\\s*:(?!=)`, "m").test(justfile);
+  return {
+    testCommand: hasRecipe("test") ? "just test" : null,
+    lintCommand: hasRecipe("lint") ? "just lint" : null,
+    buildCommand: hasRecipe("build") ? "just build" : null
+  };
+}
+async function hasRequirementsFile(cwd) {
+  try {
+    const entries = await readdir(cwd);
+    return entries.some((entry) => /^requirements[^/]*\.txt$/i.test(entry));
+  } catch (error) {
+    if (isFileMissing(error)) {
+      return false;
+    }
+    throw error;
+  }
+}
+async function detectPythonCommands(cwd) {
+  const [
+    pyproject,
+    hasUvLock,
+    hasPoetryLock,
+    hasPytestIni,
+    hasToxIni,
+    hasRequirements
+  ] = await Promise.all([
+    readTextFile(join(cwd, "pyproject.toml")),
+    fileExists(join(cwd, "uv.lock")),
+    fileExists(join(cwd, "poetry.lock")),
+    fileExists(join(cwd, "pytest.ini")),
+    fileExists(join(cwd, "tox.ini")),
+    hasRequirementsFile(cwd)
+  ]);
+  const hasPythonSignals = pyproject !== null || hasUvLock || hasPoetryLock || hasPytestIni || hasToxIni || hasRequirements;
+  if (!hasPythonSignals) {
+    return { testCommand: null, buildCommand: null, lintCommand: null };
+  }
+  const hasPytestConfig = hasPytestIni || /\[tool\.pytest(?:\.ini_options)?\]/.test(pyproject ?? "");
+  if (!hasPytestConfig) {
+    return { testCommand: null, buildCommand: null, lintCommand: null };
+  }
+  const testCommand = hasUvLock ? "uv run pytest" : hasPoetryLock ? "poetry run pytest" : "pytest";
+  return { testCommand, buildCommand: null, lintCommand: null };
+}
+async function detectGoCommands(cwd) {
+  const hasGoMod = await fileExists(join(cwd, "go.mod"));
+  return {
+    testCommand: hasGoMod ? "go test ./..." : null,
+    buildCommand: null,
+    lintCommand: null
+  };
+}
+async function detectRustCommands(cwd) {
+  const hasCargoToml = await fileExists(join(cwd, "Cargo.toml"));
+  return {
+    testCommand: hasCargoToml ? "cargo test" : null,
+    buildCommand: null,
+    lintCommand: null
+  };
+}
+async function detectValidationCommands(cwd) {
+  const [makeCommands, justCommands, nodeCommands, pythonCommands, goCommands, rustCommands] = await Promise.all([
+    detectMakeCommands(cwd),
+    detectJustCommands(cwd),
+    detectNodeScripts(cwd),
+    detectPythonCommands(cwd),
+    detectGoCommands(cwd),
+    detectRustCommands(cwd)
+  ]);
+  const candidates = {
+    testCommand: [],
+    lintCommand: [],
+    buildCommand: []
+  };
+  for (const commandSet of [makeCommands, justCommands]) {
+    addCandidate(candidates, "testCommand", commandSet.testCommand, 3);
+    addCandidate(candidates, "lintCommand", commandSet.lintCommand, 3);
+    addCandidate(candidates, "buildCommand", commandSet.buildCommand, 3);
+  }
+  addCandidate(candidates, "testCommand", nodeCommands.testCommand, 2);
+  addCandidate(candidates, "lintCommand", nodeCommands.lintCommand, 2);
+  addCandidate(candidates, "buildCommand", nodeCommands.buildCommand, 2);
+  for (const commandSet of [pythonCommands, goCommands, rustCommands]) {
+    addCandidate(candidates, "testCommand", commandSet.testCommand, 1);
+    addCandidate(candidates, "lintCommand", commandSet.lintCommand, 1);
+    addCandidate(candidates, "buildCommand", commandSet.buildCommand, 1);
+  }
+  return {
+    testCommand: resolveCommand(candidates, "testCommand"),
+    lintCommand: resolveCommand(candidates, "lintCommand"),
+    buildCommand: resolveCommand(candidates, "buildCommand")
+  };
+}
 async function detectCiPlatform(cwd) {
   const workflowsDir = join(cwd, ".github", "workflows");
   const exists = await fileExists(workflowsDir);
@@ -310,10 +698,18 @@ async function detectMonorepo(cwd) {
   if (hasLerna) {
     return true;
   }
+  const hasGoWorkspace = await fileExists(join(cwd, "go.work"));
+  if (hasGoWorkspace) {
+    return true;
+  }
   const packageJson = await readJsonFile(join(cwd, "package.json"));
   if (packageJson?.workspaces) {
     return true;
   }
+  const cargoToml = await readTextFile(join(cwd, "Cargo.toml"));
+  if (cargoToml?.includes("[workspace]")) {
+    return true;
+  }
   return false;
 }
 async function detectExistingSkills(cwd) {
@@ -357,7 +753,7 @@ async function detectEnvironment(cwd) {
     existingSkills
   ] = await Promise.all([
     detectPackageManager(cwd),
-    detectScripts(cwd),
+    detectValidationCommands(cwd),
     detectCiPlatform(cwd),
     detectMonorepo(cwd),
     detectExistingSkills(cwd)
@@ -528,6 +924,11 @@ function generateReferenceWorkflow(input) {
   lines.push("  kind: github-project");
   lines.push(`  project_id: ${input.projectId}`);
   lines.push("  state_field: Status");
+  if (input.priorityFieldName) {
+    lines.push(`  priority_field: ${input.priorityFieldName}`);
+  } else {
+    lines.push("  # priority_field: Priority");
+  }
   lines.push("");
   const activeColumns = input.statusColumns.filter((c) => c.role === "active");
   const waitColumns = input.statusColumns.filter((c) => c.role === "wait");
@@ -558,8 +959,6 @@ function generateReferenceWorkflow(input) {
     lines.push("  blocker_check_states: [{first active state}]");
   }
   lines.push("");
-  const agentCommand = resolveAgentCommand2(input.runtime);
-  const hookComment = resolveHookComment(input.runtime);
   lines.push("polling:");
   lines.push("  interval_ms: 30000");
   lines.push("");
@@ -567,7 +966,9 @@ function generateReferenceWorkflow(input) {
   lines.push("  root: .runtime/symphony-workspaces");
   lines.push("");
   lines.push("hooks:");
-  lines.push(`  after_create: hooks/after_create.sh  # ${hookComment}`);
+  lines.push(
+    `  after_create: ${DEFAULT_AFTER_CREATE_HOOK_PATH}  # ${DEFAULT_AFTER_CREATE_HOOK_COMMENT}`
+  );
   lines.push("  before_run: null");
   lines.push("  after_run: null");
   lines.push("  before_remove: null");
@@ -579,11 +980,7 @@ function generateReferenceWorkflow(input) {
   lines.push("  retry_base_delay_ms: 10000");
   lines.push("  max_turns: 20");
   lines.push("");
-  lines.push("codex:");
-  lines.push(`  command: ${agentCommand}`);
-  lines.push("  read_timeout_ms: 5000");
-  lines.push("  turn_timeout_ms: 3600000");
-  lines.push("  stall_timeout_ms: 300000");
+  lines.push(...buildRuntimeFrontMatter(input.runtime));
   lines.push("");
   lines.push("---");
   lines.push("");
@@ -611,6 +1008,14 @@ function generateReferenceWorkflow(input) {
     }
   }
   lines.push("");
+  lines.push("## Repository Validation Guidance");
+  lines.push("");
+  for (const line of buildRepositoryValidationGuidance(
+    input.detectedEnvironment
+  )) {
+    lines.push(`- ${line}`);
+  }
+  lines.push("");
   lines.push("## Default Posture");
   lines.push("");
   lines.push(
@@ -812,26 +1217,6 @@ function generateReferenceWorkflow(input) {
   lines.push("");
   return lines.join("\n");
 }
-function resolveAgentCommand2(runtime) {
-  switch (runtime) {
-    case "codex":
-      return "codex app-server";
-    case "claude-code":
-      return "claude-code";
-    default:
-      return runtime;
-  }
-}
-function resolveHookComment(runtime) {
-  switch (runtime) {
-    case "codex":
-      return "npm/yarn/pnpm install script";
-    case "claude-code":
-      return "npm/yarn/pnpm install script";
-    default:
-      return "package-manager-specific script";
-  }
-}
 function resolveRoleAction(role) {
   switch (role) {
     case "active":
@@ -849,10 +1234,10 @@ function resolveRoleAction(role) {
 import { mkdir as mkdir2, readFile as readFile2, rename, writeFile as writeFile2 } from "fs/promises";
 import { join as join2 } from "path";
 function normalizeRuntimeForSkills(runtime) {
-  if (runtime === "claude-code" || runtime.includes("claude-code")) {
+  if (isClaudeRuntime(runtime)) {
     return "claude-code";
   }
-  if (runtime === "codex" || runtime.includes("codex")) {
+  if (isCodexRuntime(runtime)) {
     return "codex";
   }
   return null;
@@ -921,6 +1306,17 @@ function generateGhSymphonySkill(ctx) {
   );
   lines.push("- `gh` CLI must be authenticated");
   lines.push("");
+  lines.push("## Repository Validation Guidance");
+  lines.push("");
+  lines.push(
+    "Carry the detected repository validation posture into any new or refined `WORKFLOW.md` instead of falling back to generic instructions."
+  );
+  for (const line of buildRepositoryValidationGuidance(
+    ctx.detectedEnvironment
+  )) {
+    lines.push(`- ${line}`);
+  }
+  lines.push("");
   lines.push("## Mode Detection");
   lines.push("");
   lines.push("Check if `WORKFLOW.md` exists in the current directory:");
@@ -1406,6 +1802,15 @@ Then re-run: ${retryCommand}`,
     "Fix missing scope"
   );
 }
+function warnIfProjectDiscoveryPartial(result) {
+  if (!result.partial) {
+    return;
+  }
+  const limitDetail = result.reason === "result_limit" ? "the discovered project count reached the safety cap" : "the GitHub API request budget reached the safety cap";
+  p.log.warn(
+    `Project discovery may be incomplete: ${limitDetail}. Showing ${result.projects.length} discovered project${result.projects.length === 1 ? "" : "s"} after ${result.requests} request${result.requests === 1 ? "" : "s"}.`
+  );
+}
 async function abortIfCancelled(input) {
   const result = await input;
   if (p.isCancel(result)) {
@@ -1418,6 +1823,7 @@ function parseInitFlags(args) {
   const flags = {
     dryRun: false,
     nonInteractive: false,
+    runtime: "codex",
     skipSkills: false,
     skipContext: false
   };
@@ -1439,6 +1845,10 @@ function parseInitFlags(args) {
         flags.output = next;
         i += 1;
         break;
+      case "--runtime":
+        flags.runtime = next ?? "";
+        i += 1;
+        break;
       case "--skip-skills":
         flags.skipSkills = true;
         break;
@@ -1449,6 +1859,25 @@ function parseInitFlags(args) {
   }
   return flags;
 }
+async function runInitRuntimePreflight(runtime) {
+  if (!isClaudeRuntime(runtime)) {
+    return true;
+  }
+  const hasGitHubGraphqlToken = typeof process.env.GITHUB_GRAPHQL_TOKEN === "string" && process.env.GITHUB_GRAPHQL_TOKEN.trim().length > 0;
+  const report = await runClaudePreflight({
+    cwd: process.cwd(),
+    env: process.env,
+    command: resolveClaudeCommandBinary(resolveRuntimeCommand(runtime)) ?? resolveRuntimeCommand(runtime),
+    includeGhAuth: !hasGitHubGraphqlToken
+  });
+  const message = formatClaudePreflightText(report);
+  if (report.ok) {
+    p.log.info(message);
+    return true;
+  }
+  p.log.error(message);
+  return false;
+}
 var handler = async (args, options) => {
   const flags = parseInitFlags(args);
   if (flags.nonInteractive) {
@@ -1458,6 +1887,71 @@ var handler = async (args, options) => {
   await runInteractive(flags, options);
 };
 var init_default = handler;
+function resolveInitRuntime(runtime) {
+  return normalizeInitRuntime(runtime ?? "codex-app-server");
+}
+function validateInitRuntime(runtime) {
+  if (isSupportedInitRuntime(runtime)) {
+    return null;
+  }
+  return `Unsupported runtime '${runtime}'. Choose one of: codex-app-server, claude-print.`;
+}
+async function promptRuntimeSelection() {
+  return abortIfCancelled(
+    p.select({
+      message: "Step 1/3 \u2014 Select the agent runtime:",
+      options: [
+        {
+          value: "codex-app-server",
+          label: "codex-app-server",
+          hint: "Codex app-server JSON-RPC runtime"
+        },
+        {
+          value: "claude-print",
+          label: "claude-print",
+          hint: "Claude Code non-interactive stream-json runtime"
+        }
+      ]
+    })
+  );
+}
+function commandRuns(binary, args) {
+  const result = spawnSync(binary, args, {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: 3e3
+  });
+  return result.error === void 0 && result.status === 0;
+}
+function runRuntimePreflight(runtime) {
+  const command = resolveRuntimeCommand(runtime);
+  const checks = [];
+  const versionOk = commandRuns(command, ["--version"]);
+  checks.push({
+    label: "Runtime binary",
+    ok: versionOk,
+    detail: versionOk ? `${command} is available on PATH.` : `${command} was not found or did not run with --version.`
+  });
+  if (isClaudeRuntime(runtime)) {
+    const hasAnthropicKey = Boolean(process.env.ANTHROPIC_API_KEY);
+    checks.push({
+      label: "Claude auth",
+      ok: hasAnthropicKey,
+      detail: hasAnthropicKey ? "ANTHROPIC_API_KEY is set." : "ANTHROPIC_API_KEY is not set. Set it before running Claude workers."
+    });
+  }
+  const okIcon = "OK";
+  const failIcon = "FAIL";
+  const lines = checks.map(
+    (check) => `${check.ok ? okIcon : failIcon} ${check.label.padEnd(16)} ${check.detail}`
+  );
+  p.note(lines.join("\n"), `Runtime preflight \u2014 ${runtime}`);
+  if (checks.some((check) => !check.ok)) {
+    p.log.warn(
+      "Runtime preflight found missing local prerequisites. Generated files still include the selected runtime defaults."
+    );
+  }
+}
 async function resolveChangeStatus(path, content, mode) {
   try {
     const existing = await readFile3(path, "utf8");
@@ -1487,6 +1981,9 @@ async function writePlannedFile(file) {
   const temporaryPath = `${file.path}.tmp`;
   await writeFile3(temporaryPath, file.content, "utf8");
   await rename2(temporaryPath, file.path);
+  if (file.executable) {
+    await chmod(file.path, 493);
+  }
   return true;
 }
 function resolveStatusField(projectDetail) {
@@ -1494,13 +1991,68 @@ function resolveStatusField(projectDetail) {
 }
 function buildAutomaticStateMappings(statusField) {
   const mappings = {};
-  for (const mapping of inferAllStateRoles(statusField.options.map((o) => o.name))) {
+  for (const mapping of inferAllStateRoles(
+    statusField.options.map((o) => o.name)
+  )) {
     if (mapping.role) {
       mappings[mapping.columnName] = { role: mapping.role };
     }
   }
   return mappings;
 }
+function isPriorityFieldCandidateName(fieldName) {
+  return /\bpriority\b/i.test(fieldName.trim());
+}
+function resolvePriorityField(projectDetail, statusField) {
+  const singleSelectFields = projectDetail.statusFields.filter(
+    (field) => field.id !== statusField.id
+  );
+  const exactMatches = singleSelectFields.filter(
+    (field) => field.name.trim().toLowerCase() === "priority"
+  );
+  if (exactMatches.length === 1) {
+    return { field: exactMatches[0], ambiguous: [] };
+  }
+  if (exactMatches.length > 1) {
+    return { field: null, ambiguous: exactMatches };
+  }
+  const likelyMatches = singleSelectFields.filter(
+    (field) => isPriorityFieldCandidateName(field.name)
+  );
+  if (likelyMatches.length === 1) {
+    return { field: likelyMatches[0], ambiguous: [] };
+  }
+  if (likelyMatches.length > 1) {
+    return { field: null, ambiguous: likelyMatches };
+  }
+  return { field: null, ambiguous: [] };
+}
+async function promptPriorityField(priorityCandidates, options) {
+  if (priorityCandidates.length === 0) {
+    return null;
+  }
+  const selectedFieldId = await abortIfCancelled(
+    p.select({
+      message: `${options?.stepLabel ?? "Priority field"} \u2014 Multiple GitHub Project priority fields look plausible. Select the one Symphony should use:`,
+      options: [
+        ...priorityCandidates.map((field) => ({
+          value: field.id,
+          label: field.name,
+          hint: `${field.options.length} option${field.options.length === 1 ? "" : "s"}`
+        })),
+        {
+          value: "__skip_priority_field__",
+          label: "Skip priority-aware dispatch",
+          hint: "Leave tracker.priority_field unset"
+        }
+      ]
+    })
+  );
+  if (selectedFieldId === "__skip_priority_field__") {
+    return null;
+  }
+  return priorityCandidates.find((field) => field.id === selectedFieldId) ?? null;
+}
 async function promptStateMappings(statusField, options) {
   const mappings = {};
   const inferred = inferAllStateRoles(statusField.options.map((o) => o.name));
@@ -1529,12 +2081,15 @@ async function promptStateMappings(statusField, options) {
   return mappings;
 }
 async function planWorkflowArtifacts(opts) {
+  const environment = opts.environment ?? await detectEnvironment(opts.cwd);
   const workflowMd = generateWorkflowMarkdown({
     projectId: opts.projectDetail.id,
     stateFieldName: opts.statusField.name,
+    priorityFieldName: opts.priorityField?.name ?? null,
     mappings: opts.mappings,
     lifecycle: toWorkflowLifecycleConfig(opts.statusField.name, opts.mappings),
-    runtime: opts.runtime
+    runtime: opts.runtime,
+    detectedEnvironment: environment
   });
   const workflowPlan = await planFileChange({
     path: opts.outputPath,
@@ -1546,9 +2101,11 @@ async function planWorkflowArtifacts(opts) {
     cwd: opts.cwd,
     projectDetail: opts.projectDetail,
     statusField: opts.statusField,
+    priorityField: opts.priorityField,
     runtime: opts.runtime,
     skipSkills: opts.skipSkills,
-    skipContext: opts.skipContext
+    skipContext: opts.skipContext,
+    environment
   });
   return {
     outputPath: opts.outputPath,
@@ -1570,10 +2127,27 @@ function summarizeEnvironment(env) {
   ];
 }
 async function planEcosystem(opts) {
-  const { cwd, projectDetail, statusField, runtime, skipSkills, skipContext } = opts;
+  const {
+    cwd,
+    projectDetail,
+    statusField,
+    priorityField,
+    runtime,
+    skipSkills,
+    skipContext
+  } = opts;
   const ghSymphonyDir = join3(cwd, ".gh-symphony");
-  const environment = await detectEnvironment(cwd);
+  const environment = opts.environment ?? await detectEnvironment(cwd);
   const files = [];
+  files.push(
+    await planFileChange({
+      path: join3(cwd, DEFAULT_AFTER_CREATE_HOOK_PATH),
+      label: DEFAULT_AFTER_CREATE_HOOK_LABEL,
+      content: DEFAULT_AFTER_CREATE_HOOK_CONTENT,
+      mode: "create-only",
+      executable: true
+    })
+  );
   if (!skipContext) {
     const contextYaml = buildContextYaml({
       projectDetail,
@@ -1581,7 +2155,7 @@ async function planEcosystem(opts) {
       detectedEnvironment: environment,
       runtime: {
         agent: runtime,
-        agent_command: runtime === "codex" ? "bash -lc codex app-server" : runtime === "claude-code" ? "bash -lc claude-code" : runtime
+        agent_command: resolveShellAgentCommand(runtime)
       }
     });
     files.push(
@@ -1599,7 +2173,9 @@ async function planEcosystem(opts) {
       name: o.name,
       role: null
     })),
-    projectId: projectDetail.id
+    projectId: projectDetail.id,
+    priorityFieldName: priorityField?.name ?? null,
+    detectedEnvironment: environment
   });
   files.push(
     await planFileChange({
@@ -1630,7 +2206,8 @@ async function planEcosystem(opts) {
         })),
         statusFieldId: statusField.id,
         contextYamlPath: ".gh-symphony/context.yaml",
-        referenceWorkflowPath: ".gh-symphony/reference-workflow.md"
+        referenceWorkflowPath: ".gh-symphony/reference-workflow.md",
+        detectedEnvironment: environment
       }
     );
     for (const plannedSkill of plannedSkills) {
@@ -1648,7 +2225,9 @@ async function planEcosystem(opts) {
     projectId: projectDetail.id,
     githubProjectTitle: projectDetail.title,
     runtime,
+    priorityFieldName: priorityField?.name ?? null,
     skillsDir,
+    skipSkills,
     environment,
     files
   };
@@ -1656,18 +2235,24 @@ async function planEcosystem(opts) {
 async function writeEcosystem(opts) {
   const plan = await planEcosystem(opts);
   await mkdir3(join3(opts.cwd, ".gh-symphony"), { recursive: true });
+  const afterCreateHookPath = join3(opts.cwd, DEFAULT_AFTER_CREATE_HOOK_PATH);
   const contextYamlPath = join3(opts.cwd, ".gh-symphony", "context.yaml");
   const referenceWorkflowPath = join3(
     opts.cwd,
     ".gh-symphony",
     "reference-workflow.md"
   );
+  let afterCreateHookWritten = false;
   let contextYamlWritten = false;
   let referenceWorkflowWritten = false;
   const skillsWritten = [];
   const skillsSkipped = [];
   for (const file of plan.files) {
     const written = await writePlannedFile(file);
+    if (file.path === afterCreateHookPath) {
+      afterCreateHookWritten = written;
+      continue;
+    }
     if (file.path === contextYamlPath) {
       contextYamlWritten = written;
       continue;
@@ -1689,7 +2274,10 @@ async function writeEcosystem(opts) {
     projectId: plan.projectId,
     githubProjectTitle: plan.githubProjectTitle,
     runtime: plan.runtime,
+    priorityFieldName: plan.priorityFieldName,
     skillsDir: plan.skillsDir,
+    skipSkills: plan.skipSkills,
+    afterCreateHookWritten,
     contextYamlWritten,
     referenceWorkflowWritten,
     skillsWritten: skillsWritten.sort(),
@@ -1700,11 +2288,21 @@ function printEcosystemSummary(result, workflowPath, opts) {
   const cwd = process.cwd();
   const relWorkflow = relative(cwd, workflowPath) || "WORKFLOW.md";
   const lines = [];
-  lines.push(`GitHub Project   ${result.githubProjectTitle}  (${result.projectId})`);
+  lines.push(
+    `GitHub Project   ${result.githubProjectTitle}  (${result.projectId})`
+  );
   lines.push(`Runtime   ${result.runtime}`);
+  if (result.priorityFieldName) {
+    lines.push(`Priority field   ${result.priorityFieldName}`);
+  }
   lines.push("");
   lines.push("Generated files");
   lines.push(`  \u2713 WORKFLOW.md                          ${relWorkflow}`);
+  if (result.afterCreateHookWritten) {
+    lines.push(
+      `  \u2713 ${DEFAULT_AFTER_CREATE_HOOK_LABEL.padEnd(36)} ${DEFAULT_AFTER_CREATE_HOOK_PATH}`
+    );
+  }
   if (result.contextYamlWritten) {
     lines.push(
       "  \u2713 Context metadata                     .gh-symphony/context.yaml"
@@ -1725,7 +2323,7 @@ function printEcosystemSummary(result, workflowPath, opts) {
     for (const name of result.skillsSkipped) {
       lines.push(`  \u2013 ${name}  (already exists, skipped)`);
     }
-  } else if (result.runtime !== "codex" && result.runtime !== "claude-code") {
+  } else if (!result.skipSkills) {
     lines.push("");
     lines.push("Skills  \u2192  (skipped \u2014 custom runtime)");
   }
@@ -1750,6 +2348,9 @@ function renderDryRunPreview(workflowPath, workflowPlan, ecosystemPlan) {
     `GitHub Project   ${ecosystemPlan.githubProjectTitle}  (${ecosystemPlan.projectId})`
   );
   lines.push(`Runtime   ${ecosystemPlan.runtime}`);
+  if (ecosystemPlan.priorityFieldName) {
+    lines.push(`Priority field   ${ecosystemPlan.priorityFieldName}`);
+  }
   lines.push("");
   lines.push("Planned file changes");
   lines.push(
@@ -1777,6 +2378,7 @@ function buildDryRunJsonResult(workflowPath, workflowPlan, ecosystemPlan) {
     projectId: ecosystemPlan.projectId,
     githubProjectTitle: ecosystemPlan.githubProjectTitle,
     runtime: ecosystemPlan.runtime,
+    priorityFieldName: ecosystemPlan.priorityFieldName,
     files: [workflowPlan, ...ecosystemPlan.files].map((file) => ({
       path: file.path,
       label: file.label,
@@ -1792,6 +2394,18 @@ function printDryRunPreview(workflowPath, workflowPlan, ecosystemPlan) {
   );
 }
 async function runNonInteractive(flags, options) {
+  const runtime = resolveInitRuntime(flags.runtime);
+  const runtimeError = validateInitRuntime(runtime);
+  if (runtimeError) {
+    process.stderr.write(`Error: ${runtimeError}
+`);
+    process.exitCode = 1;
+    return;
+  }
+  if (!await runInitRuntimePreflight(runtime)) {
+    process.exitCode = 1;
+    return;
+  }
   let token;
   try {
     token = getGhTokenWithSource().token;
@@ -1849,6 +2463,13 @@ async function runNonInteractive(flags, options) {
     return;
   }
   const mappings = buildAutomaticStateMappings(statusField);
+  const { field: autoPriorityField, ambiguous: ambiguousPriorityFields } = resolvePriorityField(githubProject, statusField);
+  if (ambiguousPriorityFields.length > 0) {
+    process.stderr.write(
+      `Warning: Multiple priority-like single-select fields found (${ambiguousPriorityFields.map((field) => `"${field.name}"`).join(", ")}). Skipping tracker.priority_field in non-interactive mode.
+`
+    );
+  }
   const validation = validateStateMapping(mappings);
   if (!validation.valid) {
     process.stderr.write(
@@ -1865,8 +2486,9 @@ Run without --non-interactive for manual mapping.
     outputPath,
     projectDetail: githubProject,
     statusField,
+    priorityField: autoPriorityField,
     mappings,
-    runtime: "codex",
+    runtime,
     skipSkills: flags.skipSkills,
     skipContext: flags.skipContext
   });
@@ -1887,7 +2509,8 @@ Run without --non-interactive for manual mapping.
     cwd: process.cwd(),
     projectDetail: githubProject,
     statusField,
-    runtime: "codex",
+    priorityField: autoPriorityField,
+    runtime,
     skipSkills: flags.skipSkills,
     skipContext: flags.skipContext
   });
@@ -1907,6 +2530,15 @@ async function runInteractive(flags, options) {
   await runInteractiveStandalone(flags, options);
 }
 async function runInteractiveStandalone(flags, _options) {
+  const runtime = await promptRuntimeSelection();
+  if (isClaudeRuntime(runtime)) {
+    if (!await runInitRuntimePreflight(runtime)) {
+      process.exitCode = 1;
+      return;
+    }
+  } else {
+    runRuntimePreflight(runtime);
+  }
   const s1 = p.spinner();
   s1.start("Checking GitHub authentication...");
   let client;
@@ -1929,10 +2561,12 @@ async function runInteractiveStandalone(flags, _options) {
   s2.start("Loading projects...");
   let projects;
   try {
-    projects = await listUserProjects(client);
+    const discovery = await discoverUserProjects(client);
+    projects = discovery.projects;
     s2.stop(
       `Found ${projects.length} project${projects.length === 1 ? "" : "s"}`
     );
+    warnIfProjectDiscoveryPartial(discovery);
   } catch (error) {
     s2.stop("Failed to load projects.");
     if (error instanceof GitHubScopeError) {
@@ -1952,7 +2586,7 @@ async function runInteractiveStandalone(flags, _options) {
   }
   const selectedGithubProjectId = await abortIfCancelled(
     p.select({
-      message: "Step 1/2 \u2014 Select a GitHub Project board:",
+      message: "Step 2/3 \u2014 Select a GitHub Project board:",
       options: projects.map((proj) => ({
         value: proj.id,
         label: `${proj.owner.login}/${proj.title}`,
@@ -1981,7 +2615,16 @@ async function runInteractiveStandalone(flags, _options) {
     process.exitCode = 1;
     return;
   }
-  const mappings = await promptStateMappings(statusField);
+  const priorityResolution = resolvePriorityField(projectDetail, statusField);
+  const mappings = await promptStateMappings(statusField, {
+    stepLabel: priorityResolution.ambiguous.length > 0 ? "Step 3/4" : "Step 3/3"
+  });
+  let priorityField = priorityResolution.field;
+  if (priorityResolution.ambiguous.length > 0) {
+    priorityField = await promptPriorityField(priorityResolution.ambiguous, {
+      stepLabel: "Step 4/4"
+    });
+  }
   const validation = validateStateMapping(mappings);
   if (!validation.valid) {
     p.log.error("Mapping validation failed:");
@@ -2000,8 +2643,9 @@ async function runInteractiveStandalone(flags, _options) {
     outputPath,
     projectDetail,
     statusField,
+    priorityField,
     mappings,
-    runtime: "codex",
+    runtime,
     skipSkills: flags.skipSkills,
     skipContext: flags.skipContext
   });
@@ -2014,7 +2658,8 @@ async function runInteractiveStandalone(flags, _options) {
     cwd: process.cwd(),
     projectDetail,
     statusField,
-    runtime: "codex",
+    priorityField,
+    runtime,
     skipSkills: flags.skipSkills,
     skipContext: flags.skipContext
   });
@@ -2061,10 +2706,12 @@ function generateProjectId(githubProjectTitle, uniqueKey) {
 
 export {
   validateStateMapping,
+  warnIfProjectDiscoveryPartial,
   abortIfCancelled,
   init_default,
   resolveStatusField,
   buildAutomaticStateMappings,
+  resolvePriorityField,
   promptStateMappings,
   planWorkflowArtifacts,
   writeWorkflowPlan,