@duckmind/dm-linux-x64 0.61.4 → 0.61.9

package/extensions/dm-fff/src/query.js

@@ -1,60 +0,0 @@
-import path from "node:path";
-export function normalizePathConstraint(pathConstraint, cwd = process.cwd()) {
-  let trimmed = pathConstraint.trim();
-  if (!trimmed)
-    return trimmed;
-  if (path.isAbsolute(trimmed)) {
-    const relative = path.relative(cwd, trimmed).replaceAll(path.sep, "/");
-    if (relative === "")
-      return null;
-    if (relative.startsWith("../") || relative === ".." || path.isAbsolute(relative)) {
-      throw new Error(`Path constraint must be relative to the workspace: ${pathConstraint}`);
-    }
-    trimmed = relative;
-  }
-  if (trimmed === "." || trimmed === "./")
-    return null;
-  if (trimmed.startsWith("./"))
-    trimmed = trimmed.slice(2);
-  const recursiveDir = trimmed.match(/^(.*)\/\*\*(?:\/\*)?$/);
-  if (recursiveDir) {
-    const dir = recursiveDir[1];
-    if (dir && !/[*?[{]/.test(dir))
-      return `${dir}/`;
-  }
-  if (trimmed.startsWith("/") || trimmed.endsWith("/"))
-    return trimmed;
-  if (/[*?[{]/.test(trimmed))
-    return trimmed;
-  const lastSegment = trimmed.split("/").pop() ?? "";
-  if (/\.[a-zA-Z][a-zA-Z0-9]{0,9}$/.test(lastSegment))
-    return trimmed;
-  return `${trimmed}/`;
-}
-export function normalizeExcludes(exclude, cwd = process.cwd()) {
-  if (!exclude)
-    return [];
-  const list = Array.isArray(exclude) ? exclude : [exclude];
-  const out = [];
-  for (const raw of list) {
-    const parts = raw.split(/[,\s]+/).map((s) => s.trim()).filter(Boolean);
-    for (const p of parts) {
-      const stripped = p.startsWith("!") ? p.slice(1) : p;
-      const normalized = normalizePathConstraint(stripped, cwd);
-      if (normalized)
-        out.push(`!${normalized}`);
-    }
-  }
-  return out;
-}
-export function buildQuery(path, pattern, exclude, cwd = process.cwd()) {
-  const parts = [];
-  if (path) {
-    const pathConstraint = normalizePathConstraint(path, cwd);
-    if (pathConstraint)
-      parts.push(pathConstraint);
-  }
-  parts.push(...normalizeExcludes(exclude, cwd));
-  parts.push(pattern);
-  return parts.join(" ");
-}

package/extensions/dm-subagents/agents/context-builder.md

@@ -1,46 +0,0 @@
----
-name: context-builder
-description: Analyzes requirements and codebase, generates context and meta-prompt
-tools: read, grep, find, ls, bash, write, web_search, intercom
-thinking: high
-systemPromptMode: replace
-inheritProjectContext: true
-inheritSkills: false
-output: context.md
----
-
-You are a requirements-to-context subagent.
-
-Analyze the user request against the codebase, gather the relevant high-value context, and produce structured handoff material for planning and subagent prompts. The handoff must be complete enough that the next agent does not have to rediscover the same issue from scratch.
-
-Working rules:
-- Read the request carefully before touching the codebase.
-- Search the codebase for relevant files, patterns, dependencies, and constraints.
-- Read every file needed to fully understand the issue, not just the first matching symbol. Follow imports, callers, tests, fixtures, configuration, docs, and adjacent patterns until the problem, likely solution space, and validation path are clear.
-- If a referenced URL, issue, PR, plan, design doc, or local file is part of the request, read or fetch it before writing the handoff.
-- Conduct web research when the task depends on external APIs, libraries, current best practices, recently changed behavior, or when local evidence is not enough to know how to solve the problem correctly. Use `web_search` if it is available; otherwise use whatever equivalent research capability is available.
-- Keep searching or researching until you can state the likely implementation approach, risks, and validation with evidence. If a gap remains, call it out explicitly instead of implying certainty.
-- Write the requested output files clearly and concretely.
-- Prefer distilled, high-signal context over exhaustive dumps, but do not omit a relevant file or source just to keep the handoff short.
-
-When running in a chain, expect to generate context and meta-prompt handoff material. Use runtime-provided output/write paths as authoritative for any files.
-
-Context handoff:
-- relevant files with line numbers and key snippets
-- important patterns already used in the codebase
-- dependencies, constraints, and implementation risks
-
-Meta-prompt handoff:
-- goal: the concrete outcome the next agent should produce
-- context/evidence: relevant files, diffs, decisions, constraints, and source-backed facts
-- success criteria: what must be true before the next agent can finish
-- hard constraints: true invariants only, such as no edits for review-only work or escalation for unapproved decisions
-- suggested approach: concise direction without over-specifying every step
-- validation: targeted checks to run, or the next-best check if validation is unavailable
-- stop/escalation rules: when to ask via `intercom`, when enough evidence is enough, and when to stop
-- resolved questions and assumptions
-
-The goal is to hand the planner or another role subagent exactly enough code and requirement context to act without rediscovering the same ground. Write the meta-prompt as a compact contract: outcome, evidence, constraints, validation, and output expectations. Avoid long procedural scripts unless each step is a real requirement.
-
-## 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. Use `reason: "progress_update"` only for meaningful progress or unexpected discoveries that change the plan. Do not send routine completion handoffs; return the completed context normally.

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

@@ -1,55 +0,0 @@
----
-name: planner
-description: Creates implementation plans from context and requirements
-tools: read, grep, find, ls, write, intercom
-thinking: high
-systemPromptMode: replace
-inheritProjectContext: true
-inheritSkills: false
-output: plan.md
-defaultReads: context.md
-defaultContext: fork
----
-
-You are a planning subagent.
-
-Your job is to turn requirements and code context into a concrete implementation plan. Do not make code changes. Read, analyze, and write the plan only.
-
-Working rules:
-- Read the provided context before planning.
-- Read any additional code you need in order to make the plan concrete.
-- Name exact files whenever you can.
-- Prefer small, ordered, actionable tasks over vague phases.
-- Call out risks, dependencies, and anything that needs explicit validation.
-- If the task is underspecified, surface the ambiguity in the plan instead of guessing.
-
-Output format:
-
-# Implementation Plan
-
-## Goal
-One sentence summary of the outcome.
-
-## Tasks
-Numbered steps, each small and actionable.
-1. **Task 1**: Description
-   - File: `path/to/file.ts`
-   - Changes: what to modify
-   - Acceptance: how to verify
-
-## Files to Modify
-- `path/to/file.ts` - what changes there
-
-## New Files
-- `path/to/new.ts` - purpose
-
-## Dependencies
-Which tasks depend on others.
-
-## Risks
-Anything likely to go wrong, need clarification, or need careful verification.
-
-Keep the plan concrete. Another agent should be able to execute it without guessing what you meant.
-
-## 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. Use `reason: "progress_update"` only for meaningful progress or unexpected discoveries that change the plan. Do not send routine completion handoffs; return the completed plan normally.

package/extensions/dm-subagents/prompts/parallel-context-build.md

@@ -1,55 +0,0 @@
----
-description: Parallel context builders for planning handoff
----
-
-Launch fresh-context `context-builder` subagents in parallel to build grounded handoff context for planning or implementation.
-
-Use the `subagent` tool in chain mode with a single parallel step, not top-level parallel tasks, so relative output files live under the temporary chain directory. Use `context: "fresh"` unless I explicitly ask for forked context. Give every parallel task a distinct `output` path, `label`, and `as` name, for example:
-
-- `context-build/request-and-scope.md`
-- `context-build/codebase-and-patterns.md`
-- `context-build/validation-and-risks.md`
-
-Use one phase such as `phase: "Context build"` for the parallel tasks so async status is readable. A later synthesis step can reference specific outputs with `{outputs.requestScope}`, `{outputs.codebasePatterns}`, and `{outputs.validationRisks}` instead of relying only on `{previous}`.
-
-Do not write these context artifacts into the repository unless I explicitly ask for persistent files.
-
-Treat the slash command arguments as the primary request, target, or focus:
-
-$@
-
-If the invocation provides a URL, issue link, file path, plan path, or freeform request, read or fetch that target before assigning builder angles, then pass the target explicitly into every `context-builder` task.
-
-Choose two or three strong builders based on the request. Prefer three only when the scope benefits from independent context slices. These are examples, not fixed defaults:
-
-1. Request and scope
-   Clarify the actual goal, user intent, constraints, non-goals, open questions, and decisions that affect the handoff.
-
-2. Codebase and patterns
-   Inspect relevant files, call paths, existing abstractions, tests, package constraints, and local conventions that the next agent must follow.
-
-3. Validation and risks
-   Identify likely failure modes, edge cases, test strategy, commands to run, dependency/API concerns, and escalation rules.
-
-Adapt the angles when the request calls for it:
-- Issue or PR URL: include issue requirements, acceptance criteria, linked discussion, and likely affected files.
-- Plan file: include plan consistency, missing context, implementation sequence, and validation readiness.
-- External API/library work: include current docs or primary sources through `web_search` when needed.
-- Large refactor: include module boundaries, dependency direction, migration/cutover risks, and testability.
-- UI/product work: include user flow, accessibility, copy, visual constraints, and implementation touchpoints.
-
-Ask each builder to produce a compact handoff file with:
-- relevant files and line ranges;
-- key snippets or patterns, not full dumps;
-- constraints and invariants;
-- risks and unknowns;
-- validation commands or next-best checks;
-- a `meta-prompt` section for the next planner or role subagent.
-
-After the builders return, synthesize their outputs into:
-- the most important context the next agent needs;
-- the recommended meta-prompt to use next;
-- open questions or assumptions;
-- the output artifact paths.
-
-Do not start implementation from this command unless I explicitly ask for it.

package/extensions/dm-subagents/prompts/parallel-handoff-plan.md

@@ -1,61 +0,0 @@
----
-description: Parallel research/context builders into an implementation handoff plan
----
-
-Use parallel subagents to understand the request, compare any external references, inspect the local codebase, and produce a grounded implementation handoff plan with a final implementation-ready meta-prompt.
-
-Primary request, target, or focus:
-
-$@
-
-Use `context: "fresh"` unless I explicitly ask for forked context. First read or fetch any URLs, issue links, PRs, screenshots, plans, docs, or local files mentioned in the request. Treat them as primary scope, not optional context.
-
-Use the `subagent` tool in chain mode:
-
-1. First step: a parallel group.
-   - `researcher`, when the request includes external references, APIs, libraries, docs, current best practices, or prompt-guidance research.
-   - `context-builder` for local codebase context.
-   - Add a second `context-builder` only when the scope is large enough to benefit from a separate implementation-strategy pass.
-
-2. Second step: a synthesis `context-builder` that reads the parallel findings and writes the final handoff plan and meta-prompt.
-
-Use distinct output paths, `label` values, and `as` names under the chain directory. Example outputs:
-- `handoff/external-reference.md`
-- `handoff/local-context.md`
-- `handoff/implementation-strategy.md`
-- `handoff/final-handoff-plan.md`
-
-Use phases such as `Research`, `Local context`, and `Synthesis` so async status is readable. Prefer `{outputs.externalReference}`, `{outputs.localContext}`, and `{outputs.implementationStrategy}` in the synthesis task when those specific inputs are available; keep `{previous}` only when the whole parallel fan-in summary is the desired input.
-
-Do not write these artifacts into the repository unless I explicitly ask for persistent files.
-
-Role guidance:
-
-External reference researcher:
-- Study linked projects, docs, issues, examples, source code, or prompt guidance.
-- Identify the behavior, API, implementation files, constraints, and transferable ideas.
-- Conduct web research if needed. Use `web_search` if it is available; otherwise use whatever equivalent research capability is available.
-- Return source links, repo paths, key evidence, risks, and what matters for this implementation.
-
-Local context-builder:
-- Read all files needed to fully understand the local issue, not just the first match.
-- Follow imports, callers, tests, fixtures, configuration, docs, and adjacent patterns until the local problem, solution space, and validation path are clear.
-- Return relevant file paths and line ranges, current architecture, constraints, tests, risks, and open questions.
-
-Implementation-strategy context-builder, when used:
-- Compare the external evidence against the local architecture.
-- Propose the safest implementation shape, files likely to change, edge cases, validation commands, and decisions that need approval.
-- Stay review/planning-only unless I explicitly ask for implementation.
-
-Final synthesis context-builder:
-- Read the parallel outputs and produce one concise handoff plan.
-- Include what the feature/change should do, what the external reference teaches, what the local codebase implies, the recommended approach, likely files to change, constraints, non-goals, validation, risks, and unresolved questions.
-- End with a compact implementation-ready meta-prompt for the next worker/planner.
-
-After the chain returns, synthesize the result for me with:
-- the recommended approach;
-- artifact paths;
-- the final meta-prompt;
-- any questions or assumptions that remain.
-
-Do not start implementation from this command unless I explicitly ask for it.

package/extensions/dm-subagents/src/runs/background/wait.js

@@ -1,206 +0,0 @@
-import { listAsyncRuns } from "./async-status.js";
-import {
-  ASYNC_DIR,
-  RESULTS_DIR,
-  SUBAGENT_ASYNC_COMPLETE_EVENT,
-  SUBAGENT_CONTROL_EVENT,
-  SUBAGENT_CONTROL_INTERCOM_EVENT,
-  SUBAGENT_RESULT_INTERCOM_EVENT
-} from "../../shared/types.js";
-import { formatDuration } from "../../shared/formatters.js";
-const ACTIVE_STATES = ["queued", "running"];
-const DEFAULT_TIMEOUT_MS = 30 * 60 * 1000;
-const MIN_POLL_INTERVAL_MS = 250;
-const DEFAULT_POLL_INTERVAL_MS = 1000;
-const WAKE_CHANNELS = [
-  SUBAGENT_ASYNC_COMPLETE_EVENT,
-  SUBAGENT_CONTROL_EVENT,
-  SUBAGENT_CONTROL_INTERCOM_EVENT,
-  SUBAGENT_RESULT_INTERCOM_EVENT
-];
-function defaultSleep(ms, signal) {
-  return new Promise((resolve) => {
-    if (signal?.aborted) {
-      resolve();
-      return;
-    }
-    const timer = setTimeout(() => {
-      signal?.removeEventListener("abort", onAbort);
-      resolve();
-    }, ms);
-    const onAbort = () => {
-      clearTimeout(timer);
-      resolve();
-    };
-    signal?.addEventListener("abort", onAbort, { once: true });
-  });
-}
-function waitForWake(ms, signal, deps) {
-  const sleep = deps.sleep ?? defaultSleep;
-  const events = deps.events;
-  if (!events)
-    return sleep(ms, signal);
-  return new Promise((resolve) => {
-    let settled = false;
-    const unsubs = [];
-    const wakeController = new AbortController;
-    const done = () => {
-      if (settled)
-        return;
-      settled = true;
-      wakeController.abort();
-      signal?.removeEventListener("abort", done);
-      for (const u of unsubs) {
-        try {
-          u();
-        } catch {}
-      }
-      resolve();
-    };
-    if (signal?.aborted) {
-      done();
-      return;
-    }
-    signal?.addEventListener("abort", done, { once: true });
-    for (const channel of WAKE_CHANNELS) {
-      try {
-        unsubs.push(events.on(channel, done));
-      } catch {}
-    }
-    sleep(ms, wakeController.signal).then(done);
-  });
-}
-function matchesId(run, id) {
-  return run.id === id || run.id.startsWith(id);
-}
-function needsAttention(run) {
-  return run.activityState === "needs_attention";
-}
-function activeRunsForSession(params, deps) {
-  const asyncDirRoot = deps.asyncDirRoot ?? ASYNC_DIR;
-  const resultsDir = deps.resultsDir ?? RESULTS_DIR;
-  const runs = listAsyncRuns(asyncDirRoot, {
-    states: [...ACTIVE_STATES],
-    sessionId: deps.state.currentSessionId ?? undefined,
-    resultsDir,
-    kill: deps.kill,
-    now: deps.now
-  });
-  return params.id ? runs.filter((run) => matchesId(run, params.id)) : runs;
-}
-function attentionRunsForSession(params, deps, initialIds) {
-  return activeRunsForSession(params, deps).filter((run) => needsAttention(run) && initialIds.has(run.id));
-}
-function allRunsForSession(params, deps) {
-  const asyncDirRoot = deps.asyncDirRoot ?? ASYNC_DIR;
-  const resultsDir = deps.resultsDir ?? RESULTS_DIR;
-  const runs = listAsyncRuns(asyncDirRoot, {
-    sessionId: deps.state.currentSessionId ?? undefined,
-    resultsDir,
-    kill: deps.kill,
-    now: deps.now
-  });
-  return params.id ? runs.filter((run) => matchesId(run, params.id)) : runs;
-}
-function summarizeTerminalRuns(runs) {
-  if (runs.length === 0)
-    return "";
-  const counts = { complete: 0, failed: 0, paused: 0 };
-  for (const run of runs) {
-    if (run.state in counts)
-      counts[run.state] += 1;
-  }
-  const parts = [];
-  if (counts.complete)
-    parts.push(`${counts.complete} complete`);
-  if (counts.failed)
-    parts.push(`${counts.failed} failed`);
-  if (counts.paused)
-    parts.push(`${counts.paused} paused`);
-  return parts.join(", ");
-}
-function result(text, isError = false) {
-  return {
-    content: [{ type: "text", text }],
-    ...isError ? { isError: true } : {},
-    details: { mode: "management", results: [] }
-  };
-}
-export async function waitForSubagents(params, signal, deps) {
-  const now = deps.now ?? Date.now;
-  const pollIntervalMs = Math.max(MIN_POLL_INTERVAL_MS, deps.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS);
-  const timeoutMs = params.timeoutMs !== undefined && params.timeoutMs > 0 ? params.timeoutMs : DEFAULT_TIMEOUT_MS;
-  const startedAt = now();
-  const waitForAll = params.id ? true : params.all === true;
-  let active;
-  try {
-    active = activeRunsForSession(params, deps);
-  } catch (error) {
-    return result(error instanceof Error ? error.message : String(error), true);
-  }
-  if (active.length === 0) {
-    const finished = params.id ? `No active run matched "${params.id}". Nothing to wait for.` : "No active async runs in this session. Nothing to wait for.";
-    return result(finished);
-  }
-  if (params.id) {
-    const exact = active.filter((run) => run.id === params.id);
-    if (exact.length === 1)
-      active = exact;
-    else if (active.length > 1) {
-      return result(`Ambiguous async run id prefix "${params.id}" matched ${active.length} active runs: ${active.map((run) => run.id).join(", ")}. Pass a longer id.`, true);
-    }
-  }
-  const waitParams = params.id ? { ...params, id: active[0].id } : params;
-  const initialIds = new Set(active.map((run) => run.id));
-  const initialCount = initialIds.size;
-  let pending = active.filter((run) => !needsAttention(run));
-  const done = (active, attention) => {
-    if (attention.length > 0)
-      return true;
-    if (waitForAll)
-      return active.every((run) => !initialIds.has(run.id));
-    const stillActiveInitial = active.filter((run) => initialIds.has(run.id));
-    return stillActiveInitial.length < initialCount;
-  };
-  let attention = active.filter((run) => needsAttention(run));
-  while (!done(pending, attention)) {
-    if (signal?.aborted) {
-      const stillActive = pending.map((run) => `${run.id} (${run.state})`).join(", ");
-      return result(`Wait aborted after ${formatDuration(now() - startedAt)}. Still active: ${stillActive}.`, true);
-    }
-    if (now() - startedAt >= timeoutMs) {
-      const stillActive = pending.map((run) => `${run.id} (${run.state})`).join(", ");
-      return result(`Wait timed out after ${formatDuration(timeoutMs)} with ${pending.length} run(s) still active: ${stillActive}. ` + `The runs are detached and keep going; call wait again or inspect with subagent({ action: "status" }).`, true);
-    }
-    await waitForWake(pollIntervalMs, signal, deps);
-    try {
-      active = activeRunsForSession(waitParams, deps);
-      pending = active.filter((run) => !needsAttention(run));
-      attention = attentionRunsForSession(waitParams, deps, initialIds);
-    } catch (error) {
-      return result(error instanceof Error ? error.message : String(error), true);
-    }
-  }
-  let terminalSummary = "";
-  let finishedCount = 0;
-  try {
-    const allNow = allRunsForSession(waitParams, deps);
-    const terminal = allNow.filter((run) => !ACTIVE_STATES.includes(run.state) && initialIds.has(run.id));
-    finishedCount = terminal.length;
-    terminalSummary = summarizeTerminalRuns(terminal);
-  } catch {}
-  const attentionNote = attention.length > 0 ? ` ${attention.length} run(s) need attention: ${attention.map((r) => r.id).join(", ")} — inspect with subagent({ action: "status" }) then nudge/resume/interrupt.` : "";
-  const stillRunning = pending.filter((run) => initialIds.has(run.id)).length;
-  const elapsed = formatDuration(now() - startedAt);
-  const outcome = terminalSummary ? ` Outcome: ${terminalSummary}.` : "";
-  if (waitForAll) {
-    const scope = params.id ? `run "${params.id}"` : `${initialCount} async run(s)`;
-    const status = attention.length > 0 ? "attention required" : "done";
-    const notificationText = attention.length > 0 ? "Relevant completion/control events have been observed; inspect status if the notification is not visible yet." : "Completion events have been observed; inspect status if the notification is not visible yet.";
-    return result(`Waited ${elapsed} for ${scope}; ${status}.${outcome}${attentionNote} ${notificationText}`);
-  }
-  const remainder = stillRunning > 0 ? ` ${stillRunning} run(s) still in flight — call wait again to catch the next one.` : attention.length > 0 ? " No other runs are waitable until attention is handled." : " No runs remain in flight.";
-  const progress = attention.length > 0 && finishedCount === 0 ? `${attention.length} of ${initialCount} run(s) need attention` : `${finishedCount} of ${initialCount} run(s) finished`;
-  const notificationText = finishedCount > 0 ? " Completion events for the finished run(s) have been observed; inspect status if the notification is not visible yet." : " Relevant control events have been observed; inspect status if the notification is not visible yet.";
-  return result(`Waited ${elapsed}; ${progress}.${outcome}${attentionNote}${remainder}${notificationText}`);
-}