@camilyos/codex-antigravity-kit 0.1.0

package/dist/chunk-URIBUKLX.js

@@ -0,0 +1,1747 @@
+// src/core/agent-router.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+var KNOWN_AGENTS = {
+  "web-engineer": {
+    id: "web-engineer",
+    name: "Web Engineer",
+    agentFile: "web-engineer.md",
+    skillFile: "web-engineering.md",
+    description: "Modern web fullstack architecture, frontend, APIs, CSS, and performance",
+    keywords: [
+      "web",
+      "frontend",
+      "backend",
+      "html",
+      "css",
+      "react",
+      "next.js",
+      "nextjs",
+      "vue",
+      "svelte",
+      "angular",
+      "rest api",
+      "graphql",
+      "websocket",
+      "http",
+      "endpoint",
+      "tailwind",
+      "responsive",
+      "core web vitals",
+      "lcp",
+      "inp",
+      "browser",
+      "dom"
+    ],
+    repoIndicators: [
+      "next.config.js",
+      "next.config.mjs",
+      "next.config.ts",
+      "vite.config.ts",
+      "vite.config.js",
+      "svelte.config.js",
+      "angular.json",
+      "tsconfig.json"
+    ]
+  },
+  "mobile-engineer": {
+    id: "mobile-engineer",
+    name: "Mobile Engineer",
+    agentFile: "mobile-engineer.md",
+    skillFile: "mobile-engineering.md",
+    description: "Mobile applications across Native (iOS/Android) and Cross-Platform (Flutter, React Native)",
+    keywords: [
+      "mobile",
+      "ios",
+      "android",
+      "flutter",
+      "dart",
+      "react native",
+      "react-native",
+      "expo",
+      "swift",
+      "swiftui",
+      "uikit",
+      "kotlin",
+      "jetpack compose",
+      "apk",
+      "ipa",
+      "push notification",
+      "biometrics",
+      "app store",
+      "play store",
+      "offline-first",
+      "sqlite"
+    ],
+    repoIndicators: [
+      "pubspec.yaml",
+      "Podfile",
+      "android/build.gradle",
+      "ios/Podfile",
+      "build.gradle",
+      "build.gradle.kts"
+    ]
+  },
+  "game-engineer": {
+    id: "game-engineer",
+    name: "Game Engineer",
+    agentFile: "game-engineer.md",
+    skillFile: "game-engineering.md",
+    description: "Game architecture and mechanics across Unity, Godot, and Cocos Creator",
+    keywords: [
+      "game",
+      "gameplay",
+      "game loop",
+      "unity",
+      "godot",
+      "cocos",
+      "cocos creator",
+      "physics",
+      "rigidbody",
+      "collider",
+      "collision",
+      "sprite",
+      "tilemap",
+      "prefab",
+      "shader",
+      "draw call",
+      "fps",
+      "ecs",
+      "fixedupdate",
+      "_physics_process",
+      "player controller"
+    ],
+    repoIndicators: [
+      "project.godot",
+      "ProjectSettings/ProjectVersion.txt",
+      "Assets",
+      "cocos.config.json",
+      "project.json"
+    ]
+  },
+  "researcher": {
+    id: "researcher",
+    name: "Technical Researcher",
+    agentFile: "researcher.md",
+    skillFile: "research.md",
+    description: "Deep technical research, feasibility studies, spikes, and architecture trade-offs",
+    keywords: [
+      "research",
+      "spike",
+      "feasibility",
+      "investigate",
+      "benchmark",
+      "comparison",
+      "trade-off",
+      "tradeoff",
+      "evaluate library",
+      "proof of concept",
+      "poc",
+      "state-of-the-art",
+      "options analysis",
+      "architectural evaluation"
+    ],
+    repoIndicators: []
+  },
+  "business-analyst": {
+    id: "business-analyst",
+    name: "Business Analyst",
+    agentFile: "business-analyst.md",
+    skillFile: "requirements-analysis.md",
+    description: "Requirements elicitation, user stories, domain modeling, and Gherkin acceptance criteria",
+    keywords: [
+      "requirements",
+      "requirement",
+      "user story",
+      "user stories",
+      "acceptance criteria",
+      "given ",
+      "when ",
+      "then ",
+      "persona",
+      "personas",
+      "business logic",
+      "prd",
+      "functional requirement",
+      "non-functional",
+      "workflow diagram",
+      "user journey"
+    ],
+    repoIndicators: []
+  },
+  "codex": {
+    id: "codex",
+    name: "Codex Lead",
+    agentFile: "codex.md",
+    skillFile: "codex-workflow.md",
+    description: "General technical lead, architect, and orchestrator",
+    keywords: ["orchestration", "workflow", "general", "architecture"],
+    repoIndicators: []
+  }
+};
+function detectAgent(options) {
+  const { root, content = "", explicitAgent } = options;
+  if (explicitAgent && explicitAgent.trim().length > 0) {
+    const normalized = explicitAgent.trim().toLowerCase();
+    const match = KNOWN_AGENTS[normalized];
+    if (!match) {
+      const valid = Object.keys(KNOWN_AGENTS).join(", ");
+      throw new Error(`Unknown agent: "${explicitAgent}". Available agents: ${valid}`);
+    }
+    return {
+      agent: match,
+      isExplicit: true,
+      confidence: 1,
+      reason: `Explicitly requested via --agent ${match.id}`,
+      instructions: loadAgentInstructions(root, match.agentFile),
+      skillInstructions: loadSkillInstructions(root, match.skillFile)
+    };
+  }
+  const normalizedText = ` ${content.toLowerCase()} `;
+  const candidateScores = {
+    "game-engineer": { score: 0, reasons: [] },
+    "mobile-engineer": { score: 0, reasons: [] },
+    "web-engineer": { score: 0, reasons: [] },
+    "researcher": { score: 0, reasons: [] },
+    "business-analyst": { score: 0, reasons: [] }
+  };
+  for (const [id, candidate] of Object.entries(candidateScores)) {
+    const def = KNOWN_AGENTS[id];
+    if (!def) continue;
+    for (const kw of def.keywords) {
+      if (normalizedText.includes(kw)) {
+        candidate.score += 2;
+        if (candidate.reasons.length < 3) {
+          candidate.reasons.push(`keyword "${kw}"`);
+        }
+      }
+    }
+  }
+  for (const [id, candidate] of Object.entries(candidateScores)) {
+    const def = KNOWN_AGENTS[id];
+    if (!def) continue;
+    for (const fileIndicator of def.repoIndicators) {
+      if (existsSync(join(root, fileIndicator))) {
+        candidate.score += 3;
+        if (candidate.reasons.length < 4) {
+          candidate.reasons.push(`repo file "${fileIndicator}"`);
+        }
+      }
+    }
+  }
+  const packageJsonPath = join(root, "package.json");
+  if (existsSync(packageJsonPath)) {
+    try {
+      const rawPkg = readFileSync(packageJsonPath, "utf8");
+      if (rawPkg.includes("react-native") || rawPkg.includes("expo")) {
+        candidateScores["mobile-engineer"].score += 3;
+        candidateScores["mobile-engineer"].reasons.push("package.json (react-native)");
+      } else if (rawPkg.includes("react") || rawPkg.includes("next") || rawPkg.includes("vue") || rawPkg.includes("svelte")) {
+        candidateScores["web-engineer"].score += 2;
+        candidateScores["web-engineer"].reasons.push("package.json (web framework)");
+      }
+    } catch {
+    }
+  }
+  let bestCandidateId = "codex";
+  let maxScore = 0;
+  let matchReasons = [];
+  for (const [id, data] of Object.entries(candidateScores)) {
+    if (data.score > maxScore) {
+      maxScore = data.score;
+      bestCandidateId = id;
+      matchReasons = data.reasons;
+    }
+  }
+  const selectedDef = KNOWN_AGENTS[bestCandidateId] ?? KNOWN_AGENTS["codex"];
+  const confidence = Math.min(1, maxScore / 6);
+  const reason = maxScore > 0 ? `Auto-detected based on ${matchReasons.join(", ")}` : "Defaulted to Codex General Lead (no specific domain signals found)";
+  return {
+    agent: selectedDef,
+    isExplicit: false,
+    confidence,
+    reason,
+    instructions: loadAgentInstructions(root, selectedDef.agentFile),
+    skillInstructions: loadSkillInstructions(root, selectedDef.skillFile)
+  };
+}
+function loadAgentInstructions(root, fileName) {
+  const customPath = join(root, ".codex", "agents", fileName);
+  if (existsSync(customPath)) {
+    return readFileSync(customPath, "utf8");
+  }
+  return "";
+}
+function loadSkillInstructions(root, fileName) {
+  const customPath = join(root, ".codex", "skills", fileName);
+  if (existsSync(customPath)) {
+    return readFileSync(customPath, "utf8");
+  }
+  return "";
+}
+
+// src/core/state-machine.ts
+var WorkflowState = /* @__PURE__ */ ((WorkflowState2) => {
+  WorkflowState2["IDLE"] = "IDLE";
+  WorkflowState2["DISCOVERY"] = "DISCOVERY";
+  WorkflowState2["CLARIFICATION_REQUIRED"] = "CLARIFICATION_REQUIRED";
+  WorkflowState2["BRAINSTORMING"] = "BRAINSTORMING";
+  WorkflowState2["PLANNING"] = "PLANNING";
+  WorkflowState2["READY"] = "READY";
+  WorkflowState2["IMPLEMENTING"] = "IMPLEMENTING";
+  WorkflowState2["VERIFYING"] = "VERIFYING";
+  WorkflowState2["REVIEWING"] = "REVIEWING";
+  WorkflowState2["REPAIR_REQUIRED"] = "REPAIR_REQUIRED";
+  WorkflowState2["COMPLETED"] = "COMPLETED";
+  WorkflowState2["BLOCKED"] = "BLOCKED";
+  WorkflowState2["ESCALATION_REQUIRED"] = "ESCALATION_REQUIRED";
+  return WorkflowState2;
+})(WorkflowState || {});
+var transitions = {
+  ["IDLE" /* IDLE */]: ["DISCOVERY" /* DISCOVERY */],
+  ["DISCOVERY" /* DISCOVERY */]: [
+    "CLARIFICATION_REQUIRED" /* CLARIFICATION_REQUIRED */,
+    "BRAINSTORMING" /* BRAINSTORMING */
+  ],
+  ["CLARIFICATION_REQUIRED" /* CLARIFICATION_REQUIRED */]: [
+    "BRAINSTORMING" /* BRAINSTORMING */,
+    "ESCALATION_REQUIRED" /* ESCALATION_REQUIRED */
+  ],
+  ["BRAINSTORMING" /* BRAINSTORMING */]: ["PLANNING" /* PLANNING */],
+  ["PLANNING" /* PLANNING */]: ["READY" /* READY */],
+  ["READY" /* READY */]: ["IMPLEMENTING" /* IMPLEMENTING */],
+  ["IMPLEMENTING" /* IMPLEMENTING */]: [
+    "VERIFYING" /* VERIFYING */,
+    "BLOCKED" /* BLOCKED */,
+    "ESCALATION_REQUIRED" /* ESCALATION_REQUIRED */
+  ],
+  ["VERIFYING" /* VERIFYING */]: ["REVIEWING" /* REVIEWING */, "BLOCKED" /* BLOCKED */],
+  ["REVIEWING" /* REVIEWING */]: [
+    "COMPLETED" /* COMPLETED */,
+    "REPAIR_REQUIRED" /* REPAIR_REQUIRED */,
+    "ESCALATION_REQUIRED" /* ESCALATION_REQUIRED */,
+    "BLOCKED" /* BLOCKED */
+  ],
+  ["REPAIR_REQUIRED" /* REPAIR_REQUIRED */]: ["IMPLEMENTING" /* IMPLEMENTING */],
+  ["COMPLETED" /* COMPLETED */]: ["IDLE" /* IDLE */],
+  ["BLOCKED" /* BLOCKED */]: ["ESCALATION_REQUIRED" /* ESCALATION_REQUIRED */],
+  ["ESCALATION_REQUIRED" /* ESCALATION_REQUIRED */]: ["IDLE" /* IDLE */]
+};
+function canTransition(from, to) {
+  return transitions[from].includes(to);
+}
+function transitionOrThrow(from, to) {
+  if (!canTransition(from, to)) {
+    throw new Error(`Invalid state transition: ${from} -> ${to}`);
+  }
+  return to;
+}
+
+// src/fs/workflow-store.ts
+import { mkdirSync, readFileSync as readFileSync2, writeFileSync, existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+var WorkflowStore = class {
+  root;
+  workflowDir;
+  tasksDir;
+  statePath;
+  configPath;
+  constructor(root) {
+    this.root = root;
+    this.workflowDir = join2(root, ".agent-workflow");
+    this.tasksDir = join2(this.workflowDir, "tasks");
+    this.statePath = join2(this.workflowDir, "STATE.md");
+    this.configPath = join2(this.workflowDir, "config.json");
+  }
+  ensureBaseStructure() {
+    mkdirSync(this.workflowDir, { recursive: true });
+    mkdirSync(this.tasksDir, { recursive: true });
+  }
+  ensureTask(taskId) {
+    const taskDir = join2(this.tasksDir, taskId);
+    mkdirSync(taskDir, { recursive: true });
+    return taskDir;
+  }
+  writeTaskFile(taskId, fileName, content) {
+    const taskDir = this.ensureTask(taskId);
+    const path = join2(taskDir, fileName);
+    writeFileSync(path, content, "utf8");
+    return path;
+  }
+  readTaskFile(taskId, fileName) {
+    const path = join2(this.tasksDir, taskId, fileName);
+    return readFileSync2(path, "utf8");
+  }
+  hasTaskFile(taskId, fileName) {
+    const path = join2(this.tasksDir, taskId, fileName);
+    return existsSync2(path);
+  }
+  writeConfig(config) {
+    this.ensureBaseStructure();
+    writeFileSync(this.configPath, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+  }
+  readConfig() {
+    const raw = readFileSync2(this.configPath, "utf8");
+    return JSON.parse(raw);
+  }
+  writeState(snapshot) {
+    this.ensureBaseStructure();
+    const content = toStateMarkdown(snapshot);
+    writeFileSync(this.statePath, content, "utf8");
+  }
+  readState() {
+    if (!existsSync2(this.statePath)) {
+      return defaultState();
+    }
+    const raw = readFileSync2(this.statePath, "utf8");
+    return parseStateMarkdown(raw);
+  }
+};
+function defaultState() {
+  return {
+    state: "IDLE" /* IDLE */,
+    currentPhase: "none",
+    currentTask: "none",
+    reviewAttempt: 0,
+    repairAttempt: 0,
+    nextAction: "Run init",
+    blockingIssues: [],
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function toStateMarkdown(snapshot) {
+  const issues = snapshot.blockingIssues.length === 0 ? "- None" : snapshot.blockingIssues.map((issue) => `- ${issue}`).join("\n");
+  return [
+    "# Current State",
+    "",
+    `State: ${snapshot.state}`,
+    `Current phase: ${snapshot.currentPhase}`,
+    `Current task: ${snapshot.currentTask}`,
+    `Review attempt: ${snapshot.reviewAttempt}`,
+    `Repair attempt: ${snapshot.repairAttempt}`,
+    "",
+    "## Blocking Issues",
+    issues,
+    "",
+    "## Next",
+    snapshot.nextAction,
+    "",
+    `Updated at: ${snapshot.updatedAt}`,
+    ""
+  ].join("\n");
+}
+function parseStateMarkdown(markdown) {
+  const line = (prefix) => markdown.split(/\r?\n/).find((item) => item.startsWith(prefix))?.slice(prefix.length).trim();
+  const stateValue = line("State: ");
+  const currentPhase = line("Current phase: ") ?? "none";
+  const currentTask = line("Current task: ") ?? "none";
+  const reviewAttempt = Number(line("Review attempt: ") ?? "0");
+  const repairAttempt = Number(line("Repair attempt: ") ?? "0");
+  const updatedAt = line("Updated at: ") ?? (/* @__PURE__ */ new Date()).toISOString();
+  const state = Object.values(WorkflowState).find((value) => value === stateValue) ?? "IDLE" /* IDLE */;
+  const nextSection = markdown.split("## Next\n")[1] ?? "";
+  const nextAction = (nextSection.split(/\r?\n/)[0] ?? "Run init").trim();
+  const blockingSection = markdown.split("## Blocking Issues\n")[1] ?? "";
+  const blockingRaw = blockingSection.split("\n## Next")[0] ?? "";
+  const blockingIssues = blockingRaw.split(/\r?\n/).map((item) => item.trim()).filter((item) => item.startsWith("- ") && item !== "- None").map((item) => item.slice(2));
+  return {
+    state,
+    currentPhase,
+    currentTask,
+    reviewAttempt,
+    repairAttempt,
+    nextAction,
+    blockingIssues,
+    updatedAt
+  };
+}
+
+// src/commands/brainstorm.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+function runBrainstorm(options) {
+  const store = new WorkflowStore(options.root);
+  store.ensureBaseStructure();
+  let spec = "";
+  if (options.spec && existsSync3(options.spec)) {
+    spec = readFileSync3(options.spec, "utf8");
+    store.writeTaskFile(options.task, "SPEC.md", spec);
+  } else if (options.prompt) {
+    spec = options.prompt;
+    store.writeTaskFile(options.task, "SPEC.md", spec);
+  } else if (store.hasTaskFile(options.task, "SPEC.md")) {
+    spec = store.readTaskFile(options.task, "SPEC.md");
+  } else {
+    throw new Error(
+      `Missing spec for task ${options.task}. Provide --spec <path>, --prompt <text>, or create .agent-workflow/tasks/${options.task}/SPEC.md`
+    );
+  }
+  const agentResolution = detectAgent({
+    root: options.root,
+    content: spec,
+    explicitAgent: options.agent
+  });
+  console.log(`[Agent Router] Assigned: ${agentResolution.agent.name} (${agentResolution.agent.id})`);
+  console.log(`[Agent Router] Reason: ${agentResolution.reason}`);
+  const brainstorm = buildBrainstormMarkdown(options.task, spec, agentResolution);
+  store.writeTaskFile(options.task, "BRAINSTORM.md", brainstorm);
+  const state = store.readState();
+  state.state = "DISCOVERY" /* DISCOVERY */;
+  state.state = "BRAINSTORMING" /* BRAINSTORMING */;
+  state.currentTask = options.task;
+  state.currentPhase = "brainstorming";
+  state.nextAction = "Run plan command to convert brainstorm into phases and tasks";
+  state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  store.writeState(state);
+  console.log(brainstorm);
+}
+function buildBrainstormMarkdown(task, spec, agentResolution) {
+  return [
+    "# Brainstorm",
+    "",
+    `Task: ${task}`,
+    `Assigned Agent: ${agentResolution.agent.name} (${agentResolution.agent.id})`,
+    `Agent Selection: ${agentResolution.reason}`,
+    "",
+    "## Goal",
+    `Task ${task}`,
+    "",
+    "## Current System",
+    "Repository contains an orchestration kit with Codex planning and Antigravity execution boundaries.",
+    "",
+    "## Requirements",
+    spec.trim(),
+    "",
+    "## Constraints",
+    "- Keep context small and deterministic",
+    "- Use filesystem artifacts as durable state",
+    "- Do not invent requirements",
+    "",
+    "## Relevant Existing Architecture",
+    "- Codex owns clarification, planning, review, and verification",
+    "- Antigravity owns implementation",
+    "- Agy is the worker CLI bridge",
+    "",
+    "## Options Considered",
+    "### Option A",
+    "Pros: Simple artifact-first workflow",
+    "Cons: Requires explicit commands",
+    "",
+    "### Option B",
+    "Pros: More automation",
+    "Cons: Higher complexity and harder debugging",
+    "",
+    "## Recommended Approach",
+    "Use an artifact-first command flow: brainstorm -> plan -> execute -> review.",
+    "",
+    "## Why",
+    "This keeps the workflow small, inspectable, and easy to recover.",
+    "",
+    "## Risks",
+    "- Incomplete specs can still block execution",
+    "- Worker output may need repair",
+    "",
+    "## Open Questions",
+    "None",
+    ""
+  ].join("\n");
+}
+
+// src/bridge/shell-agy-adapter.ts
+import { spawn } from "child_process";
+var ShellAgyAdapter = class {
+  command;
+  baseArgs;
+  constructor(options) {
+    this.command = options.command;
+    this.baseArgs = options.baseArgs ?? [];
+  }
+  async run(request) {
+    return new Promise((resolve) => {
+      const startedAt = Date.now();
+      const args = [
+        ...this.baseArgs,
+        "--add-dir",
+        request.repoPath,
+        "--print",
+        request.prompt,
+        "--output-format",
+        "text",
+        "--print-timeout",
+        `${Math.ceil(request.timeoutMs / 1e3)}s`
+      ];
+      const child = spawn(this.command, args, {
+        cwd: request.repoPath,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      let timedOut = false;
+      const timer = setTimeout(() => {
+        timedOut = true;
+        child.kill("SIGTERM");
+      }, request.timeoutMs);
+      child.stdout.on("data", (chunk) => {
+        stdout += chunk.toString("utf8");
+      });
+      child.stderr.on("data", (chunk) => {
+        stderr += chunk.toString("utf8");
+      });
+      child.on("error", (error) => {
+        clearTimeout(timer);
+        resolve({
+          ok: false,
+          timedOut,
+          exitCode: null,
+          stdout,
+          stderr: `${stderr}
+${error.message}`.trim(),
+          durationMs: Date.now() - startedAt
+        });
+      });
+      child.on("close", (exitCode) => {
+        clearTimeout(timer);
+        resolve({
+          ok: !timedOut && exitCode === 0,
+          timedOut,
+          exitCode,
+          stdout,
+          stderr,
+          durationMs: Date.now() - startedAt
+        });
+      });
+    });
+  }
+};
+
+// src/core/result-parser.ts
+var knownStatuses = ["DONE", "BLOCKED", "FAILED"];
+function parseWorkerResult(raw) {
+  const lines = raw.split(/\r?\n/).map((line) => line.trim());
+  const statusLine = lines.find(
+    (line) => knownStatuses.some((status2) => line.toUpperCase().includes(status2))
+  );
+  const status = knownStatuses.find((value) => statusLine?.toUpperCase().includes(value)) ?? "FAILED";
+  const summary = lines.find((line) => line.length > 0 && !line.startsWith("#")) ?? "No summary provided by worker.";
+  return { status, summary };
+}
+
+// src/commands/execute.ts
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import { join as join3 } from "path";
+async function runExecute(options) {
+  const store = new WorkflowStore(options.root);
+  if (!existsSync4(store.configPath)) {
+    throw new Error("Missing .agent-workflow/config.json. Run init first.");
+  }
+  const config = store.readConfig();
+  const adapter = new ShellAgyAdapter({
+    command: config.agyCommand,
+    baseArgs: config.agyArgs
+  });
+  await runExecuteWithAdapter(options, adapter);
+}
+async function runExecuteWithAdapter(options, adapter) {
+  const store = new WorkflowStore(options.root);
+  store.ensureBaseStructure();
+  const current = store.readState();
+  let contextSource = "";
+  let contextContent = "";
+  if (options.file && existsSync4(options.file)) {
+    contextSource = options.file;
+    contextContent = readFileSync4(options.file, "utf8");
+    store.writeTaskFile(options.task, "PLAN.md", contextContent);
+  } else if (options.plan && existsSync4(options.plan)) {
+    contextSource = options.plan;
+    contextContent = readFileSync4(options.plan, "utf8");
+    store.writeTaskFile(options.task, "PLAN.md", contextContent);
+  } else if (store.hasTaskFile(options.task, "PLAN.md")) {
+    contextSource = join3(store.tasksDir, options.task, "PLAN.md");
+    contextContent = store.readTaskFile(options.task, "PLAN.md");
+  } else if (options.spec && existsSync4(options.spec)) {
+    contextSource = options.spec;
+    contextContent = readFileSync4(options.spec, "utf8");
+    store.writeTaskFile(options.task, "SPEC.md", contextContent);
+  } else if (store.hasTaskFile(options.task, "SPEC.md")) {
+    contextSource = join3(store.tasksDir, options.task, "SPEC.md");
+    contextContent = store.readTaskFile(options.task, "SPEC.md");
+  } else {
+    throw new Error(
+      `No context markdown file found to execute for task ${options.task}. Run 'plan' or provide --plan, --file, or --spec.`
+    );
+  }
+  let repairContent = "";
+  if (options.repairRequest && existsSync4(options.repairRequest)) {
+    repairContent = readFileSync4(options.repairRequest, "utf8");
+    store.writeTaskFile(options.task, "REPAIR_REQUEST.md", repairContent);
+  } else if (store.hasTaskFile(options.task, "REPAIR_REQUEST.md")) {
+    repairContent = store.readTaskFile(options.task, "REPAIR_REQUEST.md");
+  }
+  const agentResolution = detectAgent({
+    root: options.root,
+    content: contextContent,
+    explicitAgent: options.agent
+  });
+  console.log(`[Agent Router] Assigned: ${agentResolution.agent.name} (${agentResolution.agent.id})`);
+  console.log(`[Agent Router] Reason: ${agentResolution.reason}`);
+  const executeArtifact = buildExecuteMarkdown(options.task, contextSource, contextContent, agentResolution);
+  store.writeTaskFile(options.task, "EXECUTE.md", executeArtifact);
+  advanceStateToImplementing(current);
+  current.currentTask = options.task;
+  current.currentPhase = "implementation";
+  current.nextAction = "Wait for worker execution result";
+  current.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  store.writeState(current);
+  const workerRulesPath = join3(options.root, ".antigravity", "WORKER_RULES.md");
+  const workerRules = existsSync4(workerRulesPath) ? readFileSync4(workerRulesPath, "utf8") : "";
+  const prompt = buildWorkerPrompt({
+    taskId: options.task,
+    workerRules,
+    context: contextContent,
+    repairRequest: repairContent,
+    agentResolution
+  });
+  const timeoutMs = options.timeoutMs ?? 6e5;
+  const execution = await adapter.run({
+    repoPath: options.root,
+    taskId: options.task,
+    prompt,
+    timeoutMs
+  });
+  const resultContent = toResultMarkdown(
+    execution.stdout,
+    execution.stderr,
+    execution.exitCode,
+    execution.durationMs
+  );
+  store.writeTaskFile(options.task, "RESULT.md", resultContent);
+  current.state = transitionOrThrow(current.state, "VERIFYING" /* VERIFYING */);
+  if (!execution.ok) {
+    current.state = "BLOCKED" /* BLOCKED */;
+    current.blockingIssues = [
+      execution.timedOut ? "Worker execution timed out" : `Worker failed with exit code ${execution.exitCode}`
+    ];
+    current.nextAction = "Inspect RESULT.md and decide escalation or retry";
+    current.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    store.writeState(current);
+    console.log("Worker execution failed or timed out. See RESULT.md");
+    return;
+  }
+  const parsed = parseWorkerResult(execution.stdout);
+  applyParsedResultState(current, parsed);
+  current.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  store.writeState(current);
+  console.log(`Worker status: ${parsed.status}`);
+  console.log(`Summary: ${parsed.summary}`);
+}
+function advanceStateToImplementing(snapshot) {
+  if (snapshot.state === "IMPLEMENTING" /* IMPLEMENTING */) {
+    return;
+  }
+  if (snapshot.state === "REPAIR_REQUIRED" /* REPAIR_REQUIRED */) {
+    snapshot.state = transitionOrThrow(snapshot.state, "IMPLEMENTING" /* IMPLEMENTING */);
+    return;
+  }
+  if (snapshot.state === "READY" /* READY */) {
+    snapshot.state = transitionOrThrow(snapshot.state, "IMPLEMENTING" /* IMPLEMENTING */);
+    return;
+  }
+  if (snapshot.state === "PLANNING" /* PLANNING */) {
+    snapshot.state = transitionOrThrow(snapshot.state, "READY" /* READY */);
+    snapshot.state = transitionOrThrow(snapshot.state, "IMPLEMENTING" /* IMPLEMENTING */);
+    return;
+  }
+  if (snapshot.state === "BRAINSTORMING" /* BRAINSTORMING */) {
+    snapshot.state = transitionOrThrow(snapshot.state, "PLANNING" /* PLANNING */);
+    snapshot.state = transitionOrThrow(snapshot.state, "READY" /* READY */);
+    snapshot.state = transitionOrThrow(snapshot.state, "IMPLEMENTING" /* IMPLEMENTING */);
+    return;
+  }
+  if (snapshot.state === "DISCOVERY" /* DISCOVERY */) {
+    snapshot.state = transitionOrThrow(snapshot.state, "BRAINSTORMING" /* BRAINSTORMING */);
+    snapshot.state = transitionOrThrow(snapshot.state, "PLANNING" /* PLANNING */);
+    snapshot.state = transitionOrThrow(snapshot.state, "READY" /* READY */);
+    snapshot.state = transitionOrThrow(snapshot.state, "IMPLEMENTING" /* IMPLEMENTING */);
+    return;
+  }
+  snapshot.state = transitionOrThrow(snapshot.state, "DISCOVERY" /* DISCOVERY */);
+  snapshot.state = transitionOrThrow(snapshot.state, "BRAINSTORMING" /* BRAINSTORMING */);
+  snapshot.state = transitionOrThrow(snapshot.state, "PLANNING" /* PLANNING */);
+  snapshot.state = transitionOrThrow(snapshot.state, "READY" /* READY */);
+  snapshot.state = transitionOrThrow(snapshot.state, "IMPLEMENTING" /* IMPLEMENTING */);
+}
+function buildWorkerPrompt(input) {
+  const parts = [
+    "You are Antigravity implementation worker.",
+    "",
+    input.workerRules,
+    "",
+    `# Task ID
+${input.taskId}`,
+    "",
+    `# Assigned Role
+Agent: ${input.agentResolution.agent.name} (${input.agentResolution.agent.id})
+Reason: ${input.agentResolution.reason}`
+  ];
+  if (input.agentResolution.instructions) {
+    parts.push("# Agent Operational Guidelines\n" + input.agentResolution.instructions);
+  }
+  if (input.agentResolution.skillInstructions) {
+    parts.push("# Recommended Skill Practices\n" + input.agentResolution.skillInstructions);
+  }
+  parts.push("# Implementation Context & Specification\n" + input.context);
+  if (input.repairRequest) {
+    parts.push("# REPAIR REQUEST\n" + input.repairRequest);
+  }
+  parts.push("Return only concise Implementation Result markdown with status DONE | BLOCKED | FAILED.");
+  return parts.filter(Boolean).join("\n\n");
+}
+function applyParsedResultState(state, result) {
+  state.state = transitionOrThrow(state.state, "REVIEWING" /* REVIEWING */);
+  if (result.status === "DONE") {
+    state.nextAction = "Run review and record PASS/FAIL";
+    state.blockingIssues = [];
+    return;
+  }
+  if (result.status === "FAILED") {
+    state.state = "REPAIR_REQUIRED" /* REPAIR_REQUIRED */;
+    state.repairAttempt += 1;
+    state.nextAction = "Create repair request and execute again";
+    return;
+  }
+  state.state = "ESCALATION_REQUIRED" /* ESCALATION_REQUIRED */;
+  state.blockingIssues = ["Worker returned BLOCKED status"];
+  state.nextAction = "Resolve blocking decision with user";
+}
+function buildExecuteMarkdown(task, source, context, agentResolution) {
+  return [
+    "# Execute",
+    "",
+    `Task: ${task}`,
+    `Source: ${source}`,
+    `Assigned Agent: ${agentResolution.agent.name} (${agentResolution.agent.id})`,
+    `Agent Selection: ${agentResolution.reason}`,
+    "",
+    "## Context & Plan Package",
+    context.trim(),
+    "",
+    "## Expected Worker Result",
+    "- DONE when implementation and tests complete",
+    "- FAILED when implementation needs repair",
+    "- BLOCKED when missing context/decision",
+    ""
+  ].join("\n");
+}
+function toResultMarkdown(stdout, stderr, exitCode, durationMs) {
+  return [
+    "# Implementation Result",
+    "",
+    "## Execution",
+    `- Exit code: ${String(exitCode)}`,
+    `- Duration ms: ${durationMs}`,
+    "",
+    "## Stdout",
+    "```text",
+    stdout.trim() || "(empty)",
+    "```",
+    "",
+    "## Stderr",
+    "```text",
+    stderr.trim() || "(empty)",
+    "```",
+    ""
+  ].join("\n");
+}
+
+// src/commands/delegate.ts
+import { readFileSync as readFileSync5, existsSync as existsSync5 } from "fs";
+import { join as join4 } from "path";
+async function runDelegate(options) {
+  const store = new WorkflowStore(options.root);
+  if (!existsSync5(store.configPath)) {
+    throw new Error("Missing .agent-workflow/config.json. Run init first.");
+  }
+  const config = store.readConfig();
+  const adapter = new ShellAgyAdapter({
+    command: config.agyCommand,
+    baseArgs: config.agyArgs
+  });
+  await runDelegateWithAdapter(options, adapter);
+}
+async function runDelegateWithAdapter(options, adapter) {
+  const store = new WorkflowStore(options.root);
+  store.ensureBaseStructure();
+  const current = store.readState();
+  const specContent = readFileSync5(options.spec, "utf8");
+  store.writeTaskFile(options.task, "SPEC.md", specContent);
+  let repairContent = "";
+  if (options.repairRequest) {
+    repairContent = readFileSync5(options.repairRequest, "utf8");
+    store.writeTaskFile(options.task, "REPAIR_REQUEST.md", repairContent);
+  }
+  advanceStateToImplementing2(current);
+  current.currentTask = options.task;
+  current.currentPhase = "implementation";
+  current.nextAction = "Wait for worker execution result";
+  current.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  store.writeState(current);
+  const workerRulesPath = join4(options.root, ".antigravity", "WORKER_RULES.md");
+  const workerRules = existsSync5(workerRulesPath) ? readFileSync5(workerRulesPath, "utf8") : "";
+  const prompt = buildWorkerPrompt2({
+    taskId: options.task,
+    workerRules,
+    spec: specContent,
+    repairRequest: repairContent
+  });
+  const execution = await adapter.run({
+    repoPath: options.root,
+    taskId: options.task,
+    prompt,
+    timeoutMs: options.timeoutMs
+  });
+  const resultContent = toResultMarkdown2(execution.stdout, execution.stderr, execution.exitCode, execution.durationMs);
+  store.writeTaskFile(options.task, "RESULT.md", resultContent);
+  current.state = transitionOrThrow(current.state, "VERIFYING" /* VERIFYING */);
+  if (!execution.ok) {
+    current.state = "BLOCKED" /* BLOCKED */;
+    current.blockingIssues = [
+      execution.timedOut ? "Worker execution timed out" : `Worker failed with exit code ${execution.exitCode}`
+    ];
+    current.nextAction = "Inspect RESULT.md and decide escalation or retry";
+    current.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    store.writeState(current);
+    console.log("Worker execution failed or timed out. See RESULT.md");
+    return;
+  }
+  const parsed = parseWorkerResult(execution.stdout);
+  applyParsedResultState2(current, parsed);
+  current.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  store.writeState(current);
+  console.log(`Worker status: ${parsed.status}`);
+  console.log(`Summary: ${parsed.summary}`);
+}
+function buildWorkerPrompt2(input) {
+  return [
+    "You are Antigravity implementation worker.",
+    "",
+    input.workerRules,
+    "",
+    `# Task ID
+${input.taskId}`,
+    "",
+    "# SPEC",
+    input.spec,
+    input.repairRequest ? "# REPAIR REQUEST\n" + input.repairRequest : "",
+    "",
+    "Return only concise Implementation Result markdown with status DONE | BLOCKED | FAILED."
+  ].filter(Boolean).join("\n");
+}
+function applyParsedResultState2(state, result) {
+  state.state = transitionOrThrow(state.state, "REVIEWING" /* REVIEWING */);
+  if (result.status === "DONE") {
+    state.nextAction = "Run review and record PASS/FAIL";
+    state.blockingIssues = [];
+    return;
+  }
+  if (result.status === "FAILED") {
+    state.state = "REPAIR_REQUIRED" /* REPAIR_REQUIRED */;
+    state.repairAttempt += 1;
+    state.nextAction = "Create repair request and delegate again";
+    return;
+  }
+  state.state = "ESCALATION_REQUIRED" /* ESCALATION_REQUIRED */;
+  state.blockingIssues = ["Worker returned BLOCKED status"];
+  state.nextAction = "Resolve blocking decision with user";
+}
+function toResultMarkdown2(stdout, stderr, exitCode, durationMs) {
+  return [
+    "# Implementation Result",
+    "",
+    "## Execution",
+    `- Exit code: ${String(exitCode)}`,
+    `- Duration ms: ${durationMs}`,
+    "",
+    "## Stdout",
+    "```text",
+    stdout.trim() || "(empty)",
+    "```",
+    "",
+    "## Stderr",
+    "```text",
+    stderr.trim() || "(empty)",
+    "```",
+    ""
+  ].join("\n");
+}
+function advanceStateToImplementing2(snapshot) {
+  if (snapshot.state === "IMPLEMENTING" /* IMPLEMENTING */) {
+    return;
+  }
+  if (snapshot.state === "REPAIR_REQUIRED" /* REPAIR_REQUIRED */) {
+    snapshot.state = transitionOrThrow(snapshot.state, "IMPLEMENTING" /* IMPLEMENTING */);
+    return;
+  }
+  if (snapshot.state === "READY" /* READY */) {
+    snapshot.state = transitionOrThrow(snapshot.state, "IMPLEMENTING" /* IMPLEMENTING */);
+    return;
+  }
+  if (snapshot.state === "PLANNING" /* PLANNING */) {
+    snapshot.state = transitionOrThrow(snapshot.state, "READY" /* READY */);
+    snapshot.state = transitionOrThrow(snapshot.state, "IMPLEMENTING" /* IMPLEMENTING */);
+    return;
+  }
+  if (snapshot.state === "BRAINSTORMING" /* BRAINSTORMING */) {
+    snapshot.state = transitionOrThrow(snapshot.state, "PLANNING" /* PLANNING */);
+    snapshot.state = transitionOrThrow(snapshot.state, "READY" /* READY */);
+    snapshot.state = transitionOrThrow(snapshot.state, "IMPLEMENTING" /* IMPLEMENTING */);
+    return;
+  }
+  if (snapshot.state === "DISCOVERY" /* DISCOVERY */) {
+    snapshot.state = transitionOrThrow(snapshot.state, "BRAINSTORMING" /* BRAINSTORMING */);
+    snapshot.state = transitionOrThrow(snapshot.state, "PLANNING" /* PLANNING */);
+    snapshot.state = transitionOrThrow(snapshot.state, "READY" /* READY */);
+    snapshot.state = transitionOrThrow(snapshot.state, "IMPLEMENTING" /* IMPLEMENTING */);
+    return;
+  }
+  snapshot.state = transitionOrThrow(snapshot.state, "DISCOVERY" /* DISCOVERY */);
+  snapshot.state = transitionOrThrow(snapshot.state, "BRAINSTORMING" /* BRAINSTORMING */);
+  snapshot.state = transitionOrThrow(snapshot.state, "PLANNING" /* PLANNING */);
+  snapshot.state = transitionOrThrow(snapshot.state, "READY" /* READY */);
+  snapshot.state = transitionOrThrow(snapshot.state, "IMPLEMENTING" /* IMPLEMENTING */);
+}
+
+// src/commands/doctor.ts
+import { existsSync as existsSync6 } from "fs";
+import { spawnSync } from "child_process";
+function runDoctor(options) {
+  const store = new WorkflowStore(options.root);
+  const checks = [];
+  const agyCheck = spawnSync("sh", ["-lc", "command -v agy"], {
+    cwd: options.root,
+    encoding: "utf8"
+  });
+  checks.push({
+    name: "agy command",
+    ok: agyCheck.status === 0,
+    detail: agyCheck.stdout.trim() || agyCheck.stderr.trim()
+  });
+  checks.push({
+    name: ".agent-workflow directory",
+    ok: existsSync6(store.workflowDir)
+  });
+  checks.push({
+    name: "STATE.md",
+    ok: existsSync6(store.statePath)
+  });
+  checks.push({
+    name: "config.json",
+    ok: existsSync6(store.configPath)
+  });
+  checks.push({
+    name: "AGENTS.md",
+    ok: existsSync6(`${options.root}/AGENTS.md`)
+  });
+  checks.push({
+    name: ".codex/agents/codex.md",
+    ok: existsSync6(`${options.root}/.codex/agents/codex.md`)
+  });
+  checks.push({
+    name: ".codex/agents/brainstormer.md",
+    ok: existsSync6(`${options.root}/.codex/agents/brainstormer.md`)
+  });
+  checks.push({
+    name: ".codex/agents/planner.md",
+    ok: existsSync6(`${options.root}/.codex/agents/planner.md`)
+  });
+  checks.push({
+    name: ".codex/agents/researcher.md",
+    ok: existsSync6(`${options.root}/.codex/agents/researcher.md`)
+  });
+  checks.push({
+    name: ".codex/agents/business-analyst.md",
+    ok: existsSync6(`${options.root}/.codex/agents/business-analyst.md`)
+  });
+  checks.push({
+    name: ".codex/agents/web-engineer.md",
+    ok: existsSync6(`${options.root}/.codex/agents/web-engineer.md`)
+  });
+  checks.push({
+    name: ".codex/agents/mobile-engineer.md",
+    ok: existsSync6(`${options.root}/.codex/agents/mobile-engineer.md`)
+  });
+  checks.push({
+    name: ".codex/agents/game-engineer.md",
+    ok: existsSync6(`${options.root}/.codex/agents/game-engineer.md`)
+  });
+  checks.push({
+    name: ".codex/skills/codex-workflow.md",
+    ok: existsSync6(`${options.root}/.codex/skills/codex-workflow.md`)
+  });
+  checks.push({
+    name: ".codex/skills/brainstorming.md",
+    ok: existsSync6(`${options.root}/.codex/skills/brainstorming.md`)
+  });
+  checks.push({
+    name: ".codex/skills/planning.md",
+    ok: existsSync6(`${options.root}/.codex/skills/planning.md`)
+  });
+  checks.push({
+    name: ".codex/skills/research.md",
+    ok: existsSync6(`${options.root}/.codex/skills/research.md`)
+  });
+  checks.push({
+    name: ".codex/skills/requirements-analysis.md",
+    ok: existsSync6(`${options.root}/.codex/skills/requirements-analysis.md`)
+  });
+  checks.push({
+    name: ".codex/skills/web-engineering.md",
+    ok: existsSync6(`${options.root}/.codex/skills/web-engineering.md`)
+  });
+  checks.push({
+    name: ".codex/skills/mobile-engineering.md",
+    ok: existsSync6(`${options.root}/.codex/skills/mobile-engineering.md`)
+  });
+  checks.push({
+    name: ".codex/skills/game-engineering.md",
+    ok: existsSync6(`${options.root}/.codex/skills/game-engineering.md`)
+  });
+  for (const check of checks) {
+    console.log(`${check.ok ? "PASS" : "FAIL"} - ${check.name}`);
+    if (check.detail) {
+      console.log(`  ${check.detail}`);
+    }
+  }
+  const hasFailure = checks.some((check) => !check.ok);
+  if (hasFailure) {
+    process.exitCode = 1;
+  }
+}
+
+// src/commands/init.ts
+import { existsSync as existsSync7, mkdirSync as mkdirSync2, readFileSync as readFileSync6, writeFileSync as writeFileSync2 } from "fs";
+import { join as join5 } from "path";
+var defaultConfig = {
+  agyCommand: "agy",
+  agyArgs: [],
+  maxRepairAttempts: 3
+};
+var defaultAgents = `# Codex Runtime Contract
+
+Codex role: Technical Lead, Architect, Planner, Orchestrator, Reviewer, Verifier.
+
+Execution order:
+Understand -> Inspect -> Clarify -> Brainstorm -> Plan -> Delegate -> Review -> Repair -> Verify -> Complete.
+
+Rules:
+1. Search before asking.
+2. If missing context affects architecture/behavior/security/compatibility, stop and ask.
+3. Do not invent requirements.
+4. Do not delegate before task spec is complete.
+5. PASS only after verification and independent review.
+`;
+var defaultWorkerRules = `# Antigravity Worker Contract
+
+You are the implementation worker.
+
+1. SPEC is the contract.
+2. REPAIR request is the correction contract.
+3. Inspect relevant code before editing.
+4. Implement minimal correct scope.
+5. Add or update tests.
+6. Run verification commands.
+7. Report using Implementation Result contract.
+8. Return BLOCKED if missing decision/context prevents safe completion.
+`;
+var defaultCodexAgent = `# Codex Agent Template
+
+Role: Technical Lead / Planner / Reviewer
+
+Use this agent for:
+- clarifying requirements
+- decomposing work into phases
+- reviewing implementation output
+- deciding PASS / FAIL / BLOCKED
+
+Rules:
+1. Keep decisions in markdown artifacts.
+2. Do not delegate before the spec is complete.
+3. Prefer the smallest safe next action.
+`;
+var brainstormAgent = `# Brainstormer Agent
+
+Role: Discovery and problem framing.
+
+Use this agent for:
+- turning a rough request into a clear problem statement
+- identifying constraints, assumptions, and unknowns
+- comparing solution options before planning
+- preparing the input for planning
+
+Operating rules:
+1. Stay in discovery; do not implement.
+2. Capture only evidence-backed assumptions.
+3. Prefer short, explicit notes.
+4. End with concrete questions or a recommendation.
+
+Output format:
+- Goal
+- Context
+- Constraints
+- Options
+- Risks
+- Open questions
+- Recommended next step
+`;
+var plannerAgent = `# Planner Agent
+
+Role: Convert a validated brainstorm into an execution plan.
+
+Use this agent for:
+- breaking work into phases and tasks
+- defining acceptance criteria
+- identifying dependencies and sequencing
+- preparing the handoff to execution
+
+Operating rules:
+1. Use the brainstorm as the source of truth.
+2. Split work into small, ordered steps.
+3. Keep the plan testable and recoverable.
+4. Call out blockers explicitly.
+
+Output format:
+- Objective
+- Scope
+- Phases
+- Tasks
+- Acceptance criteria
+- Verification
+- Blockers
+`;
+var defaultCodexSkill = `# Codex Skill Template
+
+Use this skill when the task must be executed through the Codex flow in this kit.
+
+Workflow:
+1. Brainstorm
+2. Plan
+3. Execute
+4. Delegate
+5. Review
+
+Output artifacts:
+- BRAINSTORM.md
+- PLAN.md
+- EXECUTE.md
+- RESULT.md
+- REVIEW.md
+`;
+var brainstormingSkill = `# Brainstorming Skill
+
+Use this skill when you need to transform a vague request into a decision-ready problem statement.
+
+Workflow:
+1. Read the spec or request.
+2. Identify goals, constraints, unknowns, and risks.
+3. Compare at least two viable approaches.
+4. Recommend the safest next step.
+
+Outputs:
+- BRAINSTORM.md
+- Decision notes
+- Open questions
+
+Do not implement code in this phase.
+`;
+var planningSkill = `# Planning Skill
+
+Use this skill when the request is ready to be turned into an execution plan.
+
+Workflow:
+1. Consume the brainstorm output.
+2. Break the work into phases.
+3. Add acceptance criteria and verification steps.
+4. Prepare a clear execution handoff.
+
+Outputs:
+- PLAN.md
+- Task breakdown
+- Verification checklist
+- Handoff notes
+
+Do not delegate implementation until the plan is complete.
+`;
+var researcherAgent = `# Researcher Agent
+
+Role: Deep Technical Research, Spikes, Architecture Benchmarks & Feasibility.
+
+Use this agent for:
+- investigating unknown technical domains, new libraries, or unfamiliar APIs
+- conducting technical spikes and feasibility studies before architectural commitment
+- comparing competing frameworks, protocols, and third-party services
+- identifying hidden constraints, license obligations, deprecations, and performance bottlenecks
+- analyzing state-of-the-art implementations and industry best practices
+
+Operating rules:
+1. Search code and documentation before speculating.
+2. Provide concrete evidence, benchmarks, or citations for claims.
+3. Compare at least 2 viable approaches with explicit trade-offs (pros/cons/risks).
+4. Never assume third-party API contracts without verifying current versions.
+5. Conclude with a definitive, actionable recommendation and a risk mitigation strategy.
+
+Output format:
+- Research Objective & Scope
+- Background & Current State
+- Evaluated Options (Trade-off Matrix)
+- Spike / Proof of Concept Findings
+- Risks & Breaking Changes
+- Recommended Architecture / Path Forward
+`;
+var businessAnalystAgent = `# Business Analyst (BA) Agent
+
+Role: Requirements Elicitation, User Story Breakdown, Domain Modeling & Acceptance Criteria Engineering.
+
+Use this agent for:
+- turning unstructured business requirements or user requests into precise functional specifications
+- identifying distinct user personas, user journeys, and role-based permissions
+- uncovering non-obvious edge cases, error scenarios, and business boundary rules
+- authoring testable acceptance criteria using Gherkin (Given / When / Then) syntax
+- mapping domain entities, data dictionaries, and state transition lifecycles
+
+Operating rules:
+1. Do not invent requirements; clarify ambiguities with explicit questions or assumptions.
+2. Separate business logic and user intent from technical implementation details.
+3. Every functional requirement must have at least one testable acceptance criterion.
+4. Always specify happy path, alternative paths, and negative/failure paths.
+5. Highlight all dependencies on external systems, legal/compliance rules, and business limits.
+
+Output format:
+- Feature Summary & Business Value
+- User Personas & Permissions
+- User Stories & Workflows
+- Functional & Non-Functional Requirements
+- Edge Cases & Negative Scenarios
+- Acceptance Criteria (Given/When/Then)
+- Open Questions & Assumptions
+`;
+var webEngineerAgent = `# Web Engineer Agent
+
+Role: Modern Web Architecture & Engineering Specialist (Frontend, Backend, APIs, Performance).
+
+Use this agent for:
+- designing responsive frontend architectures (React, Next.js, Vue, Svelte, Vanilla HTML/CSS/JS)
+- building resilient backend services and APIs (Node.js/TypeScript, Go, Python, REST, GraphQL, WebSocket)
+- defining state management, data caching, optimistic UI updates, and server components
+- enforcing modern web performance (Core Web Vitals: LCP, INP, CLS) and responsive design
+- securing web applications against XSS, CSRF, SSRF, CORS misconfigurations, and injection attacks
+- establishing SEO, accessibility (WCAG 2.1 AA, ARIA roles), and progressive enhancement standards
+
+Operating rules:
+1. Adhere to repository coding patterns and modern framework idioms (prefer web standards and composable patterns).
+2. Never hardcode sensitive tokens or environment secrets into client-side bundles.
+3. Design UI components for responsiveness across mobile, tablet, and desktop breakpoints.
+4. Keep network waterfalls minimal: optimize bundle size, leverage code splitting and caching headers.
+5. All interactive UI elements must have unique test identifiers and valid keyboard focus management.
+
+Output format:
+- Web Architecture & Tech Stack Details
+- Component Hierarchy & State Flow
+- API Contracts & Data Schemas
+- Routing & Navigation Structure
+- Performance & Security Constraints
+- Verification & Test Matrix (Unit, Integration, E2E)
+`;
+var mobileEngineerAgent = `# Mobile Engineer Agent
+
+Role: Mobile Application Architecture & Engineering Specialist (Cross-Platform & Native).
+
+Use this agent for:
+- architecting cross-platform apps using Flutter/Dart or React Native/Expo
+- engineering native iOS applications (Swift, SwiftUI, UIKit, Combine/Async-Await)
+- engineering native Android applications (Kotlin, Jetpack Compose, Coroutines/Flow)
+- managing mobile lifecycle states (foreground, background, suspended, terminated)
+- designing offline-first local storage, SQLite/Room/CoreData/WatermelonDB/Hive, and background sync
+- handling device hardware integrations: Push notifications, Biometrics, Camera, Geolocation, Bluetooth
+- configuring native build pipelines, signing, permissions, deep linking, and App Store/Play Store readiness
+
+Operating rules:
+1. Respect native operating system guidelines (Apple Human Interface Guidelines and Material Design 3).
+2. Handle network flakiness gracefully: implement retries, offline caching, and optimistic local state.
+3. Treat app permissions defensively: request at runtime with clear user rationale and fallback states.
+4. Avoid main-thread blocking; offload heavy computations and disk I/O to background workers/isolates.
+5. Account for device fragmentation: test various screen aspect ratios, safe areas, notches, and dark mode.
+
+Output format:
+- Target Platform & Architecture (Native iOS/Android, React Native, or Flutter)
+- State Management & Navigation Hierarchy
+- Local Storage & Offline Sync Strategy
+- Native Capabilities & Permission Handling
+- Device Lifecycle & Memory Considerations
+- Build, Verification & Device Testing Strategy
+`;
+var gameEngineerAgent = `# Game Engineer Agent
+
+Role: Game Systems Architecture, Gameplay Mechanics & Engine Specialist (Unity, Godot, Cocos Creator).
+
+Use this agent for:
+- architecting game systems across major game engines:
+  - Unity: C#, GameObject/Component lifecycle, ScriptableObjects, DOTS/Burst, Addressables
+  - Godot: GDScript / C#, Node tree hierarchy, Scene inheritance, Signals, Resource system
+  - Cocos Creator: TypeScript, Component lifecycle, Prefabs, Canvas/UI, WebGL/HTML5 packaging
+- developing core gameplay loops, mechanics, player controllers, and input action maps
+- designing Entity-Component-System (ECS) and data-driven state machines
+- configuring 2D/3D physics, collision layers, rigid bodies, raycasting, and triggers
+- managing asset pipelines: sprites, tilemaps, 3D meshes, particle effects, animations, and audio mixers
+- profiling and optimizing game performance: frame-rate stability (60/120 FPS), draw calls, texture atlases, garbage collection pauses
+
+Operating rules:
+1. Keep gameplay logic decoupled from rendering and engine-specific editor scripts where feasible.
+2. Optimize memory allocations in the hot game loop (Update / _process) to prevent GC spikes.
+3. Physics updates must run in fixed timesteps (FixedUpdate / _physics_process).
+4. Manage scene and asset lifecycles strictly to eliminate memory leaks and dangling event listeners.
+5. Provide deterministic fallback logic and verification tests for core game rules and mathematical calculations.
+
+Output format:
+- Game Engine, Version & Render Pipeline Selection
+- Core Game Loop & Gameplay Mechanics Architecture
+- Scene / Node Hierarchy & Component Relationships
+- Physics, Collision Matrix & Input Handling
+- Asset Management & Performance Budget (Draw calls, Memory, Target FPS)
+- Verification Checklist & Playtest Strategy
+`;
+var researchSkill = `# Technical Research Skill
+
+Use this skill when tackling technical uncertainty, evaluating new libraries, prototyping spikes, or comparing architectural designs.
+
+Workflow:
+1. Frame the Spike: Define the research question, target hypothesis, constraints, and success criteria.
+2. Explore Existing Solutions: Inspect repository codebase, official documentation, ecosystem libraries, and community benchmarks.
+3. Compare Alternatives: Benchmark at least 2 distinct approaches across complexity, maintenance, scalability, security, and developer experience.
+4. Prototype & Validate: Run minimal proof-of-concept tests or sandbox experiments to verify critical assumptions.
+5. Document & Recommend: Synthesize findings into clear architectural guidance, trade-offs, and an actionable implementation path.
+
+Outputs:
+- Research findings artifact (RESEARCH.md or section in BRAINSTORM.md)
+- Technical comparison matrix
+- Decision record with trade-offs and rationale
+- Risk assessment and mitigation plan
+`;
+var requirementsAnalysisSkill = `# Requirements Analysis Skill
+
+Use this skill when translating high-level business goals, user feedback, or feature requests into actionable, testable technical requirements.
+
+Workflow:
+1. Clarify Business Intent: Elicit the core user problem, business metrics, and target audience.
+2. Deconstruct User Journeys: Map end-to-end flows covering happy path, alternative paths, and error scenarios.
+3. Formulate Acceptance Criteria: Write precise, testable criteria using Gherkin syntax (Given [context], When [action], Then [outcome]).
+4. Identify Non-Functional Requirements: Specify performance targets, security rules, compliance, and accessibility standards.
+5. Surface Unknowns: Flag open questions, unconfirmed business logic, and potential edge cases before planning.
+
+Outputs:
+- Business requirements specification (REQUIREMENTS.md or section in SPEC.md)
+- User stories with Gherkin acceptance criteria
+- Domain entities & data dictionary definitions
+- Edge case checklist & business validation rules
+`;
+var webEngineeringSkill = `# Web Engineering Skill
+
+Use this skill when designing, implementing, or optimizing fullstack web applications, frontends, APIs, and modern web architectures.
+
+Workflow:
+1. Analyze Repository & Tech Stack: Inspect active frameworks (React, Next.js, Vue, Node.js, etc.), state stores, design systems, and package dependencies.
+2. Design Component & State Flow: Architect clean component boundaries, unidirectional data flow, server/client state segregation, and error boundaries.
+3. Specify API Contracts: Define type-safe request/response schemas (TypeScript, Zod, OpenAPI, GraphQL) and error handling codes.
+4. Enforce UX, Performance & Accessibility: Apply responsive layouts, Core Web Vitals optimizations (LCP, INP, CLS), keyboard navigation, and ARIA roles.
+5. Formulate Verification Matrix: Define unit tests (Vitest/Jest), component tests, and end-to-end integration scenarios (Playwright/Cypress).
+
+Outputs:
+- Web implementation plan (PLAN.md with web-specific phase breakdown)
+- Component hierarchy and data flow diagrams
+- API schema specifications and endpoint contracts
+- Performance, security, and accessibility verification checklist
+`;
+var mobileEngineeringSkill = `# Mobile Engineering Skill
+
+Use this skill when developing, refactoring, or optimizing native (iOS Swift, Android Kotlin) and cross-platform (Flutter, React Native) mobile applications.
+
+Workflow:
+1. Target Platform & Framework Audit: Inspect whether the app is Flutter, React Native, Swift/SwiftUI, or Kotlin/Jetpack Compose, plus target SDK versions.
+2. Design Navigation & State Hierarchy: Define screen stacks, tabs, modals, deep linking schemes, and application-wide state management.
+3. Architect Storage & Offline Capability: Specify local caching, SQLite / Room / CoreData / WatermelonDB schemas, and background sync strategies.
+4. Integrate Native Device Capabilities: Structure permission flows, push notifications, hardware access, and platform bridges/plugins defensively.
+5. Formulate Verification & Emulation Matrix: Specify unit tests, widget/component tests, and platform-specific simulator/device build commands.
+
+Outputs:
+- Mobile technical implementation plan
+- Screen navigation and state transition map
+- Local database schema and offline sync rules
+- Platform permission checklist and native configuration guidelines
+`;
+var gameEngineeringSkill = `# Game Engineering Skill
+
+Use this skill when developing, refactoring, or optimizing games across Unity, Godot, or Cocos Creator engines.
+
+Workflow:
+1. Engine & Architecture Assessment: Identify game engine (Unity C#, Godot GDScript/C#, Cocos Creator TypeScript), rendering pipeline, and target platforms (PC, Mobile, WebGL, Console).
+2. Gameplay Loops & Mechanics Design: Structure the primary game loop, player controllers, state machines, and event dispatchers.
+3. Scene, Node & Entity Architecture: Establish clean scene hierarchies, prefabs/nodes composition, and decouple gameplay logic from presentation.
+4. Physics, Collision & Input Integration: Configure collision layers/masks, rigid body properties, input action maps, and fixed-timestep calculations.
+5. Optimization & Performance Profiling: Audit hot loop allocations, draw call batching, texture atlases, object pooling, and target frame rate (60/120 FPS).
+
+Outputs:
+- Game architecture & mechanics implementation plan
+- Scene hierarchy and component relationship specification
+- Physics collision matrix and input mapping configuration
+- Object pooling and memory optimization checklist
+- Verification plan with deterministic math/logic tests and playtest criteria
+`;
+function runInit(options) {
+  const store = new WorkflowStore(options.root);
+  store.ensureBaseStructure();
+  const architecturePath = join5(store.workflowDir, "ARCHITECTURE.md");
+  const projectPath = join5(store.workflowDir, "PROJECT.md");
+  const decisionsPath = join5(store.workflowDir, "DECISIONS.md");
+  const agentsPath = join5(options.root, "AGENTS.md");
+  const codexDir = join5(options.root, ".codex");
+  const codexAgentsDir = join5(codexDir, "agents");
+  const codexSkillsDir = join5(codexDir, "skills");
+  const workerDir = join5(options.root, ".antigravity");
+  const workerPath = join5(workerDir, "WORKER_RULES.md");
+  mkdirSync2(codexDir, { recursive: true });
+  mkdirSync2(codexAgentsDir, { recursive: true });
+  mkdirSync2(codexSkillsDir, { recursive: true });
+  if (!existsSync7(workerDir)) {
+    mkdirSync2(workerDir, { recursive: true });
+    writeFileSync2(join5(workerDir, ".gitkeep"), "", "utf8");
+  }
+  writeIfMissing(projectPath, "# Project\n\nDescribe project-level goals and boundaries.\n", options.force);
+  writeIfMissing(
+    architecturePath,
+    "# Architecture\n\nDocument Codex brain, bridge, worker, state, and review loop architecture.\n",
+    options.force
+  );
+  writeIfMissing(decisionsPath, "# Decisions\n\nLog only material architectural/product decisions.\n", options.force);
+  writeIfMissing(join5(codexAgentsDir, "brainstormer.md"), brainstormAgent, options.force);
+  writeIfMissing(join5(codexAgentsDir, "planner.md"), plannerAgent, options.force);
+  writeIfMissing(join5(codexAgentsDir, "codex.md"), defaultCodexAgent, options.force);
+  writeIfMissing(join5(codexAgentsDir, "researcher.md"), researcherAgent, options.force);
+  writeIfMissing(join5(codexAgentsDir, "business-analyst.md"), businessAnalystAgent, options.force);
+  writeIfMissing(join5(codexAgentsDir, "web-engineer.md"), webEngineerAgent, options.force);
+  writeIfMissing(join5(codexAgentsDir, "mobile-engineer.md"), mobileEngineerAgent, options.force);
+  writeIfMissing(join5(codexAgentsDir, "game-engineer.md"), gameEngineerAgent, options.force);
+  writeIfMissing(join5(codexSkillsDir, "brainstorming.md"), brainstormingSkill, options.force);
+  writeIfMissing(join5(codexSkillsDir, "planning.md"), planningSkill, options.force);
+  writeIfMissing(join5(codexSkillsDir, "codex-workflow.md"), defaultCodexSkill, options.force);
+  writeIfMissing(join5(codexSkillsDir, "research.md"), researchSkill, options.force);
+  writeIfMissing(join5(codexSkillsDir, "requirements-analysis.md"), requirementsAnalysisSkill, options.force);
+  writeIfMissing(join5(codexSkillsDir, "web-engineering.md"), webEngineeringSkill, options.force);
+  writeIfMissing(join5(codexSkillsDir, "mobile-engineering.md"), mobileEngineeringSkill, options.force);
+  writeIfMissing(join5(codexSkillsDir, "game-engineering.md"), gameEngineeringSkill, options.force);
+  if (!existsSync7(store.statePath) || options.force) {
+    const state = defaultState();
+    state.state = "IDLE" /* IDLE */;
+    state.nextAction = "Start discovery for a feature request";
+    store.writeState(state);
+  }
+  if (!existsSync7(store.configPath) || options.force) {
+    store.writeConfig(defaultConfig);
+  }
+  writeIfMissing(agentsPath, defaultAgents, options.force);
+  writeIfMissing(workerPath, defaultWorkerRules, options.force);
+  console.log("Initialized codex-antigravity kit");
+  console.log(`Workflow dir: ${store.workflowDir}`);
+}
+function writeIfMissing(path, content, force) {
+  if (!existsSync7(path) || force) {
+    writeFileSync2(path, content, "utf8");
+    return;
+  }
+  const current = readFileSync6(path, "utf8");
+  if (current.trim().length === 0) {
+    writeFileSync2(path, content, "utf8");
+  }
+}
+
+// src/commands/plan.ts
+import { existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
+function runPlan(options) {
+  const store = new WorkflowStore(options.root);
+  store.ensureBaseStructure();
+  let spec = "";
+  if (options.spec && existsSync8(options.spec)) {
+    spec = readFileSync7(options.spec, "utf8");
+    store.writeTaskFile(options.task, "SPEC.md", spec);
+  } else if (store.hasTaskFile(options.task, "SPEC.md")) {
+    spec = store.readTaskFile(options.task, "SPEC.md");
+  } else {
+    spec = `# Task ${options.task}
+`;
+  }
+  const brainstormContent = store.hasTaskFile(options.task, "BRAINSTORM.md") ? store.readTaskFile(options.task, "BRAINSTORM.md") : "# Brainstorm\n\nRun brainstorm first.\n";
+  const agentResolution = detectAgent({
+    root: options.root,
+    content: `${spec}
+${brainstormContent}`,
+    explicitAgent: options.agent
+  });
+  console.log(`[Agent Router] Assigned: ${agentResolution.agent.name} (${agentResolution.agent.id})`);
+  console.log(`[Agent Router] Reason: ${agentResolution.reason}`);
+  const plan = buildPlanMarkdown(options.task, spec, brainstormContent, agentResolution);
+  store.writeTaskFile(options.task, "PLAN.md", plan);
+  const state = store.readState();
+  state.state = "BRAINSTORMING" /* BRAINSTORMING */;
+  state.state = "PLANNING" /* PLANNING */;
+  state.currentTask = options.task;
+  state.currentPhase = "planning";
+  state.nextAction = `Run execute command to implement work described in PLAN.md for task ${options.task}`;
+  state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  store.writeState(state);
+  console.log(plan);
+}
+function buildPlanMarkdown(task, spec, brainstorm, agentResolution) {
+  return [
+    "# Plan",
+    "",
+    `Task: ${task}`,
+    `Assigned Agent: ${agentResolution.agent.name} (${agentResolution.agent.id})`,
+    `Agent Selection: ${agentResolution.reason}`,
+    "",
+    "## Objective",
+    "Convert brainstorm into actionable phases and tasks.",
+    "",
+    "## Context",
+    brainstorm.trim(),
+    "",
+    "## Requirements",
+    spec.trim(),
+    "",
+    "## Phases",
+    "### Phase 1 \u2014 Scope and Contracts",
+    "- Confirm task boundaries",
+    "- Capture expected behavior",
+    "",
+    "### Phase 2 \u2014 Worker Execution",
+    "- Send spec to Antigravity",
+    "- Collect implementation result",
+    "",
+    "### Phase 3 \u2014 Review and Repair",
+    "- Codex reviews diff and output",
+    "- Produce repair request if needed",
+    "",
+    "## Acceptance Criteria",
+    "- Brainstorm artifact exists",
+    "- Plan artifact exists",
+    "- Execute artifact can be generated",
+    "- Workflow remains recoverable from disk",
+    "",
+    "## Verification",
+    "- npm test",
+    "- npm run build",
+    "- npx codex-antigravity-kit doctor",
+    ""
+  ].join("\n");
+}
+
+// src/core/repair-loop.ts
+var RepairLoop = class {
+  constructor(maxAttempts) {
+    this.maxAttempts = maxAttempts;
+    if (maxAttempts < 1) {
+      throw new Error("maxAttempts must be >= 1");
+    }
+  }
+  maxAttempts;
+  canRetry(currentAttempt) {
+    return currentAttempt < this.maxAttempts;
+  }
+  nextAttempt(currentAttempt) {
+    return currentAttempt + 1;
+  }
+  needsEscalation(currentAttempt) {
+    return !this.canRetry(currentAttempt);
+  }
+};
+
+// src/commands/review.ts
+import { readFileSync as readFileSync8 } from "fs";
+function runReview(options) {
+  const store = new WorkflowStore(options.root);
+  const state = store.readState();
+  const config = store.readConfig();
+  const loop = new RepairLoop(config.maxRepairAttempts);
+  const reviewContent = options.reviewFile ? readFileSync8(options.reviewFile, "utf8") : `# Review
+
+Outcome: ${options.outcome}
+`;
+  store.writeTaskFile(options.task, "REVIEW.md", reviewContent);
+  state.currentTask = options.task;
+  state.reviewAttempt += 1;
+  if (options.outcome === "PASS") {
+    state.state = "COMPLETED" /* COMPLETED */;
+    state.nextAction = "Task completed. Return to IDLE when ready.";
+    state.blockingIssues = [];
+  } else if (options.outcome === "BLOCKED") {
+    state.state = "ESCALATION_REQUIRED" /* ESCALATION_REQUIRED */;
+    state.nextAction = "Escalate blocking issue to user";
+    state.blockingIssues = ["Reviewer marked task as BLOCKED"];
+  } else {
+    state.repairAttempt += 1;
+    if (loop.needsEscalation(state.repairAttempt)) {
+      state.state = "ESCALATION_REQUIRED" /* ESCALATION_REQUIRED */;
+      state.nextAction = "Repair attempts exceeded limit. Escalate to user.";
+      state.blockingIssues = [
+        `Max repair attempts exceeded (${config.maxRepairAttempts})`
+      ];
+    } else {
+      state.state = "REPAIR_REQUIRED" /* REPAIR_REQUIRED */;
+      state.nextAction = "Prepare targeted repair request and delegate again";
+      state.blockingIssues = [];
+    }
+  }
+  state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  store.writeState(state);
+  console.log(`Review outcome recorded: ${options.outcome}`);
+  console.log(`State is now: ${state.state}`);
+}
+
+// src/commands/status.ts
+function runStatus(options) {
+  const store = new WorkflowStore(options.root);
+  const state = store.readState();
+  console.log("Current workflow status");
+  console.log(`State: ${state.state}`);
+  console.log(`Current phase: ${state.currentPhase}`);
+  console.log(`Current task: ${state.currentTask}`);
+  console.log(`Review attempt: ${state.reviewAttempt}`);
+  console.log(`Repair attempt: ${state.repairAttempt}`);
+  console.log(`Next action: ${state.nextAction}`);
+  console.log(`Updated at: ${state.updatedAt}`);
+  if (state.blockingIssues.length > 0) {
+    console.log("Blocking issues:");
+    for (const issue of state.blockingIssues) {
+      console.log(`- ${issue}`);
+    }
+  }
+}
+
+export {
+  KNOWN_AGENTS,
+  detectAgent,
+  WorkflowState,
+  canTransition,
+  transitionOrThrow,
+  WorkflowStore,
+  defaultState,
+  runBrainstorm,
+  ShellAgyAdapter,
+  parseWorkerResult,
+  runExecute,
+  runExecuteWithAdapter,
+  runDelegate,
+  runDelegateWithAdapter,
+  runDoctor,
+  runInit,
+  runPlan,
+  RepairLoop,
+  runReview,
+  runStatus
+};