@duckmind/dm-darwin-x64 0.66.5 → 0.66.6

package/extensions/dm-lens/dist/clients/python-provenance.js

@@ -0,0 +1,551 @@
+const SUMMARY_BY_ROOT = new WeakMap;
+const TRAVERSAL_VISIT_CAP = 50000;
+const TRAVERSAL_DEPTH_CAP = 128;
+const EXPRESSION_DEPTH_CAP = 8;
+const BINDING_SCAN_DEPTH_CAP = 32;
+const ANCESTOR_DEPTH_CAP = 64;
+export const PYTHON_SQLALCHEMY_RECEIVER_NAMES = new Set([
+  "session",
+  "db_session",
+  "async_session",
+  "sync_session"
+]);
+export const PYTHON_SQLALCHEMY_STATEMENT_BUILDERS = new Set(["select", "insert", "update", "delete"]);
+const FROM_IMPORT_PROVENANCE = new Map([
+  ["sqlalchemy.orm:Session", "sqlalchemy-session"],
+  ["sqlalchemy.ext.asyncio:AsyncSession", "sqlalchemy-session"],
+  ["psycopg:sql", "psycopg-sql-module"],
+  ["psycopg2:sql", "psycopg-sql-module"],
+  ["psycopg.sql:SQL", "psycopg-sql-constructor"],
+  ["psycopg2.sql:SQL", "psycopg-sql-constructor"],
+  ["psycopg.sql:Identifier", "psycopg-identifier-constructor"],
+  ["psycopg2.sql:Identifier", "psycopg-identifier-constructor"]
+]);
+const PLAIN_PACKAGE_PROVENANCE = new Map([
+  ["sqlalchemy", "sqlalchemy-module"],
+  ["psycopg", "psycopg-package"],
+  ["psycopg2", "psycopg-package"]
+]);
+function nodeKey(node) {
+  return `${node.type}:${node.startIndex}:${node.endIndex}`;
+}
+function namedChildren(node) {
+  return (node.children ?? []).filter((child) => child.isNamed);
+}
+function calleeNode(call) {
+  if (call.type !== "call")
+    return;
+  return call.childForFieldName?.("function") ?? namedChildren(call)[0];
+}
+function directNamedChild(node, type) {
+  return namedChildren(node).find((child) => child.type === type);
+}
+const BINDING_TARGET_CONTAINER_TYPES = new Set([
+  "tuple",
+  "pattern_list",
+  "list",
+  "list_pattern",
+  "tuple_pattern",
+  "starred_expression",
+  "list_splat_pattern",
+  "dictionary_splat_pattern"
+]);
+const BINDING_TARGET_REFERENCE_TYPES = new Set(["attribute", "subscript"]);
+const BINDING_PATTERN_CONTAINER_TYPES = new Set([
+  "case_pattern",
+  "as_pattern",
+  "union_pattern",
+  "list_pattern",
+  "tuple_pattern",
+  "list_splat_pattern",
+  "dictionary_splat_pattern",
+  "class_pattern"
+]);
+const BINDING_PATTERN_REFERENCE_TYPES = new Set([
+  "attribute",
+  "qualified_pattern"
+]);
+function scanBindingNames(node, mode, scan, depth = 0) {
+  if (!node || depth > BINDING_SCAN_DEPTH_CAP) {
+    scan.unknown = true;
+    return;
+  }
+  const descend = (child, next) => scanBindingNames(child, next, scan, depth + 1);
+  if (node.type === "as_pattern_target") {
+    descend(namedChildren(node)[0], "target");
+    return;
+  }
+  if (mode === "as") {
+    for (const child of namedChildren(node))
+      descend(child, "as");
+    return;
+  }
+  if (node.type === "identifier") {
+    if (node.text !== "_")
+      scan.names.push(node.text);
+    return;
+  }
+  if (mode === "pattern") {
+    if (node.type === "dotted_name") {
+      if (!node.text.includes(".") && node.text !== "_") {
+        scan.names.push(node.text);
+      }
+      return;
+    }
+    if (BINDING_PATTERN_REFERENCE_TYPES.has(node.type))
+      return;
+    if (node.type === "keyword_pattern") {
+      const value = namedChildren(node).slice(1);
+      if (value.length !== 1)
+        scan.unknown = true;
+      else
+        descend(value[0], "pattern");
+      return;
+    }
+    if (BINDING_PATTERN_CONTAINER_TYPES.has(node.type)) {
+      for (const child of namedChildren(node))
+        descend(child, "pattern");
+      return;
+    }
+    scan.unknown = true;
+    return;
+  }
+  if (BINDING_TARGET_REFERENCE_TYPES.has(node.type))
+    return;
+  if (BINDING_TARGET_CONTAINER_TYPES.has(node.type)) {
+    for (const child of namedChildren(node))
+      descend(child, "target");
+    return;
+  }
+  scan.unknown = true;
+}
+function collectBindingNames(node, mode) {
+  const scan = { names: [], unknown: false };
+  scanBindingNames(node, mode, scan);
+  return scan;
+}
+function parseImportBinding(node, isFrom) {
+  if (node.type === "aliased_import") {
+    const children = namedChildren(node);
+    const source = children[0]?.text;
+    const local = children.at(-1);
+    return source && local?.type === "identifier" ? { source, local: local.text } : undefined;
+  }
+  if (node.type !== "dotted_name" && node.type !== "identifier") {
+    return;
+  }
+  if (isFrom)
+    return { source: node.text, local: node.text };
+  const local = node.text.split(".")[0];
+  return local ? { source: node.text, local } : undefined;
+}
+function directAnnotationName(parameter) {
+  if (parameter.type !== "typed_parameter" && parameter.type !== "typed_default_parameter") {
+    return;
+  }
+  const type = directNamedChild(parameter, "type");
+  const children = type ? namedChildren(type) : [];
+  return children.length === 1 && children[0]?.type === "identifier" ? children[0].text : undefined;
+}
+function parameterName(parameter) {
+  if (parameter.type === "identifier")
+    return parameter.text;
+  return directNamedChild(parameter, "identifier")?.text;
+}
+function markInvalid(state) {
+  state.invalid = true;
+}
+function addBinding(state, name, functionChain) {
+  state.bindingCounts.set(name, (state.bindingCounts.get(name) ?? 0) + 1);
+  for (const fn of functionChain) {
+    const key = nodeKey(fn);
+    const bindings = state.functionBindings.get(key) ?? new Map;
+    bindings.set(name, (bindings.get(name) ?? 0) + 1);
+    state.functionBindings.set(key, bindings);
+  }
+}
+function addTarget(state, target, functionChain) {
+  const extracted = collectBindingNames(target, "target");
+  if (extracted.unknown)
+    markInvalid(state);
+  for (const name of extracted.names)
+    addBinding(state, name, functionChain);
+}
+function recordFunctionParameters(node, state) {
+  const annotations = new Map;
+  const parameters = directNamedChild(node, "parameters");
+  for (const parameter of namedChildren(parameters ?? node)) {
+    const name = parameterName(parameter);
+    if (!name) {
+      if (parameter.type !== "list_splat_pattern")
+        markInvalid(state);
+      continue;
+    }
+    addBinding(state, name, state.functionChain);
+    const annotation = directAnnotationName(parameter);
+    if (annotation)
+      annotations.set(name, annotation);
+  }
+  state.functionAnnotations.set(nodeKey(node), annotations);
+}
+function recordFunctionDefinition(node, state) {
+  recordFunctionParameters(node, state);
+  recordDefinitionBinding(node, state);
+}
+function recordLambdaParameters(node, state) {
+  const parameters = directNamedChild(node, "lambda_parameters");
+  for (const parameter of namedChildren(parameters ?? node)) {
+    const name = parameterName(parameter);
+    if (name)
+      addBinding(state, name, state.functionChain);
+    else
+      markInvalid(state);
+  }
+}
+function recordImportBindings(node, state) {
+  const isFrom = node.type === "import_from_statement";
+  const children = namedChildren(node);
+  const moduleName = isFrom ? children[0]?.text : undefined;
+  if (node.text.includes("*") || isFrom && !moduleName)
+    markInvalid(state);
+  for (const part of isFrom ? children.slice(1) : children) {
+    const binding = parseImportBinding(part, isFrom);
+    if (!binding) {
+      markInvalid(state);
+      continue;
+    }
+    addBinding(state, binding.local, state.functionChain);
+    if (!state.moduleDirect)
+      continue;
+    const provenance = isFrom ? FROM_IMPORT_PROVENANCE.get(`${moduleName}:${binding.source}`) : PLAIN_PACKAGE_PROVENANCE.get(binding.source);
+    if (provenance) {
+      state.imports.set(binding.local, {
+        name: binding.local,
+        provenance,
+        endIndex: node.endIndex
+      });
+    }
+  }
+}
+function recordTargetBinding(node, state) {
+  addTarget(state, node.childForFieldName?.("left") ?? namedChildren(node)[0], state.functionChain);
+}
+function recordAssignmentValue(node, state) {
+  recordTargetBinding(node, state);
+  const target = node.childForFieldName?.("left") ?? namedChildren(node)[0];
+  const value = node.childForFieldName?.("right") ?? namedChildren(node).at(-1);
+  if (target?.type !== "identifier" || !value || value === target)
+    return;
+  state.assignments.set(target.text, value);
+}
+function recordAsPatternBinding(node, state) {
+  const extracted = collectBindingNames(node, "as");
+  if (extracted.unknown)
+    markInvalid(state);
+  for (const name of extracted.names)
+    addBinding(state, name, state.functionChain);
+}
+function recordDeleteTargets(node, state) {
+  for (const child of namedChildren(node)) {
+    addTarget(state, child, state.functionChain);
+  }
+}
+function recordCaseBindings(node, state) {
+  const extracted = collectBindingNames(directNamedChild(node, "case_pattern"), "pattern");
+  if (extracted.unknown)
+    markInvalid(state);
+  for (const name of extracted.names)
+    addBinding(state, name, state.functionChain);
+}
+function recordDeclarationBindings(node, state) {
+  for (const child of namedChildren(node)) {
+    addBinding(state, child.text, state.functionChain);
+  }
+}
+function recordDefinitionBinding(node, state) {
+  const name = directNamedChild(node, "identifier")?.text;
+  if (name)
+    addBinding(state, name, state.parentFunctionChain);
+  else
+    markInvalid(state);
+}
+function recordTypeAliasBinding(node, state) {
+  const name = directNamedChild(node, "type")?.children?.find((child) => child.type === "identifier")?.text;
+  if (name)
+    addBinding(state, name, state.functionChain);
+  else
+    markInvalid(state);
+}
+const DYNAMIC_NAMESPACE_BUILTINS = new Set([
+  "exec",
+  "eval",
+  "globals",
+  "locals",
+  "vars"
+]);
+function recordDynamicNamespaceHazard(node, state) {
+  const callee = calleeNode(node);
+  if (callee?.type === "identifier" && DYNAMIC_NAMESPACE_BUILTINS.has(callee.text)) {
+    markInvalid(state);
+  }
+}
+const SUMMARY_NODE_RECORDERS = Object.freeze({
+  function_definition: recordFunctionDefinition,
+  class_definition: recordDefinitionBinding,
+  lambda: recordLambdaParameters,
+  import_from_statement: recordImportBindings,
+  import_statement: recordImportBindings,
+  assignment: recordAssignmentValue,
+  augmented_assignment: recordTargetBinding,
+  named_expression: recordTargetBinding,
+  for_statement: recordTargetBinding,
+  for_in_clause: recordTargetBinding,
+  with_item: recordAsPatternBinding,
+  except_clause: recordAsPatternBinding,
+  except_group_clause: recordAsPatternBinding,
+  delete_statement: recordDeleteTargets,
+  case_clause: recordCaseBindings,
+  type_alias_statement: recordTypeAliasBinding,
+  global_statement: recordDeclarationBindings,
+  nonlocal_statement: recordDeclarationBindings,
+  call: recordDynamicNamespaceHazard
+});
+
+class Summary {
+  invalid;
+  imports;
+  bindingCounts;
+  assignments;
+  functions;
+  constructor(root) {
+    const state = {
+      imports: new Map,
+      bindingCounts: new Map,
+      assignments: new Map,
+      functionBindings: new Map,
+      functionAnnotations: new Map,
+      invalid: false,
+      visits: 0,
+      functionChain: [],
+      parentFunctionChain: [],
+      moduleDirect: false
+    };
+    const visit = (node, depth, moduleDirect, activeFunctions) => {
+      if (++state.visits > TRAVERSAL_VISIT_CAP || depth > TRAVERSAL_DEPTH_CAP) {
+        markInvalid(state);
+        return;
+      }
+      if (node.hasError || node.type === "ERROR" || node.type === "MISSING") {
+        markInvalid(state);
+        return;
+      }
+      const functionChain = node.type === "function_definition" ? [...activeFunctions, node] : activeFunctions;
+      state.functionChain = functionChain;
+      state.parentFunctionChain = activeFunctions;
+      state.moduleDirect = moduleDirect;
+      const recorder = SUMMARY_NODE_RECORDERS[node.type];
+      if (recorder)
+        recorder(node, state);
+      for (const child of node.children ?? []) {
+        visit(child, depth + 1, node === root, functionChain);
+      }
+    };
+    visit(root, 0, false, []);
+    this.invalid = state.invalid;
+    this.imports = state.imports;
+    this.bindingCounts = state.bindingCounts;
+    this.assignments = state.assignments;
+    this.functions = new Map([...state.functionAnnotations.entries()].map(([key, annotations]) => [
+      key,
+      {
+        parameterAnnotations: annotations,
+        bindingCounts: state.functionBindings.get(key) ?? new Map
+      }
+    ]));
+  }
+  provenanceFor(name, reference) {
+    const candidate = this.boundOnce(name) ? this.imports.get(name) : undefined;
+    return candidate && candidate.endIndex <= reference.startIndex ? candidate.provenance : null;
+  }
+  boundOnce(name) {
+    return !this.invalid && (this.bindingCounts.get(name) ?? 0) === 1;
+  }
+  singleAssignmentValue(name, reference) {
+    if (!this.boundOnce(name))
+      return null;
+    const value = this.assignments.get(name);
+    return value && value.endIndex <= reference.startIndex ? value : null;
+  }
+  isFunctionLocalName(reference) {
+    if (this.invalid || reference.type !== "identifier")
+      return true;
+    let current = reference.parent;
+    for (let depth = 0;current && depth < ANCESTOR_DEPTH_CAP; depth++) {
+      if (current.type === "function_definition") {
+        const summary = this.functions.get(nodeKey(current));
+        if (!summary)
+          return true;
+        if ((summary.bindingCounts.get(reference.text) ?? 0) > 0)
+          return true;
+      }
+      current = current.parent;
+    }
+    return false;
+  }
+  isSqlAlchemySessionReceiver(receiver) {
+    if (this.invalid || receiver.type !== "identifier")
+      return false;
+    let current = receiver.parent;
+    for (let depth = 0;current && depth < ANCESTOR_DEPTH_CAP; depth++) {
+      if (current.type === "function_definition") {
+        const summary = this.functions.get(nodeKey(current));
+        if (!summary)
+          return false;
+        const annotation = summary.parameterAnnotations.get(receiver.text);
+        return annotation !== undefined && (summary.bindingCounts.get(receiver.text) ?? 0) === 1 && this.provenanceFor(annotation, receiver) === "sqlalchemy-session";
+      }
+      current = current.parent;
+    }
+    return false;
+  }
+}
+function getPythonProvenanceSummary(root) {
+  const cached = SUMMARY_BY_ROOT.get(root);
+  if (cached)
+    return cached;
+  const summary = new Summary(root);
+  SUMMARY_BY_ROOT.set(root, summary);
+  return summary;
+}
+function expressionProvenance(node, summary, depth = 0) {
+  if (!node || depth > EXPRESSION_DEPTH_CAP)
+    return null;
+  if (node.type === "identifier")
+    return summary.provenanceFor(node.text, node);
+  if (node.type !== "attribute")
+    return null;
+  const object = node.childForFieldName?.("object") ?? namedChildren(node)[0];
+  const attribute = node.childForFieldName?.("attribute") ?? namedChildren(node).at(-1);
+  const provenance = expressionProvenance(object, summary, depth + 1);
+  if (provenance === "psycopg-package" && attribute?.text === "sql") {
+    return "psycopg-sql-module";
+  }
+  if (provenance === "psycopg-sql-module") {
+    if (attribute?.text === "SQL")
+      return "psycopg-sql-constructor";
+    if (attribute?.text === "Identifier")
+      return "psycopg-identifier-constructor";
+  }
+  return null;
+}
+export function isSafePsycopgIdentifierComposition(node, root) {
+  if (node?.type !== "call" || !root)
+    return false;
+  const summary = getPythonProvenanceSummary(root);
+  if (summary.invalid)
+    return false;
+  const formatCallee = node.childForFieldName?.("function") ?? namedChildren(node)[0];
+  if (formatCallee?.type !== "attribute")
+    return false;
+  const formatChildren = namedChildren(formatCallee);
+  const hasFormatMethod = formatChildren.some((child) => child.text === "format");
+  const sqlConstructor = formatChildren.find((child) => child.type === "call");
+  if (!hasFormatMethod || !sqlConstructor)
+    return false;
+  const constructorCallee = sqlConstructor.childForFieldName?.("function") ?? namedChildren(sqlConstructor)[0];
+  if (expressionProvenance(constructorCallee, summary) !== "psycopg-sql-constructor")
+    return false;
+  const templateArgs = namedChildren(directNamedChild(sqlConstructor, "argument_list") ?? sqlConstructor).filter((child) => child.type !== "comment");
+  if (templateArgs.length !== 1 || templateArgs[0]?.type !== "string" || namedChildren(templateArgs[0]).some((child) => child.type === "interpolation"))
+    return false;
+  const formatArgs = namedChildren(directNamedChild(node, "argument_list") ?? node).filter((child) => child.type !== "comment");
+  if (formatArgs.length === 0)
+    return false;
+  return formatArgs.every((argument) => {
+    if (argument.type !== "call")
+      return false;
+    const callee = argument.childForFieldName?.("function") ?? namedChildren(argument)[0];
+    return expressionProvenance(callee, summary) === "psycopg-identifier-constructor";
+  });
+}
+export function isProvenSqlAlchemySessionReceiver(receiver, root) {
+  return !!receiver && !!root && getPythonProvenanceSummary(root).isSqlAlchemySessionReceiver(receiver);
+}
+function isStaticStringLiteral(node) {
+  return node?.type === "string" && !namedChildren(node).some((child) => child.type === "interpolation");
+}
+function callArguments(call) {
+  return namedChildren(directNamedChild(call, "argument_list") ?? call).filter((child) => child.type !== "comment");
+}
+const COMPOSED_SQL_NODE_TYPES = new Set([
+  "string",
+  "concatenated_string",
+  "binary_operator"
+]);
+function carriesComposedSql(node, depth = 0) {
+  if (!node)
+    return false;
+  if (depth > EXPRESSION_DEPTH_CAP)
+    return true;
+  if (COMPOSED_SQL_NODE_TYPES.has(node.type))
+    return true;
+  if (node.type !== "call")
+    return false;
+  const callee = calleeNode(node);
+  if (callee?.type === "attribute") {
+    const object = callee.childForFieldName?.("object") ?? namedChildren(callee)[0];
+    if (carriesComposedSql(object, depth + 1))
+      return true;
+  }
+  return callArguments(node).some((argument) => carriesComposedSql(argument, depth + 1));
+}
+function builderCalleeName(call, summary) {
+  const callee = calleeNode(call);
+  if (callee?.type === "identifier")
+    return callee.text;
+  if (callee?.type !== "attribute")
+    return;
+  const object = callee.childForFieldName?.("object") ?? namedChildren(callee)[0];
+  if (expressionProvenance(object, summary) !== "sqlalchemy-module") {
+    return;
+  }
+  const attribute = callee.childForFieldName?.("attribute") ?? namedChildren(callee).at(-1);
+  return attribute?.type === "identifier" ? attribute.text : undefined;
+}
+function isStatementBuilderCall(node, summary) {
+  if (node?.type !== "call")
+    return false;
+  const name = builderCalleeName(node, summary);
+  if (!name)
+    return false;
+  const args = callArguments(node);
+  if (name === "text") {
+    return args.length === 1 && isStaticStringLiteral(args[0]);
+  }
+  if (!PYTHON_SQLALCHEMY_STATEMENT_BUILDERS.has(name))
+    return false;
+  return !args.some((argument) => carriesComposedSql(argument));
+}
+export function isSqlAlchemyStatementArgument(node, root) {
+  if (!node || !root)
+    return false;
+  const summary = getPythonProvenanceSummary(root);
+  if (isStatementBuilderCall(node, summary))
+    return true;
+  if (node.type !== "identifier")
+    return false;
+  const bound = summary.singleAssignmentValue(node.text, node);
+  return isStatementBuilderCall(bound ?? undefined, summary);
+}
+export function isSqlAlchemyEntityQueryArgument(node, root) {
+  if (!node || !root)
+    return false;
+  const summary = getPythonProvenanceSummary(root);
+  if (isStatementBuilderCall(node, summary))
+    return true;
+  if (carriesComposedSql(node))
+    return false;
+  if (node.type !== "identifier")
+    return true;
+  return !summary.isFunctionLocalName(node);
+}

package/extensions/dm-lens/dist/clients/quiet-window-config.js

@@ -0,0 +1,16 @@
+import { toPositiveFinite } from "./env-utils.js";
+let _enabledCache;
+export function isQuietWindowEnabled() {
+  if (_enabledCache !== undefined)
+    return _enabledCache;
+  _enabledCache = process.env.DM_LENS_QUIET_WINDOW !== "0";
+  return _enabledCache;
+}
+export function _resetQuietWindowEnabledForTests() {
+  _enabledCache = undefined;
+}
+const DEFAULT_QUIET_WINDOW_WAIT_MS = 15000;
+export function quietWindowWaitMs() {
+  const raw = toPositiveFinite(process.env.DM_LENS_QUIET_WINDOW_WAIT_MS);
+  return raw > 0 ? raw : DEFAULT_QUIET_WINDOW_WAIT_MS;
+}

package/extensions/dm-lens/dist/clients/quiet-window.js

@@ -0,0 +1,129 @@
+import { readInstanceRegistry, updateHeartbeat } from "./instance-registry.js";
+import { logLatency } from "./latency-logger.js";
+import { sampleProcesses } from "./resource-sampler.js";
+import { _resetQuietWindowEnabledForTests, isQuietWindowEnabled, quietWindowWaitMs } from "./quiet-window-config.js";
+const _tasks = [];
+export function registerQuietWindowTask(name, fn) {
+  _tasks.push({ name, fn });
+}
+export function _resetQuietWindowTasksForTests() {
+  _tasks.length = 0;
+}
+
+export { isQuietWindowEnabled, quietWindowWaitMs, _resetQuietWindowEnabledForTests };
+let _inProgress = false;
+export async function runQuietWindow(deps) {
+  const { dbg, cwd } = deps;
+  if (!isQuietWindowEnabled()) {
+    logLatency({
+      type: "phase",
+      filePath: cwd ?? "<dm-lens>",
+      phase: "quiet_window",
+      durationMs: 0,
+      metadata: { skipped: "disabled" }
+    });
+    return;
+  }
+  if (_inProgress) {
+    dbg("quiet_window: skipping — a previous run is still in progress");
+    logLatency({
+      type: "phase",
+      filePath: cwd ?? "<dm-lens>",
+      phase: "quiet_window",
+      durationMs: 0,
+      metadata: { skipped: "in-progress" }
+    });
+    return;
+  }
+  _inProgress = true;
+  const totalStart = Date.now();
+  const results = [];
+  try {
+    for (const task of _tasks) {
+      const taskStart = Date.now();
+      let ok = true;
+      try {
+        await task.fn({
+          runtime: deps.runtime,
+          cwd: deps.cwd,
+          sessionId: deps.sessionId,
+          ownerId: deps.ownerId,
+          sessionGeneration: deps.runtime.captureSessionGeneration()
+        });
+      } catch (err) {
+        ok = false;
+        const detail = err instanceof Error ? err.stack ?? `${err.name}: ${err.message}` : String(err);
+        dbg(`quiet_window: task "${task.name}" failed: ${detail}`);
+      }
+      results.push({
+        name: task.name,
+        durationMs: Date.now() - taskStart,
+        ok
+      });
+    }
+  } finally {
+    _inProgress = false;
+    logLatency({
+      type: "phase",
+      filePath: cwd ?? "<dm-lens>",
+      phase: "quiet_window",
+      durationMs: Date.now() - totalStart,
+      metadata: { tasks: results }
+    });
+  }
+}
+let _builtinsRegistered = false;
+export function registerBuiltinQuietWindowTasks(getRuntime) {
+  if (_builtinsRegistered)
+    return;
+  _builtinsRegistered = true;
+  registerQuietWindowTask("cascade_carry_over_settle", async (context) => {
+    const runtime = getRuntime();
+    await runtime.settleCascadeRuns(quietWindowWaitMs(), {
+      generation: context?.sessionGeneration
+    });
+  });
+  registerQuietWindowTask("instance_registry_heartbeat", async () => {
+    await updateHeartbeat(await buildHeartbeatResourcePatchBounded());
+  });
+}
+const HEARTBEAT_SAMPLE_TIMEOUT_MS = 2000;
+async function buildHeartbeatResourcePatchBounded() {
+  let timer;
+  try {
+    return await Promise.race([
+      buildHeartbeatResourcePatch(),
+      new Promise((resolve) => {
+        timer = setTimeout(() => resolve({}), HEARTBEAT_SAMPLE_TIMEOUT_MS);
+      })
+    ]);
+  } finally {
+    if (timer)
+      clearTimeout(timer);
+  }
+}
+async function buildHeartbeatResourcePatch() {
+  try {
+    const instances = await readInstanceRegistry();
+    const self = instances.find((instance) => instance.pid === process.pid);
+    const childPids = self?.lspChildren.map((child) => child.pid) ?? [];
+    const usage = await sampleProcesses([process.pid, ...childPids]);
+    if (usage === null)
+      return {};
+    const childUsage = {};
+    for (const pid of childPids) {
+      const sample = usage.get(pid);
+      if (sample)
+        childUsage[pid] = sample;
+    }
+    return {
+      cpuPercent: usage.get(process.pid)?.cpuPercent,
+      childUsage
+    };
+  } catch {
+    return {};
+  }
+}
+export function _resetBuiltinQuietWindowRegistrationForTests() {
+  _builtinsRegistered = false;
+}