@ai-setting/roy-agent-core 1.6.16 → 1.6.18

package/dist/shared/@ai-setting/{roy-agent-core-8v0hzw96.js → roy-agent-core-n1fx2fx4.js}

@@ -1,10 +1,10 @@
 import {
   ProcessRegistry,
   runWithProcessRegistryAsync
-} from "./roy-agent-core-eaj0b1hm.js";
+} from "./roy-agent-core-44g3synv.js";
 import {
   builtInPrompts
-} from "./roy-agent-core-pq1q854s.js";
+} from "./roy-agent-core-65vpkh7x.js";
 import {
   runWithBgTaskIdAsync
 } from "./roy-agent-core-c1v263jn.js";
@@ -108,7 +108,631 @@ function listKnownSubagentDescriptions(registry) {
 
 // src/env/task/delegate/delegate-tool.ts
 init_global_hook_manager();
-var logger = createLogger("task:delegate");
+
+// src/env/task/task-creation-registry.ts
+var TOKEN_PATTERNS = [
+  /\bsk-(?:proj-)?[A-Za-z0-9_-]{16,}\b/g,
+  /\bxox[abprs]-[A-Za-z0-9-]{8,}\b/g,
+  /\bghp_[A-Za-z0-9]{16,}\b/g,
+  /\bgithub_pat_[A-Za-z0-9_]{16,}\b/g,
+  /\bBearer\s+[A-Za-z0-9._\-+/=]{12,}\b/g,
+  /\bAKIA[0-9A-Z]{16}\b/g
+];
+function redactTokens(s) {
+  let out = s;
+  for (const pat of TOKEN_PATTERNS) {
+    out = out.replace(pat, "<redacted>");
+  }
+  return out;
+}
+function truncate(s, max) {
+  if (s.length <= max)
+    return s;
+  if (max <= 3)
+    return s.slice(0, max);
+  return s.slice(0, max - 1) + "…";
+}
+function sanitize(s, max) {
+  return truncate(redactTokens(s), max);
+}
+
+class TaskCreationRegistry {
+  maxEntries;
+  ttlMs;
+  maxDescriptionChars;
+  records = new Map;
+  childrenIndex = new Map;
+  constructor(config = {}) {
+    this.maxEntries = config.maxEntries ?? 500;
+    this.ttlMs = config.ttlMs ?? 24 * 60 * 60 * 1000;
+    this.maxDescriptionChars = config.maxDescriptionChars ?? 240;
+  }
+  record(task, source = {}) {
+    const now = new Date().toISOString();
+    const record = this.toRecord(task, source, now);
+    this.upsert(record);
+    this.indexParentChild(record);
+    this.evictIfNeeded();
+    return record;
+  }
+  update(task, source) {
+    const existing = this.records.get(task.id);
+    if (!existing)
+      return;
+    const now = new Date().toISOString();
+    this.records.delete(task.id);
+    const merged = {
+      ...existing,
+      ...this.toRecord(task, source ?? existing.source, now),
+      createdAt: existing.createdAt,
+      source: source ?? existing.source
+    };
+    this.records.set(task.id, merged);
+    this.childrenIndex.delete(merged.taskId);
+    this.indexParentChild(merged);
+    this.evictIfNeeded();
+    return merged;
+  }
+  remove(id) {
+    const rec = this.records.get(id);
+    if (!rec)
+      return false;
+    this.records.delete(id);
+    if (rec.parentTaskId !== undefined) {
+      const siblings = this.childrenIndex.get(rec.parentTaskId);
+      siblings?.delete(id);
+      if (siblings && siblings.size === 0) {
+        this.childrenIndex.delete(rec.parentTaskId);
+      }
+    }
+    return true;
+  }
+  getById(id) {
+    const rec = this.records.get(id);
+    if (!rec)
+      return;
+    if (Date.now() - Date.parse(rec.updatedAt) > this.ttlMs) {
+      this.remove(id);
+      return;
+    }
+    return rec;
+  }
+  peekById(id) {
+    return this.records.get(id);
+  }
+  clear() {
+    this.records.clear();
+    this.childrenIndex.clear();
+  }
+  size() {
+    return this.records.size;
+  }
+  recent(options = {}) {
+    const limit = options.limit ?? 10;
+    const statuses = options.statuses;
+    const excludeIds = new Set(options.excludeIds ?? []);
+    const excludeAncestorId = options.excludeAncestorOf ?? options.excludeSelfOrDescendant;
+    const excludeAncestorIds = excludeAncestorId ? this.collectSubtree(excludeAncestorId) : new Set;
+    const sinceMs = options.sinceHours ? Date.now() - options.sinceHours * 60 * 60 * 1000 : 0;
+    const now = Date.now();
+    const excludeAll = new Set([...excludeIds, ...excludeAncestorIds]);
+    const all = [];
+    for (const rec of this.records.values()) {
+      if (now - Date.parse(rec.updatedAt) > this.ttlMs)
+        continue;
+      if (sinceMs > 0 && Date.parse(rec.updatedAt) < sinceMs)
+        continue;
+      if (excludeAll.has(rec.taskId))
+        continue;
+      if (options.scope) {
+        if (options.scope.sessionId !== undefined && rec.source.sessionId !== options.scope.sessionId)
+          continue;
+        if (options.scope.parentSessionId !== undefined && rec.source.parentSessionId !== options.scope.parentSessionId)
+          continue;
+        if (options.scope.subagentType !== undefined && rec.source.subagentType !== options.scope.subagentType)
+          continue;
+      }
+      if (statuses) {
+        if (!statuses.includes(rec.status))
+          continue;
+      } else {
+        if (rec.status === "archived")
+          continue;
+      }
+      all.push(rec);
+    }
+    if (options.activeChildFirst) {
+      const activeChildBoost = new Map;
+      for (const rec of all) {
+        activeChildBoost.set(rec.taskId, this.hasActiveChild(rec.taskId));
+      }
+      all.sort((a, b) => {
+        const aBoost = activeChildBoost.get(a.taskId) ? 1 : 0;
+        const bBoost = activeChildBoost.get(b.taskId) ? 1 : 0;
+        if (aBoost !== bBoost)
+          return bBoost - aBoost;
+        const cmp = Date.parse(b.updatedAt) - Date.parse(a.updatedAt);
+        if (cmp !== 0)
+          return cmp;
+        return b.taskId - a.taskId;
+      });
+    } else {
+      all.sort((a, b) => {
+        const cmp = Date.parse(b.updatedAt) - Date.parse(a.updatedAt);
+        if (cmp !== 0)
+          return cmp;
+        return b.taskId - a.taskId;
+      });
+    }
+    return all.slice(0, limit);
+  }
+  getSubtreeSummary(parentId, options = {}) {
+    const includeArchived = options.includeArchived === true;
+    const summary = {
+      descendantCount: 0,
+      activeCount: 0,
+      completedCount: 0,
+      maxDepth: 0
+    };
+    if (!this.records.has(parentId) && !this.childrenIndex.has(parentId)) {
+      return summary;
+    }
+    const directChildren = this.childrenIndex.get(parentId);
+    const currentLevel = directChildren ? Array.from(directChildren) : [];
+    let depth = currentLevel.length > 0 ? 1 : 0;
+    summary.maxDepth = depth;
+    let levelIds = currentLevel;
+    while (levelIds.length > 0) {
+      const nextLevel = [];
+      for (const id of levelIds) {
+        const rec = this.records.get(id);
+        if (!rec)
+          continue;
+        if (!includeArchived && rec.status === "archived")
+          continue;
+        summary.descendantCount++;
+        if (rec.status === "active") {
+          summary.activeCount++;
+        } else if (rec.status === "completed") {
+          summary.completedCount++;
+        }
+        const grandchildren = this.childrenIndex.get(id);
+        if (grandchildren && grandchildren.size > 0) {
+          for (const gc of grandchildren)
+            nextLevel.push(gc);
+        }
+      }
+      if (nextLevel.length > 0) {
+        depth++;
+        summary.maxDepth = depth;
+      }
+      levelIds = nextLevel;
+    }
+    return summary;
+  }
+  hasActiveChild(parentId) {
+    const children = this.childrenIndex.get(parentId);
+    if (!children)
+      return false;
+    for (const childId of children) {
+      const rec = this.records.get(childId);
+      if (!rec)
+        continue;
+      if (rec.status === "active" || rec.status === "todo")
+        return true;
+    }
+    return false;
+  }
+  toRecord(task, source, isoNow) {
+    const parsedContext = this.safeParseContext(task.context);
+    const safeContext = parsedContext ? this.stripSensitiveKeys(parsedContext) : undefined;
+    return {
+      taskId: task.id,
+      title: task.title,
+      description: sanitize(task.description || "", this.maxDescriptionChars),
+      goals: sanitize(task.goals_and_expected_deliverables || "", this.maxDescriptionChars),
+      tags: task.tags ?? [],
+      status: task.status,
+      priority: task.priority,
+      type: task.type,
+      parentTaskId: task.parent_task_id,
+      source,
+      createdAt: task.createdAt || isoNow,
+      updatedAt: task.updatedAt || isoNow,
+      operationCount: 0,
+      project_path: task.project_path,
+      branch: this.pickString(safeContext, "branch"),
+      worktree_path: this.pickString(safeContext, "worktree_path"),
+      parentBranch: this.pickString(safeContext, "parent_branch"),
+      context: safeContext
+    };
+  }
+  safeParseContext(raw) {
+    if (!raw || !raw.trim())
+      return;
+    try {
+      const parsed = JSON.parse(raw);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        return parsed;
+      }
+      return;
+    } catch {
+      return;
+    }
+  }
+  pickString(obj, key) {
+    if (!obj)
+      return;
+    const v = obj[key];
+    return typeof v === "string" ? v : undefined;
+  }
+  static STRIPPED_KEYS = ["commit", "token", "secret", "password", "api_key"];
+  stripSensitiveKeys(obj) {
+    if (obj === null || obj === undefined)
+      return obj;
+    if (Array.isArray(obj))
+      return obj.map((v) => this.stripSensitiveKeys(v));
+    if (typeof obj !== "object")
+      return obj;
+    const out = {};
+    const strippedKeys = TaskCreationRegistry.STRIPPED_KEYS;
+    for (const [k, v] of Object.entries(obj)) {
+      const lower = k.toLowerCase();
+      if (strippedKeys.some((s) => lower.includes(s)))
+        continue;
+      out[k] = this.stripSensitiveKeys(v);
+    }
+    return out;
+  }
+  upsert(record) {
+    this.records.set(record.taskId, record);
+  }
+  indexParentChild(record) {
+    if (record.parentTaskId === undefined || record.parentTaskId === null)
+      return;
+    const parentId = record.parentTaskId;
+    let set = this.childrenIndex.get(parentId);
+    if (!set) {
+      set = new Set;
+      this.childrenIndex.set(parentId, set);
+    }
+    set.add(record.taskId);
+  }
+  collectSubtree(rootId) {
+    const out = new Set([rootId]);
+    const queue = [rootId];
+    while (queue.length > 0) {
+      const id = queue.shift();
+      const children = this.childrenIndex.get(id);
+      if (!children)
+        continue;
+      for (const child of children) {
+        if (!out.has(child)) {
+          out.add(child);
+          queue.push(child);
+        }
+      }
+    }
+    return out;
+  }
+  evictIfNeeded() {
+    if (this.records.size <= this.maxEntries)
+      return;
+    const overflow = this.records.size - this.maxEntries;
+    const keys = Array.from(this.records.keys()).slice(0, overflow);
+    for (const k of keys) {
+      this.remove(k);
+    }
+  }
+}
+
+// src/env/task/registry-hook-installer.ts
+init_logger();
+var logger = createLogger("registry-hook-installer");
+function installTaskCreationRegistryHooks(taskComponent, registry, options = {}) {
+  const uniqueSuffix = `${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+  const hookName = options.hookName ? `${options.hookName}:${uniqueSuffix}` : `registry-hook-installer:${uniqueSuffix}`;
+  const priority = options.priority ?? 100;
+  let uninstalled = false;
+  const safeRecord = (task, source) => {
+    try {
+      registry.record(task, source);
+    } catch (err) {
+      logger.warn(`[registry-hook-installer] record failed for task #${task.id}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  };
+  const safeUpdate = (task, source) => {
+    try {
+      registry.update(task, source);
+    } catch (err) {
+      logger.warn(`[registry-hook-installer] update failed for task #${task.id}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  };
+  const safeRemove = (id) => {
+    try {
+      registry.remove(id);
+    } catch (err) {
+      logger.warn(`[registry-hook-installer] remove failed for task #${id}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  };
+  const buildSource = () => ({
+    sessionId: options.sessionIdProvider?.(),
+    ...options.staticSource ?? {}
+  });
+  const afterCreate = {
+    name: `${hookName}:after-create`,
+    priority,
+    execute: async (ctx) => {
+      const data = ctx.data;
+      if (data?.task)
+        safeRecord(data.task, buildSource());
+    }
+  };
+  const afterUpdate = {
+    name: `${hookName}:after-update`,
+    priority,
+    execute: async (ctx) => {
+      const data = ctx.data;
+      if (!data?.task)
+        return;
+      const exists = registry.peekById(data.task.id);
+      if (exists) {
+        safeUpdate(data.task, buildSource());
+      } else {
+        safeRecord(data.task, buildSource());
+      }
+    }
+  };
+  const afterComplete = {
+    name: `${hookName}:after-complete`,
+    priority,
+    execute: async (ctx) => {
+      const data = ctx.data;
+      if (data?.task)
+        safeUpdate(data.task, buildSource());
+    }
+  };
+  const afterDelete = {
+    name: `${hookName}:after-delete`,
+    priority,
+    execute: async (ctx) => {
+      const data = ctx.data;
+      if (typeof data?.id === "number")
+        safeRemove(data.id);
+    }
+  };
+  taskComponent.registerHook(TaskHookPoints.AFTER_CREATE, afterCreate);
+  taskComponent.registerHook(TaskHookPoints.AFTER_UPDATE, afterUpdate);
+  taskComponent.registerHook(TaskHookPoints.AFTER_COMPLETE, afterComplete);
+  taskComponent.registerHook(TaskHookPoints.AFTER_DELETE, afterDelete);
+  return {
+    uninstall() {
+      if (uninstalled)
+        return;
+      uninstalled = true;
+      taskComponent.unregisterHook(TaskHookPoints.AFTER_CREATE, afterCreate.name);
+      taskComponent.unregisterHook(TaskHookPoints.AFTER_UPDATE, afterUpdate.name);
+      taskComponent.unregisterHook(TaskHookPoints.AFTER_COMPLETE, afterComplete.name);
+      taskComponent.unregisterHook(TaskHookPoints.AFTER_DELETE, afterDelete.name);
+      logger.debug(`[registry-hook-installer] uninstalled hooks (name=${hookName})`);
+    }
+  };
+}
+
+// src/env/task/task-reuse-registry.ts
+init_logger();
+var logger2 = createLogger("task-reuse-registry");
+var DEFAULT_CONFIG = {
+  maxEntries: 500,
+  ttlMs: 24 * 60 * 60 * 1000,
+  maxDescriptionChars: 240
+};
+var registries = new WeakMap;
+function getOrCreateTaskReuseRegistry(env) {
+  const existing = registries.get(env);
+  if (existing)
+    return existing.registry;
+  const registry = new TaskCreationRegistry(DEFAULT_CONFIG);
+  let installHandle = { uninstall: () => {} };
+  try {
+    const taskComponent = env.getComponent?.("task");
+    if (taskComponent?.registerHook) {
+      installHandle = installTaskCreationRegistryHooks(taskComponent, registry, {
+        sessionIdProvider: () => {
+          try {
+            return env.currentSessionId ?? undefined;
+          } catch {
+            return;
+          }
+        },
+        staticSource: {
+          processId: typeof process !== "undefined" ? process.pid : undefined
+        }
+      });
+      logger2.debug("[task-reuse-registry] hook installed");
+    } else {
+      logger2.debug("[task-reuse-registry] no TaskComponent in env; registry stays empty");
+    }
+  } catch (err) {
+    logger2.warn(`[task-reuse-registry] hook install failed: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  const entry = { registry, installHandle };
+  registries.set(env, entry);
+  return registry;
+}
+
+// src/env/task/task-reuse-context.ts
+var TOKEN_PATTERNS2 = [
+  /\bsk-(?:proj-)?[A-Za-z0-9_-]{16,}\b/g,
+  /\bxox[abprs]-[A-Za-z0-9-]{8,}\b/g,
+  /\bghp_[A-Za-z0-9]{16,}\b/g,
+  /\bgithub_pat_[A-Za-z0-9_]{16,}\b/g,
+  /\bBearer\s+[A-Za-z0-9._\-+/=]{12,}\b/g,
+  /\bAKIA[0-9A-Z]{16}\b/g
+];
+function redact(s) {
+  let out = s;
+  for (const pat of TOKEN_PATTERNS2)
+    out = out.replace(pat, "<redacted>");
+  return out;
+}
+function truncate2(s, max) {
+  if (s.length <= max)
+    return s;
+  if (max <= 1)
+    return s.slice(0, max);
+  return s.slice(0, max - 1) + "…";
+}
+function buildReuseCandidateSection(options) {
+  const limit = options.limit ?? 5;
+  const maxChars = options.maxChars ?? 2000;
+  const maxDescChars = options.maxDescriptionChars ?? 240;
+  const heading = options.heading ?? "Recent task context (reuse candidates)";
+  const recent = options.registry.recent({
+    scope: options.scope,
+    limit,
+    statuses: options.statuses,
+    excludeIds: options.similarTaskIds ?? [],
+    excludeAncestorOf: options.excludeAncestorOf
+  });
+  if (recent.length === 0) {
+    return { markdown: "", candidateIds: [], isEmpty: true };
+  }
+  const lines = [];
+  lines.push(`## ${heading}`);
+  lines.push("");
+  lines.push("The following tasks were recently created in this process / session and may be related to your current work. " + "Before creating a brand-new task, check whether one of these is the same work continuing. " + "The list is a *suggestion only* — confirm with `task_get <id>` before reusing.");
+  lines.push("");
+  for (const rec of recent) {
+    lines.push(`### Task #${rec.taskId}: ${rec.title}`);
+    lines.push(`- Status: ${rec.status}`);
+    if (rec.parentTaskId !== undefined && rec.parentTaskId !== null) {
+      lines.push(`- Parent: #${rec.parentTaskId}`);
+    }
+    if (rec.source.subagentType) {
+      lines.push(`- Created by: ${rec.source.subagentType}`);
+    }
+    lines.push(`- Updated: ${rec.updatedAt}`);
+    if (rec.project_path) {
+      lines.push(`- Project: ${rec.project_path}`);
+    }
+    if (rec.worktree_path) {
+      lines.push(`- Worktree: ${rec.worktree_path}`);
+    }
+    if (rec.branch) {
+      lines.push(`- Branch: ${rec.branch}`);
+    }
+    if (rec.parentBranch) {
+      lines.push(`- Parent branch: ${rec.parentBranch}`);
+    }
+    let summary;
+    try {
+      summary = options.registry.getSubtreeSummary(rec.taskId);
+    } catch {
+      summary = undefined;
+    }
+    if (summary && summary.descendantCount > 0) {
+      lines.push(`- Children: ${summary.descendantCount} ` + `(active: ${summary.activeCount}, completed: ${summary.completedCount}, max depth: ${summary.maxDepth})`);
+    }
+    const hasActiveChild = summary !== undefined && summary.activeCount > 0;
+    if (rec.status === "completed" && hasActiveChild) {
+      lines.push(`- ⚠ Has active child — reopening this parent will conflict with running work; prefer creating a child task.`);
+    }
+    const safeDesc = redact(truncate2(rec.description, maxDescChars));
+    if (safeDesc) {
+      lines.push(`- Description: ${safeDesc}`);
+    }
+    if (rec.tags && rec.tags.length > 0) {
+      lines.push(`- Tags: ${rec.tags.join(", ")}`);
+    }
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push("### Reuse instructions");
+  lines.push("");
+  lines.push("1. **First** call `task_get <id>` on the most relevant candidate to read its description, goals, and recent operations.");
+  lines.push("2. **If it is the same work continuing** — prefer `task_update` over `task_create`:");
+  lines.push("   - Set `status` back to `active` (or `todo`) to reopen a completed task.");
+  lines.push("   - Append new context to `description` and `goals_and_expected_deliverables` (do not replace).");
+  lines.push('   - Update `current_status` to reflect the new scope, then call `task_operation_create` with `milestone_type: "decision"` to record the continuation.');
+  lines.push("3. **Only** if the candidate is clearly a different task, call `task_create` with a distinguishing title and `parent_task_id` if appropriate.");
+  lines.push("4. Do **not** create a duplicate task merely because the existing one is already `completed` — reopen it instead.");
+  lines.push("5. Do **not** reuse an unrelated candidate just to fill this list. Empty reuse is a valid outcome.");
+  lines.push("");
+  lines.push("### Decision matrix — three legal paths");
+  lines.push("");
+  lines.push("Pick exactly **one** of these paths before calling `task_create`. Reopen-first");
+  lines.push("remains the default, but the matrix adds two new paths for independent work.");
+  lines.push("");
+  lines.push("**Path A — Continuation (reopen existing task).** The new work is the SAME");
+  lines.push('logical task. Use `task_update(task_id=<id>, { status: "active", ... })` and');
+  lines.push("append description/goals. Do **not** create a new task id.");
+  lines.push("");
+  lines.push("```");
+  lines.push('task_update(task_id=<parent_id>, { status: "active", current_status: "..." })');
+  lines.push('task_operation_create({ task_id=<parent_id>, milestone_type: "decision",');
+  lines.push('  milestone_title: "Reopened for <new-scope>",');
+  lines.push('  milestone_description: "<why this is the same work>" })');
+  lines.push("```");
+  lines.push("");
+  lines.push("**Path B — Child task (parent_task_id=<id>).** The new work is related but");
+  lines.push("distinct: an independent bug fix, optimization, parallel delivery or");
+  lines.push("independent acceptance item under the same feature. Create a child task so");
+  lines.push("the audit trail is preserved. Always pair with an audit operation.");
+  lines.push("");
+  lines.push("```");
+  for (const rec of recent) {
+    const safeProj = rec.project_path ?? "<project_path>";
+    lines.push(`task_create(parent_task_id=${rec.taskId}, title="<distinguishing title>", ` + `project_path="${safeProj}", context=<inherit or override>)`);
+    break;
+  }
+  lines.push('task_operation_create({ task_id=<new_id>, milestone_type: "milestone",');
+  lines.push('  milestone_title: "Child of #<parent_id>: <new-scope>",');
+  lines.push('  milestone_description: "<why this is a sibling/child, not a reopen>" })');
+  lines.push("```");
+  lines.push("");
+  lines.push("**Path C — New root (no parent_task_id).** The new work is unrelated to any");
+  lines.push("existing task. Create a brand-new root task. Use this sparingly — root count");
+  lines.push("should stay ≤ ~10 to keep the tree readable.");
+  lines.push("");
+  lines.push("```");
+  lines.push('task_create(parent_task_id=undefined, title="<distinct topic>", project_path="<project_path>", context=<json>)');
+  lines.push('task_operation_create({ task_id=<new_id>, milestone_type: "create",');
+  lines.push('  milestone_title: "New root: <topic>",');
+  lines.push('  milestone_description: "<why this is not a child of any existing task>" })');
+  lines.push("```");
+  lines.push("");
+  lines.push("**Operation audit templates.** Every `task_create`/`task_update` call MUST be");
+  lines.push("followed by a `task_operation_create` so the next agent sees *why* the path was");
+  lines.push("chosen. Use the appropriate `milestone_type`:");
+  lines.push("  - continuation → `decision` (and `progress` once the new scope makes headway)");
+  lines.push("  - child task → `milestone` (then `progress` as the child advances)");
+  lines.push("  - new root → `create` (then `progress` per phase)");
+  lines.push("");
+  lines.push("**Project + context inheritance.** For Path B/C, prefer inheriting the");
+  lines.push("candidate's `project_path`, `context.worktree_path`, `context.branch` and");
+  lines.push("`context.parent_branch` from the parent task. Sensitive keys (commits,");
+  lines.push("tokens, secrets) are stripped automatically. Use the helper:");
+  lines.push("");
+  lines.push("```");
+  lines.push("inheritChildContext({ parent: { taskId, projectPath, contextJson, tags }, overrides: {...} })");
+  lines.push("```");
+  lines.push("");
+  let markdown = lines.join(`
+`);
+  if (markdown.length > maxChars) {
+    markdown = truncate2(markdown, maxChars);
+  }
+  return {
+    markdown,
+    candidateIds: recent.map((r) => r.taskId),
+    isEmpty: false
+  };
+}
+
+// src/env/task/delegate/delegate-tool.ts
+var logger3 = createLogger("task:delegate");
 var BackgroundTaskEventTypes = {
   STARTED: "task.background.started",
   PROGRESS: "task.background.progress",
@@ -202,7 +826,7 @@ function ensureSubAgentRegistered(agentComponent, subagentType, basePrompt, subA
   if (registry) {
     const agentDef = registry.get(subagentType);
     if (agentDef?.type === "workflow") {
-      logger.debug(`[delegate] Skipping registration for workflow agent: ${subagentType}`);
+      logger3.debug(`[delegate] Skipping registration for workflow agent: ${subagentType}`);
       return null;
     }
   }
@@ -219,7 +843,7 @@ function ensureSubAgentRegistered(agentComponent, subagentType, basePrompt, subA
       agentConfig.deniedTools = deniedTools;
     }
     agentInstance = agentComponent.registerAgent(subagentType, agentConfig);
-    logger.debug(`[delegate] Registered subagent: ${subagentType}`);
+    logger3.debug(`[delegate] Registered subagent: ${subagentType}`);
   }
   return agentInstance;
 }
@@ -316,11 +940,11 @@ class BackgroundTaskManager {
       return { runIds: [], stopResults: [] };
     }
     const runIds = Array.from(set);
-    logger.info(`[BackgroundTaskManager] propagateStopToWorkflowRuns count=${runIds.length} bgTaskId=${bgTaskId}`);
+    logger3.info(`[BackgroundTaskManager] propagateStopToWorkflowRuns count=${runIds.length} bgTaskId=${bgTaskId}`);
     const stopResults = [];
     for (const runId of runIds) {
       if (typeof this.workflowService?.stopRun !== "function") {
-        logger.warn(`[BackgroundTaskManager] workflowService not injected; cannot stop ${runId}`);
+        logger3.warn(`[BackgroundTaskManager] workflowService not injected; cannot stop ${runId}`);
         stopResults.push({
           runId,
           success: false,
@@ -333,7 +957,7 @@ class BackgroundTaskManager {
         stopResults.push({ runId, success: true });
       } catch (err) {
         const errMsg = err instanceof Error ? err.message : String(err);
-        logger.warn(`[BackgroundTaskManager] workflowService.stopRun(${runId}) failed (likely already terminal): ${errMsg}`);
+        logger3.warn(`[BackgroundTaskManager] workflowService.stopRun(${runId}) failed (likely already terminal): ${errMsg}`);
         stopResults.push({ runId, success: false, error: errMsg });
       }
     }
@@ -344,7 +968,7 @@ class BackgroundTaskManager {
   resolveEntryAgent(subagentType) {
     try {
       if (BackgroundTaskManager.detectWorkflowShortcutCompat(subagentType)) {
-        logger.info(`[BackgroundTaskManager] Compat rewrite: '${subagentType}' → '${BackgroundTaskManager.DEFAULT_WORKFLOW_ENTRY_AGENT}'`);
+        logger3.info(`[BackgroundTaskManager] Compat rewrite: '${subagentType}' → '${BackgroundTaskManager.DEFAULT_WORKFLOW_ENTRY_AGENT}'`);
         return BackgroundTaskManager.DEFAULT_WORKFLOW_ENTRY_AGENT;
       }
       const agentComponent = this.env?.getComponent?.("agent");
@@ -355,7 +979,7 @@ class BackgroundTaskManager {
       }
       return agent.entryAgent ?? BackgroundTaskManager.DEFAULT_WORKFLOW_ENTRY_AGENT;
     } catch (err) {
-      logger.warn(`[BackgroundTaskManager] resolveEntryAgent failed for ${subagentType}: ${err}`);
+      logger3.warn(`[BackgroundTaskManager] resolveEntryAgent failed for ${subagentType}: ${err}`);
       return;
     }
   }
@@ -376,7 +1000,7 @@ class BackgroundTaskManager {
           trigger_session_id: parentSessionId
         }
       });
-      logger.info(`[BackgroundTaskManager] Event published: ${type}`);
+      logger3.info(`[BackgroundTaskManager] Event published: ${type}`);
     }
   }
   async createTask(options) {
@@ -398,7 +1022,7 @@ class BackgroundTaskManager {
       }
       const createdBy = reusedSession?.info?.metadata?.created_by;
       if (createdBy && createdBy !== "subagent") {
-        logger.warn(`[BackgroundTaskManager] Session ${existingSubSessionId} was not created by a sub-agent (created_by=${createdBy}); reusing anyway`);
+        logger3.warn(`[BackgroundTaskManager] Session ${existingSubSessionId} was not created by a sub-agent (created_by=${createdBy}); reusing anyway`);
       }
       subSession = reusedSession;
       try {
@@ -411,9 +1035,9 @@ class BackgroundTaskManager {
           }
         });
       } catch (err) {
-        logger.warn(`[BackgroundTaskManager] Failed to update reused session metadata`, { existingSubSessionId, error: err instanceof Error ? err.message : String(err) });
+        logger3.warn(`[BackgroundTaskManager] Failed to update reused session metadata`, { existingSubSessionId, error: err instanceof Error ? err.message : String(err) });
       }
-      logger.info(`[BackgroundTaskManager] Reusing sub session: ${existingSubSessionId} for task ${taskIdGen}`);
+      logger3.info(`[BackgroundTaskManager] Reusing sub session: ${existingSubSessionId} for task ${taskIdGen}`);
     } else {
       const metadata = {
         subagent_type: subagentType,
@@ -476,7 +1100,7 @@ class BackgroundTaskManager {
     };
     this.publishBackgroundEvent(BackgroundTaskEventTypes.STARTED, startedPayload, parentSessionId);
     this.executeTask(taskIdGen, prompt, timeout, parentSessionId).catch((err) => {
-      logger.error(`[BackgroundTaskManager] executeTask unhandled rejection`, {
+      logger3.error(`[BackgroundTaskManager] executeTask unhandled rejection`, {
         taskId: taskIdGen,
         error: err instanceof Error ? err.message : String(err)
       });
@@ -486,7 +1110,7 @@ class BackgroundTaskManager {
   async executeTask(taskId, prompt, timeout, parentSessionId) {
     const task = this.tasks.get(taskId);
     if (!task) {
-      logger.warn(`[BackgroundTaskManager] executeTask: Task not found`, { taskId });
+      logger3.warn(`[BackgroundTaskManager] executeTask: Task not found`, { taskId });
       return;
     }
     const startedAt = Date.now();
@@ -505,7 +1129,7 @@ class BackgroundTaskManager {
       const taskRegistry = this.processRegistries.get(taskId);
       const result = await this.executeWithAbort(subSession, prompt, timeoutMs, taskId, abortController?.signal, task.similarTaskIds, taskRegistry);
       if (abortController?.signal.aborted) {
-        logger.info(`[BackgroundTaskManager] Task was aborted`, { taskId });
+        logger3.info(`[BackgroundTaskManager] Task was aborted`, { taskId });
         return;
       }
       const completedAt = Date.now();
@@ -532,7 +1156,7 @@ class BackgroundTaskManager {
         associatedTaskId: task.associatedTaskId
       };
       this.publishBackgroundEvent(BackgroundTaskEventTypes.COMPLETED, completedPayload, parentSessionId || task.parentSessionId);
-      logger.info(`[BackgroundTaskManager] Task completed successfully`, {
+      logger3.info(`[BackgroundTaskManager] Task completed successfully`, {
         taskId,
         executionTimeMs
       });
@@ -584,7 +1208,7 @@ class BackgroundTaskManager {
         this.publishBackgroundEvent(BackgroundTaskEventTypes.FAILED, failedPayload, parentSessionId || task.parentSessionId);
       }
       task.error = errorMessage;
-      logger.error(`[BackgroundTaskManager] Task execution error`, {
+      logger3.error(`[BackgroundTaskManager] Task execution error`, {
         taskId,
         status: task.status,
         error: errorMessage
@@ -667,7 +1291,7 @@ ${prompt}
             try {
               const similarTask = await taskComponent.getTask(similarId);
               if (!similarTask) {
-                logger.warn(`[delegate] Similar task #${similarId} not found, skipping`);
+                logger3.warn(`[delegate] Similar task #${similarId} not found, skipping`);
                 continue;
               }
               const operations = await taskComponent.listOperations({ taskId: similarId, limit: 10 });
@@ -693,7 +1317,7 @@ ${prompt}
               }
               similarTasksSections.push(section);
             } catch (err) {
-              logger.warn(`[delegate] Failed to fetch similar task #${similarId}`, { error: err instanceof Error ? err.message : String(err) });
+              logger3.warn(`[delegate] Failed to fetch similar task #${similarId}`, { error: err instanceof Error ? err.message : String(err) });
             }
           }
           if (similarTasksSections.length > 0) {
@@ -716,12 +1340,35 @@ Use these as guidance to improve task execution efficiency.`;
           }
         }
       } catch (err) {
-        logger.warn(`[delegate] Failed to inject similar tasks reference`, { error: err instanceof Error ? err.message : String(err) });
+        logger3.warn(`[delegate] Failed to inject similar tasks reference`, { error: err instanceof Error ? err.message : String(err) });
       }
     }
     if (!agentComponent) {
       throw new Error("AgentComponent not found");
     }
+    try {
+      if (this.env) {
+        const reuseRegistry = getOrCreateTaskReuseRegistry(this.env);
+        const reuseSection = buildReuseCandidateSection({
+          registry: reuseRegistry,
+          similarTaskIds: similarTaskIds ?? [],
+          limit: 5,
+          maxChars: 2000,
+          maxDescriptionChars: 240
+        });
+        if (!reuseSection.isEmpty) {
+          fullPrompt += `
+
+---
+
+${reuseSection.markdown}`;
+        }
+      }
+    } catch (err) {
+      logger3.warn(`[delegate] Failed to inject reuse candidate section`, {
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
     const subAgentForRegister = subAgent ? { ...subAgent, allowedTools } : allowedTools ? {
       id: subagentType,
       name: subagentType,
@@ -738,7 +1385,7 @@ Use these as guidance to improve task execution efficiency.`;
         try {
           await processRegistry?.killAll();
         } catch (err) {
-          logger.warn(`[delegate] ProcessRegistry.killAll failed`, {
+          logger3.warn(`[delegate] ProcessRegistry.killAll failed`, {
             error: err instanceof Error ? err.message : String(err)
           });
         }
@@ -798,7 +1445,7 @@ Use these as guidance to improve task execution efficiency.`;
     try {
       await this.processRegistries.get(taskId)?.killAll();
     } catch (err) {
-      logger.warn(`[delegate] stopTask killAll failed`, {
+      logger3.warn(`[delegate] stopTask killAll failed`, {
         taskId,
         error: err instanceof Error ? err.message : String(err)
       });
@@ -852,7 +1499,7 @@ Use these as guidance to improve task execution efficiency.`;
             stoppedTaskIds.push(taskId);
           }
         } catch (err) {
-          logger.warn(`[BackgroundTaskManager] stopAllForParent failed for ${taskId}: ${err instanceof Error ? err.message : String(err)}`);
+          logger3.warn(`[BackgroundTaskManager] stopAllForParent failed for ${taskId}: ${err instanceof Error ? err.message : String(err)}`);
         }
       }
     }
@@ -863,12 +1510,12 @@ Use these as guidance to improve task execution efficiency.`;
       try {
         await this.processRegistries.get(taskId)?.killAll();
       } catch (err) {
-        logger.warn(`[BackgroundTaskManager] forceStopAllAcrossParents killAll failed for ${taskId}: ${err instanceof Error ? err.message : String(err)}`);
+        logger3.warn(`[BackgroundTaskManager] forceStopAllAcrossParents killAll failed for ${taskId}: ${err instanceof Error ? err.message : String(err)}`);
       }
       try {
         await this.propagateStopToWorkflowRuns(taskId, "force stop all");
       } catch (err) {
-        logger.warn(`[BackgroundTaskManager] forceStopAllAcrossParents propagateStopToWorkflowRuns failed for ${taskId}: ${err instanceof Error ? err.message : String(err)}`);
+        logger3.warn(`[BackgroundTaskManager] forceStopAllAcrossParents propagateStopToWorkflowRuns failed for ${taskId}: ${err instanceof Error ? err.message : String(err)}`);
       }
       let justMarkedStopped = false;
       if (task.status === "running" || task.status === "pending") {
@@ -879,7 +1526,7 @@ Use these as guidance to improve task execution efficiency.`;
           task.abortController?.abort();
           justMarkedStopped = true;
         } catch (err) {
-          logger.warn(`[BackgroundTaskManager] forceStopAllAcrossParents mark stopped failed for ${taskId}: ${err instanceof Error ? err.message : String(err)}`);
+          logger3.warn(`[BackgroundTaskManager] forceStopAllAcrossParents mark stopped failed for ${taskId}: ${err instanceof Error ? err.message : String(err)}`);
         }
       }
       if (justMarkedStopped) {
@@ -903,14 +1550,14 @@ Use these as guidance to improve task execution efficiency.`;
   async dispose() {
     for (const [taskId, controller] of this.abortControllers) {
       controller.abort();
-      logger.debug(`[BackgroundTaskManager] Aborted task: ${taskId}`);
+      logger3.debug(`[BackgroundTaskManager] Aborted task: ${taskId}`);
     }
     this.abortControllers.clear();
     for (const [, registry] of this.processRegistries) {
       try {
         await registry.killAll();
       } catch (err) {
-        logger.warn(`[BackgroundTaskManager] dispose registry.killAll failed`, {
+        logger3.warn(`[BackgroundTaskManager] dispose registry.killAll failed`, {
           error: err instanceof Error ? err.message : String(err)
         });
       }
@@ -921,7 +1568,7 @@ Use these as guidance to improve task execution efficiency.`;
     }
     this.workflowRunRegistries.clear();
     this.tasks.clear();
-    logger.info(`[BackgroundTaskManager] Disposed`);
+    logger3.info(`[BackgroundTaskManager] Disposed`);
   }
 }
 __legacyDecorateClassTS([
@@ -1035,7 +1682,7 @@ No need to poll — just wait for the notification and use \`task_get\` with the
       const params = DelegateToolParameters.parse(args);
       const { description, prompt, subagent_type = "general", timeout, reason, similar_task_ids } = params;
       const parentSessionId = ctx.session_id || "default";
-      logger.info(`[delegate_task] Called: description=${description}, subagent_type=${subagent_type}`);
+      logger3.info(`[delegate_task] Called: description=${description}, subagent_type=${subagent_type}`);
       const registry2 = getAgentRegistry(taskComponent);
       if (!isKnownSubagentType(subagent_type, registry2)) {
         return {
@@ -1083,7 +1730,7 @@ async function handleBackgroundTask(backgroundTaskManager, parentSessionId, desc
         originalPrompt: prompt,
         description
       });
-      logger.info(`[delegate_task] Routing workflow subagent '${subagentType}' → entry-agent '${entryAgent}'`);
+      logger3.info(`[delegate_task] Routing workflow subagent '${subagentType}' → entry-agent '${entryAgent}'`);
     }
     const { taskId: bgProcessId, subSessionId } = await backgroundTaskManager.createTask({
       parentSessionId,