@aman_asmuei/aman-agent 0.34.0 → 0.40.0

package/dist/index.js

@@ -659,24 +659,247 @@ var init_delegate_remote = __esm({
   }
 });
 
+// src/orchestrator/types.ts
+import { z } from "zod";
+var ModelTierEnum, TaskNodeSchema, PhaseGateTypeEnum, PhaseGateSchema, TaskDAGSchema, OrchestrationStatusEnum, TaskStatusEnum, OrchestrationConfigSchema;
+var init_types = __esm({
+  "src/orchestrator/types.ts"() {
+    "use strict";
+    ModelTierEnum = z.enum(["fast", "standard", "advanced"]);
+    TaskNodeSchema = z.object({
+      id: z.string().min(1),
+      name: z.string().min(1),
+      description: z.string().optional(),
+      profile: z.string().min(1),
+      tier: ModelTierEnum,
+      dependencies: z.array(z.string()).default([]),
+      phase: z.string().optional(),
+      context: z.string().optional(),
+      metadata: z.record(z.unknown()).optional()
+    });
+    PhaseGateTypeEnum = z.enum([
+      "approval",
+      "ci_pass",
+      "test_pass",
+      "custom"
+    ]);
+    PhaseGateSchema = z.object({
+      id: z.string().min(1),
+      name: z.string().min(1),
+      type: PhaseGateTypeEnum,
+      afterNodes: z.array(z.string()),
+      beforeNodes: z.array(z.string()),
+      metadata: z.record(z.unknown()).optional()
+    });
+    TaskDAGSchema = z.object({
+      id: z.string().min(1),
+      name: z.string().min(1),
+      goal: z.string().min(1),
+      nodes: z.array(TaskNodeSchema).min(1),
+      gates: z.array(PhaseGateSchema).default([]),
+      metadata: z.record(z.unknown()).optional()
+    });
+    OrchestrationStatusEnum = z.enum([
+      "pending",
+      "running",
+      "awaiting_approval",
+      "approved",
+      "paused",
+      "completed",
+      "failed",
+      "cancelled"
+    ]);
+    TaskStatusEnum = z.enum([
+      "pending",
+      "ready",
+      "running",
+      "completed",
+      "failed",
+      "skipped",
+      "blocked"
+    ]);
+    OrchestrationConfigSchema = z.object({
+      maxParallelTasks: z.number().int().positive().default(4),
+      defaultTier: ModelTierEnum.default("standard"),
+      requireApprovalForPhaseTransition: z.boolean().default(true),
+      taskTimeoutMs: z.number().int().positive().default(3e5),
+      orchestrationTimeoutMs: z.number().int().positive().default(36e5)
+    });
+  }
+});
+
+// src/orchestrator/dag.ts
+function validateDAG(dag) {
+  const nodeIds = /* @__PURE__ */ new Set();
+  for (const node of dag.nodes) {
+    if (nodeIds.has(node.id)) {
+      throw new DAGValidationError(`Duplicate node id: "${node.id}"`);
+    }
+    nodeIds.add(node.id);
+  }
+  for (const node of dag.nodes) {
+    for (const dep of node.dependencies) {
+      if (!nodeIds.has(dep)) {
+        throw new DAGValidationError(
+          `Node "${node.id}" depends on nonexistent node "${dep}"`
+        );
+      }
+    }
+  }
+  for (const gate of dag.gates) {
+    for (const id of gate.afterNodes) {
+      if (!nodeIds.has(id)) {
+        throw new DAGValidationError(
+          `Gate "${gate.id}" references nonexistent afterNode "${id}"`
+        );
+      }
+    }
+    for (const id of gate.beforeNodes) {
+      if (!nodeIds.has(id)) {
+        throw new DAGValidationError(
+          `Gate "${gate.id}" references nonexistent beforeNode "${id}"`
+        );
+      }
+    }
+  }
+  const inDegree = /* @__PURE__ */ new Map();
+  const adj = /* @__PURE__ */ new Map();
+  for (const node of dag.nodes) {
+    inDegree.set(node.id, 0);
+    adj.set(node.id, []);
+  }
+  for (const node of dag.nodes) {
+    for (const dep of node.dependencies) {
+      adj.get(dep).push(node.id);
+      inDegree.set(node.id, inDegree.get(node.id) + 1);
+    }
+  }
+  const queue = [];
+  for (const [id, deg] of inDegree) {
+    if (deg === 0) queue.push(id);
+  }
+  let visited = 0;
+  while (queue.length > 0) {
+    const current = queue.shift();
+    visited++;
+    for (const neighbor of adj.get(current)) {
+      const newDeg = inDegree.get(neighbor) - 1;
+      inDegree.set(neighbor, newDeg);
+      if (newDeg === 0) queue.push(neighbor);
+    }
+  }
+  if (visited !== dag.nodes.length) {
+    throw new DAGValidationError(
+      "DAG contains a cycle \u2014 not all nodes were reachable via topological ordering"
+    );
+  }
+}
+var DAGValidationError;
+var init_dag = __esm({
+  "src/orchestrator/dag.ts"() {
+    "use strict";
+    DAGValidationError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "DAGValidationError";
+      }
+    };
+  }
+});
+
+// src/orchestrator/decompose.ts
+function parseDecompositionResponse(response) {
+  let jsonStr;
+  const codeBlockMatch = response.match(/```(?:json)?\s*\n([\s\S]*?)\n```/);
+  if (codeBlockMatch) {
+    jsonStr = codeBlockMatch[1];
+  } else {
+    jsonStr = response;
+  }
+  let raw;
+  try {
+    raw = JSON.parse(jsonStr);
+  } catch {
+    throw new Error(
+      `Failed to parse decomposition response as JSON: ${jsonStr.slice(0, 200)}`
+    );
+  }
+  const parsed = TaskDAGSchema.parse(raw);
+  validateDAG(parsed);
+  return parsed;
+}
+async function decomposeRequirement(requirement, client) {
+  const response = await client.chat(
+    DECOMPOSITION_SYSTEM_PROMPT,
+    [{ role: "user", content: requirement }],
+    () => {
+    }
+    // stream chunks are unused; we read the final message
+  );
+  const text3 = typeof response.message.content === "string" ? response.message.content : response.message.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+  return parseDecompositionResponse(text3);
+}
+var DECOMPOSITION_SYSTEM_PROMPT;
+var init_decompose = __esm({
+  "src/orchestrator/decompose.ts"() {
+    "use strict";
+    init_types();
+    init_dag();
+    DECOMPOSITION_SYSTEM_PROMPT = `You are a software project decomposer. Given a requirement, break it into a task DAG for parallel agent execution.
+
+Return ONLY valid JSON matching this schema:
+{
+  "id": "orch-<short-id>",
+  "name": "<short name>",
+  "goal": "<one-line goal>",
+  "nodes": [
+    {
+      "id": "<unique-id>",
+      "name": "<task name>",
+      "description": "<what to do>",
+      "profile": "<architect|coder|tester|reviewer|security>",
+      "tier": "<fast|standard|advanced>",
+      "dependencies": ["<prerequisite task ids>"]
+    }
+  ],
+  "gates": [
+    {
+      "id": "<gate-id>",
+      "name": "<gate description>",
+      "type": "approval",
+      "afterNodes": ["<completed before gate>"],
+      "beforeNodes": ["<blocked until gate resolves>"]
+    }
+  ]
+}
+
+Rules:
+- architect profile = tier advanced
+- coder/tester/reviewer = tier standard
+- Maximize parallelism
+- Add approval gate before destructive actions
+- 3-12 tasks for most features`;
+  }
+});
+
 // src/dev/stack-detector.ts
 var stack_detector_exports = {};
 __export(stack_detector_exports, {
   scanStack: () => scanStack
 });
-import fs24 from "fs";
-import path24 from "path";
+import fs17 from "fs";
+import path17 from "path";
 function scanStack(projectPath) {
   const languages = [];
   const frameworks = [];
   const databases = [];
   const infra = [];
   let isMonorepo = false;
-  let projectName = path24.basename(projectPath);
-  const goModPath = path24.join(projectPath, "go.mod");
-  if (fs24.existsSync(goModPath)) {
+  let projectName = path17.basename(projectPath);
+  const goModPath = path17.join(projectPath, "go.mod");
+  if (fs17.existsSync(goModPath)) {
     languages.push("go");
-    const content = fs24.readFileSync(goModPath, "utf-8");
+    const content = fs17.readFileSync(goModPath, "utf-8");
     const moduleMatch = content.match(/^module\s+(.+)$/m);
     if (moduleMatch) {
       const parts = moduleMatch[1].trim().split("/");
@@ -687,11 +910,11 @@ function scanStack(projectPath) {
     if (content.includes("go-chi/chi")) frameworks.push("chi");
     if (content.includes("labstack/echo")) frameworks.push("echo");
   }
-  const pkgPath = path24.join(projectPath, "package.json");
-  const hasTsConfig = fs24.existsSync(path24.join(projectPath, "tsconfig.json"));
-  if (fs24.existsSync(pkgPath)) {
+  const pkgPath = path17.join(projectPath, "package.json");
+  const hasTsConfig = fs17.existsSync(path17.join(projectPath, "tsconfig.json"));
+  if (fs17.existsSync(pkgPath)) {
     try {
-      const pkg = JSON.parse(fs24.readFileSync(pkgPath, "utf-8"));
+      const pkg = JSON.parse(fs17.readFileSync(pkgPath, "utf-8"));
       if (pkg.name) projectName = pkg.name;
       if (hasTsConfig) {
         languages.push("typescript");
@@ -709,35 +932,35 @@ function scanStack(projectPath) {
   } else if (hasTsConfig) {
     languages.push("typescript");
   }
-  const cargoPath = path24.join(projectPath, "Cargo.toml");
-  if (fs24.existsSync(cargoPath)) {
+  const cargoPath = path17.join(projectPath, "Cargo.toml");
+  if (fs17.existsSync(cargoPath)) {
     languages.push("rust");
-    const content = fs24.readFileSync(cargoPath, "utf-8");
+    const content = fs17.readFileSync(cargoPath, "utf-8");
     if (content.includes("[workspace]")) isMonorepo = true;
     const nameMatch = content.match(/^\s*name\s*=\s*"([^"]+)"/m);
     if (nameMatch && !isMonorepo) projectName = nameMatch[1];
   }
-  const pyprojectPath = path24.join(projectPath, "pyproject.toml");
-  if (fs24.existsSync(pyprojectPath)) {
+  const pyprojectPath = path17.join(projectPath, "pyproject.toml");
+  if (fs17.existsSync(pyprojectPath)) {
     languages.push("python");
-    const content = fs24.readFileSync(pyprojectPath, "utf-8");
+    const content = fs17.readFileSync(pyprojectPath, "utf-8");
     if (content.includes("django")) frameworks.push("django");
     if (content.includes("fastapi")) frameworks.push("fastapi");
     if (content.includes("flask")) frameworks.push("flask");
   }
-  if (fs24.existsSync(path24.join(projectPath, "pubspec.yaml"))) {
+  if (fs17.existsSync(path17.join(projectPath, "pubspec.yaml"))) {
     languages.push("dart");
     frameworks.push("flutter");
   }
-  if (fs24.existsSync(path24.join(projectPath, "Dockerfile"))) {
+  if (fs17.existsSync(path17.join(projectPath, "Dockerfile"))) {
     infra.push("docker");
   }
   const composeNames = ["docker-compose.yml", "docker-compose.yaml", "compose.yml", "compose.yaml"];
   for (const name of composeNames) {
-    const composePath = path24.join(projectPath, name);
-    if (fs24.existsSync(composePath)) {
+    const composePath = path17.join(projectPath, name);
+    if (fs17.existsSync(composePath)) {
       if (!infra.includes("docker")) infra.push("docker");
-      const content = fs24.readFileSync(composePath, "utf-8");
+      const content = fs17.readFileSync(composePath, "utf-8");
       for (const [pattern, dbName] of Object.entries(DB_IMAGE_MAP)) {
         if (content.includes(pattern) && !databases.includes(dbName)) {
           databases.push(dbName);
@@ -746,16 +969,16 @@ function scanStack(projectPath) {
       break;
     }
   }
-  if (fs24.existsSync(path24.join(projectPath, ".github", "workflows"))) {
+  if (fs17.existsSync(path17.join(projectPath, ".github", "workflows"))) {
     infra.push("github-actions");
   }
   for (const dir of ["k3s", "k8s", "deploy"]) {
-    if (fs24.existsSync(path24.join(projectPath, dir))) {
+    if (fs17.existsSync(path17.join(projectPath, dir))) {
       infra.push("kubernetes");
       break;
     }
   }
-  if (fs24.existsSync(path24.join(projectPath, "Makefile"))) {
+  if (fs17.existsSync(path17.join(projectPath, "Makefile"))) {
     infra.push("make");
   }
   return {
@@ -795,10 +1018,475 @@ var init_stack_detector = __esm({
   }
 });
 
+// src/github/types.ts
+import { z as z2 } from "zod";
+var GitHubIssueSchema, GitHubPRSchema, WorkflowRunSchema, CheckStatusSchema, GhResultSchema;
+var init_types2 = __esm({
+  "src/github/types.ts"() {
+    "use strict";
+    GitHubIssueSchema = z2.object({
+      number: z2.number().int().positive(),
+      title: z2.string().min(1),
+      body: z2.string().nullable().default(null),
+      state: z2.enum(["OPEN", "CLOSED"]),
+      url: z2.string().url(),
+      labels: z2.array(z2.object({ name: z2.string() })).default([]),
+      assignees: z2.array(z2.object({ login: z2.string() })).default([]),
+      author: z2.object({ login: z2.string() }).optional(),
+      createdAt: z2.string(),
+      updatedAt: z2.string()
+    });
+    GitHubPRSchema = z2.object({
+      number: z2.number().int().positive(),
+      title: z2.string().min(1),
+      body: z2.string().nullable().default(null),
+      state: z2.enum(["OPEN", "CLOSED", "MERGED"]),
+      url: z2.string().url(),
+      headRefName: z2.string(),
+      baseRefName: z2.string(),
+      isDraft: z2.boolean().default(false),
+      mergeable: z2.enum(["MERGEABLE", "CONFLICTING", "UNKNOWN"]).default("UNKNOWN"),
+      labels: z2.array(z2.object({ name: z2.string() })).default([]),
+      author: z2.object({ login: z2.string() }).optional(),
+      createdAt: z2.string(),
+      updatedAt: z2.string()
+    });
+    WorkflowRunSchema = z2.object({
+      databaseId: z2.number().int().positive(),
+      name: z2.string(),
+      workflowName: z2.string().optional(),
+      status: z2.enum([
+        "queued",
+        "in_progress",
+        "completed",
+        "waiting",
+        "requested",
+        "pending"
+      ]),
+      conclusion: z2.enum([
+        "success",
+        "failure",
+        "cancelled",
+        "skipped",
+        "timed_out",
+        "action_required",
+        "neutral",
+        "stale",
+        ""
+      ]).nullable().default(null),
+      url: z2.string().url(),
+      headBranch: z2.string(),
+      event: z2.string(),
+      createdAt: z2.string(),
+      updatedAt: z2.string()
+    });
+    CheckStatusSchema = z2.object({
+      passed: z2.boolean(),
+      pending: z2.boolean(),
+      failing: z2.boolean(),
+      total: z2.number().int().nonnegative(),
+      details: z2.array(
+        z2.object({
+          name: z2.string(),
+          status: z2.string(),
+          conclusion: z2.string().nullable()
+        })
+      ).default([])
+    });
+    GhResultSchema = z2.object({
+      success: z2.boolean(),
+      stdout: z2.string(),
+      stderr: z2.string(),
+      exitCode: z2.number().int()
+    });
+  }
+});
+
+// src/github/cli.ts
+var cli_exports = {};
+__export(cli_exports, {
+  GhError: () => GhError,
+  gh: () => gh,
+  ghAvailable: () => ghAvailable,
+  ghCurrentRepo: () => ghCurrentRepo,
+  ghJson: () => ghJson
+});
+import { execFile } from "child_process";
+import { promisify } from "util";
+async function gh(args, options) {
+  const ghBin = options?.env?.GH_PATH ?? process.env.GH_PATH ?? "gh";
+  const timeout = options?.timeoutMs ?? 3e4;
+  const execOpts = {
+    timeout,
+    ...options?.cwd ? { cwd: options.cwd } : {},
+    ...options?.env ? { env: { ...process.env, ...options.env } } : {}
+  };
+  try {
+    const { stdout, stderr } = await execFileAsync(ghBin, args, execOpts);
+    return { success: true, stdout, stderr, exitCode: 0 };
+  } catch (err) {
+    const e = err;
+    const exitCode = typeof e.code === "number" ? e.code : 1;
+    return {
+      success: false,
+      stdout: e.stdout ?? "",
+      stderr: e.stderr ?? "",
+      exitCode
+    };
+  }
+}
+async function ghJson(args, options) {
+  const result = await gh(args, options);
+  if (!result.success) {
+    throw new GhError(
+      `gh command failed: ${result.stderr}`,
+      result.exitCode,
+      result.stderr
+    );
+  }
+  try {
+    return JSON.parse(result.stdout);
+  } catch {
+    throw new GhError(
+      `Failed to parse JSON from gh output: ${result.stdout.slice(0, 200)}`,
+      0,
+      result.stderr
+    );
+  }
+}
+async function ghAvailable() {
+  const result = await gh(["auth", "status"]);
+  return result.success;
+}
+async function ghCurrentRepo() {
+  try {
+    const data = await ghJson(
+      ["repo", "view", "--json", "owner,name"]
+    );
+    return { owner: data.owner.login, name: data.name };
+  } catch {
+    return null;
+  }
+}
+var execFileAsync, GhError;
+var init_cli = __esm({
+  "src/github/cli.ts"() {
+    "use strict";
+    execFileAsync = promisify(execFile);
+    GhError = class extends Error {
+      constructor(message, exitCode, stderr) {
+        super(message);
+        this.exitCode = exitCode;
+        this.stderr = stderr;
+        this.name = "GhError";
+      }
+      exitCode;
+      stderr;
+    };
+  }
+});
+
+// src/github/issue-planner.ts
+async function fetchIssue(issueNumber, options) {
+  const args = [
+    "issue",
+    "view",
+    String(issueNumber),
+    "--json",
+    ISSUE_JSON_FIELDS
+  ];
+  if (options?.repo) {
+    args.push("--repo", options.repo);
+  }
+  const raw = await ghJson(args, { cwd: options?.cwd });
+  return GitHubIssueSchema.parse(raw);
+}
+function formatIssueAsRequirement(issue) {
+  const parts = [`# ${issue.title}`];
+  if (issue.body) {
+    parts.push("", issue.body);
+  }
+  const extras = [];
+  if (issue.labels.length > 0) {
+    extras.push(`Labels: ${issue.labels.map((l) => l.name).join(", ")}`);
+  }
+  if (issue.assignees.length > 0) {
+    extras.push(
+      `Assignees: ${issue.assignees.map((a) => a.login).join(", ")}`
+    );
+  }
+  if (extras.length > 0) {
+    parts.push("", ...extras);
+  }
+  return parts.join("\n");
+}
+async function planFromIssue(issueNumber, client, options) {
+  const issue = await fetchIssue(issueNumber, options);
+  const requirement = formatIssueAsRequirement(issue);
+  const dag = await decomposeRequirement(requirement, client);
+  return { issue, dag };
+}
+var ISSUE_JSON_FIELDS;
+var init_issue_planner = __esm({
+  "src/github/issue-planner.ts"() {
+    "use strict";
+    init_cli();
+    init_types2();
+    init_decompose();
+    ISSUE_JSON_FIELDS = "number,title,body,state,url,labels,assignees,author,createdAt,updatedAt";
+  }
+});
+
+// src/github/pr-manager.ts
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+async function createPR(options) {
+  const args = [
+    "pr",
+    "create",
+    "--title",
+    options.title,
+    "--body",
+    options.body,
+    "--head",
+    options.head
+  ];
+  if (options.base) {
+    args.push("--base", options.base);
+  }
+  if (options.draft) {
+    args.push("--draft");
+  }
+  if (options.labels) {
+    for (const label of options.labels) {
+      args.push("--label", label);
+    }
+  }
+  if (options.repo) {
+    args.push("--repo", options.repo);
+  }
+  const ghOpts = options.cwd ? { cwd: options.cwd } : void 0;
+  const result = await gh(args, ghOpts);
+  if (!result.success) {
+    const { GhError: GhError2 } = await Promise.resolve().then(() => (init_cli(), cli_exports));
+    throw new GhError2(
+      `Failed to create PR: ${result.stderr}`,
+      result.exitCode,
+      result.stderr
+    );
+  }
+  const url = result.stdout.trim();
+  const prNumber = parseInt(url.split("/").pop(), 10);
+  return getPR(prNumber, { repo: options.repo, cwd: options.cwd });
+}
+async function listPRs(options) {
+  const args = ["pr", "list", "--json", PR_JSON_FIELDS];
+  if (options?.state) {
+    args.push("--state", options.state);
+  }
+  if (options?.head) {
+    args.push("--head", options.head);
+  }
+  if (options?.limit != null) {
+    args.push("--limit", String(options.limit));
+  }
+  if (options?.repo) {
+    args.push("--repo", options.repo);
+  }
+  const ghOpts = options?.cwd ? { cwd: options.cwd } : void 0;
+  const raw = await ghJson(args, ghOpts);
+  return raw.map((item) => GitHubPRSchema.parse(item));
+}
+async function getPR(prNumber, options) {
+  const args = [
+    "pr",
+    "view",
+    String(prNumber),
+    "--json",
+    PR_JSON_FIELDS
+  ];
+  if (options?.repo) {
+    args.push("--repo", options.repo);
+  }
+  const ghOpts = options?.cwd ? { cwd: options.cwd } : void 0;
+  const raw = await ghJson(args, ghOpts);
+  return GitHubPRSchema.parse(raw);
+}
+async function commentOnPR(prNumber, body, options) {
+  const args = ["pr", "comment", String(prNumber), "--body", body];
+  if (options?.repo) {
+    args.push("--repo", options.repo);
+  }
+  const ghOpts = options?.cwd ? { cwd: options.cwd } : void 0;
+  const result = await gh(args, ghOpts);
+  if (!result.success) {
+    const { GhError: GhError2 } = await Promise.resolve().then(() => (init_cli(), cli_exports));
+    throw new GhError2(
+      `Failed to comment on PR #${prNumber}: ${result.stderr}`,
+      result.exitCode,
+      result.stderr
+    );
+  }
+}
+async function createBranch(branchName, options) {
+  const args = ["checkout", "-b", branchName];
+  if (options?.baseBranch) {
+    args.push(options.baseBranch);
+  }
+  const execOpts = {};
+  if (options?.cwd) {
+    execOpts.cwd = options.cwd;
+  }
+  await execFileAsync2("git", args, execOpts);
+}
+var execFileAsync2, PR_JSON_FIELDS;
+var init_pr_manager = __esm({
+  "src/github/pr-manager.ts"() {
+    "use strict";
+    init_cli();
+    init_types2();
+    execFileAsync2 = promisify2(execFile2);
+    PR_JSON_FIELDS = "number,title,body,state,url,headRefName,baseRefName,isDraft,mergeable,labels,author,createdAt,updatedAt";
+  }
+});
+
+// src/github/ci-gate.ts
+async function getLatestRun(branch, options) {
+  const args = [
+    "run",
+    "list",
+    "--branch",
+    branch,
+    "--limit",
+    "1",
+    "--json",
+    RUN_JSON_FIELDS
+  ];
+  if (options?.workflow) {
+    args.push("--workflow", options.workflow);
+  }
+  if (options?.repo) {
+    args.push("--repo", options.repo);
+  }
+  const runs = await ghJson(args, { cwd: options?.cwd });
+  if (!runs.length) return null;
+  return WorkflowRunSchema.parse(runs[0]);
+}
+async function getCheckStatus(ref, options) {
+  const isPRNumber = /^\d+$/.test(ref);
+  if (isPRNumber) {
+    const args = ["pr", "checks", ref, "--json", "name,status,conclusion"];
+    if (options?.repo) args.push("--repo", options.repo);
+    const checks = await ghJson(args, { cwd: options?.cwd });
+    const details = checks.map((c) => ({
+      name: c.name,
+      status: c.status,
+      conclusion: c.conclusion
+    }));
+    const passed = details.every(
+      (d) => d.status === "completed" && d.conclusion === "success"
+    );
+    const pending = details.some((d) => d.status !== "completed");
+    const failing = details.some(
+      (d) => d.status === "completed" && d.conclusion !== "success" && d.conclusion !== "skipped" && d.conclusion !== "neutral"
+    );
+    return CheckStatusSchema.parse({
+      passed: passed && details.length > 0,
+      pending,
+      failing,
+      total: details.length,
+      details
+    });
+  }
+  const run = await getLatestRun(ref, options);
+  if (!run) {
+    return CheckStatusSchema.parse({
+      passed: false,
+      pending: false,
+      failing: false,
+      total: 0,
+      details: []
+    });
+  }
+  return CheckStatusSchema.parse({
+    passed: run.status === "completed" && run.conclusion === "success",
+    pending: run.status !== "completed",
+    failing: run.status === "completed" && run.conclusion !== "success" && run.conclusion !== "skipped" && run.conclusion !== "neutral",
+    total: 1,
+    details: [
+      { name: run.name, status: run.status, conclusion: run.conclusion }
+    ]
+  });
+}
+async function waitForCI(branch, options) {
+  const pollInterval = options?.pollIntervalMs ?? 1e4;
+  const timeout = options?.timeoutMs ?? 6e5;
+  const deadline = Date.now() + timeout;
+  while (Date.now() < deadline) {
+    const run = await getLatestRun(branch, options);
+    if (run && run.status === "completed") {
+      return { passed: run.conclusion === "success", run };
+    }
+    if (Date.now() + pollInterval >= deadline) break;
+    await new Promise((resolve) => setTimeout(resolve, pollInterval));
+  }
+  return { passed: false, run: null };
+}
+async function isCIPassing(branch, options) {
+  const run = await getLatestRun(branch, options);
+  return run !== null && run.status === "completed" && run.conclusion === "success";
+}
+var RUN_JSON_FIELDS;
+var init_ci_gate = __esm({
+  "src/github/ci-gate.ts"() {
+    "use strict";
+    init_cli();
+    init_types2();
+    RUN_JSON_FIELDS = "databaseId,name,workflowName,status,conclusion,url,headBranch,event,createdAt,updatedAt";
+  }
+});
+
+// src/github/index.ts
+var github_exports = {};
+__export(github_exports, {
+  CheckStatusSchema: () => CheckStatusSchema,
+  GhError: () => GhError,
+  GhResultSchema: () => GhResultSchema,
+  GitHubIssueSchema: () => GitHubIssueSchema,
+  GitHubPRSchema: () => GitHubPRSchema,
+  WorkflowRunSchema: () => WorkflowRunSchema,
+  commentOnPR: () => commentOnPR,
+  createBranch: () => createBranch,
+  createPR: () => createPR,
+  fetchIssue: () => fetchIssue,
+  formatIssueAsRequirement: () => formatIssueAsRequirement,
+  getCheckStatus: () => getCheckStatus,
+  getLatestRun: () => getLatestRun,
+  getPR: () => getPR,
+  gh: () => gh,
+  ghAvailable: () => ghAvailable,
+  ghCurrentRepo: () => ghCurrentRepo,
+  ghJson: () => ghJson,
+  isCIPassing: () => isCIPassing,
+  listPRs: () => listPRs,
+  planFromIssue: () => planFromIssue,
+  waitForCI: () => waitForCI
+});
+var init_github = __esm({
+  "src/github/index.ts"() {
+    "use strict";
+    init_types2();
+    init_cli();
+    init_issue_planner();
+    init_pr_manager();
+    init_ci_gate();
+  }
+});
+
 // src/dev/context-builder.ts
-import fs25 from "fs";
-import path25 from "path";
-import os22 from "os";
+import fs26 from "fs";
+import path26 from "path";
+import os23 from "os";
 import { createDatabase as createDatabase2, recall as recall2 } from "@aman_asmuei/amem-core";
 import {
   getIdentity as acoreGetIdentity2
@@ -826,9 +1514,9 @@ async function buildContext2(stack, opts) {
   const rules = [];
   let memoriesUsed = 0;
   try {
-    const amemDir = process.env.AMEM_DIR ?? path25.join(os22.homedir(), ".amem");
-    const dbPath = process.env.AMEM_DB ?? path25.join(amemDir, "memory.db");
-    if (!process.env.AMEM_DB && !fs25.existsSync(dbPath)) throw new Error("no db");
+    const amemDir = process.env.AMEM_DIR ?? path26.join(os23.homedir(), ".amem");
+    const dbPath = process.env.AMEM_DB ?? path26.join(amemDir, "memory.db");
+    if (!process.env.AMEM_DB && !fs26.existsSync(dbPath)) throw new Error("no db");
     const db2 = createDatabase2(dbPath);
     const queryParts = [stack.projectName, ...stack.languages, ...stack.frameworks];
     const query = queryParts.join(" ");
@@ -984,8 +1672,8 @@ __export(claude_md_writer_exports, {
   writeClaudeMd: () => writeClaudeMd,
   writeContextFile: () => writeContextFile
 });
-import fs26 from "fs";
-import path26 from "path";
+import fs27 from "fs";
+import path27 from "path";
 function formatStack(stack) {
   const parts = [];
   const goFrameworks = ["fiber", "gin", "chi", "echo"];
@@ -1069,11 +1757,11 @@ function parseMarker(content) {
 }
 function checkStaleness(projectPath, editor = "claude") {
   const target = EDITOR_TARGETS[editor];
-  const filePath = path26.join(projectPath, target.contextFile);
-  if (!fs26.existsSync(filePath)) {
+  const filePath = path27.join(projectPath, target.contextFile);
+  if (!fs27.existsSync(filePath)) {
     return { status: "missing" };
   }
-  const content = fs26.readFileSync(filePath, "utf-8");
+  const content = fs27.readFileSync(filePath, "utf-8");
   const marker = parseMarker(content);
   if (!marker) {
     return { status: "no-marker" };
@@ -1082,22 +1770,22 @@ function checkStaleness(projectPath, editor = "claude") {
 }
 function writeContextFile(ctx, projectPath, editor = "claude") {
   const target = EDITOR_TARGETS[editor];
-  const filePath = path26.join(projectPath, target.contextFile);
+  const filePath = path27.join(projectPath, target.contextFile);
   let backedUp = false;
-  const parentDir = path26.dirname(filePath);
-  if (!fs26.existsSync(parentDir)) {
-    fs26.mkdirSync(parentDir, { recursive: true });
+  const parentDir = path27.dirname(filePath);
+  if (!fs27.existsSync(parentDir)) {
+    fs27.mkdirSync(parentDir, { recursive: true });
   }
-  if (fs26.existsSync(filePath)) {
-    const content = fs26.readFileSync(filePath, "utf-8");
+  if (fs27.existsSync(filePath)) {
+    const content = fs27.readFileSync(filePath, "utf-8");
     const marker = parseMarker(content);
     if (!marker) {
-      fs26.copyFileSync(filePath, `${filePath}.bak`);
+      fs27.copyFileSync(filePath, `${filePath}.bak`);
       backedUp = true;
     }
   }
   const md = renderToString(ctx);
-  fs26.writeFileSync(filePath, md, "utf-8");
+  fs27.writeFileSync(filePath, md, "utf-8");
   return { written: true, backedUp, path: filePath };
 }
 var EDITOR_TARGETS, writeClaudeMd;
@@ -1140,23 +1828,23 @@ var dev_command_exports = {};
 __export(dev_command_exports, {
   runDev: () => runDev
 });
-import fs27 from "fs";
-import path27 from "path";
+import fs28 from "fs";
+import path28 from "path";
 function ensureGitignore(projectPath, editor) {
-  const gitignorePath = path27.join(projectPath, ".gitignore");
-  if (!fs27.existsSync(gitignorePath)) return;
-  const content = fs27.readFileSync(gitignorePath, "utf-8");
+  const gitignorePath = path28.join(projectPath, ".gitignore");
+  if (!fs28.existsSync(gitignorePath)) return;
+  const content = fs28.readFileSync(gitignorePath, "utf-8");
   const target = EDITOR_TARGETS[editor];
   if (content.includes(target.gitignoreEntry)) return;
-  fs27.appendFileSync(gitignorePath, `
+  fs28.appendFileSync(gitignorePath, `
 # Generated by aman-agent dev
 ${target.gitignoreEntry}
 `);
 }
 async function runDev(projectPath, flags = {}, precomputedStack) {
-  const resolved = path27.resolve(projectPath);
+  const resolved = path28.resolve(projectPath);
   const editor = flags.editor ?? "claude";
-  if (!fs27.existsSync(resolved)) {
+  if (!fs28.existsSync(resolved)) {
     return { success: false, generated: false, error: `Directory not found: ${resolved}` };
   }
   const stack = precomputedStack ?? scanStack(resolved);
@@ -1164,8 +1852,8 @@ async function runDev(projectPath, flags = {}, precomputedStack) {
     const ctx2 = await buildContext2(stack, { smart: flags.smart });
     const newContent = renderToString(ctx2);
     const target = EDITOR_TARGETS[editor];
-    const existingPath = path27.join(resolved, target.contextFile);
-    const existing = fs27.existsSync(existingPath) ? fs27.readFileSync(existingPath, "utf-8") : "";
+    const existingPath = path28.join(resolved, target.contextFile);
+    const existing = fs28.existsSync(existingPath) ? fs28.readFileSync(existingPath, "utf-8") : "";
     return {
       success: true,
       generated: false,
@@ -2577,18 +3265,18 @@ var McpManager = class {
 
 // src/agent.ts
 import * as readline from "readline";
-import fs23 from "fs";
-import path23 from "path";
-import os21 from "os";
+import fs25 from "fs";
+import path25 from "path";
+import os22 from "os";
 import pc7 from "picocolors";
 import { marked } from "marked";
 import { markedTerminal } from "marked-terminal";
 import logUpdate from "log-update";
 
 // src/commands.ts
-import fs20 from "fs";
-import path20 from "path";
-import os18 from "os";
+import fs22 from "fs";
+import path22 from "path";
+import os19 from "os";
 import { execFileSync as execFileSync3 } from "child_process";
 import pc6 from "picocolors";
 
@@ -2940,6 +3628,136 @@ async function memorySync(action, opts = {}) {
 import fs8 from "fs";
 import path8 from "path";
 import os7 from "os";
+
+// src/profiles/orchestrator-profiles.ts
+var architectProfile = {
+  name: "architect",
+  label: "System Architect",
+  description: "Designs system architecture, decomposes features into modules, plans file structure and interfaces",
+  core: `# System Architect
+
+You are a system architect. Your job is to:
+- Analyze requirements and design the overall system structure
+- Define module boundaries, interfaces, and data flows
+- Plan file structure and naming conventions
+- Identify dependencies and integration points
+- Choose appropriate patterns and abstractions
+- Consider scalability, maintainability, and testability
+
+## Output Format
+Produce a clear, structured design document with:
+1. **Architecture overview** \u2014 high-level components and their relationships
+2. **File structure** \u2014 exact paths for new/modified files
+3. **Interfaces** \u2014 key types, function signatures, and data contracts
+4. **Dependencies** \u2014 what depends on what, build order
+5. **Risks** \u2014 potential issues and mitigation strategies
+
+Be precise with file paths and interface definitions. The implementation agents will follow your design exactly.`,
+  rules: `- Never write implementation code \u2014 design only
+- Always specify exact file paths
+- Consider existing codebase patterns before proposing new ones
+- Flag breaking changes explicitly`
+};
+var securityProfile = {
+  name: "security",
+  label: "Security Analyst",
+  description: "Reviews code for security vulnerabilities, runs SAST checks, audits dependencies",
+  core: `# Security Analyst
+
+You are a security analyst. Your job is to:
+- Review code for OWASP Top 10 vulnerabilities
+- Check for injection flaws (SQL, command, XSS)
+- Verify authentication and authorization patterns
+- Audit dependency versions for known CVEs
+- Check for secrets/credentials in code
+- Validate input sanitization and output encoding
+- Review error handling for information leakage
+
+## Output Format
+Produce a security report with:
+1. **Critical** \u2014 must fix before merge (injection, auth bypass, secrets)
+2. **High** \u2014 should fix (missing validation, weak crypto)
+3. **Medium** \u2014 recommended (verbose errors, missing rate limiting)
+4. **Low** \u2014 informational (best practice suggestions)
+
+For each finding: file path, line number, description, remediation.`,
+  rules: `- Never approve code with Critical findings
+- Always check for hardcoded secrets
+- Flag any use of eval, exec, or shell string concatenation
+- Verify all user input is validated at system boundaries`
+};
+var testerProfile = {
+  name: "tester",
+  label: "Test Engineer",
+  description: "Writes comprehensive tests, identifies edge cases, ensures coverage",
+  core: `# Test Engineer
+
+You are a test engineer. Your job is to:
+- Write comprehensive unit and integration tests
+- Identify edge cases and boundary conditions
+- Test error paths and failure modes
+- Verify behavior against specifications
+- Ensure tests are deterministic and fast
+- Follow existing test patterns in the codebase
+
+## Testing Principles
+- Test behavior, not implementation details
+- Each test should verify one specific thing
+- Use descriptive test names that explain the expected behavior
+- Arrange-Act-Assert pattern
+- Mock external dependencies, test internal logic directly
+- Prefer integration tests for complex interactions
+
+## Output Format
+Produce test files following the project's existing patterns (Vitest, Jest, pytest, etc.).
+Include: happy path, error cases, edge cases, boundary values.`,
+  rules: `- Never skip error path testing
+- Always test boundary conditions
+- Tests must be deterministic (no timing dependencies, no random values)
+- Follow the project's existing test framework and patterns`
+};
+var reviewerProfile = {
+  name: "reviewer",
+  label: "Code Reviewer",
+  description: "Reviews code for quality, correctness, and adherence to patterns",
+  core: `# Code Reviewer
+
+You are a code reviewer. Your job is to:
+- Check code correctness and logic errors
+- Verify adherence to project conventions and patterns
+- Identify potential performance issues
+- Assess readability and maintainability
+- Check error handling completeness
+- Verify tests adequately cover the changes
+
+## Review Approach
+- Focus on correctness first, style second
+- Flag bugs and logic errors as Critical
+- Flag missing error handling as High
+- Flag style and convention issues as Medium
+- Acknowledge good patterns and clean code
+
+## Output Format
+Produce a review with confidence-scored findings:
+- **CRITICAL** (confidence > 0.9) \u2014 definite bugs or security issues
+- **IMPORTANT** (confidence > 0.7) \u2014 likely problems or missing handling
+- **SUGGESTION** (confidence > 0.5) \u2014 improvements worth considering
+- **PRAISE** \u2014 highlight good patterns
+
+Include file path, line range, and specific explanation for each finding.`,
+  rules: `- Never rubber-stamp \u2014 always provide substantive review
+- Focus on what matters: correctness > performance > style
+- Be specific: cite exact lines and explain why something is wrong
+- Distinguish between "must fix" and "nice to have"`
+};
+var ORCHESTRATOR_PROFILES = [
+  architectProfile,
+  securityProfile,
+  testerProfile,
+  reviewerProfile
+];
+
+// src/profile-templates.ts
 var BUILT_IN_PROFILES = [
   {
     name: "coder",
@@ -3027,7 +3845,8 @@ var BUILT_IN_PROFILES = [
 - Present speculation as fact
 - Ignore contradicting evidence
 - Oversimplify complex topics`
-  }
+  },
+  ...ORCHESTRATOR_PROFILES
 ];
 function installProfileTemplate(templateName, userName) {
   const template = BUILT_IN_PROFILES.find((t) => t.name === templateName);
@@ -5253,49 +6072,115 @@ async function delegatePipeline(steps, initialInput, client, mcpManager, options
   return results;
 }
 
+// src/orchestrator/index.ts
+init_types();
+init_dag();
+init_decompose();
+
+// src/orchestrator/scheduler.ts
+init_dag();
+
+// src/orchestrator/checkpoint.ts
+import { readFile as readFile2, writeFile, mkdir } from "fs/promises";
+import { join } from "path";
+
+// src/orchestrator/smart-orchestrate.ts
+init_decompose();
+
+// src/orchestrator/templates/index.ts
+init_dag();
+
+// src/project/detector.ts
+var FRONTEND_FRAMEWORKS = /* @__PURE__ */ new Set(["react", "vue", "svelte"]);
+var FULLSTACK_FRAMEWORKS = /* @__PURE__ */ new Set(["next", "nuxt", "remix"]);
+var BACKEND_FRAMEWORKS = /* @__PURE__ */ new Set([
+  "express",
+  "fastify",
+  "hono",
+  "nestjs",
+  "fiber",
+  "gin",
+  "chi",
+  "echo",
+  "fastapi",
+  "django",
+  "flask"
+]);
+var WEB_FRAMEWORKS = /* @__PURE__ */ new Set([
+  ...FRONTEND_FRAMEWORKS,
+  ...FULLSTACK_FRAMEWORKS,
+  ...BACKEND_FRAMEWORKS
+]);
+
+// src/orchestrator/smart-orchestrate.ts
+init_stack_detector();
+
+// src/profiles/auto-install.ts
+import fs18 from "fs";
+import path18 from "path";
+import os15 from "os";
+
+// src/orchestrator/index.ts
+init_dag();
+function formatDAGForDisplay(dag) {
+  const lines = [];
+  lines.push(`## ${dag.name}`);
+  lines.push(`**Goal:** ${dag.goal}`);
+  lines.push(`**Tasks:** ${dag.nodes.length} | **Gates:** ${dag.gates.length}`);
+  lines.push("");
+  for (const node of dag.nodes) {
+    const depLabel = node.dependencies.length === 0 ? "(root)" : `(after: ${node.dependencies.join(", ")})`;
+    lines.push(`- **${node.name}** \u2192 ${node.profile} [${node.tier}] ${depLabel}`);
+  }
+  for (const gate of dag.gates) {
+    lines.push(`- \u{1F512} **${gate.name}** [${gate.type}]`);
+  }
+  return lines.join("\n");
+}
+
 // src/commands.ts
 init_registry();
 import { StreamableHTTPClientTransport as StreamableHTTPClientTransport2 } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { Client as Client3 } from "@modelcontextprotocol/sdk/client/index.js";
 
 // src/teams.ts
-import fs17 from "fs";
-import path17 from "path";
-import os15 from "os";
+import fs19 from "fs";
+import path19 from "path";
+import os16 from "os";
 import pc4 from "picocolors";
 function getTeamsDir() {
-  return path17.join(os15.homedir(), ".acore", "teams");
+  return path19.join(os16.homedir(), ".acore", "teams");
 }
 function ensureTeamsDir() {
   const dir = getTeamsDir();
-  if (!fs17.existsSync(dir)) fs17.mkdirSync(dir, { recursive: true });
+  if (!fs19.existsSync(dir)) fs19.mkdirSync(dir, { recursive: true });
   return dir;
 }
 function teamPath(name) {
   const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
-  return path17.join(ensureTeamsDir(), `${slug}.json`);
+  return path19.join(ensureTeamsDir(), `${slug}.json`);
 }
 function createTeam(team) {
   const fp = teamPath(team.name);
-  fs17.writeFileSync(fp, JSON.stringify(team, null, 2), "utf-8");
+  fs19.writeFileSync(fp, JSON.stringify(team, null, 2), "utf-8");
 }
 function loadTeam(name) {
   const fp = teamPath(name);
-  if (!fs17.existsSync(fp)) return null;
+  if (!fs19.existsSync(fp)) return null;
   try {
-    return JSON.parse(fs17.readFileSync(fp, "utf-8"));
+    return JSON.parse(fs19.readFileSync(fp, "utf-8"));
   } catch {
     return null;
   }
 }
 function listTeams() {
   const dir = getTeamsDir();
-  if (!fs17.existsSync(dir)) return [];
+  if (!fs19.existsSync(dir)) return [];
   const teams = [];
-  for (const file of fs17.readdirSync(dir)) {
+  for (const file of fs19.readdirSync(dir)) {
     if (!file.endsWith(".json")) continue;
     try {
-      const content = fs17.readFileSync(path17.join(dir, file), "utf-8");
+      const content = fs19.readFileSync(path19.join(dir, file), "utf-8");
       teams.push(JSON.parse(content));
     } catch {
     }
@@ -5304,8 +6189,8 @@ function listTeams() {
 }
 function deleteTeam(name) {
   const fp = teamPath(name);
-  if (!fs17.existsSync(fp)) return false;
-  fs17.unlinkSync(fp);
+  if (!fs19.existsSync(fp)) return false;
+  fs19.unlinkSync(fp);
   return true;
 }
 async function runTeam(team, task, client, mcpManager, tools) {
@@ -5532,23 +6417,23 @@ var BUILT_IN_TEAMS = [
 
 // src/plans.ts
 init_logger();
-import fs18 from "fs";
-import path18 from "path";
-import os16 from "os";
+import fs20 from "fs";
+import path20 from "path";
+import os17 from "os";
 function getPlansDir() {
-  const localDir = path18.join(process.cwd(), ".acore", "plans");
-  const localAcore = path18.join(process.cwd(), ".acore");
-  if (fs18.existsSync(localAcore)) return localDir;
-  return path18.join(os16.homedir(), ".acore", "plans");
+  const localDir = path20.join(process.cwd(), ".acore", "plans");
+  const localAcore = path20.join(process.cwd(), ".acore");
+  if (fs20.existsSync(localAcore)) return localDir;
+  return path20.join(os17.homedir(), ".acore", "plans");
 }
 function ensurePlansDir() {
   const dir = getPlansDir();
-  if (!fs18.existsSync(dir)) fs18.mkdirSync(dir, { recursive: true });
+  if (!fs20.existsSync(dir)) fs20.mkdirSync(dir, { recursive: true });
   return dir;
 }
 function planPath(name) {
   const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
-  return path18.join(ensurePlansDir(), `${slug}.md`);
+  return path20.join(ensurePlansDir(), `${slug}.md`);
 }
 function serializePlan(plan) {
   const lines = [];
@@ -5574,7 +6459,7 @@ function parsePlan(content, filePath) {
     const createdMatch = content.match(/\*\*Created:\*\*\s*(.+)/);
     const updatedMatch = content.match(/\*\*Updated:\*\*\s*(.+)/);
     const activeMatch = content.match(/\*\*Active:\*\*\s*(.+)/);
-    const name = nameMatch?.[1]?.trim() || path18.basename(filePath, ".md");
+    const name = nameMatch?.[1]?.trim() || path20.basename(filePath, ".md");
     const goal = goalMatch?.[1]?.trim() || "";
     const createdAt = createdMatch?.[1]?.trim() || "";
     const updatedAt = updatedMatch?.[1]?.trim() || "";
@@ -5616,22 +6501,22 @@ function createPlan(name, goal, steps) {
 }
 function savePlan(plan) {
   const fp = planPath(plan.name);
-  fs18.writeFileSync(fp, serializePlan(plan), "utf-8");
+  fs20.writeFileSync(fp, serializePlan(plan), "utf-8");
 }
 function loadPlan(name) {
   const fp = planPath(name);
-  if (!fs18.existsSync(fp)) return null;
-  const content = fs18.readFileSync(fp, "utf-8");
+  if (!fs20.existsSync(fp)) return null;
+  const content = fs20.readFileSync(fp, "utf-8");
   return parsePlan(content, fp);
 }
 function listPlans() {
   const dir = getPlansDir();
-  if (!fs18.existsSync(dir)) return [];
+  if (!fs20.existsSync(dir)) return [];
   const plans = [];
-  for (const file of fs18.readdirSync(dir)) {
+  for (const file of fs20.readdirSync(dir)) {
     if (!file.endsWith(".md")) continue;
-    const fp = path18.join(dir, file);
-    const content = fs18.readFileSync(fp, "utf-8");
+    const fp = path20.join(dir, file);
+    const content = fs20.readFileSync(fp, "utf-8");
     const plan = parsePlan(content, fp);
     if (plan) plans.push(plan);
   }
@@ -5726,13 +6611,14 @@ function progressBar(pct) {
 }
 
 // src/commands.ts
+init_github();
 init_user_model();
 
 // src/background.ts
 init_logger();
-import fs19 from "fs";
-import path19 from "path";
-import os17 from "os";
+import fs21 from "fs";
+import path21 from "path";
+import os18 from "os";
 import pc5 from "picocolors";
 var BACKGROUND_ELIGIBLE = /* @__PURE__ */ new Set([
   "run_tests",
@@ -5771,13 +6657,13 @@ var NEVER_BACKGROUND = /* @__PURE__ */ new Set([
   "file_list",
   "avatar_prompt"
 ]);
-var TASK_LOG_DIR = path19.join(os17.homedir(), ".aman-agent");
-var TASK_LOG_FILE = path19.join(TASK_LOG_DIR, "bg-tasks.json");
+var TASK_LOG_DIR = path21.join(os18.homedir(), ".aman-agent");
+var TASK_LOG_FILE = path21.join(TASK_LOG_DIR, "bg-tasks.json");
 var MAX_LOG_ENTRIES = 50;
 function loadTaskLog() {
   try {
-    if (!fs19.existsSync(TASK_LOG_FILE)) return [];
-    const raw = fs19.readFileSync(TASK_LOG_FILE, "utf-8");
+    if (!fs21.existsSync(TASK_LOG_FILE)) return [];
+    const raw = fs21.readFileSync(TASK_LOG_FILE, "utf-8");
     return JSON.parse(raw);
   } catch {
     return [];
@@ -5785,9 +6671,9 @@ function loadTaskLog() {
 }
 function saveTaskLog(entries) {
   try {
-    if (!fs19.existsSync(TASK_LOG_DIR)) fs19.mkdirSync(TASK_LOG_DIR, { recursive: true });
+    if (!fs21.existsSync(TASK_LOG_DIR)) fs21.mkdirSync(TASK_LOG_DIR, { recursive: true });
     const trimmed = entries.slice(-MAX_LOG_ENTRIES);
-    fs19.writeFileSync(TASK_LOG_FILE, JSON.stringify(trimmed, null, 2));
+    fs21.writeFileSync(TASK_LOG_FILE, JSON.stringify(trimmed, null, 2));
   } catch (err) {
     log.debug("background", "Failed to save task log", err);
   }
@@ -5936,10 +6822,10 @@ import {
 } from "@aman_asmuei/arules-core";
 var AGENT_SCOPE = process.env.AMAN_AGENT_SCOPE ?? "dev:agent";
 function readEcosystemFile(filePath, label) {
-  if (!fs20.existsSync(filePath)) {
+  if (!fs22.existsSync(filePath)) {
     return pc6.dim(`No ${label} file found at ${filePath}`);
   }
-  return fs20.readFileSync(filePath, "utf-8").trim();
+  return fs22.readFileSync(filePath, "utf-8").trim();
 }
 function parseCommand(input) {
   const trimmed = input.trim();
@@ -6024,8 +6910,8 @@ async function handleIdentityCommand(action, args, _ctx) {
     }
     if (args.includes("--reset")) {
       const modelPath = defaultModelPath();
-      if (fs20.existsSync(modelPath)) {
-        fs20.unlinkSync(modelPath);
+      if (fs22.existsSync(modelPath)) {
+        fs22.unlinkSync(modelPath);
         return { handled: true, output: pc6.green("User model reset. Starting fresh.") };
       }
       return { handled: true, output: pc6.dim("No user model to reset.") };
@@ -6269,9 +7155,9 @@ ${result.violations.map((v) => `  - ${v}`).join("\n")}`)
   };
 }
 async function handleWorkflowsCommand(action, args, ctx) {
-  const home2 = os18.homedir();
+  const home2 = os19.homedir();
   if (!action) {
-    const content = readEcosystemFile(path20.join(home2, ".aflow", "flow.md"), "workflows (aflow)");
+    const content = readEcosystemFile(path22.join(home2, ".aflow", "flow.md"), "workflows (aflow)");
     return { handled: true, output: content };
   }
   if (action === "add") {
@@ -6293,7 +7179,7 @@ async function handleWorkflowsCommand(action, args, ctx) {
       return { handled: true, output: pc6.yellow("Usage: /workflows get <name>") };
     }
     const name = args.join(" ").toLowerCase();
-    const raw = readEcosystemFile(path20.join(home2, ".aflow", "flow.md"), "workflows (aflow)");
+    const raw = readEcosystemFile(path22.join(home2, ".aflow", "flow.md"), "workflows (aflow)");
     if (raw.startsWith("No ")) {
       return { handled: true, output: raw };
     }
@@ -6352,12 +7238,12 @@ async function handleToolsCommand(action, args, _ctx) {
       return { handled: true, output: pc6.yellow("Usage: /tools search <query...>") };
     }
     const query = args.join(" ").toLowerCase();
-    const home2 = os18.homedir();
-    const toolsFile = path20.join(home2, ".akit", "tools.md");
-    if (!fs20.existsSync(toolsFile)) {
+    const home2 = os19.homedir();
+    const toolsFile = path22.join(home2, ".akit", "tools.md");
+    if (!fs22.existsSync(toolsFile)) {
       return { handled: true, output: pc6.dim(`No tools file found. Use 'npx @aman_asmuei/akit search ${args.join(" ")}' to search the registry.`) };
     }
-    const raw = fs20.readFileSync(toolsFile, "utf-8").trim();
+    const raw = fs22.readFileSync(toolsFile, "utf-8").trim();
     const lines = raw.split("\n");
     const matches = lines.filter((l) => l.toLowerCase().includes(query));
     if (matches.length === 0) {
@@ -6368,9 +7254,9 @@ async function handleToolsCommand(action, args, _ctx) {
   return handleAkitCommand(action, args);
 }
 async function handleSkillsCommand(action, args, ctx) {
-  const home2 = os18.homedir();
+  const home2 = os19.homedir();
   if (!action) {
-    const content = readEcosystemFile(path20.join(home2, ".askill", "skills.md"), "skills (askill)");
+    const content = readEcosystemFile(path22.join(home2, ".askill", "skills.md"), "skills (askill)");
     return { handled: true, output: content };
   }
   if (action === "install") {
@@ -6392,8 +7278,8 @@ async function handleSkillsCommand(action, args, ctx) {
       return { handled: true, output: pc6.yellow("Usage: /skills search <query...>") };
     }
     const query = args.join(" ").toLowerCase();
-    const home3 = os18.homedir();
-    const raw = readEcosystemFile(path20.join(home3, ".askill", "skills.md"), "skills (askill)");
+    const home3 = os19.homedir();
+    const raw = readEcosystemFile(path22.join(home3, ".askill", "skills.md"), "skills (askill)");
     if (raw.startsWith("No ")) {
       return { handled: true, output: raw };
     }
@@ -6407,23 +7293,23 @@ async function handleSkillsCommand(action, args, ctx) {
   if (action === "list") {
     const autoOnly = args.includes("--auto");
     if (autoOnly) {
-      const logPath = path20.join(os18.homedir(), ".aman-agent", "crystallization-log.json");
+      const logPath = path22.join(os19.homedir(), ".aman-agent", "crystallization-log.json");
       try {
-        const content2 = fs20.readFileSync(logPath, "utf-8");
+        const content2 = fs22.readFileSync(logPath, "utf-8");
         const entries = JSON.parse(content2);
         if (entries.length === 0) {
           return { handled: true, output: pc6.dim("No crystallized skills yet.") };
         }
-        const suggestionsPath = path20.join(os18.homedir(), ".aman-agent", "crystallization-suggestions.json");
+        const suggestionsPath = path22.join(os19.homedir(), ".aman-agent", "crystallization-suggestions.json");
         let sugCounts = {};
         try {
-          const sc = fs20.readFileSync(suggestionsPath, "utf-8");
+          const sc = fs22.readFileSync(suggestionsPath, "utf-8");
           sugCounts = JSON.parse(sc);
         } catch {
         }
         let versionCounts = {};
         try {
-          const skillsContent = fs20.readFileSync(path20.join(os18.homedir(), ".askill", "skills.md"), "utf-8");
+          const skillsContent = fs22.readFileSync(path22.join(os19.homedir(), ".askill", "skills.md"), "utf-8");
           const versionRe = /^# (.+)\.v(\d+)$/gm;
           let vMatch;
           while ((vMatch = versionRe.exec(skillsContent)) !== null) {
@@ -6448,13 +7334,13 @@ async function handleSkillsCommand(action, args, ctx) {
         return { handled: true, output: pc6.dim("No crystallized skills yet.") };
       }
     }
-    const content = readEcosystemFile(path20.join(home2, ".askill", "skills.md"), "skills (askill)");
+    const content = readEcosystemFile(path22.join(home2, ".askill", "skills.md"), "skills (askill)");
     return { handled: true, output: content };
   }
   if (action === "crystallize") {
-    const pmDir = path20.join(os18.homedir(), ".acore", "postmortems");
+    const pmDir = path22.join(os19.homedir(), ".acore", "postmortems");
     try {
-      const files = fs20.readdirSync(pmDir);
+      const files = fs22.readdirSync(pmDir);
       const jsonFiles = files.filter((f) => f.endsWith(".json")).sort().reverse();
       if (jsonFiles.length === 0) {
         return {
@@ -6463,7 +7349,7 @@ async function handleSkillsCommand(action, args, ctx) {
         };
       }
       const latest = jsonFiles[0];
-      const content = fs20.readFileSync(path20.join(pmDir, latest), "utf-8");
+      const content = fs22.readFileSync(path22.join(pmDir, latest), "utf-8");
       const report = JSON.parse(content);
       if (!report.crystallizationCandidates || report.crystallizationCandidates.length === 0) {
         return {
@@ -6471,8 +7357,8 @@ async function handleSkillsCommand(action, args, ctx) {
           output: pc6.dim(`No crystallization candidates in the most recent post-mortem (${latest}). Run a longer session or wait for the next auto-postmortem.`)
         };
       }
-      const skillsMdPath = path20.join(os18.homedir(), ".askill", "skills.md");
-      const logPath = path20.join(os18.homedir(), ".aman-agent", "crystallization-log.json");
+      const skillsMdPath = path22.join(os19.homedir(), ".askill", "skills.md");
+      const logPath = path22.join(os19.homedir(), ".aman-agent", "crystallization-log.json");
       const postmortemFilename = latest.replace(/\.json$/, ".md");
       const lines = [
         pc6.bold(`Found ${report.crystallizationCandidates.length} candidate(s) in ${latest}:`)
@@ -6529,9 +7415,9 @@ async function handleSkillsCommand(action, args, ctx) {
   return { handled: true, output: pc6.yellow(`Unknown action: /skills ${action}. Try /skills --help`) };
 }
 async function handleEvalCommand(action, args, ctx) {
-  const home2 = os18.homedir();
+  const home2 = os19.homedir();
   if (!action) {
-    const content = readEcosystemFile(path20.join(home2, ".aeval", "eval.md"), "evaluation (aeval)");
+    const content = readEcosystemFile(path22.join(home2, ".aeval", "eval.md"), "evaluation (aeval)");
     return { handled: true, output: content };
   }
   if (action === "milestone") {
@@ -6543,10 +7429,10 @@ async function handleEvalCommand(action, args, ctx) {
     return { handled: true, output };
   }
   if (action === "report") {
-    const evalFile = path20.join(home2, ".aeval", "eval.md");
+    const evalFile = path22.join(home2, ".aeval", "eval.md");
     const lines = [pc6.bold("\u{1F4CA} Eval Report")];
-    if (fs20.existsSync(evalFile)) {
-      lines.push("", fs20.readFileSync(evalFile, "utf-8").trim());
+    if (fs22.existsSync(evalFile)) {
+      lines.push("", fs22.readFileSync(evalFile, "utf-8").trim());
     } else {
       lines.push("", pc6.dim("No eval log yet. Use /eval milestone <text> to start."));
     }
@@ -7104,10 +7990,10 @@ function handleSave() {
 }
 function handleReset(action) {
   const dirs = {
-    config: path20.join(os18.homedir(), ".aman-agent"),
-    memory: path20.join(os18.homedir(), ".amem"),
-    identity: path20.join(os18.homedir(), ".acore"),
-    rules: path20.join(os18.homedir(), ".arules")
+    config: path22.join(os19.homedir(), ".aman-agent"),
+    memory: path22.join(os19.homedir(), ".amem"),
+    identity: path22.join(os19.homedir(), ".acore"),
+    rules: path22.join(os19.homedir(), ".arules")
   };
   if (action === "help" || !action) {
     return {
@@ -7132,15 +8018,15 @@ function handleReset(action) {
   const removed = [];
   for (const target of targets) {
     const dir = dirs[target];
-    if (fs20.existsSync(dir)) {
-      fs20.rmSync(dir, { recursive: true, force: true });
+    if (fs22.existsSync(dir)) {
+      fs22.rmSync(dir, { recursive: true, force: true });
       removed.push(target);
     }
   }
   if (targets.includes("config")) {
     const configDir2 = dirs.config;
-    fs20.mkdirSync(configDir2, { recursive: true });
-    fs20.writeFileSync(path20.join(configDir2, ".reconfig"), "", "utf-8");
+    fs22.mkdirSync(configDir2, { recursive: true });
+    fs22.writeFileSync(path22.join(configDir2, ".reconfig"), "", "utf-8");
   }
   if (removed.length === 0) {
     return { handled: true, output: pc6.dim("Nothing to reset \u2014 directories don't exist.") };
@@ -7157,11 +8043,11 @@ function handleReset(action) {
 function handleUpdate() {
   try {
     const current = execFileSync3("npm", ["view", "@aman_asmuei/aman-agent", "version"], { encoding: "utf-8" }).trim();
-    const local = true ? "0.34.0" : "unknown";
+    const local = true ? "0.40.0" : "unknown";
     if (current === local) {
       return { handled: true, output: `${pc6.green("Up to date")} \u2014 v${local}` };
     }
-    const isVendored = process.execPath.includes(path20.join(".aman-agent", "node"));
+    const isVendored = process.execPath.includes(path22.join(".aman-agent", "node"));
     const updateCmd = isVendored ? "aman-agent update" : "npm install -g @aman_asmuei/aman-agent@latest";
     return {
       handled: true,
@@ -7197,11 +8083,11 @@ function handleExportCommand() {
   return { handled: true, exportConversation: true };
 }
 function handleDebugCommand() {
-  const logPath = path20.join(os18.homedir(), ".aman-agent", "debug.log");
-  if (!fs20.existsSync(logPath)) {
+  const logPath = path22.join(os19.homedir(), ".aman-agent", "debug.log");
+  if (!fs22.existsSync(logPath)) {
     return { handled: true, output: pc6.dim("No debug log found.") };
   }
-  const content = fs20.readFileSync(logPath, "utf-8");
+  const content = fs22.readFileSync(logPath, "utf-8");
   const lines = content.trim().split("\n");
   const last20 = lines.slice(-20).join("\n");
   return { handled: true, output: pc6.bold("Debug Log (last 20 entries):\n") + pc6.dim(last20) };
@@ -7481,7 +8367,7 @@ ${text3}` };
   };
 }
 function handleProfileCommand(action, args) {
-  const profilesDir = path20.join(os18.homedir(), ".acore", "profiles");
+  const profilesDir = path22.join(os19.homedir(), ".acore", "profiles");
   if (action === "me") {
     const user = loadUserIdentity();
     if (!user) {
@@ -7549,8 +8435,8 @@ ${pc6.dim("Edit with: /profile edit")}` };
         };
       }
       const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
-      const profileDir = path20.join(profilesDir, slug);
-      if (fs20.existsSync(profileDir)) {
+      const profileDir = path22.join(profilesDir, slug);
+      if (fs22.existsSync(profileDir)) {
         return { handled: true, output: pc6.yellow(`Profile already exists: ${slug}`) };
       }
       const builtIn = BUILT_IN_PROFILES.find((t) => t.name === slug);
@@ -7566,16 +8452,16 @@ ${pc6.dim("Edit with: /profile edit")}` };
   Use: aman-agent --profile ${slug}`
         };
       }
-      fs20.mkdirSync(profileDir, { recursive: true });
-      const globalCore = path20.join(os18.homedir(), ".acore", "core.md");
-      if (fs20.existsSync(globalCore)) {
-        let content = fs20.readFileSync(globalCore, "utf-8");
+      fs22.mkdirSync(profileDir, { recursive: true });
+      const globalCore = path22.join(os19.homedir(), ".acore", "core.md");
+      if (fs22.existsSync(globalCore)) {
+        let content = fs22.readFileSync(globalCore, "utf-8");
         const aiName = name.charAt(0).toUpperCase() + name.slice(1);
         content = content.replace(/^# .+$/m, `# ${aiName}`);
-        fs20.writeFileSync(path20.join(profileDir, "core.md"), content, "utf-8");
+        fs22.writeFileSync(path22.join(profileDir, "core.md"), content, "utf-8");
       } else {
         const aiName = name.charAt(0).toUpperCase() + name.slice(1);
-        fs20.writeFileSync(path20.join(profileDir, "core.md"), `# ${aiName}
+        fs22.writeFileSync(path22.join(profileDir, "core.md"), `# ${aiName}
 
 ## Identity
 - Role: ${aiName} is your AI companion
@@ -7588,7 +8474,7 @@ ${pc6.dim("Edit with: /profile edit")}` };
       return {
         handled: true,
         output: pc6.green(`Profile created: ${slug}`) + `
-  Edit: ${path20.join(profileDir, "core.md")}
+  Edit: ${path22.join(profileDir, "core.md")}
   Use: aman-agent --profile ${slug}
 
   ${pc6.dim("Add rules.md or skills.md for profile-specific overrides.")}`
@@ -7597,9 +8483,9 @@ ${pc6.dim("Edit with: /profile edit")}` };
     case "show": {
       const name = args[0];
       if (!name) return { handled: true, output: pc6.yellow("Usage: /profile show <name>") };
-      const profileDir = path20.join(profilesDir, name);
-      if (!fs20.existsSync(profileDir)) return { handled: true, output: pc6.red(`Profile not found: ${name}`) };
-      const files = fs20.readdirSync(profileDir).filter((f) => f.endsWith(".md"));
+      const profileDir = path22.join(profilesDir, name);
+      if (!fs22.existsSync(profileDir)) return { handled: true, output: pc6.red(`Profile not found: ${name}`) };
+      const files = fs22.readdirSync(profileDir).filter((f) => f.endsWith(".md"));
       const lines = files.map((f) => `  ${f}`);
       return { handled: true, output: `Profile: ${pc6.bold(name)}
 Files:
@@ -7608,9 +8494,9 @@ ${lines.join("\n")}` };
     case "delete": {
       const name = args[0];
       if (!name) return { handled: true, output: pc6.yellow("Usage: /profile delete <name>") };
-      const profileDir = path20.join(profilesDir, name);
-      if (!fs20.existsSync(profileDir)) return { handled: true, output: pc6.red(`Profile not found: ${name}`) };
-      fs20.rmSync(profileDir, { recursive: true });
+      const profileDir = path22.join(profilesDir, name);
+      if (!fs22.existsSync(profileDir)) return { handled: true, output: pc6.red(`Profile not found: ${name}`) };
+      fs22.rmSync(profileDir, { recursive: true });
       return { handled: true, output: pc6.dim(`Profile deleted: ${name}`) };
     }
     case "help":
@@ -7828,10 +8714,10 @@ function handleShowcaseCommand(action, args) {
   Or place it as a sibling directory to aman-agent.`
     };
   }
-  const corePath = path20.join(os18.homedir(), ".acore", "core.md");
+  const corePath = path22.join(os19.homedir(), ".acore", "core.md");
   let currentShowcase = null;
-  if (fs20.existsSync(corePath)) {
-    const content = fs20.readFileSync(corePath, "utf-8");
+  if (fs22.existsSync(corePath)) {
+    const content = fs22.readFileSync(corePath, "utf-8");
     const nameMatch = content.match(/^# (.+)/m);
     if (nameMatch) {
       const coreName = nameMatch[1].trim().toLowerCase();
@@ -7972,6 +8858,121 @@ async function handleFileCommand(action, args) {
   }
   return { handled: true, output: pc6.yellow(`Unknown /file subcommand: ${action}. Try /file for help.`) };
 }
+async function handleOrchestrateCommand(action, args, ctx) {
+  if (!action) {
+    return {
+      handled: true,
+      output: `Usage: /orchestrate <requirement>
+
+Decomposes a requirement into a task DAG and executes it with parallel agents.
+
+Alias: /orch`
+    };
+  }
+  const requirement = [action, ...args].join(" ");
+  if (!ctx.llmClient) {
+    return { handled: true, output: pc6.red("Orchestration requires an LLM client. Not available.") };
+  }
+  try {
+    const dag = await decomposeRequirement(requirement, ctx.llmClient);
+    const display = formatDAGForDisplay(dag);
+    return { handled: true, output: display };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { handled: true, output: pc6.red(`Orchestration failed: ${msg}`) };
+  }
+}
+async function handleGitHubCommand(action, args, ctx) {
+  if (!action) {
+    const available = await ghAvailable();
+    if (!available) {
+      return { handled: true, output: pc6.red("GitHub CLI (gh) is not available or not authenticated. Run: gh auth login") };
+    }
+    const repo = await ghCurrentRepo();
+    if (!repo) {
+      return { handled: true, output: pc6.yellow("Not inside a GitHub repository.") };
+    }
+    return { handled: true, output: `GitHub repo: ${pc6.bold(`${repo.owner}/${repo.name}`)}` };
+  }
+  switch (action) {
+    case "issues": {
+      const { gh: ghExec } = await Promise.resolve().then(() => (init_github(), github_exports));
+      const repoArgs = args.length > 0 ? ["--repo", args[0]] : [];
+      const result = await ghExec(["issue", "list", "--limit", "10", ...repoArgs]);
+      if (!result.success) {
+        return { handled: true, output: pc6.red(`Failed to list issues: ${result.stderr}`) };
+      }
+      return { handled: true, output: result.stdout.trim() || pc6.dim("No open issues.") };
+    }
+    case "prs": {
+      const repoArgs = args.length > 0 ? { repo: args[0] } : {};
+      try {
+        const prs = await listPRs({ state: "open", limit: 10, ...repoArgs });
+        if (prs.length === 0) {
+          return { handled: true, output: pc6.dim("No open PRs.") };
+        }
+        const lines = prs.map(
+          (pr) => `#${pr.number} ${pr.title} (${pr.headRefName} \u2192 ${pr.baseRefName})${pr.isDraft ? " [draft]" : ""}`
+        );
+        return { handled: true, output: lines.join("\n") };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { handled: true, output: pc6.red(`Failed to list PRs: ${msg}`) };
+      }
+    }
+    case "plan": {
+      const issueNum = parseInt(args[0], 10);
+      if (!issueNum || isNaN(issueNum)) {
+        return { handled: true, output: pc6.red("Usage: /github plan <issue-number>") };
+      }
+      if (!ctx.llmClient) {
+        return { handled: true, output: pc6.red("Planning requires an LLM client. Not available.") };
+      }
+      try {
+        const issue = await fetchIssue(issueNum);
+        const requirement = formatIssueAsRequirement(issue);
+        const dag = await decomposeRequirement(requirement, ctx.llmClient);
+        const display = formatDAGForDisplay(dag);
+        return { handled: true, output: `${pc6.bold(`Plan for #${issue.number}: ${issue.title}`)}
+
+${display}` };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { handled: true, output: pc6.red(`Failed to plan issue #${issueNum}: ${msg}`) };
+      }
+    }
+    case "ci": {
+      const branch = args[0];
+      if (!branch) {
+        return { handled: true, output: pc6.red("Usage: /github ci <branch>") };
+      }
+      try {
+        const passing = await isCIPassing(branch);
+        return {
+          handled: true,
+          output: passing ? pc6.green(`CI is passing on ${branch}`) : pc6.yellow(`CI is NOT passing on ${branch}`)
+        };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { handled: true, output: pc6.red(`Failed to check CI: ${msg}`) };
+      }
+    }
+    default:
+      return {
+        handled: true,
+        output: [
+          `Usage: /github [subcommand]`,
+          ``,
+          `Subcommands:`,
+          `  (none)           Show current repo info`,
+          `  issues [repo]    List open issues`,
+          `  prs [repo]       List open PRs`,
+          `  plan <number>    Plan from a GitHub issue`,
+          `  ci <branch>      Check CI status for a branch`
+        ].join("\n")
+      };
+  }
+}
 var KNOWN_COMMANDS = /* @__PURE__ */ new Set([
   "quit",
   "exit",
@@ -8005,7 +9006,10 @@ var KNOWN_COMMANDS = /* @__PURE__ */ new Set([
   "showcase",
   "file",
   "observe",
-  "postmortem"
+  "postmortem",
+  "orchestrate",
+  "orch",
+  "github"
 ]);
 async function handleObserveCommand(action, ctx) {
   if (!ctx.observationSession) {
@@ -8142,6 +9146,11 @@ async function handleCommand(input, ctx) {
       return handleObserveCommand(action, ctx);
     case "postmortem":
       return handlePostmortemCommand(action, args, ctx);
+    case "orchestrate":
+    case "orch":
+      return handleOrchestrateCommand(action, args, ctx);
+    case "github":
+      return handleGitHubCommand(action, args, ctx);
     default:
       return { handled: false };
   }
@@ -8229,10 +9238,10 @@ init_logger();
 
 // src/skill-engine.ts
 init_logger();
-import fs21 from "fs";
+import fs23 from "fs";
 import fsp from "fs/promises";
-import path21 from "path";
-import os19 from "os";
+import path23 from "path";
+import os20 from "os";
 var SKILL_TRIGGERS = {
   testing: ["test", "spec", "coverage", "tdd", "jest", "vitest", "mocha", "assert", "mock", "stub", "fixture", "e2e", "integration test", "unit test"],
   "api-design": ["api", "endpoint", "rest", "graphql", "route", "controller", "middleware", "http", "request", "response", "status code", "pagination"],
@@ -8261,20 +9270,20 @@ async function loadRuntimeTriggers(skillsMdPath) {
     return /* @__PURE__ */ new Map();
   }
 }
-var LEVEL_FILE = path21.join(os19.homedir(), ".aman-agent", "skill-levels.json");
+var LEVEL_FILE = path23.join(os20.homedir(), ".aman-agent", "skill-levels.json");
 function loadSkillLevels() {
   try {
-    if (fs21.existsSync(LEVEL_FILE)) {
-      return JSON.parse(fs21.readFileSync(LEVEL_FILE, "utf-8"));
+    if (fs23.existsSync(LEVEL_FILE)) {
+      return JSON.parse(fs23.readFileSync(LEVEL_FILE, "utf-8"));
     }
   } catch {
   }
   return {};
 }
 function saveSkillLevels(levels) {
-  const dir = path21.dirname(LEVEL_FILE);
-  if (!fs21.existsSync(dir)) fs21.mkdirSync(dir, { recursive: true });
-  fs21.writeFileSync(LEVEL_FILE, JSON.stringify(levels, null, 2), "utf-8");
+  const dir = path23.dirname(LEVEL_FILE);
+  if (!fs23.existsSync(dir)) fs23.mkdirSync(dir, { recursive: true });
+  fs23.writeFileSync(LEVEL_FILE, JSON.stringify(levels, null, 2), "utf-8");
 }
 function computeLevel(activations) {
   if (activations >= 50) return { level: 5, label: "Expert" };
@@ -8501,7 +9510,7 @@ async function autoTriggerSkills(userInput, mcpManager) {
     const result = await mcpManager.callTool("skill_list", {});
     const skills = JSON.parse(result);
     const installed = skills.filter((s) => s.installed).map((s) => s.name);
-    const skillsMdPath = path21.join(os19.homedir(), ".askill", "skills.md");
+    const skillsMdPath = path23.join(os20.homedir(), ".askill", "skills.md");
     const runtimeTriggers = await loadRuntimeTriggers(skillsMdPath);
     if (installed.length === 0 && runtimeTriggers.size === 0) return "";
     const matched = matchSkillsSemantic(userInput, installed, runtimeTriggers);
@@ -8958,9 +9967,9 @@ function humanizeError(message) {
 }
 
 // src/hints.ts
-import fs22 from "fs";
-import path22 from "path";
-import os20 from "os";
+import fs24 from "fs";
+import path24 from "path";
+import os21 from "os";
 var HINTS = [
   {
     id: "eval",
@@ -8998,11 +10007,11 @@ function getHint(state, ctx) {
   }
   return null;
 }
-var HINTS_FILE = path22.join(os20.homedir(), ".aman-agent", "hints-seen.json");
+var HINTS_FILE = path24.join(os21.homedir(), ".aman-agent", "hints-seen.json");
 function loadShownHints() {
   try {
-    if (fs22.existsSync(HINTS_FILE)) {
-      const data = JSON.parse(fs22.readFileSync(HINTS_FILE, "utf-8"));
+    if (fs24.existsSync(HINTS_FILE)) {
+      const data = JSON.parse(fs24.readFileSync(HINTS_FILE, "utf-8"));
       return new Set(Array.isArray(data) ? data : []);
     }
   } catch {
@@ -9011,9 +10020,9 @@ function loadShownHints() {
 }
 function saveShownHints(shown) {
   try {
-    const dir = path22.dirname(HINTS_FILE);
-    fs22.mkdirSync(dir, { recursive: true });
-    fs22.writeFileSync(HINTS_FILE, JSON.stringify([...shown]), "utf-8");
+    const dir = path24.dirname(HINTS_FILE);
+    fs24.mkdirSync(dir, { recursive: true });
+    fs24.writeFileSync(HINTS_FILE, JSON.stringify([...shown]), "utf-8");
   } catch {
   }
 }
@@ -9280,9 +10289,9 @@ ${task.result}`
       }
       if (cmdResult.exportConversation) {
         try {
-          const exportDir = path23.join(os21.homedir(), ".aman-agent", "exports");
-          fs23.mkdirSync(exportDir, { recursive: true });
-          const exportPath = path23.join(exportDir, `${sessionId}.md`);
+          const exportDir = path25.join(os22.homedir(), ".aman-agent", "exports");
+          fs25.mkdirSync(exportDir, { recursive: true });
+          const exportPath = path25.join(exportDir, `${sessionId}.md`);
           const lines = [
             `# Conversation \u2014 ${(/* @__PURE__ */ new Date()).toLocaleString()}`,
             `**Model:** ${model}`,
@@ -9296,7 +10305,7 @@ ${task.result}`
               lines.push(`${label} ${msg.content}`, "");
             }
           }
-          fs23.writeFileSync(exportPath, lines.join("\n"), "utf-8");
+          fs25.writeFileSync(exportPath, lines.join("\n"), "utf-8");
           console.log(pc7.green(`Exported to ${exportPath}`));
         } catch {
           console.log(pc7.red("Failed to export conversation."));
@@ -9422,25 +10431,25 @@ ${knowledgeItem.content}
     for (const match of filePathMatches) {
       let filePath = match[1];
       if (filePath.startsWith("~/")) {
-        filePath = path23.join(os21.homedir(), filePath.slice(2));
+        filePath = path25.join(os22.homedir(), filePath.slice(2));
       }
-      if (!fs23.existsSync(filePath) || !fs23.statSync(filePath).isFile()) continue;
-      const ext = path23.extname(filePath).toLowerCase();
+      if (!fs25.existsSync(filePath) || !fs25.statSync(filePath).isFile()) continue;
+      const ext = path25.extname(filePath).toLowerCase();
       if (imageExts.has(ext)) {
         try {
-          const stat = fs23.statSync(filePath);
+          const stat = fs25.statSync(filePath);
           if (stat.size > maxImageBytes) {
-            process.stdout.write(pc7.yellow(`  [skipped: ${path23.basename(filePath)} \u2014 exceeds 20MB limit]
+            process.stdout.write(pc7.yellow(`  [skipped: ${path25.basename(filePath)} \u2014 exceeds 20MB limit]
 `));
             continue;
           }
-          const data = fs23.readFileSync(filePath).toString("base64");
+          const data = fs25.readFileSync(filePath).toString("base64");
           const mediaType = mimeMap[ext] || "image/png";
           imageBlocks.push({
             type: "image",
             source: { type: "base64", media_type: mediaType, data }
           });
-          process.stdout.write(pc7.dim(`  [attached image: ${path23.basename(filePath)} (${(stat.size / 1024).toFixed(1)}KB)]
+          process.stdout.write(pc7.dim(`  [attached image: ${path25.basename(filePath)} (${(stat.size / 1024).toFixed(1)}KB)]
 `));
         } catch {
           process.stdout.write(pc7.dim(`  [could not read image: ${filePath}]
@@ -9448,7 +10457,7 @@ ${knowledgeItem.content}
         }
       } else if (textExts.has(ext) || ext === "") {
         try {
-          const content = fs23.readFileSync(filePath, "utf-8");
+          const content = fs25.readFileSync(filePath, "utf-8");
           const maxChars = 5e4;
           const trimmed = content.length > maxChars ? content.slice(0, maxChars) + `
 
@@ -9458,7 +10467,7 @@ ${knowledgeItem.content}
 <file path="${filePath}" size="${content.length} chars">
 ${trimmed}
 </file>`;
-          process.stdout.write(pc7.dim(`  [attached: ${path23.basename(filePath)} (${(content.length / 1024).toFixed(1)}KB)]
+          process.stdout.write(pc7.dim(`  [attached: ${path25.basename(filePath)} (${(content.length / 1024).toFixed(1)}KB)]
 `));
         } catch {
           process.stdout.write(pc7.dim(`  [could not read: ${filePath}]
@@ -9467,7 +10476,7 @@ ${trimmed}
       } else if (docExts.has(ext)) {
         if (mcpManager) {
           try {
-            process.stdout.write(pc7.dim(`  [converting: ${path23.basename(filePath)}...]
+            process.stdout.write(pc7.dim(`  [converting: ${path25.basename(filePath)}...]
 `));
             const converted = await mcpManager.callTool("doc_convert", { path: filePath });
             if (converted && !converted.startsWith("Error") && !converted.includes("Could not convert")) {
@@ -9476,7 +10485,7 @@ ${trimmed}
 <file path="${filePath}" format="${ext}">
 ${converted.slice(0, 5e4)}
 </file>`;
-              process.stdout.write(pc7.dim(`  [attached: ${path23.basename(filePath)} (converted from ${ext})]
+              process.stdout.write(pc7.dim(`  [attached: ${path25.basename(filePath)} (converted from ${ext})]
 `));
             } else {
               textContent += `
@@ -9488,7 +10497,7 @@ ${converted}
 `));
             }
           } catch {
-            process.stdout.write(pc7.dim(`  [could not convert: ${path23.basename(filePath)}]
+            process.stdout.write(pc7.dim(`  [could not convert: ${path25.basename(filePath)}]
 `));
           }
         } else {
@@ -9880,7 +10889,7 @@ ${result2.response}` : `[${input2.profile}] failed: ${result2.error}`;
       }
       if (hooksConfig?.featureHints) {
         hintState.turnCount++;
-        const hasWorkflows = fs23.existsSync(path23.join(os21.homedir(), ".aflow", "flow.md"));
+        const hasWorkflows = fs25.existsSync(path25.join(os22.homedir(), ".aflow", "flow.md"));
         const memoryCount = memoryTokens > 0 ? Math.floor(memoryTokens / 5) : 0;
         const hint = getHint(hintState, { hasWorkflows, memoryCount });
         if (hint) {
@@ -9926,8 +10935,8 @@ async function saveConversationToMemory(messages, sessionId) {
 }
 
 // src/index.ts
-import fs28 from "fs";
-import path28 from "path";
+import fs29 from "fs";
+import path29 from "path";
 
 // src/presets.ts
 var PRESETS = {
@@ -10040,7 +11049,7 @@ import * as p3 from "@clack/prompts";
 
 // src/server/index.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z } from "zod";
+import { z as z3 } from "zod";
 
 // src/server/transport.ts
 import http from "http";
@@ -10141,7 +11150,7 @@ var Inbox = class {
 // package.json
 var package_default = {
   name: "@aman_asmuei/aman-agent",
-  version: "0.34.0",
+  version: "0.40.0",
   description: "Your AI companion, running locally \u2014 powered by the aman ecosystem",
   type: "module",
   engines: {
@@ -10307,8 +11316,8 @@ async function startAgentServer(opts) {
     {
       description: "Delegate a task to this agent. Returns the agent's final response text.",
       inputSchema: {
-        task: z.string().describe("The task to run against this agent's profile"),
-        context: z.string().optional().describe("Optional extra context")
+        task: z3.string().describe("The task to run against this agent's profile"),
+        context: z3.string().optional().describe("Optional extra context")
       }
     },
     async (input) => {
@@ -10321,9 +11330,9 @@ async function startAgentServer(opts) {
     {
       description: "Deliver a one-way message into this agent's inbox. Drained at next user turn.",
       inputSchema: {
-        from: z.string().optional(),
-        topic: z.string().optional(),
-        body: z.string()
+        from: z3.string().optional(),
+        topic: z3.string().optional(),
+        body: z3.string()
       }
     },
     async (input) => {
@@ -10434,9 +11443,9 @@ async function runServe(opts) {
 
 // src/index.ts
 async function autoDetectConfig() {
-  const reconfigMarker = path28.join(homeDir(), ".reconfig");
-  if (fs28.existsSync(reconfigMarker)) {
-    fs28.unlinkSync(reconfigMarker);
+  const reconfigMarker = path29.join(homeDir(), ".reconfig");
+  if (fs29.existsSync(reconfigMarker)) {
+    fs29.unlinkSync(reconfigMarker);
     return null;
   }
   const anthropicKey = process.env.ANTHROPIC_API_KEY;
@@ -10465,10 +11474,10 @@ async function autoDetectConfig() {
   return null;
 }
 function bootstrapEcosystem() {
-  const corePath = path28.join(identityDir(), "core.md");
-  if (fs28.existsSync(corePath)) return false;
-  fs28.mkdirSync(identityDir(), { recursive: true });
-  fs28.writeFileSync(corePath, [
+  const corePath = path29.join(identityDir(), "core.md");
+  if (fs29.existsSync(corePath)) return false;
+  fs29.mkdirSync(identityDir(), { recursive: true });
+  fs29.writeFileSync(corePath, [
     "# Aman",
     "",
     "## Personality",
@@ -10480,10 +11489,10 @@ function bootstrapEcosystem() {
     "## Session",
     "_New companion \u2014 no prior sessions._"
   ].join("\n"), "utf-8");
-  const rulesPath = path28.join(rulesDir(), "rules.md");
-  if (!fs28.existsSync(rulesPath)) {
-    fs28.mkdirSync(rulesDir(), { recursive: true });
-    fs28.writeFileSync(rulesPath, [
+  const rulesPath = path29.join(rulesDir(), "rules.md");
+  if (!fs29.existsSync(rulesPath)) {
+    fs29.mkdirSync(rulesDir(), { recursive: true });
+    fs29.writeFileSync(rulesPath, [
       "# Guardrails",
       "",
       "## safety",
@@ -10495,20 +11504,20 @@ function bootstrapEcosystem() {
       "- Respect the user's preferences stored in memory"
     ].join("\n"), "utf-8");
   }
-  const flowPath = path28.join(workflowsDir(), "flow.md");
-  if (!fs28.existsSync(flowPath)) {
-    fs28.mkdirSync(workflowsDir(), { recursive: true });
-    fs28.writeFileSync(flowPath, "# Workflows\n\n_No workflows defined yet. Use /workflows add to create one._\n", "utf-8");
+  const flowPath = path29.join(workflowsDir(), "flow.md");
+  if (!fs29.existsSync(flowPath)) {
+    fs29.mkdirSync(workflowsDir(), { recursive: true });
+    fs29.writeFileSync(flowPath, "# Workflows\n\n_No workflows defined yet. Use /workflows add to create one._\n", "utf-8");
   }
-  const skillPath = path28.join(skillsDir(), "skills.md");
-  if (!fs28.existsSync(skillPath)) {
-    fs28.mkdirSync(skillsDir(), { recursive: true });
-    fs28.writeFileSync(skillPath, "# Skills\n\n_No skills installed yet. Use /skills install to add domain expertise._\n", "utf-8");
+  const skillPath = path29.join(skillsDir(), "skills.md");
+  if (!fs29.existsSync(skillPath)) {
+    fs29.mkdirSync(skillsDir(), { recursive: true });
+    fs29.writeFileSync(skillPath, "# Skills\n\n_No skills installed yet. Use /skills install to add domain expertise._\n", "utf-8");
   }
   return true;
 }
 var program = new Command();
-program.name("aman-agent").description("Your AI companion, running locally").version("0.34.0").option("--model <model>", "Override LLM model").option("--budget <tokens>", "Token budget for system prompt (default: 8000)", parseInt).option("--profile <name>", "Use a specific agent profile (e.g., coder, writer, researcher)").action(async (options) => {
+program.name("aman-agent").description("Your AI companion, running locally").version("0.40.0").option("--model <model>", "Override LLM model").option("--budget <tokens>", "Token budget for system prompt (default: 8000)", parseInt).option("--profile <name>", "Use a specific agent profile (e.g., coder, writer, researcher)").action(async (options) => {
   p4.intro(pc9.bold("aman agent") + pc9.dim(" \u2014 your AI companion"));
   let config = loadConfig();
   if (!config) {
@@ -10863,18 +11872,18 @@ program.command("init").description("Set up your AI companion with a guided wiza
   });
   if (p4.isCancel(preset)) process.exit(0);
   const result = applyPreset(preset, name || "Aman");
-  fs28.mkdirSync(identityDir(), { recursive: true });
-  fs28.writeFileSync(path28.join(identityDir(), "core.md"), result.coreMd, "utf-8");
+  fs29.mkdirSync(identityDir(), { recursive: true });
+  fs29.writeFileSync(path29.join(identityDir(), "core.md"), result.coreMd, "utf-8");
   p4.log.success(`Identity created \u2014 ${PRESETS[preset].identity.personality.split(".")[0].toLowerCase()}`);
   if (result.rulesMd) {
-    fs28.mkdirSync(rulesDir(), { recursive: true });
-    fs28.writeFileSync(path28.join(rulesDir(), "rules.md"), result.rulesMd, "utf-8");
+    fs29.mkdirSync(rulesDir(), { recursive: true });
+    fs29.writeFileSync(path29.join(rulesDir(), "rules.md"), result.rulesMd, "utf-8");
     const ruleCount = (result.rulesMd.match(/^- /gm) || []).length;
     p4.log.success(`${ruleCount} rules set`);
   }
   if (result.flowMd) {
-    fs28.mkdirSync(workflowsDir(), { recursive: true });
-    fs28.writeFileSync(path28.join(workflowsDir(), "flow.md"), result.flowMd, "utf-8");
+    fs29.mkdirSync(workflowsDir(), { recursive: true });
+    fs29.writeFileSync(path29.join(workflowsDir(), "flow.md"), result.flowMd, "utf-8");
     const wfCount = (result.flowMd.match(/^## /gm) || []).length;
     p4.log.success(`${wfCount} workflow${wfCount > 1 ? "s" : ""} added`);
   }
@@ -10976,16 +11985,16 @@ ${result.diff}`);
 });
 program.command("setup").description("Run the full configuration wizard (provider, identity, presets)").action(async () => {
   p4.intro(pc9.bold("aman agent setup") + pc9.dim(" \u2014 full configuration wizard"));
-  const reconfigPath = path28.join(homeDir(), ".reconfig");
-  fs28.mkdirSync(homeDir(), { recursive: true });
-  fs28.writeFileSync(reconfigPath, "", "utf-8");
+  const reconfigPath = path29.join(homeDir(), ".reconfig");
+  fs29.mkdirSync(homeDir(), { recursive: true });
+  fs29.writeFileSync(reconfigPath, "", "utf-8");
   p4.log.info("Configuration reset. Restart aman-agent to complete setup.");
 });
 program.command("update").description("Update aman-agent to the latest version").action(async () => {
   const { execFileSync: execFileSync4 } = await import("child_process");
-  const isVendored = process.execPath.includes(path28.join(".aman-agent", "node"));
+  const isVendored = process.execPath.includes(path29.join(".aman-agent", "node"));
   if (isVendored) {
-    const npmPath = path28.join(homeDir(), "node", "bin", "npm");
+    const npmPath = path29.join(homeDir(), "node", "bin", "npm");
     console.log("Updating aman-agent...");
     try {
       execFileSync4(npmPath, ["install", "-g", "@aman_asmuei/aman-agent@latest"], {
@@ -11013,7 +12022,7 @@ program.command("update").description("Update aman-agent to the latest version")
 program.command("uninstall").description("Remove aman-agent and all its data").action(async () => {
   const home2 = homeDir();
   if (!process.stdin.isTTY) {
-    fs28.rmSync(home2, { recursive: true, force: true });
+    fs29.rmSync(home2, { recursive: true, force: true });
     console.log("\u2713 Removed " + home2);
     return;
   }
@@ -11024,7 +12033,7 @@ program.command("uninstall").description("Remove aman-agent and all its data").a
     console.log("Cancelled.");
     return;
   }
-  fs28.rmSync(home2, { recursive: true, force: true });
+  fs29.rmSync(home2, { recursive: true, force: true });
   console.log("\u2713 Removed " + home2);
   console.log("");
   console.log("To complete uninstall, remove the PATH line from your shell config:");