ccjk 13.3.5 → 13.3.7

package/dist/chunks/{convoy-manager.mjs → session-manager.mjs}

@@ -1,829 +1,810 @@
-import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
-import { glob } from 'tinyglobby';
-import { e as executionTracer } from '../shared/ccjk.BfIpomdz.mjs';
-import { f as fsParadigm } from '../shared/ccjk.BxSmJ8B7.mjs';
+import { EventEmitter } from 'node:events';
+import { n as nanoid } from '../shared/ccjk.BoApaI4j.mjs';
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { x as K } from './main.mjs';
 import { j as join } from '../shared/ccjk.bQ7Dh1g4.mjs';
+import { glob } from 'tinyglobby';
+import { e as executionTracer } from '../shared/ccjk.CHUEFqmw.mjs';
+import { f as fsParadigm } from '../shared/ccjk.wLJHO0Af.mjs';
 import 'node:child_process';
 import 'node:fs/promises';
-import { homedir } from 'node:os';
 import 'node:path';
-import { EventEmitter } from 'node:events';
-import { n as nanoid } from '../shared/ccjk.BoApaI4j.mjs';
-import { x as K } from './main.mjs';
 
-const DEPTH_TOKEN_BUDGETS = {
-  L0: 100,
-  // Abstract summary only
-  L1: 2e3,
-  // Overview
-  L2: Number.POSITIVE_INFINITY
-  // Full content
-};
-const PHASE_BUDGET_MULTIPLIERS = {
-  exploring: 2,
-  executing: 0.6,
-  generating: 0.4,
-  reviewing: 1.2,
-  idle: 1
-};
-const CHARS_PER_TOKEN = 4;
-function estimateTokens(text) {
-  return Math.ceil(text.length / CHARS_PER_TOKEN);
-}
-function truncateToDepth(content, depth) {
-  if (depth === "L2") return content;
-  const maxChars = DEPTH_TOKEN_BUDGETS[depth] * CHARS_PER_TOKEN;
-  if (content.length <= maxChars) return content;
-  if (depth === "L0") {
-    const firstPara = content.split(/\n\n/)[0];
-    return firstPara.length <= maxChars ? firstPara : content.slice(0, maxChars);
+class GitBackedStateManager extends EventEmitter {
+  config;
+  worktrees = /* @__PURE__ */ new Map();
+  initialized = false;
+  pendingCommits = /* @__PURE__ */ new Map();
+  constructor(config = {}) {
+    super();
+    this.config = {
+      workspaceRoot: config.workspaceRoot ?? join(homedir(), ".ccjk", "workspace"),
+      useWorktrees: config.useWorktrees ?? true,
+      autoCommit: config.autoCommit ?? true,
+      compressionLevel: config.compressionLevel ?? 6,
+      verbose: config.verbose ?? false,
+      commitBatchInterval: config.commitBatchInterval ?? 1e3
+    };
   }
-  return `${content.slice(0, maxChars)}
-... (truncated, use L2 for full content)`;
-}
-class ContextLoader {
-  cache = /* @__PURE__ */ new Map();
-  defaultMaxSize = 1e5;
-  // 100KB default
-  defaultTokenBudget = 8e3;
-  // ~32KB at 4 chars/token
   /**
-   * Resolve effective depth from options.
-   * If depth is explicit, use it. Otherwise derive from tokenBudget.
+   * Initialize the workspace with Git
    */
-  resolveDepth(tokenBudget, explicitDepth) {
-    if (explicitDepth) return explicitDepth;
-    if (tokenBudget <= DEPTH_TOKEN_BUDGETS.L0) return "L0";
-    if (tokenBudget <= DEPTH_TOKEN_BUDGETS.L1) return "L1";
-    return "L2";
+  async initialize() {
+    if (this.initialized)
+      return;
+    const { workspaceRoot } = this.config;
+    try {
+      if (!existsSync(workspaceRoot)) {
+        mkdirSync(workspaceRoot, { recursive: true });
+        this.log(`Created workspace: ${workspaceRoot}`);
+      }
+      const gitDir = join(workspaceRoot, ".git");
+      if (!existsSync(gitDir)) {
+        await this.exec("git", ["init"], workspaceRoot);
+        this.log("Initialized Git repository");
+        const gitignore = `
+# Sensitive data
+*.env
+*.key
+*.pem
+credentials.json
+
+# Temporary files
+*.tmp
+*.log
+*.swp
+
+# OS files
+.DS_Store
+Thumbs.db
+`;
+        writeFileSync(join(workspaceRoot, ".gitignore"), gitignore.trim());
+        await this.exec("git", ["add", ".gitignore"], workspaceRoot);
+        await this.exec("git", ["commit", "-m", "Initial commit"], workspaceRoot);
+        this.log("Created initial commit");
+      }
+      const agentsDir = join(workspaceRoot, "agents");
+      if (!existsSync(agentsDir)) {
+        mkdirSync(agentsDir, { recursive: true });
+      }
+      await this.loadExistingWorktrees();
+      this.initialized = true;
+      this.emit("initialized");
+      this.log("GitBackedStateManager initialized");
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.emit("error", err);
+      throw err;
+    }
   }
   /**
-   * Load context hierarchically with OpenViking-style tiered depth control.
-   * Pass tokenBudget to automatically select L0/L1/L2 depth.
+   * Create isolated worktree for agent
    */
-  async load(options = {}) {
-    const {
-      projectRoot = process.cwd(),
-      maxSize = this.defaultMaxSize,
-      tokenBudget,
-      depth: explicitDepth,
-      layers = ["project", "domain", "task", "execution"],
-      task
-    } = options;
-    const phaseMultiplier = options.taskPhase ? PHASE_BUDGET_MULTIPLIERS[options.taskPhase] ?? 1 : 1;
-    const effectiveBudget = Math.round((tokenBudget ?? this.defaultTokenBudget) * phaseMultiplier);
-    const depth = this.resolveDepth(effectiveBudget, explicitDepth);
-    const cacheKey = this.getCacheKey(projectRoot, layers, task?.id, depth);
-    const cached = this.cache.get(cacheKey);
-    if (cached && Date.now() - cached.loadedAt < 6e4) {
-      executionTracer.logEvent("context-load", {
-        source: "cache",
-        layers: layers.length,
-        size: cached.totalSize,
-        tokens: cached.totalTokens,
-        depth
-      });
-      return cached;
+  async createAgentWorktree(agentId) {
+    await this.ensureInitialized();
+    const { workspaceRoot, useWorktrees } = this.config;
+    if (this.worktrees.has(agentId)) {
+      return this.worktrees.get(agentId);
     }
-    const context = {
-      layers: /* @__PURE__ */ new Map(),
-      totalSize: 0,
-      totalTokens: 0,
-      loadedAt: Date.now(),
-      depth
-    };
-    for (const layer of layers) {
-      const entries = await this.loadLayer(layer, projectRoot, task, depth);
-      if (entries.length > 0) {
-        context.layers.set(layer, entries);
-        context.totalSize += entries.reduce((sum, e) => sum + e.content.length, 0);
-        context.totalTokens += entries.reduce((sum, e) => sum + e.tokenEstimate, 0);
+    const agentPath = join(workspaceRoot, "agents", agentId);
+    if (useWorktrees) {
+      const branchName = `agent/${agentId}`;
+      try {
+        await this.exec("git", ["checkout", "--orphan", branchName], workspaceRoot);
+        await this.exec("git", ["reset", "--hard"], workspaceRoot);
+        await this.exec("git", ["checkout", "main"], workspaceRoot).catch(() => {
+          return this.exec("git", ["checkout", "master"], workspaceRoot);
+        });
+        if (!existsSync(agentPath)) {
+          await this.exec("git", ["worktree", "add", agentPath, branchName], workspaceRoot);
+        }
+      } catch {
+        if (!existsSync(agentPath)) {
+          mkdirSync(agentPath, { recursive: true });
+        }
       }
-      if (context.totalSize > maxSize || context.totalTokens > effectiveBudget) {
-        break;
+    } else {
+      if (!existsSync(agentPath)) {
+        mkdirSync(agentPath, { recursive: true });
       }
     }
-    this.cache.set(cacheKey, context);
-    executionTracer.logEvent("context-load", {
-      source: "fresh",
-      layers: context.layers.size,
-      size: context.totalSize,
-      tokens: context.totalTokens,
-      depth
-    });
-    return context;
+    const stateFile = join(agentPath, "state.json");
+    const mailboxFile = join(agentPath, "mailbox.json");
+    if (!existsSync(stateFile)) {
+      writeFileSync(stateFile, JSON.stringify({ agentId, createdAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2));
+    }
+    if (!existsSync(mailboxFile)) {
+      writeFileSync(mailboxFile, JSON.stringify({ inbox: [], outbox: [], archive: [] }, null, 2));
+    }
+    this.worktrees.set(agentId, agentPath);
+    this.emit("worktree:created", agentId, agentPath);
+    this.log(`Created worktree for agent: ${agentId}`);
+    return agentPath;
   }
   /**
-   * Load a specific context layer
+   * Save agent state to Git
    */
-  async loadLayer(layer, projectRoot, task, depth = "L2") {
-    switch (layer) {
-      case "project":
-        return this.loadProjectContext(projectRoot, depth);
-      case "domain":
-        return this.loadDomainContext(projectRoot, task, depth);
-      case "task":
-        return this.loadTaskContext(task, depth);
-      case "execution":
-        return this.loadExecutionContext(task, depth);
-      default:
-        return [];
+  async saveState(agentId, state) {
+    await this.ensureInitialized();
+    const agentPath = await this.getOrCreateAgentPath(agentId);
+    const stateFile = join(agentPath, "state.json");
+    let existingState = {};
+    if (existsSync(stateFile)) {
+      try {
+        existingState = JSON.parse(readFileSync(stateFile, "utf-8"));
+      } catch {
+      }
     }
+    const newState = {
+      ...existingState,
+      ...state,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    writeFileSync(stateFile, JSON.stringify(newState, null, 2));
+    let commitId = "";
+    if (this.config.autoCommit) {
+      commitId = await this.batchCommit(agentId, `Update state: ${agentId}`);
+    }
+    this.emit("state:saved", agentId, commitId);
+    this.log(`Saved state for agent: ${agentId}`);
+    return commitId;
   }
   /**
-   * Load project-level context
-   * - README.md
-   * - CLAUDE.md
-   * - package.json
-   * - tsconfig.json
+   * Load agent state from Git
    */
-  async loadProjectContext(projectRoot, depth = "L2") {
-    const entries = [];
-    const files = ["README.md", "CLAUDE.md", "package.json", "tsconfig.json"];
-    for (const file of files) {
-      const path = join(projectRoot, file);
-      if (existsSync(path)) {
-        const raw = readFileSync(path, "utf-8");
-        const content = truncateToDepth(raw, depth);
-        entries.push({
-          layer: "project",
-          source: file,
-          content,
-          priority: 100,
-          depth,
-          tokenEstimate: estimateTokens(content),
-          metadata: { path }
-        });
-      }
+  async loadState(agentId) {
+    await this.ensureInitialized();
+    const agentPath = this.worktrees.get(agentId);
+    if (!agentPath) {
+      return null;
+    }
+    const stateFile = join(agentPath, "state.json");
+    if (!existsSync(stateFile)) {
+      return null;
+    }
+    try {
+      const state = JSON.parse(readFileSync(stateFile, "utf-8"));
+      this.emit("state:loaded", agentId);
+      this.log(`Loaded state for agent: ${agentId}`);
+      return state;
+    } catch {
+      return null;
     }
-    return entries;
   }
   /**
-   * Load domain-specific context
-   * Based on task type/domain, load relevant files
+   * Rollback to previous state
    */
-  async loadDomainContext(projectRoot, task, depth = "L2") {
-    if (!task) return [];
-    const entries = [];
-    const structure = await fsParadigm.detect(projectRoot);
-    const domain = this.inferDomain(task);
-    if (!domain) {
-      const sourceFiles = fsParadigm.getFilesByRole(structure, "source");
-      for (const file of sourceFiles.slice(0, 3)) {
+  async rollback(agentId, commitId) {
+    await this.ensureInitialized();
+    const agentPath = this.worktrees.get(agentId);
+    if (!agentPath) {
+      throw new Error(`Agent not found: ${agentId}`);
+    }
+    try {
+      await this.exec("git", ["reset", "--hard", commitId], agentPath);
+      this.emit("state:rolled-back", agentId, commitId);
+      this.log(`Rolled back agent ${agentId} to commit ${commitId}`);
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.emit("error", err);
+      throw err;
+    }
+  }
+  /**
+   * Get state history for agent
+   */
+  async getHistory(agentId, limit = 10) {
+    await this.ensureInitialized();
+    const agentPath = this.worktrees.get(agentId);
+    if (!agentPath) {
+      return [];
+    }
+    try {
+      const result = await this.exec(
+        "git",
+        ["log", `--max-count=${limit}`, "--format=%H|%s|%ct", "--", "state.json"],
+        agentPath
+      );
+      const snapshots = [];
+      for (const line of result.stdout.split("\n").filter(Boolean)) {
+        const [commitId, message, timestamp] = line.split("|");
+        const stateResult = await this.exec(
+          "git",
+          ["show", `${commitId}:state.json`],
+          agentPath
+        ).catch(() => ({ stdout: "{}" }));
+        let state;
         try {
-          const raw = readFileSync(file, "utf-8");
-          const content = truncateToDepth(raw, depth);
-          entries.push({
-            layer: "domain",
-            source: file.replace(projectRoot, ""),
-            content,
-            priority: 75,
-            depth,
-            tokenEstimate: estimateTokens(content),
-            metadata: { paradigm: structure.paradigm, path: file }
-          });
+          state = JSON.parse(stateResult.stdout);
         } catch {
+          state = {};
         }
+        snapshots.push({
+          id: nanoid(),
+          agentId,
+          commitId,
+          timestamp: Number.parseInt(timestamp, 10) * 1e3,
+          message,
+          state
+        });
       }
-      return entries;
+      return snapshots;
+    } catch {
+      return [];
     }
-    const patterns = this.getDomainPatterns(domain, structure.paradigm);
-    for (const pattern of patterns) {
-      const files = await glob([pattern], {
-        cwd: projectRoot,
-        absolute: true,
-        ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**"]
-      });
-      for (const file of files.slice(0, 5)) {
-        try {
-          const raw = readFileSync(file, "utf-8");
-          const content = truncateToDepth(raw, depth);
-          entries.push({
-            layer: "domain",
-            source: file.replace(projectRoot, ""),
-            content,
-            priority: 80,
-            depth,
-            tokenEstimate: estimateTokens(content),
-            metadata: { domain, paradigm: structure.paradigm, path: file }
-          });
-        } catch {
-        }
+  }
+  /**
+   * Cleanup agent worktree
+   */
+  async cleanup(agentId) {
+    await this.ensureInitialized();
+    const agentPath = this.worktrees.get(agentId);
+    if (!agentPath) {
+      return;
+    }
+    try {
+      if (this.config.useWorktrees) {
+        await this.exec("git", ["worktree", "remove", agentPath, "--force"], this.config.workspaceRoot);
       }
+      this.worktrees.delete(agentId);
+      this.emit("worktree:removed", agentId);
+      this.log(`Cleaned up worktree for agent: ${agentId}`);
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.emit("error", err);
+      throw err;
     }
-    return entries;
   }
   /**
-   * Load task-specific context
+   * Get all agent IDs
    */
-  async loadTaskContext(task, depth = "L2") {
-    if (!task) return [];
-    const entries = [];
-    if (task.description) {
-      const content = truncateToDepth(task.description, depth);
-      entries.push({
-        layer: "task",
-        source: "task-description",
-        content,
-        priority: 90,
-        depth,
-        tokenEstimate: estimateTokens(content),
-        metadata: { taskId: task.id }
-      });
-    }
-    if (task.input && depth !== "L0") {
-      const content = truncateToDepth(JSON.stringify(task.input, null, 2), depth);
-      entries.push({
-        layer: "task",
-        source: "task-input",
-        content,
-        priority: 85,
-        depth,
-        tokenEstimate: estimateTokens(content),
-        metadata: { taskId: task.id }
-      });
-    }
-    return entries;
+  getAgentIds() {
+    return Array.from(this.worktrees.keys());
   }
   /**
-   * Load execution-specific context
-   * - Recent errors
-   * - Previous attempts
-   * - Related task outputs
+   * Check if agent exists
    */
-  async loadExecutionContext(task, depth = "L2") {
-    if (!task) return [];
-    const entries = [];
-    if (task.output && depth !== "L0") {
-      const content = truncateToDepth(JSON.stringify(task.output, null, 2), depth);
-      entries.push({
-        layer: "execution",
-        source: "previous-output",
-        content,
-        priority: 70,
-        depth,
-        tokenEstimate: estimateTokens(content),
-        metadata: { taskId: task.id }
-      });
-    }
-    return entries;
+  hasAgent(agentId) {
+    return this.worktrees.has(agentId);
   }
   /**
-   * Infer domain from task
+   * Get workspace root path
    */
-  inferDomain(task) {
-    const text = `${task.name} ${task.description || ""}`.toLowerCase();
-    const domains = {
-      api: ["api", "endpoint", "route", "controller"],
-      ui: ["ui", "component", "view", "page", "frontend"],
-      database: ["database", "db", "schema", "migration", "model"],
-      auth: ["auth", "login", "user", "permission", "session"],
-      test: ["test", "spec", "e2e", "unit", "integration"],
-      config: ["config", "settings", "env", "setup"]
-    };
-    for (const [domain, keywords] of Object.entries(domains)) {
-      if (keywords.some((kw) => text.includes(kw))) {
-        return domain;
-      }
-    }
-    return null;
+  getWorkspaceRoot() {
+    return this.config.workspaceRoot;
   }
   /**
-   * Get file patterns for a domain (paradigm-aware)
+   * Get agent path
    */
-  getDomainPatterns(domain, paradigm) {
-    const basePatterns = {
-      api: ["**/api/**/*.ts", "**/routes/**/*.ts", "**/controllers/**/*.ts"],
-      ui: ["**/components/**/*.{tsx,vue}", "**/pages/**/*.{tsx,vue}", "**/views/**/*.{tsx,vue}"],
-      database: ["**/models/**/*.ts", "**/schema/**/*.ts", "**/migrations/**/*.ts"],
-      auth: ["**/auth/**/*.ts", "**/middleware/auth*.ts"],
-      test: ["**/*.test.ts", "**/*.spec.ts"],
-      config: ["**/config/**/*.ts", "**/*.config.ts"]
-    };
-    let patterns = basePatterns[domain] || [];
-    if (paradigm === "monorepo") {
-      patterns = patterns.map((p) => `packages/*/${p}`);
-    } else if (paradigm === "fullstack") {
-      if (domain === "ui") {
-        patterns = patterns.map((p) => `client/${p}`);
-      } else if (domain === "api") {
-        patterns = patterns.map((p) => `server/${p}`);
-      }
+  getAgentPath(agentId) {
+    return this.worktrees.get(agentId);
+  }
+  /**
+   * Get state history for agent
+   */
+  async getStateHistory(agentId, limit = 20) {
+    await this.ensureInitialized();
+    const agentPath = this.worktrees.get(agentId);
+    if (!agentPath) {
+      return { agentId, commits: [], totalCommits: 0 };
+    }
+    try {
+      const result = await this.exec(
+        "git",
+        ["log", `--max-count=${limit}`, "--format=%H|%s|%ct", "--", "state.json"],
+        agentPath
+      );
+      const commits = result.stdout.split("\n").filter(Boolean).map((line) => {
+        const [id, message, timestamp] = line.split("|");
+        return {
+          id,
+          message,
+          timestamp: Number.parseInt(timestamp, 10) * 1e3
+        };
+      });
+      const countResult = await this.exec(
+        "git",
+        ["rev-list", "--count", "HEAD", "--", "state.json"],
+        agentPath
+      ).catch(() => ({ stdout: "0" }));
+      return {
+        agentId,
+        commits,
+        totalCommits: Number.parseInt(countResult.stdout.trim(), 10) || commits.length
+      };
+    } catch {
+      return { agentId, commits: [], totalCommits: 0 };
     }
-    return patterns;
   }
   /**
-   * Get cache key
+   * Create a named snapshot of current state
    */
-  getCacheKey(projectRoot, layers, taskId, depth = "L2") {
-    return `${projectRoot}:${layers.join(",")}:${taskId || "none"}:${depth}`;
+  async createSnapshot(agentId, description) {
+    await this.ensureInitialized();
+    const agentPath = this.worktrees.get(agentId);
+    if (!agentPath) {
+      throw new Error(`Agent not found: ${agentId}`);
+    }
+    const commitId = await this.commit(agentId, `Snapshot: ${description}`);
+    if (!commitId) {
+      const result = await this.exec("git", ["rev-parse", "HEAD"], agentPath);
+      const currentCommitId = result.stdout.trim();
+      const state2 = await this.loadState(agentId);
+      return {
+        id: nanoid(),
+        agentId,
+        commitId: currentCommitId,
+        timestamp: Date.now(),
+        message: description,
+        state: state2 ?? {}
+      };
+    }
+    const state = await this.loadState(agentId);
+    return {
+      id: nanoid(),
+      agentId,
+      commitId,
+      timestamp: Date.now(),
+      message: description,
+      state: state ?? {}
+    };
   }
   /**
-   * Clear cache
+   * Restore state from a snapshot
    */
-  clearCache() {
-    this.cache.clear();
+  async restoreSnapshot(agentId, snapshotId) {
+    await this.rollback(agentId, snapshotId);
   }
   /**
-   * Format context for LLM consumption
+   * Sync with remote (if configured)
    */
-  formatForLLM(context) {
-    const sections = [];
-    sections.push(`<!-- context depth=${context.depth} tokens\u2248${context.totalTokens} -->
-`);
-    const layerOrder = ["project", "domain", "task", "execution"];
-    for (const layer of layerOrder) {
-      const entries = context.layers.get(layer);
-      if (!entries || entries.length === 0) continue;
-      sections.push(`# ${layer.toUpperCase()} CONTEXT
-`);
-      const sorted = entries.sort((a, b) => b.priority - a.priority);
-      for (const entry of sorted) {
-        sections.push(`## ${entry.source} [${entry.depth}]
-`);
-        sections.push(entry.content);
-        sections.push("\n");
+  async syncWithRemote() {
+    await this.ensureInitialized();
+    try {
+      const remoteResult = await this.exec("git", ["remote"], this.config.workspaceRoot);
+      if (!remoteResult.stdout.trim()) {
+        this.log("No remote configured, skipping sync");
+        return;
       }
-    }
-    return sections.join("\n");
-  }
-}
-const contextLoader = new ContextLoader();
-async function loadContextAtDepth(depth, options = {}) {
-  return contextLoader.load({ ...options, depth });
-}
-
-const contextLoader$1 = {
-  __proto__: null,
-  ContextLoader: ContextLoader,
-  contextLoader: contextLoader,
-  loadContextAtDepth: loadContextAtDepth
-};
-
-function detectTaskPhase(history) {
-  if (history.length === 0) return "idle";
-  const recent = history.slice(-10);
-  const recentText = recent.map((h) => h.content).join(" ").toLowerCase();
-  if (recentText.includes("write") || recentText.includes("create") || recentText.includes("generating"))
-    return "generating";
-  if (recentText.includes("test") || recentText.includes("review") || recentText.includes("check"))
-    return "reviewing";
-  if (recentText.includes("edit") || recentText.includes("bash") || recentText.includes("run"))
-    return "executing";
-  if (recentText.includes("read") || recentText.includes("search") || recentText.includes("grep"))
-    return "exploring";
-  return "idle";
-}
-function extractFilePaths(content) {
-  const matches = content.match(/(?:\/[\w./\-]+\.\w+|[\w./\-]+\.(?:ts|js|json|md|py|go|rs))/g);
-  return matches ? [...new Set(matches)] : [];
-}
-class SessionIntelligence {
-  session;
-  constructor(session) {
-    this.session = session;
-    if (!session.intelligence) {
-      session.intelligence = {
-        taskPhase: "idle",
-        filesTouched: [],
-        keyDecisions: [],
-        toolCallCount: 0,
-        compressionWatermark: 0
-      };
+      await this.exec("git", ["pull", "--rebase"], this.config.workspaceRoot);
+      await this.exec("git", ["push"], this.config.workspaceRoot);
+      this.log("Synced with remote");
+    } catch (error) {
+      this.log(`Sync failed: ${error}`);
     }
   }
-  get state() {
-    return this.session.intelligence;
+  // ========================================================================
+  // Private Methods
+  // ========================================================================
+  async ensureInitialized() {
+    if (!this.initialized) {
+      await this.initialize();
+    }
   }
-  /**
-   * Observe a new history entry and update intelligence state.
-   * Call this after every message added to the session.
-   */
-  observe(entry) {
-    const intel = this.state;
-    if (!intel.userOriginalIntent && entry.role === "user" && entry.content.trim().length > 10) {
-      intel.userOriginalIntent = entry.content.slice(0, 500);
+  async getOrCreateAgentPath(agentId) {
+    if (!this.worktrees.has(agentId)) {
+      await this.createAgentWorktree(agentId);
     }
-    const files = extractFilePaths(entry.content);
-    for (const f of files) {
-      if (!intel.filesTouched.includes(f)) {
-        intel.filesTouched.push(f);
+    return this.worktrees.get(agentId);
+  }
+  async loadExistingWorktrees() {
+    const agentsDir = join(this.config.workspaceRoot, "agents");
+    if (!existsSync(agentsDir)) {
+      return;
+    }
+    try {
+      const { readdirSync, statSync } = await import('node:fs');
+      const entries = readdirSync(agentsDir);
+      for (const entry of entries) {
+        const entryPath = join(agentsDir, entry);
+        if (statSync(entryPath).isDirectory()) {
+          this.worktrees.set(entry, entryPath);
+          this.log(`Loaded existing worktree: ${entry}`);
+        }
       }
+    } catch {
     }
-    if (entry.role === "assistant" && /\b(bash|read|write|edit|grep|glob)\b/i.test(entry.content)) {
-      intel.toolCallCount++;
+  }
+  async batchCommit(agentId, message) {
+    const existing = this.pendingCommits.get(agentId);
+    if (existing) {
+      clearTimeout(existing);
     }
-    intel.taskPhase = detectTaskPhase(this.session.history);
+    return new Promise((resolve) => {
+      const timeout = setTimeout(async () => {
+        this.pendingCommits.delete(agentId);
+        const commitId = await this.commit(agentId, message);
+        resolve(commitId);
+      }, this.config.commitBatchInterval);
+      this.pendingCommits.set(agentId, timeout);
+    });
   }
-  /**
-   * Record a key decision explicitly.
-   */
-  recordDecision(decision) {
-    const intel = this.state;
-    if (!intel.keyDecisions.includes(decision)) {
-      intel.keyDecisions.push(decision.slice(0, 200));
-      if (intel.keyDecisions.length > 20) {
-        intel.keyDecisions.shift();
+  async commit(agentId, message) {
+    const agentPath = this.worktrees.get(agentId);
+    if (!agentPath) {
+      return "";
+    }
+    try {
+      await this.exec("git", ["add", "-A"], agentPath);
+      const statusResult = await this.exec("git", ["status", "--porcelain"], agentPath);
+      if (!statusResult.stdout.trim()) {
+        return "";
       }
+      await this.exec("git", ["commit", "-m", message], agentPath);
+      const result = await this.exec("git", ["rev-parse", "HEAD"], agentPath);
+      return result.stdout.trim();
+    } catch {
+      return "";
     }
   }
-  /**
-   * Mark that history up to index N has been compressed.
-   */
-  markCompressed(upToIndex) {
-    this.state.compressionWatermark = upToIndex;
+  async exec(cmd, args, cwd) {
+    const result = await K(cmd, args, { nodeOptions: { cwd } });
+    return {
+      stdout: result.stdout,
+      stderr: result.stderr
+    };
   }
-  /**
-   * Generate a system prompt injection that preserves intent across compaction.
-   * Inject this whenever context is about to be compressed.
-   */
-  getSystemPromptInjection() {
-    const intel = this.state;
-    const parts = ["<!-- session-intelligence -->"];
-    if (intel.userOriginalIntent) {
-      parts.push(`Original user intent: ${intel.userOriginalIntent}`);
-    }
-    if (intel.keyDecisions.length > 0) {
-      parts.push(`Key decisions: ${intel.keyDecisions.join("; ")}`);
-    }
-    if (intel.filesTouched.length > 0) {
-      parts.push(`Files touched: ${intel.filesTouched.slice(-20).join(", ")}`);
+  log(message) {
+    if (this.config.verbose) {
+      console.log(`[GitBackedState] ${message}`);
     }
-    parts.push(`Task phase: ${intel.taskPhase} | Tool calls: ${intel.toolCallCount}`);
-    parts.push("<!-- /session-intelligence -->");
-    return parts.join("\n");
   }
-  /**
-   * Returns true if the session has enough context to be worth preserving.
-   */
-  hasSignificantContext() {
-    const intel = this.state;
-    return !!intel.userOriginalIntent || intel.toolCallCount > 3 || intel.filesTouched.length > 0;
+}
+let globalStateManager = null;
+function getGlobalStateManager(config) {
+  if (!globalStateManager) {
+    globalStateManager = new GitBackedStateManager(config);
   }
+  return globalStateManager;
 }
 
-class GitBackedStateManager extends EventEmitter {
-  config;
-  worktrees = /* @__PURE__ */ new Map();
+const gitBackedState = {
+  __proto__: null,
+  GitBackedStateManager: GitBackedStateManager,
+  getGlobalStateManager: getGlobalStateManager
+};
+
+class ConvoyManager extends EventEmitter {
+  stateManager;
+  convoys = /* @__PURE__ */ new Map();
   initialized = false;
-  pendingCommits = /* @__PURE__ */ new Map();
-  constructor(config = {}) {
+  constructor(stateManager) {
     super();
-    this.config = {
-      workspaceRoot: config.workspaceRoot ?? join(homedir(), ".ccjk", "workspace"),
-      useWorktrees: config.useWorktrees ?? true,
-      autoCommit: config.autoCommit ?? true,
-      compressionLevel: config.compressionLevel ?? 6,
-      verbose: config.verbose ?? false,
-      commitBatchInterval: config.commitBatchInterval ?? 1e3
-    };
+    this.stateManager = stateManager ?? getGlobalStateManager();
   }
   /**
-   * Initialize the workspace with Git
+   * Initialize convoy manager
    */
   async initialize() {
     if (this.initialized)
       return;
-    const { workspaceRoot } = this.config;
-    try {
-      if (!existsSync(workspaceRoot)) {
-        mkdirSync(workspaceRoot, { recursive: true });
-        this.log(`Created workspace: ${workspaceRoot}`);
-      }
-      const gitDir = join(workspaceRoot, ".git");
-      if (!existsSync(gitDir)) {
-        await this.exec("git", ["init"], workspaceRoot);
-        this.log("Initialized Git repository");
-        const gitignore = `
-# Sensitive data
-*.env
-*.key
-*.pem
-credentials.json
-
-# Temporary files
-*.tmp
-*.log
-*.swp
-
-# OS files
-.DS_Store
-Thumbs.db
-`;
-        writeFileSync(join(workspaceRoot, ".gitignore"), gitignore.trim());
-        await this.exec("git", ["add", ".gitignore"], workspaceRoot);
-        await this.exec("git", ["commit", "-m", "Initial commit"], workspaceRoot);
-        this.log("Created initial commit");
-      }
-      const agentsDir = join(workspaceRoot, "agents");
-      if (!existsSync(agentsDir)) {
-        mkdirSync(agentsDir, { recursive: true });
-      }
-      await this.loadExistingWorktrees();
-      this.initialized = true;
-      this.emit("initialized");
-      this.log("GitBackedStateManager initialized");
-    } catch (error) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      this.emit("error", err);
-      throw err;
+    await this.stateManager.initialize();
+    await this.loadConvoys();
+    this.initialized = true;
+  }
+  /**
+   * Create new convoy
+   */
+  async create(name, options = {}) {
+    await this.ensureInitialized();
+    const convoy = {
+      id: `cv-${nanoid(6)}`,
+      name,
+      description: options.description ?? "",
+      tasks: [],
+      status: "pending",
+      progress: 0,
+      totalTasks: 0,
+      completedTasks: 0,
+      failedTasks: 0,
+      cancelledTasks: 0,
+      skippedTasks: 0,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      createdBy: options.createdBy ?? "system",
+      notifications: {
+        onComplete: options.notifyOnComplete ?? false,
+        onFailure: options.notifyOnFailure ?? true,
+        onProgress: options.notifyOnProgress ?? false,
+        notifyHuman: options.notifyHuman ?? false
+      },
+      metadata: options.metadata,
+      tags: options.tags ?? []
+    };
+    this.convoys.set(convoy.id, convoy);
+    await this.persistConvoy(convoy);
+    this.emit("convoy:created", convoy);
+    return convoy;
+  }
+  /**
+   * Add task to convoy
+   */
+  async addTask(convoyId, title, options = {}) {
+    await this.ensureInitialized();
+    const convoy = this.convoys.get(convoyId);
+    if (!convoy) {
+      throw new Error(`Convoy not found: ${convoyId}`);
+    }
+    const task = {
+      id: `task-${nanoid(6)}`,
+      title,
+      description: options.description ?? "",
+      status: "pending",
+      assignedTo: options.assignedTo,
+      dependsOn: options.dependsOn ?? [],
+      metadata: options.metadata
+    };
+    convoy.tasks.push(task);
+    convoy.totalTasks = convoy.tasks.length;
+    this.updateProgress(convoy);
+    await this.persistConvoy(convoy);
+    return task;
+  }
+  /**
+   * Add multiple tasks to convoy
+   */
+  async addTasks(convoyId, tasks) {
+    const addedTasks = [];
+    for (const { title, options } of tasks) {
+      const task = await this.addTask(convoyId, title, options);
+      addedTasks.push(task);
     }
+    return addedTasks;
   }
   /**
-   * Create isolated worktree for agent
+   * Start convoy execution
    */
-  async createAgentWorktree(agentId) {
+  async start(convoyId) {
     await this.ensureInitialized();
-    const { workspaceRoot, useWorktrees } = this.config;
-    if (this.worktrees.has(agentId)) {
-      return this.worktrees.get(agentId);
+    const convoy = this.convoys.get(convoyId);
+    if (!convoy) {
+      throw new Error(`Convoy not found: ${convoyId}`);
     }
-    const agentPath = join(workspaceRoot, "agents", agentId);
-    if (useWorktrees) {
-      const branchName = `agent/${agentId}`;
-      try {
-        await this.exec("git", ["checkout", "--orphan", branchName], workspaceRoot);
-        await this.exec("git", ["reset", "--hard"], workspaceRoot);
-        await this.exec("git", ["checkout", "main"], workspaceRoot).catch(() => {
-          return this.exec("git", ["checkout", "master"], workspaceRoot);
-        });
-        if (!existsSync(agentPath)) {
-          await this.exec("git", ["worktree", "add", agentPath, branchName], workspaceRoot);
-        }
-      } catch {
-        if (!existsSync(agentPath)) {
-          mkdirSync(agentPath, { recursive: true });
-        }
-      }
-    } else {
-      if (!existsSync(agentPath)) {
-        mkdirSync(agentPath, { recursive: true });
-      }
+    if (convoy.status !== "pending" && convoy.status !== "paused") {
+      throw new Error(`Cannot start convoy in status: ${convoy.status}`);
     }
-    const stateFile = join(agentPath, "state.json");
-    const mailboxFile = join(agentPath, "mailbox.json");
-    if (!existsSync(stateFile)) {
-      writeFileSync(stateFile, JSON.stringify({ agentId, createdAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2));
+    convoy.status = "in_progress";
+    convoy.startedAt = convoy.startedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+    await this.persistConvoy(convoy);
+    this.emit("convoy:started", convoy);
+  }
+  /**
+   * Start a task
+   */
+  async startTask(convoyId, taskId, assignedTo) {
+    await this.ensureInitialized();
+    const convoy = this.convoys.get(convoyId);
+    if (!convoy) {
+      throw new Error(`Convoy not found: ${convoyId}`);
     }
-    if (!existsSync(mailboxFile)) {
-      writeFileSync(mailboxFile, JSON.stringify({ inbox: [], outbox: [], archive: [] }, null, 2));
+    const task = convoy.tasks.find((t) => t.id === taskId);
+    if (!task) {
+      throw new Error(`Task not found: ${taskId}`);
     }
-    this.worktrees.set(agentId, agentPath);
-    this.emit("worktree:created", agentId, agentPath);
-    this.log(`Created worktree for agent: ${agentId}`);
-    return agentPath;
+    const unmetDeps = this.getUnmetDependencies(convoy, task);
+    if (unmetDeps.length > 0) {
+      throw new Error(`Task has unmet dependencies: ${unmetDeps.join(", ")}`);
+    }
+    task.status = "in_progress";
+    task.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    if (assignedTo) {
+      task.assignedTo = assignedTo;
+    }
+    if (convoy.status === "pending") {
+      convoy.status = "in_progress";
+      convoy.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    }
+    await this.persistConvoy(convoy);
+    this.emit("task:started", convoy, task);
   }
   /**
-   * Save agent state to Git
+   * Complete a task
    */
-  async saveState(agentId, state) {
+  async completeTask(convoyId, taskId, result) {
     await this.ensureInitialized();
-    const agentPath = await this.getOrCreateAgentPath(agentId);
-    const stateFile = join(agentPath, "state.json");
-    let existingState = {};
-    if (existsSync(stateFile)) {
-      try {
-        existingState = JSON.parse(readFileSync(stateFile, "utf-8"));
-      } catch {
-      }
+    const convoy = this.convoys.get(convoyId);
+    if (!convoy) {
+      throw new Error(`Convoy not found: ${convoyId}`);
     }
-    const newState = {
-      ...existingState,
-      ...state,
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    writeFileSync(stateFile, JSON.stringify(newState, null, 2));
-    let commitId = "";
-    if (this.config.autoCommit) {
-      commitId = await this.batchCommit(agentId, `Update state: ${agentId}`);
+    const task = convoy.tasks.find((t) => t.id === taskId);
+    if (!task) {
+      throw new Error(`Task not found: ${taskId}`);
+    }
+    task.status = "completed";
+    task.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    task.result = result;
+    convoy.completedTasks++;
+    this.updateProgress(convoy);
+    this.checkConvoyCompletion(convoy);
+    await this.persistConvoy(convoy);
+    this.emit("task:completed", convoy, task);
+    if (convoy.notifications.onProgress) {
+      this.emit("convoy:progress", convoy, convoy.progress);
     }
-    this.emit("state:saved", agentId, commitId);
-    this.log(`Saved state for agent: ${agentId}`);
-    return commitId;
   }
   /**
-   * Load agent state from Git
+   * Fail a task
    */
-  async loadState(agentId) {
+  async failTask(convoyId, taskId, error) {
     await this.ensureInitialized();
-    const agentPath = this.worktrees.get(agentId);
-    if (!agentPath) {
-      return null;
+    const convoy = this.convoys.get(convoyId);
+    if (!convoy) {
+      throw new Error(`Convoy not found: ${convoyId}`);
     }
-    const stateFile = join(agentPath, "state.json");
-    if (!existsSync(stateFile)) {
-      return null;
+    const task = convoy.tasks.find((t) => t.id === taskId);
+    if (!task) {
+      throw new Error(`Task not found: ${taskId}`);
     }
-    try {
-      const state = JSON.parse(readFileSync(stateFile, "utf-8"));
-      this.emit("state:loaded", agentId);
-      this.log(`Loaded state for agent: ${agentId}`);
-      return state;
-    } catch {
-      return null;
+    task.status = "failed";
+    task.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    task.error = error;
+    convoy.failedTasks++;
+    this.updateProgress(convoy);
+    await this.skipDependentTasks(convoy, taskId);
+    this.checkConvoyCompletion(convoy);
+    await this.persistConvoy(convoy);
+    this.emit("task:failed", convoy, task);
+    if (convoy.notifications.onFailure) {
+      this.emit("convoy:failed", convoy);
     }
   }
   /**
-   * Rollback to previous state
+   * Cancel a task
    */
-  async rollback(agentId, commitId) {
+  async cancelTask(convoyId, taskId) {
     await this.ensureInitialized();
-    const agentPath = this.worktrees.get(agentId);
-    if (!agentPath) {
-      throw new Error(`Agent not found: ${agentId}`);
+    const convoy = this.convoys.get(convoyId);
+    if (!convoy) {
+      throw new Error(`Convoy not found: ${convoyId}`);
     }
-    try {
-      await this.exec("git", ["reset", "--hard", commitId], agentPath);
-      this.emit("state:rolled-back", agentId, commitId);
-      this.log(`Rolled back agent ${agentId} to commit ${commitId}`);
-    } catch (error) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      this.emit("error", err);
-      throw err;
+    const task = convoy.tasks.find((t) => t.id === taskId);
+    if (!task) {
+      throw new Error(`Task not found: ${taskId}`);
     }
+    task.status = "cancelled";
+    task.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    convoy.cancelledTasks++;
+    this.updateProgress(convoy);
+    await this.skipDependentTasks(convoy, taskId);
+    this.checkConvoyCompletion(convoy);
+    await this.persistConvoy(convoy);
+    this.emit("task:cancelled", convoy, task);
   }
   /**
-   * Get state history for agent
+   * Pause convoy
    */
-  async getHistory(agentId, limit = 10) {
+  async pause(convoyId) {
     await this.ensureInitialized();
-    const agentPath = this.worktrees.get(agentId);
-    if (!agentPath) {
-      return [];
+    const convoy = this.convoys.get(convoyId);
+    if (!convoy) {
+      throw new Error(`Convoy not found: ${convoyId}`);
     }
-    try {
-      const result = await this.exec(
-        "git",
-        ["log", `--max-count=${limit}`, "--format=%H|%s|%ct", "--", "state.json"],
-        agentPath
-      );
-      const snapshots = [];
-      for (const line of result.stdout.split("\n").filter(Boolean)) {
-        const [commitId, message, timestamp] = line.split("|");
-        const stateResult = await this.exec(
-          "git",
-          ["show", `${commitId}:state.json`],
-          agentPath
-        ).catch(() => ({ stdout: "{}" }));
-        let state;
-        try {
-          state = JSON.parse(stateResult.stdout);
-        } catch {
-          state = {};
-        }
-        snapshots.push({
-          id: nanoid(),
-          agentId,
-          commitId,
-          timestamp: Number.parseInt(timestamp, 10) * 1e3,
-          message,
-          state
-        });
-      }
-      return snapshots;
-    } catch {
-      return [];
+    if (convoy.status !== "in_progress") {
+      throw new Error(`Cannot pause convoy in status: ${convoy.status}`);
     }
+    convoy.status = "paused";
+    await this.persistConvoy(convoy);
+    this.emit("convoy:paused", convoy);
   }
   /**
-   * Cleanup agent worktree
+   * Resume convoy
    */
-  async cleanup(agentId) {
+  async resume(convoyId) {
+    await this.ensureInitialized();
+    const convoy = this.convoys.get(convoyId);
+    if (!convoy) {
+      throw new Error(`Convoy not found: ${convoyId}`);
+    }
+    if (convoy.status !== "paused") {
+      throw new Error(`Cannot resume convoy in status: ${convoy.status}`);
+    }
+    convoy.status = "in_progress";
+    await this.persistConvoy(convoy);
+    this.emit("convoy:resumed", convoy);
+  }
+  /**
+   * Cancel convoy
+   */
+  async cancel(convoyId) {
     await this.ensureInitialized();
-    const agentPath = this.worktrees.get(agentId);
-    if (!agentPath) {
-      return;
+    const convoy = this.convoys.get(convoyId);
+    if (!convoy) {
+      throw new Error(`Convoy not found: ${convoyId}`);
     }
-    try {
-      if (this.config.useWorktrees) {
-        await this.exec("git", ["worktree", "remove", agentPath, "--force"], this.config.workspaceRoot);
+    convoy.status = "cancelled";
+    convoy.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    for (const task of convoy.tasks) {
+      if (task.status === "pending" || task.status === "in_progress") {
+        task.status = "cancelled";
+        task.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+        convoy.cancelledTasks++;
       }
-      this.worktrees.delete(agentId);
-      this.emit("worktree:removed", agentId);
-      this.log(`Cleaned up worktree for agent: ${agentId}`);
-    } catch (error) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      this.emit("error", err);
-      throw err;
     }
+    this.updateProgress(convoy);
+    await this.persistConvoy(convoy);
+    this.emit("convoy:cancelled", convoy);
   }
   /**
-   * Get all agent IDs
+   * Get convoy by ID
    */
-  getAgentIds() {
-    return Array.from(this.worktrees.keys());
+  get(convoyId) {
+    return this.convoys.get(convoyId);
   }
   /**
-   * Check if agent exists
+   * List all convoys
    */
-  hasAgent(agentId) {
-    return this.worktrees.has(agentId);
+  list(filter) {
+    let convoys = Array.from(this.convoys.values());
+    if (filter) {
+      if (filter.status) {
+        convoys = convoys.filter((c) => c.status === filter.status);
+      }
+      if (filter.createdBy) {
+        convoys = convoys.filter((c) => c.createdBy === filter.createdBy);
+      }
+      if (filter.tags && filter.tags.length > 0) {
+        convoys = convoys.filter(
+          (c) => filter.tags.some((tag) => c.tags.includes(tag))
+        );
+      }
+    }
+    return convoys.sort(
+      (a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
+    );
   }
   /**
-   * Get workspace root path
+   * Get active convoys
    */
-  getWorkspaceRoot() {
-    return this.config.workspaceRoot;
+  getActive() {
+    return this.list({ status: "in_progress" });
   }
   /**
-   * Get agent path
+   * Get next available tasks (no unmet dependencies)
    */
-  getAgentPath(agentId) {
-    return this.worktrees.get(agentId);
+  getNextTasks(convoyId) {
+    const convoy = this.convoys.get(convoyId);
+    if (!convoy)
+      return [];
+    return convoy.tasks.filter((task) => {
+      if (task.status !== "pending")
+        return false;
+      return this.getUnmetDependencies(convoy, task).length === 0;
+    });
   }
   /**
-   * Get state history for agent
+   * Get convoy summary
    */
-  async getStateHistory(agentId, limit = 20) {
-    await this.ensureInitialized();
-    const agentPath = this.worktrees.get(agentId);
-    if (!agentPath) {
-      return { agentId, commits: [], totalCommits: 0 };
-    }
-    try {
-      const result = await this.exec(
-        "git",
-        ["log", `--max-count=${limit}`, "--format=%H|%s|%ct", "--", "state.json"],
-        agentPath
-      );
-      const commits = result.stdout.split("\n").filter(Boolean).map((line) => {
-        const [id, message, timestamp] = line.split("|");
-        return {
-          id,
-          message,
-          timestamp: Number.parseInt(timestamp, 10) * 1e3
-        };
-      });
-      const countResult = await this.exec(
-        "git",
-        ["rev-list", "--count", "HEAD", "--", "state.json"],
-        agentPath
-      ).catch(() => ({ stdout: "0" }));
-      return {
-        agentId,
-        commits,
-        totalCommits: Number.parseInt(countResult.stdout.trim(), 10) || commits.length
-      };
-    } catch {
-      return { agentId, commits: [], totalCommits: 0 };
+  getSummary(convoyId) {
+    const convoy = this.convoys.get(convoyId);
+    if (!convoy)
+      return "Convoy not found";
+    const lines = [
+      `Convoy: ${convoy.name} (${convoy.id})`,
+      `Status: ${convoy.status}`,
+      `Progress: ${convoy.progress}%`,
+      `Tasks: ${convoy.completedTasks}/${convoy.totalTasks} completed`
+    ];
+    if (convoy.failedTasks > 0) {
+      lines.push(`Failed: ${convoy.failedTasks}`);
     }
-  }
-  /**
-   * Create a named snapshot of current state
-   */
-  async createSnapshot(agentId, description) {
-    await this.ensureInitialized();
-    const agentPath = this.worktrees.get(agentId);
-    if (!agentPath) {
-      throw new Error(`Agent not found: ${agentId}`);
+    if (convoy.cancelledTasks > 0) {
+      lines.push(`Cancelled: ${convoy.cancelledTasks}`);
     }
-    const commitId = await this.commit(agentId, `Snapshot: ${description}`);
-    if (!commitId) {
-      const result = await this.exec("git", ["rev-parse", "HEAD"], agentPath);
-      const currentCommitId = result.stdout.trim();
-      const state2 = await this.loadState(agentId);
-      return {
-        id: nanoid(),
-        agentId,
-        commitId: currentCommitId,
-        timestamp: Date.now(),
-        message: description,
-        state: state2 ?? {}
-      };
+    if (convoy.skippedTasks > 0) {
+      lines.push(`Skipped: ${convoy.skippedTasks}`);
     }
-    const state = await this.loadState(agentId);
-    return {
-      id: nanoid(),
-      agentId,
-      commitId,
-      timestamp: Date.now(),
-      message: description,
-      state: state ?? {}
-    };
-  }
-  /**
-   * Restore state from a snapshot
-   */
-  async restoreSnapshot(agentId, snapshotId) {
-    await this.rollback(agentId, snapshotId);
+    return lines.join("\n");
   }
   /**
-   * Sync with remote (if configured)
+   * Delete convoy
    */
-  async syncWithRemote() {
+  async delete(convoyId) {
     await this.ensureInitialized();
-    try {
-      const remoteResult = await this.exec("git", ["remote"], this.config.workspaceRoot);
-      if (!remoteResult.stdout.trim()) {
-        this.log("No remote configured, skipping sync");
-        return;
-      }
-      await this.exec("git", ["pull", "--rebase"], this.config.workspaceRoot);
-      await this.exec("git", ["push"], this.config.workspaceRoot);
-      this.log("Synced with remote");
-    } catch (error) {
-      this.log(`Sync failed: ${error}`);
-    }
+    const convoy = this.convoys.get(convoyId);
+    if (!convoy)
+      return false;
+    this.convoys.delete(convoyId);
+    return true;
   }
   // ========================================================================
   // Private Methods
@@ -833,505 +814,558 @@ Thumbs.db
       await this.initialize();
     }
   }
-  async getOrCreateAgentPath(agentId) {
-    if (!this.worktrees.has(agentId)) {
-      await this.createAgentWorktree(agentId);
-    }
-    return this.worktrees.get(agentId);
+  updateProgress(convoy) {
+    const processed = convoy.completedTasks + convoy.failedTasks + convoy.cancelledTasks + convoy.skippedTasks;
+    convoy.progress = convoy.totalTasks > 0 ? Math.round(processed / convoy.totalTasks * 100) : 0;
   }
-  async loadExistingWorktrees() {
-    const agentsDir = join(this.config.workspaceRoot, "agents");
-    if (!existsSync(agentsDir)) {
-      return;
-    }
-    try {
-      const { readdirSync, statSync } = await import('node:fs');
-      const entries = readdirSync(agentsDir);
-      for (const entry of entries) {
-        const entryPath = join(agentsDir, entry);
-        if (statSync(entryPath).isDirectory()) {
-          this.worktrees.set(entry, entryPath);
-          this.log(`Loaded existing worktree: ${entry}`);
+  checkConvoyCompletion(convoy) {
+    const processed = convoy.completedTasks + convoy.failedTasks + convoy.cancelledTasks + convoy.skippedTasks;
+    if (processed === convoy.totalTasks) {
+      convoy.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      if (convoy.failedTasks === 0 && convoy.cancelledTasks === 0) {
+        convoy.status = "completed";
+        if (convoy.notifications.onComplete) {
+          this.emit("convoy:completed", convoy);
+        }
+      } else {
+        convoy.status = "failed";
+        if (convoy.notifications.onFailure) {
+          this.emit("convoy:failed", convoy);
         }
       }
-    } catch {
     }
   }
-  async batchCommit(agentId, message) {
-    const existing = this.pendingCommits.get(agentId);
-    if (existing) {
-      clearTimeout(existing);
-    }
-    return new Promise((resolve) => {
-      const timeout = setTimeout(async () => {
-        this.pendingCommits.delete(agentId);
-        const commitId = await this.commit(agentId, message);
-        resolve(commitId);
-      }, this.config.commitBatchInterval);
-      this.pendingCommits.set(agentId, timeout);
+  getUnmetDependencies(convoy, task) {
+    return task.dependsOn.filter((depId) => {
+      const depTask = convoy.tasks.find((t) => t.id === depId);
+      return !depTask || depTask.status !== "completed";
     });
   }
-  async commit(agentId, message) {
-    const agentPath = this.worktrees.get(agentId);
-    if (!agentPath) {
-      return "";
-    }
-    try {
-      await this.exec("git", ["add", "-A"], agentPath);
-      const statusResult = await this.exec("git", ["status", "--porcelain"], agentPath);
-      if (!statusResult.stdout.trim()) {
-        return "";
-      }
-      await this.exec("git", ["commit", "-m", message], agentPath);
-      const result = await this.exec("git", ["rev-parse", "HEAD"], agentPath);
-      return result.stdout.trim();
-    } catch {
-      return "";
+  async skipDependentTasks(convoy, failedTaskId) {
+    for (const task of convoy.tasks) {
+      if (task.status === "pending" && task.dependsOn.includes(failedTaskId)) {
+        task.status = "skipped";
+        task.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+        task.error = `Skipped due to failed dependency: ${failedTaskId}`;
+        convoy.skippedTasks++;
+        this.emit("task:skipped", convoy, task);
+        await this.skipDependentTasks(convoy, task.id);
+      }
     }
   }
-  async exec(cmd, args, cwd) {
-    const result = await K(cmd, args, { nodeOptions: { cwd } });
-    return {
-      stdout: result.stdout,
-      stderr: result.stderr
-    };
-  }
-  log(message) {
-    if (this.config.verbose) {
-      console.log(`[GitBackedState] ${message}`);
+  async loadConvoys() {
+    for (const agentId of this.stateManager.getAgentIds()) {
+      if (agentId.startsWith("convoy-")) {
+        const state = await this.stateManager.loadState(agentId);
+        if (state) {
+          const convoy = state;
+          this.convoys.set(convoy.id, convoy);
+        }
+      }
     }
   }
+  async persistConvoy(convoy) {
+    await this.stateManager.createAgentWorktree(`convoy-${convoy.id}`);
+    await this.stateManager.saveState(`convoy-${convoy.id}`, convoy);
+  }
 }
-let globalStateManager = null;
-function getGlobalStateManager(config) {
-  if (!globalStateManager) {
-    globalStateManager = new GitBackedStateManager(config);
+let globalConvoyManager = null;
+function getGlobalConvoyManager() {
+  if (!globalConvoyManager) {
+    globalConvoyManager = new ConvoyManager();
   }
-  return globalStateManager;
+  return globalConvoyManager;
 }
 
-const gitBackedState = {
+const convoyManager = {
   __proto__: null,
-  GitBackedStateManager: GitBackedStateManager,
-  getGlobalStateManager: getGlobalStateManager
+  ConvoyManager: ConvoyManager,
+  getGlobalConvoyManager: getGlobalConvoyManager
 };
 
-class ConvoyManager extends EventEmitter {
-  stateManager;
-  convoys = /* @__PURE__ */ new Map();
-  initialized = false;
-  constructor(stateManager) {
-    super();
-    this.stateManager = stateManager ?? getGlobalStateManager();
-  }
-  /**
-   * Initialize convoy manager
-   */
-  async initialize() {
-    if (this.initialized)
-      return;
-    await this.stateManager.initialize();
-    await this.loadConvoys();
-    this.initialized = true;
+const DEPTH_TOKEN_BUDGETS = {
+  L0: 100,
+  // Abstract summary only
+  L1: 2e3,
+  // Overview
+  L2: Number.POSITIVE_INFINITY
+  // Full content
+};
+const PHASE_BUDGET_MULTIPLIERS = {
+  exploring: 2,
+  executing: 0.6,
+  generating: 0.4,
+  reviewing: 1.2,
+  idle: 1
+};
+const CHARS_PER_TOKEN = 4;
+function estimateTokens(text) {
+  return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+function truncateToDepth(content, depth) {
+  if (depth === "L2")
+    return content;
+  const maxChars = DEPTH_TOKEN_BUDGETS[depth] * CHARS_PER_TOKEN;
+  if (content.length <= maxChars)
+    return content;
+  if (depth === "L0") {
+    const firstPara = content.split(/\n\n/)[0];
+    return firstPara.length <= maxChars ? firstPara : content.slice(0, maxChars);
   }
+  return `${content.slice(0, maxChars)}
+... (truncated, use L2 for full content)`;
+}
+class ContextLoader {
+  cache = /* @__PURE__ */ new Map();
+  defaultMaxSize = 1e5;
+  // 100KB default
+  defaultTokenBudget = 8e3;
+  // ~32KB at 4 chars/token
   /**
-   * Create new convoy
+   * Resolve effective depth from options.
+   * If depth is explicit, use it. Otherwise derive from tokenBudget.
    */
-  async create(name, options = {}) {
-    await this.ensureInitialized();
-    const convoy = {
-      id: `cv-${nanoid(6)}`,
-      name,
-      description: options.description ?? "",
-      tasks: [],
-      status: "pending",
-      progress: 0,
-      totalTasks: 0,
-      completedTasks: 0,
-      failedTasks: 0,
-      cancelledTasks: 0,
-      skippedTasks: 0,
-      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-      createdBy: options.createdBy ?? "system",
-      notifications: {
-        onComplete: options.notifyOnComplete ?? false,
-        onFailure: options.notifyOnFailure ?? true,
-        onProgress: options.notifyOnProgress ?? false,
-        notifyHuman: options.notifyHuman ?? false
-      },
-      metadata: options.metadata,
-      tags: options.tags ?? []
-    };
-    this.convoys.set(convoy.id, convoy);
-    await this.persistConvoy(convoy);
-    this.emit("convoy:created", convoy);
-    return convoy;
+  resolveDepth(tokenBudget, explicitDepth) {
+    if (explicitDepth)
+      return explicitDepth;
+    if (tokenBudget <= DEPTH_TOKEN_BUDGETS.L0)
+      return "L0";
+    if (tokenBudget <= DEPTH_TOKEN_BUDGETS.L1)
+      return "L1";
+    return "L2";
   }
   /**
-   * Add task to convoy
+   * Load context hierarchically with OpenViking-style tiered depth control.
+   * Pass tokenBudget to automatically select L0/L1/L2 depth.
    */
-  async addTask(convoyId, title, options = {}) {
-    await this.ensureInitialized();
-    const convoy = this.convoys.get(convoyId);
-    if (!convoy) {
-      throw new Error(`Convoy not found: ${convoyId}`);
+  async load(options = {}) {
+    const {
+      projectRoot = process.cwd(),
+      maxSize = this.defaultMaxSize,
+      tokenBudget,
+      depth: explicitDepth,
+      layers = ["project", "domain", "task", "execution"],
+      task
+    } = options;
+    const phaseMultiplier = options.taskPhase ? PHASE_BUDGET_MULTIPLIERS[options.taskPhase] ?? 1 : 1;
+    const effectiveBudget = Math.round((tokenBudget ?? this.defaultTokenBudget) * phaseMultiplier);
+    const depth = this.resolveDepth(effectiveBudget, explicitDepth);
+    const cacheKey = this.getCacheKey(projectRoot, layers, task?.id, depth);
+    const cached = this.cache.get(cacheKey);
+    if (cached && Date.now() - cached.loadedAt < 6e4) {
+      executionTracer.logEvent("context-load", {
+        source: "cache",
+        layers: layers.length,
+        size: cached.totalSize,
+        tokens: cached.totalTokens,
+        depth
+      });
+      return cached;
     }
-    const task = {
-      id: `task-${nanoid(6)}`,
-      title,
-      description: options.description ?? "",
-      status: "pending",
-      assignedTo: options.assignedTo,
-      dependsOn: options.dependsOn ?? [],
-      metadata: options.metadata
+    const context = {
+      layers: /* @__PURE__ */ new Map(),
+      totalSize: 0,
+      totalTokens: 0,
+      loadedAt: Date.now(),
+      depth
     };
-    convoy.tasks.push(task);
-    convoy.totalTasks = convoy.tasks.length;
-    this.updateProgress(convoy);
-    await this.persistConvoy(convoy);
-    return task;
-  }
-  /**
-   * Add multiple tasks to convoy
-   */
-  async addTasks(convoyId, tasks) {
-    const addedTasks = [];
-    for (const { title, options } of tasks) {
-      const task = await this.addTask(convoyId, title, options);
-      addedTasks.push(task);
-    }
-    return addedTasks;
-  }
-  /**
-   * Start convoy execution
-   */
-  async start(convoyId) {
-    await this.ensureInitialized();
-    const convoy = this.convoys.get(convoyId);
-    if (!convoy) {
-      throw new Error(`Convoy not found: ${convoyId}`);
-    }
-    if (convoy.status !== "pending" && convoy.status !== "paused") {
-      throw new Error(`Cannot start convoy in status: ${convoy.status}`);
+    for (const layer of layers) {
+      const entries = await this.loadLayer(layer, projectRoot, task, depth);
+      if (entries.length > 0) {
+        context.layers.set(layer, entries);
+        context.totalSize += entries.reduce((sum, e) => sum + e.content.length, 0);
+        context.totalTokens += entries.reduce((sum, e) => sum + e.tokenEstimate, 0);
+      }
+      if (context.totalSize > maxSize || context.totalTokens > effectiveBudget) {
+        break;
+      }
     }
-    convoy.status = "in_progress";
-    convoy.startedAt = convoy.startedAt ?? (/* @__PURE__ */ new Date()).toISOString();
-    await this.persistConvoy(convoy);
-    this.emit("convoy:started", convoy);
+    this.cache.set(cacheKey, context);
+    executionTracer.logEvent("context-load", {
+      source: "fresh",
+      layers: context.layers.size,
+      size: context.totalSize,
+      tokens: context.totalTokens,
+      depth
+    });
+    return context;
   }
   /**
-   * Start a task
+   * Load a specific context layer
    */
-  async startTask(convoyId, taskId, assignedTo) {
-    await this.ensureInitialized();
-    const convoy = this.convoys.get(convoyId);
-    if (!convoy) {
-      throw new Error(`Convoy not found: ${convoyId}`);
-    }
-    const task = convoy.tasks.find((t) => t.id === taskId);
-    if (!task) {
-      throw new Error(`Task not found: ${taskId}`);
-    }
-    const unmetDeps = this.getUnmetDependencies(convoy, task);
-    if (unmetDeps.length > 0) {
-      throw new Error(`Task has unmet dependencies: ${unmetDeps.join(", ")}`);
-    }
-    task.status = "in_progress";
-    task.startedAt = (/* @__PURE__ */ new Date()).toISOString();
-    if (assignedTo) {
-      task.assignedTo = assignedTo;
-    }
-    if (convoy.status === "pending") {
-      convoy.status = "in_progress";
-      convoy.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  async loadLayer(layer, projectRoot, task, depth = "L2") {
+    switch (layer) {
+      case "project":
+        return this.loadProjectContext(projectRoot, depth);
+      case "domain":
+        return this.loadDomainContext(projectRoot, task, depth);
+      case "task":
+        return this.loadTaskContext(task, depth);
+      case "execution":
+        return this.loadExecutionContext(task, depth);
+      default:
+        return [];
     }
-    await this.persistConvoy(convoy);
-    this.emit("task:started", convoy, task);
   }
   /**
-   * Complete a task
+   * Load project-level context
+   * - README.md
+   * - CLAUDE.md
+   * - package.json
+   * - tsconfig.json
    */
-  async completeTask(convoyId, taskId, result) {
-    await this.ensureInitialized();
-    const convoy = this.convoys.get(convoyId);
-    if (!convoy) {
-      throw new Error(`Convoy not found: ${convoyId}`);
-    }
-    const task = convoy.tasks.find((t) => t.id === taskId);
-    if (!task) {
-      throw new Error(`Task not found: ${taskId}`);
-    }
-    task.status = "completed";
-    task.completedAt = (/* @__PURE__ */ new Date()).toISOString();
-    task.result = result;
-    convoy.completedTasks++;
-    this.updateProgress(convoy);
-    this.checkConvoyCompletion(convoy);
-    await this.persistConvoy(convoy);
-    this.emit("task:completed", convoy, task);
-    if (convoy.notifications.onProgress) {
-      this.emit("convoy:progress", convoy, convoy.progress);
+  async loadProjectContext(projectRoot, depth = "L2") {
+    const entries = [];
+    const files = ["README.md", "CLAUDE.md", "package.json", "tsconfig.json"];
+    for (const file of files) {
+      const path = join(projectRoot, file);
+      if (existsSync(path)) {
+        const raw = readFileSync(path, "utf-8");
+        const content = truncateToDepth(raw, depth);
+        entries.push({
+          layer: "project",
+          source: file,
+          content,
+          priority: 100,
+          depth,
+          tokenEstimate: estimateTokens(content),
+          metadata: { path }
+        });
+      }
     }
+    return entries;
   }
   /**
-   * Fail a task
+   * Load domain-specific context
+   * Based on task type/domain, load relevant files
    */
-  async failTask(convoyId, taskId, error) {
-    await this.ensureInitialized();
-    const convoy = this.convoys.get(convoyId);
-    if (!convoy) {
-      throw new Error(`Convoy not found: ${convoyId}`);
-    }
-    const task = convoy.tasks.find((t) => t.id === taskId);
-    if (!task) {
-      throw new Error(`Task not found: ${taskId}`);
+  async loadDomainContext(projectRoot, task, depth = "L2") {
+    if (!task)
+      return [];
+    const entries = [];
+    const structure = await fsParadigm.detect(projectRoot);
+    const domain = this.inferDomain(task);
+    if (!domain) {
+      const sourceFiles = fsParadigm.getFilesByRole(structure, "source");
+      for (const file of sourceFiles.slice(0, 3)) {
+        try {
+          const raw = readFileSync(file, "utf-8");
+          const content = truncateToDepth(raw, depth);
+          entries.push({
+            layer: "domain",
+            source: file.replace(projectRoot, ""),
+            content,
+            priority: 75,
+            depth,
+            tokenEstimate: estimateTokens(content),
+            metadata: { paradigm: structure.paradigm, path: file }
+          });
+        } catch {
+        }
+      }
+      return entries;
     }
-    task.status = "failed";
-    task.completedAt = (/* @__PURE__ */ new Date()).toISOString();
-    task.error = error;
-    convoy.failedTasks++;
-    this.updateProgress(convoy);
-    await this.skipDependentTasks(convoy, taskId);
-    this.checkConvoyCompletion(convoy);
-    await this.persistConvoy(convoy);
-    this.emit("task:failed", convoy, task);
-    if (convoy.notifications.onFailure) {
-      this.emit("convoy:failed", convoy);
+    const patterns = this.getDomainPatterns(domain, structure.paradigm);
+    for (const pattern of patterns) {
+      const files = await glob([pattern], {
+        cwd: projectRoot,
+        absolute: true,
+        ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**"]
+      });
+      for (const file of files.slice(0, 5)) {
+        try {
+          const raw = readFileSync(file, "utf-8");
+          const content = truncateToDepth(raw, depth);
+          entries.push({
+            layer: "domain",
+            source: file.replace(projectRoot, ""),
+            content,
+            priority: 80,
+            depth,
+            tokenEstimate: estimateTokens(content),
+            metadata: { domain, paradigm: structure.paradigm, path: file }
+          });
+        } catch {
+        }
+      }
     }
+    return entries;
   }
   /**
-   * Cancel a task
+   * Load task-specific context
    */
-  async cancelTask(convoyId, taskId) {
-    await this.ensureInitialized();
-    const convoy = this.convoys.get(convoyId);
-    if (!convoy) {
-      throw new Error(`Convoy not found: ${convoyId}`);
+  async loadTaskContext(task, depth = "L2") {
+    if (!task)
+      return [];
+    const entries = [];
+    if (task.description) {
+      const content = truncateToDepth(task.description, depth);
+      entries.push({
+        layer: "task",
+        source: "task-description",
+        content,
+        priority: 90,
+        depth,
+        tokenEstimate: estimateTokens(content),
+        metadata: { taskId: task.id }
+      });
     }
-    const task = convoy.tasks.find((t) => t.id === taskId);
-    if (!task) {
-      throw new Error(`Task not found: ${taskId}`);
+    if (task.input && depth !== "L0") {
+      const content = truncateToDepth(JSON.stringify(task.input, null, 2), depth);
+      entries.push({
+        layer: "task",
+        source: "task-input",
+        content,
+        priority: 85,
+        depth,
+        tokenEstimate: estimateTokens(content),
+        metadata: { taskId: task.id }
+      });
     }
-    task.status = "cancelled";
-    task.completedAt = (/* @__PURE__ */ new Date()).toISOString();
-    convoy.cancelledTasks++;
-    this.updateProgress(convoy);
-    await this.skipDependentTasks(convoy, taskId);
-    this.checkConvoyCompletion(convoy);
-    await this.persistConvoy(convoy);
-    this.emit("task:cancelled", convoy, task);
+    return entries;
   }
   /**
-   * Pause convoy
+   * Load execution-specific context
+   * - Recent errors
+   * - Previous attempts
+   * - Related task outputs
    */
-  async pause(convoyId) {
-    await this.ensureInitialized();
-    const convoy = this.convoys.get(convoyId);
-    if (!convoy) {
-      throw new Error(`Convoy not found: ${convoyId}`);
-    }
-    if (convoy.status !== "in_progress") {
-      throw new Error(`Cannot pause convoy in status: ${convoy.status}`);
+  async loadExecutionContext(task, depth = "L2") {
+    if (!task)
+      return [];
+    const entries = [];
+    if (task.output && depth !== "L0") {
+      const content = truncateToDepth(JSON.stringify(task.output, null, 2), depth);
+      entries.push({
+        layer: "execution",
+        source: "previous-output",
+        content,
+        priority: 70,
+        depth,
+        tokenEstimate: estimateTokens(content),
+        metadata: { taskId: task.id }
+      });
     }
-    convoy.status = "paused";
-    await this.persistConvoy(convoy);
-    this.emit("convoy:paused", convoy);
+    return entries;
   }
   /**
-   * Resume convoy
+   * Infer domain from task
    */
-  async resume(convoyId) {
-    await this.ensureInitialized();
-    const convoy = this.convoys.get(convoyId);
-    if (!convoy) {
-      throw new Error(`Convoy not found: ${convoyId}`);
-    }
-    if (convoy.status !== "paused") {
-      throw new Error(`Cannot resume convoy in status: ${convoy.status}`);
+  inferDomain(task) {
+    const text = `${task.name} ${task.description || ""}`.toLowerCase();
+    const domains = {
+      api: ["api", "endpoint", "route", "controller"],
+      ui: ["ui", "component", "view", "page", "frontend"],
+      database: ["database", "db", "schema", "migration", "model"],
+      auth: ["auth", "login", "user", "permission", "session"],
+      test: ["test", "spec", "e2e", "unit", "integration"],
+      config: ["config", "settings", "env", "setup"]
+    };
+    for (const [domain, keywords] of Object.entries(domains)) {
+      if (keywords.some((kw) => text.includes(kw))) {
+        return domain;
+      }
     }
-    convoy.status = "in_progress";
-    await this.persistConvoy(convoy);
-    this.emit("convoy:resumed", convoy);
+    return null;
   }
   /**
-   * Cancel convoy
+   * Get file patterns for a domain (paradigm-aware)
    */
-  async cancel(convoyId) {
-    await this.ensureInitialized();
-    const convoy = this.convoys.get(convoyId);
-    if (!convoy) {
-      throw new Error(`Convoy not found: ${convoyId}`);
-    }
-    convoy.status = "cancelled";
-    convoy.completedAt = (/* @__PURE__ */ new Date()).toISOString();
-    for (const task of convoy.tasks) {
-      if (task.status === "pending" || task.status === "in_progress") {
-        task.status = "cancelled";
-        task.completedAt = (/* @__PURE__ */ new Date()).toISOString();
-        convoy.cancelledTasks++;
+  getDomainPatterns(domain, paradigm) {
+    const basePatterns = {
+      api: ["**/api/**/*.ts", "**/routes/**/*.ts", "**/controllers/**/*.ts"],
+      ui: ["**/components/**/*.{tsx,vue}", "**/pages/**/*.{tsx,vue}", "**/views/**/*.{tsx,vue}"],
+      database: ["**/models/**/*.ts", "**/schema/**/*.ts", "**/migrations/**/*.ts"],
+      auth: ["**/auth/**/*.ts", "**/middleware/auth*.ts"],
+      test: ["**/*.test.ts", "**/*.spec.ts"],
+      config: ["**/config/**/*.ts", "**/*.config.ts"]
+    };
+    let patterns = basePatterns[domain] || [];
+    if (paradigm === "monorepo") {
+      patterns = patterns.map((p) => `packages/*/${p}`);
+    } else if (paradigm === "fullstack") {
+      if (domain === "ui") {
+        patterns = patterns.map((p) => `client/${p}`);
+      } else if (domain === "api") {
+        patterns = patterns.map((p) => `server/${p}`);
       }
     }
-    this.updateProgress(convoy);
-    await this.persistConvoy(convoy);
-    this.emit("convoy:cancelled", convoy);
+    return patterns;
   }
   /**
-   * Get convoy by ID
+   * Get cache key
    */
-  get(convoyId) {
-    return this.convoys.get(convoyId);
+  getCacheKey(projectRoot, layers, taskId, depth = "L2") {
+    return `${projectRoot}:${layers.join(",")}:${taskId || "none"}:${depth}`;
   }
   /**
-   * List all convoys
+   * Clear cache
    */
-  list(filter) {
-    let convoys = Array.from(this.convoys.values());
-    if (filter) {
-      if (filter.status) {
-        convoys = convoys.filter((c) => c.status === filter.status);
-      }
-      if (filter.createdBy) {
-        convoys = convoys.filter((c) => c.createdBy === filter.createdBy);
-      }
-      if (filter.tags && filter.tags.length > 0) {
-        convoys = convoys.filter(
-          (c) => filter.tags.some((tag) => c.tags.includes(tag))
-        );
-      }
-    }
-    return convoys.sort(
-      (a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
-    );
+  clearCache() {
+    this.cache.clear();
   }
   /**
-   * Get active convoys
+   * Format context for LLM consumption
    */
-  getActive() {
-    return this.list({ status: "in_progress" });
+  formatForLLM(context) {
+    const sections = [];
+    sections.push(`<!-- context depth=${context.depth} tokens\u2248${context.totalTokens} -->
+`);
+    const layerOrder = ["project", "domain", "task", "execution"];
+    for (const layer of layerOrder) {
+      const entries = context.layers.get(layer);
+      if (!entries || entries.length === 0)
+        continue;
+      sections.push(`# ${layer.toUpperCase()} CONTEXT
+`);
+      const sorted = entries.sort((a, b) => b.priority - a.priority);
+      for (const entry of sorted) {
+        sections.push(`## ${entry.source} [${entry.depth}]
+`);
+        sections.push(entry.content);
+        sections.push("\n");
+      }
+    }
+    return sections.join("\n");
   }
-  /**
-   * Get next available tasks (no unmet dependencies)
-   */
-  getNextTasks(convoyId) {
-    const convoy = this.convoys.get(convoyId);
-    if (!convoy)
-      return [];
-    return convoy.tasks.filter((task) => {
-      if (task.status !== "pending")
-        return false;
-      return this.getUnmetDependencies(convoy, task).length === 0;
-    });
+}
+const contextLoader = new ContextLoader();
+async function loadContextAtDepth(depth, options = {}) {
+  return contextLoader.load({ ...options, depth });
+}
+
+const contextLoader$1 = {
+  __proto__: null,
+  ContextLoader: ContextLoader,
+  contextLoader: contextLoader,
+  loadContextAtDepth: loadContextAtDepth
+};
+
+function detectTaskPhase(history) {
+  if (history.length === 0)
+    return "idle";
+  const recent = history.slice(-10);
+  const recentText = recent.map((h) => h.content).join(" ").toLowerCase();
+  if (recentText.includes("write") || recentText.includes("create") || recentText.includes("generating"))
+    return "generating";
+  if (recentText.includes("test") || recentText.includes("review") || recentText.includes("check"))
+    return "reviewing";
+  if (recentText.includes("edit") || recentText.includes("bash") || recentText.includes("run"))
+    return "executing";
+  if (recentText.includes("read") || recentText.includes("search") || recentText.includes("grep"))
+    return "exploring";
+  return "idle";
+}
+function extractFilePaths(content) {
+  const matches = content.match(/\/[\w./\-]+\.\w+|[\w./\-]+\.(?:ts|js|json|md|py|go|rs)/g);
+  return matches ? [...new Set(matches)] : [];
+}
+class SessionIntelligence {
+  static instance = null;
+  session;
+  constructor(session) {
+    this.session = session;
+    if (!session.intelligence) {
+      session.intelligence = {
+        taskPhase: "idle",
+        filesTouched: [],
+        keyDecisions: [],
+        toolCallCount: 0,
+        compressionWatermark: 0
+      };
+    }
+  }
+  get state() {
+    return this.session.intelligence;
   }
   /**
-   * Get convoy summary
+   * Observe a new history entry and update intelligence state.
+   * Call this after every message added to the session.
    */
-  getSummary(convoyId) {
-    const convoy = this.convoys.get(convoyId);
-    if (!convoy)
-      return "Convoy not found";
-    const lines = [
-      `Convoy: ${convoy.name} (${convoy.id})`,
-      `Status: ${convoy.status}`,
-      `Progress: ${convoy.progress}%`,
-      `Tasks: ${convoy.completedTasks}/${convoy.totalTasks} completed`
-    ];
-    if (convoy.failedTasks > 0) {
-      lines.push(`Failed: ${convoy.failedTasks}`);
+  observe(entry) {
+    const intel = this.state;
+    if (!intel.userOriginalIntent && entry.role === "user" && entry.content.trim().length > 10) {
+      intel.userOriginalIntent = entry.content.slice(0, 500);
     }
-    if (convoy.cancelledTasks > 0) {
-      lines.push(`Cancelled: ${convoy.cancelledTasks}`);
+    const files = extractFilePaths(entry.content);
+    for (const f of files) {
+      if (!intel.filesTouched.includes(f)) {
+        intel.filesTouched.push(f);
+      }
     }
-    if (convoy.skippedTasks > 0) {
-      lines.push(`Skipped: ${convoy.skippedTasks}`);
+    if (entry.role === "assistant" && /\b(bash|read|write|edit|grep|glob)\b/i.test(entry.content)) {
+      intel.toolCallCount++;
     }
-    return lines.join("\n");
+    intel.taskPhase = detectTaskPhase(this.session.history);
   }
   /**
-   * Delete convoy
+   * Record a key decision explicitly.
    */
-  async delete(convoyId) {
-    await this.ensureInitialized();
-    const convoy = this.convoys.get(convoyId);
-    if (!convoy)
-      return false;
-    this.convoys.delete(convoyId);
-    return true;
-  }
-  // ========================================================================
-  // Private Methods
-  // ========================================================================
-  async ensureInitialized() {
-    if (!this.initialized) {
-      await this.initialize();
-    }
-  }
-  updateProgress(convoy) {
-    const processed = convoy.completedTasks + convoy.failedTasks + convoy.cancelledTasks + convoy.skippedTasks;
-    convoy.progress = convoy.totalTasks > 0 ? Math.round(processed / convoy.totalTasks * 100) : 0;
-  }
-  checkConvoyCompletion(convoy) {
-    const processed = convoy.completedTasks + convoy.failedTasks + convoy.cancelledTasks + convoy.skippedTasks;
-    if (processed === convoy.totalTasks) {
-      convoy.completedAt = (/* @__PURE__ */ new Date()).toISOString();
-      if (convoy.failedTasks === 0 && convoy.cancelledTasks === 0) {
-        convoy.status = "completed";
-        if (convoy.notifications.onComplete) {
-          this.emit("convoy:completed", convoy);
-        }
-      } else {
-        convoy.status = "failed";
-        if (convoy.notifications.onFailure) {
-          this.emit("convoy:failed", convoy);
-        }
+  recordDecision(decision) {
+    const intel = this.state;
+    if (!intel.keyDecisions.includes(decision)) {
+      intel.keyDecisions.push(decision.slice(0, 200));
+      if (intel.keyDecisions.length > 20) {
+        intel.keyDecisions.shift();
       }
     }
   }
-  getUnmetDependencies(convoy, task) {
-    return task.dependsOn.filter((depId) => {
-      const depTask = convoy.tasks.find((t) => t.id === depId);
-      return !depTask || depTask.status !== "completed";
-    });
+  /**
+   * Mark that history up to index N has been compressed.
+   */
+  markCompressed(upToIndex) {
+    this.state.compressionWatermark = upToIndex;
   }
-  async skipDependentTasks(convoy, failedTaskId) {
-    for (const task of convoy.tasks) {
-      if (task.status === "pending" && task.dependsOn.includes(failedTaskId)) {
-        task.status = "skipped";
-        task.completedAt = (/* @__PURE__ */ new Date()).toISOString();
-        task.error = `Skipped due to failed dependency: ${failedTaskId}`;
-        convoy.skippedTasks++;
-        this.emit("task:skipped", convoy, task);
-        await this.skipDependentTasks(convoy, task.id);
-      }
+  /**
+   * Generate a system prompt injection that preserves intent across compaction.
+   * Inject this whenever context is about to be compressed.
+   */
+  getSystemPromptInjection() {
+    const intel = this.state;
+    const parts = ["<!-- session-intelligence -->"];
+    if (intel.userOriginalIntent) {
+      parts.push(`Original user intent: ${intel.userOriginalIntent}`);
+    }
+    if (intel.keyDecisions.length > 0) {
+      parts.push(`Key decisions: ${intel.keyDecisions.join("; ")}`);
+    }
+    if (intel.filesTouched.length > 0) {
+      parts.push(`Files touched: ${intel.filesTouched.slice(-20).join(", ")}`);
     }
+    parts.push(`Task phase: ${intel.taskPhase} | Tool calls: ${intel.toolCallCount}`);
+    parts.push("<!-- /session-intelligence -->");
+    return parts.join("\n");
   }
-  async loadConvoys() {
-    for (const agentId of this.stateManager.getAgentIds()) {
-      if (agentId.startsWith("convoy-")) {
-        const state = await this.stateManager.loadState(agentId);
-        if (state) {
-          const convoy = state;
-          this.convoys.set(convoy.id, convoy);
-        }
-      }
+  /**
+   * Returns true if the session has enough context to be worth preserving.
+   */
+  hasSignificantContext() {
+    const intel = this.state;
+    return !!intel.userOriginalIntent || intel.toolCallCount > 3 || intel.filesTouched.length > 0;
+  }
+  static getInstance() {
+    if (!SessionIntelligence.instance) {
+      SessionIntelligence.instance = new SessionIntelligence({
+        id: "session-intelligence-singleton",
+        createdAt: /* @__PURE__ */ new Date(),
+        lastUsedAt: /* @__PURE__ */ new Date(),
+        history: []
+      });
     }
+    return SessionIntelligence.instance;
   }
-  async persistConvoy(convoy) {
-    await this.stateManager.createAgentWorktree(`convoy-${convoy.id}`);
-    await this.stateManager.saveState(`convoy-${convoy.id}`, convoy);
+  recordMessage(role, content) {
+    const entry = {
+      timestamp: /* @__PURE__ */ new Date(),
+      role,
+      content
+    };
+    this.session.history.push(entry);
+    this.observe(entry);
   }
-}
-let globalConvoyManager = null;
-function getGlobalConvoyManager() {
-  if (!globalConvoyManager) {
-    globalConvoyManager = new ConvoyManager();
+  updatePhase(phase) {
+    this.state.taskPhase = phase;
   }
-  return globalConvoyManager;
 }
 
-const convoyManager = {
-  __proto__: null,
-  ConvoyManager: ConvoyManager,
-  getGlobalConvoyManager: getGlobalConvoyManager
-};
-
-export { SessionIntelligence as S, getGlobalStateManager as a, contextLoader$1 as b, contextLoader as c, gitBackedState as d, convoyManager as e, getGlobalConvoyManager as g };
+export { SessionIntelligence as S, getGlobalStateManager as a, gitBackedState as b, contextLoader as c, convoyManager as d, contextLoader$1 as e, getGlobalConvoyManager as g };