lynkr 9.9.1 → 9.11.0

package/src/agents/context-manager.js

@@ -1,236 +0,0 @@
-const fs = require("fs");
-const path = require("path");
-const logger = require("../logger");
-
-class ContextManager {
-  constructor() {
-    this.transcriptsDir = path.join(process.cwd(), "data", "agent-transcripts");
-    this.ensureTranscriptsDir();
-  }
-
-  ensureTranscriptsDir() {
-    if (!fs.existsSync(this.transcriptsDir)) {
-      fs.mkdirSync(this.transcriptsDir, { recursive: true });
-    }
-  }
-
-  /**
-   * Create fresh context for subagent
-   * @param {Object} agentDef - Agent definition
-   * @param {string} taskPrompt - Task from main agent
-   * @param {Object} mainContext - Minimal context from main agent
-   * @returns {Object} - Fresh context for subagent
-   */
-  createSubagentContext(agentDef, taskPrompt, mainContext = {}) {
-    const agentId = this.generateAgentId();
-    const transcriptPath = path.join(this.transcriptsDir, `agent-${agentId}.jsonl`);
-
-    // Initialize transcript file
-    fs.writeFileSync(transcriptPath, "");
-
-    // Build minimal context (NOT full main agent history)
-    const messages = [];
-
-    // System prompt from agent definition
-    messages.push({
-      role: "system",
-      content: agentDef.systemPrompt
-    });
-
-    // Optional: Add minimal context from main agent
-    if (mainContext.relevant_context) {
-      messages.push({
-        role: "system",
-        content: `Context from main agent:\n${mainContext.relevant_context}`
-      });
-    }
-
-    // Task prompt
-    messages.push({
-      role: "user",
-      content: taskPrompt
-    });
-
-    const context = {
-      agentId,
-      agentName: agentDef.name,
-      transcriptPath,
-      messages,
-      steps: 0,
-      maxSteps: agentDef.maxSteps,
-      model: agentDef.model,
-      allowedTools: agentDef.allowedTools,
-      startTime: Date.now(),
-
-      // Original task prompt — consumed by the Reflector to infer task type.
-      taskPrompt,
-
-      // In-memory transcript mirror of the JSONL file — consumed by the
-      // Reflector for tool-usage / error-recovery analysis. The JSONL file
-      // remains the durable record; this array is the hot-path copy.
-      transcript: [],
-
-      // Token tracking
-      inputTokens: 0,
-      outputTokens: 0,
-
-      // State
-      terminated: false,
-      result: null
-    };
-
-    this.writeTranscriptEntry(transcriptPath, {
-      type: "agent_start",
-      agentId,
-      agentName: agentDef.name,
-      taskPrompt,
-      timestamp: Date.now()
-    });
-
-    logger.info({ agentId, agentName: agentDef.name }, "Created fresh subagent context");
-
-    return context;
-  }
-
-  /**
-   * Add message to subagent context
-   */
-  addMessage(context, message) {
-    context.messages.push(message);
-
-    this.writeTranscriptEntry(context.transcriptPath, {
-      type: "message",
-      agentId: context.agentId,
-      message,
-      timestamp: Date.now()
-    });
-  }
-
-  /**
-   * Record tool execution in transcript
-   */
-  recordToolCall(context, toolName, input, output, error = null) {
-    const entry = {
-      type: "tool_call",
-      agentId: context.agentId,
-      step: context.steps,
-      toolName,
-      input,
-      output: error ? null : output,
-      error: error ? error.message : null,
-      timestamp: Date.now()
-    };
-
-    // Keep the in-memory transcript in sync so the Reflector (which reads
-    // context.transcript) sees tool calls without re-parsing the JSONL file.
-    if (Array.isArray(context.transcript)) {
-      context.transcript.push(entry);
-    }
-
-    this.writeTranscriptEntry(context.transcriptPath, entry);
-  }
-
-  /**
-   * Complete subagent execution
-   */
-  completeExecution(context, result) {
-    context.terminated = true;
-    context.result = result;
-
-    this.writeTranscriptEntry(context.transcriptPath, {
-      type: "agent_complete",
-      agentId: context.agentId,
-      result,
-      stats: {
-        steps: context.steps,
-        durationMs: Date.now() - context.startTime,
-        inputTokens: context.inputTokens,
-        outputTokens: context.outputTokens
-      },
-      timestamp: Date.now()
-    });
-
-    logger.info({
-      agentId: context.agentId,
-      steps: context.steps,
-      durationMs: Date.now() - context.startTime
-    }, "Subagent execution completed");
-  }
-
-  /**
-   * Fail subagent execution
-   */
-  failExecution(context, error) {
-    context.terminated = true;
-
-    this.writeTranscriptEntry(context.transcriptPath, {
-      type: "agent_failed",
-      agentId: context.agentId,
-      error: error.message,
-      stats: {
-        steps: context.steps,
-        durationMs: Date.now() - context.startTime
-      },
-      timestamp: Date.now()
-    });
-
-    logger.error({
-      agentId: context.agentId,
-      error: error.message
-    }, "Subagent execution failed");
-  }
-
-  /**
-   * Write entry to transcript file (JSONL format)
-   */
-  writeTranscriptEntry(transcriptPath, entry) {
-    try {
-      fs.appendFileSync(transcriptPath, JSON.stringify(entry) + "\n");
-    } catch (error) {
-      logger.warn({ error: error.message }, "Failed to write transcript entry");
-    }
-  }
-
-  /**
-   * Read transcript for debugging
-   */
-  readTranscript(agentId) {
-    const transcriptPath = path.join(this.transcriptsDir, `agent-${agentId}.jsonl`);
-
-    if (!fs.existsSync(transcriptPath)) {
-      return null;
-    }
-
-    const lines = fs.readFileSync(transcriptPath, "utf8").split("\n").filter(l => l.trim());
-    return lines.map(line => JSON.parse(line));
-  }
-
-  /**
-   * Generate unique agent ID
-   */
-  generateAgentId() {
-    return `${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
-  }
-
-  /**
-   * Clean old transcripts (older than 7 days)
-   */
-  cleanOldTranscripts() {
-    const maxAge = 7 * 24 * 60 * 60 * 1000; // 7 days
-    const now = Date.now();
-
-    const files = fs.readdirSync(this.transcriptsDir);
-
-    for (const file of files) {
-      const filePath = path.join(this.transcriptsDir, file);
-      const stats = fs.statSync(filePath);
-
-      if (now - stats.mtimeMs > maxAge) {
-        fs.unlinkSync(filePath);
-        logger.debug({ file }, "Cleaned old transcript");
-      }
-    }
-  }
-}
-
-module.exports = ContextManager;

package/src/agents/decomposition/dispatcher.js

@@ -1,185 +0,0 @@
-/**
- * Subtask dispatcher (Phase 3).
- *
- * Executes a validated plan respecting its dependency DAG:
- *   - subtasks are grouped into topological "levels" (Kahn's algorithm)
- *   - subtasks in the same level have no dependency on each other → run in
- *     parallel via the existing ParallelCoordinator (spawnParallel)
- *   - a subtask receives ONLY its own prompt plus the compressed results of the
- *     subtasks it depends on (context isolation — the token win)
- *
- * The spawn functions are injectable for testing.
- */
-
-const logger = require("../../logger");
-
-// Cap how much of a dependency's result we forward, to preserve the
-// context-isolation savings (subagents already return summaries; this bounds
-// pathological cases).
-const MAX_CONTEXT_CHARS = 2000;
-
-/**
- * Group subtasks into dependency levels. Returns array of arrays of ids.
- * Throws if the graph is unresolvable (should not happen — planner validated).
- */
-function topologicalLevels(subtasks) {
-  const byId = new Map(subtasks.map((s) => [s.id, s]));
-  const indegree = new Map(subtasks.map((s) => [s.id, 0]));
-  const dependents = new Map(subtasks.map((s) => [s.id, []]));
-
-  for (const s of subtasks) {
-    for (const dep of s.dependsOn) {
-      if (!byId.has(dep)) continue;
-      indegree.set(s.id, indegree.get(s.id) + 1);
-      dependents.get(dep).push(s.id);
-    }
-  }
-
-  const levels = [];
-  let frontier = subtasks.filter((s) => indegree.get(s.id) === 0).map((s) => s.id);
-  const resolved = new Set();
-
-  while (frontier.length > 0) {
-    levels.push(frontier);
-    const next = [];
-    for (const id of frontier) {
-      resolved.add(id);
-      for (const child of dependents.get(id)) {
-        indegree.set(child, indegree.get(child) - 1);
-        if (indegree.get(child) === 0) next.push(child);
-      }
-    }
-    frontier = next;
-  }
-
-  if (resolved.size !== subtasks.length) {
-    throw new Error("Unresolvable subtask graph (cycle or dangling dependency)");
-  }
-  return levels;
-}
-
-function compressResult(text) {
-  if (typeof text !== "string") return String(text ?? "");
-  if (text.length <= MAX_CONTEXT_CHARS) return text;
-  return text.slice(0, MAX_CONTEXT_CHARS) + "\n…[truncated]";
-}
-
-function buildContextForSubtask(subtask, resultsById) {
-  if (!subtask.dependsOn || subtask.dependsOn.length === 0) return null;
-  const parts = [];
-  for (const dep of subtask.dependsOn) {
-    const r = resultsById.get(dep);
-    if (r && r.success && r.result) {
-      parts.push(`Result of subtask ${dep}:\n${compressResult(r.result)}`);
-    } else if (r) {
-      parts.push(`Subtask ${dep} did not complete successfully.`);
-    }
-  }
-  return parts.length > 0 ? parts.join("\n\n") : null;
-}
-
-/**
- * Dispatch a validated plan.
- * @param {Object} plan - { subtasks: [...] }
- * @param {Object} [options]
- * @param {string} [options.sessionId]
- * @param {string} [options.cwd]
- * @param {Function} [options.spawnParallel] - (agentTypes[], prompts[], opts) => results[]
- * @returns {Promise<{results: Array, levels: Array, stats: Object}>}
- */
-async function dispatchPlan(plan, options = {}) {
-  const spawnParallel = options.spawnParallel || require("../index").spawnParallel;
-  const subtasks = plan.subtasks;
-  const byId = new Map(subtasks.map((s) => [s.id, s]));
-  const levels = topologicalLevels(subtasks);
-  const resultsById = new Map();
-
-  let totalInputTokens = 0;
-  let totalOutputTokens = 0;
-  let totalSubagents = 0;
-
-  for (let li = 0; li < levels.length; li++) {
-    const levelIds = levels[li];
-    const levelSubtasks = levelIds.map((id) => byId.get(id));
-
-    const agentTypes = levelSubtasks.map((s) => s.agentType);
-    const prompts = levelSubtasks.map((s) => s.prompt);
-    const perTaskContext = levelSubtasks.map((s) => buildContextForSubtask(s, resultsById));
-
-    logger.info(
-      { level: li, count: levelIds.length, ids: levelIds },
-      "[Decomposition] Dispatching subtask level"
-    );
-
-    // spawnParallel shares one options object; pass per-task context by spawning
-    // the level as individual parallel calls when contexts differ.
-    const levelResults = await runLevel(
-      spawnParallel,
-      agentTypes,
-      prompts,
-      perTaskContext,
-      options
-    );
-
-    levelResults.forEach((res, idx) => {
-      const st = levelSubtasks[idx];
-      totalSubagents += 1;
-      totalInputTokens += res?.stats?.inputTokens || 0;
-      totalOutputTokens += res?.stats?.outputTokens || 0;
-      resultsById.set(st.id, {
-        id: st.id,
-        agentType: st.agentType,
-        success: !!res?.success,
-        result: res?.success ? res.result : null,
-        error: res?.success ? null : res?.error || "unknown error",
-        stats: res?.stats || {},
-      });
-    });
-  }
-
-  const results = subtasks.map((s) => resultsById.get(s.id));
-  return {
-    results,
-    levels,
-    stats: {
-      subagents: totalSubagents,
-      inputTokens: totalInputTokens,
-      outputTokens: totalOutputTokens,
-    },
-  };
-}
-
-/**
- * Run one level. When subtasks in the level have differing injected contexts we
- * spawn them as separate parallel calls (each with its own mainContext), then
- * await all. When none need context, a single spawnParallel batch is used.
- */
-async function runLevel(spawnParallel, agentTypes, prompts, perTaskContext, options) {
-  const anyContext = perTaskContext.some((c) => c);
-
-  if (!anyContext) {
-    return spawnParallel(agentTypes, prompts, {
-      sessionId: options.sessionId,
-      cwd: options.cwd,
-    });
-  }
-
-  // Mixed/with-context: one spawnParallel call per subtask so each gets its own
-  // mainContext, executed concurrently.
-  const calls = agentTypes.map((type, i) =>
-    spawnParallel([type], [prompts[i]], {
-      sessionId: options.sessionId,
-      cwd: options.cwd,
-      mainContext: perTaskContext[i] ? { relevant_context: perTaskContext[i] } : undefined,
-    }).then((arr) => arr[0])
-  );
-  return Promise.all(calls);
-}
-
-module.exports = {
-  dispatchPlan,
-  topologicalLevels,
-  buildContextForSubtask,
-  compressResult,
-  MAX_CONTEXT_CHARS,
-};

package/src/agents/decomposition/gate.js

@@ -1,136 +0,0 @@
-/**
- * Decomposition gate (Phase 1).
- *
- * Decides whether breaking a task into isolated-context subtasks is actually
- * worth it. This is the make-or-break of the feature: naive "decompose
- * everything" loses money, because every subagent carries fixed overhead
- * (planning + per-agent handoff/summarisation). Decomposition only pays off
- * when the task is (a) genuinely complex, (b) large enough to amortise that
- * overhead, and (c) divisible into reasonably independent units.
- *
- * Pure and synchronous so it can be unit-tested without a model. The caller
- * supplies a pre-computed complexity `analysis` (from routing/complexity-analyzer)
- * and the raw payload.
- */
-
-const DEFAULTS = {
-  minComplexity: 60, // 0-100; only decompose genuinely complex work
-  minTokens: 3000, // estimated monolithic tokens; below this the overhead wins
-  minIndependentUnits: 2, // need at least 2 separable pieces to bother
-  maxSubtasks: 6,
-};
-
-const ENUMERATION_RE = /^\s*(?:[-*+]|\d+[.)]|step\s+\d+\b)/gim;
-const CONJUNCTION_RE = /\b(?:and then|then|also|additionally|as well as|after that|finally|next,)\b/gi;
-const IMPERATIVE_RE = /\b(?:add|create|build|implement|write|refactor|update|fix|remove|delete|migrate|test|document|configure|set up|wire|integrate|generate)\b/gi;
-const FILE_PATH_RE = /\b[\w./-]+\.(?:js|ts|tsx|jsx|py|go|rs|java|rb|c|cpp|h|json|yaml|yml|md|sql|sh|css|html)\b/gi;
-
-function _uniqueMatches(text, re) {
-  const set = new Set();
-  const matches = text.match(re) || [];
-  for (const m of matches) set.add(m.toLowerCase().trim());
-  return set;
-}
-
-/**
- * Heuristically estimate how many independent units a task contains.
- * Conservative: takes the strongest of several weak signals rather than summing
- * them, so a single rambling sentence doesn't look like five subtasks.
- * @param {string} text
- * @returns {number}
- */
-function estimateIndependentUnits(text) {
-  if (!text || typeof text !== "string") return 1;
-
-  const enumerated = (text.match(ENUMERATION_RE) || []).length;
-  const conjunctions = (text.match(CONJUNCTION_RE) || []).length;
-  const imperatives = _uniqueMatches(text, IMPERATIVE_RE).size;
-  const files = _uniqueMatches(text, FILE_PATH_RE).size;
-
-  // Each signal is an independent lower-bound estimate of separable units.
-  const signals = [
-    enumerated, // explicit list items
-    conjunctions + 1, // "do A and then B" → 2 units
-    imperatives, // distinct action verbs
-    files, // distinct files usually map to distinct work
-  ];
-
-  const estimate = Math.max(...signals, 1);
-  return estimate;
-}
-
-/**
- * Decide whether to decompose.
- * @param {Object} analysis - result of analyzeComplexity(payload)
- * @param {Object} payload - the request payload
- * @param {Object} [options]
- * @param {Object} [options.config] - threshold overrides (see DEFAULTS)
- * @param {string} [options.riskLevel] - 'low'|'medium'|'high'; 'high' disables decomposition
- * @param {string} [options.taskText] - explicit task text (else derived from analysis/payload)
- * @returns {{ decompose: boolean, reason: string, signals: Object }}
- */
-function shouldDecompose(analysis, payload = {}, options = {}) {
-  const cfg = { ...DEFAULTS, ...(options.config || {}) };
-
-  const score = Number(analysis?.score ?? 0);
-  const estimatedTokens = Number(
-    analysis?.breakdown?.tokens?.estimated ?? options.estimatedTokens ?? 0
-  );
-
-  const taskText =
-    options.taskText ||
-    analysis?.content ||
-    _firstUserText(payload) ||
-    "";
-
-  const independentUnits = estimateIndependentUnits(taskText);
-
-  const signals = {
-    score,
-    estimatedTokens,
-    independentUnits,
-    riskLevel: options.riskLevel || "low",
-    thresholds: cfg,
-  };
-
-  // Never decompose high-risk work — keep it in one capable context where the
-  // exempt-from-laziness concerns (validation/security) stay coherent.
-  if (options.riskLevel === "high") {
-    return { decompose: false, reason: "high_risk_skip", signals };
-  }
-
-  if (score < cfg.minComplexity) {
-    return { decompose: false, reason: "below_complexity_threshold", signals };
-  }
-
-  if (estimatedTokens < cfg.minTokens) {
-    return { decompose: false, reason: "too_small_to_amortise_overhead", signals };
-  }
-
-  if (independentUnits < cfg.minIndependentUnits) {
-    return { decompose: false, reason: "not_divisible", signals };
-  }
-
-  return { decompose: true, reason: "decompose_worthwhile", signals };
-}
-
-function _firstUserText(payload) {
-  const messages = payload?.messages;
-  if (!Array.isArray(messages)) return "";
-  const user = [...messages].reverse().find((m) => m.role === "user");
-  if (!user) return "";
-  if (typeof user.content === "string") return user.content;
-  if (Array.isArray(user.content)) {
-    return user.content
-      .filter((b) => b?.type === "text" || typeof b?.text === "string")
-      .map((b) => b.text || "")
-      .join("\n");
-  }
-  return "";
-}
-
-module.exports = {
-  shouldDecompose,
-  estimateIndependentUnits,
-  DEFAULTS,
-};