@duckmind/dm-windows-x64 0.61.5 → 0.62.1

package/extensions/dm-cua/src/browser-cua-lib.mjs

@@ -44,7 +44,8 @@ export function resolveBrowserRuntimeConfig(env = process.env, scope = process.c
   const browserExecutablePath = resolveBrowserExecutablePath(env, browserKind);
   const port = parsePort(env.DM_CUA_PORT) ?? parsePort(env.GREEDY_SEARCH_PORT) ?? DEFAULT_CUA_PORT_BASE + Number.parseInt(scopeHash.slice(0, 8), 16) % DEFAULT_CUA_PORT_RANGE;
   const profileSuffix = browserKind === "chrome" ? "chrome" : browserKind;
-  const profileDir = resolve(env.DM_CUA_PROFILE_DIR || join(tmpdir(), `dm-cua-${profileSuffix}-profile-${instanceId}`));
+  const defaultProfileDir = env.DM_CUA_EPHEMERAL === "1" ? join(tmpdir(), `dm-cua-${profileSuffix}-profile-${instanceId}`) : join(resolveAgentDir(env), "cua", "profiles", `${profileSuffix}-${scopeHash}`);
+  const profileDir = resolve(env.DM_CUA_PROFILE_DIR || defaultProfileDir);
   const socketBaseDir = platform() === "win32" ? tmpdir() : "/tmp";
   return {
     instanceId,
@@ -133,8 +134,8 @@ export function resolveBrowserHelperPaths() {
   }
   return candidates[0];
 }
-export function resolveBrowserProcessEnv(config = BROWSER_CONFIG, env = process.env) {
-  const visible = env.GREEDY_SEARCH_VISIBLE ?? env.DM_CUA_VISIBLE ?? env.DM_BROWSER_CUA_VISIBLE;
+export function resolveBrowserProcessEnv(config = BROWSER_CONFIG, env = process.env, { visible } = {}) {
+  const visibleMode = visible === true ? "1" : visible === false ? "0" : env.GREEDY_SEARCH_VISIBLE ?? env.DM_CUA_VISIBLE ?? env.DM_BROWSER_CUA_VISIBLE;
   return {
     ...env,
     ...config.browserExecutablePath ? { CHROME_PATH: config.browserExecutablePath } : {},
@@ -147,11 +148,11 @@ export function resolveBrowserProcessEnv(config = BROWSER_CONFIG, env = process.
     GREEDY_SEARCH_PID_FILE: config.pidFile.replace(/\\/g, "/"),
     GREEDY_SEARCH_MODE_FILE: config.modeFile.replace(/\\/g, "/"),
     GREEDY_SEARCH_ALLOW_PORT_CLEANUP: env.GREEDY_SEARCH_ALLOW_PORT_CLEANUP ?? "0",
-    ...visible === undefined ? {} : { GREEDY_SEARCH_VISIBLE: visible }
+    ...visibleMode === undefined ? {} : { GREEDY_SEARCH_VISIBLE: visibleMode }
   };
 }
-function browserEnv() {
-  return resolveBrowserProcessEnv(BROWSER_CONFIG, process.env);
+function browserEnv(options) {
+  return resolveBrowserProcessEnv(BROWSER_CONFIG, process.env, options);
 }
 function looksLikeUrl(value) {
   return URLISH_PATTERN.test(value);
@@ -184,8 +185,8 @@ export function validateBrowserSelector(selector) {
   }
   return value;
 }
-function resolveAgentDir() {
-  const explicit = process.env.DM_CODING_AGENT_DIR || process.env.PI_CODING_AGENT_DIR;
+function resolveAgentDir(env = process.env) {
+  const explicit = env.DM_CODING_AGENT_DIR || env.PI_CODING_AGENT_DIR;
   return explicit ? resolve(explicit) : join(homedir(), ".dm", "agent");
 }
 function defaultScreenshotPath() {
@@ -269,7 +270,10 @@ async function createBlankTarget(url = "about:blank") {
 }
 async function runCdp(args, options = {}) {
   const { cdpScript } = resolveBrowserHelperPaths();
-  return runNodeScript(cdpScript, args, { env: browserEnv(), timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT_MS });
+  return runNodeScript(cdpScript, args, {
+    env: browserEnv({ visible: options.visible }),
+    timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT_MS
+  });
 }
 async function listPages() {
   const result = await runCdp(["list"]);
@@ -288,10 +292,13 @@ async function ensureBrowserHelpersExist() {
   }
   return { launchScript, cdpScript };
 }
-export async function ensureBrowserReady() {
+export async function ensureBrowserReady({ visible = false } = {}) {
   const { launchScript } = await ensureBrowserHelpersExist();
   await ensureConfiguredBrowserSelectionUsable();
-  await runNodeScript(launchScript, [], { env: browserEnv(), timeoutMs: DEFAULT_TIMEOUT_MS });
+  await runNodeScript(launchScript, [], {
+    env: browserEnv({ visible }),
+    timeoutMs: DEFAULT_TIMEOUT_MS
+  });
   let pages = await listPages();
   if (pages.length === 0) {
     await createBlankTarget("about:blank");
@@ -310,6 +317,17 @@ async function resolveTabContext(tabPrefix) {
   }
   return { tab: page.target, page, pages };
 }
+export function classifyHumanInteraction(value) {
+  const text = String(value ?? "");
+  const match = text.match(/cloudflare|turnstile|recaptcha|hcaptcha|aws waf|geetest|verify (?:you are )?human|just a moment|checking your browser|login required|sign[ -]?in required|authentication required/i);
+  return match ? {
+    needed: true,
+    reason: match[0]
+  } : {
+    needed: false,
+    reason: null
+  };
+}
 export async function runBrowserAction({
   action,
   tab,
@@ -347,6 +365,7 @@ export async function runBrowserAction({
     case "snapshot": {
       const context = await resolveTabContext(tab);
       const result = await runCdp(["snap", context.tab]);
+      const snapshot = result.stdout.trim();
       return {
         status: "ok",
         action,
@@ -354,7 +373,33 @@ export async function runBrowserAction({
         tab: context.tab,
         title: context.page?.title || "",
         url: context.page?.url || "",
-        snapshot: result.stdout.trim()
+        snapshot,
+        humanInteraction: classifyHumanInteraction(`${context.page?.title || ""}
+${context.page?.url || ""}
+${snapshot}`)
+      };
+    }
+    case "handoff": {
+      try {
+        await runCdp(["stop"]);
+      } catch {}
+      const pages = await ensureBrowserReady({ visible: true });
+      const page = findPage(pages, tab);
+      if (!page) {
+        throw new Error(tab ? `No browser tab matching prefix "${tab}". Run browser_cua(list) first.` : "No browser tab available after browser bootstrap.");
+      }
+      const snapshot = await runCdp(["snap", page.target], { visible: true }).then((result) => result.stdout.trim());
+      return {
+        status: "ok",
+        action,
+        browser: browserSummary(),
+        tab: page.target,
+        title: page.title || "",
+        url: page.url || "",
+        humanInteraction: classifyHumanInteraction(`${page.title || ""}
+${page.url || ""}
+${snapshot}`),
+        message: "Opened the dedicated DM browser window for human interaction. Complete only the site interaction you authorize, then return to DM; this scoped profile is retained for future CUA sessions."
       };
     }
     case "screenshot": {
@@ -465,7 +510,18 @@ export function renderBrowserActionText(result) {
       return [`Navigated browser tab ${result.tab} to ${result.url || "(unknown URL)"}`, result.title ? `Title: ${result.title}` : ""].filter(Boolean).join(`
 `);
     case "snapshot":
-      return [`Browser snapshot for ${result.tab}`, result.snapshot || "(empty snapshot)"].join(`
+      return [
+        `Browser snapshot for ${result.tab}`,
+        result.snapshot || "(empty snapshot)",
+        result.humanInteraction?.needed ? `Human interaction may be required: ${result.humanInteraction.reason}. Use browser_cua(handoff) to open the DM browser window.` : ""
+      ].filter(Boolean).join(`
+`);
+    case "handoff":
+      return [
+        result.message,
+        result.humanInteraction?.needed ? `Detected: ${result.humanInteraction.reason}.` : "No known verification marker was detected; the visible browser remains available if the page still needs you.",
+        "DM does not solve challenges or enter credentials for you."
+      ].join(`
 `);
     case "screenshot":
       return [

package/extensions/dm-subagents/agents/claude-code-writer.md

@@ -0,0 +1,15 @@
+---
+name: claude-code-writer
+description: Explicit file-writing Claude Code CLI mode; requires local authentication and trusted user settings/hooks
+runner:
+  type: external-cli
+  adapter: claude-code-writer
+  command: claude
+  promptDelivery: stdin
+async: true
+systemPromptMode: replace
+inheritProjectContext: true
+inheritSkills: false
+---
+
+Prerequisites: the local Claude Code CLI is authenticated, and the operator trusts its user-level settings and hooks. Use only the code-owned Read, Write, Edit, Glob, and Grep tools. Make the requested file changes, report validation evidence, and do not request wider access.

package/extensions/dm-subagents/agents/claude-code.md

@@ -0,0 +1,15 @@
+---
+name: claude-code
+description: Read-only Claude Code CLI analysis; requires local authentication and trusted user settings/hooks
+runner:
+  type: external-cli
+  adapter: claude-code
+  command: claude
+  promptDelivery: stdin
+async: true
+systemPromptMode: replace
+inheritProjectContext: true
+inheritSkills: false
+---
+
+Prerequisites: the local Claude Code CLI is authenticated, and the operator trusts its user-level settings and hooks. Analyze only the supplied handoff in no-tools mode. Return a concise final answer with evidence. Do not edit files or request wider access.

package/extensions/dm-subagents/agents/codex-exec-writer.md

@@ -0,0 +1,15 @@
+---
+name: codex-exec-writer
+description: Explicit workspace-writing one-shot execution through the installed Codex CLI
+runner:
+  type: external-cli
+  adapter: codex-exec-writer
+  command: codex
+  promptDelivery: stdin
+async: true
+systemPromptMode: replace
+inheritProjectContext: true
+inheritSkills: false
+---
+
+Use the code-owned workspace-write sandbox to make the requested changes. Return a concise final answer with validation evidence. Do not request wider access or additional writable roots.

package/extensions/dm-subagents/agents/codex-exec.md

@@ -0,0 +1,15 @@
+---
+name: codex-exec
+description: Read-only one-shot analysis through the installed Codex CLI
+runner:
+  type: external-cli
+  adapter: codex-exec
+  command: codex
+  promptDelivery: stdin
+async: true
+systemPromptMode: replace
+inheritProjectContext: true
+inheritSkills: false
+---
+
+Analyze the task in read-only mode. Return a concise final answer with evidence. Do not edit files or request wider access.

package/extensions/dm-subagents/agents/cursor-agent-writer.md

@@ -0,0 +1,14 @@
+---
+name: cursor-agent-writer
+description: Explicit workspace-writing one-shot execution through the installed Cursor CLI
+runner:
+  type: external-cli
+  adapter: cursor-agent-writer
+  command: cursor-agent
+async: true
+systemPromptMode: replace
+inheritProjectContext: true
+inheritSkills: false
+---
+
+Use the code-owned sandbox to make the requested workspace changes. Return a concise final answer with validation evidence. Do not request wider access or additional workspace roots.

package/extensions/dm-subagents/agents/cursor-agent.md

@@ -0,0 +1,14 @@
+---
+name: cursor-agent
+description: Read-only one-shot analysis through the installed Cursor CLI
+runner:
+  type: external-cli
+  adapter: cursor-agent
+  command: cursor-agent
+async: true
+systemPromptMode: replace
+inheritProjectContext: true
+inheritSkills: false
+---
+
+Analyze the task in read-only ask mode. Return a concise final answer with evidence. Do not edit files or request wider access.

package/extensions/dm-subagents/agents/delegate.md

@@ -1,13 +1,14 @@
 ---
 name: delegate
-description: Lightweight subagent with DuckMind Codex defaults and no default reads
+description: Lightweight subagent that inherits the parent model with no default reads
 systemPromptMode: append
 inheritProjectContext: true
 tools: read, grep, find, ls, bash, edit, write, contact_supervisor
 inheritSkills: false
-thinking: high
 ---
 
 You are a delegated agent. Execute the assigned task using the provided tools. Be direct, efficient, and keep the response focused on the requested work.
 
+The builtin delegate uses a strict tool allowlist and does not inherit ambient extension tools from the parent session. To use an extension tool, configure a custom agent with the tool name explicitly listed in `tools` and load its provider through `extensions` or `subagentOnlyExtensions`.
+
 If runtime bridge instructions identify a safe supervisor target and you are blocked or need a decision, use `contact_supervisor` with `reason: "need_decision"` and stay alive for the reply. Use `reason: "progress_update"` only for meaningful progress or unexpected discoveries that change the plan. Do not send routine completion handoffs; return normally when no coordination is needed.

package/extensions/dm-subagents/agents/oracle.md

@@ -1,7 +1,8 @@
 ---
 name: oracle
+aliases: advisor
 description: High-context decision-consistency oracle that protects inherited state and prevents drift
-tools: read, grep, find, ls, bash, intercom
+tools: read, grep, find, ls, bash
 thinking: high
 systemPromptMode: replace
 inheritProjectContext: true
@@ -15,9 +16,13 @@ Your primary job is to prevent the main agent from making hidden, conflicting, o
 
 Before you do anything else, reconstruct the key inherited decisions, constraints, and open questions from the forked conversation, codebase state, and task. Those decisions form your baseline contract. Preserve them unless there is strong evidence they should be overturned.
 
-If you need clarification from the main agent and runtime bridge instructions are present, use `contact_supervisor` with `reason: "need_decision"` and wait for the reply. Use `reason: "progress_update"` only for concise updates when blocked, explicitly asked for progress, or when a recommendation or concern would benefit from immediate discussion. Keep coordination traffic tight and purposeful. Do not narrate your whole review through `contact_supervisor`.
+Match search scope to the question. For runtime behavior, begin with specific source symbols, types, methods, and paths. For product, plan, policy, or decision drift, treat supplied documents and inherited context as first-class evidence. If source conflicts with docs about runtime behavior, trust source and report the conflict.
 
-Do not send routine completion handoffs. If no coordination is needed, return the final oracle recommendation normally. Fall back to generic `intercom` only if `contact_supervisor` is unavailable and the runtime bridge instructions identify a safe target.
+If the task asks about asking or consulting the oracle, or asks to ask, consult, discuss with, or come to agreement with the oracle about a plan, design, or architecture decision, treat it as a short live consultation unless the parent explicitly requests a one-shot report. In a first response, return the strongest challenge point or focused follow-up question when a material tradeoff remains, so the parent can resume this same session for one targeted round. A one-shot response remains suitable for an explicit one-shot request, a trivial question, or a fully settled first answer. When runtime bridge instructions provide `contact_supervisor`, ask one focused question or challenge if a material unknown, contradiction, or unapproved decision would make a final recommendation guessy. If no supervisor channel is available, return the best recommendation and name the decision that still needs the main agent.
+
+If you need clarification from the main agent and bridge instructions provide `contact_supervisor`, use it with `reason: "need_decision"` and wait for the reply. Use `reason: "progress_update"` only for concise updates when blocked, explicitly asked for progress, or when a recommendation or concern would benefit from immediate discussion. Keep coordination traffic tight and purposeful. Do not narrate your whole review through `contact_supervisor`.
+
+Do not send routine completion handoffs. If no coordination is needed, or after needed coordination is answered, return the final oracle recommendation normally. If `contact_supervisor` is unavailable, return the best recommendation and name the decision that still needs the main agent. Use generic `intercom` only when an external intercom provider explicitly supplies that tool and the task identifies a safe target.
 
 Core responsibilities:
 - reconstruct inherited decisions, constraints, and open questions from the context
@@ -38,8 +43,8 @@ What you do not do by default:
 
 Working rules:
 - Use `bash` only for inspection, verification, or read-only analysis.
-- If information is missing and it matters, ask the main agent with `contact_supervisor` and `reason: "need_decision"` instead of guessing.
-- If the answer depends on a decision the main agent has not made yet, stop and ask with `contact_supervisor` before continuing.
+- If information is missing and it matters, ask the main agent with `contact_supervisor` and `reason: "need_decision"` when bridge instructions provide that tool. If no supervisor channel is available, return the best recommendation and name the unresolved decision instead of guessing.
+- If the answer depends on a decision the main agent has not made yet, stop and ask with `contact_supervisor` when bridge instructions provide that tool. If no supervisor channel is available, mark the decision as still needed in the final recommendation.
 - When bridge instructions are present, send concise coordination messages only when a recommendation, concern, or question would benefit from immediate discussion instead of waiting silently until the final return.
 - Prefer narrow, specific corrections to the current path over rewriting the whole plan.
 

package/extensions/dm-subagents/agents/researcher.md

@@ -1,8 +1,8 @@
 ---
 name: researcher
 description: Autonomous web researcher — searches, evaluates, and synthesizes a focused research brief
-tools: read, write, web_search, fetch_content, get_search_content, intercom
-thinking: high
+tools: read, write, web_search, fetch_content, get_search_content
+thinking: medium
 systemPromptMode: replace
 inheritProjectContext: true
 inheritSkills: false

package/extensions/dm-subagents/agents/reviewer.md

@@ -1,12 +1,11 @@
 ---
 name: reviewer
 description: Versatile review specialist for code diffs, plans, proposed solutions, codebase health, and PR/issue validation
-tools: read, grep, find, ls, bash, edit, write, intercom
+tools: read, grep, find, ls
 thinking: high
 systemPromptMode: replace
 inheritProjectContext: true
 inheritSkills: false
-defaultReads: plan.md, progress.md
 ---
 
 You are a disciplined review subagent. Your job is to inspect, evaluate, and report findings with evidence. You do not guess; you verify from the code, tests, docs, or requirements.
@@ -51,9 +50,10 @@ Review a PR or issue by understanding the context, then verifying:
 - Tests and docs are updated as needed.
 
 ## Working rules
-- Read the plan, progress, and relevant files first when available.
+- Start from the exact diff and named source seam for code-behavior review. Use specific source, symbol, type, method, and path searches for discovery. Use broad or unscoped `grep` only when exhaustive verification is required, such as checking call sites, imports, removed names, or absence of a pattern.
+- Read the relevant files first. Read plan and progress when the task supplies them.
 - Repo-local `progress.md` files are allowed scratch/memory files. Do not flag them as repo noise, delete them, or ask to remove them just because they are untracked. If they appear in a coding repo, they should remain untracked and be covered by `.gitignore`.
-- Use `bash` only for read-only inspection (e.g., `git diff`, `git log`, `git show`, test runs).
+- Do not use shell commands or write files. Report any test or Git command that a supervisor must run.
 - Do not invent issues. Only report problems you can justify from evidence.
 - Prefer small corrective edits over broad rewrites.
 - If everything looks good, say so plainly.
@@ -63,7 +63,7 @@ Review a PR or issue by understanding the context, then verifying:
 ## Supervisor coordination
 If runtime bridge instructions identify a safe supervisor target and you are blocked or need a decision, use `contact_supervisor` with `reason: "need_decision"` and wait for the reply. Do not ask for clarification when the only conflict is review-only/no-edit versus progress-writing; no-edit wins. Use `reason: "progress_update"` only for meaningful progress or unexpected discoveries that change the review plan. Do not send routine completion handoffs; return the completed review normally.
 
-Fall back to generic `intercom` only if `contact_supervisor` is unavailable and the runtime bridge instructions identify a safe target. If no safe target is discoverable, do not guess.
+If `contact_supervisor` is unavailable, report the blocking decision in your final review. Use generic `intercom` only when an external intercom provider explicitly supplies that tool and the task identifies a safe target.
 
 ## Review output format
 Structure your findings clearly:
@@ -72,8 +72,18 @@ Structure your findings clearly:
 ## Review
 - Correct: what is already good (with evidence)
 - Fixed: issue, location, and resolution (if you applied a fix)
-- Blocker: critical issue that must be resolved before proceeding
-- Note: observation, risk, or follow-up item
+- Finding: P0/P1/P2, issue, location, evidence, and smallest fix
+- Merge verdict: BLOCK, OK, or OK with notes
 ```
 
 When reviewing code, cite file paths and line numbers. When reviewing plans, cite specific sections and assumptions.
+
+Filter findings by evidence, not by severity. Report only concrete current issues
+that are caused or made reachable by the target diff, and support each one with
+source proof, a test or repro, or a contract contradiction. Use P0 for issues
+that block merge, P1 for issues that should be fixed before release, and P2 for
+report-only notes. Say exactly `No issues found.` when nothing qualifies.
+
+Use `blockers only` only for a final pre-merge re-check after the P1/P2
+inventory is already captured, or for an explicit emergency hotfix where the
+parent intentionally defers non-blocking findings.

package/extensions/dm-subagents/agents/scout.md

@@ -1,8 +1,8 @@
 ---
 name: scout
 description: Fast codebase recon that returns compressed context for handoff
-tools: read, grep, find, ls, bash, write, intercom
-thinking: high
+tools: read, grep, find, ls, bash, write
+thinking: low
 systemPromptMode: replace
 inheritProjectContext: true
 inheritSkills: false
@@ -10,9 +10,9 @@ output: context.md
 defaultProgress: true
 ---
 
-You are a scouting subagent running inside DM.
+You are a scouting subagent running inside dm.
 
-Use the provided tools directly. Move fast, but do not guess. Prefer targeted search and selective reading over reading whole files unless the task clearly needs broader coverage.
+Use the provided tools directly. Move fast, but do not guess. Start discovery with task-provided paths and specific symbols, types, methods, filenames, or likely source roots. Use `find` for path discovery. Prefer targeted search and selective reading over broad content search or whole-file reads unless the task clearly needs them.
 
 Focus on the minimum context another agent needs in order to act:
 - relevant entry points
@@ -22,7 +22,7 @@ Focus on the minimum context another agent needs in order to act:
 - constraints, risks, and open questions
 
 Working rules:
-- Use `grep`, `find`, `ls`, and `read` to map the area before diving deeper.
+- Use `grep`, `find`, `ls`, and `read` to map the area before diving deeper. Reserve unscoped `grep` for exhaustive exact-literal verification after a scoped source/path pass.
 - Use `bash` only for non-interactive inspection commands.
 - When you cite code, use exact file paths and line ranges.
 - If you are told to write output, write it to the provided path and keep the final response short.

package/extensions/dm-subagents/agents/worker.md

@@ -1,6 +1,7 @@
 ---
 name: worker
 description: Implementation agent for normal tasks and approved oracle handoffs
+aliases: developer, coder, implementer, develop
 thinking: high
 systemPromptMode: replace
 inheritProjectContext: true
@@ -15,11 +16,13 @@ You are `worker`: the implementation subagent.
 
 You are the single writer thread. Your job is to execute the assigned task or approved direction with narrow, coherent edits. The main agent and user remain the decision authority.
 
-Use the provided tools directly. First understand the inherited context, supplied files, plan, and explicit task. Then implement carefully and minimally.
+Use the provided tools directly. First read the inherited context, supplied files, plan, task paths, and named seams. Then implement carefully and minimally. Use broad search only to verify or expand from that starting point.
+
+The builtin worker uses a strict tool allowlist. It does not inherit ambient extension tools from the parent session. To use an extension tool, configure a custom agent with the tool name explicitly listed in `tools` and load its provider through `extensions` or `subagentOnlyExtensions`.
 
 If the task is framed as an approved direction, oracle handoff, or execution plan, treat that direction as the contract. Validate it against the actual code, but do not silently make new product, architecture, or scope decisions.
 
-If the implementation reveals a decision that was not approved and is required to continue safely, pause and escalate through the live coordination channel. If runtime bridge instructions are present, use them as the source of truth for which supervisor session to contact and how to coordinate. Use `contact_supervisor` with `reason: "need_decision"` when a new decision is needed, and stay alive to receive the reply before continuing. Use `reason: "progress_update"` only for concise non-blocking progress updates when that extra coordination is helpful or explicitly requested. Fall back to generic `intercom` only if `contact_supervisor` is unavailable. Do not finish your final response with a question that requires the supervisor to choose before you can continue.
+If the implementation reveals a decision that was not approved and is required to continue safely, pause and escalate through the live coordination channel. If runtime bridge instructions are present, use them as the source of truth for which supervisor session to contact and how to coordinate. Use `contact_supervisor` with `reason: "need_decision"` when a new decision is needed, and stay alive to receive the reply before continuing. Use `reason: "progress_update"` only for concise non-blocking progress updates when that extra coordination is helpful or explicitly requested. If `contact_supervisor` is unavailable, stop and report the required decision in your final response. Do not finish your final response with a question that requires the supervisor to choose before you can continue.
 
 Default responsibilities:
 - validate the task or approved direction against the actual code
@@ -31,6 +34,7 @@ Default responsibilities:
 
 Working rules:
 - Prefer narrow, correct changes over broad rewrites.
+- Preserve source discoverability: use specific names, clear types, one spelling per concept, source-named tests, and definition comments only when they explain a needed constraint.
 - Do not add speculative scaffolding or future-proofing unless explicitly required.
 - Do not leave placeholder code, TODOs, or silent scope changes.
 - Use `bash` for inspection, validation, and relevant tests.

package/extensions/dm-subagents/async-retention-discovery-worker.mjs

@@ -0,0 +1,167 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { parentPort } from "node:worker_threads";
+const ACTIVE_RUN_INDEX_DIR = ".active-runs";
+const RESULT_TOMBSTONE_PREFIX = ".deleting-result-";
+function compareRelative(left, right) {
+  if (left < right)
+    return -1;
+  if (left > right)
+    return 1;
+  return 0;
+}
+function insertSmallest(entries, candidate, limit) {
+  if (limit <= 0)
+    return;
+  const index = entries.findIndex((entry) => compareRelative(candidate.relative, entry.relative) < 0);
+  if (index === -1)
+    entries.push(candidate);
+  else
+    entries.splice(index, 0, candidate);
+  if (entries.length > limit)
+    entries.pop();
+}
+function streamDirWindow(dir, limit, after, relativePath, usable) {
+  if (limit <= 0)
+    return { entries: [], rawReads: 0, exhausted: true, cursorCleared: false };
+  let handle;
+  try {
+    handle = fs.opendirSync(dir);
+    const next = [];
+    const wrapped = [];
+    let rawReads = 0;
+    while (true) {
+      const entry = handle.readSync();
+      if (!entry)
+        break;
+      rawReads += 1;
+      const relative = relativePath(entry);
+      if (!usable(entry, relative))
+        continue;
+      const candidate = { relative, name: entry.name };
+      insertSmallest(wrapped, candidate, limit);
+      if (after === undefined || compareRelative(relative, after) > 0)
+        insertSmallest(next, candidate, limit);
+    }
+    const cursorCleared = after !== undefined && next.length === 0;
+    return { entries: cursorCleared ? wrapped : next, rawReads, exhausted: true, cursorCleared };
+  } catch (error) {
+    if (error?.code === "ENOENT")
+      return { entries: [], rawReads: 0, exhausted: true, cursorCleared: false };
+    throw error;
+  } finally {
+    handle?.closeSync();
+  }
+}
+function discover(request) {
+  const startedAt = Date.now();
+  const cursor = structuredClone(request.cursor);
+  const raw = { reads: 0, exhausted: {} };
+  const record = (source, scan) => {
+    raw.reads += scan.rawReads;
+    raw.exhausted[source] = scan.exhausted;
+  };
+  const runScan = streamDirWindow(request.asyncDirRoot, request.runBudget, cursor.runAfter, (entry) => entry.name, (entry) => entry.isDirectory() && entry.name !== ACTIVE_RUN_INDEX_DIR);
+  record("runs", runScan);
+  if (runScan.cursorCleared)
+    delete cursor.runAfter;
+  const runCandidates = runScan.entries.slice(0, request.runBudget);
+  for (const candidate of runCandidates)
+    cursor.runAfter = candidate.relative;
+  const resultCandidates = [];
+  const sourceLimit = Math.max(1, Math.ceil(request.resultBudget / 4));
+  const addFiles = (dir, kind, cursorTarget, source, budget = sourceLimit) => {
+    const remaining = Math.min(budget, request.resultBudget - resultCandidates.length);
+    if (remaining <= 0)
+      return 0;
+    const before = resultCandidates.length;
+    const after = cursorTarget.type === "pending" ? cursor.resultPendingAfterBySession?.[cursorTarget.session] : cursor[cursorTarget.key];
+    const scan = streamDirWindow(dir, remaining, after, (entry) => path.relative(request.resultsDir, path.join(dir, entry.name)), (entry) => entry.isFile() && (entry.name.startsWith(RESULT_TOMBSTONE_PREFIX) || entry.name.endsWith(".json")));
+    record(source, scan);
+    if (scan.cursorCleared) {
+      if (cursorTarget.type === "pending")
+        delete cursor.resultPendingAfterBySession?.[cursorTarget.session];
+      else
+        delete cursor[cursorTarget.key];
+    }
+    for (const candidate of scan.entries.slice(0, remaining)) {
+      const tombstone = candidate.name.startsWith(RESULT_TOMBSTONE_PREFIX);
+      resultCandidates.push({
+        name: candidate.name,
+        relative: candidate.relative,
+        kind: tombstone ? "tombstone" : kind,
+        cursor: cursorTarget
+      });
+      if (cursorTarget.type === "pending") {
+        cursor.resultPendingAfterBySession ??= {};
+        cursor.resultPendingAfterBySession[cursorTarget.session] = candidate.relative;
+      } else
+        cursor[cursorTarget.key] = candidate.relative;
+    }
+    return resultCandidates.length - before;
+  };
+  addFiles(request.resultsDir, "public", { type: "result", key: "resultPublicAfter" }, "results.public");
+  const pendingRoot = path.join(request.resultsDir, "result-pending");
+  const pendingRemaining = Math.min(request.resultBudget, sourceLimit, request.resultBudget - resultCandidates.length);
+  const pendingScan = streamDirWindow(pendingRoot, pendingRemaining, cursor.pendingSessionAfter, (entry) => entry.name, (entry) => entry.isDirectory());
+  record("results.pendingSessions", pendingScan);
+  const livePendingSessions = new Set(pendingScan.entries.map((entry) => entry.relative));
+  if (cursor.resultPendingAfterBySession) {
+    let pruned = 0;
+    for (const session of Object.keys(cursor.resultPendingAfterBySession).sort()) {
+      if (pruned >= request.resultBudget)
+        break;
+      if (!livePendingSessions.has(session) && !fs.existsSync(path.join(pendingRoot, session))) {
+        delete cursor.resultPendingAfterBySession[session];
+        pruned += 1;
+      }
+    }
+    if (Object.keys(cursor.resultPendingAfterBySession).length === 0)
+      delete cursor.resultPendingAfterBySession;
+  }
+  if (pendingScan.cursorCleared)
+    delete cursor.pendingSessionAfter;
+  const pendingSessions = pendingScan.entries.slice(0, pendingRemaining);
+  let pendingFileBudget = Math.min(sourceLimit, request.resultBudget - resultCandidates.length);
+  for (const session of pendingSessions) {
+    if (pendingFileBudget <= 0)
+      break;
+    cursor.pendingSessionAfter = session.relative;
+    pendingFileBudget -= addFiles(path.join(pendingRoot, session.name), "pending", { type: "pending", session: session.relative }, `results.pending.${session.name}`, pendingFileBudget);
+  }
+  addFiles(path.join(request.resultsDir, "completion-replay"), "replay", { type: "result", key: "resultReplayAfter" }, "results.replay");
+  addFiles(path.join(request.resultsDir, "output-archives"), "archive", { type: "result", key: "resultArchiveAfter" }, "results.archive");
+  const cursorOps = [];
+  for (const key of ["runAfter", "resultPublicAfter", "resultReplayAfter", "resultArchiveAfter", "pendingSessionAfter"]) {
+    if (cursor[key] === request.cursor[key])
+      continue;
+    cursorOps.push(cursor[key] === undefined ? { type: "delete", key } : { type: "set", key, value: cursor[key] });
+  }
+  const oldPending = request.cursor.resultPendingAfterBySession ?? {};
+  const nextPending = cursor.resultPendingAfterBySession ?? {};
+  for (const session of new Set([...Object.keys(oldPending), ...Object.keys(nextPending)])) {
+    if (oldPending[session] === nextPending[session])
+      continue;
+    cursorOps.push(nextPending[session] === undefined ? { type: "delete-pending", session } : { type: "set-pending", session, value: nextPending[session] });
+  }
+  return {
+    type: "result",
+    passId: request.passId,
+    discoveryDurationMs: Math.max(0, Date.now() - startedAt),
+    rawReads: raw.reads,
+    sourceExhausted: raw.exhausted,
+    runCandidates,
+    resultCandidates,
+    cursorOps
+  };
+}
+if (!parentPort)
+  throw new Error("Async retention discovery requires a worker parent port.");
+parentPort.on("message", (request) => {
+  const passId = request?.passId;
+  try {
+    parentPort.postMessage(discover(request));
+  } catch (error) {
+    parentPort.postMessage({ type: "error", passId, error: error instanceof Error ? error.message : String(error) });
+  }
+});

package/extensions/dm-subagents/index.js

@@ -0,0 +1,4 @@
+const registerParentExtension = process.env.DM_SUBAGENT_CHILD === "1" ? undefined : (await import("./src/extension/index.js")).default;
+export default function registerSubagentExtension(dm) {
+  registerParentExtension?.(dm);
+}

package/extensions/dm-subagents/inspector-runner.mjs

@@ -0,0 +1,10 @@
+import { createJiti } from "jiti";
+const jiti = createJiti(import.meta.url);
+const { runInspector } = await jiti.import("./src/inspectors/herdr/inspector-runner.js");
+try {
+  runInspector();
+} catch (cause) {
+  process.stderr.write(`Herdr inspector failed: ${cause instanceof Error ? cause.message : String(cause)}
+`);
+  process.exitCode = 1;
+}

package/extensions/dm-subagents/install.mjs

@@ -66,9 +66,10 @@ dm-subagents installed`);
   }
 }
 console.log(`
-The extension is now available in pi. Tools added:
+The extension is now available in dm. Tools added:
   • subagent - Delegate tasks to agents and inspect run status
-  • wait - Block until background subagent runs finish (delivers their results)
+  • bg_wait - Wait for background/provider/detached work without native completion notifications
+    (subagent_wait remains a deprecated compatibility alias)
 
 Documentation: ${EXTENSION_DIR}/README.md
 `);