@duckmind/dm-windows-x64 0.61.4 → 0.61.9

package/extensions/dm-subagents/src/api/preflight.js

@@ -0,0 +1,322 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { discoverAgentSnapshot, findBlockingAgentDiagnostic, formatUnknownAgentError, resolveAgentName, unknownAgentDiagnosticContext } from "../agents/agents.js";
+import { resolveExecutionAgentScope } from "../agents/agent-scope.js";
+import { buildSkillInjection, normalizeSkillInput, resolveSkillsWithFallback } from "../agents/skills.js";
+import { buildAgentMemoryInjection } from "../agents/agent-memory.js";
+import { buildModelCandidates, inheritsParentModel, resolveEffectiveSubagentModel } from "../runs/shared/model-fallback.js";
+import { resolveModelScopesForAgent } from "../runs/shared/model-scope.js";
+import { applyThinkingSuffix, resolvePiLaunchToolPlan } from "../runs/shared/dm-args.js";
+import { injectOutputPathSystemPrompt, normalizeSingleOutputOverride, resolveSingleOutputPath } from "../runs/shared/single-output.js";
+import { getArtifactPaths, getArtifactsDir } from "../shared/artifacts.js";
+import { resolveEffectiveThinking } from "../shared/model-info.js";
+import { assertThinkingWithinCeiling, decodeThinkingCeiling, intersectThinkingCeilings, SUBAGENT_THINKING_CEILING_ENV } from "../shared/thinking-ceiling.js";
+import { SUBAGENT_LIFECYCLE_ARTIFACT_VERSION } from "../shared/types.js";
+import { capabilityCeilingAgentRestrictionMessage, intersectSubagentCapabilityCeilings } from "../runs/shared/capability-ceiling.js";
+import { resolvePermissionRules } from "../runs/shared/permissions.js";
+import { resolveStepBehavior } from "../shared/settings.js";
+import { canPreferForkFromSnapshot, resolveSubagentLaunchContext } from "../shared/fork-context.js";
+import { loadConfig } from "../extension/config.js";
+import { agentDefinitionDigest, AGENT_DEFINITION_PROJECTION_VERSION, launchBindingDigest, stableJsonDigest } from "../shared/launch-contract.js";
+import { DIRS, TEMP_ROOT_DIR } from "../shared/types.js";
+import { processTerminalCandidatePath, processTerminalPath } from "../runs/background/process-terminal.js";
+import { resultFilePath } from "../runs/background/result-files.js";
+import { nestedResultsPath } from "../runs/shared/nested-events.js";
+import { normalizeExtensionBindings } from "../runs/shared/extension-bindings.js";
+export const SUBAGENT_LAUNCH_CONTRACT_VERSION = 2;
+function packageVersion() {
+  const packagePath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "package.json");
+  const parsed = JSON.parse(fs.readFileSync(packagePath, "utf-8"));
+  if (typeof parsed.version !== "string" || !parsed.version.trim()) {
+    throw new Error(`Invalid package version in '${packagePath}'.`);
+  }
+  return parsed.version;
+}
+function digestContract(contract) {
+  return stableJsonDigest(contract);
+}
+function normalizeAvailableModels(models) {
+  return (models ?? []).map((model) => ({ ...model, fullId: model.fullId ?? `${model.provider}/${model.id}` }));
+}
+function resolveLaunchContractContext(input, agent) {
+  return resolveSubagentLaunchContext({
+    explicitContext: input.context,
+    agentDefaultContext: agent.defaultContext,
+    defaultSubagentContext: loadConfig().defaultSubagentContext,
+    canUseImplicitFork: canPreferForkFromSnapshot({
+      parentSessionFile: input.parentSessionFile,
+      leafId: input.parentLeafId
+    })
+  });
+}
+function taskWorkspaceScopeAuthorityDiagnostic(task) {
+  if (!task)
+    return;
+  const text = task.replace(/\s+/g, " ").trim();
+  if (!text)
+    return;
+  const createsWorkspacePackage = /\b(?:add|create|introduce|make|set up)\b.{0,80}\b(?:new\s+)?(?:workspace\s+)?package\b/i.test(text) || /\b(?:new\s+)?package\b.{0,80}\b(?:workspace|monorepo)\b/i.test(text);
+  if (!createsWorkspacePackage)
+    return;
+  const packageOnlyAuthority = /\b(?:only|solely)\b.{0,40}\b(?:edit|change|modify|touch|write(?:\s+to)?)\b.{0,80}\b(?:package(?:\s+directory)?|packages\/[\w.-]+)\b/i.test(text) || /\b(?:do not|don't|must not)\b.{0,40}\b(?:edit|change|modify|touch|write(?:\s+to)?)\b.{0,80}\b(?:root|workspace|lockfile|metadata)\b/i.test(text) || /\bwithout\b.{0,40}\b(?:root|workspace|lockfile|metadata)\b.{0,40}\b(?:edit|change|modification|write)s?\b/i.test(text);
+  if (!packageOnlyAuthority)
+    return;
+  return {
+    code: "workspace_scope_authority",
+    severity: "warning",
+    message: "Task asks for a workspace package change while limiting authority to package-scope edits. New workspace packages often need root workspace metadata or lockfile changes, so confirm that authority before launch."
+  };
+}
+function candidateList(inputAgent, selected, all) {
+  return [...all.builtin, ...all.package, ...all.user, ...all.project].filter((agent) => Boolean(resolveAgentName(inputAgent, [agent]).agent)).map((agent) => ({
+    name: agent.name,
+    ...agent.localName ? { localName: agent.localName } : {},
+    ...agent.packageName ? { packageName: agent.packageName } : {},
+    source: agent.source,
+    filePath: agent.filePath,
+    ...agent.disabled === true ? { disabled: true } : {},
+    selected: Boolean(selected && agent.filePath === selected.filePath && agent.name === selected.name)
+  }));
+}
+export async function resolveSubagentLaunchContract(input) {
+  const diagnostics = [];
+  const authorityDiagnostic = taskWorkspaceScopeAuthorityDiagnostic(input.task);
+  if (authorityDiagnostic)
+    diagnostics.push(authorityDiagnostic);
+  const effectiveCwd = path.resolve(input.cwd);
+  try {
+    if (!fs.statSync(effectiveCwd).isDirectory()) {
+      return { ok: false, code: "invalid_cwd", message: `cwd '${effectiveCwd}' is not a directory.`, diagnostics };
+    }
+  } catch (error) {
+    const detail = error instanceof Error ? ` ${error.message}` : "";
+    return { ok: false, code: "invalid_cwd", message: `cwd '${effectiveCwd}' is not a directory.${detail}`, diagnostics };
+  }
+  if (input.context !== undefined && input.context !== "fresh" && input.context !== "fork") {
+    return { ok: false, code: "unsupported_mode", message: `Unsupported context '${String(input.context)}'; expected 'fresh' or 'fork'.`, diagnostics };
+  }
+  if (input.artifactDir !== undefined && input.artifactDir !== "project" && input.artifactDir !== "session" && input.artifactDir !== "temp") {
+    return { ok: false, code: "invalid_artifact_dir", message: `Unsupported artifactDir '${String(input.artifactDir)}'; expected 'project', 'session', or 'temp'.`, diagnostics };
+  }
+  const scope = resolveExecutionAgentScope(input.agentScope);
+  const parentProvider = input.preferredProvider ?? input.parentModel?.provider;
+  const discovery = discoverAgentSnapshot(effectiveCwd, scope, parentProvider, { includeChains: false });
+  const discovered = discovery.effective;
+  const resolvedAgent = resolveAgentName(input.agent, discovered.agents);
+  const ambiguousCandidates = resolvedAgent.error ? discovered.agents.filter((agent) => resolveAgentName(input.agent, [agent]).agent) : resolvedAgent.agent;
+  const invalidAgent = findBlockingAgentDiagnostic(input.agent, ambiguousCandidates, discovered.agentDiagnostics);
+  if (invalidAgent) {
+    const message = `Agent '${input.agent}' has invalid configuration: ${invalidAgent.error}`;
+    return { ok: false, code: "missing_agent", message, diagnostics: [{ code: "missing_agent", severity: "error", message }] };
+  }
+  if (resolvedAgent.error) {
+    return { ok: false, code: "ambiguous_agent", message: resolvedAgent.error, diagnostics };
+  }
+  if (!resolvedAgent.agent) {
+    return { ok: false, code: "missing_agent", message: formatUnknownAgentError(input.agent, unknownAgentDiagnosticContext(discovered)), diagnostics };
+  }
+  const agent = resolvedAgent.agent;
+  let extensionBindings;
+  try {
+    extensionBindings = normalizeExtensionBindings(input.extensionBindings)?.value;
+  } catch (error) {
+    return { ok: false, code: "invalid_extension_bindings", message: error instanceof Error ? error.message : String(error), diagnostics };
+  }
+  if (extensionBindings !== undefined && (agent.runner?.type === "external-cli" || agent.runner?.type === "external-job")) {
+    return { ok: false, code: "unsupported_mode", message: `extensionBindings is not supported for runner.type='${agent.runner.type}'.`, diagnostics };
+  }
+  const context = resolveLaunchContractContext(input, agent);
+  if (context === "fork") {
+    diagnostics.push({ code: "host_required", severity: "host-required", message: "Exact fork session branching and fork-thinking downgrade checks require DM host session and model-registry snapshots." });
+  }
+  const effectiveCapabilityCeiling = intersectSubagentCapabilityCeilings(input.capabilityCeiling, input.inheritedCapabilityCeiling);
+  const restrictionMessage = capabilityCeilingAgentRestrictionMessage(agent.name, effectiveCapabilityCeiling);
+  if (restrictionMessage)
+    return { ok: false, code: "restricted_agent", message: restrictionMessage, diagnostics };
+  const runId = input.runId ?? "preflight";
+  const skillInput = normalizeSkillInput(input.skill);
+  const outputOverride = normalizeSingleOutputOverride(input.output, agent.output);
+  const behavior = resolveStepBehavior(agent, {
+    ...outputOverride !== undefined ? { output: outputOverride } : {},
+    ...input.outputMode !== undefined ? { outputMode: input.outputMode } : {},
+    ...skillInput !== undefined ? { skills: skillInput } : {},
+    ...input.model !== undefined ? { model: input.model } : {}
+  });
+  const requestedSkills = behavior.skills === false ? [] : behavior.skills;
+  const resolvedSkills = resolveSkillsWithFallback(requestedSkills, effectiveCwd, effectiveCwd, agent.skillPath, agent.filePath ? path.dirname(agent.filePath) : effectiveCwd);
+  if (resolvedSkills.missing.includes("dm-subagents")) {
+    return { ok: false, code: "missing_skill", message: "The dm-subagents orchestration skill is not child-injectable.", diagnostics };
+  }
+  if (resolvedSkills.missing.length > 0)
+    diagnostics.push({ code: "missing_skill", severity: "error", message: `Missing skills: ${resolvedSkills.missing.join(", ")}` });
+  const externalRunner = agent.runner?.type === "external-cli" || agent.runner?.type === "external-job";
+  const availableModels = normalizeAvailableModels(input.availableModels);
+  const preferredProvider = agent.modelProvider ?? input.preferredProvider ?? input.parentModel?.provider;
+  const modelScopes = resolveModelScopesForAgent(discovered.modelScope, agent.name, input.parentModel);
+  const primaryModel = externalRunner ? undefined : resolveEffectiveSubagentModel(input.model, agent.model, input.parentModel, availableModels, preferredProvider, { scope: modelScopes });
+  const effectiveThinkingConfig = input.thinking !== undefined ? input.thinking : agent.thinking;
+  const thinkingCeiling = externalRunner ? undefined : intersectThinkingCeilings(discovered.maxThinking, input.thinkingCeiling, input.inheritedThinkingCeiling, decodeThinkingCeiling(process.env[SUBAGENT_THINKING_CEILING_ENV]));
+  const model = externalRunner ? undefined : applyThinkingSuffix(primaryModel, effectiveThinkingConfig, input.thinking !== undefined);
+  const modelCandidates = externalRunner ? [] : buildModelCandidates(primaryModel, agent.fallbackModels, availableModels, preferredProvider, {
+    scope: modelScopes,
+    primaryModelFromParent: inheritsParentModel(input.model, agent.model, input.parentModel)
+  }).map((candidate) => applyThinkingSuffix(candidate, effectiveThinkingConfig, input.thinking !== undefined) ?? candidate);
+  if (!externalRunner) {
+    try {
+      assertThinkingWithinCeiling({ model, configThinking: effectiveThinkingConfig, ceiling: thinkingCeiling, agent: agent.name, runId });
+      for (const candidate of modelCandidates)
+        assertThinkingWithinCeiling({ model: candidate, configThinking: effectiveThinkingConfig, ceiling: thinkingCeiling, agent: agent.name, runId });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      diagnostics.push({ code: "thinking_ceiling", severity: "error", message });
+      return { ok: false, code: "thinking_ceiling", message, diagnostics };
+    }
+  }
+  let toolPlan;
+  const permissionRules = resolvePermissionRules(loadConfig().permissions, agent.permissions);
+  const fast = input.fast ?? agent.fast;
+  try {
+    toolPlan = resolvePiLaunchToolPlan({
+      tools: agent.tools,
+      allowNestedSubagents: agent.allowNestedSubagents,
+      extensions: agent.extensions,
+      subagentOnlyExtensions: agent.subagentOnlyExtensions,
+      mcpDirectTools: agent.mcpDirectTools,
+      cwd: effectiveCwd,
+      requireReadTool: resolvedSkills.resolved.length > 0,
+      structuredOutput: Boolean(input.outputSchema),
+      fast,
+      model,
+      modelCandidates,
+      capabilityCeiling: effectiveCapabilityCeiling,
+      agentName: agent.name,
+      permissionRules
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    diagnostics.push({ code: "denied_required_tool", severity: "error", message });
+    return { ok: false, code: "denied_required_tool", message, diagnostics };
+  }
+  const artifactsEnabled = input.artifacts !== false;
+  const artifactsDir = artifactsEnabled ? getArtifactsDir(input.parentSessionFile ?? null, effectiveCwd, input.artifactDir) : undefined;
+  const artifactPaths = artifactsDir ? getArtifactPaths(artifactsDir, runId, agent.name, 0) : undefined;
+  const outputPath = resolveSingleOutputPath(behavior.output, effectiveCwd, effectiveCwd, artifactsDir ? path.join(artifactsDir, "outputs", runId) : undefined);
+  const sessionRoot = input.sessionDir ? path.resolve(input.sessionDir) : input.sessionRoot ? path.join(path.resolve(input.sessionRoot), runId) : undefined;
+  const sessionDir = sessionRoot ? path.join(sessionRoot, "run-0") : undefined;
+  const lifecycleAsyncDir = input.nestedRootRunId ? path.join(TEMP_ROOT_DIR, "nested-subagent-runs", input.nestedRootRunId, runId) : path.join(DIRS.async, runId);
+  const lifecycleResultPath = input.nestedRootRunId ? nestedResultsPath(input.nestedRootRunId, runId) : resultFilePath(DIRS.results, runId);
+  if (!sessionDir)
+    diagnostics.push({ code: "host_required", severity: "host-required", message: "No sessionRoot/sessionDir was supplied; exact child session paths require the DM host session-root policy." });
+  if (!externalRunner && input.availableModels === undefined && (input.model || agent.model || input.parentModel)) {
+    diagnostics.push({ code: "host_required", severity: "host-required", message: "No availableModels snapshot was supplied; model resolution may differ from the active DM host registry." });
+  }
+  if (resolvedSkills.missing.length > 0) {
+    return { ok: false, code: "missing_skill", message: `Missing skills: ${resolvedSkills.missing.join(", ")}`, diagnostics };
+  }
+  let effectiveSystemPrompt = agent.systemPrompt?.trim() ?? "";
+  if (resolvedSkills.resolved.length > 0) {
+    const skillInjection = buildSkillInjection(resolvedSkills.resolved);
+    effectiveSystemPrompt = effectiveSystemPrompt ? `${effectiveSystemPrompt}
+
+${skillInjection}` : skillInjection;
+  }
+  const memoryInjection = buildAgentMemoryInjection(agent, effectiveCwd);
+  if (memoryInjection)
+    effectiveSystemPrompt = effectiveSystemPrompt ? `${effectiveSystemPrompt}
+
+${memoryInjection}` : memoryInjection;
+  effectiveSystemPrompt = injectOutputPathSystemPrompt(effectiveSystemPrompt, outputPath, agent);
+  const candidates = candidateList(input.agent, agent, discovery.all);
+  const shadowedCandidates = candidates.filter((candidate) => !candidate.selected);
+  const definitionDigest = agentDefinitionDigest(agent);
+  const contractBase = {
+    version: SUBAGENT_LAUNCH_CONTRACT_VERSION,
+    runId,
+    agent: {
+      name: agent.name,
+      ...agent.localName ? { localName: agent.localName } : {},
+      ...agent.packageName ? { packageName: agent.packageName } : {},
+      source: agent.source,
+      filePath: agent.filePath,
+      definitionProjectionVersion: AGENT_DEFINITION_PROJECTION_VERSION,
+      definitionDigest,
+      shadowedCandidates
+    },
+    context,
+    ...model ? { model } : {},
+    modelCandidates,
+    ...resolveEffectiveThinking(model, effectiveThinkingConfig) ? { thinking: resolveEffectiveThinking(model, effectiveThinkingConfig) } : {},
+    ...thinkingCeiling ? { thinkingCeiling } : {},
+    systemPromptMode: agent.systemPromptMode,
+    inheritProjectContext: agent.inheritProjectContext,
+    inheritGlobalContext: agent.inheritGlobalContext,
+    inheritSkills: agent.inheritSkills,
+    skills: {
+      requested: requestedSkills,
+      resolved: resolvedSkills.resolved.map((skill) => ({ name: skill.name, path: skill.path, source: skill.source })),
+      missing: resolvedSkills.missing
+    },
+    tools: {
+      requestedBuiltin: toolPlan.requestedBuiltinTools,
+      declaredBuiltin: toolPlan.declaredBuiltinTools,
+      effectiveAllowlist: toolPlan.effectiveToolAllowlist,
+      explicitAllowlist: toolPlan.explicitToolAllowlist,
+      requiredChildTools: toolPlan.requiredChildTools,
+      internalTools: toolPlan.internalTools,
+      mcp: toolPlan.effectiveMcpSelections,
+      effectiveMcpTools: toolPlan.effectiveMcpTools,
+      toolExtensionPaths: toolPlan.toolExtensionPaths,
+      runtimeExtensions: toolPlan.runtimeExtensions,
+      configuredExtensions: toolPlan.configuredExtensions,
+      extensionArgs: toolPlan.extensionArgs,
+      disableAmbientExtensions: toolPlan.disableAmbientExtensions,
+      fanoutAuthorized: toolPlan.fanoutAuthorized,
+      ...toolPlan.capabilityCeiling ? { capabilityCeiling: toolPlan.capabilityCeiling } : {},
+      ...toolPlan.capabilityAudit ? { capabilityAudit: toolPlan.capabilityAudit } : {}
+    },
+    roots: {
+      cwd: effectiveCwd,
+      ...sessionRoot ? { sessionRoot } : {},
+      ...sessionDir ? { sessionDir, sessionFile: path.join(sessionDir, "session.jsonl") } : {},
+      ...artifactsDir ? { artifactsDir } : {},
+      ...artifactPaths ? { artifactPaths } : {},
+      ...outputPath ? { outputPath } : {},
+      lifecycle: {
+        asyncDir: lifecycleAsyncDir,
+        resultPath: lifecycleResultPath,
+        statusPath: path.join(lifecycleAsyncDir, "status.json"),
+        eventsPath: path.join(lifecycleAsyncDir, "events.jsonl"),
+        processTerminalPath: processTerminalPath(lifecycleAsyncDir),
+        processTerminalCandidatePath: processTerminalCandidatePath(lifecycleAsyncDir)
+      }
+    },
+    protocol: {
+      lifecycleArtifactVersion: SUBAGENT_LIFECYCLE_ARTIFACT_VERSION,
+      packageVersion: packageVersion()
+    },
+    diagnostics,
+    launchContractDigest: launchBindingDigest({
+      task: input.task ?? "",
+      definitionDigest,
+      ...model ? { model } : {},
+      modelCandidates,
+      ...fast !== undefined ? { fast } : {},
+      ...resolveEffectiveThinking(model, effectiveThinkingConfig) ? { thinking: resolveEffectiveThinking(model, effectiveThinkingConfig) } : {},
+      systemPrompt: effectiveSystemPrompt,
+      systemPromptMode: agent.systemPromptMode,
+      inheritProjectContext: agent.inheritProjectContext,
+      inheritGlobalContext: agent.inheritGlobalContext,
+      inheritSkills: agent.inheritSkills,
+      skills: requestedSkills,
+      tools: toolPlan.effectiveToolAllowlist,
+      extensions: toolPlan.extensionArgs,
+      mcpDirectTools: toolPlan.effectiveMcpTools,
+      ...outputPath ? { outputPath } : {},
+      outputMode: behavior.outputMode,
+      ...input.outputSchema ? { structuredOutputSchema: input.outputSchema } : {},
+      ...extensionBindings ? { extensionBindings } : {}
+    })
+  };
+  return { ok: true, contract: { ...contractBase, digest: digestContract(contractBase) } };
+}

package/extensions/dm-subagents/src/api/project-panes.js

@@ -0,0 +1,11 @@
+export {
+  PROJECT_PANES_API_VERSION,
+  PROJECT_PANE_TRUST_STATUS,
+  createProjectPaneManager,
+  openProjectPane,
+  getProjectPaneStatus,
+  focusProjectPane,
+  closeProjectPane,
+  readProjectPaneBinding,
+  projectPaneBindingPath
+} from "../inspectors/herdr/project-panes.js";

package/extensions/dm-subagents/src/api/shared-types.js

@@ -0,0 +1,4 @@
+export {
+  DEFAULT_FORK_PREAMBLE,
+  wrapForkTask
+} from "../shared/types.js";

package/extensions/dm-subagents/src/extension/config.js

@@ -1,6 +1,168 @@
 import * as fs from "node:fs";
+import * as os from "node:os";
 import * as path from "node:path";
+import { Key } from "@duckmind/dm-tui";
+import { FLEET_KEYBINDING_ACTIONS } from "../shared/types.js";
+import { validateMissionStoreConfig } from "../missions/store.js";
+import { validateAuthorityPolicy } from "../policy/authority.js";
 import { getAgentDir } from "../shared/utils.js";
+import { DEFAULT_MODEL_EXCLUSION_TTL_MS, MAX_MODEL_EXCLUSION_TTL_MS, setDefaultTTL } from "../runs/shared/model-exclusions.js";
+import { validatePermissionConfig } from "../runs/shared/permissions.js";
+import { MAX_ABANDONED_SLOT_RELEASE_AFTER_MS, MIN_ABANDONED_SLOT_RELEASE_AFTER_MS } from "../runs/background/active-async-capacity.js";
+const ARTIFACT_DIR_PREFERENCES = new Set(["project", "session", "temp"]);
+const FLEET_KEYBINDING_ACTION_SET = new Set(FLEET_KEYBINDING_ACTIONS);
+const KEY_MODIFIERS = new Set(["ctrl", "shift", "alt", "super"]);
+const BASE_KEY_IDS = new Set([
+  ..."abcdefghijklmnopqrstuvwxyz0123456789",
+  ...Object.values(Key).flatMap((value) => typeof value === "string" ? [value.toLowerCase()] : [])
+]);
+
+class PrunedForkConfigError extends Error {
+}
+function validateForkContextConfig(value) {
+  if (value === undefined)
+    return;
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("config.forkContext must be a JSON object");
+  const config = value;
+  if (config.mode !== undefined && config.mode !== "full" && config.mode !== "pruned") {
+    throw new Error('config.forkContext.mode must be "full" or "pruned"');
+  }
+  if (config.model !== undefined && (typeof config.model !== "string" || !config.model.trim())) {
+    throw new PrunedForkConfigError("config.forkContext.model must be a non-empty string");
+  }
+  if (config.mode === "pruned" && config.model === undefined) {
+    throw new PrunedForkConfigError('config.forkContext.model is required when config.forkContext.mode is "pruned"');
+  }
+}
+function isValidKeyId(value) {
+  if (value !== value.trim())
+    return false;
+  const parts = value.toLowerCase().split("+");
+  const base = parts.pop();
+  if (!base || !BASE_KEY_IDS.has(base))
+    return false;
+  return parts.length <= KEY_MODIFIERS.size && new Set(parts).size === parts.length && parts.every((modifier) => KEY_MODIFIERS.has(modifier));
+}
+export function resolveScheduledStoreRoot(value) {
+  const expanded = value.startsWith("~/") ? path.join(os.homedir(), value.slice(2)) : value;
+  if (!path.isAbsolute(expanded))
+    throw new Error(`config.scheduledRuns.storeRoot must be an absolute path or "~/...", got ${JSON.stringify(value)}`);
+  return path.normalize(expanded);
+}
+function validateScheduledRunsConfig(value) {
+  if (value === undefined)
+    return;
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("config.scheduledRuns must be a JSON object");
+  const storeRoot = value.storeRoot;
+  if (storeRoot === undefined)
+    return;
+  if (typeof storeRoot !== "string" || !storeRoot.trim())
+    throw new Error("config.scheduledRuns.storeRoot must be a non-empty string");
+  resolveScheduledStoreRoot(storeRoot);
+}
+function validateFleetKeybindingsConfig(value) {
+  if (value === undefined)
+    return;
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("config.fleetKeybindings must be a JSON object");
+  for (const [action, bindings] of Object.entries(value)) {
+    if (!FLEET_KEYBINDING_ACTION_SET.has(action))
+      throw new Error(`config.fleetKeybindings.${action} is not a supported Fleet action`);
+    if (!Array.isArray(bindings) || bindings.length === 0)
+      throw new Error(`config.fleetKeybindings.${action} must be a non-empty array of strings`);
+    for (const binding of bindings) {
+      if (typeof binding !== "string" || !binding.trim())
+        throw new Error(`config.fleetKeybindings.${action} entries must be non-empty strings`);
+    }
+  }
+}
+function validateArtifactConfig(value) {
+  if (value === undefined)
+    return;
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("config.artifactConfig must be a JSON object");
+  const cleanupDays = value.cleanupDays;
+  if (cleanupDays !== undefined && (typeof cleanupDays !== "number" || !Number.isInteger(cleanupDays) || cleanupDays < 0)) {
+    throw new Error("config.artifactConfig.cleanupDays must be a non-negative integer");
+  }
+}
+function validateCapacityConfig(value) {
+  if (value === undefined)
+    return;
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("config.capacity must be a JSON object");
+  const abandonedSlotReleaseAfterMs = value.abandonedSlotReleaseAfterMs;
+  if (abandonedSlotReleaseAfterMs !== undefined && abandonedSlotReleaseAfterMs !== false && (typeof abandonedSlotReleaseAfterMs !== "number" || !Number.isInteger(abandonedSlotReleaseAfterMs) || abandonedSlotReleaseAfterMs < MIN_ABANDONED_SLOT_RELEASE_AFTER_MS || abandonedSlotReleaseAfterMs > MAX_ABANDONED_SLOT_RELEASE_AFTER_MS)) {
+    throw new Error(`config.capacity.abandonedSlotReleaseAfterMs must be false or an integer from ${MIN_ABANDONED_SLOT_RELEASE_AFTER_MS} to ${MAX_ABANDONED_SLOT_RELEASE_AFTER_MS}`);
+  }
+}
+function validateModelExclusionsConfig(value) {
+  if (value === undefined)
+    return;
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("config.modelExclusions must be a JSON object");
+  const defaultTtlMs = value.defaultTtlMs;
+  if (defaultTtlMs !== undefined && (typeof defaultTtlMs !== "number" || !Number.isFinite(defaultTtlMs) || defaultTtlMs <= 0 || defaultTtlMs > MAX_MODEL_EXCLUSION_TTL_MS)) {
+    throw new Error(`config.modelExclusions.defaultTtlMs must be a finite positive number no greater than ${MAX_MODEL_EXCLUSION_TTL_MS}`);
+  }
+}
+function validateOrcaProgressTabsConfig(value) {
+  if (value === undefined)
+    return;
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("config.orcaProgressTabs must be a JSON object");
+  const config = value;
+  for (const key of Object.keys(config)) {
+    if (key !== "enabled")
+      throw new Error(`config.orcaProgressTabs.${key} is not supported`);
+  }
+  if (config.enabled !== undefined && typeof config.enabled !== "boolean") {
+    throw new Error("config.orcaProgressTabs.enabled must be a boolean");
+  }
+}
+function validateMainWindowRendererConfig(value) {
+  if (value === undefined)
+    return;
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("config.mainWindowRenderer must be a JSON object");
+  const rendererConfig = value;
+  if (rendererConfig.horizontalSpacing !== undefined && (typeof rendererConfig.horizontalSpacing !== "number" || !Number.isInteger(rendererConfig.horizontalSpacing) || rendererConfig.horizontalSpacing < 0 || rendererConfig.horizontalSpacing > 4)) {
+    throw new Error("config.mainWindowRenderer.horizontalSpacing must be an integer from 0 to 4");
+  }
+  if (rendererConfig.compactResultMaxLines !== undefined && (typeof rendererConfig.compactResultMaxLines !== "number" || !Number.isInteger(rendererConfig.compactResultMaxLines) || rendererConfig.compactResultMaxLines < 1)) {
+    throw new Error("config.mainWindowRenderer.compactResultMaxLines must be a positive integer");
+  }
+}
+function validateConfig(config) {
+  if (config.defaultSubagentContext !== undefined && config.defaultSubagentContext !== "fresh" && config.defaultSubagentContext !== "fork") {
+    throw new Error('config.defaultSubagentContext must be "fresh" or "fork"');
+  }
+  validateForkContextConfig(config.forkContext);
+  if (config.foregroundDetachShortcut !== undefined && (typeof config.foregroundDetachShortcut !== "string" || !isValidKeyId(config.foregroundDetachShortcut))) {
+    throw new Error('config.foregroundDetachShortcut must be a valid keybinding string such as "ctrl+b"');
+  }
+  if (config.artifactDir !== undefined && !ARTIFACT_DIR_PREFERENCES.has(config.artifactDir)) {
+    throw new Error(`config.artifactDir must be "project", "session", or "temp"`);
+  }
+  if (config.maxActiveAsyncRunsPerSession !== undefined && (typeof config.maxActiveAsyncRunsPerSession !== "number" || !Number.isInteger(config.maxActiveAsyncRunsPerSession) || config.maxActiveAsyncRunsPerSession < 0)) {
+    throw new Error("config.maxActiveAsyncRunsPerSession must be a non-negative integer");
+  }
+  if (config.resultScanLogging !== undefined && config.resultScanLogging !== "all" && config.resultScanLogging !== "activity" && config.resultScanLogging !== "off") {
+    throw new Error('config.resultScanLogging must be "all", "activity", or "off"');
+  }
+  validateMissionStoreConfig(config.missions);
+  validateAuthorityPolicy(config.authorityPolicy);
+  validatePermissionConfig(config.permissions);
+  validateScheduledRunsConfig(config.scheduledRuns);
+  validateFleetKeybindingsConfig(config.fleetKeybindings);
+  validateArtifactConfig(config.artifactConfig);
+  validateCapacityConfig(config.capacity);
+  validateModelExclusionsConfig(config.modelExclusions);
+  validateMainWindowRendererConfig(config.mainWindowRenderer);
+  validateOrcaProgressTabsConfig(config.orcaProgressTabs);
+}
 export function getConfigPath() {
   return path.join(getAgentDir(), "extensions", "subagent", "config.json");
 }
@@ -11,6 +173,7 @@ function readConfigForUpdate(configPath = getConfigPath()) {
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
     throw new Error(`Subagent config at '${configPath}' must be a JSON object`);
   }
+  validateConfig(parsed);
   return parsed;
 }
 export function saveConfig(config, configPath = getConfigPath()) {
@@ -21,14 +184,26 @@ export function saveConfig(config, configPath = getConfigPath()) {
 export function updateConfig(updater) {
   const configPath = getConfigPath();
   const next = updater(readConfigForUpdate(configPath));
+  validateConfig(next);
   saveConfig(next, configPath);
   return next;
 }
+export function resolveModelExclusionTTL(config) {
+  return config.modelExclusions?.defaultTtlMs ?? DEFAULT_MODEL_EXCLUSION_TTL_MS;
+}
+export function applyModelExclusionsConfig(config) {
+  setDefaultTTL(resolveModelExclusionTTL(config), { shortenExisting: config.modelExclusions?.defaultTtlMs !== undefined });
+}
+export function resolveAsyncByDefault(config) {
+  return config.asyncByDefault !== false;
+}
 export function loadConfig() {
   const configPath = getConfigPath();
   try {
     return readConfigForUpdate(configPath);
   } catch (error) {
+    if (error instanceof PrunedForkConfigError)
+      throw error;
     console.error(`Failed to load subagent config from '${configPath}':`, error);
   }
   return {};

package/extensions/dm-subagents/src/extension/control-notices.js

@@ -6,21 +6,6 @@ export function controlNoticeTarget(details) {
 export function formatSubagentControlNotice(details, content) {
   return details.noticeText ?? content ?? formatControlNoticeMessage(details.event, controlNoticeTarget(details));
 }
-function noticeTimerKey(details) {
-  const childIntercomTarget = controlNoticeTarget(details);
-  return `${details.event.runId}:${controlNotificationKey(details.event, childIntercomTarget)}`;
-}
-export function clearPendingForegroundControlNotices(state, runId) {
-  const pending = state.pendingForegroundControlNotices;
-  if (!pending)
-    return;
-  for (const [key, timer] of pending) {
-    if (runId !== undefined && !key.startsWith(`${runId}:`))
-      continue;
-    clearTimeout(timer);
-    pending.delete(key);
-  }
-}
 function deliverControlNotice(input) {
   const childIntercomTarget = controlNoticeTarget(input.details);
   const key = controlNotificationKey(input.details.event, childIntercomTarget);
@@ -28,42 +13,18 @@ function deliverControlNotice(input) {
     return;
   input.visibleControlNotices.add(key);
   const noticeText = input.details.noticeText ?? formatControlNoticeMessage(input.details.event, childIntercomTarget);
-  input.pi.sendMessage({
+  input.dm.sendMessage({
     customType: SUBAGENT_CONTROL_MESSAGE_TYPE,
     content: noticeText,
     display: true,
     details: { ...input.details, childIntercomTarget, noticeText }
-  }, { triggerTurn: input.details.source !== "foreground" });
-}
-function isForegroundNoticeStillActionable(state, details) {
-  const control = state.foregroundControls.get(details.event.runId);
-  if (!control)
-    return false;
-  if (control.currentAgent && control.currentAgent !== details.event.agent)
-    return false;
-  if (details.event.index !== undefined && control.currentIndex !== details.event.index)
-    return false;
-  return control.currentActivityState === "needs_attention";
+  }, { triggerTurn: input.details.source === "async" });
 }
 export function handleSubagentControlNotice(input) {
   if (!input.details?.event || input.details.event.type === "active_long_running")
     return;
-  if (input.details.source !== "foreground") {
-    deliverControlNotice(input);
+  if (input.details.source === "foreground") {
     return;
   }
-  const pending = input.state.pendingForegroundControlNotices ?? new Map;
-  input.state.pendingForegroundControlNotices = pending;
-  const timerKey = noticeTimerKey(input.details);
-  const existing = pending.get(timerKey);
-  if (existing)
-    clearTimeout(existing);
-  const timer = setTimeout(() => {
-    pending.delete(timerKey);
-    if (!isForegroundNoticeStillActionable(input.state, input.details))
-      return;
-    deliverControlNotice(input);
-  }, input.foregroundDelayMs ?? 1000);
-  timer.unref?.();
-  pending.set(timerKey, timer);
+  deliverControlNotice(input);
 }