@aman_asmuei/aman-agent 0.40.0 → 0.41.0

package/dist/index.js

@@ -731,17 +731,17 @@ var init_types = __esm({
 // 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}"`);
+  for (const node2 of dag.nodes) {
+    if (nodeIds.has(node2.id)) {
+      throw new DAGValidationError(`Duplicate node id: "${node2.id}"`);
     }
-    nodeIds.add(node.id);
+    nodeIds.add(node2.id);
   }
-  for (const node of dag.nodes) {
-    for (const dep of node.dependencies) {
+  for (const node2 of dag.nodes) {
+    for (const dep of node2.dependencies) {
       if (!nodeIds.has(dep)) {
         throw new DAGValidationError(
-          `Node "${node.id}" depends on nonexistent node "${dep}"`
+          `Node "${node2.id}" depends on nonexistent node "${dep}"`
         );
       }
     }
@@ -764,14 +764,14 @@ function validateDAG(dag) {
   }
   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 node2 of dag.nodes) {
+    inDegree.set(node2.id, 0);
+    adj.set(node2.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);
+  for (const node2 of dag.nodes) {
+    for (const dep of node2.dependencies) {
+      adj.get(dep).push(node2.id);
+      inDegree.set(node2.id, inDegree.get(node2.id) + 1);
     }
   }
   const queue = [];
@@ -794,6 +794,32 @@ function validateDAG(dag) {
     );
   }
 }
+function getReadyNodes(dag, taskStatuses, resolvedGates) {
+  const gateBlocked = /* @__PURE__ */ new Set();
+  for (const gate of dag.gates) {
+    if (resolvedGates?.has(gate.id)) continue;
+    const allAfterDone = gate.afterNodes.every(
+      (id) => taskStatuses.get(id) === "completed"
+    );
+    if (allAfterDone) {
+      for (const id of gate.beforeNodes) {
+        gateBlocked.add(id);
+      }
+    }
+  }
+  const ready = [];
+  for (const node2 of dag.nodes) {
+    if (taskStatuses.get(node2.id) !== "pending") continue;
+    if (gateBlocked.has(node2.id)) continue;
+    const allDepsCompleted = node2.dependencies.every(
+      (dep) => taskStatuses.get(dep) === "completed"
+    );
+    if (allDepsCompleted) {
+      ready.push(node2.id);
+    }
+  }
+  return ready;
+}
 var DAGValidationError;
 var init_dag = __esm({
   "src/orchestrator/dag.ts"() {
@@ -3756,6 +3782,9 @@ var ORCHESTRATOR_PROFILES = [
   testerProfile,
   reviewerProfile
 ];
+function getOrchestratorProfile(name) {
+  return ORCHESTRATOR_PROFILES.find((p5) => p5.name === name);
+}
 
 // src/profile-templates.ts
 var BUILT_IN_PROFILES = [
@@ -6074,21 +6103,950 @@ async function delegatePipeline(steps, initialInput, client, mcpManager, options
 
 // src/orchestrator/index.ts
 init_types();
+
+// src/orchestrator/state-machine.ts
+var ORCHESTRATION_TRANSITIONS = {
+  pending: ["running", "cancelled"],
+  running: ["awaiting_approval", "paused", "completed", "failed", "cancelled"],
+  awaiting_approval: ["approved", "cancelled", "failed"],
+  approved: ["running", "cancelled"],
+  paused: ["running", "cancelled", "failed"],
+  completed: [],
+  failed: [],
+  cancelled: []
+};
+var TASK_TRANSITIONS = {
+  pending: ["ready", "skipped", "blocked"],
+  ready: ["running", "skipped", "blocked"],
+  running: ["completed", "failed"],
+  completed: [],
+  failed: ["ready"],
+  skipped: [],
+  blocked: ["ready", "skipped"]
+};
+var TERMINAL_ORCHESTRATION = /* @__PURE__ */ new Set([
+  "completed",
+  "failed",
+  "cancelled"
+]);
+var InvalidTransitionError = class extends Error {
+  constructor(from, to, entity = "orchestration") {
+    super(
+      `Invalid ${entity} transition: ${from} \u2192 ${to}`
+    );
+    this.from = from;
+    this.to = to;
+    this.entity = entity;
+    this.name = "InvalidTransitionError";
+  }
+  from;
+  to;
+  entity;
+};
+function createOrchestrationState(dag) {
+  const now = Date.now();
+  const taskStatuses = /* @__PURE__ */ new Map();
+  for (const node2 of dag.nodes) {
+    taskStatuses.set(node2.id, "pending");
+  }
+  return {
+    dag,
+    status: "pending",
+    taskStatuses,
+    taskResults: /* @__PURE__ */ new Map(),
+    activeGate: null,
+    startedAt: now,
+    updatedAt: now
+  };
+}
+function canTransition(state, to) {
+  return ORCHESTRATION_TRANSITIONS[state.status].includes(to);
+}
+function cloneState(state) {
+  return {
+    ...state,
+    taskStatuses: new Map(state.taskStatuses),
+    taskResults: new Map(state.taskResults),
+    updatedAt: Date.now()
+  };
+}
+function transition(state, to, error) {
+  if (!canTransition(state, to)) {
+    throw new InvalidTransitionError(state.status, to);
+  }
+  const next = cloneState(state);
+  next.status = to;
+  if (TERMINAL_ORCHESTRATION.has(to)) {
+    next.completedAt = next.updatedAt;
+  }
+  if (error !== void 0) {
+    next.error = error;
+  }
+  return next;
+}
+function transitionTask(state, taskId, to) {
+  const current = state.taskStatuses.get(taskId);
+  if (current === void 0) {
+    throw new Error(`Unknown task id: ${taskId}`);
+  }
+  if (!TASK_TRANSITIONS[current].includes(to)) {
+    throw new InvalidTransitionError(current, to, "task");
+  }
+  const next = cloneState(state);
+  next.taskStatuses.set(taskId, to);
+  return next;
+}
+
+// src/orchestrator/index.ts
 init_dag();
+
+// src/orchestrator/model-router.ts
+function createModelRouter(clients) {
+  return {
+    getClient(tier) {
+      if (tier === "fast") return clients.fast ?? clients.standard;
+      if (tier === "advanced") return clients.advanced ?? clients.standard;
+      return clients.standard;
+    }
+  };
+}
+
+// src/orchestrator/audit.ts
+function createAuditLog(orchestrationId) {
+  return { orchestrationId, events: [] };
+}
+function recordAuditEvent(log5, event) {
+  log5.events.push({ ...event, timestamp: Date.now() });
+}
+
+// src/orchestrator/index.ts
 init_decompose();
 
 // src/orchestrator/scheduler.ts
 init_dag();
+async function runScheduler(dag, router, options, callbacks) {
+  const startTime = Date.now();
+  const maxParallel = options?.maxParallelTasks ?? 4;
+  const mcpManager = options?.mcpManager ?? null;
+  validateDAG(dag);
+  let state = createOrchestrationState(dag);
+  const auditLog = createAuditLog(dag.id);
+  state = transition(state, "running");
+  recordAuditEvent(auditLog, {
+    type: "orchestration_started",
+    message: `Orchestration "${dag.name}" started`
+  });
+  const resolvedGates = /* @__PURE__ */ new Set();
+  const running = /* @__PURE__ */ new Map();
+  async function transitionOrch(to, error) {
+    const from = state.status;
+    state = transition(state, to, error);
+    if (callbacks?.onPhaseTransition) {
+      await callbacks.onPhaseTransition(from, to);
+    }
+  }
+  function dispatchTask(nodeId) {
+    const node2 = dag.nodes.find((n) => n.id === nodeId);
+    state = transitionTask(state, nodeId, "ready");
+    state = transitionTask(state, nodeId, "running");
+    const taskPromise = (async () => {
+      if (callbacks?.onTaskStarted) {
+        await callbacks.onTaskStarted(nodeId, node2.name);
+      }
+      recordAuditEvent(auditLog, {
+        type: "task_started",
+        message: `Task "${node2.name}" started`,
+        taskId: nodeId
+      });
+      const startedAt = Date.now();
+      const client = router.getClient(node2.tier);
+      const taskDesc = [node2.name, node2.description, node2.context].filter(Boolean).join(": ");
+      try {
+        const delegationResult = await delegateTask(
+          taskDesc,
+          node2.profile,
+          client,
+          mcpManager,
+          { silent: true }
+        );
+        const completedAt = Date.now();
+        if (delegationResult.success) {
+          const taskResult = {
+            nodeId,
+            status: "completed",
+            output: delegationResult.response,
+            toolsUsed: delegationResult.toolsUsed,
+            turns: delegationResult.turns,
+            startedAt,
+            completedAt,
+            tier: node2.tier
+          };
+          state = transitionTask(state, nodeId, "completed");
+          state.taskResults.set(nodeId, taskResult);
+          recordAuditEvent(auditLog, {
+            type: "task_completed",
+            message: `Task "${node2.name}" completed`,
+            taskId: nodeId
+          });
+          if (callbacks?.onTaskCompleted) {
+            await callbacks.onTaskCompleted(nodeId, node2.name, taskResult);
+          }
+        } else {
+          const taskResult = {
+            nodeId,
+            status: "failed",
+            error: delegationResult.error ?? "Task failed",
+            toolsUsed: delegationResult.toolsUsed,
+            turns: delegationResult.turns,
+            startedAt,
+            completedAt,
+            tier: node2.tier
+          };
+          state = transitionTask(state, nodeId, "failed");
+          state.taskResults.set(nodeId, taskResult);
+          recordAuditEvent(auditLog, {
+            type: "task_failed",
+            message: `Task "${node2.name}" failed: ${delegationResult.error}`,
+            taskId: nodeId
+          });
+          if (callbacks?.onTaskFailed) {
+            await callbacks.onTaskFailed(nodeId, node2.name, delegationResult.error ?? "Task failed");
+          }
+        }
+      } catch (err) {
+        const completedAt = Date.now();
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        const taskResult = {
+          nodeId,
+          status: "failed",
+          error: errorMsg,
+          toolsUsed: [],
+          turns: 0,
+          startedAt,
+          completedAt,
+          tier: node2.tier
+        };
+        state = transitionTask(state, nodeId, "failed");
+        state.taskResults.set(nodeId, taskResult);
+        recordAuditEvent(auditLog, {
+          type: "task_failed",
+          message: `Task "${node2.name}" threw: ${errorMsg}`,
+          taskId: nodeId
+        });
+        if (callbacks?.onTaskFailed) {
+          await callbacks.onTaskFailed(nodeId, node2.name, errorMsg);
+        }
+      }
+    })();
+    running.set(nodeId, taskPromise);
+    taskPromise.then(() => running.delete(nodeId));
+  }
+  try {
+    while (true) {
+      if (["completed", "failed", "cancelled"].includes(state.status)) {
+        break;
+      }
+      const hasFailed = [...state.taskStatuses.values()].some((s) => s === "failed");
+      if (hasFailed) {
+        await transitionOrch("failed", "A task failed");
+        recordAuditEvent(auditLog, {
+          type: "orchestration_failed",
+          message: "Orchestration failed due to task failure"
+        });
+        break;
+      }
+      let gateHandled = false;
+      for (const gate of dag.gates) {
+        if (resolvedGates.has(gate.id)) continue;
+        const allAfterDone = gate.afterNodes.every(
+          (id) => state.taskStatuses.get(id) === "completed"
+        );
+        if (!allAfterDone) continue;
+        gateHandled = true;
+        await transitionOrch("awaiting_approval");
+        recordAuditEvent(auditLog, {
+          type: "approval_requested",
+          message: `Gate "${gate.name}" requires approval`,
+          gateId: gate.id
+        });
+        let approved = false;
+        if (callbacks?.onApprovalRequired) {
+          approved = await callbacks.onApprovalRequired(gate.id, gate.name);
+        }
+        if (approved) {
+          resolvedGates.add(gate.id);
+          await transitionOrch("approved");
+          recordAuditEvent(auditLog, {
+            type: "approval_granted",
+            message: `Gate "${gate.name}" approved`,
+            gateId: gate.id
+          });
+          await transitionOrch("running");
+          recordAuditEvent(auditLog, {
+            type: "gate_resolved",
+            message: `Gate "${gate.name}" resolved, resuming`,
+            gateId: gate.id
+          });
+        } else {
+          await transitionOrch("cancelled");
+          recordAuditEvent(auditLog, {
+            type: "approval_denied",
+            message: `Gate "${gate.name}" denied, cancelling`,
+            gateId: gate.id
+          });
+          break;
+        }
+      }
+      if (["completed", "failed", "cancelled"].includes(state.status)) {
+        break;
+      }
+      const readyNodes = getReadyNodes(dag, state.taskStatuses, resolvedGates);
+      if (readyNodes.length === 0 && running.size === 0) {
+        const allCompleted = [...state.taskStatuses.values()].every(
+          (s) => s === "completed" || s === "skipped"
+        );
+        if (allCompleted) {
+          await transitionOrch("completed");
+          recordAuditEvent(auditLog, {
+            type: "orchestration_completed",
+            message: `Orchestration "${dag.name}" completed successfully`
+          });
+          break;
+        } else {
+          await transitionOrch("failed", "Scheduler stuck: no ready or running tasks");
+          recordAuditEvent(auditLog, {
+            type: "orchestration_failed",
+            message: "Orchestration stuck with no progress possible"
+          });
+          break;
+        }
+      }
+      const availableSlots = maxParallel - running.size;
+      const toDispatch = readyNodes.slice(0, availableSlots);
+      for (const nodeId of toDispatch) {
+        dispatchTask(nodeId);
+      }
+      if (running.size > 0) {
+        await Promise.race(running.values());
+      }
+    }
+  } catch (err) {
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    if (!["completed", "failed", "cancelled"].includes(state.status)) {
+      try {
+        state = transition(state, "failed", errorMsg);
+      } catch {
+      }
+    }
+    recordAuditEvent(auditLog, {
+      type: "orchestration_failed",
+      message: `Orchestration error: ${errorMsg}`
+    });
+  }
+  return {
+    status: state.status,
+    taskResults: state.taskResults,
+    auditLog,
+    error: state.error,
+    durationMs: Date.now() - startTime
+  };
+}
+
+// src/orchestrator/review-loop.ts
+function buildReviewDAG(originalDAG, taskResults) {
+  let context = "Review the following completed work:\n\n";
+  for (const node2 of originalDAG.nodes) {
+    const result = taskResults.get(node2.id);
+    context += `## Task: ${node2.name}
+`;
+    context += `Profile: ${node2.profile}
+`;
+    context += `Output: ${result?.output ?? "(no output)"}
+
+`;
+  }
+  return {
+    id: `review-${originalDAG.id}`,
+    name: `Review: ${originalDAG.name}`,
+    goal: `Review the completed work from "${originalDAG.name}"`,
+    nodes: [
+      {
+        id: "code-review",
+        name: "Code Review",
+        profile: "reviewer",
+        tier: "standard",
+        dependencies: [],
+        context
+      },
+      {
+        id: "test-review",
+        name: "Test Review",
+        profile: "tester",
+        tier: "standard",
+        dependencies: [],
+        context
+      }
+    ],
+    gates: []
+  };
+}
+async function runReviewLoop(originalDAG, taskResults, options) {
+  const reviewDAG = buildReviewDAG(originalDAG, taskResults);
+  const schedulerResult = await runScheduler(
+    reviewDAG,
+    options.router,
+    {},
+    options.callbacks
+  );
+  if (schedulerResult.status === "completed") {
+    return {
+      passed: true,
+      iterations: 1,
+      reviewResult: schedulerResult
+    };
+  }
+  return {
+    passed: false,
+    iterations: 1,
+    reason: schedulerResult.error,
+    reviewResult: schedulerResult
+  };
+}
+
+// src/orchestrator/circuit-breaker.ts
+var DEFAULTS = {
+  failureThreshold: 3,
+  resetTimeoutMs: 6e4,
+  halfOpenMaxAttempts: 1
+};
+function createCircuitBreaker(name, options) {
+  const opts = { ...DEFAULTS, ...options };
+  let state = "closed";
+  let failures = 0;
+  let lastFailureAt = null;
+  let openedAt = null;
+  let halfOpenAttempts = 0;
+  function checkHalfOpen() {
+    if (state === "open" && openedAt !== null && Date.now() - openedAt >= opts.resetTimeoutMs) {
+      state = "half-open";
+      halfOpenAttempts = 0;
+    }
+  }
+  return {
+    get name() {
+      return name;
+    },
+    get state() {
+      checkHalfOpen();
+      return state;
+    },
+    get failures() {
+      return failures;
+    },
+    get lastFailureAt() {
+      return lastFailureAt;
+    },
+    canExecute() {
+      checkHalfOpen();
+      if (state === "closed") return true;
+      if (state === "open") return false;
+      if (halfOpenAttempts >= opts.halfOpenMaxAttempts) return false;
+      halfOpenAttempts++;
+      return true;
+    },
+    recordSuccess() {
+      if (state === "half-open") {
+        state = "closed";
+        failures = 0;
+        lastFailureAt = null;
+        openedAt = null;
+        halfOpenAttempts = 0;
+      }
+    },
+    recordFailure() {
+      failures++;
+      lastFailureAt = Date.now();
+      if (state === "half-open") {
+        state = "open";
+        openedAt = Date.now();
+        halfOpenAttempts = 0;
+      } else if (failures >= opts.failureThreshold) {
+        state = "open";
+        openedAt = Date.now();
+      }
+    },
+    reset() {
+      state = "closed";
+      failures = 0;
+      lastFailureAt = null;
+      openedAt = null;
+      halfOpenAttempts = 0;
+    }
+  };
+}
+function createCircuitBreakerRegistry(options) {
+  const breakers = /* @__PURE__ */ new Map();
+  return {
+    get(name) {
+      let cb = breakers.get(name);
+      if (!cb) {
+        cb = createCircuitBreaker(name, options);
+        breakers.set(name, cb);
+      }
+      return cb;
+    },
+    getAll() {
+      return [...breakers.values()];
+    },
+    resetAll() {
+      for (const cb of breakers.values()) {
+        cb.reset();
+      }
+    },
+    formatStatus() {
+      if (breakers.size === 0) {
+        return "No circuit breakers registered.";
+      }
+      const lines = [...breakers.values()].map(
+        (cb) => `  ${cb.name}: state=${cb.state} failures=${cb.failures}`
+      );
+      return `Circuit breakers (${breakers.size}):
+${lines.join("\n")}`;
+    }
+  };
+}
 
 // src/orchestrator/checkpoint.ts
 import { readFile as readFile2, writeFile, mkdir } from "fs/promises";
 import { join } from "path";
 
+// src/orchestrator/cost-tracker.ts
+var DEFAULT_TIER_COSTS = {
+  fast: {
+    inputTokensPerDollar: 5e6,
+    outputTokensPerDollar: 125e4
+  },
+  // ~$0.20/$0.80 per 1M
+  standard: {
+    inputTokensPerDollar: 333333,
+    outputTokensPerDollar: 66667
+  },
+  // ~$3/$15 per 1M
+  advanced: {
+    inputTokensPerDollar: 66667,
+    outputTokensPerDollar: 13333
+  }
+  // ~$15/$75 per 1M
+};
+function createCostTracker(options) {
+  const budgetLimit = options?.budgetLimit ?? null;
+  const tierCosts = {
+    ...DEFAULT_TIER_COSTS,
+    ...options?.tierCosts
+  };
+  const _entries = [];
+  function estimateCost(tier, inputTokens, outputTokens) {
+    const rates = tierCosts[tier];
+    return inputTokens / rates.inputTokensPerDollar + outputTokens / rates.outputTokensPerDollar;
+  }
+  function record(taskId, tier, inputTokens, outputTokens) {
+    _entries.push({
+      tier,
+      taskId,
+      inputTokens,
+      outputTokens,
+      estimatedCost: estimateCost(tier, inputTokens, outputTokens),
+      timestamp: Date.now()
+    });
+  }
+  function totalCost() {
+    return _entries.reduce((sum, e) => sum + e.estimatedCost, 0);
+  }
+  function costByTier() {
+    const result = {
+      fast: 0,
+      standard: 0,
+      advanced: 0
+    };
+    for (const entry of _entries) {
+      result[entry.tier] += entry.estimatedCost;
+    }
+    return result;
+  }
+  function entries() {
+    return [..._entries];
+  }
+  function isOverBudget() {
+    if (budgetLimit === null) return false;
+    return totalCost() > budgetLimit;
+  }
+  function remainingBudget() {
+    if (budgetLimit === null) return null;
+    return budgetLimit - totalCost();
+  }
+  function formatSummary() {
+    const total = totalCost();
+    const byTier = costByTier();
+    const lines = [];
+    lines.push(`Total: $${total.toFixed(4)}`);
+    for (const tier of ["fast", "standard", "advanced"]) {
+      if (byTier[tier] > 0) {
+        lines.push(`  ${tier}: $${byTier[tier].toFixed(4)}`);
+      }
+    }
+    if (budgetLimit !== null) {
+      const remaining = remainingBudget();
+      lines.push(
+        `Budget: $${budgetLimit.toFixed(2)} | Remaining: $${remaining.toFixed(4)}`
+      );
+    }
+    lines.push(`Entries: ${_entries.length}`);
+    return lines.join("\n");
+  }
+  return {
+    record,
+    totalCost,
+    costByTier,
+    entries,
+    isOverBudget,
+    remainingBudget,
+    formatSummary
+  };
+}
+
+// src/orchestrator/policy.ts
+var maxTaskCount = {
+  name: "max-task-count",
+  description: "DAG has more than 20 tasks",
+  severity: "warning",
+  check: (dag) => {
+    if (dag.nodes.length > 20) {
+      return [
+        {
+          rule: "max-task-count",
+          severity: "warning",
+          message: `DAG has ${dag.nodes.length} tasks (limit: 20)`
+        }
+      ];
+    }
+    return [];
+  }
+};
+var requiresReview = {
+  name: "requires-review",
+  description: 'No node with profile "reviewer" exists',
+  severity: "warning",
+  check: (dag) => {
+    const hasReviewer = dag.nodes.some((n) => n.profile === "reviewer");
+    if (!hasReviewer) {
+      return [
+        {
+          rule: "requires-review",
+          severity: "warning",
+          message: "DAG has no reviewer node \u2014 consider adding a code review step"
+        }
+      ];
+    }
+    return [];
+  }
+};
+var requiresTesting = {
+  name: "requires-testing",
+  description: 'No node with profile "tester" exists',
+  severity: "warning",
+  check: (dag) => {
+    const hasTester = dag.nodes.some((n) => n.profile === "tester");
+    if (!hasTester) {
+      return [
+        {
+          rule: "requires-testing",
+          severity: "warning",
+          message: "DAG has no tester node \u2014 consider adding a testing step"
+        }
+      ];
+    }
+    return [];
+  }
+};
+var noOrphanNodes = {
+  name: "no-orphan-nodes",
+  description: "Every node is either a root or has valid dependencies",
+  severity: "error",
+  check: (dag) => {
+    const nodeIds = new Set(dag.nodes.map((n) => n.id));
+    const violations = [];
+    for (const node2 of dag.nodes) {
+      for (const dep of node2.dependencies) {
+        if (!nodeIds.has(dep)) {
+          violations.push({
+            rule: "no-orphan-nodes",
+            severity: "error",
+            message: `Node "${node2.id}" depends on "${dep}" which does not exist`,
+            nodeId: node2.id
+          });
+        }
+      }
+    }
+    return violations;
+  }
+};
+var approvalBeforeDeploy = {
+  name: "approval-before-deploy",
+  description: "If any node name contains 'deploy' or 'release', an approval gate should exist",
+  severity: "warning",
+  check: (dag) => {
+    const deployNodes = dag.nodes.filter((n) => {
+      const lower = n.name.toLowerCase();
+      return lower.includes("deploy") || lower.includes("release");
+    });
+    if (deployNodes.length === 0) return [];
+    const hasApprovalGate = dag.gates.some((g) => g.type === "approval");
+    if (hasApprovalGate) return [];
+    return deployNodes.map((n) => ({
+      rule: "approval-before-deploy",
+      severity: "warning",
+      message: `Node "${n.name}" looks like a deploy/release step but no approval gate exists`,
+      nodeId: n.id
+    }));
+  }
+};
+var noAdvancedWithoutJustification = {
+  name: "no-advanced-without-justification",
+  description: 'Nodes with tier "advanced" flagged for cost awareness',
+  severity: "info",
+  check: (dag) => dag.nodes.filter((n) => n.tier === "advanced").map((n) => ({
+    rule: "no-advanced-without-justification",
+    severity: "info",
+    message: `Node "${n.id}" uses advanced tier \u2014 ensure this is justified for cost`,
+    nodeId: n.id
+  }))
+};
+var maxParallelDepth = {
+  name: "max-parallel-depth",
+  description: "DAG has more than 5 levels of depth",
+  severity: "warning",
+  check: (dag) => {
+    const nodeIds = new Set(dag.nodes.map((n) => n.id));
+    const depthMap = /* @__PURE__ */ new Map();
+    function getDepth(node2, visited) {
+      if (depthMap.has(node2.id)) return depthMap.get(node2.id);
+      if (visited.has(node2.id)) return 0;
+      visited.add(node2.id);
+      let maxDep = 0;
+      for (const depId of node2.dependencies) {
+        const depNode = dag.nodes.find((n) => n.id === depId);
+        if (depNode) {
+          maxDep = Math.max(maxDep, getDepth(depNode, visited) + 1);
+        }
+      }
+      depthMap.set(node2.id, maxDep);
+      return maxDep;
+    }
+    for (const node2 of dag.nodes) {
+      getDepth(node2, /* @__PURE__ */ new Set());
+    }
+    const maxDepth = Math.max(0, ...depthMap.values());
+    if (maxDepth > 5) {
+      return [
+        {
+          rule: "max-parallel-depth",
+          severity: "warning",
+          message: `DAG depth is ${maxDepth} (limit: 5)`
+        }
+      ];
+    }
+    return [];
+  }
+};
+function getDefaultPolicies() {
+  return [
+    maxTaskCount,
+    requiresReview,
+    requiresTesting,
+    noOrphanNodes,
+    approvalBeforeDeploy,
+    noAdvancedWithoutJustification,
+    maxParallelDepth
+  ];
+}
+function evaluatePolicy(dag, rules) {
+  const effectiveRules = rules ?? getDefaultPolicies();
+  const violations = [];
+  for (const rule of effectiveRules) {
+    violations.push(...rule.check(dag));
+  }
+  const hasErrors = violations.some((v) => v.severity === "error");
+  return {
+    passed: !hasErrors,
+    violations
+  };
+}
+
+// src/orchestrator/runner.ts
+async function runOrchestrationFull(dag, options) {
+  const startTime = Date.now();
+  let policyResult;
+  if (options.enablePolicyCheck) {
+    policyResult = evaluatePolicy(dag);
+    if (!policyResult.passed) {
+      const errorMessages = policyResult.violations.filter((v) => v.severity === "error").map((v) => v.message).join("; ");
+      return {
+        scheduler: {
+          status: "failed",
+          taskResults: /* @__PURE__ */ new Map(),
+          auditLog: createAuditLog(dag.id),
+          error: `Policy check failed: ${errorMessages}`,
+          durationMs: Date.now() - startTime
+        },
+        policy: policyResult,
+        success: false,
+        durationMs: Date.now() - startTime
+      };
+    }
+  }
+  const circuitBreakers = options.enableCircuitBreaker ? createCircuitBreakerRegistry() : void 0;
+  const costTracker = options.enableCostTracking ? createCostTracker({ budgetLimit: options.budgetLimit }) : void 0;
+  const wrappedCallbacks = {
+    ...options.callbacks,
+    onTaskStarted: async (nodeId, nodeName) => {
+      const node2 = dag.nodes.find((n) => n.id === nodeId);
+      if (circuitBreakers && node2) {
+        circuitBreakers.get(node2.profile).canExecute();
+      }
+      await options.callbacks?.onTaskStarted?.(nodeId, nodeName);
+    },
+    onTaskCompleted: async (nodeId, nodeName, result) => {
+      const node2 = dag.nodes.find((n) => n.id === nodeId);
+      if (node2) {
+        circuitBreakers?.get(node2.profile).recordSuccess();
+        costTracker?.record(nodeId, node2.tier, result.turns * 500, result.turns * 200);
+      }
+      await options.callbacks?.onTaskCompleted?.(nodeId, nodeName, result);
+    },
+    onTaskFailed: async (nodeId, nodeName, error) => {
+      const node2 = dag.nodes.find((n) => n.id === nodeId);
+      if (node2) {
+        circuitBreakers?.get(node2.profile).recordFailure();
+      }
+      await options.callbacks?.onTaskFailed?.(nodeId, nodeName, error);
+    }
+  };
+  const schedulerResult = await runScheduler(dag, options.router, {
+    maxParallelTasks: options.maxParallelTasks
+  }, wrappedCallbacks);
+  let reviewResult;
+  if (options.enableSelfReview && schedulerResult.status === "completed") {
+    reviewResult = await runReviewLoop(dag, schedulerResult.taskResults, {
+      router: options.router
+    });
+  }
+  const success = schedulerResult.status === "completed" && (reviewResult ? reviewResult.passed : true) && (costTracker ? !costTracker.isOverBudget() : true);
+  return {
+    scheduler: schedulerResult,
+    policy: policyResult,
+    review: reviewResult,
+    costSummary: costTracker?.formatSummary(),
+    circuitBreakerStatus: circuitBreakers?.formatStatus(),
+    success,
+    durationMs: Date.now() - startTime
+  };
+}
+
 // src/orchestrator/smart-orchestrate.ts
 init_decompose();
 
 // src/orchestrator/templates/index.ts
 init_dag();
+function node(id, profile, tier, deps = []) {
+  return {
+    id,
+    name: id.charAt(0).toUpperCase() + id.slice(1),
+    profile,
+    tier,
+    dependencies: deps
+  };
+}
+function approvalGate(id, afterNodes, beforeNodes) {
+  return {
+    id,
+    name: `Approval: ${id}`,
+    type: "approval",
+    afterNodes,
+    beforeNodes
+  };
+}
+function fullFeatureTemplate(options) {
+  const gates = [];
+  if (options.requireApproval) {
+    gates.push(approvalGate("approval", ["review", "test"], ["finalize"]));
+  }
+  const dag = {
+    id: `full-feature-${options.name}`,
+    name: `Full Feature: ${options.name}`,
+    goal: options.goal,
+    nodes: [
+      node("design", "architect", "advanced"),
+      node("implement", "coder", "standard", ["design"]),
+      node("review", "reviewer", "standard", ["implement"]),
+      node("test", "tester", "standard", ["implement"]),
+      node("finalize", "coder", "standard", ["review", "test"])
+    ],
+    gates
+  };
+  validateDAG(dag);
+  return dag;
+}
+function bugFixTemplate(options) {
+  const nodes = [
+    node("reproduce", "tester", "standard"),
+    node("fix", "coder", "standard", ["reproduce"]),
+    node("test", "tester", "standard", ["fix"]),
+    node("review", "reviewer", "standard", ["test"])
+  ];
+  const gates = [];
+  if (options.requireApproval) {
+    nodes.push(node("verify", "tester", "standard", ["review"]));
+    gates.push(approvalGate("approval", ["review"], ["verify"]));
+  }
+  const dag = {
+    id: `bug-fix-${options.name}`,
+    name: `Bug Fix: ${options.name}`,
+    goal: options.goal,
+    nodes,
+    gates
+  };
+  validateDAG(dag);
+  return dag;
+}
+function securityAuditTemplate(options) {
+  const gates = [];
+  if (options.requireApproval) {
+    gates.push(approvalGate("approval", ["triage"], ["fix"]));
+  }
+  const dag = {
+    id: `security-audit-${options.name}`,
+    name: `Security Audit: ${options.name}`,
+    goal: options.goal,
+    nodes: [
+      node("scan", "security", "standard"),
+      node("triage", "security", "standard", ["scan"]),
+      node("fix", "coder", "standard", ["triage"]),
+      node("rescan", "security", "standard", ["fix"]),
+      node("review", "reviewer", "standard", ["rescan"])
+    ],
+    gates
+  };
+  validateDAG(dag);
+  return dag;
+}
+var TEMPLATES = {
+  "full-feature": fullFeatureTemplate,
+  "bug-fix": bugFixTemplate,
+  "security-audit": securityAuditTemplate
+};
+function getTemplate(name) {
+  return TEMPLATES[name];
+}
 
 // src/project/detector.ts
 var FRONTEND_FRAMEWORKS = /* @__PURE__ */ new Set(["react", "vue", "svelte"]);
@@ -6106,11 +7064,92 @@ var BACKEND_FRAMEWORKS = /* @__PURE__ */ new Set([
   "django",
   "flask"
 ]);
+var ML_FRAMEWORKS = /* @__PURE__ */ new Set(["torch", "tensorflow", "sklearn", "pytorch", "pandas", "numpy"]);
 var WEB_FRAMEWORKS = /* @__PURE__ */ new Set([
   ...FRONTEND_FRAMEWORKS,
   ...FULLSTACK_FRAMEWORKS,
   ...BACKEND_FRAMEWORKS
 ]);
+var TEMPLATE_MAP = {
+  "web-frontend": "full-feature",
+  "web-fullstack": "full-feature",
+  "api-backend": "full-feature",
+  mobile: "full-feature",
+  "cli-tool": "bug-fix",
+  library: "full-feature",
+  "ml-data": "full-feature",
+  monorepo: "full-feature",
+  unknown: "full-feature"
+};
+var PROFILE_MAP = {
+  "web-frontend": ["architect", "coder", "tester", "reviewer"],
+  "web-fullstack": ["architect", "coder", "security", "tester", "reviewer"],
+  "api-backend": ["architect", "coder", "security", "tester", "reviewer"],
+  mobile: ["architect", "coder", "tester", "reviewer"],
+  "cli-tool": ["coder", "tester", "reviewer"],
+  library: ["architect", "coder", "tester", "reviewer"],
+  "ml-data": ["architect", "coder", "tester"],
+  monorepo: ["architect", "coder", "security", "tester", "reviewer"],
+  unknown: ["coder", "tester", "reviewer"]
+};
+var DESCRIPTION_MAP = {
+  "web-frontend": "Frontend web application",
+  "web-fullstack": "Full-stack web application with database",
+  "api-backend": "API/backend service",
+  mobile: "Mobile application",
+  "cli-tool": "Command-line tool",
+  library: "Reusable library/package",
+  "ml-data": "Machine learning / data science project",
+  monorepo: "Monorepo with multiple packages",
+  unknown: "Unknown project type"
+};
+function hasAny(items, set) {
+  return items.some((i) => set.has(i));
+}
+function classifyProject(stack) {
+  let type;
+  let confidence;
+  if (stack.isMonorepo) {
+    type = "monorepo";
+    confidence = 0.9;
+  } else if (hasAny(stack.frameworks, /* @__PURE__ */ new Set(["flutter"])) || stack.languages.includes("dart")) {
+    type = "mobile";
+    confidence = 0.9;
+  } else if (hasAny(stack.frameworks, FULLSTACK_FRAMEWORKS) && stack.databases.length > 0) {
+    type = "web-fullstack";
+    confidence = 0.9;
+  } else if (hasAny(stack.frameworks, BACKEND_FRAMEWORKS)) {
+    type = "api-backend";
+    confidence = 0.9;
+  } else if (hasAny(stack.frameworks, FRONTEND_FRAMEWORKS)) {
+    type = "web-frontend";
+    confidence = 0.85;
+  } else if (stack.languages.includes("python") && !hasAny(stack.frameworks, WEB_FRAMEWORKS)) {
+    if (hasAny(stack.frameworks, ML_FRAMEWORKS)) {
+      type = "ml-data";
+      confidence = 0.8;
+    } else {
+      type = "cli-tool";
+      confidence = 0.6;
+    }
+  } else if (stack.languages.length > 0 && stack.frameworks.length === 0) {
+    type = "library";
+    confidence = 0.6;
+  } else if (stack.languages.length === 0 && stack.frameworks.length === 0) {
+    type = "unknown";
+    confidence = 0.3;
+  } else {
+    type = "unknown";
+    confidence = 0.3;
+  }
+  return {
+    type,
+    confidence,
+    suggestedTemplate: TEMPLATE_MAP[type],
+    suggestedProfiles: PROFILE_MAP[type],
+    description: DESCRIPTION_MAP[type]
+  };
+}
 
 // src/orchestrator/smart-orchestrate.ts
 init_stack_detector();
@@ -6119,24 +7158,130 @@ init_stack_detector();
 import fs18 from "fs";
 import path18 from "path";
 import os15 from "os";
+function isProfileInstalled(profileName, profilesDir) {
+  return fs18.existsSync(path18.join(profilesDir, profileName, "core.md"));
+}
+function installProfile(profileName, profilesDir) {
+  const profile = getOrchestratorProfile(profileName);
+  if (!profile) return false;
+  const profileDir = path18.join(profilesDir, profileName);
+  fs18.mkdirSync(profileDir, { recursive: true });
+  fs18.writeFileSync(path18.join(profileDir, "core.md"), profile.core, "utf-8");
+  if (profile.rules) {
+    fs18.writeFileSync(path18.join(profileDir, "rules.md"), profile.rules, "utf-8");
+  }
+  return true;
+}
+function ensureAllProfilesInstalled(profilesDir) {
+  const installed = [];
+  const skipped = [];
+  for (const profile of ORCHESTRATOR_PROFILES) {
+    if (isProfileInstalled(profile.name, profilesDir)) {
+      skipped.push(profile.name);
+    } else {
+      installProfile(profile.name, profilesDir);
+      installed.push(profile.name);
+    }
+  }
+  return { installed, skipped };
+}
+function getProfilesDir() {
+  const acoreHome = process.env.ACORE_HOME;
+  if (acoreHome) {
+    return path18.join(acoreHome, "profiles");
+  }
+  return path18.join(os15.homedir(), ".acore", "profiles");
+}
 
-// src/orchestrator/index.ts
-init_dag();
+// src/orchestrator/smart-orchestrate.ts
 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 node2 of dag.nodes) {
+    const depLabel = node2.dependencies.length === 0 ? "(root)" : `(after: ${node2.dependencies.join(", ")})`;
+    lines.push(`- **${node2.name}** \u2192 ${node2.profile} [${node2.tier}] ${depLabel}`);
   }
   for (const gate of dag.gates) {
     lines.push(`- \u{1F512} **${gate.name}** [${gate.type}]`);
   }
   return lines.join("\n");
 }
+async function smartOrchestrate(options) {
+  ensureAllProfilesInstalled(getProfilesDir());
+  let projectType;
+  let templateName = options.templateName;
+  if (options.projectPath && !templateName) {
+    const stack = scanStack(options.projectPath);
+    const classification = classifyProject(stack);
+    projectType = classification.type;
+    templateName = classification.suggestedTemplate;
+  }
+  let dag;
+  if (templateName) {
+    const templateFn = getTemplate(templateName);
+    if (templateFn) {
+      dag = templateFn({ name: "Orchestration", goal: options.requirement });
+    } else {
+      dag = await decomposeRequirement(options.requirement, options.client);
+      templateName = void 0;
+    }
+  } else {
+    dag = await decomposeRequirement(options.requirement, options.client);
+  }
+  const orchestration = await runOrchestrationFull(dag, {
+    router: options.router,
+    enablePolicyCheck: options.enablePolicyCheck,
+    enableSelfReview: options.enableSelfReview,
+    enableCostTracking: options.enableCostTracking,
+    budgetLimit: options.budgetLimit,
+    callbacks: options.callbacks
+  });
+  const summary = formatSmartResult({
+    dag,
+    projectType,
+    templateUsed: templateName,
+    orchestration,
+    summary: ""
+  });
+  return { dag, projectType, templateUsed: templateName, orchestration, summary };
+}
+function formatSmartResult(result) {
+  const lines = [];
+  if (result.projectType) {
+    lines.push(`Project type: ${result.projectType}`);
+  }
+  if (result.templateUsed) {
+    lines.push(`Template: ${result.templateUsed}`);
+  }
+  lines.push("");
+  lines.push(formatDAGForDisplay(result.dag));
+  lines.push("");
+  const orch = result.orchestration;
+  lines.push(
+    `Status: ${orch.success ? "completed" : "failed"} (${orch.durationMs}ms)`
+  );
+  if (orch.policy && !orch.policy.passed) {
+    const errorCount = orch.policy.violations.filter(
+      (v) => v.severity === "error"
+    ).length;
+    lines.push(
+      `Policy: FAILED \u2014 ${errorCount} error${errorCount !== 1 ? "s" : ""}`
+    );
+  }
+  if (orch.review) {
+    lines.push(`Review: ${orch.review.passed ? "passed" : "failed"}`);
+  }
+  if (orch.costSummary) {
+    lines.push(`Cost: ${orch.costSummary}`);
+  }
+  return lines.join("\n");
+}
+
+// src/orchestrator/index.ts
+init_dag();
 
 // src/commands.ts
 init_registry();
@@ -8043,7 +9188,7 @@ function handleReset(action) {
 function handleUpdate() {
   try {
     const current = execFileSync3("npm", ["view", "@aman_asmuei/aman-agent", "version"], { encoding: "utf-8" }).trim();
-    const local = true ? "0.40.0" : "unknown";
+    const local = true ? "0.41.0" : "unknown";
     if (current === local) {
       return { handled: true, output: `${pc6.green("Up to date")} \u2014 v${local}` };
     }
@@ -8862,21 +10007,57 @@ 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`
+      output: [
+        "Usage: /orchestrate <requirement>",
+        "",
+        "Decomposes a requirement into a task DAG and executes it with parallel agents.",
+        "Auto-detects project type, selects template, runs policy check, and tracks cost.",
+        "",
+        "Options (pass as first arg):",
+        "  --template <name>   Force a template (full-feature, bug-fix, security-audit)",
+        "  --no-review         Skip self-review loop",
+        "  --no-policy         Skip policy check",
+        "",
+        "Alias: /orch"
+      ].join("\n")
     };
   }
-  const requirement = [action, ...args].join(" ");
   if (!ctx.llmClient) {
     return { handled: true, output: pc6.red("Orchestration requires an LLM client. Not available.") };
   }
+  let templateName;
+  let enableSelfReview = true;
+  let enablePolicyCheck = true;
+  const filtered = [];
+  const allArgs = [action, ...args];
+  for (let i = 0; i < allArgs.length; i++) {
+    if (allArgs[i] === "--template" && allArgs[i + 1]) {
+      templateName = allArgs[++i];
+    } else if (allArgs[i] === "--no-review") {
+      enableSelfReview = false;
+    } else if (allArgs[i] === "--no-policy") {
+      enablePolicyCheck = false;
+    } else {
+      filtered.push(allArgs[i]);
+    }
+  }
+  const requirement = filtered.join(" ");
+  if (!requirement.trim()) {
+    return { handled: true, output: pc6.red("Please provide a requirement to orchestrate.") };
+  }
   try {
-    const dag = await decomposeRequirement(requirement, ctx.llmClient);
-    const display = formatDAGForDisplay(dag);
-    return { handled: true, output: display };
+    const router = createModelRouter({ standard: ctx.llmClient });
+    const result = await smartOrchestrate({
+      requirement,
+      client: ctx.llmClient,
+      router,
+      projectPath: process.cwd(),
+      templateName,
+      enablePolicyCheck,
+      enableSelfReview,
+      enableCostTracking: true
+    });
+    return { handled: true, output: result.summary };
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     return { handled: true, output: pc6.red(`Orchestration failed: ${msg}`) };
@@ -8931,11 +10112,22 @@ async function handleGitHubCommand(action, args, ctx) {
       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}`)}
+        const router = createModelRouter({ standard: ctx.llmClient });
+        const result = await smartOrchestrate({
+          requirement,
+          client: ctx.llmClient,
+          router,
+          projectPath: process.cwd(),
+          enablePolicyCheck: true,
+          enableSelfReview: false,
+          enableCostTracking: true
+        });
+        return {
+          handled: true,
+          output: `${pc6.bold(`Plan for #${issue.number}: ${issue.title}`)}
 
-${display}` };
+${result.summary}`
+        };
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
         return { handled: true, output: pc6.red(`Failed to plan issue #${issueNum}: ${msg}`) };
@@ -11150,7 +12342,7 @@ var Inbox = class {
 // package.json
 var package_default = {
   name: "@aman_asmuei/aman-agent",
-  version: "0.40.0",
+  version: "0.41.0",
   description: "Your AI companion, running locally \u2014 powered by the aman ecosystem",
   type: "module",
   engines: {
@@ -11517,7 +12709,7 @@ function bootstrapEcosystem() {
   return true;
 }
 var program = new Command();
-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) => {
+program.name("aman-agent").description("Your AI companion, running locally").version("0.41.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) {