tianshu-harness 3.23.0

package/dist/chunk-THKDVSEC.js

@@ -0,0 +1,90 @@
+#!/usr/bin/env -S node --expose-gc --max-old-space-size=4096
+import { createRequire as __rivetCreateRequire } from 'node:module'; const require = __rivetCreateRequire(import.meta.url);
+import {
+  getResolvedEnv
+} from "./chunk-UFMN76QD.js";
+import {
+  init_esm_shims
+} from "./chunk-5GGOGLSN.js";
+
+// src/tools/spawn-git.ts
+init_esm_shims();
+import { spawn, spawnSync, execFile } from "child_process";
+import { existsSync } from "fs";
+import { join } from "path";
+var UNSAFE_GIT_ENV = /* @__PURE__ */ new Set([
+  "GIT_DIR",
+  "GIT_WORK_TREE",
+  "GIT_INDEX_FILE",
+  "GIT_OBJECT_DIRECTORY",
+  "GIT_ALTERNATE_OBJECT_DIRECTORIES",
+  "GIT_COMMON_DIR",
+  "GIT_REPLACE_REF_BASE"
+]);
+function sanitizeGitEnv(env) {
+  const copy = { ...env };
+  for (const name of Object.keys(copy)) {
+    if (UNSAFE_GIT_ENV.has(name.toUpperCase())) delete copy[name];
+  }
+  return copy;
+}
+function resolveGitCommand(env, deps) {
+  const effectiveEnv = { ...process.env, ...env };
+  const platform = deps?.platform ?? process.platform;
+  const exists = deps?.existsSync ?? existsSync;
+  const override = effectiveEnv["RIVET_GIT_PATH"];
+  if (override && exists(override)) return override;
+  if (platform === "win32") {
+    const candidates = [
+      "C:\\Program Files\\Git\\cmd\\git.exe",
+      "C:\\Program Files (x86)\\Git\\cmd\\git.exe"
+    ];
+    const localApp = effectiveEnv["LOCALAPPDATA"];
+    if (localApp) {
+      candidates.push(join(localApp, "Programs", "Git", "cmd", "git.exe"));
+    }
+    for (const c of candidates) {
+      if (exists(c)) return c;
+    }
+  }
+  return "git";
+}
+function gitEnv(cwd) {
+  return sanitizeGitEnv(getResolvedEnv(cwd));
+}
+function spawnGitSync(args, opts) {
+  const cwd = typeof opts?.cwd === "string" ? opts.cwd : void 0;
+  const command = resolveGitCommand(opts?.env);
+  const env = sanitizeGitEnv({ ...gitEnv(cwd), ...opts?.env });
+  return spawnSync(command, args, {
+    encoding: "utf-8",
+    ...opts,
+    env,
+    windowsHide: true
+  });
+}
+function spawnGit(args, opts) {
+  const cwd = typeof opts?.cwd === "string" ? opts.cwd : void 0;
+  const command = resolveGitCommand(opts?.env);
+  const env = sanitizeGitEnv({ ...gitEnv(cwd), ...opts?.env });
+  return spawn(command, args, { ...opts, env, windowsHide: true });
+}
+function execFileGit(args, opts, cb) {
+  const cwd = typeof opts?.cwd === "string" ? opts.cwd : void 0;
+  const command = resolveGitCommand(opts?.env);
+  const env = sanitizeGitEnv({ ...gitEnv(cwd), ...opts?.env });
+  const mergedOpts = { ...opts, encoding: "utf-8", env, windowsHide: true };
+  if (cb) {
+    return execFile(command, args, mergedOpts, cb);
+  }
+  return execFile(command, args, mergedOpts);
+}
+
+export {
+  sanitizeGitEnv,
+  resolveGitCommand,
+  gitEnv,
+  spawnGitSync,
+  spawnGit,
+  execFileGit
+};

package/dist/chunk-TI4GSEL5.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env -S node --expose-gc --max-old-space-size=4096
+import { createRequire as __rivetCreateRequire } from 'node:module'; const require = __rivetCreateRequire(import.meta.url);
+import {
+  GoalTracker
+} from "./chunk-OXMIV4WE.js";
+import {
+  writeFileAtomicSync
+} from "./chunk-A5MNH4ER.js";
+import {
+  init_esm_shims
+} from "./chunk-5GGOGLSN.js";
+
+// src/agent/goal-persist.ts
+init_esm_shims();
+import { join } from "path";
+import { readFileSync, existsSync, unlinkSync } from "fs";
+function goalStatePath(sessionDir, sessionId) {
+  return join(sessionDir, `${sessionId}.goal.json`);
+}
+function saveGoalState(sessionDir, sessionId, tracker) {
+  const record = tracker.toRecord();
+  writeFileAtomicSync(goalStatePath(sessionDir, sessionId), JSON.stringify(record, null, 2) + "\n");
+}
+function loadGoalState(sessionDir, sessionId) {
+  const path = goalStatePath(sessionDir, sessionId);
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function deleteGoalState(sessionDir, sessionId) {
+  const path = goalStatePath(sessionDir, sessionId);
+  if (existsSync(path)) {
+    unlinkSync(path);
+  }
+}
+function restoreGoalTracker(sessionDir, sessionId, config) {
+  const record = loadGoalState(sessionDir, sessionId);
+  if (!record) return null;
+  if (record.status === "complete") return null;
+  return GoalTracker.fromRecord(record, config);
+}
+
+export {
+  goalStatePath,
+  saveGoalState,
+  loadGoalState,
+  deleteGoalState,
+  restoreGoalTracker
+};

package/dist/chunk-TPI73L57.js

@@ -0,0 +1,164 @@
+#!/usr/bin/env -S node --expose-gc --max-old-space-size=4096
+import { createRequire as __rivetCreateRequire } from 'node:module'; const require = __rivetCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-5GGOGLSN.js";
+
+// src/compact/constants.ts
+init_esm_shims();
+var DEFAULT_POLICY_RATIOS = {
+  watch: 0.6,
+  compact: 0.78,
+  reactive: 0.88,
+  ceiling: 0.95
+};
+var STRATEGY_POLICY_RATIOS = {
+  // DeepSeek-style persistent exact-prefix cache: compaction is expensive because
+  // reshaping history can invalidate a valuable prefix. Delay non-emergency
+  // compaction while retaining the 95% hard ceiling.
+  "cache-preserving": { watch: 0.72, compact: 0.86, reactive: 0.92, ceiling: 0.95 },
+  // OpenAI/Gemini/Claude-like cache paths: some cache survives or TTL is short,
+  // so keep the existing ACF behaviour.
+  balanced: DEFAULT_POLICY_RATIOS,
+  // MiMO/local/no-cache providers: no prefix-cache loss, so compact earlier to
+  // keep the active context cleaner.
+  aggressive: { watch: 0.5, compact: 0.7, reactive: 0.84, ceiling: 0.95 }
+};
+function strategyForCacheType(cacheType, persistent) {
+  if (cacheType === "exact-prefix" && persistent) return "cache-preserving";
+  if (cacheType === "none") return "aggressive";
+  return "balanced";
+}
+function compactProviderStrategy(providerProfile) {
+  if (!providerProfile) return "balanced";
+  return strategyForCacheType(providerProfile.cacheType, providerProfile.persistent);
+}
+function compactPolicyRatios(providerProfile) {
+  const base = STRATEGY_POLICY_RATIOS[compactProviderStrategy(providerProfile)];
+  const o = providerProfile?.compaction?.ratios;
+  if (!o) return base;
+  return {
+    watch: o.watch ?? base.watch,
+    compact: o.compact ?? base.compact,
+    reactive: o.reactive ?? base.reactive,
+    ceiling: o.ceiling ?? base.ceiling
+  };
+}
+function compactThresholds(input) {
+  const contextWindow = typeof input === "number" ? input : input.contextWindow;
+  const ratios = typeof input === "number" ? { watch: 0.6, compact: 0.78, reactive: 0.8, ceiling: 0.95 } : compactPolicyRatios(input.providerProfile);
+  const isLargeWindow = contextWindow >= LARGE_CONTEXT_WINDOW_TOKENS;
+  const toolResultHardCap = isLargeWindow ? 2e5 : 1e5;
+  return {
+    autoThreshold: Math.floor(contextWindow * ratios.reactive),
+    // Pure ratio — the old Math.min(..., 500K) clamp dragged the 1M
+    // cache-preserving watch floor from 720K down to 500K, triggering the
+    // watch tier at 50% of the window instead of the intended 72%.
+    autoFloor: Math.floor(contextWindow * ratios.watch),
+    toolResultMaxTokens: Math.min(Math.floor(contextWindow * 0.3), toolResultHardCap)
+  };
+}
+var TASK_ANCHOR_MAX_ITEMS = 6;
+var CACHE_ANCHOR_MESSAGES = 2;
+var KEEP_RECENT_MESSAGES = 4;
+var LARGE_CONTEXT_WINDOW_TOKENS = 5e5;
+function summaryOutputBudgetChars(contextWindow, opts) {
+  const base = contextWindow >= 1e6 ? { full: 8e3, partial: 5e3 } : contextWindow >= LARGE_CONTEXT_WINDOW_TOKENS ? { full: 6e3, partial: 4e3 } : { full: 3e3, partial: 2e3 };
+  if (!opts?.generous) return base;
+  return { full: base.full * 2, partial: base.partial * 2 };
+}
+function adaptiveCompactPolicyRatios(providerProfile, recentHitRate) {
+  const base = compactPolicyRatios(providerProfile);
+  if (recentHitRate === null) return base;
+  if (recentHitRate >= 0.85) {
+    return {
+      watch: Math.min(base.watch + 0.05, 0.9),
+      compact: Math.min(base.compact + 0.03, 0.93),
+      reactive: Math.min(base.reactive + 0.02, 0.95),
+      ceiling: base.ceiling
+    };
+  }
+  if (recentHitRate < 0.3) {
+    return {
+      watch: Math.max(base.watch - 0.1, 0.4),
+      compact: Math.max(base.compact - 0.08, 0.6),
+      reactive: Math.max(base.reactive - 0.05, 0.75),
+      ceiling: base.ceiling
+    };
+  }
+  return base;
+}
+function precisionCeilingRatio(contextWindow, override) {
+  if (typeof override === "number" && Number.isFinite(override) && override > 0 && override < 1) {
+    return override;
+  }
+  if (contextWindow >= LARGE_CONTEXT_WINDOW_TOKENS) return 0.7;
+  if (contextWindow >= 2e5) return 0.55;
+  return 1;
+}
+var PRUNE_PROTECT_RECENT_MESSAGES = 8;
+var PRUNE_MIN_CONTENT_CHARS = 1200;
+function pruneThresholds(contextWindow) {
+  if (contextWindow >= 5e5) {
+    return { protectRecent: 60, minChars: 15e4 };
+  }
+  if (contextWindow >= 2e5) {
+    return { protectRecent: 30, minChars: 4e4 };
+  }
+  return { protectRecent: PRUNE_PROTECT_RECENT_MESSAGES, minChars: PRUNE_MIN_CONTENT_CHARS };
+}
+function staleRoundThresholds(contextWindow) {
+  if (contextWindow >= 5e5) {
+    return { recentToKeep: 30, previewChars: 15e4 };
+  }
+  if (contextWindow >= 2e5) {
+    return { recentToKeep: 12, previewChars: 4e4 };
+  }
+  return { recentToKeep: 4, previewChars: 1200 };
+}
+var PER_MESSAGE_TOOL_RESULT_BUDGET_CHARS = 12e4;
+function perMessageToolResultBudget(contextWindow) {
+  if (!contextWindow || contextWindow <= 0) {
+    return PER_MESSAGE_TOOL_RESULT_BUDGET_CHARS;
+  }
+  const { minChars } = pruneThresholds(contextWindow);
+  const scaled = minChars * 2;
+  if (scaled < PER_MESSAGE_TOOL_RESULT_BUDGET_CHARS) {
+    return PER_MESSAGE_TOOL_RESULT_BUDGET_CHARS;
+  }
+  return Math.min(scaled, 3e5);
+}
+var INLINE_TOOL_RESULT_MAX_CHARS = 5e4;
+function toolTypeBudgets(contextWindow) {
+  const w = contextWindow;
+  const grepPerCall = w >= 2e5 ? Math.min(Math.floor(w * 4e-3), 8e3) : 2e3;
+  const grepSummarize = w >= 2e5 ? Math.min(Math.floor(w * 8e-3), 16e3) : 4e3;
+  return {
+    grep: { perCall: grepPerCall, perTurnCumulative: grepSummarize * 2, summarizeAfter: grepSummarize },
+    search: { perCall: grepPerCall, perTurnCumulative: grepSummarize * 2, summarizeAfter: grepSummarize },
+    read_file: { perCall: Math.min(w * 0.1, 2e4), perTurnCumulative: Math.min(w * 0.25, 5e4), summarizeAfter: Math.min(w * 0.15, 3e4) },
+    bash: { perCall: 5e3, perTurnCumulative: 15e3, summarizeAfter: 8e3 },
+    default: { perCall: 5e3, perTurnCumulative: 2e4, summarizeAfter: 1e4 }
+  };
+}
+function getToolBudget(toolName, contextWindow) {
+  const budgets = toolTypeBudgets(contextWindow);
+  return budgets[toolName] ?? budgets["default"];
+}
+
+export {
+  compactProviderStrategy,
+  compactPolicyRatios,
+  compactThresholds,
+  TASK_ANCHOR_MAX_ITEMS,
+  CACHE_ANCHOR_MESSAGES,
+  KEEP_RECENT_MESSAGES,
+  summaryOutputBudgetChars,
+  adaptiveCompactPolicyRatios,
+  precisionCeilingRatio,
+  pruneThresholds,
+  staleRoundThresholds,
+  perMessageToolResultBudget,
+  INLINE_TOOL_RESULT_MAX_CHARS,
+  getToolBudget
+};

package/dist/chunk-TVHW77C7.js

@@ -0,0 +1,338 @@
+#!/usr/bin/env -S node --expose-gc --max-old-space-size=4096
+import { createRequire as __rivetCreateRequire } from 'node:module'; const require = __rivetCreateRequire(import.meta.url);
+import {
+  dependencyEdgeSchema,
+  dependencyId
+} from "./chunk-4QJ3Y5JM.js";
+import {
+  init_esm_shims
+} from "./chunk-5GGOGLSN.js";
+
+// src/agent/unified-plan.ts
+init_esm_shims();
+
+// src/agent/task-graph.ts
+init_esm_shims();
+function validateTaskGraph(graph) {
+  const ids = new Set(graph.nodes.map((n) => n.id));
+  const dangling = [];
+  for (const node of graph.nodes) {
+    for (const dep of node.dependsOn) {
+      if (!ids.has(dep)) dangling.push({ taskId: node.id, missingDep: dep });
+    }
+  }
+  const cycles = [];
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const stack = [];
+  function dfs(id) {
+    if (visited.has(id)) return;
+    if (visiting.has(id)) {
+      const idx = stack.indexOf(id);
+      if (idx >= 0) cycles.push(stack.slice(idx).concat(id));
+      return;
+    }
+    visiting.add(id);
+    stack.push(id);
+    const node = graph.nodes.find((n) => n.id === id);
+    if (node) {
+      for (const dep of node.dependsOn) {
+        if (ids.has(dep)) dfs(dep);
+      }
+    }
+    stack.pop();
+    visiting.delete(id);
+    visited.add(id);
+  }
+  for (const node of graph.nodes) dfs(node.id);
+  return { valid: dangling.length === 0 && cycles.length === 0, dangling, cycles };
+}
+function topologicalOrder(graph) {
+  const nodeMap = new Map(graph.nodes.map((n) => [n.id, n]));
+  const visited = /* @__PURE__ */ new Set();
+  const result = [];
+  function visit(id) {
+    if (visited.has(id)) return;
+    visited.add(id);
+    const node = nodeMap.get(id);
+    if (node) {
+      for (const dep of node.dependsOn) {
+        if (nodeMap.has(dep)) visit(dep);
+      }
+    }
+    result.push(id);
+  }
+  for (const node of graph.nodes) visit(node.id);
+  return result;
+}
+function groupIntoWaves(graph) {
+  const order = topologicalOrder(graph);
+  const nodeMap = new Map(graph.nodes.map((n) => [n.id, n]));
+  const assigned = /* @__PURE__ */ new Map();
+  const waves = [];
+  for (const id of order) {
+    const node = nodeMap.get(id);
+    let wave = 0;
+    for (const dep of node.dependsOn) {
+      const depWave = assigned.get(dep);
+      if (depWave !== void 0 && depWave >= wave) wave = depWave + 1;
+    }
+    assigned.set(id, wave);
+    if (!waves[wave]) waves[wave] = [];
+    waves[wave].push(id);
+  }
+  return waves.filter(Boolean);
+}
+function renderTaskGraphSummary(graph) {
+  const waves = groupIntoWaves(graph);
+  const lines = [`Mission: ${graph.mission}`, `Tasks: ${graph.nodes.length}`, ""];
+  for (const [i, wave] of waves.entries()) {
+    lines.push(`Wave ${i + 1}:`);
+    for (const id of wave) {
+      const node = graph.nodes.find((n) => n.id === id);
+      const deps = node.dependsOn.length > 0 ? ` (deps: ${node.dependsOn.join(", ")})` : "";
+      lines.push(`  ${node.id} [${node.profile}] ${node.title}${deps}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/agent/unified-plan.ts
+function taskGraphToUnifiedPlan(graph, source = "plan_task") {
+  const tasks = graph.nodes.map((node) => ({
+    id: node.id,
+    title: node.title,
+    objective: node.objective,
+    profile: node.profile,
+    kind: node.kind,
+    files: node.files,
+    dependsOn: node.dependsOn.map(dependencyId),
+    riskTier: node.riskTier
+  }));
+  return {
+    version: 1,
+    objective: graph.mission,
+    tasks,
+    source,
+    createdAt: graph.createdAt
+  };
+}
+function unifiedPlanToTaskGraph(plan) {
+  return {
+    mission: plan.objective,
+    nodes: plan.tasks.map((node) => ({
+      id: node.id,
+      title: node.title,
+      objective: node.objective,
+      profile: node.profile,
+      kind: node.kind,
+      files: node.files,
+      dependsOn: node.dependsOn.map(dependencyId),
+      riskTier: node.riskTier
+    })),
+    createdAt: plan.createdAt
+  };
+}
+function unifiedPlanToTeamTasks(plan) {
+  return plan.tasks.map((node) => ({
+    id: node.id,
+    title: node.title,
+    objective: node.objective,
+    files: node.files,
+    profile: node.profile,
+    kind: node.kind,
+    verification: node.verification ?? [],
+    dependsOn: node.dependsOn,
+    riskTier: node.riskTier,
+    touchSet: node.touchSet ?? node.files,
+    groupId: node.groupId,
+    routeHint: node.routeHint
+  }));
+}
+function buildDependencyReachability(tasks) {
+  const direct = /* @__PURE__ */ new Map();
+  for (const t of tasks) direct.set(t.id, t.dependsOn.map(dependencyId));
+  const reach = /* @__PURE__ */ new Map();
+  for (const t of tasks) {
+    const acc = /* @__PURE__ */ new Set();
+    const stack = t.dependsOn.map(dependencyId);
+    while (stack.length > 0) {
+      const dep = stack.pop();
+      if (acc.has(dep)) continue;
+      acc.add(dep);
+      for (const d of direct.get(dep) ?? []) stack.push(d);
+    }
+    reach.set(t.id, acc);
+  }
+  return reach;
+}
+function detectOverlapWithoutOrder(tasks) {
+  const warnings = [];
+  const reach = buildDependencyReachability(tasks);
+  for (let i = 0; i < tasks.length; i++) {
+    for (let j = i + 1; j < tasks.length; j++) {
+      const a = tasks[i];
+      const b = tasks[j];
+      const aFiles = a.touchSet && a.touchSet.length > 0 ? a.touchSet : a.files;
+      const bFiles = b.touchSet && b.touchSet.length > 0 ? b.touchSet : b.files;
+      if (aFiles.length === 0 || bFiles.length === 0) continue;
+      const shared = aFiles.filter((f) => bFiles.includes(f));
+      if (shared.length === 0) continue;
+      const ordered = reach.get(a.id)?.has(b.id) === true || reach.get(b.id)?.has(a.id) === true;
+      if (!ordered) {
+        warnings.push(
+          `\u5206\u7247 ${a.id} \u4E0E ${b.id} \u90FD\u6539 ${shared.join(", ")} \u4F46\u672A\u6807 dependsOn \u2014\u2014 \u8865\u4E00\u6761\u4F9D\u8D56\u8BA9\u5199\u5165\u987A\u5E8F\u660E\u786E(\u5426\u5219\u4F1A\u88AB\u540C\u6587\u4EF6\u68C0\u6D4B\u81EA\u52A8\u4E32\u884C\u6392\u6CE2)\u3002`
+        );
+      }
+    }
+  }
+  return warnings;
+}
+function validateUnifiedPlan(plan) {
+  const errors = [];
+  const nodeErrors = [];
+  if (!plan.objective.trim()) {
+    errors.push("objective is empty");
+  }
+  if (plan.tasks.length === 0) {
+    errors.push("no tasks defined");
+  }
+  const ids = /* @__PURE__ */ new Set();
+  for (const node of plan.tasks) {
+    if (!node.id.trim()) {
+      nodeErrors.push({ nodeId: "(empty)", error: "node has empty id" });
+      continue;
+    }
+    if (ids.has(node.id)) {
+      nodeErrors.push({ nodeId: node.id, error: "duplicate node id" });
+    }
+    ids.add(node.id);
+    if (!node.objective.trim()) {
+      nodeErrors.push({ nodeId: node.id, error: "objective is empty" });
+    }
+  }
+  for (const node of plan.tasks) {
+    for (const dep of node.dependsOn) {
+      const depId = dependencyId(dep);
+      if (!ids.has(depId)) {
+        nodeErrors.push({ nodeId: node.id, error: `depends on unknown task: ${depId}` });
+      }
+    }
+  }
+  const graph = unifiedPlanToTaskGraph(plan);
+  const graphValidation = validateTaskGraph(graph);
+  if (!graphValidation.valid) {
+    for (const d of graphValidation.dangling) {
+      errors.push(`dangling dep: ${d.taskId} \u2192 ${d.missingDep}`);
+    }
+    for (const cycle of graphValidation.cycles) {
+      errors.push(`cycle: ${cycle.join(" \u2192 ")}`);
+    }
+  }
+  const warnings = graphValidation.cycles.length === 0 ? detectOverlapWithoutOrder(plan.tasks) : [];
+  return {
+    valid: errors.length === 0 && nodeErrors.length === 0,
+    errors,
+    nodeErrors,
+    warnings
+  };
+}
+function serializeUnifiedPlan(plan) {
+  return JSON.stringify(plan);
+}
+function deserializeUnifiedPlan(json) {
+  try {
+    const obj = JSON.parse(json);
+    if (!obj || typeof obj !== "object") return null;
+    const plan = obj;
+    if (plan.version !== 1) return null;
+    if (!Array.isArray(plan.tasks)) return null;
+    if (typeof plan.objective !== "string") return null;
+    for (const node of plan.tasks) {
+      if (typeof node.id !== "string" || !node.id.trim()) return null;
+      if (typeof node.objective !== "string") return null;
+      if (typeof node.profile !== "string") return null;
+      if (typeof node.kind !== "string") return null;
+      if (!Array.isArray(node.files)) return null;
+      if (!node.dependsOn.every((dep) => typeof dep === "string" || dependencyEdgeSchema.safeParse(dep).success)) return null;
+    }
+    return plan;
+  } catch {
+    return null;
+  }
+}
+function renderUnifiedPlanSummary(plan) {
+  const validated = validateUnifiedPlan(plan);
+  const lines = [
+    `Mission: ${plan.objective}`,
+    `Tasks: ${plan.tasks.length} | Source: ${plan.source}`,
+    `Valid: ${validated.valid ? "yes" : "no"}`
+  ];
+  if (!validated.valid) {
+    lines.push("");
+    lines.push("Validation errors:");
+    for (const err of validated.errors) {
+      lines.push(`  - ${err}`);
+    }
+    for (const ne of validated.nodeErrors) {
+      lines.push(`  - [${ne.nodeId}] ${ne.error}`);
+    }
+  }
+  if (validated.warnings.length > 0) {
+    lines.push("");
+    lines.push("Advisories (non-blocking):");
+    for (const w of validated.warnings) {
+      lines.push(`  - ${w}`);
+    }
+  }
+  if (validated.valid) {
+    let getDepth2 = function(nodeId) {
+      if (depthMap.has(nodeId)) return depthMap.get(nodeId);
+      const node = plan.tasks.find((n) => n.id === nodeId);
+      if (!node || node.dependsOn.length === 0) {
+        depthMap.set(nodeId, 0);
+        return 0;
+      }
+      const max = Math.max(0, ...node.dependsOn.map((d) => getDepth2(dependencyId(d)) + 1));
+      depthMap.set(nodeId, max);
+      return max;
+    };
+    var getDepth = getDepth2;
+    lines.push("");
+    const depthMap = /* @__PURE__ */ new Map();
+    for (const node of plan.tasks) getDepth2(node.id);
+    const byDepth = /* @__PURE__ */ new Map();
+    for (const node of plan.tasks) {
+      const depth = depthMap.get(node.id) ?? 0;
+      const group = byDepth.get(depth) ?? [];
+      group.push(node);
+      byDepth.set(depth, group);
+    }
+    for (const [depth, nodes] of [...byDepth.entries()].sort(([a], [b]) => a - b)) {
+      const label = depth === 0 ? "Wave 1 (no deps)" : `Wave ${depth + 1}`;
+      lines.push(`${label}:`);
+      for (const node of nodes) {
+        const deps = node.dependsOn.length > 0 ? ` \u2190 ${node.dependsOn.map(dependencyId).join(", ")}` : "";
+        lines.push(`  ${node.id} [${node.profile}] ${node.title}${deps}`);
+      }
+    }
+  }
+  if (plan.nonGoals?.length) {
+    lines.push("");
+    lines.push("Non-goals:");
+    for (const ng of plan.nonGoals) lines.push(`  - ${ng}`);
+  }
+  return lines.join("\n");
+}
+
+export {
+  validateTaskGraph,
+  renderTaskGraphSummary,
+  taskGraphToUnifiedPlan,
+  unifiedPlanToTeamTasks,
+  detectOverlapWithoutOrder,
+  validateUnifiedPlan,
+  serializeUnifiedPlan,
+  deserializeUnifiedPlan,
+  renderUnifiedPlanSummary
+};