@duckmind/dm-linux-x64 0.66.0 → 0.66.2

package/extensions/dm-lens/dist/tools/lsp-structured-output.js

@@ -1,277 +0,0 @@
-import { fileURLToPath, pathToFileURL } from "node:url";
-function asRecord(value) {
-  return typeof value === "object" && value !== null ? value : undefined;
-}
-function finiteNumber(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
-}
-function lspStatusFromFailureKind(failureKind) {
-  if (failureKind === "success" || failureKind === "fallback_success") {
-    return "success";
-  }
-  if (failureKind === "empty_result")
-    return "empty";
-  if (failureKind === "unsupported")
-    return "unsupported";
-  if (failureKind === "bad_input" || failureKind === "invalid_operation" || failureKind === "missing_file_path") {
-    return "bad_input";
-  }
-  if (failureKind === "no_server")
-    return "no_server";
-  if (failureKind === "lsp_disabled")
-    return "lsp_disabled";
-  if (failureKind === "filepath_is_directory")
-    return "filepath_is_directory";
-  if (failureKind === "tracked_snapshot")
-    return "tracked_snapshot";
-  return "error";
-}
-function lspToolLocationFromUriRange(uri, range) {
-  if (typeof uri !== "string" || !uri.startsWith("file:"))
-    return;
-  const rangeLike = asRecord(range);
-  const startLine = finiteNumber(rangeLike?.start?.line);
-  const startCharacter = finiteNumber(rangeLike?.start?.character);
-  const endLine = finiteNumber(rangeLike?.end?.line);
-  const endCharacter = finiteNumber(rangeLike?.end?.character);
-  if (startLine === undefined || startCharacter === undefined || endLine === undefined || endCharacter === undefined) {
-    return;
-  }
-  try {
-    return {
-      uri,
-      filePath: fileURLToPath(uri),
-      range: {
-        start: {
-          line: Math.floor(startLine) + 1,
-          character: Math.floor(startCharacter) + 1
-        },
-        end: {
-          line: Math.floor(endLine) + 1,
-          character: Math.floor(endCharacter) + 1
-        }
-      }
-    };
-  } catch {
-    return;
-  }
-}
-function lspToolLocationFromFileRange(filePath, range) {
-  if (!filePath || filePath === "(workspace)")
-    return;
-  const rangeLike = asRecord(range);
-  const startLine = finiteNumber(rangeLike?.start?.line);
-  const startCharacter = finiteNumber(rangeLike?.start?.character);
-  const endLine = finiteNumber(rangeLike?.end?.line);
-  const endCharacter = finiteNumber(rangeLike?.end?.character);
-  if (startLine === undefined || startCharacter === undefined || endLine === undefined || endCharacter === undefined) {
-    return;
-  }
-  return {
-    uri: pathToFileURL(filePath).href,
-    filePath,
-    range: {
-      start: {
-        line: Math.floor(startLine) + 1,
-        character: Math.floor(startCharacter) + 1
-      },
-      end: {
-        line: Math.floor(endLine) + 1,
-        character: Math.floor(endCharacter) + 1
-      }
-    }
-  };
-}
-function pushToolLocation(out, uri, range) {
-  const loc = lspToolLocationFromUriRange(uri, range);
-  if (loc)
-    out.push(loc);
-}
-function collectLocationSummaries(result, filePath) {
-  const out = [];
-  for (const entry of Array.isArray(result) ? result : [result]) {
-    const record = asRecord(entry);
-    if (!record)
-      continue;
-    pushToolLocation(out, record.uri, record.range);
-    pushToolLocation(out, record.targetUri, record.targetSelectionRange ?? record.targetRange);
-    if (!record.uri && !record.targetUri) {
-      const local = lspToolLocationFromFileRange(filePath, record.range);
-      let alreadyIncluded = false;
-      for (const loc of out) {
-        if (loc.uri === local?.uri) {
-          alreadyIncluded = true;
-          break;
-        }
-      }
-      if (local && !alreadyIncluded)
-        out.push(local);
-    }
-  }
-  return out;
-}
-function collectWorkspaceSymbolLocationSummaries(result) {
-  const out = [];
-  for (const entry of Array.isArray(result) ? result : [result]) {
-    const symbol = asRecord(entry);
-    const location = asRecord(symbol?.location);
-    if (!location)
-      continue;
-    pushToolLocation(out, location.uri, location.range);
-    pushToolLocation(out, location.targetUri, location.targetSelectionRange ?? location.targetRange);
-  }
-  return out;
-}
-function collectCallHierarchyLocationSummaries(result, operation) {
-  const out = [];
-  for (const entry of Array.isArray(result) ? result : [result]) {
-    const record = asRecord(entry);
-    const item = asRecord(operation === "incomingCalls" ? record?.from : record?.to);
-    pushToolLocation(out, item?.uri, item?.selectionRange ?? item?.range);
-  }
-  return out;
-}
-function collectLspToolLocationsForOperation(operation, result, filePath) {
-  if ([
-    "definition",
-    "typeDefinition",
-    "declaration",
-    "references",
-    "implementation",
-    "prepareCallHierarchy"
-  ].includes(operation)) {
-    return collectLocationSummaries(result, filePath);
-  }
-  if (operation === "workspaceSymbol") {
-    return collectWorkspaceSymbolLocationSummaries(result);
-  }
-  if (operation === "documentSymbol" || operation === "findSymbol") {
-    return collectLocationSummaries(result, filePath);
-  }
-  if (operation === "incomingCalls" || operation === "outgoingCalls") {
-    return collectCallHierarchyLocationSummaries(result, operation);
-  }
-  return [];
-}
-function parseBalancedJsonPrefix(text) {
-  const trimmed = text.trim();
-  const start = trimmed.search(/[[{]/);
-  if (start < 0)
-    return;
-  const open = trimmed[start];
-  const close = open === "[" ? "]" : "}";
-  let depth = 0;
-  let inString = false;
-  let escaped = false;
-  for (let i = start;i < trimmed.length; i += 1) {
-    const ch = trimmed[i];
-    if (inString) {
-      if (escaped)
-        escaped = false;
-      else if (ch === "\\")
-        escaped = true;
-      else if (ch === '"')
-        inString = false;
-      continue;
-    }
-    if (ch === '"') {
-      inString = true;
-      continue;
-    }
-    if (ch === open)
-      depth += 1;
-    if (ch === close)
-      depth -= 1;
-    if (depth === 0) {
-      try {
-        return {
-          value: JSON.parse(trimmed.slice(start, i + 1)),
-          rest: trimmed.slice(i + 1).trim()
-        };
-      } catch {
-        return;
-      }
-    }
-  }
-  return;
-}
-function parseLspNavigationTextPayload(text) {
-  const notes = [];
-  const hints = [];
-  const errors = [];
-  const trimmed = text.trim();
-  if (!trimmed)
-    return { notes, hints, errors };
-  try {
-    return { result: JSON.parse(trimmed), notes, hints, errors };
-  } catch {}
-  const lines = trimmed.split(/\r?\n/);
-  let jsonCandidate = trimmed;
-  if (/^Note:/i.test(lines[0] ?? "") && lines.length > 1) {
-    notes.push((lines.shift() ?? "").replace(/^Note:\s*/i, ""));
-    jsonCandidate = lines.join(`
-`).trim();
-  }
-  const parsed = parseBalancedJsonPrefix(jsonCandidate);
-  if (parsed) {
-    for (const entry of parsed.rest.split(/\r?\n/)) {
-      const line = entry.trim();
-      if (!line)
-        continue;
-      if (/^Hint:/i.test(line))
-        hints.push(line.replace(/^Hint:\s*/i, ""));
-      else if (/^Note:/i.test(line))
-        notes.push(line.replace(/^Note:\s*/i, ""));
-      else
-        notes.push(line);
-    }
-    return { result: parsed.value, notes, hints, errors };
-  }
-  for (const entry of lines) {
-    const line = entry.trim();
-    if (!line)
-      continue;
-    if (/^Hint:/i.test(line))
-      hints.push(line.replace(/^Hint:\s*/i, ""));
-    else if (/^Note:/i.test(line))
-      notes.push(line.replace(/^Note:\s*/i, ""));
-    else if (/^LSP error:/i.test(line))
-      errors.push(line);
-    else
-      notes.push(line);
-  }
-  return { notes, hints, errors };
-}
-function withoutUndefined(value) {
-  for (const key of Object.keys(value)) {
-    if (value[key] === undefined)
-      delete value[key];
-  }
-  return value;
-}
-export function buildLspNavigationEnvelope(options) {
-  const parsed = parseLspNavigationTextPayload(options.text ?? "");
-  const status = lspStatusFromFailureKind(options.failureKind);
-  const result = parsed.result;
-  const notes = [...parsed.notes];
-  const hints = [...parsed.hints];
-  const errors = [...parsed.errors];
-  if (options.isError && errors.length === 0 && (options.text ?? "").trim()) {
-    errors.push((options.text ?? "").trim());
-  }
-  const locations = collectLspToolLocationsForOperation(options.operation, result, options.filePath ?? "");
-  return withoutUndefined({
-    tool: "lsp_navigation",
-    operation: options.operation,
-    ok: !options.isError,
-    status,
-    filePath: options.filePath,
-    resultCount: options.resultCount,
-    result,
-    locations: locations.length > 0 ? locations : undefined,
-    notes: notes.length > 0 ? notes : undefined,
-    hints: hints.length > 0 ? hints : undefined,
-    errors: errors.length > 0 ? errors : undefined,
-    metadata: options.details
-  });
-}

package/extensions/dm-lens/dist/tools/module-report.js

@@ -1,332 +0,0 @@
-import * as path from "node:path";
-import { Type } from "../clients/deps/typebox.js";
-import { logLatency } from "../clients/latency-logger.js";
-import { moduleReport, readEnclosing, readSymbol, renderCompactModuleReport } from "../clients/module-report.js";
-import { baseName, compactRenderResult } from "./render-compact.js";
-function resolveFile(filePath, cwd) {
-  return path.isAbsolute(filePath) ? filePath : path.resolve(cwd || ".", filePath);
-}
-function errorMessage(err) {
-  return err instanceof Error ? err.message : String(err);
-}
-export function createModuleReportTool(getProjectRoot) {
-  return {
-    name: "module_report",
-    label: "Module Report",
-    description: "Return a navigable source-module outline with symbols, references, and read handles. An outline shows shape, not bodies, and does not satisfy read-before-edit; `read_symbol` and `read_enclosing` return body text and record read coverage. On a cold cache, project_report and symbol_search return available: false with a retry hint and start a non-blocking background build; module_report degrades to outline-only with cache freshness explicit. Example: use module_report on `src/app.ts` before read_symbol.",
-    promptSnippet: "Outline a source module before reading a body",
-    renderResult: compactRenderResult(({ details, args, isError }) => {
-      const base = baseName(args.path) || "module";
-      if (isError || details?.available === false) {
-        return `module_report ${base} — unavailable`;
-      }
-      const parts = [
-        `${details?.symbols ?? 0} symbols`,
-        `${details?.exports ?? 0} exports`
-      ];
-      if (details?.callbacks)
-        parts.push(`${details.callbacks} callbacks`);
-      const view = details?.view && details.view !== "default" ? ` [${details.view}]` : "";
-      return `module_report ${base}  ${parts.join(" · ")}${view}`;
-    }),
-    parameters: Type.Object({
-      path: Type.String({
-        description: "Source file, e.g. `src/app.ts`."
-      }),
-      maxRefsPerSymbol: Type.Optional(Type.Number({
-        description: "Cap on who-uses-this entries per symbol (default 10)."
-      })),
-      focus: Type.Optional(Type.String({
-        description: "Optional task hint used only to rank recommendedReads (does not expand scope or trigger scans)."
-      })),
-      view: Type.Optional(Type.String({
-        enum: ["summary", "default", "compact"],
-        description: "Payload tier. summary returns top-level entries/recommendedReads and section provenance with heavy callback/usedBy/blast-radius payloads omitted. compact (cheapest) returns a line-oriented TEXT rendering of the full report instead of JSON."
-      })),
-      blastRadius: Type.Optional(Type.Boolean({
-        description: "Include the cross-file blast-radius section: transitive dependents aggregated to ranked file reads. Read-only over the cached graph (omitted when cold)."
-      })),
-      blastRadiusDepth: Type.Optional(Type.Number({
-        description: "Max hops for the blast-radius walk (default 3). Only used with blastRadius."
-      })),
-      callGraph: Type.Optional(Type.Boolean({
-        description: "Include bounded derived callers/callees from the cached FunctionCallGraph; cold or stale cache state is explicit."
-      })),
-      maxCallGraphEntries: Type.Optional(Type.Number({
-        description: "Per-direction cap for call-graph relations (default 20)."
-      }))
-    }),
-    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-      const absFile = resolveFile(params.path, ctx.cwd);
-      const cwd = getProjectRoot() || ctx.cwd || ".";
-      let report;
-      try {
-        report = await moduleReport(absFile, cwd, {
-          maxRefsPerSymbol: params.maxRefsPerSymbol,
-          focus: params.focus,
-          view: params.view,
-          blastRadius: params.blastRadius,
-          blastRadiusDepth: params.blastRadiusDepth,
-          callGraph: params.callGraph,
-          maxCallGraphEntries: params.maxCallGraphEntries
-        });
-      } catch (err) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Module report failed for ${path.basename(absFile)}: ${errorMessage(err)}`
-            }
-          ],
-          isError: true,
-          details: { available: false }
-        };
-      }
-      const text = params.view === "compact" ? renderCompactModuleReport(report) : JSON.stringify(report);
-      return {
-        content: [{ type: "text", text }],
-        isError: !report.available,
-        details: {
-          available: report.available,
-          staleness: report.staleness,
-          symbols: report.summary.symbols,
-          exports: report.summary.exports,
-          callbacks: report.callbacks.length,
-          callbackSupport: report.callbackSupport,
-          view: report.view ?? "default"
-        }
-      };
-    }
-  };
-}
-function recordReadCoverage(recordSymbolRead, result, phase) {
-  if (!result.name || !result.kind || typeof result.startLine !== "number" || typeof result.endLine !== "number") {
-    return false;
-  }
-  try {
-    recordSymbolRead(result.path, {
-      name: result.name,
-      kind: result.kind,
-      startLine: result.startLine,
-      endLine: result.endLine
-    });
-    return true;
-  } catch (err) {
-    logLatency({
-      type: "phase",
-      phase,
-      filePath: result.path,
-      durationMs: 0,
-      metadata: { error: errorMessage(err) }
-    });
-    return false;
-  }
-}
-export function createReadSymbolTool(getProjectRoot, recordSymbolRead) {
-  return {
-    name: "read_symbol",
-    label: "Read Symbol",
-    description: "Return one symbol's verbatim source. An outline shows shape, not bodies, and does not satisfy read-before-edit; `read_symbol` and `read_enclosing` return body text and record read coverage. Example: use read_symbol after module_report identifies `parseConfig`.",
-    promptSnippet: "Read one symbol's body instead of the whole file",
-    renderResult: compactRenderResult(({ details, args, isError, lineCount }) => {
-      const base = baseName(args.path);
-      if (isError || details?.found === false) {
-        const sym = typeof args.symbol === "string" ? args.symbol : "?";
-        return `read_symbol "${sym}" ${base} — not found`;
-      }
-      const range = details?.startLine && details?.endLine ? `:${details.startLine}-${details.endLine} (${details.endLine - details.startLine + 1} lines)` : ` (${lineCount} lines)`;
-      return `read_symbol ${details?.kind ?? ""} ${details?.name ?? ""}  ${base}${range}`.replace(/\s+/g, " ");
-    }),
-    parameters: Type.Object({
-      path: Type.String({
-        description: "Absolute or workspace-relative path to the source file."
-      }),
-      symbol: Type.String({
-        description: "Exact symbol name or callback handle to read (e.g. a function, class, type, or module_report callbacks[].name). Accepts a dotted `Class.method` name to resolve a member."
-      }),
-      kind: Type.Optional(Type.String({
-        description: "Optional kind filter (e.g. function, interface, class) to disambiguate when multiple same-file symbols share the requested name. Omitting it returns the first match, same as today."
-      }))
-    }),
-    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-      const absFile = resolveFile(params.path, ctx.cwd);
-      const cwd = getProjectRoot() || ctx.cwd || ".";
-      let result;
-      try {
-        result = await readSymbol(absFile, params.symbol, cwd, {
-          kind: params.kind
-        });
-      } catch (err) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Read symbol failed for ${path.basename(absFile)}: ${errorMessage(err)}`
-            }
-          ],
-          isError: true,
-          details: { found: false }
-        };
-      }
-      if (!result.found) {
-        const warningSuffix = result.warnings?.length ? ` Warnings: ${result.warnings.join("; ")}` : "";
-        const suggestionSuffix = result.suggestions?.length ? ` Did you mean: ${result.suggestions.join(", ")}?` : " Use module_report to list available symbols.";
-        const text = result.error ? `Could not inspect ${path.basename(absFile)}: ${result.error}${warningSuffix}` : `Symbol "${params.symbol}" not found in ${path.basename(absFile)}.${suggestionSuffix}${warningSuffix}`;
-        return {
-          content: [{ type: "text", text }],
-          isError: true,
-          details: {
-            found: false,
-            ...result.error ? { error: result.error } : {},
-            ...result.warnings ? { warnings: result.warnings } : {},
-            ...result.suggestions ? { suggestions: result.suggestions } : {}
-          }
-        };
-      }
-      const readRecorded = recordReadCoverage(recordSymbolRead, result, "read_symbol_guard_error");
-      const ambiguityNote = result.ambiguous ? ` (${result.ambiguous.count} matches — returned the ${result.kind}; pass \`kind\` to disambiguate: ${result.ambiguous.kinds.join(", ")})` : "";
-      const header = `${result.kind} ${result.name}${ambiguityNote}  ${path.basename(result.path)}:${result.startLine}-${result.endLine}`;
-      const guardWarning = readRecorded ? "" : `
-
-Warning: read coverage recording failed; the returned body may not satisfy the edit guard.`;
-      return {
-        content: [
-          {
-            type: "text",
-            text: `${header}${guardWarning}
-
-${result.source ?? ""}`
-          }
-        ],
-        details: {
-          found: true,
-          name: result.name,
-          kind: result.kind,
-          startLine: result.startLine,
-          endLine: result.endLine,
-          readRecorded,
-          ...result.ambiguous ? { ambiguous: result.ambiguous } : {}
-        }
-      };
-    }
-  };
-}
-export function createReadEnclosingTool(getProjectRoot, recordSymbolRead) {
-  return {
-    name: "read_enclosing",
-    label: "Read Enclosing",
-    description: "Return the smallest symbol or callback enclosing a line. An outline shows shape, not bodies, and does not satisfy read-before-edit; `read_symbol` and `read_enclosing` return body text and record read coverage. Example: use read_enclosing after a diagnostic points to line 42.",
-    promptSnippet: "Read the enclosing symbol or callback body for a line",
-    renderResult: compactRenderResult(({ details, args, isError }) => {
-      const base = baseName(args.path);
-      if (isError || details?.found === false) {
-        const ln = typeof args.line === "number" ? args.line : "?";
-        return `read_enclosing ${base}:${ln} — no enclosing symbol`;
-      }
-      const range = details?.startLine && details?.endLine ? `:${details.startLine}-${details.endLine}` : "";
-      return `read_enclosing ${details?.kind ?? ""} ${details?.name ?? ""}  ${base}${range}`.replace(/\s+/g, " ");
-    }),
-    parameters: Type.Object({
-      path: Type.String({
-        description: "Absolute or workspace-relative path to the source file."
-      }),
-      line: Type.Number({
-        description: "1-based line number inside the desired symbol/callback."
-      }),
-      kinds: Type.Optional(Type.Array(Type.String(), {
-        description: "Optional kind filter, e.g. function, method, callback, class, object_property_callback."
-      })),
-      maxLines: Type.Optional(Type.Number({
-        description: "Optional maximum body size to return. Oversized matches obey onOversize."
-      })),
-      onOversize: Type.Optional(Type.String({
-        enum: ["error", "slice", "outline"],
-        description: "Behavior when the enclosing body exceeds maxLines. error (default) returns metadata only; slice returns a bounded partial read around line; outline returns nested symbols/callbacks with read handles."
-      })),
-      aroundLine: Type.Optional(Type.Number({
-        description: "Maximum lines for onOversize=slice; defaults to maxLines, then 80."
-      }))
-    }),
-    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-      const absFile = resolveFile(params.path, ctx.cwd);
-      const cwd = getProjectRoot() || ctx.cwd || ".";
-      let result;
-      try {
-        result = await readEnclosing(absFile, params.line, cwd, {
-          kinds: params.kinds,
-          maxLines: params.maxLines,
-          onOversize: params.onOversize,
-          aroundLine: params.aroundLine
-        });
-      } catch (err) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Read enclosing failed for ${path.basename(absFile)}:${params.line}: ${errorMessage(err)}`
-            }
-          ],
-          isError: true,
-          details: { found: false }
-        };
-      }
-      if (!result.found) {
-        const warningSuffix = result.warnings?.length ? ` Warnings: ${result.warnings.join("; ")}` : "";
-        const outlineSuffix = result.outline?.length ? `
-
-Nested outline:
-${JSON.stringify(result.outline)}` : "";
-        const text = result.error ? `Could not read enclosing range in ${path.basename(absFile)}:${result.line}: ${result.error}${warningSuffix}${outlineSuffix}` : `No enclosing symbol/callback found in ${path.basename(absFile)}:${result.line}.${warningSuffix}`;
-        return {
-          content: [{ type: "text", text }],
-          isError: true,
-          details: {
-            found: false,
-            line: result.line,
-            ...result.name ? { name: result.name } : {},
-            ...result.kind ? { kind: result.kind } : {},
-            ...result.startLine ? { startLine: result.startLine } : {},
-            ...result.endLine ? { endLine: result.endLine } : {},
-            ...result.enclosingStartLine ? { enclosingStartLine: result.enclosingStartLine } : {},
-            ...result.enclosingEndLine ? { enclosingEndLine: result.enclosingEndLine } : {},
-            ...result.selection ? { selection: result.selection } : {},
-            ...result.outline ? { outline: result.outline } : {},
-            ...result.error ? { error: result.error } : {},
-            ...result.warnings ? { warnings: result.warnings } : {}
-          }
-        };
-      }
-      const readRecorded = recordReadCoverage(recordSymbolRead, result, "read_enclosing_guard_error");
-      const range = result.partial ? `${result.startLine}-${result.endLine} (partial of ${result.enclosingStartLine}-${result.enclosingEndLine})` : `${result.startLine}-${result.endLine}`;
-      const header = `${result.kind} ${result.name}  ${path.basename(result.path)}:${range}`;
-      const guardWarning = readRecorded ? "" : `
-
-Warning: read coverage recording failed; the returned body may not satisfy the edit guard.`;
-      return {
-        content: [
-          {
-            type: "text",
-            text: `${header}${guardWarning}
-
-${result.source ?? ""}`
-          }
-        ],
-        details: {
-          found: true,
-          name: result.name,
-          kind: result.kind,
-          line: result.line,
-          startLine: result.startLine,
-          endLine: result.endLine,
-          enclosingStartLine: result.enclosingStartLine,
-          enclosingEndLine: result.enclosingEndLine,
-          parentChain: result.parentChain,
-          partial: result.partial,
-          selection: result.selection,
-          readRecorded,
-          ...result.warnings ? { warnings: result.warnings } : {}
-        }
-      };
-    }
-  };
-}

package/extensions/dm-lens/dist/tools/project-report.js

@@ -1,72 +0,0 @@
-import { Type } from "../clients/deps/typebox.js";
-import { projectReport, renderCompactProjectReport } from "../clients/lens-engine.js";
-import { compactRenderResult, renderToolText } from "./render-compact.js";
-function errorMessage(err) {
-  return err instanceof Error ? err.message : String(err);
-}
-export function createProjectReportTool(getProjectRoot) {
-  return {
-    name: "project_report",
-    label: "Project Report",
-    description: "Orient in a project from its review graph, with ranked hubs and entry points. On a cold cache, project_report and symbol_search return available: false with a retry hint and start a non-blocking background build; module_report degrades to outline-only with cache freshness explicit. Example: use project_report before module_report when the target file is unknown.",
-    promptSnippet: "Orient in a project before choosing a file",
-    renderResult: compactRenderResult(({ details, isError }) => {
-      if (isError || details?.available === false) {
-        return `project_report — unavailable${details?.hint ? `: ${details.hint}` : ""}`;
-      }
-      const parts = [
-        `${details?.hubs ?? 0} hub(s)`,
-        `${details?.entryPoints ?? 0} entry point(s)`
-      ];
-      const view = details?.view && details.view !== "default" ? ` [${details.view}]` : "";
-      return `project_report  ${parts.join(" · ")}${view}`;
-    }),
-    parameters: Type.Object({
-      limit: Type.Optional(Type.Number({
-        description: "Scales every ranked section's cap (default 10) — a single knob for all sections."
-      })),
-      focus: Type.Optional(Type.String({
-        description: "Optional task hint used only to re-rank sections toward relevant subsystems (does not expand scope or trigger scans)."
-      })),
-      view: Type.Optional(Type.String({
-        enum: ["default", "compact"],
-        description: "Payload tier. compact (cheapest) returns a line-oriented TEXT rendering instead of JSON. Default returns JSON."
-      }))
-    }),
-    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-      const cwd = getProjectRoot() || ctx.cwd || ".";
-      let report;
-      try {
-        report = await projectReport(cwd, {
-          limit: params.limit,
-          focus: params.focus,
-          view: params.view === "compact" ? "compact" : undefined
-        });
-      } catch (err) {
-        return {
-          ...renderToolText(`Project report failed: ${errorMessage(err)}`),
-          isError: true,
-          details: { available: false }
-        };
-      }
-      if (!report.available) {
-        return {
-          ...renderToolText(report.hint ?? "No review graph cached for this workspace yet.", report),
-          isError: true,
-          details: { available: false, hint: report.hint }
-        };
-      }
-      const text = params.view === "compact" ? renderCompactProjectReport(report) : JSON.stringify(report);
-      return {
-        content: [{ type: "text", text }],
-        isError: false,
-        details: {
-          available: true,
-          hubs: report.hubs?.length ?? 0,
-          entryPoints: report.entryPoints?.length ?? 0,
-          view: report.view ?? "default"
-        }
-      };
-    }
-  };
-}