agentic-dev 0.2.14 → 0.2.16

package/dist/lib/orchestration-assets.js

@@ -0,0 +1,673 @@
+// @ts-nocheck
+import fs from "node:fs";
+import path from "node:path";
+const SPECIALIZED_AGENTS = [
+    { id: "architecture", description: "Drive boundaries, system shape, and migration decisions." },
+    { id: "specs", description: "Translate SDD planning artifacts into actionable task structure." },
+    { id: "runtime", description: "Own application/runtime implementation work." },
+    { id: "ui", description: "Own screen and UI delivery tasks." },
+    { id: "api", description: "Own contract and API work." },
+    { id: "quality", description: "Run verification and regression closure." },
+    { id: "gitops", description: "Own GitHub Projects, workflow automation, and delivery closure." },
+];
+function repoRootDir() {
+    return path.resolve(new URL("../../", import.meta.url).pathname);
+}
+function copyRecursive(sourceRoot, destinationRoot) {
+    fs.mkdirSync(destinationRoot, { recursive: true });
+    for (const entry of fs.readdirSync(sourceRoot, { withFileTypes: true })) {
+        const sourcePath = path.join(sourceRoot, entry.name);
+        const destinationPath = path.join(destinationRoot, entry.name);
+        if (entry.isDirectory()) {
+            copyRecursive(sourcePath, destinationPath);
+        }
+        else {
+            fs.copyFileSync(sourcePath, destinationPath);
+        }
+    }
+}
+function writeFile(filePath, content) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, content);
+}
+function workflowYaml() {
+    return `name: Agentic Orchestration
+
+on:
+  push:
+    paths:
+      - "sdd/02_plan/**"
+      - ".agentic-dev/orchestration.json"
+      - ".agentic-dev/runtime/**"
+  workflow_dispatch:
+
+jobs:
+  orchestrate:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      issues: write
+      repository-projects: write
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: "22"
+
+      - name: Start orchestration server
+        env:
+          GITHUB_TOKEN: \${{ secrets.GITHUB_TOKEN }}
+        run: |
+          npx --yes tsx .agentic-dev/runtime/server.ts > /tmp/agentic-orchestration.log 2>&1 &
+          echo $! > /tmp/agentic-orchestration.pid
+          for i in $(seq 1 30); do
+            if curl -fsS http://127.0.0.1:4310/health >/dev/null; then
+              exit 0
+            fi
+            sleep 1
+          done
+          cat /tmp/agentic-orchestration.log
+          exit 1
+
+      - name: Build task IR from SDD planning
+        run: curl -fsS -X POST http://127.0.0.1:4310/sync/ir
+
+      - name: Sync GitHub project tasks
+        env:
+          GITHUB_TOKEN: \${{ secrets.GITHUB_TOKEN }}
+        run: curl -fsS -X POST http://127.0.0.1:4310/sync/tasks
+
+      - name: Plan multi-agent queue
+        env:
+          GITHUB_TOKEN: \${{ secrets.GITHUB_TOKEN }}
+        run: curl -fsS -X POST http://127.0.0.1:4310/queue/plan
+
+      - name: Build dispatch plan
+        env:
+          GITHUB_TOKEN: \${{ secrets.GITHUB_TOKEN }}
+        run: curl -fsS -X POST http://127.0.0.1:4310/queue/dispatch
+
+      - name: Execute dispatch queue
+        env:
+          GITHUB_TOKEN: \${{ secrets.GITHUB_TOKEN }}
+          AGENTIC_AGENT_TIMEOUT_MS: "30000"
+        run: curl -fsS -X POST http://127.0.0.1:4310/queue/execute
+
+      - name: Close completed tasks
+        env:
+          GITHUB_TOKEN: \${{ secrets.GITHUB_TOKEN }}
+        run: curl -fsS -X POST http://127.0.0.1:4310/tasks/close
+
+      - name: Stop orchestration server
+        if: always()
+        run: |
+          if [ -f /tmp/agentic-orchestration.pid ]; then
+            kill $(cat /tmp/agentic-orchestration.pid) || true
+          fi
+`;
+}
+function runtimeLibScript() {
+    return `#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+
+export function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+export function readJson(filePath, fallback = null) {
+  if (!fs.existsSync(filePath)) return fallback;
+  return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+}
+
+export function writeJson(filePath, payload) {
+  ensureDir(path.dirname(filePath));
+  fs.writeFileSync(filePath, JSON.stringify(payload, null, 2) + "\\n");
+}
+
+export function generatedDir() {
+  return path.resolve(".agentic-dev/generated");
+}
+
+export function generatedPath(name) {
+  return path.join(generatedDir(), name);
+}
+
+export function orchestrationConfig() {
+  return readJson(path.resolve(".agentic-dev/orchestration.json"), {});
+}
+
+export function ghJson(args) {
+  return JSON.parse(execFileSync("gh", args, { encoding: "utf-8" }));
+}
+
+export function gh(args) {
+  return execFileSync("gh", args, { encoding: "utf-8" }).trim();
+}
+
+export function loadTaskIr() {
+  return readJson(generatedPath("task-ir.json"), { tasks: [] });
+}
+
+export function loadQueue() {
+  return readJson(generatedPath("agent-queue.json"), { queue: [] });
+}
+
+export function loadTaskIndex() {
+  return readJson(generatedPath("task-index.json"), { tasks: [] });
+}
+
+export function loadDispatchPlan() {
+  return readJson(generatedPath("dispatch-plan.json"), { dispatch: [] });
+}
+
+export function loadExecutionJournal() {
+  return readJson(generatedPath("execution-journal.json"), { executions: [] });
+}
+`;
+}
+function sddToIrScript() {
+    return `#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import { generatedPath, writeJson } from "./runtime-lib.ts";
+
+function walk(root) {
+  if (!fs.existsSync(root)) return [];
+  const files = [];
+  for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+    const full = path.join(root, entry.name);
+    if (entry.isDirectory()) files.push(...walk(full));
+    else if (entry.name.endsWith(".md")) files.push(full);
+  }
+  return files;
+}
+
+function parseChecklist(markdown, source) {
+  const tasks = [];
+  const lines = markdown.split(/\\r?\\n/);
+  for (const [index, line] of lines.entries()) {
+    const match = line.match(/^- \\[( |x)\\] (.+)$/);
+    if (!match) continue;
+    const status = match[1] === "x" ? "closed" : "open";
+    const title = match[2].trim();
+    const id = \`\${path.basename(source, ".md")}:\${index + 1}\`;
+    tasks.push({ id, title, status, source });
+  }
+  return tasks;
+}
+
+const planRoot = path.resolve("sdd/02_plan");
+const files = walk(planRoot);
+const tasks = files.flatMap((file) =>
+  parseChecklist(fs.readFileSync(file, "utf-8"), path.relative(process.cwd(), file)),
+);
+const outputPath = generatedPath("task-ir.json");
+writeJson(outputPath, { generated_at: new Date().toISOString(), tasks });
+console.log(\`task_ir=\${outputPath}\`);
+console.log(\`tasks=\${tasks.length}\`);
+`;
+}
+function syncProjectTasksScript() {
+    return `#!/usr/bin/env node
+import { gh, ghJson, loadTaskIr, orchestrationConfig, writeJson, generatedPath } from "./runtime-lib.ts";
+
+const orchestration = orchestrationConfig();
+const taskIr = loadTaskIr();
+const existingIssues = ghJson([
+  "issue",
+  "list",
+  "--repo",
+  orchestration.github.repository.slug,
+  "--state",
+  "all",
+  "--limit",
+  "200",
+  "--json",
+  "number,title,state",
+]);
+const syncResult = { created: [], closed: [], tasks: [] };
+
+for (const task of taskIr.tasks) {
+  const issueTitle = \`[agentic-task] \${task.id} \${task.title}\`;
+  const found = existingIssues.find((issue) =>
+    issue.title.startsWith(\`[agentic-task] \${task.id} \`),
+  );
+  if (!found && task.status === "open") {
+    const url = gh([
+      "issue",
+      "create",
+      "--repo",
+      orchestration.github.repository.slug,
+      "--title",
+      issueTitle,
+      "--body",
+      \`SDD source: \${task.source}\\n\\nManaged by agentic-dev orchestration.\`,
+    ]);
+    syncResult.created.push({ id: task.id, title: task.title, issue_url: url });
+  }
+  if (found && task.status === "closed" && found.state !== "CLOSED") {
+    gh([
+      "issue",
+      "close",
+      String(found.number),
+      "--repo",
+      orchestration.github.repository.slug,
+      "--comment",
+      "Closed from SDD task IR.",
+    ]);
+    syncResult.closed.push({ id: task.id, issue_number: found.number });
+  }
+
+  syncResult.tasks.push({
+    id: task.id,
+    title: task.title,
+    source: task.source,
+    status: task.status,
+    issue_number: found?.number ?? null,
+    issue_url: found
+      ? \`https://github.com/\${orchestration.github.repository.slug}/issues/\${found.number}\`
+      : null,
+  });
+}
+
+writeJson(generatedPath("task-sync.json"), syncResult);
+writeJson(generatedPath("task-index.json"), { tasks: syncResult.tasks });
+console.log(\`synced_tasks=\${taskIr.tasks.length}\`);
+`;
+}
+function runQueueScript() {
+    return `#!/usr/bin/env node
+import { generatedPath, loadTaskIr, orchestrationConfig, writeJson } from "./runtime-lib.ts";
+
+const orchestration = orchestrationConfig();
+const taskIr = loadTaskIr();
+
+function classifyAgent(title) {
+  const lower = title.toLowerCase();
+  if (lower.includes("api") || lower.includes("contract")) return "api";
+  if (lower.includes("screen") || lower.includes("ui")) return "ui";
+  if (lower.includes("verify") || lower.includes("test") || lower.includes("proof")) return "quality";
+  if (lower.includes("workflow") || lower.includes("project") || lower.includes("github")) return "gitops";
+  if (lower.includes("arch") || lower.includes("boundary") || lower.includes("structure")) return "architecture";
+  if (lower.includes("plan") || lower.includes("spec")) return "specs";
+  return "runtime";
+}
+
+function pickProvider(title) {
+  const providers = Array.isArray(orchestration.providers) ? orchestration.providers : [];
+  const lower = title.toLowerCase();
+  if (lower.includes("verify") || lower.includes("test")) {
+    return providers.find((provider) => provider.startsWith("claude")) || providers[0] || "claude-subscription";
+  }
+  if (lower.includes("api") || lower.includes("contract")) {
+    return providers.find((provider) => provider.includes("api")) || providers[0] || "openai-api";
+  }
+  return providers.find((provider) => provider.startsWith("codex")) || providers[0] || "codex-subscription";
+}
+
+const openTasks = taskIr.tasks.filter((task) => task.status === "open");
+const queue = openTasks.map((task) => ({
+  ...task,
+  assigned_agent: classifyAgent(task.title),
+  preferred_provider: pickProvider(task.title),
+}));
+
+const outputPath = generatedPath("agent-queue.json");
+writeJson(outputPath, { providers: orchestration.providers, queue });
+console.log(\`agent_queue=\${outputPath}\`);
+console.log(\`queued=\${queue.length}\`);
+`;
+}
+function dispatchQueueScript() {
+    return `#!/usr/bin/env node
+import { generatedPath, loadQueue, orchestrationConfig, writeJson } from "./runtime-lib.ts";
+
+const orchestration = orchestrationConfig();
+const queuePayload = loadQueue();
+
+const dispatch = queuePayload.queue.map((task) => ({
+  task_id: task.id,
+  title: task.title,
+  source: task.source,
+  assigned_agent: task.assigned_agent,
+  provider: task.preferred_provider,
+  repository: orchestration.github.repository.slug,
+  project_title: orchestration.github.project.title,
+  execution_state: "planned",
+}));
+
+const outputPath = generatedPath("dispatch-plan.json");
+writeJson(outputPath, {
+  generated_at: new Date().toISOString(),
+  dispatch,
+});
+console.log(\`dispatch_plan=\${outputPath}\`);
+console.log(\`planned=\${dispatch.length}\`);
+`;
+}
+function dispatchExecutorScript() {
+    return `#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { generatedPath, loadDispatchPlan, loadTaskIndex, orchestrationConfig, writeJson } from "./runtime-lib.ts";
+
+const orchestration = orchestrationConfig();
+const dispatchPlan = loadDispatchPlan();
+const taskIndex = loadTaskIndex();
+const executionDir = generatedPath("executions");
+const commandTimeoutMs = Number(process.env.AGENTIC_AGENT_TIMEOUT_MS || 30000);
+fs.mkdirSync(executionDir, { recursive: true });
+
+function commandExists(command) {
+  const result = spawnSync("bash", ["-lc", \`command -v \${command}\`], { stdio: "ignore" });
+  return result.status === 0;
+}
+
+function commentOnIssue(issueNumber, body) {
+  return spawnSync(
+    "gh",
+    ["issue", "comment", String(issueNumber), "--repo", orchestration.github.repository.slug, "--body", body],
+    { encoding: "utf-8" },
+  );
+}
+
+function buildPrompt(item, taskMeta) {
+  return [
+    \`You are the \${item.assigned_agent} agent working inside repository \${item.repository}.\`,
+    \`GitHub Project: \${item.project_title}\`,
+    \`Task id: \${item.task_id}\`,
+    \`Task title: \${item.title}\`,
+    taskMeta?.source ? \`SDD source: \${taskMeta.source}\` : "",
+    "Follow the repository SDD workflow.",
+    "Implement the task directly in the working tree when changes are required.",
+    "Run relevant verification for the task.",
+    "Return a concise summary of what changed, what was verified, and any blockers.",
+  ]
+    .filter(Boolean)
+    .join("\\n");
+}
+
+function runProvider(provider, prompt) {
+  if ((provider.startsWith("codex") || provider.startsWith("openai")) && commandExists("codex")) {
+    return {
+      adapter: "codex-cli",
+      result: spawnSync(
+        "codex",
+        [
+          "exec",
+          "--skip-git-repo-check",
+          "--dangerously-bypass-approvals-and-sandbox",
+          "--cd",
+          process.cwd(),
+          prompt,
+        ],
+        { encoding: "utf-8", maxBuffer: 1024 * 1024 * 20, timeout: commandTimeoutMs },
+      ),
+    };
+  }
+
+  if (provider.startsWith("claude") && commandExists("claude")) {
+    return {
+      adapter: "claude-cli",
+      result: spawnSync(
+        "claude",
+        [
+          "-p",
+          "--dangerously-skip-permissions",
+          "--output-format",
+          "text",
+          "--add-dir",
+          process.cwd(),
+          prompt,
+        ],
+        { encoding: "utf-8", maxBuffer: 1024 * 1024 * 20, timeout: commandTimeoutMs },
+      ),
+    };
+  }
+
+  if (provider.startsWith("ollama") && commandExists("ollama")) {
+    return {
+      adapter: "ollama-cli",
+      result: spawnSync(
+        "ollama",
+        ["run", process.env.AGENTIC_OLLAMA_MODEL || "qwen2.5-coder:7b", prompt],
+        { encoding: "utf-8", maxBuffer: 1024 * 1024 * 20, timeout: commandTimeoutMs },
+      ),
+    };
+  }
+
+  return {
+    adapter: "unavailable",
+    result: {
+      status: 127,
+      stdout: "",
+      stderr: \`No live adapter available for provider \${provider}\`,
+    },
+  };
+}
+
+const executions = [];
+
+for (const item of dispatchPlan.dispatch) {
+  const taskMeta = taskIndex.tasks.find((task) => task.id === item.task_id) || {};
+  const executionPath = path.join(executionDir, \`\${item.task_id}.json\`);
+  const prompt = buildPrompt(item, taskMeta);
+  const startedAt = new Date().toISOString();
+
+  const record = {
+    ...item,
+    issue_number: taskMeta.issue_number ?? null,
+    issue_url: taskMeta.issue_url ?? null,
+    started_at: startedAt,
+    completed_at: null,
+    prompt_path: path.relative(process.cwd(), executionPath.replace(/\\.json$/, ".prompt.txt")),
+    execution_artifact: path.relative(process.cwd(), executionPath),
+    adapter: "pending",
+    execution_state: "running",
+    exit_code: null,
+    stdout: "",
+    stderr: "",
+  };
+
+  fs.writeFileSync(executionPath.replace(/\\.json$/, ".prompt.txt"), prompt + "\\n");
+  const live = runProvider(String(item.provider || ""), prompt);
+  record.adapter = live.adapter;
+  record.exit_code = live.result.status ?? null;
+  record.stdout = String(live.result.stdout || "");
+  record.stderr = String(live.result.stderr || "");
+  record.execution_state = live.result.status === 0 ? "completed" : "failed";
+  record.completed_at = new Date().toISOString();
+
+  if (record.issue_number) {
+    const comment = [
+      "Agentic-dev dispatch execution result",
+      \`Task: \${record.task_id}\`,
+      \`Provider: \${record.provider}\`,
+      \`Adapter: \${record.adapter}\`,
+      \`State: \${record.execution_state}\`,
+      \`Execution artifact: \${record.execution_artifact}\`,
+    ].join("\\n");
+    commentOnIssue(record.issue_number, comment);
+  }
+
+  fs.writeFileSync(executionPath, JSON.stringify(record, null, 2) + "\\n");
+  executions.push(record);
+}
+
+writeJson(generatedPath("execution-journal.json"), {
+  generated_at: new Date().toISOString(),
+  executions,
+});
+console.log(\`executed=\${executions.length}\`);
+console.log(\`execution_journal=\${generatedPath("execution-journal.json")}\`);
+`;
+}
+function closeTasksScript() {
+    return `#!/usr/bin/env node
+import { gh, ghJson, generatedPath, loadExecutionJournal, orchestrationConfig, writeJson } from "./runtime-lib.ts";
+
+const orchestration = orchestrationConfig();
+const executionJournal = loadExecutionJournal();
+const issues = ghJson([
+  "issue",
+  "list",
+  "--repo",
+  orchestration.github.repository.slug,
+  "--state",
+  "open",
+  "--limit",
+  "200",
+  "--json",
+  "number,title",
+]);
+const closed = [];
+
+const successfulTaskIds = new Set(
+  executionJournal.executions
+    .filter((execution) => execution.execution_state === "completed")
+    .map((execution) => execution.task_id),
+);
+
+for (const issue of issues) {
+  const match = issue.title.match(/^\\[agentic-task\\] ([^ ]+) /);
+  if (!match) continue;
+  if (!successfulTaskIds.has(match[1])) continue;
+  gh([
+    "issue",
+    "close",
+    String(issue.number),
+    "--repo",
+    orchestration.github.repository.slug,
+    "--comment",
+    "Closed from SDD orchestration close pass.",
+  ]);
+  closed.push({ id: match[1], issue_number: issue.number });
+}
+
+writeJson(generatedPath("closed-tasks.json"), { closed });
+console.log(\`closed_candidates=\${successfulTaskIds.size}\`);
+`;
+}
+function serverScript() {
+    return `#!/usr/bin/env node
+import http from "node:http";
+import { spawn } from "node:child_process";
+
+const port = Number(process.env.AGENTIC_ORCHESTRATION_PORT || 4310);
+
+function runNodeScript(script) {
+  return new Promise((resolve, reject) => {
+    const child = spawn("npx", ["--yes", "tsx", script], {
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+
+    let stdout = "";
+    let stderr = "";
+
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+
+    child.on("close", (code) => {
+      if (code !== 0) {
+        reject(new Error(stderr || stdout || \`Script failed: \${script}\`));
+        return;
+      }
+      resolve({ stdout, stderr });
+    });
+  });
+}
+
+const routes = {
+  "POST /sync/ir": ".agentic-dev/runtime/sdd_to_ir.ts",
+  "POST /sync/tasks": ".agentic-dev/runtime/sync_project_tasks.ts",
+  "POST /queue/plan": ".agentic-dev/runtime/run_multi_agent_queue.ts",
+  "POST /queue/dispatch": ".agentic-dev/runtime/dispatch_agents.ts",
+  "POST /queue/execute": ".agentic-dev/runtime/dispatch_execute.ts",
+  "POST /tasks/close": ".agentic-dev/runtime/close_completed_tasks.ts",
+};
+
+const server = http.createServer(async (req, res) => {
+  const routeKey = \`\${req.method} \${req.url}\`;
+  if (req.method === "GET" && req.url === "/health") {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ ok: true, port }));
+    return;
+  }
+
+  const script = routes[routeKey];
+  if (!script) {
+    res.writeHead(404, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "not_found" }));
+    return;
+  }
+
+  try {
+    const result = await runNodeScript(script);
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ ok: true, stdout: result.stdout.trim() }));
+  } catch (error) {
+    res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ ok: false, error: String(error.message || error) }));
+  }
+});
+
+server.listen(port, "127.0.0.1", () => {
+  console.log(\`agentic_orchestration_server=http://127.0.0.1:\${port}\`);
+});
+`;
+}
+export function installSharedAgentAssets(destinationRoot) {
+    const root = repoRootDir();
+    copyRecursive(path.join(root, ".agent"), path.join(destinationRoot, ".agent"));
+    copyRecursive(path.join(root, ".claude"), path.join(destinationRoot, ".claude"));
+    copyRecursive(path.join(root, ".codex"), path.join(destinationRoot, ".codex"));
+}
+export function installOrchestrationAssets(destinationRoot) {
+    writeFile(path.join(destinationRoot, ".github/workflows/agentic-orchestration.yml"), workflowYaml());
+    writeFile(path.join(destinationRoot, ".agentic-dev/runtime/runtime-lib.ts"), runtimeLibScript());
+    writeFile(path.join(destinationRoot, ".agentic-dev/runtime/sdd_to_ir.ts"), sddToIrScript());
+    writeFile(path.join(destinationRoot, ".agentic-dev/runtime/sync_project_tasks.ts"), syncProjectTasksScript());
+    writeFile(path.join(destinationRoot, ".agentic-dev/runtime/run_multi_agent_queue.ts"), runQueueScript());
+    writeFile(path.join(destinationRoot, ".agentic-dev/runtime/dispatch_agents.ts"), dispatchQueueScript());
+    writeFile(path.join(destinationRoot, ".agentic-dev/runtime/dispatch_execute.ts"), dispatchExecutorScript());
+    writeFile(path.join(destinationRoot, ".agentic-dev/runtime/close_completed_tasks.ts"), closeTasksScript());
+    writeFile(path.join(destinationRoot, ".agentic-dev/runtime/server.ts"), serverScript());
+}
+export function buildOrchestrationConfig(setupSelections = {}) {
+    return {
+        project_name: setupSelections.projectName || "",
+        specialized_agents: SPECIALIZED_AGENTS,
+        providers: Array.isArray(setupSelections.providerProfiles) ? setupSelections.providerProfiles : [],
+        github: {
+            repository: setupSelections.githubRepository || {},
+            project: setupSelections.githubProject || {},
+            project_mode: setupSelections.githubProjectMode || "create-if-missing",
+        },
+        workflow: {
+            ir_output: ".agentic-dev/generated/task-ir.json",
+            queue_output: ".agentic-dev/generated/agent-queue.json",
+            dispatch_output: ".agentic-dev/generated/dispatch-plan.json",
+            execution_output: ".agentic-dev/generated/execution-journal.json",
+            workflow_file: ".github/workflows/agentic-orchestration.yml",
+            server_entry: ".agentic-dev/runtime/server.ts",
+            executor_entry: ".agentic-dev/runtime/dispatch_execute.ts",
+            server_port: 4310,
+        },
+    };
+}
+export function writeOrchestrationConfig(destinationRoot, setupSelections = {}) {
+    const config = buildOrchestrationConfig(setupSelections);
+    writeFile(path.join(destinationRoot, ".agentic-dev/orchestration.json"), `${JSON.stringify(config, null, 2)}\n`);
+}
+//# sourceMappingURL=orchestration-assets.js.map

package/dist/lib/orchestration-assets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestration-assets.js","sourceRoot":"","sources":["../../src/lib/orchestration-assets.ts"],"names":[],"mappings":"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"}