@swarmcraftai/cli 0.1.0

package/dist/main.cjs

@@ -0,0 +1,4312 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../packages/packet-workflow/dist/assistantActions.js
+var require_assistantActions = __commonJS({
+  "../../packages/packet-workflow/dist/assistantActions.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.SWARMCRAFT_ASSISTANT_ACTIONS = exports2.SWARMCRAFT_DIAGNOSTIC_WORKFLOWS = exports2.SWARMCRAFT_ASSISTANT_WORKFLOW_POLICY = void 0;
+    exports2.getSwarmCraftAssistantAction = getSwarmCraftAssistantAction;
+    exports2.getStageAssistantActions = getStageAssistantActions;
+    exports2.renderAssistantActionAdapterMetadata = renderAssistantActionAdapterMetadata;
+    exports2.listAssistantActionAdapterMetadata = listAssistantActionAdapterMetadata;
+    exports2.findMissingAssistantActionAdapters = findMissingAssistantActionAdapters;
+    exports2.SWARMCRAFT_ASSISTANT_WORKFLOW_POLICY = {
+      roleAgents: "optional-secondary",
+      diagnostics: "internal-support-or-advanced-only",
+      copilotCommandStyle: "slash-command"
+    };
+    exports2.SWARMCRAFT_DIAGNOSTIC_WORKFLOWS = [
+      "packet-sync-triage",
+      "repo-seed-audit"
+    ];
+    exports2.SWARMCRAFT_ASSISTANT_ACTIONS = [
+      {
+        key: "plan",
+        kind: "planning",
+        laneBound: false,
+        description: "Create a new plan or ticket from inside the repo, or check an existing plan for stale or incoherent scope.",
+        packetEffect: "Creates or revises planning artifacts; may create a provisional todo packet for sync promotion.",
+        copilotPromptPath: ".github/prompts/plan.prompt.md",
+        copilotSkillPath: ".github/skills/swarmcraft-plan/SKILL.md",
+        copilotInvocation: "/plan",
+        codexSkillPath: ".agents/skills/swarmcraft-plan/SKILL.md",
+        codexInvocation: "$swarmcraft-plan"
+      },
+      {
+        key: "do",
+        kind: "stage",
+        stageKey: "doing",
+        laneBound: true,
+        description: "Implement scoped packet work.",
+        packetEffect: "Existing doing packet may move to checking.",
+        copilotPromptPath: ".github/prompts/do.prompt.md",
+        copilotSkillPath: ".github/skills/swarmcraft-do/SKILL.md",
+        copilotInvocation: "/do ticket=<packet-path>",
+        codexSkillPath: ".agents/skills/swarmcraft-do/SKILL.md",
+        codexInvocation: "$swarmcraft-do ticket=<packet-path>"
+      },
+      {
+        key: "check",
+        kind: "stage",
+        stageKey: "checking",
+        laneBound: true,
+        description: "Validate implementation evidence.",
+        packetEffect: "Existing checking packet may move to reviewing or back to doing.",
+        copilotPromptPath: ".github/prompts/check.prompt.md",
+        copilotSkillPath: ".github/skills/swarmcraft-check/SKILL.md",
+        copilotInvocation: "/check ticket=<packet-path>",
+        codexSkillPath: ".agents/skills/swarmcraft-check/SKILL.md",
+        codexInvocation: "$swarmcraft-check ticket=<packet-path>"
+      },
+      {
+        key: "review",
+        kind: "stage",
+        stageKey: "reviewing",
+        laneBound: true,
+        description: "Record human approval decisions.",
+        packetEffect: "Existing reviewing packet remains ready for extension-owned done movement.",
+        copilotPromptPath: ".github/prompts/review.prompt.md",
+        copilotSkillPath: ".github/skills/swarmcraft-review/SKILL.md",
+        copilotInvocation: "/review ticket=<packet-path>",
+        codexSkillPath: ".agents/skills/swarmcraft-review/SKILL.md",
+        codexInvocation: "$swarmcraft-review ticket=<packet-path>"
+      },
+      {
+        key: "test",
+        kind: "testing",
+        laneBound: false,
+        description: "Add or run system testing coverage.",
+        packetEffect: "Records test evidence on an existing packet or creates a testing-focused todo packet.",
+        copilotPromptPath: ".github/prompts/test.prompt.md",
+        copilotSkillPath: ".github/skills/swarmcraft-test/SKILL.md",
+        copilotInvocation: "/test",
+        codexSkillPath: ".agents/skills/swarmcraft-test/SKILL.md",
+        codexInvocation: "$swarmcraft-test"
+      }
+    ];
+    function getSwarmCraftAssistantAction(actionKey) {
+      const action = exports2.SWARMCRAFT_ASSISTANT_ACTIONS.find((candidate) => candidate.key === actionKey);
+      if (!action) {
+        throw new Error(`Unknown SwarmCraft assistant action: ${actionKey}`);
+      }
+      return action;
+    }
+    function getStageAssistantActions() {
+      return exports2.SWARMCRAFT_ASSISTANT_ACTIONS.filter((action) => action.kind === "stage");
+    }
+    function renderAssistantActionAdapterMetadata(provider, action) {
+      if (provider === "copilot") {
+        return {
+          provider,
+          action: action.key,
+          relativePath: action.copilotPromptPath,
+          invocation: action.copilotInvocation,
+          skillPath: action.copilotSkillPath,
+          promptPath: action.copilotPromptPath
+        };
+      }
+      return {
+        provider,
+        action: action.key,
+        relativePath: action.codexSkillPath,
+        invocation: action.codexInvocation,
+        skillPath: action.codexSkillPath
+      };
+    }
+    function listAssistantActionAdapterMetadata(expectedProviders = ["copilot", "codex"], expectedActions = exports2.SWARMCRAFT_ASSISTANT_ACTIONS) {
+      return expectedProviders.flatMap((provider) => expectedActions.map((action) => renderAssistantActionAdapterMetadata(provider, action)));
+    }
+    function findMissingAssistantActionAdapters(expectedProviders, adapters, expectedActions = exports2.SWARMCRAFT_ASSISTANT_ACTIONS) {
+      const missing = [];
+      for (const provider of expectedProviders) {
+        const providerAdapters = adapters.filter((adapter) => adapter.provider === provider);
+        for (const action of expectedActions) {
+          const hasAdapter = providerAdapters.some((adapter) => adapter.action === action.key);
+          if (!hasAdapter) {
+            missing.push(`${provider} is missing ${action.key} action adapter`);
+          }
+        }
+      }
+      return missing;
+    }
+  }
+});
+
+// ../../packages/packet-workflow/dist/agentProviders.js
+var require_agentProviders = __commonJS({
+  "../../packages/packet-workflow/dist/agentProviders.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.EXTERNAL_AGENT_PROVIDER_DEFAULTS = exports2.DEFAULT_EXTERNAL_AGENT_PROVIDER = exports2.EXTERNAL_AGENT_PROVIDERS = void 0;
+    exports2.parseExternalAgentProvider = parseExternalAgentProvider2;
+    exports2.resolveExternalAgentProviderDefault = resolveExternalAgentProviderDefault2;
+    exports2.applyExternalAgentProviderDefault = applyExternalAgentProviderDefault;
+    exports2.resolveExternalAgentSandboxMode = resolveExternalAgentSandboxMode2;
+    exports2.resolveExternalAgentApprovalPosture = resolveExternalAgentApprovalPosture2;
+    exports2.EXTERNAL_AGENT_PROVIDERS = ["codex", "copilot", "custom"];
+    exports2.DEFAULT_EXTERNAL_AGENT_PROVIDER = "custom";
+    exports2.EXTERNAL_AGENT_PROVIDER_DEFAULTS = {
+      codex: {
+        command: "codex exec --sandbox workspace-write {command}",
+        sandboxMode: "workspace-write",
+        approvalPosture: "codex-config"
+      },
+      copilot: {
+        command: "copilot --allow-all-tools --no-ask-user -p {command}",
+        sandboxMode: "local-cli-default",
+        approvalPosture: "allow-all-tools,no-ask-user"
+      }
+    };
+    function parseExternalAgentProvider2(rawValue) {
+      if (exports2.EXTERNAL_AGENT_PROVIDERS.includes(rawValue)) {
+        return rawValue;
+      }
+      throw new Error("--agent-provider must be codex, copilot, or custom.");
+    }
+    function resolveExternalAgentProviderDefault2(provider) {
+      return exports2.EXTERNAL_AGENT_PROVIDER_DEFAULTS[provider] ?? null;
+    }
+    function applyExternalAgentProviderDefault(parsed) {
+      if (parsed.agentMode !== "externalCommand" || parsed.agentCommand) {
+        return;
+      }
+      const providerDefault = resolveExternalAgentProviderDefault2(parsed.agentProvider);
+      if (providerDefault) {
+        parsed.agentCommand = providerDefault.command;
+        parsed.agentCommandSource = "provider-default";
+      }
+    }
+    function resolveExternalAgentSandboxMode2(parsedArgs) {
+      if (parsedArgs.agentMode !== "externalCommand") {
+        return null;
+      }
+      const providerDefault = resolveExternalAgentProviderDefault2(parsedArgs.agentProvider);
+      if (parsedArgs.agentCommandSource === "provider-default" && providerDefault) {
+        return providerDefault.sandboxMode;
+      }
+      if (parsedArgs.agentProvider === "codex") {
+        const match = parsedArgs.agentCommand?.match(/--sandbox\s+([^\s]+)/);
+        return match ? match[1] : "codex-config";
+      }
+      if (parsedArgs.agentProvider === "copilot") {
+        return "local-cli-default";
+      }
+      return null;
+    }
+    function resolveExternalAgentApprovalPosture2(parsedArgs) {
+      if (parsedArgs.agentMode !== "externalCommand") {
+        return null;
+      }
+      const providerDefault = resolveExternalAgentProviderDefault2(parsedArgs.agentProvider);
+      if (parsedArgs.agentCommandSource === "provider-default" && providerDefault) {
+        return providerDefault.approvalPosture;
+      }
+      const command = parsedArgs.agentCommand ?? "";
+      if (parsedArgs.agentProvider === "codex") {
+        return command.includes("--dangerously-bypass-approvals-and-sandbox") ? "bypass-approvals-and-sandbox" : "codex-config";
+      }
+      if (parsedArgs.agentProvider === "copilot") {
+        return command.includes("--allow-all") || command.includes("--yolo") ? "allow-all" : "copilot-config";
+      }
+      return null;
+    }
+  }
+});
+
+// ../../packages/packet-workflow/dist/manifest.js
+var require_manifest = __commonJS({
+  "../../packages/packet-workflow/dist/manifest.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.buildPreviousDoneTicketMap = buildPreviousDoneTicketMap;
+    exports2.countCompletedStages = countCompletedStages;
+    exports2.resolveWorkflowRunStatus = resolveWorkflowRunStatus;
+    exports2.summarizeWorkflowRunDurations = summarizeWorkflowRunDurations2;
+    exports2.computeElapsedMs = computeElapsedMs2;
+    exports2.sumNumbers = sumNumbers;
+    exports2.averageNumber = averageNumber;
+    function buildPreviousDoneTicketMap(previousManifest) {
+      const tickets = Array.isArray(previousManifest?.tickets) ? previousManifest.tickets : [];
+      return new Map(tickets.filter((ticket) => Boolean(ticket?.ticketId) && ticket.outcome === "done").map((ticket) => [ticket.ticketId, ticket]));
+    }
+    function countCompletedStages(ticketOutcome) {
+      const stages = Array.isArray(ticketOutcome?.stages) ? ticketOutcome.stages : [];
+      return stages.filter((stage) => stage?.result && stage.result !== "pending").length;
+    }
+    function resolveWorkflowRunStatus(manifest, options = {}) {
+      const tickets = Array.isArray(manifest.tickets) ? manifest.tickets : [];
+      if (tickets.some((ticket) => String(ticket.outcome ?? "").startsWith("blocked"))) {
+        return "blocked";
+      }
+      if (options.reviewing && tickets.some((ticket) => ticket.outcome === "manual-review-required")) {
+        return "manual-review-required";
+      }
+      return "success";
+    }
+    function summarizeWorkflowRunDurations2(manifest) {
+      const tickets = Array.isArray(manifest.tickets) ? manifest.tickets : [];
+      const ticketDurations = tickets.map((ticket) => computeElapsedMs2(ticket.startedAt, ticket.finishedAt)).filter((value) => value !== null);
+      const stageDurations = tickets.flatMap((ticket) => Array.isArray(ticket.stages) ? ticket.stages : []).map((stage) => computeElapsedMs2(stage.startedAt, stage.finishedAt)).filter((value) => value !== null);
+      return {
+        elapsedMs: computeElapsedMs2(manifest.generatedAt, manifest.finishedAt),
+        ticketCount: tickets.length,
+        totalTicketMs: sumNumbers(ticketDurations),
+        totalStageMs: sumNumbers(stageDurations),
+        averageTicketMs: averageNumber(ticketDurations),
+        averageStageMs: averageNumber(stageDurations)
+      };
+    }
+    function computeElapsedMs2(startedAt, finishedAt) {
+      if (!startedAt || !finishedAt) {
+        return null;
+      }
+      const elapsedMs = Date.parse(finishedAt) - Date.parse(startedAt);
+      return Number.isFinite(elapsedMs) ? Math.max(0, elapsedMs) : null;
+    }
+    function sumNumbers(values) {
+      return values.reduce((total, value) => total + Number(value || 0), 0);
+    }
+    function averageNumber(values) {
+      if (values.length === 0) {
+        return null;
+      }
+      return Math.round(sumNumbers(values) / values.length);
+    }
+  }
+});
+
+// ../../packages/packet-workflow/dist/packetFile.js
+var require_packetFile = __commonJS({
+  "../../packages/packet-workflow/dist/packetFile.js"(exports2) {
+    "use strict";
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.PacketFileContractError = exports2.PROVISIONAL_TICKET_ID_PREFIX = exports2.PACKET_FILE_ROOT = exports2.WORKFLOW_STATES = exports2.CHECKLIST_STAGES = void 0;
+    exports2.renderPacketFile = renderPacketFile2;
+    exports2.renderProvisionalPacketFile = renderProvisionalPacketFile;
+    exports2.renderChecklistSection = renderChecklistSection;
+    exports2.resolvePacketFilePath = resolvePacketFilePath3;
+    exports2.parsePacketFile = parsePacketFile3;
+    exports2.rewritePacketFileMetadata = rewritePacketFileMetadata3;
+    exports2.rewriteProvisionalPacketFileMetadata = rewriteProvisionalPacketFileMetadata;
+    exports2.rewritePacketFile = rewritePacketFile;
+    exports2.markChecklistStageComplete = markChecklistStageComplete;
+    exports2.appendAgentUpdateLines = appendAgentUpdateLines;
+    exports2.composeTicketNotes = composeTicketNotes2;
+    exports2.ensurePacketFileIdentity = ensurePacketFileIdentity2;
+    exports2.ensurePacketMatches = ensurePacketMatches;
+    exports2.isProvisionalPacketFile = isProvisionalPacketFile;
+    exports2.assertProvisionalPacketFile = assertProvisionalPacketFile;
+    exports2.findChecklistShapeProblem = findChecklistShapeProblem2;
+    exports2.assertChecklistShape = assertChecklistShape;
+    exports2.listChecklistItemsForStage = listChecklistItemsForStage2;
+    exports2.allChecklistItemsComplete = allChecklistItemsComplete2;
+    exports2.splitStoredTicketNotes = splitStoredTicketNotes;
+    exports2.normalizeSectionText = normalizeSectionText;
+    exports2.previewText = previewText;
+    exports2.slugify = slugify;
+    var node_path_1 = __importDefault(require("node:path"));
+    exports2.CHECKLIST_STAGES = ["doing", "checking", "reviewing"];
+    exports2.WORKFLOW_STATES = ["todo", "doing", "checking", "reviewing", "done"];
+    exports2.PACKET_FILE_ROOT = ".swarmcraft/projects/";
+    exports2.PROVISIONAL_TICKET_ID_PREFIX = "provisional:";
+    var PacketFileContractError2 = class extends Error {
+      code;
+      constructor(code, message) {
+        super(message);
+        this.name = "PacketFileContractError";
+        this.code = code;
+      }
+    };
+    exports2.PacketFileContractError = PacketFileContractError2;
+    function renderPacketFile2(project, ticket, syncedAt, existingContents = null) {
+      const storedSections = existingContents ? parsePacketFile3(existingContents).sections : splitStoredTicketNotes(ticket.notes ?? null);
+      const goal = ticket.summary?.trim() ? ticket.summary.trim() : "Describe the outcome in one short paragraph.";
+      return [
+        "---",
+        "swarmcraftVersion: 1",
+        `projectId: ${project.id}`,
+        `ticketId: ${ticket.id}`,
+        `title: ${escapeFrontmatterValue(ticket.title ?? "")}`,
+        `lane: ${ticket.workflowState}`,
+        `syncRevision: ${ticket.revision}`,
+        `lastSyncedAt: ${syncedAt}`,
+        "---",
+        "",
+        "## Goal",
+        "",
+        goal,
+        "",
+        "## Doing Checklist",
+        "",
+        renderChecklistSection(ticket, "doing"),
+        "",
+        "## Checking Checklist",
+        "",
+        renderChecklistSection(ticket, "checking"),
+        "",
+        "## Reviewing Checklist",
+        "",
+        renderChecklistSection(ticket, "reviewing"),
+        "",
+        "## Notes",
+        "",
+        storedSections.notes ?? "",
+        "",
+        "## Agent Update",
+        "",
+        storedSections.agentUpdate || "<!-- Short structured summary of what changed, what is blocked, and what still needs review. -->",
+        ""
+      ].join("\n");
+    }
+    function renderProvisionalPacketFile(input2) {
+      const title = input2.title.trim();
+      const provisionalTicketId = input2.provisionalTicketId?.trim() || `${exports2.PROVISIONAL_TICKET_ID_PREFIX}${slugify(title)}`;
+      return [
+        "---",
+        "swarmcraftVersion: 1",
+        `projectId: ${input2.projectId}`,
+        `ticketId: ${provisionalTicketId}`,
+        `title: ${escapeFrontmatterValue(title)}`,
+        "lane: todo",
+        "syncRevision: 0",
+        "lastSyncedAt: null",
+        "provisional: true",
+        "---",
+        "",
+        "## Goal",
+        "",
+        input2.goal.trim() || "Describe the outcome in one short paragraph.",
+        "",
+        "## Doing Checklist",
+        "",
+        renderProvisionalChecklist(input2.checklists.doing),
+        "",
+        "## Checking Checklist",
+        "",
+        renderProvisionalChecklist(input2.checklists.checking),
+        "",
+        "## Reviewing Checklist",
+        "",
+        renderProvisionalChecklist(input2.checklists.reviewing),
+        "",
+        "## Notes",
+        "",
+        input2.notes?.trim() ?? "",
+        "",
+        "## Agent Update",
+        "",
+        input2.agentUpdate?.trim() || "<!-- Short structured summary of what changed, what is blocked, and what still needs review. -->",
+        ""
+      ].join("\n");
+    }
+    function renderChecklistSection(ticket, checklistStage) {
+      const checklistItems = listChecklistItemsForStage2(ticket.checklistItems, checklistStage);
+      if (checklistItems.length === 0) {
+        return `<!-- No ${checklistStage} checklist items yet. Add or sync them from SwarmCraft. -->`;
+      }
+      return checklistItems.map((item) => `- [${item.completed ? "x" : " "}] ${item.body}`).join("\n");
+    }
+    function renderProvisionalChecklist(items) {
+      const normalizedItems = (items ?? []).map((item) => item.trim()).filter(Boolean);
+      if (normalizedItems.length === 0) {
+        return "<!-- Add checklist items before syncing this provisional packet. -->";
+      }
+      return normalizedItems.map((item) => `- [ ] ${item}`).join("\n");
+    }
+    function resolvePacketFilePath3(project, ticket, packetLink = ticket.packetLink) {
+      if (packetLink) {
+        return packetLink.packetFilePath;
+      }
+      return node_path_1.default.posix.join(".swarmcraft", "projects", slugify(project.title || project.projectTitle || project.id), `${ticket.recommendedOrder}-${slugify(ticket.title || "ticket")}.md`);
+    }
+    function parsePacketFile3(contents) {
+      const { frontmatter, body } = parsePacketFileDocument(contents);
+      const sections = parseSections(body);
+      const requiredSections = ["Goal", "Notes", "Agent Update"];
+      for (const section of requiredSections) {
+        if (!(section in sections)) {
+          throw new PacketFileContractError2("PACKET_FILE_MALFORMED", `The packet file is missing the required ${section} section.`);
+        }
+      }
+      const lane = parseLane(frontmatter.lane);
+      const syncRevision = Number.parseInt(frontmatter.syncRevision ?? "", 10);
+      if (!Number.isInteger(syncRevision) || syncRevision < 0) {
+        throw new PacketFileContractError2("PACKET_FILE_MALFORMED", "The packet file is missing a valid syncRevision frontmatter value.");
+      }
+      const swarmcraftVersion = Number.parseInt(frontmatter.swarmcraftVersion ?? "", 10);
+      if (!Number.isInteger(swarmcraftVersion) || swarmcraftVersion !== 1) {
+        throw new PacketFileContractError2("PACKET_FILE_MALFORMED", "The packet file must declare swarmcraftVersion: 1.");
+      }
+      return {
+        frontmatter: {
+          swarmcraftVersion,
+          projectId: requireFrontmatterValue(frontmatter.projectId, "projectId"),
+          ticketId: requireFrontmatterValue(frontmatter.ticketId, "ticketId"),
+          title: frontmatter.title ?? null,
+          lane,
+          syncRevision,
+          lastSyncedAt: parseNullableFrontmatterValue(frontmatter.lastSyncedAt),
+          provisional: parseBooleanFrontmatterValue(frontmatter.provisional)
+        },
+        sections: {
+          goal: normalizeSectionText(sections.Goal ?? ""),
+          checklists: parseChecklistSections(sections),
+          notes: normalizeSectionText(sections.Notes ?? ""),
+          agentUpdate: normalizeSectionText(sections["Agent Update"] ?? "")
+        }
+      };
+    }
+    function rewritePacketFileMetadata3(contents, metadata) {
+      const { frontmatterLines, body } = parsePacketFileDocument(contents);
+      const updatedFrontmatter = new Map(frontmatterLines.map((line) => {
+        const separatorIndex = line.indexOf(":");
+        return [line.slice(0, separatorIndex).trim(), line.slice(separatorIndex + 1).trim()];
+      }));
+      updatedFrontmatter.set("lane", metadata.lane);
+      updatedFrontmatter.set("syncRevision", String(metadata.syncRevision));
+      updatedFrontmatter.set("lastSyncedAt", metadata.lastSyncedAt);
+      const orderedKeys = ["swarmcraftVersion", "projectId", "ticketId", "title", "lane", "syncRevision", "lastSyncedAt", "provisional"];
+      const rewrittenFrontmatter = orderedKeys.filter((key) => updatedFrontmatter.has(key)).map((key) => `${key}: ${updatedFrontmatter.get(key)}`).join("\n");
+      return `---
+${rewrittenFrontmatter}
+---
+${body.startsWith("\n") ? body : `
+${body}`}`;
+    }
+    function rewriteProvisionalPacketFileMetadata(contents, metadata) {
+      const { frontmatterLines, body } = parsePacketFileDocument(contents);
+      const updatedFrontmatter = new Map(frontmatterLines.map((line) => {
+        const separatorIndex = line.indexOf(":");
+        return [line.slice(0, separatorIndex).trim(), line.slice(separatorIndex + 1).trim()];
+      }));
+      updatedFrontmatter.set("ticketId", metadata.ticketId);
+      updatedFrontmatter.set("title", escapeFrontmatterValue(metadata.title));
+      updatedFrontmatter.set("lane", metadata.lane);
+      updatedFrontmatter.set("syncRevision", String(metadata.syncRevision));
+      updatedFrontmatter.set("lastSyncedAt", metadata.lastSyncedAt);
+      updatedFrontmatter.delete("provisional");
+      const orderedKeys = ["swarmcraftVersion", "projectId", "ticketId", "title", "lane", "syncRevision", "lastSyncedAt"];
+      const rewrittenFrontmatter = orderedKeys.filter((key) => updatedFrontmatter.has(key)).map((key) => `${key}: ${updatedFrontmatter.get(key)}`).join("\n");
+      return `---
+${rewrittenFrontmatter}
+---
+${body.startsWith("\n") ? body : `
+${body}`}`;
+    }
+    function rewritePacketFile(input2) {
+      let rewritten = rewritePacketFileMetadata3(input2.contents, {
+        lane: input2.lane,
+        syncRevision: parsePacketFile3(input2.contents).frontmatter.syncRevision,
+        lastSyncedAt: input2.syncedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+      });
+      rewritten = markChecklistStageComplete(rewritten, input2.completeStage);
+      return appendAgentUpdateLines(rewritten, input2.agentUpdateLines);
+    }
+    function markChecklistStageComplete(contents, checklistStage) {
+      const heading = checklistSectionHeading(checklistStage);
+      const sectionPattern = new RegExp(`(## ${escapeRegExp(heading)}\\n\\n)([\\s\\S]*?)(?=\\n## |$)`);
+      return contents.replace(sectionPattern, (_match, prefix, body) => {
+        const updatedBody = body.split("\n").map((line) => line.replace(/^- \[ \] /, "- [x] ")).join("\n");
+        return `${prefix}${updatedBody}`;
+      });
+    }
+    function appendAgentUpdateLines(contents, lines) {
+      if (lines.length === 0) {
+        return contents;
+      }
+      const sectionPattern = /(## Agent Update\n\n)([\s\S]*?)$/;
+      return contents.replace(sectionPattern, (_match, prefix, body) => {
+        const normalizedBody = normalizeSectionText(body);
+        return `${prefix}${[normalizedBody, ...lines].filter(Boolean).join("\n")}
+`;
+      });
+    }
+    function composeTicketNotes2(notes, agentUpdate) {
+      const normalizedNotes = normalizeSectionText(notes);
+      const normalizedAgentUpdate = normalizeSectionText(agentUpdate);
+      if (!normalizedNotes && !normalizedAgentUpdate) {
+        return null;
+      }
+      if (normalizedNotes && !normalizedAgentUpdate) {
+        return normalizedNotes;
+      }
+      if (!normalizedNotes && normalizedAgentUpdate) {
+        return ["## Agent Update", "", normalizedAgentUpdate].join("\n");
+      }
+      return ["## Notes", "", normalizedNotes, "", "## Agent Update", "", normalizedAgentUpdate].join("\n");
+    }
+    function ensurePacketFileIdentity2(contents, projectId, ticketId) {
+      const { frontmatter } = parsePacketFileDocument(contents);
+      if (frontmatter.projectId !== projectId || frontmatter.ticketId !== ticketId) {
+        throw new PacketFileContractError2("PACKET_FILE_MISMATCH", `The existing packet file is linked to ${frontmatter.ticketId ?? "another ticket"} and cannot be reused for ${ticketId}.`);
+      }
+    }
+    function ensurePacketMatches(packet, projectId, ticketId) {
+      if (packet.frontmatter.projectId !== projectId || packet.frontmatter.ticketId !== ticketId) {
+        throw new PacketFileContractError2("PACKET_FILE_MISMATCH", `The packet file belongs to ${packet.frontmatter.ticketId} and cannot sync into ${ticketId}.`);
+      }
+    }
+    function isProvisionalPacketFile(packet) {
+      return packet.frontmatter.provisional && packet.frontmatter.ticketId.startsWith(exports2.PROVISIONAL_TICKET_ID_PREFIX) && packet.frontmatter.lane === "todo" && packet.frontmatter.syncRevision === 0;
+    }
+    function assertProvisionalPacketFile(packet) {
+      if (!isProvisionalPacketFile(packet)) {
+        throw new PacketFileContractError2("PACKET_FILE_MALFORMED", "Provisional packets must use provisional: true, ticketId: provisional:<slug>, lane: todo, and syncRevision: 0.");
+      }
+      const title = packet.frontmatter.title?.trim();
+      if (!title) {
+        throw new PacketFileContractError2("PACKET_FILE_MALFORMED", "Provisional packets must include a title frontmatter value.");
+      }
+      if (!packet.sections.goal.trim()) {
+        throw new PacketFileContractError2("PACKET_FILE_MALFORMED", "Provisional packets must include a Goal section.");
+      }
+      for (const checklistStage of exports2.CHECKLIST_STAGES) {
+        for (const checklistItem of packet.sections.checklists[checklistStage]) {
+          if (checklistItem.completed) {
+            throw new PacketFileContractError2("PACKET_FILE_MALFORMED", "Provisional packet checklist items must start unchecked.");
+          }
+        }
+      }
+    }
+    function findChecklistShapeProblem2(currentChecklistItems, parsedChecklistItemsByStage) {
+      for (const checklistStage of exports2.CHECKLIST_STAGES) {
+        const orderedChecklistItems = listChecklistItemsForStage2(currentChecklistItems, checklistStage);
+        const parsedChecklistItems = parsedChecklistItemsByStage[checklistStage];
+        if (orderedChecklistItems.length !== parsedChecklistItems.length) {
+          return {
+            code: "length",
+            checklistStage,
+            message: "Checklist item additions, removals, or reordering are not supported from the packet file yet."
+          };
+        }
+        for (const [index, checklistItem] of orderedChecklistItems.entries()) {
+          if (checklistItem.body.trim() !== parsedChecklistItems[index]?.body.trim()) {
+            return {
+              code: "body",
+              checklistStage,
+              message: "Checklist item text edits are not supported from the packet file yet. Only checkbox completion can sync back to SwarmCraft."
+            };
+          }
+        }
+      }
+      return null;
+    }
+    function assertChecklistShape(currentChecklistItems, parsedChecklistItemsByStage) {
+      const problem = findChecklistShapeProblem2(currentChecklistItems, parsedChecklistItemsByStage);
+      if (problem) {
+        throw new PacketFileContractError2("PACKET_FILE_UNSUPPORTED_CHECKLIST", problem.message);
+      }
+    }
+    function listChecklistItemsForStage2(checklistItems, checklistStage) {
+      return checklistItems.filter((item) => item.checklistStage === checklistStage).slice().sort((left, right) => Number(left.itemOrder ?? 0) - Number(right.itemOrder ?? 0));
+    }
+    function allChecklistItemsComplete2(ticket, checklistStage) {
+      const items = listChecklistItemsForStage2(ticket.checklistItems, checklistStage);
+      return items.length === 0 || items.every((item) => item.completed);
+    }
+    function splitStoredTicketNotes(storedNotes) {
+      if (!storedNotes?.trim()) {
+        return { notes: "", agentUpdate: "" };
+      }
+      if (!storedNotes.includes("##")) {
+        return { notes: storedNotes.trim(), agentUpdate: "" };
+      }
+      const sections = parseSections(storedNotes);
+      return {
+        notes: normalizeSectionText(sections.Notes ?? storedNotes),
+        agentUpdate: normalizeSectionText(sections["Agent Update"] ?? "")
+      };
+    }
+    function normalizeSectionText(value) {
+      return String(value ?? "").split("\n").map((line) => line.trimEnd()).filter((line) => !isHtmlComment(line.trim())).join("\n").trim();
+    }
+    function previewText(value) {
+      const normalized = normalizeSectionText(value).replace(/\s+/g, " ").trim();
+      if (!normalized) {
+        return null;
+      }
+      return normalized.length > 240 ? `${normalized.slice(0, 237)}...` : normalized;
+    }
+    function slugify(value) {
+      return String(value).normalize("NFKD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "packet";
+    }
+    function parsePacketFileDocument(contents) {
+      const match = contents.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+      if (!match) {
+        throw new PacketFileContractError2("PACKET_FILE_MALFORMED", "The packet file is missing SwarmCraft frontmatter.");
+      }
+      const frontmatterBlock = match[1] ?? "";
+      return {
+        frontmatter: parseFrontmatterEntries(frontmatterBlock),
+        frontmatterLines: frontmatterBlock.split("\n").map((line) => line.trim()).filter(Boolean),
+        body: match[2] ?? ""
+      };
+    }
+    function parseFrontmatterEntries(frontmatterBlock) {
+      const entries = frontmatterBlock.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => {
+        const separatorIndex = line.indexOf(":");
+        if (separatorIndex < 0) {
+          return null;
+        }
+        const key = line.slice(0, separatorIndex).trim();
+        const value = parseFrontmatterValue(line.slice(separatorIndex + 1).trim());
+        return [key, value];
+      }).filter((entry) => entry !== null);
+      return Object.fromEntries(entries);
+    }
+    function parseFrontmatterValue(value) {
+      if (value.startsWith('"') && value.endsWith('"')) {
+        try {
+          return JSON.parse(value);
+        } catch {
+          return value.replace(/^"|"$/g, "");
+        }
+      }
+      return value;
+    }
+    function parseNullableFrontmatterValue(value) {
+      if (!value || value === "null") {
+        return null;
+      }
+      return value;
+    }
+    function parseBooleanFrontmatterValue(value) {
+      return value === "true";
+    }
+    function parseSections(body) {
+      const sections = {};
+      let currentSection = null;
+      const sectionLines = /* @__PURE__ */ new Map();
+      for (const line of body.split("\n")) {
+        const headingMatch = line.match(/^##\s+(.+?)\s*$/);
+        if (headingMatch) {
+          currentSection = headingMatch[1];
+          sectionLines.set(currentSection, []);
+          continue;
+        }
+        if (currentSection) {
+          sectionLines.get(currentSection)?.push(line);
+        }
+      }
+      for (const [section, lines] of sectionLines.entries()) {
+        sections[section] = lines.join("\n").trim();
+      }
+      return sections;
+    }
+    function parseChecklistSections(sections) {
+      const hasStagedChecklistSections = exports2.CHECKLIST_STAGES.some((checklistStage) => checklistSectionHeading(checklistStage) in sections);
+      if (!hasStagedChecklistSections && "Checklist" in sections) {
+        return {
+          doing: parseChecklistSection(sections.Checklist ?? ""),
+          checking: [],
+          reviewing: []
+        };
+      }
+      return {
+        doing: parseChecklistSection(sections[checklistSectionHeading("doing")] ?? ""),
+        checking: parseChecklistSection(sections[checklistSectionHeading("checking")] ?? ""),
+        reviewing: parseChecklistSection(sections[checklistSectionHeading("reviewing")] ?? "")
+      };
+    }
+    function parseChecklistSection(contents) {
+      const entries = [];
+      for (const rawLine of contents.split("\n")) {
+        const line = rawLine.trim();
+        if (!line || isHtmlComment(line)) {
+          continue;
+        }
+        const match = line.match(/^- \[([ xX])\] (.+)$/);
+        if (!match) {
+          throw new PacketFileContractError2("PACKET_FILE_MALFORMED", "Checklist entries must use the markdown checkbox form '- [ ] item'.");
+        }
+        entries.push({
+          completed: match[1].toLowerCase() === "x",
+          body: match[2].trim()
+        });
+      }
+      return entries;
+    }
+    function parseLane(value) {
+      if (exports2.WORKFLOW_STATES.includes(value)) {
+        return value;
+      }
+      throw new PacketFileContractError2("PACKET_FILE_MALFORMED", "The packet file lane frontmatter must be one of todo, doing, checking, reviewing, or done.");
+    }
+    function requireFrontmatterValue(value, key) {
+      if (!value) {
+        throw new PacketFileContractError2("PACKET_FILE_MALFORMED", `The packet file is missing the required ${key} frontmatter value.`);
+      }
+      return value;
+    }
+    function checklistSectionHeading(checklistStage) {
+      if (checklistStage === "doing") {
+        return "Doing Checklist";
+      }
+      if (checklistStage === "checking") {
+        return "Checking Checklist";
+      }
+      return "Reviewing Checklist";
+    }
+    function isHtmlComment(value) {
+      return /^<!--.*-->$/.test(value.trim());
+    }
+    function escapeRegExp(value) {
+      return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }
+    function escapeFrontmatterValue(value) {
+      return JSON.stringify(value ?? "");
+    }
+  }
+});
+
+// ../../packages/packet-workflow/dist/workflowContract.js
+var require_workflowContract = __commonJS({
+  "../../packages/packet-workflow/dist/workflowContract.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.SWARMCRAFT_STAGE_CONTRACTS = exports2.STAGE_COMMAND_TICKET_HINT = exports2.PACKET_SECTIONS = void 0;
+    exports2.getSwarmCraftStageContract = getSwarmCraftStageContract;
+    exports2.renderStageCommandLine = renderStageCommandLine;
+    exports2.renderNumberedLines = renderNumberedLines;
+    exports2.renderBullets = renderBullets;
+    exports2.findMissingStageCommandAdapters = findMissingStageCommandAdapters;
+    exports2.PACKET_SECTIONS = [
+      "## Goal",
+      "## Doing Checklist",
+      "## Checking Checklist",
+      "## Reviewing Checklist",
+      "## Notes",
+      "## Agent Update"
+    ];
+    exports2.STAGE_COMMAND_TICKET_HINT = "ticket=.swarmcraft/projects/<project-slug>/<ticket>.md";
+    exports2.SWARMCRAFT_STAGE_CONTRACTS = [
+      {
+        key: "doing",
+        command: "\\do",
+        commandDescription: "doing-lane implementation",
+        promptTitle: "Do Ticket",
+        promptDescription: "Implements a linked SwarmCraft ticket packet using the doing-stage workflow",
+        promptScope: "execution contract for the current ticket",
+        promptAction: "implementing code",
+        agentTitle: "SwarmCraft Implementor",
+        agentPurpose: "Implement the current SwarmCraft-scoped ticket from its packet and keep the packet aligned with the code.",
+        agentDescription: "Use when implementing a SwarmCraft packet, doing-lane ticket, scoped code change, or packet-driven repo update",
+        agentArgumentHint: "packet=... [scope=...]",
+        laneInstructionsTitle: "Doing Instructions",
+        checklistName: "Doing",
+        noteHeading: "### Implementation Notes",
+        laneInstructions: [
+          "Use the linked planning packet as the source of truth for scope and status.",
+          "Implement only the work needed for the current ticket.",
+          "Add or update `### Implementation Notes` under `## Notes` with what changed, important decisions, files touched, validation run, and what remains open.",
+          "Mark every completed Doing checklist item as done as soon as repository state and validation support it.",
+          "Update the packet checklist and `## Agent Update` as work progresses.",
+          "When all Doing checklist items are complete and there are no unresolved blockers, questions, or validation gaps, set packet frontmatter `lane: checking` so packet sync moves the ticket forward.",
+          "If `SWARMCRAFT_DRIVER_AUTO_COMMIT=true`, do not create a git commit; the headless build driver commits after packet sync. Otherwise, create a local git commit for the scoped ticket changes once the Doing work is complete.",
+          "Leave the ticket in doing only when implementation work remains blocked, incomplete, or unproven, and record the reason in the packet.",
+          "Keep unrelated files untouched unless the packet explicitly requires adjacent work.",
+          "Prefer focused tests or narrow validation for the touched slice before moving the ticket forward."
+        ],
+        promptRequirements: [
+          "Treat `${input:ticket}` as the execution contract for the current ticket.",
+          "Read the packet frontmatter, goal, doing checklist, notes, and agent update before editing code.",
+          "Implement only the smallest scoped change needed to advance the packet.",
+          "Keep unrelated files untouched unless the packet explicitly requires adjacent work.",
+          "Update packet checklist items only when the repository state actually supports them.",
+          "Add or update `### Implementation Notes` under `## Notes` with what changed, important decisions, files touched, validation run, and what remains open.",
+          "Mark every completed Doing checklist item as done once code and validation support it.",
+          "Update `## Agent Update` with a concise implementation summary for the checking agent.",
+          "If all Doing checklist items are complete and no blockers, questions, or validation gaps remain, set packet frontmatter `lane: checking` so packet sync moves the ticket forward.",
+          "If `SWARMCRAFT_DRIVER_AUTO_COMMIT=true`, leave the git commit to the headless build driver. Otherwise, stage and commit only the scoped ticket changes, including the packet file, using `Complete <ticket-id>: <ticket-title>`.",
+          "If implementation is incomplete or unproven, keep `lane: doing` and record the blocker or remaining work in the packet."
+        ],
+        agentWorkflow: [
+          "Restate the packet goal and choose the smallest implementation slice.",
+          "Inspect only the nearest controlling code path and one cheap disconfirming check before the first edit.",
+          "Implement the smallest plausible change.",
+          "Run focused validation immediately after the first substantive edit.",
+          "Add or update `### Implementation Notes` under `## Notes` with what changed, important decisions, files touched, validation run, and what remains open.",
+          "Mark every completed Doing checklist item as done once the repo state and validation support it.",
+          "Update `## Agent Update` with a concise implementation summary for the checking agent.",
+          "If all Doing checklist items are complete and no blockers, questions, or validation gaps remain, set packet frontmatter `lane: checking`.",
+          "If `SWARMCRAFT_DRIVER_AUTO_COMMIT=true`, stop after packet updates so the driver can sync and commit. Otherwise, stage and commit only the scoped ticket changes, including the packet file, before finishing.",
+          "If any Doing item remains incomplete or unproven, keep `lane: doing` and record the blocker or remaining work in the packet."
+        ],
+        outputItems: [
+          "What changed",
+          "Validation run",
+          "Packet updates made, including `### Implementation Notes`, completed Doing checklist items, and any lane change",
+          "Commit created, driver-managed commit noted, or commit blocker",
+          "Remaining risks or next step"
+        ],
+        stageSummary: "Doing: implement the scoped work, add `### Implementation Notes`, mark completed Doing checklist items, set `lane: checking`, and ensure the completed work is committed by either the agent or the headless driver.",
+        completionRule: "Set the packet frontmatter `lane` to `checking` so packet sync moves the ticket forward."
+      },
+      {
+        key: "checking",
+        command: "\\check",
+        commandDescription: "checking-lane machine judgment",
+        promptTitle: "Check Ticket",
+        promptDescription: "Validates a linked SwarmCraft ticket packet using the checking-stage workflow",
+        promptScope: "source of truth for the checking scope",
+        promptAction: "checking implementation evidence",
+        agentTitle: "SwarmCraft Checker",
+        agentPurpose: "Validate a SwarmCraft packet against the repo state, focused checks, and acceptance criteria before it moves forward.",
+        agentDescription: "Use when validating a SwarmCraft packet, checking-lane ticket, focused test pass, or packet readiness before review",
+        agentArgumentHint: "packet=... [validation=...]",
+        laneInstructionsTitle: "Checking Instructions",
+        checklistName: "Checking",
+        noteHeading: "### Checking Feedback",
+        laneInstructions: [
+          "Validate the implementation against the packet checklist and acceptance criteria.",
+          "Treat checking as a judge lane: accept the work toward human review or reject it back to doing with clear feedback.",
+          "Do not fix implementation defects during checking unless the user explicitly asks.",
+          "Run the narrowest tests, lint, or typecheck that can falsify the change.",
+          "Confirm the packet notes and agent update match the actual code and board state.",
+          "Mark every proven Checking checklist item as done once validation and repository state support it.",
+          "On rejection, add `### Checking Feedback` under `## Notes`, summarize the rejection in `## Agent Update`, leave failed or unproven checklist items unchecked, and set packet frontmatter `lane: doing`.",
+          "On acceptance, record validation evidence, complete only proven checking checklist items, update `## Agent Update`, and set packet frontmatter `lane: reviewing`.",
+          "Leave the ticket in checking only when validation cannot reach a clear accept or reject decision."
+        ],
+        promptRequirements: [
+          "Treat `${input:ticket}` as the source of truth for the checking scope.",
+          "Read the packet goal, checking checklist, notes, agent update, and any implementation evidence before changing files.",
+          "Act as a judge for the implementation. Do not fix implementation defects during checking unless the user explicitly asks.",
+          "Run the narrowest validation that can disconfirm the implementation.",
+          "Mark every proven Checking checklist item as done once validation and repository state support it.",
+          "If validation fails, leave failed or unproven checking checklist items unchecked and add a `### Checking Feedback` entry under `## Notes` with the failed item, evidence, validation result, and required fix.",
+          "On rejection, update `## Agent Update` with a concise rejection summary and set the packet frontmatter `lane` to `doing` so packet sync moves the ticket back for implementation.",
+          "If all Checking checklist items pass and no blockers, questions, or validation gaps remain, update the checking checklist, notes, and agent update to match the evidence.",
+          "On acceptance, set the packet frontmatter `lane` to `reviewing` so packet sync moves the ticket forward for human review.",
+          "Leave the ticket in checking only when validation could not reach a clear accept or reject decision, and record why in the packet."
+        ],
+        agentWorkflow: [
+          "List the acceptance criteria or packet checklist items that need validation.",
+          "Run the smallest test, typecheck, lint, or targeted command that can disconfirm the change.",
+          "Mark every proven Checking checklist item as done once validation and repo state support it.",
+          "If validation fails or any Checking item is unproven, add `### Checking Feedback` under `## Notes`, summarize rejection in `## Agent Update`, leave failed or unproven items unchecked, and set packet frontmatter `lane: doing`.",
+          "If all Checking checklist items pass and no blockers, questions, or validation gaps remain, update packet notes and `## Agent Update`, then set packet frontmatter `lane: reviewing`.",
+          "Leave the ticket in checking only when validation cannot reach a clear accept or reject decision, and record why in the packet."
+        ],
+        outputItems: [
+          "Validation performed",
+          "Pass or fail result",
+          "Packet updates made, including completed Checking checklist items and any lane change",
+          "Rejection feedback, review promotion, or unresolved validation blocker"
+        ],
+        stageSummary: "Checking: judge the result against checklist, tests, and acceptance criteria; accept forward to reviewing or reject back to doing with `### Checking Feedback`.",
+        completionRule: "Set the packet frontmatter `lane` to `reviewing` so packet sync moves the ticket forward for human review."
+      },
+      {
+        key: "reviewing",
+        command: "\\review",
+        commandDescription: "reviewing-lane human approval",
+        promptTitle: "Review Ticket",
+        promptDescription: "Guides human approval of a linked SwarmCraft ticket packet using the reviewing-stage workflow",
+        promptScope: "source of truth for the reviewing scope",
+        promptAction: "asking for human review",
+        agentTitle: "SwarmCraft Reviewer",
+        agentPurpose: "Guide the human review of a SwarmCraft packet and record explicit user approval before any Reviewing checklist item is marked complete.",
+        agentDescription: "Use when guiding human approval of a SwarmCraft packet, prompting for reviewing checklist confirmation, and recording review decisions without expanding scope",
+        agentArgumentHint: "packet=...",
+        laneInstructionsTitle: "Reviewing Instructions",
+        checklistName: "Reviewing",
+        noteHeading: "### Review Notes",
+        laneInstructions: [
+          "Guide human approval; do not act as another checking pass unless the user explicitly asks.",
+          "Confirm the packet is current, concise, and ready to present to the human reviewer.",
+          "Ask the user to confirm each Reviewing checklist item before marking it complete.",
+          "Use existing repository evidence or validation only to explain what the user should inspect before approving; do not infer approval from evidence alone.",
+          "Add or update `### Review Notes` under `## Notes` with user approvals, rejected review items, risks, and open questions.",
+          "Mark a Reviewing checklist item as done only after explicit user approval for that item.",
+          "If all Reviewing checklist items are explicitly approved and no unresolved risk remains, state in `## Agent Update` that the packet is ready for the extension's Move to Done action.",
+          "Do not set packet frontmatter `lane: done`; the SwarmCraft extension owns the final done transition.",
+          "Call out risks, open questions, and follow-up work in the Agent Update section.",
+          "Leave the implementation state reproducible from the repo and the packet alone.",
+          "Do not hide unfinished work behind verbal handoff; record it in the packet instead."
+        ],
+        promptRequirements: [
+          "Treat `${input:ticket}` as the source of truth for the reviewing scope.",
+          "Read the packet goal, reviewing checklist, notes, agent update, and validation evidence before asking for approval.",
+          "Prompt the user for each reviewing checklist item one at a time.",
+          "When possible, explain what repository evidence, validation result, or behavior the user should inspect before approving the item.",
+          "Ask the user to confirm whether each review item is complete and approved.",
+          "Record confirmed approvals in the packet by updating the reviewing checklist and adding or updating `### Review Notes` under `## Notes`.",
+          "Mark a Reviewing checklist item as done only after the user explicitly confirms that item is approved.",
+          "Do not infer approval from repository evidence, prior validation, or your own assessment; evidence is only context for the user's decision.",
+          "Leave unapproved, unanswered, or uncertain items unchecked and record the reason under `### Review Notes`.",
+          "Update `## Agent Update` with a concise human-review summary, including approvals, rejected items, and any remaining risk.",
+          "If all Reviewing checklist items are explicitly approved and no unresolved risk remains, state that the packet is ready for the extension's Move to Done action.",
+          "Do not set packet frontmatter `lane: done`. The SwarmCraft extension owns the board transition after review approval."
+        ],
+        agentWorkflow: [
+          "Read the packet goal, reviewing checklist, notes, agent update, and existing validation evidence so you can frame the review questions.",
+          "Ask the user to confirm each Reviewing checklist item. Prefer one clear question at a time unless the user asks for a grouped review.",
+          "For each question, summarize the relevant existing evidence or risk the user should consider before approving.",
+          "Mark a Reviewing checklist item as done only after the user explicitly confirms that item is approved.",
+          "Leave rejected, unanswered, or uncertain Reviewing items unchecked and record the user's reason under `### Review Notes`.",
+          "Update `## Agent Update` with a concise human-review summary based on the user's answers.",
+          "If all Reviewing checklist items are explicitly approved and no unresolved risk remains, state that the packet is ready for the extension's Move to Done action without changing `lane` to `done`.",
+          "If any Reviewing item remains unapproved or uncertain, keep `lane: reviewing` and record the remaining approval or risk in the packet."
+        ],
+        outputItems: [
+          "Review-readiness assessment",
+          "Packet edits made, including `### Review Notes` and completed Reviewing checklist items",
+          "Risks or open questions",
+          "Recommended next step"
+        ],
+        stageSummary: "Reviewing: ask the user to confirm each reviewing item, record `### Review Notes`, mark items only after explicit human approval, and leave the board move to done for the extension.",
+        completionRule: "Do not set packet frontmatter `lane: done`; state that the packet is ready for the extension's Move to Done action."
+      }
+    ];
+    function getSwarmCraftStageContract(stageKey) {
+      const stage = exports2.SWARMCRAFT_STAGE_CONTRACTS.find((candidate) => candidate.key === stageKey);
+      if (!stage) {
+        throw new Error(`Unknown SwarmCraft workflow stage: ${stageKey}`);
+      }
+      return stage;
+    }
+    function renderStageCommandLine(stage) {
+      return `- \`${stage.command} ${exports2.STAGE_COMMAND_TICKET_HINT}\` for ${stage.commandDescription}`;
+    }
+    function renderNumberedLines(lines, startAt = 1) {
+      return lines.map((line, index) => `${index + startAt}. ${line}`);
+    }
+    function renderBullets(lines) {
+      return lines.map((line) => `- ${line}`);
+    }
+    function findMissingStageCommandAdapters(expectedProviders, adapters) {
+      const missing = [];
+      for (const provider of expectedProviders) {
+        const providerAdapters = adapters.filter((adapter) => adapter.provider === provider);
+        for (const stage of exports2.SWARMCRAFT_STAGE_CONTRACTS) {
+          const hasAdapter = providerAdapters.some((adapter) => adapter.stage === stage.key);
+          if (!hasAdapter) {
+            missing.push(`${provider} is missing ${stage.command} adapter`);
+          }
+        }
+      }
+      return missing;
+    }
+  }
+});
+
+// ../../packages/packet-workflow/dist/stageCommands.js
+var require_stageCommands = __commonJS({
+  "../../packages/packet-workflow/dist/stageCommands.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.DEFAULT_SWARMCRAFT_AGENT_PROVIDER = exports2.SWARMCRAFT_AGENT_PROVIDERS = void 0;
+    exports2.buildPacketStageCommand = buildPacketStageCommand2;
+    exports2.buildAssistantActionCommand = buildAssistantActionCommand;
+    exports2.formatTicketArgument = formatTicketArgument;
+    var assistantActions_js_1 = require_assistantActions();
+    var workflowContract_js_1 = require_workflowContract();
+    exports2.SWARMCRAFT_AGENT_PROVIDERS = ["copilot", "codex"];
+    exports2.DEFAULT_SWARMCRAFT_AGENT_PROVIDER = "copilot";
+    var COMMAND_BY_WORKFLOW_STATE = Object.fromEntries(workflowContract_js_1.SWARMCRAFT_STAGE_CONTRACTS.map((stage) => [
+      stage.key,
+      {
+        actionKey: toStageName(stage.command),
+        stageName: toStageName(stage.command)
+      }
+    ]));
+    function buildPacketStageCommand2(input2) {
+      const commandParts = COMMAND_BY_WORKFLOW_STATE[input2.workflowState];
+      if (!commandParts) {
+        return null;
+      }
+      return buildAssistantActionCommand({
+        actionKey: commandParts.actionKey,
+        relativePacketFilePath: input2.relativePacketFilePath,
+        agentProvider: input2.agentProvider
+      });
+    }
+    function buildAssistantActionCommand(input2) {
+      const action = (0, assistantActions_js_1.getSwarmCraftAssistantAction)(input2.actionKey);
+      const agentProvider = input2.agentProvider ?? exports2.DEFAULT_SWARMCRAFT_AGENT_PROVIDER;
+      const invocation = agentProvider === "codex" ? action.codexInvocation : action.copilotInvocation;
+      const command = input2.relativePacketFilePath ? invocation.replace("<packet-path>", formatTicketArgument(input2.relativePacketFilePath)) : invocation;
+      const args = [];
+      if (input2.relativePacketFilePath && command === invocation) {
+        const packetArgumentName = input2.actionKey === "test" ? "ticket" : "scope";
+        args.push(`${packetArgumentName}=${formatTicketArgument(input2.relativePacketFilePath)}`);
+      }
+      if (input2.scope?.trim()) {
+        args.push(`scope=${formatTicketArgument(input2.scope.trim())}`);
+      }
+      return [command, ...args].join(" ");
+    }
+    function formatTicketArgument(relativePacketFilePath) {
+      if (!/\s/.test(relativePacketFilePath)) {
+        return relativePacketFilePath;
+      }
+      return `"${relativePacketFilePath.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+    }
+    function toStageName(command) {
+      return command.slice(1);
+    }
+  }
+});
+
+// ../../packages/packet-workflow/dist/index.js
+var require_dist = __commonJS({
+  "../../packages/packet-workflow/dist/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    __exportStar(require_assistantActions(), exports2);
+    __exportStar(require_agentProviders(), exports2);
+    __exportStar(require_manifest(), exports2);
+    __exportStar(require_packetFile(), exports2);
+    __exportStar(require_stageCommands(), exports2);
+    __exportStar(require_workflowContract(), exports2);
+  }
+});
+
+// ../../packages/repo-seed/dist/projectSeedModels.js
+var require_projectSeedModels = __commonJS({
+  "../../packages/repo-seed/dist/projectSeedModels.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+  }
+});
+
+// ../../packages/repo-seed/dist/templates/renderCopilotAgents.js
+var require_renderCopilotAgents = __commonJS({
+  "../../packages/repo-seed/dist/templates/renderCopilotAgents.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.renderPacketInstructionsFile = renderPacketInstructionsFile;
+    exports2.renderImplementorAgentFile = renderImplementorAgentFile;
+    exports2.renderCheckerAgentFile = renderCheckerAgentFile;
+    exports2.renderReviewerAgentFile = renderReviewerAgentFile;
+    var packet_workflow_1 = require_dist();
+    function renderPacketInstructionsFile() {
+      return [
+        "---",
+        'description: "Auto-applied SwarmCraft packet rules for planning packets under .swarmcraft/projects and related workflow guidance files"',
+        'applyTo: ".swarmcraft/**/*.md"',
+        "---",
+        "",
+        "# SwarmCraft Packet Instructions",
+        "",
+        "Use SwarmCraft packet files as the source of truth for scoped ticket work and status updates.",
+        "",
+        "## Packet Contract",
+        "",
+        "* Preserve packet identity and sync fields such as `projectId`, `ticketId`, and `syncRevision` unless SwarmCraft itself rewrites them.",
+        "* Edit packet frontmatter `lane` only when a SwarmCraft stage prompt or lane guidance explicitly tells you to request an adjacent workflow move.",
+        `* Preserve the staged packet structure: ${packet_workflow_1.PACKET_SECTIONS.map((section) => `\`${section}\``).join(", ")}.`,
+        "* Treat checklist text as board-owned scope; mark items complete only when the repo state actually supports it.",
+        "* Reviewing checklist items require explicit human approval before they are marked complete; repository evidence can inform the question but cannot replace the human confirmation.",
+        "* When all checklist items for the current lane are complete and no unresolved blocker or question remains, set packet frontmatter `lane` to the next adjacent workflow lane unless the reviewing-to-done transition is owned by the SwarmCraft extension.",
+        "* Keep `## Notes` factual and implementation-specific. Use `### Implementation Notes`, `### Checking Feedback`, and `### Review Notes` for stage-specific packet comments.",
+        "* Keep `## Agent Update` short and structured around what changed, what was validated, and what remains blocked or risky.",
+        "",
+        "## Workflow Expectations",
+        "",
+        "* Read `.swarmcraft/AGENTS.md`, `.swarmcraft/project.instructions.md`, and `.swarmcraft/project.context.md` before making substantive ticket changes when those files exist.",
+        "* Use the lane-specific guidance in `.swarmcraft/agents/` for the current workflow stage.",
+        "* Keep packet notes and agent update aligned with the actual code, validation status, and ticket state.",
+        "* Prefer small, reviewable edits and the narrowest validation that can falsify the change.",
+        "* If the packet and repo diverge, reconcile them explicitly instead of hiding the mismatch in chat only.",
+        ""
+      ].join("\n");
+    }
+    function renderImplementorAgentFile() {
+      const stage = (0, packet_workflow_1.getSwarmCraftStageContract)("doing");
+      return [
+        "---",
+        `name: "${stage.agentTitle}"`,
+        `description: "${stage.agentDescription}"`,
+        "tools: [read, edit, search, execute, todo]",
+        `argument-hint: "${stage.agentArgumentHint}"`,
+        "agents: []",
+        "---",
+        "",
+        `# ${stage.agentTitle}`,
+        "",
+        stage.agentPurpose,
+        "",
+        "## Purpose",
+        "",
+        "* Execute the current packet without inventing extra scope.",
+        "* Keep packet checklist progress, notes, and agent update consistent with the repo.",
+        "* Stop at the smallest validated change that satisfies the ticket.",
+        "",
+        "## Required Context",
+        "",
+        "1. Read `AGENTS.md` and the nearest scoped `AGENTS.md` files for touched code.",
+        "2. Read `.swarmcraft/AGENTS.md`, `.swarmcraft/project.instructions.md`, and `.swarmcraft/project.context.md` when present.",
+        "3. Read the linked packet under `.swarmcraft/projects/` before editing code.",
+        "4. Read `.swarmcraft/agents/doing.instructions.md` when present.",
+        "",
+        "## Constraints",
+        "",
+        "* Do not expand the scope beyond the packet unless the packet itself requires adjacent work.",
+        "* Do not rewrite packet identity fields or staged checklist text.",
+        "* Do not mark checklist items complete until code and validation actually support them.",
+        "* Do not ask whether to update completed Doing checklist items or move to checking when the evidence is complete; update the packet directly.",
+        "* Prefer the narrowest tests or checks that can falsify the change.",
+        "",
+        "## Workflow",
+        "",
+        ...(0, packet_workflow_1.renderNumberedLines)(stage.agentWorkflow),
+        "",
+        "## Output Format",
+        "",
+        "Return:",
+        "",
+        ...(0, packet_workflow_1.renderBullets)(stage.outputItems),
+        ""
+      ].join("\n");
+    }
+    function renderCheckerAgentFile() {
+      const stage = (0, packet_workflow_1.getSwarmCraftStageContract)("checking");
+      return [
+        "---",
+        `name: "${stage.agentTitle}"`,
+        `description: "${stage.agentDescription}"`,
+        "tools: [read, edit, search, execute, todo]",
+        `argument-hint: "${stage.agentArgumentHint}"`,
+        "agents: []",
+        "---",
+        "",
+        `# ${stage.agentTitle}`,
+        "",
+        stage.agentPurpose,
+        "",
+        "## Purpose",
+        "",
+        "* Falsify the implementation with the narrowest meaningful validation.",
+        "* Act as a machine judge: accept the work toward human review or reject it back to doing.",
+        "* Confirm packet checklist progress and notes still match the repo.",
+        "* Surface regressions, gaps, and incomplete acceptance criteria as packet feedback for the implementor.",
+        "",
+        "## Required Context",
+        "",
+        "1. Read `AGENTS.md` and the nearest scoped `AGENTS.md` files for any validated code.",
+        "2. Read `.swarmcraft/AGENTS.md`, `.swarmcraft/project.instructions.md`, and `.swarmcraft/project.context.md` when present.",
+        "3. Read the linked packet under `.swarmcraft/projects/` before validating.",
+        "4. Read `.swarmcraft/agents/checking.instructions.md` when present.",
+        "",
+        "## Constraints",
+        "",
+        "* Do not repair implementation defects during checking unless the user explicitly asks.",
+        "* Do not broaden validation scope unless the current check exposes a nearby defect.",
+        "* Do not claim success without naming the concrete validation that passed.",
+        "* Do not move unresolved risk out of the packet and into chat only.",
+        "* Do not rewrite packet identity fields or staged checklist text.",
+        "* Do not ask whether to update completed Checking checklist items or move to reviewing when the evidence is complete; update the packet directly.",
+        "",
+        "## Workflow",
+        "",
+        ...(0, packet_workflow_1.renderNumberedLines)(stage.agentWorkflow),
+        "",
+        "## Output Format",
+        "",
+        "Return:",
+        "",
+        ...(0, packet_workflow_1.renderBullets)(stage.outputItems),
+        ""
+      ].join("\n");
+    }
+    function renderReviewerAgentFile() {
+      const stage = (0, packet_workflow_1.getSwarmCraftStageContract)("reviewing");
+      return [
+        "---",
+        `name: "${stage.agentTitle}"`,
+        `description: "${stage.agentDescription}"`,
+        "tools: [read, edit, search, todo]",
+        `argument-hint: "${stage.agentArgumentHint}"`,
+        "agents: []",
+        "---",
+        "",
+        `# ${stage.agentTitle}`,
+        "",
+        stage.agentPurpose,
+        "",
+        "## Purpose",
+        "",
+        "* Prompt the user for each Reviewing checklist decision.",
+        "* Record the user's approval, rejection, uncertainty, and requested follow-up in the packet.",
+        "* Call out risks, missing evidence, and follow-up work explicitly.",
+        "",
+        "## Required Context",
+        "",
+        "1. Read `AGENTS.md` and the nearest scoped `AGENTS.md` files for the touched surface.",
+        "2. Read `.swarmcraft/AGENTS.md`, `.swarmcraft/project.instructions.md`, and `.swarmcraft/project.context.md` when present.",
+        "3. Read the linked packet under `.swarmcraft/projects/` before editing the handoff.",
+        "4. Read `.swarmcraft/agents/reviewing.instructions.md` when present.",
+        "",
+        "## Constraints",
+        "",
+        "* Do not hide unfinished work behind optimistic summaries.",
+        "* Do not rewrite the packet into a changelog; keep it concise and review-oriented.",
+        "* Do not claim review readiness if risks or validation gaps remain unresolved.",
+        "* Do not mark Reviewing checklist items complete from repository evidence alone; every checked item requires explicit human approval in the current review interaction.",
+        "* Do not act as the checking agent. Avoid fresh validation unless the user asks for it; use existing evidence only to help the user decide.",
+        "* Do not set packet frontmatter `lane: done`; the SwarmCraft extension owns the final done transition.",
+        "* Do not rewrite packet identity fields or staged checklist text.",
+        "",
+        "## Workflow",
+        "",
+        ...(0, packet_workflow_1.renderNumberedLines)(stage.agentWorkflow),
+        "",
+        "## Output Format",
+        "",
+        "Return:",
+        "",
+        ...(0, packet_workflow_1.renderBullets)(stage.outputItems),
+        ""
+      ].join("\n");
+    }
+  }
+});
+
+// ../../packages/repo-seed/dist/templates/renderCodexAgents.js
+var require_renderCodexAgents = __commonJS({
+  "../../packages/repo-seed/dist/templates/renderCodexAgents.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.renderCodexImplementorAgentFile = renderCodexImplementorAgentFile;
+    exports2.renderCodexCheckerAgentFile = renderCodexCheckerAgentFile;
+    exports2.renderCodexReviewerAgentFile = renderCodexReviewerAgentFile;
+    exports2.renderCodexConfigExampleFile = renderCodexConfigExampleFile;
+    var packet_workflow_1 = require_dist();
+    function renderCodexImplementorAgentFile() {
+      return renderCodexStageAgentFile("doing", "swarmcraft-implementor", "medium");
+    }
+    function renderCodexCheckerAgentFile() {
+      return renderCodexStageAgentFile("checking", "swarmcraft-checker", "medium");
+    }
+    function renderCodexReviewerAgentFile() {
+      return renderCodexStageAgentFile("reviewing", "swarmcraft-reviewer", "low");
+    }
+    function renderCodexConfigExampleFile() {
+      return [
+        "# Example project-scoped Codex config for a SwarmCraft-seeded repository.",
+        "#",
+        "# This file documents optional local setup. It is not loaded automatically.",
+        "# To use it, copy the relevant sections into `.codex/config.toml` or your",
+        "# personal `~/.codex/config.toml`, then adjust local paths and environment variables.",
+        "#",
+        "# Do not commit `.codex/config.toml` if it contains local paths, credentials,",
+        "# tokens, private keys, or machine-specific settings.",
+        "",
+        "# Keep subagent fan-out modest. SwarmCraft's default workflow is one ticket",
+        "# stage at a time: do, check, then review.",
+        "[agents]",
+        "max_threads = 3",
+        "max_depth = 1",
+        "",
+        "# Optional first MCP server for OpenAI or Codex documentation questions.",
+        "# Tool posture: read-only documentation lookup.",
+        "# Secret handling: no secret required.",
+        "#",
+        "# [mcp_servers.openaiDeveloperDocs]",
+        '# url = "https://developers.openai.com/mcp"',
+        "# enabled = true",
+        '# default_tools_approval_mode = "auto"',
+        "",
+        "# Optional browser automation for local UI verification.",
+        "# Tool posture: can open pages, inspect browser state, and drive browser actions.",
+        "# Approval posture: prompt by default because browser tools can interact with",
+        "# local apps and external pages.",
+        "#",
+        "# [mcp_servers.playwright]",
+        '# command = "npx"',
+        '# args = ["-y", "@playwright/mcp"]',
+        "# enabled = true",
+        '# default_tools_approval_mode = "prompt"',
+        "# tool_timeout_sec = 120",
+        ""
+      ].join("\n");
+    }
+    function renderCodexStageAgentFile(stageKey, name, reasoningEffort) {
+      const stage = (0, packet_workflow_1.getSwarmCraftStageContract)(stageKey);
+      const instructions = [
+        `You are the ${stage.agentTitle}.`,
+        "",
+        stage.agentPurpose,
+        "",
+        "Follow this workflow:",
+        ...(0, packet_workflow_1.renderNumberedLines)([
+          "Read `AGENTS.md` and the nearest scoped `AGENTS.md` files for touched code.",
+          "Read `.swarmcraft/AGENTS.md`, `.swarmcraft/project.instructions.md`, and `.swarmcraft/project.context.md` when present.",
+          "Read the linked packet under `.swarmcraft/projects/` before changing files.",
+          `Read \`.swarmcraft/agents/${stage.key}.instructions.md\` when present.`,
+          ...stage.agentWorkflow
+        ]),
+        "",
+        "Output expectations:",
+        ...stage.outputItems.map((item) => `- ${item}`),
+        "",
+        "Stage completion rule:",
+        stage.completionRule,
+        "",
+        "Do not rewrite packet identity fields, board-owned checklist text, unrelated local changes, or workflow history."
+      ].join("\n");
+      return [
+        `name = "${name}"`,
+        `description = "${escapeTomlString(stage.agentDescription)}"`,
+        `model_reasoning_effort = "${reasoningEffort}"`,
+        "",
+        'developer_instructions = """',
+        instructions,
+        '"""',
+        ""
+      ].join("\n");
+    }
+    function escapeTomlString(value) {
+      return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+    }
+  }
+});
+
+// ../../packages/repo-seed/dist/templates/renderAssistantActionSkills.js
+var require_renderAssistantActionSkills = __commonJS({
+  "../../packages/repo-seed/dist/templates/renderAssistantActionSkills.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.renderSwarmCraftActionSkillFile = renderSwarmCraftActionSkillFile;
+    var packet_workflow_1 = require_dist();
+    function renderSwarmCraftActionSkillFile(actionKey) {
+      const action = (0, packet_workflow_1.getSwarmCraftAssistantAction)(actionKey);
+      if (action.kind === "stage") {
+        return renderStageActionSkillFile(action);
+      }
+      if (action.kind === "planning") {
+        return renderPlanActionSkillFile(action);
+      }
+      return renderTestActionSkillFile(action);
+    }
+    function renderStageActionSkillFile(action) {
+      if (!action.stageKey) {
+        throw new Error(`Stage action ${action.key} is missing a stage key.`);
+      }
+      const stage = (0, packet_workflow_1.getSwarmCraftStageContract)(action.stageKey);
+      return [
+        "---",
+        `name: swarmcraft-${action.key}`,
+        `description: ${JSON.stringify(`${action.description} Use when working a SwarmCraft ${stage.key}-lane packet through the ${action.key} action from .swarmcraft/projects/.`)}`,
+        "---",
+        "",
+        `# SwarmCraft ${capitalize(action.key)}`,
+        "",
+        `Use this skill for the \`${action.key}\` action on a linked SwarmCraft packet in the \`${stage.key}\` lane.`,
+        "",
+        "## Required Context",
+        "",
+        ...(0, packet_workflow_1.renderBullets)([
+          "`AGENTS.md` and the nearest scoped `AGENTS.md` files for touched code",
+          "`.swarmcraft/AGENTS.md`",
+          "`.swarmcraft/project.instructions.md`",
+          "`.swarmcraft/project.context.md`",
+          `the linked packet under \`.swarmcraft/projects/\``,
+          `\`.swarmcraft/agents/${stage.key}.instructions.md\``
+        ]),
+        "",
+        "## Packet Contract",
+        "",
+        ...(0, packet_workflow_1.renderBullets)([
+          `Preserve the staged packet structure: ${packet_workflow_1.PACKET_SECTIONS.map((section) => `\`${section}\``).join(", ")}.`,
+          "Treat checklist text and ordering as board-owned scope.",
+          "Mark checklist items complete only when repository state and validation support them.",
+          "Keep `## Notes` factual and stage-specific.",
+          "Keep `## Agent Update` short and useful for the next agent or reviewer.",
+          "Preserve packet identity and sync fields unless SwarmCraft tooling rewrites them."
+        ]),
+        "",
+        "## Workflow",
+        "",
+        ...(0, packet_workflow_1.renderNumberedLines)(stage.agentWorkflow),
+        "",
+        "## Completion Rule",
+        "",
+        stage.completionRule,
+        "",
+        "## Output",
+        "",
+        ...(0, packet_workflow_1.renderBullets)(stage.outputItems),
+        ""
+      ].join("\n");
+    }
+    function renderPlanActionSkillFile(action) {
+      return [
+        "---",
+        `name: swarmcraft-${action.key}`,
+        `description: ${JSON.stringify("Use when the user asks to plan SwarmCraft work, create or revise a plan, check whether an existing plan is stale or coherent, turn repo context into one provisional ticket packet, or review scope for duplicate work, dependency drift, or mismatch with repository reality.")}`,
+        "---",
+        "",
+        "# SwarmCraft Plan",
+        "",
+        "Use this skill to create a narrow plan, check whether an existing plan is still coherent, revise a stale plan when asked, or draft one provisional SwarmCraft ticket packet from repo context.",
+        "",
+        "## Required Context",
+        "",
+        ...(0, packet_workflow_1.renderBullets)([
+          "`AGENTS.md` and the nearest scoped `AGENTS.md` files for touched code",
+          "`.swarmcraft/AGENTS.md`",
+          "`.swarmcraft/project.instructions.md`",
+          "`.swarmcraft/project.context.md`",
+          "nearby existing packets under `.swarmcraft/projects/`",
+          "the existing plan or requested scope when the user provides one"
+        ]),
+        "",
+        "Do not draft new scope until the project instructions, project context, and nearby packets have been checked or clearly do not exist.",
+        "",
+        "## Plan Review",
+        "",
+        ...(0, packet_workflow_1.renderNumberedLines)([
+          "Compare the requested plan against current repository structure, project context, and nearby packets.",
+          "Identify stale assumptions, incoherent scope, duplicate work, outdated dependencies, and mismatches with current files.",
+          "State whether the plan is current, stale, incoherent, duplicated, blocked by missing context, or ready for packet drafting.",
+          "Recommend the narrowest revision when a plan is stale instead of silently rewriting it.",
+          "Do not modify an existing plan or board-linked packet unless the user explicitly asks for that revision.",
+          "When asked to revise, keep the change limited to the stale or incoherent portion and preserve still-valid decisions."
+        ]),
+        "",
+        "## New Packet Drafting",
+        "",
+        "When the user wants new SwarmCraft board work, create one focused provisional packet instead of a broad backlog dump.",
+        "",
+        "Use this frontmatter shape:",
+        "",
+        "```yaml",
+        "swarmcraftVersion: 1",
+        "projectId: <project-id>",
+        "ticketId: provisional:<short-slug>",
+        'title: "<focused ticket title>"',
+        "lane: todo",
+        "syncRevision: 0",
+        "lastSyncedAt: null",
+        "provisional: true",
+        "```",
+        "",
+        "If the project id is not available from an existing packet or SwarmCraft-provided context, ask for it or leave a plan draft instead of inventing one.",
+        "",
+        "A provisional packet must include:",
+        "",
+        ...(0, packet_workflow_1.renderBullets)([
+          "`## Goal` with one clear outcome",
+          "`## Doing Checklist` with implementation tasks",
+          "`## Checking Checklist` with validation tasks",
+          "`## Reviewing Checklist` with human approval prompts",
+          "`## Notes` for planning facts and assumptions",
+          "`## Agent Update` for a concise handoff"
+        ]),
+        "",
+        "Checklist items in a provisional packet must start unchecked. Use manual Sync Packet in the SwarmCraft extension to promote a valid provisional packet into a board ticket.",
+        "",
+        "Before calling a provisional packet sync-ready, validate that:",
+        "",
+        ...(0, packet_workflow_1.renderBullets)([
+          "`projectId` is present and comes from an existing packet or SwarmCraft-provided context",
+          "`ticketId` starts with `provisional:`",
+          "`lane` is `todo`",
+          "`syncRevision` is `0`",
+          "`lastSyncedAt` is `null`",
+          "`provisional` is `true`",
+          "all six required packet sections are present",
+          "all checklist items are unchecked",
+          "the packet describes one focused ticket, not a backlog"
+        ]),
+        "",
+        "## Output",
+        "",
+        ...(0, packet_workflow_1.renderBullets)([
+          "plan status: current, stale, incoherent, or ready for packet drafting",
+          "stale assumptions or duplicate scope found",
+          "files or packets consulted",
+          "new provisional packet path when one was created",
+          "remaining decision needed before sync"
+        ]),
+        ""
+      ].join("\n");
+    }
+    function renderTestActionSkillFile(action) {
+      return [
+        "---",
+        `name: swarmcraft-${action.key}`,
+        `description: ${JSON.stringify("Use when the user asks to add, run, or document system testing, end-to-end testing, acceptance testing, API checks, coverage improvement, existing-packet test evidence, or a testing-focused provisional SwarmCraft packet.")}`,
+        "---",
+        "",
+        "# SwarmCraft Test",
+        "",
+        "Use this skill to improve testing evidence without adding a new workflow lane or silently switching into implementation work.",
+        "",
+        "## Required Context",
+        "",
+        ...(0, packet_workflow_1.renderBullets)([
+          "`AGENTS.md` and the nearest scoped `AGENTS.md` files for touched code",
+          "`.swarmcraft/AGENTS.md`",
+          "`.swarmcraft/project.instructions.md`",
+          "`.swarmcraft/project.context.md`",
+          "the linked packet when the test work belongs to existing ticket scope",
+          "nearby tests, fixtures, API routes, UI flows, and acceptance criteria"
+        ]),
+        "",
+        "## Existing Packet Mode",
+        "",
+        ...(0, packet_workflow_1.renderNumberedLines)([
+          "Read the packet goal, checklists, notes, and agent update before changing tests.",
+          "Add or run tests that exercise the user-facing or system boundary implied by the packet.",
+          "Record commands run, flows exercised, evidence captured, pass or fail result, and remaining coverage gaps under `## Notes`.",
+          "Use an existing subsection under `## Notes` when one fits; otherwise add a concise `### Test Evidence` subsection without adding a new top-level packet section.",
+          "Update `## Agent Update` with a concise testing handoff.",
+          "Do not change packet lanes as part of test work unless the user explicitly switches into `do`, `check`, or `review` work.",
+          "Do not fix implementation defects in test mode; report the defect and ask before switching into implementation."
+        ]),
+        "",
+        "## New Testing Scope",
+        "",
+        "When requested testing work is new scope, draft one testing-focused provisional packet with the same frontmatter shape as `swarmcraft-plan`: `ticketId: provisional:<slug>`, `lane: todo`, `syncRevision: 0`, `lastSyncedAt: null`, and `provisional: true`.",
+        "",
+        "The provisional packet must describe one testing outcome, include `## Goal`, `## Doing Checklist`, `## Checking Checklist`, `## Reviewing Checklist`, `## Notes`, and `## Agent Update`, and keep every checklist item unchecked until real evidence exists.",
+        "",
+        "Use the checklist sections this way:",
+        "",
+        ...(0, packet_workflow_1.renderBullets)(packet_workflow_1.CHECKLIST_STAGES.map((stage) => `\`${stage}\`: include testing work that can be verified for that stage without creating a new lane.`)),
+        "",
+        "## Validation Preference",
+        "",
+        ...(0, packet_workflow_1.renderBullets)([
+          "Prefer full-system evidence for user-facing workflows.",
+          "Use browser flows when web UI behavior matters.",
+          "Use API or service checks when server behavior matters.",
+          "Keep implementation fixes out of this skill unless the user explicitly asks to switch into implementation."
+        ]),
+        "",
+        "## Output",
+        "",
+        ...(0, packet_workflow_1.renderBullets)([
+          "tests added or commands run",
+          "flows exercised and evidence captured",
+          "pass or fail result",
+          "coverage gaps that remain",
+          "packet notes or provisional packet path updated"
+        ]),
+        ""
+      ].join("\n");
+    }
+    function capitalize(value) {
+      return `${value.slice(0, 1).toUpperCase()}${value.slice(1)}`;
+    }
+  }
+});
+
+// ../../packages/repo-seed/dist/templates/renderCodexSkills.js
+var require_renderCodexSkills = __commonJS({
+  "../../packages/repo-seed/dist/templates/renderCodexSkills.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.renderCodexSwarmCraftPlanSkillFile = renderCodexSwarmCraftPlanSkillFile;
+    exports2.renderCodexSwarmCraftDoSkillFile = renderCodexSwarmCraftDoSkillFile;
+    exports2.renderCodexSwarmCraftCheckSkillFile = renderCodexSwarmCraftCheckSkillFile;
+    exports2.renderCodexSwarmCraftReviewSkillFile = renderCodexSwarmCraftReviewSkillFile;
+    exports2.renderCodexSwarmCraftTestSkillFile = renderCodexSwarmCraftTestSkillFile;
+    exports2.renderCodexPacketWorkflowSkillFile = renderCodexPacketWorkflowSkillFile;
+    exports2.renderCodexPacketSyncTriageSkillFile = renderCodexPacketSyncTriageSkillFile;
+    exports2.renderCodexRepoSeedAuditSkillFile = renderCodexRepoSeedAuditSkillFile;
+    var packet_workflow_1 = require_dist();
+    var renderAssistantActionSkills_1 = require_renderAssistantActionSkills();
+    function renderCodexSwarmCraftPlanSkillFile() {
+      return (0, renderAssistantActionSkills_1.renderSwarmCraftActionSkillFile)("plan");
+    }
+    function renderCodexSwarmCraftDoSkillFile() {
+      return (0, renderAssistantActionSkills_1.renderSwarmCraftActionSkillFile)("do");
+    }
+    function renderCodexSwarmCraftCheckSkillFile() {
+      return (0, renderAssistantActionSkills_1.renderSwarmCraftActionSkillFile)("check");
+    }
+    function renderCodexSwarmCraftReviewSkillFile() {
+      return (0, renderAssistantActionSkills_1.renderSwarmCraftActionSkillFile)("review");
+    }
+    function renderCodexSwarmCraftTestSkillFile() {
+      return (0, renderAssistantActionSkills_1.renderSwarmCraftActionSkillFile)("test");
+    }
+    function renderCodexPacketWorkflowSkillFile() {
+      return [
+        "---",
+        "name: packet-workflow",
+        "description: Legacy compatibility helper for repositories that still have the old broad SwarmCraft packet workflow skill. Prefer the action-specific swarmcraft-do, swarmcraft-check, swarmcraft-review, swarmcraft-plan, and swarmcraft-test skills for new work.",
+        "---",
+        "",
+        "# Legacy Packet Workflow",
+        "",
+        "This skill is a compatibility bridge for older seeded repositories. New SwarmCraft seed output uses action-specific skills instead.",
+        "",
+        "Use the action-specific skills when available:",
+        "",
+        "- `swarmcraft-plan` for planning, stale-plan review, or provisional packet drafting",
+        "- `swarmcraft-do` for doing-lane implementation",
+        "- `swarmcraft-check` for checking-lane validation",
+        "- `swarmcraft-review` for reviewing-lane human approval support",
+        "- `swarmcraft-test` for system testing and testing-focused packet work",
+        "",
+        "If only this legacy skill exists, infer the intended action from the user's requested lane or stage, read the linked packet under `.swarmcraft/projects/`, and follow the matching lane guidance under `.swarmcraft/agents/`.",
+        "",
+        "## Guardrails",
+        "",
+        "- Do not expose this skill as the normal user-facing command in new seed output.",
+        "- Preserve packet identity and sync fields unless SwarmCraft tooling rewrites them.",
+        "- Keep `do`, `check`, and `review` lane behavior aligned with the action-specific skills.",
+        "- Leave review-to-done movement to the SwarmCraft extension.",
+        "",
+        "## Output",
+        "",
+        "Report which action-specific workflow you followed and whether the repository should be reseeded to replace this compatibility helper.",
+        ""
+      ].join("\n");
+    }
+    function renderCodexPacketSyncTriageSkillFile() {
+      return [
+        "---",
+        "name: packet-sync-triage",
+        "description: Use when a SwarmCraft packet cannot sync cleanly, packet and board state disagree, or revision, lane, checklist, notes, or identity drift needs diagnosis.",
+        "---",
+        "",
+        "# Packet Sync Triage",
+        "",
+        "Use this skill when packet-backed work cannot be synchronized confidently between the repository and SwarmCraft.",
+        "",
+        "## Triage Procedure",
+        "",
+        "1. Read `.swarmcraft/AGENTS.md`, the packet, and the lane-specific guidance.",
+        "2. Confirm packet identity fields such as `projectId` and `ticketId` match the intended ticket.",
+        "3. Compare packet `syncRevision` with the current board revision when available.",
+        "4. Compare packet lane with board lane and allow only same-lane or adjacent-lane recovery.",
+        "5. Confirm checklist text and order still match the expected packet contract.",
+        "6. Decide whether the board, packet, or repository evidence is authoritative for the repair.",
+        "7. Record the repair path in packet notes or `## Agent Update` when the packet remains valid.",
+        "",
+        "## Recovery Choices",
+        "",
+        "- refresh packet from board state",
+        "- preserve packet text and manually reconcile before syncing",
+        "- restore packet identity or linkage",
+        "- stop lane transition and keep the ticket in its current lane",
+        "",
+        "## Output",
+        "",
+        "Report the mismatch category, evidence, chosen recovery path, and whether the packet is still safe to use.",
+        ""
+      ].join("\n");
+    }
+    function renderCodexRepoSeedAuditSkillFile() {
+      return [
+        "---",
+        "name: repo-seed-audit",
+        "description: Use when auditing whether SwarmCraft repository seed outputs are present, aligned, and internally consistent across shared, Copilot, and Codex guidance files.",
+        "---",
+        "",
+        "# Repo Seed Audit",
+        "",
+        "Use this skill to check that a seeded SwarmCraft workspace has coherent guidance across shared, Copilot, and Codex surfaces.",
+        "",
+        "## Expected Seed Surface",
+        "",
+        "- `.swarmcraft/AGENTS.md`",
+        "- `.swarmcraft/project.instructions.md`",
+        "- `.swarmcraft/project.context.md`",
+        "- `.swarmcraft/project.seed-summary.md`",
+        "- `.swarmcraft/agents/doing.instructions.md`",
+        "- `.swarmcraft/agents/checking.instructions.md`",
+        "- `.swarmcraft/agents/reviewing.instructions.md`",
+        "- `.github/instructions/swarmcraft/swarmcraft-packets.instructions.md`",
+        "- `.github/agents/swarmcraft-implementor.agent.md`",
+        "- `.github/agents/swarmcraft-checker.agent.md`",
+        "- `.github/agents/swarmcraft-reviewer.agent.md`",
+        ...packet_workflow_1.SWARMCRAFT_ASSISTANT_ACTIONS.flatMap((action) => [
+          `- \`${action.copilotPromptPath}\``,
+          `- \`${action.copilotSkillPath}\``,
+          `- \`${action.codexSkillPath}\``
+        ]),
+        "- `.codex/agents/swarmcraft-implementor.toml`",
+        "- `.codex/agents/swarmcraft-checker.toml`",
+        "- `.codex/agents/swarmcraft-reviewer.toml`",
+        "- `.codex/config.example.toml`",
+        "",
+        "## Audit Procedure",
+        "",
+        "1. Compare the declared seed surface with files present in the workspace.",
+        "2. Check for missing files, stale references, contradictory guidance, and path drift.",
+        "3. Confirm `plan`, `do`, `check`, `review`, and `test` are represented across Copilot prompts, Copilot skills, and Codex skills.",
+        "4. Confirm provider-specific files point back to `.swarmcraft` packets as the source of truth.",
+        "5. Recommend the smallest correction that restores alignment.",
+        "",
+        "## Output",
+        "",
+        "Report expected files, actual files, drift found, and the narrowest correction for each issue.",
+        ""
+      ].join("\n");
+    }
+  }
+});
+
+// ../../packages/repo-seed/dist/templates/renderCopilotSkills.js
+var require_renderCopilotSkills = __commonJS({
+  "../../packages/repo-seed/dist/templates/renderCopilotSkills.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.renderSwarmCraftPlanSkillFile = renderSwarmCraftPlanSkillFile;
+    exports2.renderSwarmCraftDoSkillFile = renderSwarmCraftDoSkillFile;
+    exports2.renderSwarmCraftCheckSkillFile = renderSwarmCraftCheckSkillFile;
+    exports2.renderSwarmCraftReviewSkillFile = renderSwarmCraftReviewSkillFile;
+    exports2.renderSwarmCraftTestSkillFile = renderSwarmCraftTestSkillFile;
+    exports2.renderPacketWorkflowSkillFile = renderPacketWorkflowSkillFile;
+    exports2.renderPacketSyncTriageSkillFile = renderPacketSyncTriageSkillFile;
+    exports2.renderRepoSeedAuditSkillFile = renderRepoSeedAuditSkillFile;
+    var packet_workflow_1 = require_dist();
+    var renderAssistantActionSkills_1 = require_renderAssistantActionSkills();
+    function renderSwarmCraftPlanSkillFile() {
+      return (0, renderAssistantActionSkills_1.renderSwarmCraftActionSkillFile)("plan");
+    }
+    function renderSwarmCraftDoSkillFile() {
+      return (0, renderAssistantActionSkills_1.renderSwarmCraftActionSkillFile)("do");
+    }
+    function renderSwarmCraftCheckSkillFile() {
+      return (0, renderAssistantActionSkills_1.renderSwarmCraftActionSkillFile)("check");
+    }
+    function renderSwarmCraftReviewSkillFile() {
+      return (0, renderAssistantActionSkills_1.renderSwarmCraftActionSkillFile)("review");
+    }
+    function renderSwarmCraftTestSkillFile() {
+      return (0, renderAssistantActionSkills_1.renderSwarmCraftActionSkillFile)("test");
+    }
+    function renderPacketWorkflowSkillFile() {
+      const doing = (0, packet_workflow_1.getSwarmCraftStageContract)("doing");
+      const checking = (0, packet_workflow_1.getSwarmCraftStageContract)("checking");
+      const reviewing = (0, packet_workflow_1.getSwarmCraftStageContract)("reviewing");
+      return [
+        "---",
+        "name: packet-workflow",
+        "description: Use when working a SwarmCraft ticket through its repo packet, reconciling packet and repo state, or preparing packet-backed work for sync and review. This skill explains how to use the packet as the execution contract without replacing the packet editing rules enforced by the instruction files.",
+        'argument-hint: "[packet=.swarmcraft/projects/.../ticket.md] [mode=implement|sync|review]"',
+        "---",
+        "",
+        "## Packet Workflow",
+        "",
+        "Use this skill when a SwarmCraft task is driven by a packet file under `.swarmcraft/projects/`.",
+        "",
+        "Do not use this skill to override repository rules. Packet editing rules remain defined by `.github/instructions/swarmcraft/swarmcraft-packets.instructions.md`. Treat this skill as the execution playbook that sits on top of those rules.",
+        "",
+        "## When To Use This Skill",
+        "",
+        "Use this skill when you need to:",
+        "",
+        "* implement a doing-lane ticket from its packet",
+        "* validate or complete checking-lane work from the packet contract",
+        "* prepare a reviewing-lane handoff from packet state and repo evidence",
+        "* reconcile packet, repo, and board state when they drift",
+        "* decide what validation is still required before the ticket can move forward",
+        "",
+        "Do not use this skill when the task is a general repository change with no packet, or when you only need the packet editing guardrails and no workflow guidance.",
+        "",
+        "## Required Inputs",
+        "",
+        "Gather these inputs before making substantive changes:",
+        "",
+        "* the packet file path when one already exists",
+        "* the current lane, if known",
+        "* the code or files implicated by the packet goal and checklist",
+        "",
+        "When they exist, read these guidance files before making substantive changes:",
+        "",
+        "* `.swarmcraft/AGENTS.md`",
+        "* `.swarmcraft/project.instructions.md`",
+        "* `.swarmcraft/project.context.md`",
+        "* the lane-specific guidance under `.swarmcraft/agents/`",
+        "",
+        "## Workflow",
+        "",
+        "### Step 1: Establish the packet contract",
+        "",
+        "1. Read the packet frontmatter and confirm the packet is the intended work item.",
+        "2. Read `## Goal`, all checklist sections, `## Notes`, and `## Agent Update` before planning edits.",
+        "3. Treat incomplete checklist items as the currently declared scope unless the packet itself is clearly stale.",
+        "4. If the packet and repository already disagree, surface the mismatch explicitly and reconcile it instead of silently working around it.",
+        "",
+        "### Step 2: Convert the packet into a narrow execution slice",
+        "",
+        "1. Identify the smallest code path that can satisfy the packet goal or the next unchecked checklist item.",
+        "2. Prefer the owning implementation surface over broad repo exploration.",
+        "3. Form one falsifiable local hypothesis about the change you need to make.",
+        "4. Choose the cheapest focused validation that could disconfirm that hypothesis.",
+        "",
+        "### Step 3: Implement against the packet",
+        "",
+        "1. Make the smallest change that advances the packet goal.",
+        "2. Keep packet-backed scope tight. Avoid opportunistic refactors unless the packet or failing validation forces them.",
+        "3. After the first substantive edit, run the focused validation before widening scope.",
+        "4. If validation fails, repair the same slice first instead of opening a second change area.",
+        "",
+        "### Step 4: Keep the packet current",
+        "",
+        "Update the packet as work progresses:",
+        "",
+        "* mark checklist items complete only when the repository state actually supports them",
+        "* mark every completed checklist item for the current lane once the repo state and validation support it",
+        "* record material implementation facts in `### Implementation Notes` under `## Notes`",
+        "* keep `## Agent Update` short and structured around what changed, what was validated, and what remains blocked or risky",
+        "",
+        "Use these standard note headings under `## Notes` when they apply:",
+        "",
+        ...(0, packet_workflow_1.renderBullets)(packet_workflow_1.SWARMCRAFT_STAGE_CONTRACTS.map((stage) => `${stage.noteHeading} for ${stage.commandDescription}, evidence, decisions, and remaining work`)),
+        "",
+        "Do not leave important execution knowledge only in chat.",
+        "",
+        "### Step 5: Reconcile sync-sensitive state",
+        "",
+        "When packet synchronization or ticket movement is part of the task:",
+        "",
+        "1. Preserve packet identity and sync metadata unless SwarmCraft tooling is the thing rewriting it.",
+        "2. Watch for packet-to-board mismatch signals such as stale revision, wrong lane, or wrong ticket identity.",
+        "3. If the packet appears stale, refresh or reconcile before applying more repo edits.",
+        "4. Do not hide drift by editing around it. State clearly whether the packet, the repo, or the board needs correction.",
+        "",
+        "### Step 6: Close the current lane cleanly",
+        "",
+        'Use the lane to decide what "done for now" means:',
+        "",
+        ...(0, packet_workflow_1.renderBullets)(packet_workflow_1.SWARMCRAFT_STAGE_CONTRACTS.map((stage) => stage.stageSummary)),
+        "",
+        "Move work forward only when packet state, repository state, and validation evidence agree. When all checklist items for the current lane are complete and no unresolved blocker, question, or validation gap remains, set the packet frontmatter `lane` to the next adjacent workflow lane instead of asking whether to do it. The only exception is reviewing-to-done: Reviewing checklist items require explicit human approval, and the final Move to Done action belongs to the SwarmCraft extension.",
+        "",
+        "## Doing Completion Loop",
+        "",
+        "When doing work is incomplete or unproven:",
+        "",
+        "1. Leave incomplete or unproven Doing checklist items unchecked.",
+        `2. Record the blocker, missing evidence, or remaining work in \`${doing.noteHeading}\` under \`## Notes\`.`,
+        "3. Update `## Agent Update` with the current state and keep packet frontmatter `lane: doing`.",
+        "",
+        "When doing work is complete:",
+        "",
+        "1. Mark every completed Doing checklist item complete once the repo state and validation support it.",
+        `2. Record implementation facts and validation evidence in \`${doing.noteHeading}\` under \`## Notes\`.`,
+        "3. Update `## Agent Update` with a concise implementation summary for the checking agent.",
+        `4. ${doing.completionRule}`,
+        "",
+        "## Checking Judge Loop",
+        "",
+        "Checking is a machine-in-the-loop judgment lane. The checking agent should decide whether the implementation is accepted for human review or rejected back to doing.",
+        "",
+        "When checking rejects the implementation:",
+        "",
+        "1. Leave failed or unproven checking checklist items unchecked.",
+        `2. Add or update \`${checking.noteHeading}\` under \`## Notes\` with the failed checklist item, evidence, validation result, and required fix.`,
+        "3. Update `## Agent Update` with a concise rejection summary.",
+        "4. Set the packet frontmatter `lane` to `doing` so packet sync moves the ticket back for implementation.",
+        "",
+        "When checking accepts the implementation:",
+        "",
+        "1. Mark only proven checking checklist items complete.",
+        "2. Record the validation evidence in `## Notes` and summarize acceptance in `## Agent Update`.",
+        `3. ${checking.completionRule}`,
+        "",
+        "Do not repair implementation defects during checking unless the user explicitly asks. The default checking job is judgment and feedback, not implementation.",
+        "",
+        "## Reviewing Approval Loop",
+        "",
+        "Reviewing is a human approval lane. The reviewing agent should prompt the user for approval decisions, record those decisions in the packet, and leave the final done transition to the SwarmCraft extension.",
+        "",
+        "Do not treat Reviewing like Checking. Existing repository evidence and validation results are inputs for the user's decision, not substitutes for explicit human approval.",
+        "",
+        "When review is incomplete or uncertain:",
+        "",
+        "1. Leave unapproved or uncertain Reviewing checklist items unchecked.",
+        `2. Record the reason under \`${reviewing.noteHeading}\` in \`## Notes\`.`,
+        "3. Update `## Agent Update` with the remaining approval, risk, or open question and keep packet frontmatter `lane: reviewing`.",
+        "",
+        "When review is fully approved:",
+        "",
+        "1. Mark a Reviewing checklist item complete only after the user explicitly confirms that item is approved.",
+        `2. Record approvals and any relevant review evidence the user considered under \`${reviewing.noteHeading}\` in \`## Notes\`.`,
+        "3. Update `## Agent Update` with a concise review-ready summary.",
+        `4. ${reviewing.completionRule}`,
+        "",
+        "## Output Expectations",
+        "",
+        "When you use this skill, produce outcomes that leave the repo and packet aligned:",
+        "",
+        "* code changes are scoped to the packet",
+        "* validation is concrete and recorded",
+        "* checklist state reflects reality",
+        "* notes and agent update capture the important facts another reviewer would need",
+        "* completed lane checklist items and lane movement are reflected in the packet whenever evidence supports them",
+        "",
+        "## Example Invocations",
+        "",
+        "* `/packet-workflow packet=.swarmcraft/projects/acme/2-auth.md mode=implement`",
+        "* `/packet-workflow packet=.swarmcraft/projects/acme/2-auth.md mode=sync`",
+        "* `/packet-workflow packet=.swarmcraft/projects/acme/2-auth.md mode=review`",
+        ""
+      ].join("\n");
+    }
+    function renderPacketSyncTriageSkillFile() {
+      return [
+        "---",
+        "name: packet-sync-triage",
+        "description: Use when a SwarmCraft packet cannot sync cleanly, the packet and board appear to disagree, or you need a disciplined recovery path for revision, lane, checklist, or packet identity mismatches.",
+        'argument-hint: "[packet=.swarmcraft/projects/.../ticket.md] [issue=revision|lane|identity|checklist|notes]"',
+        "---",
+        "",
+        "## Packet Sync Triage",
+        "",
+        "Use this skill when packet-backed work cannot be synchronized confidently between the repository and SwarmCraft.",
+        "",
+        "This skill is for diagnosis and recovery procedure inside the target repository. It does not assume access to the SwarmCraft extension source unless that source also exists in the current workspace, and it does not replace the packet editing rules in `.github/instructions/swarmcraft/swarmcraft-packets.instructions.md`.",
+        "",
+        "## When To Use This Skill",
+        "",
+        "Use this skill when you need to:",
+        "",
+        "* diagnose a failed packet sync",
+        "* determine whether the packet file is stale",
+        "* reconcile packet identity mismatches",
+        "* explain an unsupported lane transition",
+        "* verify whether checklist shape or notes content can sync safely",
+        "* decide whether the packet, board, or repository should be treated as the source needing repair",
+        "",
+        "Do not use this skill for ordinary ticket implementation when no sync problem exists.",
+        "",
+        "## Required Inputs",
+        "",
+        "Gather as many of these as possible before changing anything:",
+        "",
+        "* the packet file path",
+        "* the current packet contents",
+        "* the current board ticket state, including lane and revision",
+        "* the current repository state implicated by the packet",
+        "* the last observed sync or move error, if available",
+        "",
+        "Read these files when they exist:",
+        "",
+        "* `.swarmcraft/AGENTS.md`",
+        "* `.swarmcraft/project.instructions.md`",
+        "* `.swarmcraft/project.context.md`",
+        "* `.swarmcraft/agents/<lane>.instructions.md`",
+        "",
+        "## Triage Procedure",
+        "",
+        "### Step 1: Confirm packet identity first",
+        "",
+        "1. Read the packet frontmatter.",
+        "2. Confirm `projectId` and `ticketId` match the intended ticket.",
+        "3. If identity does not match, stop treating the file as the packet for the current ticket.",
+        "4. State explicitly whether the wrong file was opened, the link is stale, or the packet link metadata needs repair.",
+        "",
+        "### Step 2: Check sync revision before anything else",
+        "",
+        "1. Compare the packet `syncRevision` with the current board ticket revision.",
+        "2. If the packet revision is stale, do not continue making new packet-driven mutations as though the packet were current.",
+        "3. Identify whether the packet needs to be refreshed from the board, or whether unsynced local edits must be reconciled first.",
+        "",
+        "### Step 3: Validate lane movement",
+        "",
+        "1. Compare the packet lane to the board lane.",
+        "2. Treat same-lane sync as safe from a lane perspective.",
+        "3. Treat adjacent-lane moves as the outer limit of supported automatic movement.",
+        "4. If the requested move skips lanes or otherwise violates supported workflow movement, report that as the reason instead of forcing the transition.",
+        "",
+        "### Step 4: Validate checklist shape and notes intent",
+        "",
+        "1. Confirm the checklist stages still match the expected packet contract.",
+        "2. Treat checklist text and order as board-owned structure unless SwarmCraft explicitly regenerated the packet.",
+        "3. For notes and agent update, distinguish between factual execution updates and accidental drift.",
+        "4. If the packet has been reshaped in a way that no longer maps cleanly to board checklist items, treat that as a contract issue, not as a syncable edit.",
+        "",
+        "### Step 5: Decide the direction of repair",
+        "",
+        "Use these recovery choices:",
+        "",
+        "* board is authoritative for identity, revision, and current linkage",
+        "* packet is authoritative for in-progress execution notes only when it still matches the current ticket and revision contract",
+        "* repository evidence is authoritative for whether checklist items are actually satisfied",
+        "",
+        "At the end of triage, name the repair path clearly:",
+        "",
+        "* refresh packet from board state",
+        "* preserve packet text and manually reconcile before syncing",
+        "* restore packet identity or linkage",
+        "* stop lane transition and keep the ticket in its current lane",
+        "",
+        "### Step 6: Leave a clear audit trail",
+        "",
+        "When triage results in action:",
+        "",
+        "* explain what was wrong",
+        "* explain what was treated as authoritative",
+        "* explain what was changed or intentionally not changed",
+        "* update packet notes or agent update when the packet remains valid and the triage result is part of the ticket history",
+        "",
+        "## Output Expectations",
+        "",
+        "When you use this skill, produce a short structured outcome covering:",
+        "",
+        "* the mismatch category",
+        "* the evidence used to diagnose it",
+        "* the chosen recovery path",
+        "* whether the packet is still safe to use as the active execution contract",
+        "",
+        "## Example Invocations",
+        "",
+        "* `/packet-sync-triage packet=.swarmcraft/projects/acme/2-auth.md issue=revision`",
+        "* `/packet-sync-triage packet=.swarmcraft/projects/acme/2-auth.md issue=lane`",
+        "* `/packet-sync-triage packet=.swarmcraft/projects/acme/2-auth.md issue=identity`",
+        ""
+      ].join("\n");
+    }
+    function renderRepoSeedAuditSkillFile() {
+      return [
+        "---",
+        "name: repo-seed-audit",
+        "description: Use when auditing whether SwarmCraft repository seed outputs are present, aligned, and internally consistent across the local workspace files that SwarmCraft seeded into the target repository.",
+        'argument-hint: "[project=...] [scope=workspace|guidance|full]"',
+        "---",
+        "",
+        "## Repo Seed Audit",
+        "",
+        "Use this skill when you need to verify that SwarmCraft project seeding is coherent across the repository.",
+        "",
+        "This skill is for consistency auditing inside the target repository after SwarmCraft files have been seeded. It does not assume access to the SwarmCraft product repository, extension source, or API source unless those files also exist in the current workspace.",
+        "",
+        "## When To Use This Skill",
+        "",
+        "Use this skill when you need to:",
+        "",
+        "* check whether a workspace has all expected SwarmCraft seed files",
+        "* detect drift between seeded paths, descriptions, and rendered guidance",
+        "* validate that a new seed artifact has been wired through all required surfaces",
+        "* review whether root guidance, `.swarmcraft/` files, and `.github/` customizations still agree",
+        "",
+        "Do not use this skill for a normal packet editing task.",
+        "",
+        "## Required Inputs",
+        "",
+        "Gather these inputs when available:",
+        "",
+        "* the target project or workspace folder",
+        "* the expected seeded file set",
+        "* any local documentation that explains which SwarmCraft files should exist",
+        "* the actual `.swarmcraft/` and `.github/` files present in the current workspace",
+        "",
+        "When they exist, use these repository anchors when auditing:",
+        "",
+        "* `.swarmcraft/AGENTS.md`",
+        "* `.swarmcraft/project.instructions.md`",
+        "* `.swarmcraft/project.context.md`",
+        "* `.swarmcraft/project.seed-summary.md`",
+        "* `.github/instructions/swarmcraft/swarmcraft-packets.instructions.md`",
+        "* `.github/agents/`",
+        "* `.github/skills/`",
+        "",
+        "Expected seeded guidance commonly includes:",
+        "",
+        "* `.swarmcraft/AGENTS.md`",
+        "* `.swarmcraft/project.instructions.md`",
+        "* `.swarmcraft/project.context.md`",
+        "* `.swarmcraft/project.seed-summary.md`",
+        "* `.swarmcraft/agents/doing.instructions.md`",
+        "* `.swarmcraft/agents/checking.instructions.md`",
+        "* `.swarmcraft/agents/reviewing.instructions.md`",
+        "* `.github/instructions/swarmcraft/swarmcraft-packets.instructions.md`",
+        "* `.github/agents/swarmcraft-implementor.agent.md`",
+        "* `.github/agents/swarmcraft-checker.agent.md`",
+        "* `.github/agents/swarmcraft-reviewer.agent.md`",
+        ...packet_workflow_1.SWARMCRAFT_ASSISTANT_ACTIONS.flatMap((action) => [
+          `* \`${action.copilotPromptPath}\``,
+          `* \`${action.copilotSkillPath}\``,
+          `* \`${action.codexSkillPath}\``
+        ]),
+        "* `.codex/agents/swarmcraft-implementor.toml`",
+        "* `.codex/agents/swarmcraft-checker.toml`",
+        "* `.codex/agents/swarmcraft-reviewer.toml`",
+        "* `.codex/config.example.toml`",
+        "",
+        "## Audit Procedure",
+        "",
+        "### Step 1: Establish the expected seed surface",
+        "",
+        "1. Read the local SwarmCraft guidance files first.",
+        "2. Record the canonical relative paths the seeded workspace appears to expect.",
+        "3. Record any root-file pointer behavior such as guidance written into `AGENTS.md`.",
+        "",
+        "### Step 2: Compare local declarations and local reality",
+        "",
+        "1. Compare what the local guidance implies should exist with what actually exists in the workspace.",
+        "2. Look for path drift, missing files, stale references, or contradictory descriptions.",
+        '3. Treat a path mismatch as a real integration defect even if the workspace still "mostly works."',
+        "",
+        "### Step 3: Check rendered content ownership",
+        "",
+        "1. Identify which files look machine-seeded versus manually maintained.",
+        "2. Confirm the guidance still matches the repository's current SwarmCraft workflow.",
+        "3. Check whether any referenced file moved or was deleted without the surrounding guidance being updated.",
+        "",
+        "### Step 4: Verify repository reality",
+        "",
+        "1. Inspect whether the expected seeded files actually exist in the target workspace when the audit is against a real seeded project.",
+        "2. Confirm that root guidance points to the deeper SwarmCraft files rather than contradicting them.",
+        "3. Confirm that `.github` customizations live in the discovery paths expected by VS Code.",
+        "",
+        "### Step 5: Report drift precisely",
+        "",
+        "Classify findings clearly:",
+        "",
+        "* missing expected seed file",
+        "* stale reference in local guidance",
+        "* contradictory guidance between local files",
+        "* path mismatch between local references and local files",
+        "* stale managed content or seeded output",
+        "* file exists in the repo but is no longer referenced by the local SwarmCraft guidance",
+        "",
+        "### Step 6: Recommend the narrowest correction",
+        "",
+        "For each finding, state the smallest correction that restores alignment:",
+        "",
+        "* add the missing file",
+        "* update the local guidance to reference the right path",
+        "* remove stale references that no longer match actual seeded outputs",
+        "* regenerate or manually repair seeded guidance when it drifted",
+        "",
+        "## Output Expectations",
+        "",
+        "When you use this skill, produce a concise audit result covering:",
+        "",
+        "* the expected seed surface",
+        "* the actual declared seed surface",
+        "* any drift found",
+        "* the narrowest corrective action for each mismatch",
+        "",
+        "## Example Invocations",
+        "",
+        "* `/repo-seed-audit scope=full`",
+        "* `/repo-seed-audit project=acme scope=workspace`",
+        "* `/repo-seed-audit scope=guidance`",
+        ""
+      ].join("\n");
+    }
+  }
+});
+
+// ../../packages/repo-seed/dist/templates/renderCopilotPrompts.js
+var require_renderCopilotPrompts = __commonJS({
+  "../../packages/repo-seed/dist/templates/renderCopilotPrompts.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.renderPlanPromptFile = renderPlanPromptFile;
+    exports2.renderDoPromptFile = renderDoPromptFile;
+    exports2.renderCheckPromptFile = renderCheckPromptFile;
+    exports2.renderReviewPromptFile = renderReviewPromptFile;
+    exports2.renderTestPromptFile = renderTestPromptFile;
+    var packet_workflow_1 = require_dist();
+    function renderPlanPromptFile() {
+      const action = (0, packet_workflow_1.getSwarmCraftAssistantAction)("plan");
+      return renderLaneIndependentPromptFile(action, {
+        title: "Plan Work",
+        description: "Creates or checks a SwarmCraft plan and can draft a provisional todo packet for sync",
+        inputName: "scope",
+        inputDescription: "Planning request, existing plan path, or new ticket scope.",
+        requirements: [
+          "Follow the workflow in [SwarmCraft Plan](../skills/swarmcraft-plan/SKILL.md).",
+          "Read SwarmCraft project context and nearby packets before drafting new scope.",
+          "Report stale assumptions, incoherent scope, duplicate work, and dependency drift when checking an existing plan.",
+          "Create only one focused provisional packet when new board work is requested.",
+          "Do not modify existing board-linked packets or plans unless explicitly asked."
+        ]
+      });
+    }
+    function renderDoPromptFile() {
+      return renderStagePromptFile("doing");
+    }
+    function renderCheckPromptFile() {
+      return renderStagePromptFile("checking");
+    }
+    function renderReviewPromptFile() {
+      return renderStagePromptFile("reviewing");
+    }
+    function renderTestPromptFile() {
+      const action = (0, packet_workflow_1.getSwarmCraftAssistantAction)("test");
+      return renderLaneIndependentPromptFile(action, {
+        title: "Test Work",
+        description: "Adds, runs, or documents system testing coverage for SwarmCraft packet work",
+        inputName: "scope",
+        inputDescription: "Existing packet path, testing request, or coverage gap.",
+        requirements: [
+          "Follow the workflow in [SwarmCraft Test](../skills/swarmcraft-test/SKILL.md).",
+          "Prefer full-system evidence for user-facing workflows.",
+          "Record commands run, flows exercised, evidence captured, pass or fail result, and coverage gaps.",
+          "When working an existing packet, record test evidence under `## Notes` without adding a new lane.",
+          "Keep implementation fixes out of test work unless explicitly asked."
+        ]
+      });
+    }
+    function renderStagePromptFile(stageKey) {
+      const stage = (0, packet_workflow_1.getSwarmCraftStageContract)(stageKey);
+      const action = (0, packet_workflow_1.getSwarmCraftAssistantAction)(stage.command.slice(1));
+      const skillName = `SwarmCraft ${capitalize(action.key)}`;
+      const skillRelativePath = `../skills/swarmcraft-${action.key}/SKILL.md`;
+      const requirements = [
+        `Follow the workflow in [${skillName}](${skillRelativePath}).`,
+        ...stage.promptRequirements
+      ];
+      return [
+        "---",
+        `description: '${stage.promptDescription}'`,
+        "argument-hint: 'ticket=.swarmcraft/projects/.../<ticket>.md'",
+        "---",
+        "",
+        `#file:${action.copilotSkillPath}`,
+        "",
+        `# ${stage.promptTitle}`,
+        "",
+        "## Inputs",
+        "",
+        "* ${input:ticket}: (Required) Path to the linked SwarmCraft packet file.",
+        "",
+        "## Requirements",
+        "",
+        ...(0, packet_workflow_1.renderNumberedLines)(requirements),
+        "",
+        "Proceed with the user's request using `${input:ticket}` as the ticket packet.",
+        ""
+      ].join("\n");
+    }
+    function renderLaneIndependentPromptFile(action, input2) {
+      return [
+        "---",
+        `description: '${input2.description}'`,
+        `argument-hint: '${input2.inputName}=<request-or-path>'`,
+        "---",
+        "",
+        `#file:${action.copilotSkillPath}`,
+        "",
+        `# ${input2.title}`,
+        "",
+        "## Inputs",
+        "",
+        `* \${input:${input2.inputName}}: ${input2.inputDescription}`,
+        "",
+        "## Requirements",
+        "",
+        ...(0, packet_workflow_1.renderNumberedLines)(input2.requirements),
+        "",
+        `Proceed with the user's request using \`\${input:${input2.inputName}}\` as the action scope.`,
+        ""
+      ].join("\n");
+    }
+    function capitalize(value) {
+      return `${value.slice(0, 1).toUpperCase()}${value.slice(1)}`;
+    }
+  }
+});
+
+// ../../packages/repo-seed/dist/templates/renderProjectContext.js
+var require_renderProjectContext = __commonJS({
+  "../../packages/repo-seed/dist/templates/renderProjectContext.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.renderProjectInstructionsFile = renderProjectInstructionsFile;
+    exports2.renderProjectContextFile = renderProjectContextFile;
+    function renderProjectInstructionsFile(project) {
+      const projectTitle = project.title?.trim() || project.id;
+      const projectSummary = project.summary?.trim() || "Add the product and delivery context for this project here.";
+      const primaryTargetProduct = project.primaryTargetProduct?.trim() || "Add the primary target product or surface here.";
+      return [
+        "# Project Instructions",
+        "",
+        "SwarmCraft seeds this file once and preserves later human edits.",
+        "",
+        "## Project",
+        "",
+        `- Title: ${projectTitle}`,
+        `- Summary: ${projectSummary}`,
+        `- Primary target product: ${primaryTargetProduct}`,
+        "",
+        "## Project-Specific Guidance",
+        "",
+        "Add architecture boundaries, style expectations, rollout constraints, and protected areas here.",
+        "",
+        "## Review Notes",
+        "",
+        "Document anything that agents should not change without explicit review.",
+        ""
+      ].join("\n");
+    }
+    function renderProjectContextFile(project) {
+      const repoSeedContext = project.repoSeed?.projectContext;
+      const actors = formatSummaryList(repoSeedContext?.actors, "Add the primary workflow actors here.");
+      const ecosystemDependencies = formatSummaryList(repoSeedContext?.ecosystemDependencies, "Add the ecosystem dependencies here.");
+      const constraints = formatSummaryList(repoSeedContext?.constraints, "Add the project constraints here.");
+      const brandDirection = repoSeedContext?.brandDirection?.trim() || "Add the brand direction here.";
+      const targetPlatform = repoSeedContext?.targetPlatform?.trim() || "Add the target platform here.";
+      const deploymentEnvironment = repoSeedContext?.deploymentEnvironment?.trim() || "Add the deployment environment here.";
+      const technologyPreference = renderTechnologyPreference(repoSeedContext?.technologyPreference, repoSeedContext?.preferredTechnologies ?? []);
+      return [
+        "# Project Context",
+        "",
+        "This file captures the richer project context that the engine-owned repo seed supplied during repository seeding.",
+        "",
+        "## Operating Context",
+        "",
+        `- Actors: ${actors}`,
+        `- Ecosystem dependencies: ${ecosystemDependencies}`,
+        `- Constraints: ${constraints}`,
+        `- Brand direction: ${brandDirection}`,
+        `- Target platform: ${targetPlatform}`,
+        `- Deployment environment: ${deploymentEnvironment}`,
+        `- Technology preference: ${technologyPreference}`,
+        ""
+      ].join("\n");
+    }
+    function formatSummaryList(values, fallback) {
+      if (!values || values.length === 0) {
+        return fallback;
+      }
+      return values.join(", ");
+    }
+    function renderTechnologyPreference(technologyPreference, preferredTechnologies) {
+      if (technologyPreference === "PREFERRED") {
+        return preferredTechnologies.length > 0 ? `Preferred (${preferredTechnologies.join(", ")})` : "Preferred";
+      }
+      if (technologyPreference === "DONT_CARE") {
+        return "Don't care";
+      }
+      return "Unspecified";
+    }
+  }
+});
+
+// ../../packages/repo-seed/dist/templates/renderProjectGuide.js
+var require_renderProjectGuide = __commonJS({
+  "../../packages/repo-seed/dist/templates/renderProjectGuide.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.MANAGED_SECTION_START = exports2.MANAGED_SECTION_END = void 0;
+    exports2.renderSwarmCraftAgentsFile = renderSwarmCraftAgentsFile;
+    exports2.renderProjectSeedSummaryFile = renderProjectSeedSummaryFile;
+    exports2.renderRootAgentsManagedSection = renderRootAgentsManagedSection;
+    var packet_workflow_1 = require_dist();
+    var MANAGED_SECTION_START = "<!-- BEGIN SWARMCRAFT MANAGED SECTION -->";
+    exports2.MANAGED_SECTION_START = MANAGED_SECTION_START;
+    var MANAGED_SECTION_END = "<!-- END SWARMCRAFT MANAGED SECTION -->";
+    exports2.MANAGED_SECTION_END = MANAGED_SECTION_END;
+    function renderSwarmCraftAgentsFile(project) {
+      const projectTitle = project.title?.trim() || project.id;
+      return [
+        "# SwarmCraft Agent Guide",
+        "",
+        `This repository uses SwarmCraft planning packets for ${projectTitle}.`,
+        "Treat the linked packet under .swarmcraft/projects/ as the source of truth for scoped work.",
+        "",
+        "## Start Here",
+        "",
+        "1. If SwarmCraft copied an action command, run that command in your AI chat surface first.",
+        "2. Read this file before editing code or moving ticket state.",
+        "3. Open the linked packet under .swarmcraft/projects/<project-slug>/<recommended-order>-<ticket-slug>.md.",
+        "4. Read .swarmcraft/project.instructions.md and .swarmcraft/project.context.md for project-specific context.",
+        "5. Read the lane-specific guidance under .swarmcraft/agents/ for the current workflow stage.",
+        "",
+        "Primary assistant actions:",
+        "",
+        ...packet_workflow_1.SWARMCRAFT_ASSISTANT_ACTIONS.map((action) => `- \`${action.copilotInvocation}\` in Copilot or \`${action.codexInvocation}\` in Codex: ${action.description}`),
+        "",
+        "When copied from the VS Code extension, the exact command format follows the workspace's selected AI provider:",
+        "",
+        "- Copilot copies `/plan`, `/do`, `/check`, `/review`, and `/test` prompt commands for `.github/prompts`.",
+        "- Codex copies `$swarmcraft-plan`, `$swarmcraft-do`, `$swarmcraft-check`, `$swarmcraft-review`, and `$swarmcraft-test` skill invocations for `.agents/skills`.",
+        "",
+        "## Packet Workflow",
+        "",
+        "- Use the packet Goal section to understand the intended outcome.",
+        "- Treat the staged checklist sections as the definition of done for each workflow lane.",
+        "- Mark completed checklist items in the packet as soon as repository state and validation support them.",
+        "- Keep the Notes section current with implementation details and decisions.",
+        "- Keep the Agent Update section current with status, blockers, and follow-up work.",
+        "- When all current-lane checklist items are complete and no blockers or questions remain, set the packet frontmatter `lane` to the next adjacent lane, except review-to-done which is owned by the extension.",
+        "- Keep the packet aligned with the actual code and board state before promoting the ticket.",
+        "",
+        "## Guardrails",
+        "",
+        "- Implement only the scoped ticket work unless the packet explicitly calls for adjacent changes.",
+        "- Keep diffs small, reviewable, and easy to validate.",
+        "- Do not rewrite packet identity fields or move packet files to a different path.",
+        "- If the packet, repo, and board state diverge, reconcile them before moving the ticket forward.",
+        "- Leave clear context for the next agent or reviewer in the packet instead of only in chat.",
+        "",
+        "## Lane Guidance",
+        "",
+        ...packet_workflow_1.SWARMCRAFT_STAGE_CONTRACTS.map((stage) => `- ${stage.stageSummary}`),
+        "",
+        "## Provider Adapters",
+        "",
+        "- .swarmcraft packets, project context, and lane instructions are the shared SwarmCraft contract.",
+        "- Provider-specific files under .github, .agents, and .codex are adapters for the same `plan`, `do`, `check`, `review`, and `test` workflow.",
+        "- SwarmCraft Implementor: execute the doing-lane packet work and keep the packet current.",
+        "- SwarmCraft Checker: run focused validation and reconcile the packet with the repo state.",
+        "- SwarmCraft Reviewer: prompt the human reviewer for approval decisions and record them without acting as another checking pass.",
+        "",
+        "## Seeded Files",
+        "",
+        "- .swarmcraft/project.instructions.md contains project-specific guidance and protected constraints.",
+        "- .swarmcraft/project.context.md contains actors, dependencies, platforms, and rollout context.",
+        "- .swarmcraft/project.seed-summary.md records the engine-owned repo context that was seeded.",
+        "- .swarmcraft/agents/doing.instructions.md contains implementation-stage guidance.",
+        "- .swarmcraft/agents/checking.instructions.md contains validation-stage guidance.",
+        "- .swarmcraft/agents/reviewing.instructions.md contains review-stage guidance.",
+        "- .github/instructions/swarmcraft/swarmcraft-packets.instructions.md auto-applies packet editing guardrails.",
+        "- .github/agents/swarmcraft-implementor.agent.md provides the implementation agent in the Copilot agent picker.",
+        "- .github/agents/swarmcraft-checker.agent.md provides the validation agent in the Copilot agent picker.",
+        "- .github/agents/swarmcraft-reviewer.agent.md provides the review-prep agent in the Copilot agent picker.",
+        "- .github/skills/swarmcraft-plan/SKILL.md provides the Copilot planning skill.",
+        "- .github/skills/swarmcraft-do/SKILL.md provides the Copilot doing skill.",
+        "- .github/skills/swarmcraft-check/SKILL.md provides the Copilot checking skill.",
+        "- .github/skills/swarmcraft-review/SKILL.md provides the Copilot reviewing skill.",
+        "- .github/skills/swarmcraft-test/SKILL.md provides the Copilot testing skill.",
+        "- .github/prompts/plan.prompt.md provides the `/plan` command wrapper.",
+        "- .github/prompts/do.prompt.md provides the `/do ticket=...` command wrapper.",
+        "- .github/prompts/check.prompt.md provides the `/check ticket=...` command wrapper.",
+        "- .github/prompts/review.prompt.md provides the `/review ticket=...` command wrapper.",
+        "- .github/prompts/test.prompt.md provides the `/test` command wrapper.",
+        "- .agents/skills/swarmcraft-plan/SKILL.md provides the Codex planning skill.",
+        "- .agents/skills/swarmcraft-do/SKILL.md provides the Codex doing skill.",
+        "- .agents/skills/swarmcraft-check/SKILL.md provides the Codex checking skill.",
+        "- .agents/skills/swarmcraft-review/SKILL.md provides the Codex reviewing skill.",
+        "- .agents/skills/swarmcraft-test/SKILL.md provides the Codex testing skill.",
+        "- .codex/agents/swarmcraft-implementor.toml provides the optional Codex implementor project agent.",
+        "- .codex/agents/swarmcraft-checker.toml provides the optional Codex checker project agent.",
+        "- .codex/agents/swarmcraft-reviewer.toml provides the optional Codex reviewer project agent.",
+        "- .codex/config.example.toml documents optional local Codex setup without committing secrets.",
+        ""
+      ].join("\n");
+    }
+    function renderProjectSeedSummaryFile(project) {
+      const repoSeed = project.repoSeed;
+      const workspaceInstructions = repoSeed?.workspaceInstructions ?? [];
+      const suggestedStructures = repoSeed?.suggestedStructures ?? [];
+      const syncPolicy = repoSeed?.syncPolicy;
+      const seededGuidanceLines = workspaceInstructions.length > 0 ? workspaceInstructions.map((instruction) => `- ${instruction.relativePath}: ${instruction.purpose}`) : ["- Add the seeded workspace instruction files here."];
+      const suggestedStructureLines = suggestedStructures.length > 0 ? suggestedStructures.map((structure) => `- ${structure.relativePath}: ${structure.reason}`) : ["- Add the suggested repository structure here."];
+      const syncPolicyLines = syncPolicy ? [
+        `- Lane sync: ${formatSyncPolicyState(syncPolicy.allowLaneSync, "Adjacent lane changes can sync from the packet back to SwarmCraft.", "Workflow lane changes remain board-authoritative.")}`,
+        `- Checklist sync: ${formatSyncPolicyState(syncPolicy.allowChecklistSync, "Checklist completion can sync from the packet back to SwarmCraft.", "Checklist completion remains board-authoritative.")}`,
+        `- Notes sync: ${formatSyncPolicyState(syncPolicy.allowNotesSync, "Packet Notes can sync back to SwarmCraft.", "Packet Notes are treated as local-only guidance.")}`,
+        `- Agent update sync: ${formatSyncPolicyState(syncPolicy.allowAgentUpdateSync, "Packet Agent Update content can sync back to SwarmCraft.", "Packet Agent Update content is treated as local-only guidance.")}`
+      ] : ["- Sync policy was not included in the current project detail payload."];
+      return [
+        "# Project Seed Summary",
+        "",
+        "This file captures the repo-facing slice of the engine-owned project seed that SwarmCraft used during initial repository seeding.",
+        "",
+        "## Seeded Guidance",
+        "",
+        ...seededGuidanceLines,
+        "",
+        "## Suggested Structure",
+        "",
+        ...suggestedStructureLines,
+        "",
+        "## Packet Sync Policy",
+        "",
+        ...syncPolicyLines,
+        "",
+        "## Surface Ownership",
+        "",
+        "- Engine-generated: .swarmcraft/AGENTS.md, .swarmcraft/project.context.md, .swarmcraft/project.seed-summary.md, and the lane guidance files are seeded from the engine-owned project seed.",
+        "- Human-authored: .swarmcraft/project.instructions.md is preserved after the first seed and can be refined by the project team.",
+        "- Repo-editable: packet checkbox completion, Notes, Agent Update, and adjacent lane moves are repo-editable only when the packet sync policy above allows them.",
+        "- Board-authoritative: packet identity fields, board revision, ticket ordering, and checklist text or structure remain owned by SwarmCraft.",
+        ""
+      ].join("\n");
+    }
+    function formatSyncPolicyState(enabled, enabledText, disabledText) {
+      return enabled ? enabledText : disabledText;
+    }
+    function renderRootAgentsManagedSection(project) {
+      const projectTitle = project.title?.trim() || project.id;
+      return [
+        MANAGED_SECTION_START,
+        "## SwarmCraft",
+        "",
+        `${projectTitle} uses SwarmCraft planning packets and agent guidance files under .swarmcraft/.`,
+        "",
+        "When working on a SwarmCraft-scoped ticket:",
+        "- start with .swarmcraft/AGENTS.md",
+        "- then open the linked packet under .swarmcraft/projects/",
+        "- use the packet as the source of truth for scoped work and status updates",
+        MANAGED_SECTION_END,
+        ""
+      ].join("\n");
+    }
+  }
+});
+
+// ../../packages/repo-seed/dist/templates/renderWorkspaceInstructions.js
+var require_renderWorkspaceInstructions = __commonJS({
+  "../../packages/repo-seed/dist/templates/renderWorkspaceInstructions.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.renderDoingInstructionsFile = renderDoingInstructionsFile;
+    exports2.renderCheckingInstructionsFile = renderCheckingInstructionsFile;
+    exports2.renderReviewingInstructionsFile = renderReviewingInstructionsFile;
+    var packet_workflow_1 = require_dist();
+    function renderDoingInstructionsFile() {
+      return renderLaneInstructionsFile("doing");
+    }
+    function renderCheckingInstructionsFile() {
+      return renderLaneInstructionsFile("checking");
+    }
+    function renderReviewingInstructionsFile() {
+      return renderLaneInstructionsFile("reviewing");
+    }
+    function renderLaneInstructionsFile(stageKey) {
+      const stage = (0, packet_workflow_1.getSwarmCraftStageContract)(stageKey);
+      return [
+        `# ${stage.laneInstructionsTitle}`,
+        "",
+        ...(0, packet_workflow_1.renderBullets)(stage.laneInstructions),
+        ""
+      ].join("\n");
+    }
+  }
+});
+
+// ../../packages/repo-seed/dist/seedProjectContext.js
+var require_seedProjectContext = __commonJS({
+  "../../packages/repo-seed/dist/seedProjectContext.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.CODEX_CONFIG_EXAMPLE_FILE_PATH = exports2.CODEX_REVIEWER_AGENT_FILE_PATH = exports2.CODEX_CHECKER_AGENT_FILE_PATH = exports2.CODEX_IMPLEMENTOR_AGENT_FILE_PATH = exports2.CODEX_TEST_SKILL_FILE_PATH = exports2.CODEX_REVIEW_SKILL_FILE_PATH = exports2.CODEX_CHECK_SKILL_FILE_PATH = exports2.CODEX_DO_SKILL_FILE_PATH = exports2.CODEX_PLAN_SKILL_FILE_PATH = exports2.TEST_PROMPT_FILE_PATH = exports2.REVIEW_PROMPT_FILE_PATH = exports2.CHECK_PROMPT_FILE_PATH = exports2.DO_PROMPT_FILE_PATH = exports2.PLAN_PROMPT_FILE_PATH = exports2.TEST_SKILL_FILE_PATH = exports2.REVIEW_SKILL_FILE_PATH = exports2.CHECK_SKILL_FILE_PATH = exports2.DO_SKILL_FILE_PATH = exports2.PLAN_SKILL_FILE_PATH = exports2.REVIEWER_AGENT_FILE_PATH = exports2.CHECKER_AGENT_FILE_PATH = exports2.IMPLEMENTOR_AGENT_FILE_PATH = exports2.PACKET_INSTRUCTIONS_FILE_PATH = exports2.REVIEWING_INSTRUCTIONS_FILE_PATH = exports2.CHECKING_INSTRUCTIONS_FILE_PATH = exports2.DOING_INSTRUCTIONS_FILE_PATH = exports2.PROJECT_SEED_SUMMARY_FILE_PATH = exports2.PROJECT_CONTEXT_FILE_PATH = exports2.PROJECT_INSTRUCTIONS_FILE_PATH = exports2.SWARMCRAFT_AGENTS_FILE_PATH = void 0;
+    exports2.buildProjectSeedFiles = buildProjectSeedFiles;
+    var renderCopilotAgents_1 = require_renderCopilotAgents();
+    var renderCodexAgents_1 = require_renderCodexAgents();
+    var renderCodexSkills_1 = require_renderCodexSkills();
+    var renderCopilotSkills_1 = require_renderCopilotSkills();
+    var renderCopilotPrompts_1 = require_renderCopilotPrompts();
+    var renderProjectContext_1 = require_renderProjectContext();
+    var renderProjectGuide_1 = require_renderProjectGuide();
+    var renderWorkspaceInstructions_1 = require_renderWorkspaceInstructions();
+    exports2.SWARMCRAFT_AGENTS_FILE_PATH = ".swarmcraft/AGENTS.md";
+    exports2.PROJECT_INSTRUCTIONS_FILE_PATH = ".swarmcraft/project.instructions.md";
+    exports2.PROJECT_CONTEXT_FILE_PATH = ".swarmcraft/project.context.md";
+    exports2.PROJECT_SEED_SUMMARY_FILE_PATH = ".swarmcraft/project.seed-summary.md";
+    exports2.DOING_INSTRUCTIONS_FILE_PATH = ".swarmcraft/agents/doing.instructions.md";
+    exports2.CHECKING_INSTRUCTIONS_FILE_PATH = ".swarmcraft/agents/checking.instructions.md";
+    exports2.REVIEWING_INSTRUCTIONS_FILE_PATH = ".swarmcraft/agents/reviewing.instructions.md";
+    exports2.PACKET_INSTRUCTIONS_FILE_PATH = ".github/instructions/swarmcraft/swarmcraft-packets.instructions.md";
+    exports2.IMPLEMENTOR_AGENT_FILE_PATH = ".github/agents/swarmcraft-implementor.agent.md";
+    exports2.CHECKER_AGENT_FILE_PATH = ".github/agents/swarmcraft-checker.agent.md";
+    exports2.REVIEWER_AGENT_FILE_PATH = ".github/agents/swarmcraft-reviewer.agent.md";
+    exports2.PLAN_SKILL_FILE_PATH = ".github/skills/swarmcraft-plan/SKILL.md";
+    exports2.DO_SKILL_FILE_PATH = ".github/skills/swarmcraft-do/SKILL.md";
+    exports2.CHECK_SKILL_FILE_PATH = ".github/skills/swarmcraft-check/SKILL.md";
+    exports2.REVIEW_SKILL_FILE_PATH = ".github/skills/swarmcraft-review/SKILL.md";
+    exports2.TEST_SKILL_FILE_PATH = ".github/skills/swarmcraft-test/SKILL.md";
+    exports2.PLAN_PROMPT_FILE_PATH = ".github/prompts/plan.prompt.md";
+    exports2.DO_PROMPT_FILE_PATH = ".github/prompts/do.prompt.md";
+    exports2.CHECK_PROMPT_FILE_PATH = ".github/prompts/check.prompt.md";
+    exports2.REVIEW_PROMPT_FILE_PATH = ".github/prompts/review.prompt.md";
+    exports2.TEST_PROMPT_FILE_PATH = ".github/prompts/test.prompt.md";
+    exports2.CODEX_PLAN_SKILL_FILE_PATH = ".agents/skills/swarmcraft-plan/SKILL.md";
+    exports2.CODEX_DO_SKILL_FILE_PATH = ".agents/skills/swarmcraft-do/SKILL.md";
+    exports2.CODEX_CHECK_SKILL_FILE_PATH = ".agents/skills/swarmcraft-check/SKILL.md";
+    exports2.CODEX_REVIEW_SKILL_FILE_PATH = ".agents/skills/swarmcraft-review/SKILL.md";
+    exports2.CODEX_TEST_SKILL_FILE_PATH = ".agents/skills/swarmcraft-test/SKILL.md";
+    exports2.CODEX_IMPLEMENTOR_AGENT_FILE_PATH = ".codex/agents/swarmcraft-implementor.toml";
+    exports2.CODEX_CHECKER_AGENT_FILE_PATH = ".codex/agents/swarmcraft-checker.toml";
+    exports2.CODEX_REVIEWER_AGENT_FILE_PATH = ".codex/agents/swarmcraft-reviewer.toml";
+    exports2.CODEX_CONFIG_EXAMPLE_FILE_PATH = ".codex/config.example.toml";
+    function buildProjectSeedFiles(project) {
+      return [
+        {
+          relativePath: exports2.SWARMCRAFT_AGENTS_FILE_PATH,
+          contents: (0, renderProjectGuide_1.renderSwarmCraftAgentsFile)(project)
+        },
+        {
+          relativePath: exports2.PROJECT_INSTRUCTIONS_FILE_PATH,
+          contents: (0, renderProjectContext_1.renderProjectInstructionsFile)(project)
+        },
+        {
+          relativePath: exports2.PROJECT_CONTEXT_FILE_PATH,
+          contents: (0, renderProjectContext_1.renderProjectContextFile)(project)
+        },
+        {
+          relativePath: exports2.PROJECT_SEED_SUMMARY_FILE_PATH,
+          contents: (0, renderProjectGuide_1.renderProjectSeedSummaryFile)(project)
+        },
+        {
+          relativePath: exports2.DOING_INSTRUCTIONS_FILE_PATH,
+          contents: (0, renderWorkspaceInstructions_1.renderDoingInstructionsFile)()
+        },
+        {
+          relativePath: exports2.CHECKING_INSTRUCTIONS_FILE_PATH,
+          contents: (0, renderWorkspaceInstructions_1.renderCheckingInstructionsFile)()
+        },
+        {
+          relativePath: exports2.REVIEWING_INSTRUCTIONS_FILE_PATH,
+          contents: (0, renderWorkspaceInstructions_1.renderReviewingInstructionsFile)()
+        },
+        {
+          relativePath: exports2.PACKET_INSTRUCTIONS_FILE_PATH,
+          contents: (0, renderCopilotAgents_1.renderPacketInstructionsFile)()
+        },
+        {
+          relativePath: exports2.IMPLEMENTOR_AGENT_FILE_PATH,
+          contents: (0, renderCopilotAgents_1.renderImplementorAgentFile)()
+        },
+        {
+          relativePath: exports2.CHECKER_AGENT_FILE_PATH,
+          contents: (0, renderCopilotAgents_1.renderCheckerAgentFile)()
+        },
+        {
+          relativePath: exports2.REVIEWER_AGENT_FILE_PATH,
+          contents: (0, renderCopilotAgents_1.renderReviewerAgentFile)()
+        },
+        {
+          relativePath: exports2.PLAN_SKILL_FILE_PATH,
+          contents: (0, renderCopilotSkills_1.renderSwarmCraftPlanSkillFile)()
+        },
+        {
+          relativePath: exports2.DO_SKILL_FILE_PATH,
+          contents: (0, renderCopilotSkills_1.renderSwarmCraftDoSkillFile)()
+        },
+        {
+          relativePath: exports2.CHECK_SKILL_FILE_PATH,
+          contents: (0, renderCopilotSkills_1.renderSwarmCraftCheckSkillFile)()
+        },
+        {
+          relativePath: exports2.REVIEW_SKILL_FILE_PATH,
+          contents: (0, renderCopilotSkills_1.renderSwarmCraftReviewSkillFile)()
+        },
+        {
+          relativePath: exports2.TEST_SKILL_FILE_PATH,
+          contents: (0, renderCopilotSkills_1.renderSwarmCraftTestSkillFile)()
+        },
+        {
+          relativePath: exports2.PLAN_PROMPT_FILE_PATH,
+          contents: (0, renderCopilotPrompts_1.renderPlanPromptFile)()
+        },
+        {
+          relativePath: exports2.DO_PROMPT_FILE_PATH,
+          contents: (0, renderCopilotPrompts_1.renderDoPromptFile)()
+        },
+        {
+          relativePath: exports2.CHECK_PROMPT_FILE_PATH,
+          contents: (0, renderCopilotPrompts_1.renderCheckPromptFile)()
+        },
+        {
+          relativePath: exports2.REVIEW_PROMPT_FILE_PATH,
+          contents: (0, renderCopilotPrompts_1.renderReviewPromptFile)()
+        },
+        {
+          relativePath: exports2.TEST_PROMPT_FILE_PATH,
+          contents: (0, renderCopilotPrompts_1.renderTestPromptFile)()
+        },
+        {
+          relativePath: exports2.CODEX_PLAN_SKILL_FILE_PATH,
+          contents: (0, renderCodexSkills_1.renderCodexSwarmCraftPlanSkillFile)()
+        },
+        {
+          relativePath: exports2.CODEX_DO_SKILL_FILE_PATH,
+          contents: (0, renderCodexSkills_1.renderCodexSwarmCraftDoSkillFile)()
+        },
+        {
+          relativePath: exports2.CODEX_CHECK_SKILL_FILE_PATH,
+          contents: (0, renderCodexSkills_1.renderCodexSwarmCraftCheckSkillFile)()
+        },
+        {
+          relativePath: exports2.CODEX_REVIEW_SKILL_FILE_PATH,
+          contents: (0, renderCodexSkills_1.renderCodexSwarmCraftReviewSkillFile)()
+        },
+        {
+          relativePath: exports2.CODEX_TEST_SKILL_FILE_PATH,
+          contents: (0, renderCodexSkills_1.renderCodexSwarmCraftTestSkillFile)()
+        },
+        {
+          relativePath: exports2.CODEX_IMPLEMENTOR_AGENT_FILE_PATH,
+          contents: (0, renderCodexAgents_1.renderCodexImplementorAgentFile)()
+        },
+        {
+          relativePath: exports2.CODEX_CHECKER_AGENT_FILE_PATH,
+          contents: (0, renderCodexAgents_1.renderCodexCheckerAgentFile)()
+        },
+        {
+          relativePath: exports2.CODEX_REVIEWER_AGENT_FILE_PATH,
+          contents: (0, renderCodexAgents_1.renderCodexReviewerAgentFile)()
+        },
+        {
+          relativePath: exports2.CODEX_CONFIG_EXAMPLE_FILE_PATH,
+          contents: (0, renderCodexAgents_1.renderCodexConfigExampleFile)()
+        }
+      ];
+    }
+  }
+});
+
+// ../../packages/repo-seed/dist/seedProjectFiles.js
+var require_seedProjectFiles = __commonJS({
+  "../../packages/repo-seed/dist/seedProjectFiles.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.SWARMCRAFT_AGENTS_FILE_PATH = exports2.TEST_SKILL_FILE_PATH = exports2.TEST_PROMPT_FILE_PATH = exports2.REVIEWING_INSTRUCTIONS_FILE_PATH = exports2.REVIEW_SKILL_FILE_PATH = exports2.REVIEW_PROMPT_FILE_PATH = exports2.REVIEWER_AGENT_FILE_PATH = exports2.PROJECT_SEED_SUMMARY_FILE_PATH = exports2.PROJECT_INSTRUCTIONS_FILE_PATH = exports2.PROJECT_CONTEXT_FILE_PATH = exports2.PLAN_SKILL_FILE_PATH = exports2.PLAN_PROMPT_FILE_PATH = exports2.PACKET_INSTRUCTIONS_FILE_PATH = exports2.IMPLEMENTOR_AGENT_FILE_PATH = exports2.DO_SKILL_FILE_PATH = exports2.DOING_INSTRUCTIONS_FILE_PATH = exports2.DO_PROMPT_FILE_PATH = exports2.CODEX_TEST_SKILL_FILE_PATH = exports2.CODEX_REVIEWER_AGENT_FILE_PATH = exports2.CODEX_REVIEW_SKILL_FILE_PATH = exports2.CODEX_PLAN_SKILL_FILE_PATH = exports2.CODEX_IMPLEMENTOR_AGENT_FILE_PATH = exports2.CODEX_DO_SKILL_FILE_PATH = exports2.CODEX_CONFIG_EXAMPLE_FILE_PATH = exports2.CODEX_CHECKER_AGENT_FILE_PATH = exports2.CODEX_CHECK_SKILL_FILE_PATH = exports2.CHECK_SKILL_FILE_PATH = exports2.CHECKING_INSTRUCTIONS_FILE_PATH = exports2.CHECK_PROMPT_FILE_PATH = exports2.CHECKER_AGENT_FILE_PATH = exports2.ROOT_AGENTS_FILE_PATH = void 0;
+    exports2.seedProjectFiles = seedProjectFiles2;
+    var seedProjectContext_1 = require_seedProjectContext();
+    Object.defineProperty(exports2, "CHECKER_AGENT_FILE_PATH", { enumerable: true, get: function() {
+      return seedProjectContext_1.CHECKER_AGENT_FILE_PATH;
+    } });
+    Object.defineProperty(exports2, "CHECK_PROMPT_FILE_PATH", { enumerable: true, get: function() {
+      return seedProjectContext_1.CHECK_PROMPT_FILE_PATH;
+    } });
+    Object.defineProperty(exports2, "CHECKING_INSTRUCTIONS_FILE_PATH", { enumerable: true, get: function() {
+      return seedProjectContext_1.CHECKING_INSTRUCTIONS_FILE_PATH;
+    } });
+    Object.defineProperty(exports2, "CHECK_SKILL_FILE_PATH", { enumerable: true, get: function() {
+      return seedProjectContext_1.CHECK_SKILL_FILE_PATH;
+    } });
+    Object.defineProperty(exports2, "CODEX_CHECK_SKILL_FILE_PATH", { enumerable: true, get: function() {
+      return seedProjectContext_1.CODEX_CHECK_SKILL_FILE_PATH;
+    } });
+    Object.defineProperty(exports2, "CODEX_CHECKER_AGENT_FILE_PATH", { enumerable: true, get: function() {
+      return seedProjectContext_1.CODEX_CHECKER_AGENT_FILE_PATH;
+    } });
+    Object.defineProperty(exports2, "CODEX_CONFIG_EXAMPLE_FILE_PATH", { enumerable: true, get: function() {
+      return seedProjectContext_1.CODEX_CONFIG_EXAMPLE_FILE_PATH;
+    } });
+    Object.defineProperty(exports2, "CODEX_DO_SKILL_FILE_PATH", { enumerable: true, get: function() {
+      return seedProjectContext_1.CODEX_DO_SKILL_FILE_PATH;
+    } });
+    Object.defineProperty(exports2, "CODEX_IMPLEMENTOR_AGENT_FILE_PATH", { enumerable: true, get: function() {
+      return seedProjectContext_1.CODEX_IMPLEMENTOR_AGENT_FILE_PATH;
+    } });
+    Object.defineProperty(exports2, "CODEX_PLAN_SKILL_FILE_PATH", { enumerable: true, get: function() {
+      return seedProjectContext_1.CODEX_PLAN_SKILL_FILE_PATH;
+    } });
+    Object.defineProperty(exports2, "CODEX_REVIEW_SKILL_FILE_PATH", { enumerable: true, get: function() {
+      return seedProjectContext_1.CODEX_REVIEW_SKILL_FILE_PATH;
+    } });
+    Object.defineProperty(exports2, "CODEX_REVIEWER_AGENT_FILE_PATH", { enumerable: true, get: function() {
+      return seedProjectContext_1.CODEX_REVIEWER_AGENT_FILE_PATH;
+    } });
+    Object.defineProperty(exports2, "CODEX_TEST_SKILL_FILE_PATH", { enumerable: true, get: function() {
+      return seedProjectContext_1.CODEX_TEST_SKILL_FILE_PATH;
+    } });
+    Object.defineProperty(exports2, "DO_PROMPT_FILE_PATH", { enumerable: true, get: function() {
+      return seedProjectContext_1.DO_PROMPT_FILE_PATH;
+    } });
+    Object.defineProperty(exports2, "DOING_INSTRUCTIONS_FILE_PATH", { enumerable: true, get: function() {
+      return seedProjectContext_1.DOING_INSTRUCTIONS_FILE_PATH;
+    } });
+    Object.defineProperty(exports2, "DO_SKILL_FILE_PATH", { enumerable: true, get: function() {
+      return seedProjectContext_1.DO_SKILL_FILE_PATH;
+    } });
+    Object.defineProperty(exports2, "IMPLEMENTOR_AGENT_FILE_PATH", { enumerable: true, get: function() {
+      return seedProjectContext_1.IMPLEMENTOR_AGENT_FILE_PATH;
+    } });
+    Object.defineProperty(exports2, "PACKET_INSTRUCTIONS_FILE_PATH", { enumerable: true, get: function() {
+      return seedProjectContext_1.PACKET_INSTRUCTIONS_FILE_PATH;
+    } });
+    Object.defineProperty(exports2, "PLAN_PROMPT_FILE_PATH", { enumerable: true, get: function() {
+      return seedProjectContext_1.PLAN_PROMPT_FILE_PATH;
+    } });
+    Object.defineProperty(exports2, "PLAN_SKILL_FILE_PATH", { enumerable: true, get: function() {
+      return seedProjectContext_1.PLAN_SKILL_FILE_PATH;
+    } });
+    Object.defineProperty(exports2, "PROJECT_CONTEXT_FILE_PATH", { enumerable: true, get: function() {
+      return seedProjectContext_1.PROJECT_CONTEXT_FILE_PATH;
+    } });
+    Object.defineProperty(exports2, "PROJECT_INSTRUCTIONS_FILE_PATH", { enumerable: true, get: function() {
+      return seedProjectContext_1.PROJECT_INSTRUCTIONS_FILE_PATH;
+    } });
+    Object.defineProperty(exports2, "PROJECT_SEED_SUMMARY_FILE_PATH", { enumerable: true, get: function() {
+      return seedProjectContext_1.PROJECT_SEED_SUMMARY_FILE_PATH;
+    } });
+    Object.defineProperty(exports2, "REVIEWER_AGENT_FILE_PATH", { enumerable: true, get: function() {
+      return seedProjectContext_1.REVIEWER_AGENT_FILE_PATH;
+    } });
+    Object.defineProperty(exports2, "REVIEW_PROMPT_FILE_PATH", { enumerable: true, get: function() {
+      return seedProjectContext_1.REVIEW_PROMPT_FILE_PATH;
+    } });
+    Object.defineProperty(exports2, "REVIEW_SKILL_FILE_PATH", { enumerable: true, get: function() {
+      return seedProjectContext_1.REVIEW_SKILL_FILE_PATH;
+    } });
+    Object.defineProperty(exports2, "REVIEWING_INSTRUCTIONS_FILE_PATH", { enumerable: true, get: function() {
+      return seedProjectContext_1.REVIEWING_INSTRUCTIONS_FILE_PATH;
+    } });
+    Object.defineProperty(exports2, "SWARMCRAFT_AGENTS_FILE_PATH", { enumerable: true, get: function() {
+      return seedProjectContext_1.SWARMCRAFT_AGENTS_FILE_PATH;
+    } });
+    Object.defineProperty(exports2, "TEST_PROMPT_FILE_PATH", { enumerable: true, get: function() {
+      return seedProjectContext_1.TEST_PROMPT_FILE_PATH;
+    } });
+    Object.defineProperty(exports2, "TEST_SKILL_FILE_PATH", { enumerable: true, get: function() {
+      return seedProjectContext_1.TEST_SKILL_FILE_PATH;
+    } });
+    var renderProjectGuide_1 = require_renderProjectGuide();
+    exports2.ROOT_AGENTS_FILE_PATH = "AGENTS.md";
+    async function seedProjectFiles2(project, dependencies) {
+      const projectSeedFiles = (0, seedProjectContext_1.buildProjectSeedFiles)(project);
+      for (const seedFile of projectSeedFiles) {
+        if (await dependencies.fileExists(seedFile.relativePath)) {
+          continue;
+        }
+        await dependencies.writeFile(seedFile.relativePath, seedFile.contents);
+      }
+      await upsertRootAgentsPointer(project, dependencies);
+    }
+    async function upsertRootAgentsPointer(project, dependencies) {
+      const managedSection = (0, renderProjectGuide_1.renderRootAgentsManagedSection)(project);
+      const existingContents = await readOptionalFile(exports2.ROOT_AGENTS_FILE_PATH, dependencies);
+      const updatedContents = existingContents === null ? managedSection : upsertManagedSection(existingContents, managedSection);
+      if (updatedContents === existingContents) {
+        return;
+      }
+      await dependencies.writeFile(exports2.ROOT_AGENTS_FILE_PATH, updatedContents);
+    }
+    async function readOptionalFile(relativePath, dependencies) {
+      if (!await dependencies.fileExists(relativePath)) {
+        return null;
+      }
+      return dependencies.readFile(relativePath);
+    }
+    function upsertManagedSection(existingContents, managedSection) {
+      const existingStartIndex = existingContents.indexOf(renderProjectGuide_1.MANAGED_SECTION_START);
+      const existingEndIndex = existingContents.indexOf(renderProjectGuide_1.MANAGED_SECTION_END);
+      if (existingStartIndex >= 0 && existingEndIndex >= 0 && existingEndIndex > existingStartIndex) {
+        const replacementEndIndex = existingEndIndex + renderProjectGuide_1.MANAGED_SECTION_END.length;
+        const updatedContents = `${existingContents.slice(0, existingStartIndex)}${managedSection}${existingContents.slice(replacementEndIndex)}`;
+        return normalizeTrailingNewline(updatedContents);
+      }
+      const separator = existingContents.endsWith("\n\n") ? "" : existingContents.endsWith("\n") ? "\n" : "\n\n";
+      return normalizeTrailingNewline(`${existingContents}${separator}${managedSection}`);
+    }
+    function normalizeTrailingNewline(contents) {
+      return `${contents.replace(/\s*$/, "")}
+`;
+    }
+  }
+});
+
+// ../../packages/repo-seed/dist/index.js
+var require_dist2 = __commonJS({
+  "../../packages/repo-seed/dist/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    __exportStar(require_projectSeedModels(), exports2);
+    __exportStar(require_seedProjectContext(), exports2);
+    __exportStar(require_seedProjectFiles(), exports2);
+    __exportStar(require_renderCodexAgents(), exports2);
+    __exportStar(require_renderCodexSkills(), exports2);
+    __exportStar(require_renderCopilotAgents(), exports2);
+    __exportStar(require_renderCopilotPrompts(), exports2);
+    __exportStar(require_renderCopilotSkills(), exports2);
+    __exportStar(require_renderProjectContext(), exports2);
+    __exportStar(require_renderProjectGuide(), exports2);
+    __exportStar(require_renderWorkspaceInstructions(), exports2);
+  }
+});
+
+// src/main.ts
+var import_promises4 = require("node:fs/promises");
+var import_node_path5 = __toESM(require("node:path"), 1);
+var import_promises5 = require("node:readline/promises");
+var import_node_process = require("node:process");
+var import_packet_workflow3 = __toESM(require_dist(), 1);
+
+// src/apiClient.ts
+var API_REQUEST_TIMEOUT_MS = 15e3;
+var CLIENT_SOURCE_HEADER = "X-SwarmCraft-Client";
+var REFRESH_TOKEN_COOKIE_NAME = "swarmcraft_refresh_token";
+var SwarmCraftApiError = class extends Error {
+  status;
+  code;
+  method;
+  url;
+  requestId;
+  constructor(status, code, message, method, url, requestId) {
+    super(message);
+    this.name = "SwarmCraftApiError";
+    this.status = status;
+    this.code = code;
+    this.method = method;
+    this.url = url;
+    this.requestId = requestId;
+  }
+};
+var SwarmCraftClient = class {
+  apiBaseUrl;
+  constructor(apiBaseUrl) {
+    this.apiBaseUrl = apiBaseUrl.replace(/\/$/, "");
+  }
+  login(email, password) {
+    return this.requestJson("/auth/login", {
+      method: "POST",
+      body: JSON.stringify({ email, password })
+    });
+  }
+  refresh(refreshToken) {
+    return this.requestJson("/auth/refresh", { method: "POST" }, void 0, refreshToken);
+  }
+  mfaChallenge(accessToken, code) {
+    return this.requestJson(
+      "/auth/mfa/challenge",
+      {
+        method: "POST",
+        body: JSON.stringify({ code })
+      },
+      accessToken
+    );
+  }
+  mfaRecovery(accessToken, recoveryCode) {
+    return this.requestJson(
+      "/auth/mfa/recovery",
+      {
+        method: "POST",
+        body: JSON.stringify({ recoveryCode })
+      },
+      accessToken
+    );
+  }
+  listProjects(accessToken) {
+    return this.requestJson("/projects", { method: "GET" }, accessToken);
+  }
+  loadProject(projectId, accessToken) {
+    return this.requestJson(`/projects/${encodeURIComponent(projectId)}`, { method: "GET" }, accessToken);
+  }
+  loadBoard(projectId, accessToken) {
+    return this.requestJson(`/projects/${encodeURIComponent(projectId)}/board`, { method: "GET" }, accessToken);
+  }
+  upsertTicketPacketLink(projectId, ticketId, request, accessToken) {
+    return this.requestJson(
+      `/projects/${encodeURIComponent(projectId)}/tickets/${encodeURIComponent(ticketId)}/packet-link`,
+      {
+        method: "PUT",
+        body: JSON.stringify(request)
+      },
+      accessToken
+    );
+  }
+  moveTicket(projectId, ticketId, request, accessToken) {
+    return this.requestJson(
+      `/projects/${encodeURIComponent(projectId)}/tickets/${encodeURIComponent(ticketId)}/move`,
+      {
+        method: "POST",
+        body: JSON.stringify(request)
+      },
+      accessToken
+    );
+  }
+  updateTicketNotes(projectId, ticketId, request, accessToken) {
+    return this.requestJson(
+      `/projects/${encodeURIComponent(projectId)}/tickets/${encodeURIComponent(ticketId)}/notes`,
+      {
+        method: "PATCH",
+        body: JSON.stringify(request)
+      },
+      accessToken
+    );
+  }
+  updateChecklistItem(projectId, ticketId, itemId, request, accessToken) {
+    return this.requestJson(
+      `/projects/${encodeURIComponent(projectId)}/tickets/${encodeURIComponent(ticketId)}/checklist-items/${encodeURIComponent(itemId)}`,
+      {
+        method: "PATCH",
+        body: JSON.stringify(request)
+      },
+      accessToken
+    );
+  }
+  async requestJson(path6, init, accessToken, refreshToken) {
+    const url = `${this.apiBaseUrl}${path6.startsWith("/") ? path6 : `/${path6}`}`;
+    const method = (init.method ?? "GET").toUpperCase();
+    const headers = new Headers(init.headers);
+    const abortController = new AbortController();
+    const timeoutHandle = setTimeout(() => abortController.abort(), API_REQUEST_TIMEOUT_MS);
+    headers.set("Accept", "application/json");
+    headers.set(CLIENT_SOURCE_HEADER, "CLI");
+    if (init.body && !headers.has("Content-Type")) {
+      headers.set("Content-Type", "application/json");
+    }
+    if (accessToken) {
+      headers.set("Authorization", `Bearer ${accessToken}`);
+    }
+    if (refreshToken) {
+      headers.set("Cookie", `${REFRESH_TOKEN_COOKIE_NAME}=${refreshToken}`);
+    }
+    let response;
+    try {
+      response = await fetch(url, {
+        ...init,
+        headers,
+        signal: abortController.signal
+      });
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new SwarmCraftApiError(0, "NETWORK_ERROR", `Request timed out after ${API_REQUEST_TIMEOUT_MS / 1e3} seconds.`, method, url);
+      }
+      throw new SwarmCraftApiError(0, "NETWORK_ERROR", error instanceof Error ? error.message : "Unable to reach SwarmCraft.", method, url);
+    } finally {
+      clearTimeout(timeoutHandle);
+    }
+    const rawBody = await response.text();
+    const payload = parseJson(rawBody);
+    if (!response.ok) {
+      throw toApiError(response, payload, method, url);
+    }
+    return withRefreshToken(payload, extractRefreshToken(response.headers));
+  }
+};
+function withRefreshToken(payload, refreshToken) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload) || !refreshToken || "refreshToken" in payload) {
+    return payload;
+  }
+  return {
+    ...payload,
+    refreshToken
+  };
+}
+function extractRefreshToken(headers) {
+  const extendedHeaders = headers;
+  const setCookieHeaders = typeof extendedHeaders.getSetCookie === "function" ? extendedHeaders.getSetCookie() : headers.get("set-cookie") ? [headers.get("set-cookie")] : [];
+  for (const setCookieHeader of setCookieHeaders) {
+    const firstSegment = setCookieHeader.split(";")[0] ?? "";
+    const separatorIndex = firstSegment.indexOf("=");
+    if (separatorIndex < 0) {
+      continue;
+    }
+    if (firstSegment.slice(0, separatorIndex).trim() === REFRESH_TOKEN_COOKIE_NAME) {
+      return firstSegment.slice(separatorIndex + 1).trim();
+    }
+  }
+  return null;
+}
+function parseJson(rawBody) {
+  if (!rawBody) {
+    return null;
+  }
+  try {
+    return JSON.parse(rawBody);
+  } catch {
+    return rawBody;
+  }
+}
+function toApiError(response, payload, method, url) {
+  if (payload && typeof payload === "object" && "message" in payload) {
+    const apiError = payload;
+    return new SwarmCraftApiError(
+      apiError.status ?? response.status,
+      apiError.code ?? "UNKNOWN_ERROR",
+      apiError.message ?? response.statusText,
+      method,
+      url,
+      apiError.requestId
+    );
+  }
+  return new SwarmCraftApiError(response.status, "UNKNOWN_ERROR", response.statusText || "Request failed.", method, url);
+}
+
+// src/bootstrap.ts
+var import_node_path2 = __toESM(require("node:path"), 1);
+var import_packet_workflow = __toESM(require_dist(), 1);
+var import_repo_seed = __toESM(require_dist2(), 1);
+
+// src/workspace.ts
+var import_promises = require("node:fs/promises");
+var import_node_path = __toESM(require("node:path"), 1);
+var import_node_child_process = require("node:child_process");
+var import_node_util = require("node:util");
+var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
+async function validateWorkspace(workspacePath) {
+  const resolvedWorkspacePath = import_node_path.default.resolve(workspacePath);
+  const workspaceStat = await (0, import_promises.stat)(resolvedWorkspacePath);
+  if (!workspaceStat.isDirectory()) {
+    throw new Error(`Workspace path is not a directory: ${resolvedWorkspacePath}`);
+  }
+  const gitRoot = (await runGit(["rev-parse", "--show-toplevel"], resolvedWorkspacePath)).trim();
+  const unmergedFiles = (await runGit(["diff", "--name-only", "--diff-filter=U"], resolvedWorkspacePath)).split("\n").filter(Boolean);
+  if (unmergedFiles.length > 0) {
+    throw new Error(`Workspace has unresolved merge conflicts: ${unmergedFiles.join(", ")}`);
+  }
+  const dirtyFileCount = (await runGit(["status", "--porcelain"], resolvedWorkspacePath)).split("\n").filter(Boolean).length;
+  return {
+    workspacePath: resolvedWorkspacePath,
+    workspaceFolderName: import_node_path.default.basename(resolvedWorkspacePath),
+    gitRoot,
+    dirtyFileCount,
+    hasUnmergedFiles: false
+  };
+}
+async function fileExists(absolutePath) {
+  try {
+    await (0, import_promises.access)(absolutePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readWorkspaceFile(workspacePath, relativePath) {
+  return (0, import_promises.readFile)(import_node_path.default.join(workspacePath, relativePath), "utf8");
+}
+async function writeWorkspaceFile(workspacePath, relativePath, contents) {
+  const absolutePath = import_node_path.default.join(workspacePath, relativePath);
+  await (0, import_promises.mkdir)(import_node_path.default.dirname(absolutePath), { recursive: true });
+  await (0, import_promises.writeFile)(absolutePath, contents, "utf8");
+}
+async function runCommand(command, cwd, env = process.env) {
+  return new Promise((resolve) => {
+    const child = (0, import_node_child_process.spawn)(command, {
+      cwd,
+      env,
+      shell: true,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    child.stdout.on("data", (chunk) => stdoutChunks.push(chunk));
+    child.stderr.on("data", (chunk) => stderrChunks.push(chunk));
+    child.on("close", (code) => {
+      resolve({
+        exitCode: code ?? 1,
+        stdout: Buffer.concat(stdoutChunks).toString("utf8"),
+        stderr: Buffer.concat(stderrChunks).toString("utf8")
+      });
+    });
+  });
+}
+async function gitAddAndCommit(workspacePath, message) {
+  await runGit(["add", "."], workspacePath);
+  const staged = (await runGit(["diff", "--cached", "--name-only"], workspacePath)).trim();
+  if (!staged) {
+    return false;
+  }
+  await runGit(["commit", "-m", message], workspacePath);
+  return true;
+}
+async function runGit(args, cwd) {
+  try {
+    const result = await execFileAsync("git", args, { cwd });
+    return result.stdout;
+  } catch (error) {
+    throw new Error(`Git command failed in ${cwd}: git ${args.join(" ")}`);
+  }
+}
+
+// src/bootstrap.ts
+async function runBootstrap(client, accessToken, options) {
+  const workspace = await validateWorkspace(options.workspacePath);
+  const project = await client.loadProject(options.projectId, accessToken);
+  if (project.boardState !== "UNLOCKED") {
+    throw new Error(`Project ${project.id} is ${project.boardState}; unlock the board before bootstrapping a workspace.`);
+  }
+  const board = await client.loadBoard(project.id, accessToken);
+  const seedFilesWritten = await seedWorkspace(project, workspace.workspacePath);
+  const selectedTickets = selectBootstrapTickets(board, options);
+  const packetFilesCreated = [];
+  const packetFilesRefreshed = [];
+  const linkedPackets = [];
+  const skippedTickets = [];
+  const syncedAt = (/* @__PURE__ */ new Date()).toISOString();
+  for (const ticket of selectedTickets) {
+    if (ticket.packetLink && ticket.packetLink.workspaceFolder !== workspace.workspaceFolderName) {
+      skippedTickets.push({
+        ticketId: ticket.id,
+        title: ticket.title,
+        reason: `already linked to workspace ${ticket.packetLink.workspaceFolder}`
+      });
+      continue;
+    }
+    const relativePacketPath = (0, import_packet_workflow.resolvePacketFilePath)(project, ticket, ticket.packetLink);
+    const absolutePacketPath = import_node_path2.default.join(workspace.workspacePath, relativePacketPath);
+    let packetContents;
+    if (await fileExists(absolutePacketPath)) {
+      const existingContents = await readWorkspaceFile(workspace.workspacePath, relativePacketPath);
+      try {
+        (0, import_packet_workflow.ensurePacketFileIdentity)(existingContents, project.id, ticket.id);
+        (0, import_packet_workflow.parsePacketFile)(existingContents);
+        packetContents = (0, import_packet_workflow.rewritePacketFileMetadata)(existingContents, {
+          lane: ticket.workflowState,
+          syncRevision: ticket.revision,
+          lastSyncedAt: syncedAt
+        });
+      } catch (error) {
+        if (error instanceof import_packet_workflow.PacketFileContractError && error.code === "PACKET_FILE_MALFORMED") {
+          skippedTickets.push({
+            ticketId: ticket.id,
+            title: ticket.title,
+            reason: `existing packet is malformed at ${relativePacketPath}`
+          });
+          continue;
+        }
+        throw error;
+      }
+      if (packetContents !== existingContents) {
+        await writeWorkspaceFile(workspace.workspacePath, relativePacketPath, packetContents);
+        packetFilesRefreshed.push(relativePacketPath);
+      }
+    } else {
+      packetContents = (0, import_packet_workflow.renderPacketFile)(project, ticket, syncedAt);
+      await writeWorkspaceFile(workspace.workspacePath, relativePacketPath, packetContents);
+      packetFilesCreated.push(relativePacketPath);
+    }
+    await client.upsertTicketPacketLink(project.id, ticket.id, {
+      workspaceFolder: workspace.workspaceFolderName,
+      packetFilePath: relativePacketPath,
+      expectedRevision: ticket.revision,
+      lastSyncedTicketRevision: ticket.revision,
+      lastSyncedAt: syncedAt
+    }, accessToken);
+    linkedPackets.push(relativePacketPath);
+  }
+  return {
+    projectTitle: project.title || project.projectTitle || project.id,
+    workspacePath: workspace.workspacePath,
+    dirtyFileCount: workspace.dirtyFileCount,
+    seedFilesWritten,
+    packetFilesCreated,
+    packetFilesRefreshed,
+    linkedPackets,
+    skippedTickets,
+    nextCommands: [
+      `swarmcraft one-shot --project ${project.id} --workspace ${workspace.workspacePath} --agent-provider codex`,
+      "Review generated files under .swarmcraft/, .github/, .agents/, and .codex/ before running agents."
+    ]
+  };
+}
+function selectBootstrapTickets(board, options) {
+  const requestedTicketIds = new Set(options.ticketIds);
+  const tickets = board.columns.flatMap((column) => column.tickets).filter((ticket) => ticket.workflowState !== "done").filter((ticket) => requestedTicketIds.size === 0 || requestedTicketIds.has(ticket.id)).sort((left, right) => {
+    if (left.recommendedOrder !== right.recommendedOrder) {
+      return left.recommendedOrder - right.recommendedOrder;
+    }
+    return left.columnOrder - right.columnOrder;
+  });
+  return options.ticketLimit === "all" ? tickets : tickets.slice(0, options.ticketLimit);
+}
+async function seedWorkspace(project, workspacePath) {
+  const writtenPaths = [];
+  await (0, import_repo_seed.seedProjectFiles)(project, {
+    async fileExists(relativePath) {
+      return fileExists(import_node_path2.default.join(workspacePath, relativePath));
+    },
+    async readFile(relativePath) {
+      return readWorkspaceFile(workspacePath, relativePath);
+    },
+    async writeFile(relativePath, contents) {
+      await writeWorkspaceFile(workspacePath, relativePath, contents);
+      writtenPaths.push(relativePath);
+    }
+  });
+  return writtenPaths;
+}
+
+// src/oneShot.ts
+var import_promises2 = require("node:fs/promises");
+var import_node_path3 = __toESM(require("node:path"), 1);
+var import_packet_workflow2 = __toESM(require_dist(), 1);
+async function runOneShot(client, accessToken, options) {
+  const workspace = await validateWorkspace(options.workspacePath);
+  if (workspace.dirtyFileCount > 0 && !options.allowDirty) {
+    throw new Error(`Workspace has ${workspace.dirtyFileCount} changed file(s). Commit, stash, or rerun with --allow-dirty before one-shot.`);
+  }
+  await runBootstrap(client, accessToken, {
+    projectId: options.projectId,
+    workspacePath: workspace.workspacePath,
+    ticketIds: options.ticketIds,
+    ticketLimit: options.ticketLimit
+  });
+  const project = await client.loadProject(options.projectId, accessToken);
+  let board = await client.loadBoard(project.id, accessToken);
+  const runId = options.resumeRunId ?? options.runId ?? createRunId();
+  const manifestPath = resolveManifestPath(workspace.workspacePath, runId);
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const manifest = await loadOrCreateManifest(manifestPath, {
+    generator: "swarmcraft-cli",
+    version: 1,
+    runId,
+    generatedAt: startedAt,
+    finishedAt: null,
+    status: "running",
+    project: { id: project.id, title: project.title || project.projectTitle || project.id },
+    workspacePath: workspace.workspacePath,
+    options,
+    tickets: [],
+    durations: {
+      elapsedMs: null,
+      ticketCount: 0,
+      totalTicketMs: 0,
+      totalStageMs: 0,
+      averageTicketMs: null,
+      averageStageMs: null
+    }
+  });
+  await persistManifest(manifestPath, manifest);
+  let agentRequests = manifest.tickets.flatMap((ticket) => ticket.stages).length;
+  const completedTicketIds = new Set(
+    manifest.tickets.filter((ticket) => ["done", "manual-review-required"].includes(ticket.outcome)).map((ticket) => ticket.ticketId)
+  );
+  if (options.resumeRunId) {
+    manifest.tickets = manifest.tickets.filter((ticket) => completedTicketIds.has(ticket.ticketId));
+    await persistManifest(manifestPath, manifest);
+  }
+  for (const selectedTicket of selectTickets(board, options)) {
+    if (completedTicketIds.has(selectedTicket.id)) {
+      continue;
+    }
+    const ticketOutcome = {
+      ticketId: selectedTicket.id,
+      title: selectedTicket.title,
+      packetPath: null,
+      outcome: "running",
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      finishedAt: null,
+      elapsedMs: null,
+      stages: []
+    };
+    manifest.tickets.push(ticketOutcome);
+    await persistManifest(manifestPath, manifest);
+    const result = await processTicket({
+      client,
+      accessToken,
+      project,
+      board,
+      ticket: selectedTicket,
+      workspacePath: workspace.workspacePath,
+      options,
+      ticketOutcome,
+      manifestPath,
+      manifest,
+      getAgentRequests: () => agentRequests,
+      incrementAgentRequests: () => {
+        agentRequests += 1;
+      }
+    });
+    board = result.board;
+    ticketOutcome.outcome = result.outcome;
+    ticketOutcome.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+    ticketOutcome.elapsedMs = (0, import_packet_workflow2.computeElapsedMs)(ticketOutcome.startedAt, ticketOutcome.finishedAt);
+    if (result.outcome === "done" && options.commitPolicy === "done") {
+      ticketOutcome.commitCreated = await gitAddAndCommit(workspace.workspacePath, `Complete ${selectedTicket.id}: ${selectedTicket.title}`);
+    }
+    await persistManifest(manifestPath, manifest);
+    if (result.outcome.startsWith("blocked")) {
+      break;
+    }
+  }
+  manifest.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+  manifest.status = resolveManifestStatus(manifest);
+  manifest.durations = (0, import_packet_workflow2.summarizeWorkflowRunDurations)(manifest);
+  await persistManifest(manifestPath, manifest);
+  return manifest;
+}
+async function processTicket(context) {
+  let currentBoard = context.board;
+  let currentTicket = requireTicket(currentBoard, context.ticket.id);
+  if (currentTicket.workflowState === "todo") {
+    currentBoard = await moveTicket(context.client, context.accessToken, context.project.id, currentTicket, "doing");
+    currentTicket = requireTicket(currentBoard, context.ticket.id);
+  }
+  const packetPath = (0, import_packet_workflow2.resolvePacketFilePath)(context.project, currentTicket, currentTicket.packetLink);
+  context.ticketOutcome.packetPath = packetPath;
+  await refreshPacketMetadata(context.workspacePath, packetPath, currentTicket);
+  if (currentTicket.workflowState !== "checking" && currentTicket.workflowState !== "reviewing") {
+    const doResult = await runStageAndSync({ ...context, board: currentBoard, ticket: currentTicket, packetPath, stage: "do" });
+    currentBoard = doResult.board;
+    currentTicket = doResult.ticket;
+  }
+  if (!context.options.checking) {
+    return moveAfterAcceptedChecking(context, currentBoard, currentTicket, packetPath);
+  }
+  if (currentTicket.workflowState === "doing") {
+    currentBoard = await moveTicket(context.client, context.accessToken, context.project.id, currentTicket, "checking");
+    currentTicket = requireTicket(currentBoard, currentTicket.id);
+    await refreshPacketMetadata(context.workspacePath, packetPath, currentTicket);
+  }
+  for (let attempt = 1; attempt <= context.options.maxCheckingAttempts; attempt += 1) {
+    const checkResult = await runStageAndSync({ ...context, board: currentBoard, ticket: currentTicket, packetPath, stage: "check" });
+    currentBoard = checkResult.board;
+    currentTicket = checkResult.ticket;
+    if (currentTicket.workflowState === "doing") {
+      if (attempt >= context.options.maxCheckingAttempts) {
+        return { board: currentBoard, ticket: currentTicket, outcome: "blocked-checking-retries-exhausted" };
+      }
+      currentBoard = await moveTicket(context.client, context.accessToken, context.project.id, currentTicket, "checking");
+      currentTicket = requireTicket(currentBoard, currentTicket.id);
+      await refreshPacketMetadata(context.workspacePath, packetPath, currentTicket);
+      continue;
+    }
+    const accepted = currentTicket.workflowState === "reviewing" || currentTicket.workflowState === "done" || (0, import_packet_workflow2.allChecklistItemsComplete)(currentTicket, "checking");
+    if (accepted) {
+      return moveAfterAcceptedChecking(context, currentBoard, currentTicket, packetPath);
+    }
+  }
+  return { board: currentBoard, ticket: currentTicket, outcome: "blocked-checking-unresolved" };
+}
+async function runStageAndSync(context) {
+  if (context.options.maxAgentRequests !== null && context.getAgentRequests() >= context.options.maxAgentRequests) {
+    throw new Error(`Agent request budget exhausted before ${context.stage} for ${context.ticket.title}.`);
+  }
+  const stageCommand = (0, import_packet_workflow2.buildPacketStageCommand)({
+    workflowState: context.stage === "do" ? "doing" : "checking",
+    relativePacketFilePath: context.packetPath,
+    agentProvider: context.options.agentProvider === "custom" ? "copilot" : context.options.agentProvider
+  });
+  if (!stageCommand) {
+    throw new Error(`No stage command exists for ${context.stage}.`);
+  }
+  const command = renderAgentCommand(resolveAgentCommandTemplate(context.options), {
+    command: stageCommand,
+    stage: context.stage,
+    ticket: context.packetPath,
+    workspace: context.workspacePath
+  });
+  const stageOutcome = {
+    stage: context.stage,
+    command,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    finishedAt: null,
+    elapsedMs: null,
+    exitCode: null,
+    result: "pending",
+    laneBefore: context.ticket.workflowState,
+    laneAfter: null,
+    syncedChanges: 0,
+    costUsd: null
+  };
+  context.ticketOutcome.stages.push(stageOutcome);
+  await persistManifest(context.manifestPath, context.manifest);
+  context.incrementAgentRequests();
+  const costOutputPath = import_node_path3.default.join(import_node_path3.default.dirname(context.manifestPath), "agent-cost", `${String(context.getAgentRequests() + 1).padStart(4, "0")}-${context.stage}.json`);
+  await (0, import_promises2.mkdir)(import_node_path3.default.dirname(costOutputPath), { recursive: true });
+  const execution = await runCommand(command, context.workspacePath, await buildAgentEnvironment(context.options, {
+    SWARMCRAFT_STAGE: context.stage,
+    SWARMCRAFT_PACKET: context.packetPath,
+    SWARMCRAFT_WORKSPACE: context.workspacePath,
+    SWARMCRAFT_AGENT_PROVIDER: context.options.agentProvider,
+    SWARMCRAFT_AGENT_COST_OUTPUT: costOutputPath
+  }));
+  stageOutcome.exitCode = execution.exitCode;
+  if (execution.exitCode !== 0) {
+    stageOutcome.result = "failed";
+    stageOutcome.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+    stageOutcome.elapsedMs = (0, import_packet_workflow2.computeElapsedMs)(stageOutcome.startedAt, stageOutcome.finishedAt);
+    await persistManifest(context.manifestPath, context.manifest);
+    throw new Error(`Agent command failed during ${context.stage}: ${execution.stderr || execution.stdout || command}`);
+  }
+  const syncResult = await syncPacketFile({
+    client: context.client,
+    accessToken: context.accessToken,
+    project: context.project,
+    board: context.board,
+    ticket: context.ticket,
+    workspacePath: context.workspacePath,
+    relativePacketPath: context.packetPath
+  });
+  stageOutcome.result = "synced";
+  stageOutcome.costUsd = await readStageCostUsd(costOutputPath);
+  if (context.options.requireCostTelemetry && stageOutcome.costUsd === null) {
+    throw new Error("Agent spend budget cannot be verified because cost telemetry was not written.");
+  }
+  const knownSpendUsd = sumStageCostUsd(context.manifest);
+  if (context.options.maxAgentSpendUsd !== null && knownSpendUsd > context.options.maxAgentSpendUsd) {
+    throw new Error(`Agent spend budget exceeded: $${knownSpendUsd.toFixed(4)} > $${context.options.maxAgentSpendUsd.toFixed(4)}.`);
+  }
+  stageOutcome.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+  stageOutcome.elapsedMs = (0, import_packet_workflow2.computeElapsedMs)(stageOutcome.startedAt, stageOutcome.finishedAt);
+  stageOutcome.laneAfter = syncResult.ticket.workflowState;
+  stageOutcome.syncedChanges = syncResult.syncedChanges;
+  await persistManifest(context.manifestPath, context.manifest);
+  return { board: syncResult.board, ticket: syncResult.ticket };
+}
+async function syncPacketFile(input2) {
+  const syncedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const fileContents = await readWorkspaceFile(input2.workspacePath, input2.relativePacketPath);
+  const parsedPacket = (0, import_packet_workflow2.parsePacketFile)(fileContents);
+  if (parsedPacket.frontmatter.projectId !== input2.project.id || parsedPacket.frontmatter.ticketId !== input2.ticket.id) {
+    throw new Error(`Packet ${input2.relativePacketPath} does not belong to ticket ${input2.ticket.id}.`);
+  }
+  if (parsedPacket.frontmatter.syncRevision !== input2.ticket.revision) {
+    throw new Error(`Packet ${input2.relativePacketPath} is stale; expected revision ${input2.ticket.revision}.`);
+  }
+  const shapeProblem = (0, import_packet_workflow2.findChecklistShapeProblem)(input2.ticket.checklistItems, parsedPacket.sections.checklists);
+  if (shapeProblem) {
+    throw new Error(shapeProblem.message);
+  }
+  let currentBoard = input2.board;
+  let currentTicket = input2.ticket;
+  let syncedChanges = 0;
+  for (const checklistStage of import_packet_workflow2.CHECKLIST_STAGES) {
+    const currentItems = (0, import_packet_workflow2.listChecklistItemsForStage)(currentTicket.checklistItems, checklistStage);
+    const parsedItems = parsedPacket.sections.checklists[checklistStage];
+    for (const [index, parsedItem] of parsedItems.entries()) {
+      const currentItem = currentItems[index];
+      if (currentItem.completed === parsedItem.completed) {
+        continue;
+      }
+      currentBoard = await input2.client.updateChecklistItem(input2.project.id, currentTicket.id, currentItem.id, {
+        completed: parsedItem.completed,
+        expectedRevision: currentItem.revision
+      }, input2.accessToken);
+      currentTicket = requireTicket(currentBoard, currentTicket.id);
+      syncedChanges += 1;
+    }
+  }
+  const desiredNotes = (0, import_packet_workflow2.composeTicketNotes)(parsedPacket.sections.notes, parsedPacket.sections.agentUpdate);
+  if ((currentTicket.notes ?? null) !== desiredNotes) {
+    currentBoard = await input2.client.updateTicketNotes(input2.project.id, currentTicket.id, {
+      notes: desiredNotes,
+      expectedRevision: currentTicket.revision
+    }, input2.accessToken);
+    currentTicket = requireTicket(currentBoard, currentTicket.id);
+    syncedChanges += 1;
+  }
+  if (parsedPacket.frontmatter.lane !== currentTicket.workflowState) {
+    currentBoard = await moveTicket(input2.client, input2.accessToken, input2.project.id, currentTicket, parsedPacket.frontmatter.lane);
+    currentTicket = requireTicket(currentBoard, currentTicket.id);
+    syncedChanges += 1;
+  }
+  await refreshPacketMetadata(input2.workspacePath, input2.relativePacketPath, currentTicket, syncedAt);
+  return { board: currentBoard, ticket: currentTicket, syncedChanges };
+}
+async function buildAgentEnvironment(options, stageEnv) {
+  const env = {
+    PATH: process.env.PATH ?? "",
+    HOME: process.env.HOME,
+    SHELL: process.env.SHELL,
+    TERM: process.env.TERM,
+    ...stageEnv
+  };
+  if (!options.agentApiKeyEnvName) {
+    return env;
+  }
+  const envFileValues = options.agentEnvFilePath ? await readEnvFile(options.agentEnvFilePath) : {};
+  const credentialValue = envFileValues[options.agentApiKeyEnvName] ?? process.env[options.agentApiKeyEnvName];
+  if (!credentialValue) {
+    throw new Error(`Missing approved agent credential ${options.agentApiKeyEnvName}.`);
+  }
+  env[options.agentApiKeyEnvName] = credentialValue;
+  return env;
+}
+async function readEnvFile(envFilePath) {
+  const contents = await (0, import_promises2.readFile)(envFilePath, "utf8");
+  return Object.fromEntries(
+    contents.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#")).map((line) => {
+      const separatorIndex = line.indexOf("=");
+      if (separatorIndex < 0) {
+        return null;
+      }
+      return [line.slice(0, separatorIndex).trim(), line.slice(separatorIndex + 1).trim().replace(/^"|"$/g, "")];
+    }).filter((entry) => entry !== null)
+  );
+}
+async function readStageCostUsd(costOutputPath) {
+  try {
+    const payload = JSON.parse(await (0, import_promises2.readFile)(costOutputPath, "utf8"));
+    const value = typeof payload.totalCostUsd === "number" ? payload.totalCostUsd : payload.costUsd;
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+function sumStageCostUsd(manifest) {
+  return manifest.tickets.flatMap((ticket) => ticket.stages).reduce((total, stage) => total + Number(stage.costUsd ?? 0), 0);
+}
+async function moveAfterAcceptedChecking(context, board, ticket, packetPath) {
+  if (context.options.donePolicy === "auto") {
+    const doneBoard = ticket.workflowState === "done" ? board : await moveTicket(context.client, context.accessToken, context.project.id, ticket, "done");
+    const doneTicket = requireTicket(doneBoard, ticket.id);
+    await refreshPacketMetadata(context.workspacePath, packetPath, doneTicket);
+    return { board: doneBoard, ticket: doneTicket, outcome: "done" };
+  }
+  const reviewBoard = ticket.workflowState === "reviewing" ? board : await moveTicket(context.client, context.accessToken, context.project.id, ticket, "reviewing");
+  const reviewTicket = requireTicket(reviewBoard, ticket.id);
+  await refreshPacketMetadata(context.workspacePath, packetPath, reviewTicket);
+  return { board: reviewBoard, ticket: reviewTicket, outcome: "manual-review-required" };
+}
+async function moveTicket(client, accessToken, projectId, ticket, workflowState) {
+  return client.moveTicket(projectId, ticket.id, {
+    workflowState,
+    targetIndex: null,
+    expectedRevision: ticket.revision
+  }, accessToken);
+}
+async function refreshPacketMetadata(workspacePath, relativePacketPath, ticket, syncedAt = (/* @__PURE__ */ new Date()).toISOString()) {
+  const contents = await readWorkspaceFile(workspacePath, relativePacketPath);
+  await writeWorkspaceFile(workspacePath, relativePacketPath, (0, import_packet_workflow2.rewritePacketFileMetadata)(contents, {
+    lane: ticket.workflowState,
+    syncRevision: ticket.revision,
+    lastSyncedAt: syncedAt
+  }));
+}
+function resolveAgentCommandTemplate(options) {
+  if (options.agentCommand) {
+    return options.agentCommand;
+  }
+  const providerDefault = (0, import_packet_workflow2.resolveExternalAgentProviderDefault)(options.agentProvider);
+  if (providerDefault) {
+    return providerDefault.command;
+  }
+  throw new Error("--agent-command is required when --agent-provider custom is used.");
+}
+function renderAgentCommand(commandTemplate, context) {
+  const replacements = {
+    command: shellQuote(context.command),
+    stage: shellQuote(context.stage),
+    ticket: shellQuote(context.ticket),
+    workspace: shellQuote(context.workspace)
+  };
+  const rendered = commandTemplate.replace(/\{(command|stage|ticket|workspace)\}/g, (_, key) => replacements[key]);
+  return rendered === commandTemplate ? `${commandTemplate} ${shellQuote(context.command)}` : rendered;
+}
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, "'\\''")}'`;
+}
+function selectTickets(board, options) {
+  const requestedTicketIds = new Set(options.ticketIds);
+  const tickets = board.columns.flatMap((column) => column.tickets).filter((ticket) => ticket.workflowState !== "done").filter((ticket) => requestedTicketIds.size === 0 || requestedTicketIds.has(ticket.id)).sort((left, right) => left.recommendedOrder - right.recommendedOrder || left.columnOrder - right.columnOrder);
+  return options.ticketLimit === "all" ? tickets : tickets.slice(0, options.ticketLimit);
+}
+function requireTicket(board, ticketId) {
+  const ticket = board.columns.flatMap((column) => column.tickets).find((candidate) => candidate.id === ticketId);
+  if (!ticket) {
+    throw new Error(`Ticket ${ticketId} was not present in the updated board payload.`);
+  }
+  return ticket;
+}
+function resolveManifestStatus(manifest) {
+  if (manifest.tickets.some((ticket) => ticket.outcome.startsWith("blocked"))) {
+    return "blocked";
+  }
+  if (manifest.tickets.some((ticket) => ticket.outcome === "manual-review-required")) {
+    return "manual-review-required";
+  }
+  return "success";
+}
+async function loadOrCreateManifest(manifestPath, fallback) {
+  try {
+    return JSON.parse(await (0, import_promises2.readFile)(manifestPath, "utf8"));
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+      return fallback;
+    }
+    throw error;
+  }
+}
+async function persistManifest(manifestPath, manifest) {
+  await (0, import_promises2.mkdir)(import_node_path3.default.dirname(manifestPath), { recursive: true });
+  await (0, import_promises2.writeFile)(manifestPath, `${JSON.stringify(manifest, null, 2)}
+`, "utf8");
+}
+function resolveManifestPath(workspacePath, runId) {
+  return import_node_path3.default.join(workspacePath, ".swarmcraft", "runs", runId, "manifest.json");
+}
+function createRunId() {
+  return `run-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
+}
+function describeAgentPolicy(options) {
+  return {
+    sandboxMode: (0, import_packet_workflow2.resolveExternalAgentSandboxMode)({
+      agentMode: "externalCommand",
+      agentProvider: options.agentProvider,
+      agentCommand: options.agentCommand ?? (0, import_packet_workflow2.resolveExternalAgentProviderDefault)(options.agentProvider)?.command ?? null,
+      agentCommandSource: options.agentCommand ? "cli" : "provider-default"
+    }),
+    approvalPosture: (0, import_packet_workflow2.resolveExternalAgentApprovalPosture)({
+      agentMode: "externalCommand",
+      agentProvider: options.agentProvider,
+      agentCommand: options.agentCommand ?? (0, import_packet_workflow2.resolveExternalAgentProviderDefault)(options.agentProvider)?.command ?? null,
+      agentCommandSource: options.agentCommand ? "cli" : "provider-default"
+    })
+  };
+}
+
+// src/sessionStore.ts
+var import_promises3 = require("node:fs/promises");
+var import_node_os = __toESM(require("node:os"), 1);
+var import_node_path4 = __toESM(require("node:path"), 1);
+function resolveSessionPath() {
+  return import_node_path4.default.join(import_node_os.default.homedir(), ".swarmcraft", "cli-session.json");
+}
+async function readStoredSession() {
+  try {
+    return JSON.parse(await (0, import_promises3.readFile)(resolveSessionPath(), "utf8"));
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+async function writeStoredSession(session) {
+  const sessionPath = resolveSessionPath();
+  await (0, import_promises3.mkdir)(import_node_path4.default.dirname(sessionPath), { recursive: true, mode: 448 });
+  await (0, import_promises3.writeFile)(sessionPath, `${JSON.stringify(session, null, 2)}
+`, { mode: 384 });
+  await (0, import_promises3.chmod)(sessionPath, 384);
+}
+function toStoredSession(apiBaseUrl, tokenResponse) {
+  return {
+    ...tokenResponse,
+    apiBaseUrl,
+    savedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function sessionExpiresSoon(session) {
+  const expiresAt = Date.parse(session.accessTokenExpiresAt);
+  if (!Number.isFinite(expiresAt)) {
+    return true;
+  }
+  return expiresAt - Date.now() < 6e4;
+}
+
+// src/main.ts
+var VERSION = "0.1.0";
+var DEFAULT_API_BASE_URL = "https://swarmcraft.ai/api";
+var AGENT_PROVIDER_USAGE = import_packet_workflow3.EXTERNAL_AGENT_PROVIDERS.join("|");
+var COMMANDS = [
+  {
+    name: "auth login",
+    usage: "swarmcraft auth login [--email <email>] [--password <password>] [--mfa-code <code>] [--api-base-url <url>]",
+    summary: "Sign in to SwarmCraft and store a local CLI session.",
+    implemented: true
+  },
+  {
+    name: "projects list",
+    usage: "swarmcraft projects list",
+    summary: "List SwarmCraft projects available to the signed-in user.",
+    implemented: true
+  },
+  {
+    name: "init",
+    usage: "swarmcraft init --project <project-id> --workspace <path> [--ticket <ticket-id>] [--ticket-limit <n|all>]",
+    summary: "Prepare a repository with SwarmCraft packet and agent guidance files.",
+    implemented: true
+  },
+  {
+    name: "one-shot",
+    usage: `swarmcraft one-shot --project <project-id> --workspace <path> --agent-provider ${AGENT_PROVIDER_USAGE} [--run-id <id>] [--done-policy stop|auto] [--commit-policy none|done] [--allow-dirty]`,
+    summary: "Run the project board packet loop with the selected agent provider.",
+    implemented: true
+  },
+  {
+    name: "resume",
+    usage: "swarmcraft resume --run <run-id> --workspace <path>",
+    summary: "Resume a prior CLI run from its recorded manifest.",
+    implemented: true
+  },
+  {
+    name: "status",
+    usage: "swarmcraft status --run <run-id> --workspace <path>",
+    summary: "Show the status of a recorded CLI run.",
+    implemented: true
+  },
+  {
+    name: "doctor",
+    usage: "swarmcraft doctor [--workspace <path>] [--agent-provider codex|copilot|custom]",
+    summary: "Check local auth, API, git, workspace, runtime, and agent prerequisites.",
+    implemented: true
+  },
+  {
+    name: "support-bundle",
+    usage: "swarmcraft support-bundle --run <run-id> --workspace <path>",
+    summary: "Collect a redacted support bundle for a CLI run.",
+    implemented: true
+  }
+];
+async function main(argv) {
+  const parsed = parseArgs(argv);
+  const command = findCommand(parsed.positionals);
+  if (parsed.positionals.length === 0 || hasFlag(parsed, "help") || hasFlag(parsed, "h")) {
+    if (command) {
+      printCommandHelp(command);
+    } else {
+      printGeneralHelp();
+    }
+    return 0;
+  }
+  if (hasFlag(parsed, "version") || hasFlag(parsed, "v")) {
+    console.log(VERSION);
+    return 0;
+  }
+  if (parsed.positionals[0] === "help") {
+    const helpCommand = findCommand(parsed.positionals.slice(1));
+    if (helpCommand) {
+      printCommandHelp(helpCommand);
+    } else {
+      printGeneralHelp();
+    }
+    return 0;
+  }
+  if (!command) {
+    throw new Error(`Unknown command: ${parsed.positionals.join(" ")}
+Run "swarmcraft --help" for available commands.`);
+  }
+  switch (command.name) {
+    case "auth login":
+      await runAuthLogin(parsed);
+      return 0;
+    case "projects list":
+      await runProjectsList(parsed);
+      return 0;
+    case "init":
+      await runInit(parsed);
+      return 0;
+    case "one-shot":
+      await runOneShotCommand(parsed);
+      return 0;
+    case "resume":
+      await runResume(parsed);
+      return 0;
+    case "status":
+      await runStatus(parsed);
+      return 0;
+    case "doctor":
+      await runDoctor(parsed);
+      return 0;
+    case "support-bundle":
+      await runSupportBundle(parsed);
+      return 0;
+    default:
+      throw new Error(`${command.usage}
+
+${command.summary}
+
+This command is planned but not implemented yet.`);
+  }
+}
+async function runAuthLogin(parsed) {
+  const apiBaseUrl = getOption(parsed, "api-base-url") ?? process.env.SWARMCRAFT_API_BASE_URL ?? DEFAULT_API_BASE_URL;
+  const email = getOption(parsed, "email") ?? process.env.SWARMCRAFT_EMAIL ?? await promptLine("Email: ");
+  const password = getOption(parsed, "password") ?? process.env.SWARMCRAFT_PASSWORD ?? await promptSecret("Password: ");
+  const client = new SwarmCraftClient(apiBaseUrl);
+  let tokenResponse = await client.login(email, password);
+  if (tokenResponse.user.mfaEnrolled && !tokenResponse.user.mfaVerified) {
+    const mfaCode = getOption(parsed, "mfa-code") ?? process.env.SWARMCRAFT_MFA_CODE;
+    const recoveryCode = getOption(parsed, "recovery-code") ?? process.env.SWARMCRAFT_MFA_RECOVERY_CODE;
+    if (!mfaCode && !recoveryCode) {
+      throw new Error("MFA is required. Rerun with --mfa-code <code> or --recovery-code <code>.");
+    }
+    const mfaResponse = recoveryCode ? await client.mfaRecovery(tokenResponse.accessToken, recoveryCode) : await client.mfaChallenge(tokenResponse.accessToken, mfaCode);
+    tokenResponse = {
+      ...mfaResponse.session,
+      refreshToken: mfaResponse.refreshToken ?? mfaResponse.session.refreshToken
+    };
+  }
+  await writeStoredSession(toStoredSession(apiBaseUrl, tokenResponse));
+  console.log(`Signed in as ${tokenResponse.user.email}.`);
+}
+async function runProjectsList(parsed) {
+  const { client, session } = await resolveAuthenticatedClient(parsed);
+  const projects = await client.listProjects(session.accessToken);
+  if (projects.length === 0) {
+    console.log("No projects available.");
+    return;
+  }
+  for (const project of projects) {
+    const done = project.boardSummary?.doneCount ?? 0;
+    const total = project.boardSummary?.totalCount ?? 0;
+    console.log(`${project.id}	${project.boardState}	${done}/${total} done	${project.title}`);
+  }
+}
+async function runInit(parsed) {
+  const projectId = requireOption(parsed, "project");
+  const workspacePath = requireOption(parsed, "workspace");
+  const ticketLimit = parseTicketLimit(getOption(parsed, "ticket-limit") ?? "all");
+  const { client, session } = await resolveAuthenticatedClient(parsed);
+  const summary = await runBootstrap(client, session.accessToken, {
+    projectId,
+    workspacePath,
+    ticketIds: getOptions(parsed, "ticket"),
+    ticketLimit
+  });
+  printBootstrapSummary(summary);
+}
+async function runOneShotCommand(parsed) {
+  const { client, session } = await resolveAuthenticatedClient(parsed);
+  const options = parseOneShotOptions(parsed);
+  const policy = describeAgentPolicy(options);
+  console.log(`Agent provider: ${options.agentProvider}`);
+  console.log(`Agent sandbox: ${policy.sandboxMode ?? "custom"}`);
+  console.log(`Agent approval posture: ${policy.approvalPosture ?? "custom"}`);
+  const onSigint = () => {
+    console.error("Cancellation requested. The run manifest is written incrementally; use `swarmcraft resume --run <run-id> --workspace <path>` after the current process exits.");
+    process.exit(130);
+  };
+  process.once("SIGINT", onSigint);
+  try {
+    const manifest = await runOneShot(client, session.accessToken, options);
+    printRunSummary(manifest);
+  } finally {
+    process.off("SIGINT", onSigint);
+  }
+}
+async function runResume(parsed) {
+  const runId = requireOption(parsed, "run");
+  const workspacePath = requireOption(parsed, "workspace");
+  const manifest = await readRunManifest(workspacePath, runId);
+  const { client, session } = await resolveAuthenticatedClient(parsed);
+  const resumed = await runOneShot(client, session.accessToken, {
+    ...manifest.options,
+    workspacePath,
+    resumeRunId: runId
+  });
+  printRunSummary(resumed);
+}
+async function runStatus(parsed) {
+  const runId = requireOption(parsed, "run");
+  const workspacePath = requireOption(parsed, "workspace");
+  printRunSummary(await readRunManifest(workspacePath, runId));
+}
+async function runDoctor(parsed) {
+  console.log(`Node: ${process.version}`);
+  const session = await readStoredSession();
+  console.log(`Session: ${session ? `signed in as ${session.user.email}` : "missing"}`);
+  if (session) {
+    try {
+      const client = new SwarmCraftClient(getOption(parsed, "api-base-url") ?? session.apiBaseUrl);
+      await client.listProjects(session.accessToken);
+      console.log("API: reachable");
+    } catch (error) {
+      console.log(`API: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  const workspacePath = getOption(parsed, "workspace");
+  if (workspacePath) {
+    try {
+      const workspace = await validateWorkspace(workspacePath);
+      console.log(`Workspace: ${workspace.workspacePath}`);
+      console.log(`Git root: ${workspace.gitRoot}`);
+      console.log(`Changed files: ${workspace.dirtyFileCount}`);
+    } catch (error) {
+      console.log(`Workspace: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  const provider = getOption(parsed, "agent-provider");
+  if (provider && provider !== "custom") {
+    const commandName = provider === "codex" ? "codex" : "copilot";
+    const result = await runCommand(`command -v ${commandName}`, process.cwd());
+    console.log(`${commandName}: ${result.exitCode === 0 ? result.stdout.trim() : "not found"}`);
+  }
+}
+async function runSupportBundle(parsed) {
+  const runId = requireOption(parsed, "run");
+  const workspacePath = import_node_path5.default.resolve(requireOption(parsed, "workspace"));
+  const manifestPath = resolveManifestPath(workspacePath, runId);
+  const manifest = JSON.parse(await (0, import_promises4.readFile)(manifestPath, "utf8"));
+  const bundleDir = import_node_path5.default.join(workspacePath, ".swarmcraft", "runs", runId, "support-bundle");
+  await (0, import_promises4.mkdir)(bundleDir, { recursive: true });
+  await (0, import_promises4.writeFile)(import_node_path5.default.join(bundleDir, "manifest.redacted.json"), `${JSON.stringify(redact(manifest), null, 2)}
+`, "utf8");
+  await (0, import_promises4.writeFile)(import_node_path5.default.join(bundleDir, "summary.json"), `${JSON.stringify({
+    runId,
+    manifestPath,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    node: process.version
+  }, null, 2)}
+`, "utf8");
+  console.log(`Support bundle written: ${bundleDir}`);
+}
+async function resolveAuthenticatedClient(parsed) {
+  let session = await readStoredSession();
+  if (!session) {
+    throw new Error("No SwarmCraft CLI session found. Run `swarmcraft auth login` first.");
+  }
+  const apiBaseUrl = getOption(parsed, "api-base-url") ?? process.env.SWARMCRAFT_API_BASE_URL ?? session.apiBaseUrl;
+  const client = new SwarmCraftClient(apiBaseUrl);
+  if (sessionExpiresSoon(session)) {
+    if (!session.refreshToken) {
+      throw new Error("Stored SwarmCraft session has expired. Run `swarmcraft auth login` again.");
+    }
+    const refreshed = await client.refresh(session.refreshToken);
+    session = toStoredSession(apiBaseUrl, {
+      ...refreshed,
+      refreshToken: refreshed.refreshToken ?? session.refreshToken
+    });
+    await writeStoredSession(session);
+  }
+  return { client, session };
+}
+function printBootstrapSummary(summary) {
+  console.log(`Bootstrapped ${summary.projectTitle}`);
+  console.log(`Workspace: ${summary.workspacePath}`);
+  if (summary.dirtyFileCount > 0) {
+    console.log(`Workspace had ${summary.dirtyFileCount} pre-existing changed file(s).`);
+  }
+  console.log(`Seed files written or updated: ${summary.seedFilesWritten.length}`);
+  console.log(`Packet files created: ${summary.packetFilesCreated.length}`);
+  console.log(`Packet files refreshed: ${summary.packetFilesRefreshed.length}`);
+  console.log(`Packet links upserted: ${summary.linkedPackets.length}`);
+  if (summary.skippedTickets.length > 0) {
+    console.log("Skipped tickets:");
+    for (const skipped of summary.skippedTickets) {
+      console.log(`  - ${skipped.ticketId} ${skipped.title}: ${skipped.reason}`);
+    }
+  }
+  console.log("Next:");
+  for (const nextCommand of summary.nextCommands) {
+    console.log(`  ${nextCommand}`);
+  }
+}
+function printRunSummary(manifest) {
+  console.log(`Run: ${manifest.runId}`);
+  console.log(`Status: ${manifest.status}`);
+  console.log(`Workspace: ${manifest.workspacePath}`);
+  console.log(`Tickets: ${manifest.tickets.length}`);
+  for (const ticket of manifest.tickets) {
+    console.log(`  - ${ticket.outcome}: ${ticket.title} (${ticket.stages.length} stage(s))`);
+  }
+  if (manifest.durations?.elapsedMs !== null && manifest.durations?.elapsedMs !== void 0) {
+    console.log(`Elapsed: ${Math.round(manifest.durations.elapsedMs / 1e3)}s`);
+  }
+}
+function parseOneShotOptions(parsed) {
+  const agentProvider = (0, import_packet_workflow3.parseExternalAgentProvider)(requireOption(parsed, "agent-provider"));
+  const donePolicy = parseChoice(getOption(parsed, "done-policy") ?? "stop", ["stop", "auto"], "--done-policy");
+  const commitPolicy = parseChoice(getOption(parsed, "commit-policy") ?? "none", ["none", "done"], "--commit-policy");
+  return {
+    projectId: requireOption(parsed, "project"),
+    workspacePath: requireOption(parsed, "workspace"),
+    agentProvider,
+    agentCommand: getOption(parsed, "agent-command") ?? process.env.SWARMCRAFT_AGENT_COMMAND ?? null,
+    checking: parseOnOff(getOption(parsed, "checking") ?? "on", "--checking"),
+    maxCheckingAttempts: parsePositiveInteger(getOption(parsed, "max-checking-attempts") ?? "2", "--max-checking-attempts"),
+    donePolicy,
+    commitPolicy,
+    maxAgentRequests: getOption(parsed, "max-agent-requests") ? parsePositiveInteger(getOption(parsed, "max-agent-requests"), "--max-agent-requests") : null,
+    maxAgentSpendUsd: getOption(parsed, "max-agent-spend-usd") ? parseNonNegativeNumber(getOption(parsed, "max-agent-spend-usd"), "--max-agent-spend-usd") : null,
+    requireCostTelemetry: hasFlag(parsed, "require-cost-telemetry"),
+    allowDirty: hasFlag(parsed, "allow-dirty"),
+    agentEnvFilePath: getOption(parsed, "agent-env-file") ?? null,
+    agentApiKeyEnvName: getOption(parsed, "agent-api-key-env-name") ?? null,
+    ticketIds: getOptions(parsed, "ticket"),
+    ticketLimit: parseTicketLimit(getOption(parsed, "ticket-limit") ?? "all"),
+    runId: parseRunId(getOption(parsed, "run-id"))
+  };
+}
+async function readRunManifest(workspacePath, runId) {
+  return JSON.parse(await (0, import_promises4.readFile)(resolveManifestPath(import_node_path5.default.resolve(workspacePath), runId), "utf8"));
+}
+function parseArgs(argv) {
+  const positionals = [];
+  const options = /* @__PURE__ */ new Map();
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (!arg.startsWith("-")) {
+      positionals.push(arg);
+      continue;
+    }
+    const normalized = arg.replace(/^-+/, "");
+    if (normalized.includes("=")) {
+      const [key, ...valueParts] = normalized.split("=");
+      addOption(options, key, valueParts.join("="));
+      continue;
+    }
+    const next = argv[index + 1];
+    if (!next || next.startsWith("-")) {
+      addOption(options, normalized, "true");
+      continue;
+    }
+    addOption(options, normalized, next);
+    index += 1;
+  }
+  return { positionals, options };
+}
+function findCommand(positionals) {
+  if (positionals.length === 0) {
+    return void 0;
+  }
+  const commandKey = positionals[0] === "auth" || positionals[0] === "projects" ? positionals.slice(0, 2).join(" ") : positionals[0];
+  return COMMANDS.find((command) => command.name === commandKey);
+}
+function printGeneralHelp() {
+  console.log(`SwarmCraft CLI ${VERSION}
+
+Usage:
+  swarmcraft <command> [options]
+
+Commands:
+${COMMANDS.map((command) => `  ${command.usage}
+      ${command.summary}${command.implemented ? "" : " (planned)"}`).join("\n")}
+
+Options:
+  -h, --help       Show help.
+  -v, --version    Show version.
+
+Artifacts:
+  Customer run manifests will live under .swarmcraft/runs/<run-id> in the selected workspace.
+`);
+}
+function printCommandHelp(command) {
+  console.log(`${command.usage}
+
+${command.summary}${command.implemented ? "" : "\n\nThis command is planned but not implemented yet."}
+`);
+}
+function addOption(options, key, value) {
+  const values = options.get(key) ?? [];
+  values.push(value);
+  options.set(key, values);
+}
+function hasFlag(parsed, key) {
+  return parsed.options.has(key);
+}
+function getOption(parsed, key) {
+  return parsed.options.get(key)?.at(-1);
+}
+function getOptions(parsed, key) {
+  return parsed.options.get(key) ?? [];
+}
+function requireOption(parsed, key) {
+  const value = getOption(parsed, key);
+  if (!value || value === "true") {
+    throw new Error(`Missing required option --${key}.`);
+  }
+  return value;
+}
+function parseTicketLimit(rawValue) {
+  if (rawValue === "all") {
+    return "all";
+  }
+  const parsed = Number.parseInt(rawValue, 10);
+  if (!Number.isInteger(parsed) || parsed < 1) {
+    throw new Error("--ticket-limit must be a positive integer or all.");
+  }
+  return parsed;
+}
+function parsePositiveInteger(rawValue, flagName) {
+  const parsed = Number.parseInt(rawValue, 10);
+  if (!Number.isInteger(parsed) || parsed < 1) {
+    throw new Error(`${flagName} must be a positive integer.`);
+  }
+  return parsed;
+}
+function parseNonNegativeNumber(rawValue, flagName) {
+  const parsed = Number.parseFloat(rawValue);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    throw new Error(`${flagName} must be a non-negative number.`);
+  }
+  return parsed;
+}
+function parseOnOff(rawValue, flagName) {
+  if (rawValue === "on") {
+    return true;
+  }
+  if (rawValue === "off") {
+    return false;
+  }
+  throw new Error(`${flagName} must be on or off.`);
+}
+function parseChoice(rawValue, choices, flagName) {
+  if (choices.includes(rawValue)) {
+    return rawValue;
+  }
+  throw new Error(`${flagName} must be one of ${choices.join(", ")}.`);
+}
+function parseRunId(rawValue) {
+  if (!rawValue) {
+    return void 0;
+  }
+  if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,120}$/.test(rawValue)) {
+    throw new Error("--run-id must start with a letter or number and contain only letters, numbers, dots, underscores, or hyphens.");
+  }
+  return rawValue;
+}
+function redact(value) {
+  if (Array.isArray(value)) {
+    return value.map(redact);
+  }
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+  return Object.fromEntries(
+    Object.entries(value).map(([key, entry]) => [
+      key,
+      /token|secret|password|api[-_]?key|credential/i.test(key) ? "<redacted>" : redact(entry)
+    ])
+  );
+}
+async function promptLine(prompt) {
+  const readline = (0, import_promises5.createInterface)({ input: import_node_process.stdin, output: import_node_process.stdout });
+  try {
+    return (await readline.question(prompt)).trim();
+  } finally {
+    readline.close();
+  }
+}
+async function promptSecret(prompt) {
+  return promptLine(prompt);
+}
+main(process.argv.slice(2)).then((exitCode) => {
+  process.exitCode = exitCode;
+}).catch((error) => {
+  if (error instanceof SwarmCraftApiError) {
+    const request = error.requestId ? ` requestId=${error.requestId}` : "";
+    console.error(`${error.code}: ${error.message}${request}`);
+  } else {
+    console.error(error instanceof Error ? error.message : String(error));
+  }
+  process.exitCode = 1;
+});