@topogram/cli 0.3.64 → 0.3.66

package/src/agent-ops/query-builders/workflow-context-shared.js

@@ -0,0 +1,300 @@
+import {
+  WORKFLOW_QUERY_FAMILIES_BY_MODE,
+  stableSortedStrings
+} from "./common.js";
+export function outputIdsForWorkflowContext(taskModeArtifact, maintainedBoundary = null) {
+  return stableSortedStrings([
+    ...((taskModeArtifact?.verification_targets?.output_verification_targets || []).map((entry) => entry.output_id)),
+    ...((maintainedBoundary?.outputs || []).map((entry) => entry.output_id))
+  ]);
+}
+
+export function integrationCategoriesForWorkflowContext(taskModeArtifact, importPlan = null) {
+  const categories = [];
+  if (taskModeArtifact?.mode === "import-adopt") categories.push("provider_adoption");
+  if (taskModeArtifact?.mode === "maintained-app-edit") categories.push("maintained_app");
+  if ((taskModeArtifact?.verification_targets?.maintained_app_checks || []).length > 0) categories.push("maintained_boundary");
+  if ((importPlan?.requires_human_review || []).length > 0) categories.push("human_review");
+  return stableSortedStrings(categories);
+}
+
+export function currentFocusFromTaskMode(taskModeArtifact) {
+  const selectedSurface = taskModeArtifact?.summary?.selected_surface || null;
+  if (selectedSurface) {
+    return selectedSurface;
+  }
+  const focus = taskModeArtifact?.summary?.focus || null;
+  return focus ? { kind: "mode_focus", label: focus } : null;
+}
+
+export function verificationSurfaceForTargets(verificationTargets) {
+  const targetCount = ((verificationTargets?.generated_checks || []).length)
+    + ((verificationTargets?.maintained_app_checks || []).length)
+    + ((verificationTargets?.verification_ids || []).length);
+  return targetCount > 0 ? "verification-targets" : null;
+}
+
+export function recommendedQueryFamilyForAction(nextAction, mode = null) {
+  switch (nextAction?.kind) {
+    case "review_staged":
+    case "review_bundle":
+    case "inspect_review_group":
+    case "inspect_proposal_surface":
+    case "customize_workflow_preset":
+    case "refresh_workflow_preset_customization":
+    case "import_declared_workflow_preset":
+      return "import-plan";
+    case "review_diff_impact":
+    case "inspect_projection":
+    case "inspect_diff":
+    case "review_diff_boundaries":
+      return "change-plan";
+    case "inspect_maintained_impact":
+    case "inspect_boundary_before_edit":
+    case "run_maintained_checks":
+      return "maintained-boundary";
+    case "inspect_verification_targets":
+      return "verification-targets";
+    case "inspect_workspace_digest":
+      return "single-agent-plan";
+    default:
+      break;
+  }
+
+  if (mode === "import-adopt") return "import-plan";
+  if (mode === "maintained-app-edit") return "maintained-boundary";
+  if (mode === "verification") return "verification-targets";
+  return "change-plan";
+}
+
+export function immediateArtifacts(primaryArtifacts = []) {
+  return (primaryArtifacts || []).slice(0, 2);
+}
+
+export function buildOperatorLoopSummary({
+  mode = null,
+  nextAction = null,
+  primaryArtifacts = [],
+  verificationTargets = null,
+  currentSurface = null
+} = {}) {
+  return {
+    current_surface: currentSurface,
+    start_query_family: recommendedQueryFamilyForAction(nextAction, mode),
+    immediate_artifacts: immediateArtifacts(primaryArtifacts),
+    review_surface: "review-packet",
+    decision_surface: "proceed-decision",
+    verification_surface: verificationSurfaceForTargets(verificationTargets)
+  };
+}
+
+export function nextActionRequiresReview(nextAction) {
+  const reviewKinds = new Set([
+    "review_staged",
+    "inspect_review_group",
+    "inspect_proposal_surface",
+    "inspect_plan",
+    "inspect_boundary_before_edit",
+    "review_diff_boundaries",
+    "review_diff_impact",
+    "inspect_maintained_impact",
+    "inspect_generated_impact",
+    "inspect_diff",
+    "inspect_verification_targets",
+    "inspect_workspace_digest"
+  ]);
+  return reviewKinds.has(nextAction?.kind);
+}
+
+export function buildReviewBoundaries(taskModeArtifact, importPlan = null) {
+  return {
+    ownership_boundary: taskModeArtifact?.ownership_boundary || null,
+    review_emphasis: taskModeArtifact?.review_emphasis || [],
+    approved_review_groups: importPlan?.review_groups || [],
+    requires_human_review: importPlan?.requires_human_review || []
+  };
+}
+
+export function buildBlockingConditions(taskModeArtifact, importPlan = null) {
+  const blocking = [];
+  const nextAction = taskModeArtifact?.next_action || null;
+
+  if (nextAction?.kind === "missing_plan") {
+    blocking.push({
+      kind: "missing_artifact",
+      artifact: "candidates/reconcile/adoption-plan.agent.json",
+      reason: nextAction.reason || "No staged adoption plan exists yet.",
+      recommended_step: "Run reconcile first."
+    });
+  }
+
+  if ((importPlan?.requires_human_review || []).length > 0) {
+    blocking.push({
+      kind: "human_review_required",
+      count: importPlan.requires_human_review.length,
+      items: importPlan.requires_human_review,
+      reason: `${importPlan.requires_human_review.length} staged proposal(s) still require human review or mapping decisions before canonical adoption.`
+    });
+  }
+
+  if (nextAction && nextActionRequiresReview(nextAction)) {
+    blocking.push({
+      kind: "review_gate",
+      next_action_kind: nextAction.kind,
+      reason: nextAction.reason || "The next step is review-oriented rather than directly executable."
+    });
+  }
+
+  return blocking;
+}
+
+export function firstPrimaryArtifact(taskModeArtifact) {
+  return (taskModeArtifact?.preferred_context_artifacts || [])[0] || null;
+}
+
+export function buildImportAdoptSequence(taskModeArtifact, importPlan = null) {
+  const steps = [];
+  const primaryArtifact = firstPrimaryArtifact(taskModeArtifact);
+  if (primaryArtifact) {
+    steps.push({
+      order: steps.length + 1,
+      action: "read_primary_artifact",
+      artifact: primaryArtifact,
+      review_required: false,
+      reason: "Start from the staged adoption view before changing canonical Topogram."
+    });
+  }
+  if (importPlan) {
+    steps.push({
+      order: steps.length + 1,
+      action: "inspect_adoption_state",
+      review_required: (importPlan.requires_human_review || []).length > 0,
+      reason: `${(importPlan.staged_items || []).length} staged item(s) and ${(importPlan.requires_human_review || []).length} review-required item(s) are currently in scope.`
+    });
+  }
+  if (taskModeArtifact?.next_action) {
+    steps.push({
+      order: steps.length + 1,
+      action: "follow_next_action",
+      next_action_kind: taskModeArtifact.next_action.kind,
+      review_required: nextActionRequiresReview(taskModeArtifact.next_action),
+      reason: taskModeArtifact.next_action.reason || "Follow the current staged adoption step."
+    });
+  }
+  steps.push({
+    order: steps.length + 1,
+    action: "run_proof_targets",
+    review_required: false,
+    proof_targets: taskModeArtifact?.verification_targets || null,
+    reason: "Validate proposal state before any canonical write."
+  });
+  return steps;
+}
+
+export function buildMaintainedAppEditSequence(taskModeArtifact) {
+  const steps = [];
+  const primaryArtifact = firstPrimaryArtifact(taskModeArtifact);
+  if (primaryArtifact) {
+    steps.push({
+      order: 1,
+      action: "read_primary_artifact",
+      artifact: primaryArtifact,
+      review_required: false,
+      reason: "Start from the maintained-app bundle to see accepted, guarded, and no-go seams."
+    });
+  }
+  steps.push({
+    order: steps.length + 1,
+    action: "inspect_review_boundaries",
+    review_required: true,
+    reason: "Review human-owned seams and guarded boundaries before editing maintained code."
+  });
+  steps.push({
+    order: steps.length + 1,
+    action: "respect_write_scope",
+    review_required: false,
+    reason: "Keep edits inside the maintained write scope attached to the current proof bundle."
+  });
+  steps.push({
+    order: steps.length + 1,
+    action: "run_proof_targets",
+    review_required: false,
+    proof_targets: taskModeArtifact?.verification_targets || null,
+    reason: "Run maintained proof checks after the bounded edit."
+  });
+  return steps;
+}
+
+export function buildGenericSequence(taskModeArtifact, {
+  readReason,
+  reviewReason,
+  proofReason
+} = {}) {
+  const steps = [];
+  const primaryArtifact = firstPrimaryArtifact(taskModeArtifact);
+  if (primaryArtifact) {
+    steps.push({
+      order: steps.length + 1,
+      action: "read_primary_artifact",
+      artifact: primaryArtifact,
+      review_required: false,
+      reason: readReason || "Start from the preferred context artifact for this mode."
+    });
+  }
+  if (taskModeArtifact?.next_action) {
+    steps.push({
+      order: steps.length + 1,
+      action: "follow_next_action",
+      next_action_kind: taskModeArtifact.next_action.kind,
+      review_required: nextActionRequiresReview(taskModeArtifact.next_action),
+      reason: taskModeArtifact.next_action.reason || "Follow the current recommended next action."
+    });
+  }
+  steps.push({
+    order: steps.length + 1,
+    action: "inspect_review_boundaries",
+    review_required: true,
+    reason: reviewReason || "Use the attached review emphasis and ownership boundary before mutating durable meaning."
+  });
+  steps.push({
+    order: steps.length + 1,
+    action: "run_proof_targets",
+    review_required: false,
+    proof_targets: taskModeArtifact?.verification_targets || null,
+    reason: proofReason || "Run the smallest proof set attached to this mode."
+  });
+  return steps;
+}
+
+export function buildRecommendedSequence(taskModeArtifact, importPlan = null) {
+  const mode = taskModeArtifact?.mode || null;
+  if (mode === "import-adopt") {
+    return buildImportAdoptSequence(taskModeArtifact, importPlan);
+  }
+  if (mode === "maintained-app-edit") {
+    return buildMaintainedAppEditSequence(taskModeArtifact);
+  }
+  if (mode === "diff-review") {
+    return buildGenericSequence(taskModeArtifact, {
+      readReason: "Start from the diff or focused slice before choosing an edit path.",
+      reviewReason: "Diff review should stay read-first until maintained and generated impact is clear.",
+      proofReason: "Keep proof selection attached to the affected semantic change."
+    });
+  }
+  if (mode === "verification") {
+    return buildGenericSequence(taskModeArtifact, {
+      readReason: "Start from the focused verification context before running checks.",
+      reviewReason: "Confirm the intended verification surface before widening the check set.",
+      proofReason: "Run the smallest correct proof set for the current task."
+    });
+  }
+  return buildGenericSequence(taskModeArtifact, {
+    readReason: "Start from the focused modeling context before editing canonical Topogram.",
+    reviewReason: "Review semantic boundaries before changing durable intent.",
+    proofReason: "Run the proof targets attached to the selected semantic closure."
+  });
+}
+
+export function coreWorkflowQueriesForMode(mode) {
+  return WORKFLOW_QUERY_FAMILIES_BY_MODE[mode] || ["change-plan", "risk-summary", "verification-targets"];
+}

package/src/agent-ops/query-builders/workflow-context.js

@@ -0,0 +1,398 @@
+import {
+  CANONICAL_TASK_MODES,
+  artifactLoadOrderFromGeneratorTargets,
+  flattenVerificationTargets,
+  recommendedArtifactQueriesFromGeneratorTargets,
+  stableOrderedUnion,
+  stableSortedStrings
+} from "./common.js";
+import {
+  activeProviderPreset,
+  activeTeamPreset,
+  loadWorkflowPresetArtifacts,
+  presetAppliesToContext,
+  providerManifestWorkflowPresetDeclarations,
+  skippedPresetReason,
+  summarizeWorkflowPreset
+} from "./workflow-presets-core.js";
+import { buildWorkflowPresetInventory } from "./workflow-presets.js";
+import {
+  buildBlockingConditions,
+  buildOperatorLoopSummary,
+  buildRecommendedSequence,
+  buildReviewBoundaries,
+  coreWorkflowQueriesForMode,
+  currentFocusFromTaskMode,
+  integrationCategoriesForWorkflowContext,
+  outputIdsForWorkflowContext
+} from "./workflow-context-shared.js";
+import { buildPresetGuidanceSummary, classifyRisk } from "./change-risk.js";
+export function activeWorkflowPresetsForContext({
+  workspace = null,
+  providerPresets = null,
+  teamPresets = null,
+  providerManifests = null,
+  selectors = {}
+} = {}) {
+  const loaded = (providerPresets && teamPresets)
+    ? { provider_presets: providerPresets, team_presets: teamPresets, provider_manifests: providerManifests || [] }
+    : loadWorkflowPresetArtifacts(workspace);
+
+  const activeProviderPresets = loaded.provider_presets
+    .filter((preset) => activeProviderPreset(preset) && presetAppliesToContext(preset, selectors))
+    .sort((a, b) => a.priority - b.priority || a.source_priority - b.source_priority || String(a.id).localeCompare(String(b.id)));
+  const activeTeamPresets = loaded.team_presets
+    .filter((preset) => activeTeamPreset(preset) && presetAppliesToContext(preset, selectors))
+    .sort((a, b) => a.priority - b.priority || a.source_priority - b.source_priority || String(a.id).localeCompare(String(b.id)));
+  const skippedPresets = [
+    ...loaded.provider_presets
+      .filter((preset) => !activeProviderPreset(preset) || !presetAppliesToContext(preset, selectors))
+      .map((preset) => ({
+        id: preset.id,
+        kind: preset.kind,
+        provider_id: preset.provider?.id || preset.provenance?.provider_id || null,
+        priority: preset.priority,
+        reason: skippedPresetReason(preset, selectors)
+      })),
+    ...loaded.team_presets
+      .filter((preset) => !activeTeamPreset(preset) || !presetAppliesToContext(preset, selectors))
+      .map((preset) => ({
+        id: preset.id,
+        kind: preset.kind,
+        provider_id: preset.provider?.id || preset.provenance?.provider_id || null,
+        priority: preset.priority,
+        reason: skippedPresetReason(preset, selectors)
+      }))
+  ].sort((a, b) => `${a.kind}:${a.id}`.localeCompare(`${b.kind}:${b.id}`));
+
+  return {
+    active_provider_presets: activeProviderPresets,
+    active_team_presets: activeTeamPresets,
+    skipped_presets: skippedPresets,
+    provider_manifest_declarations: providerManifestWorkflowPresetDeclarations(loaded.provider_manifests || [], loaded.provider_presets || [])
+  };
+}
+
+export function mergeFieldResolution(entries = []) {
+  return entries.filter(Boolean).map((entry) => ({
+    preset_id: entry.id,
+    kind: entry.kind,
+    priority: entry.priority,
+    source_priority: entry.source_priority
+  }));
+}
+
+export function buildWorkflowPresetActivationPayload({
+  workspace = null,
+  taskModeArtifact,
+  importPlan = null,
+  maintainedBoundary = null,
+  providerPresets = null,
+  teamPresets = null,
+  providerManifests = null,
+  selectors = {}
+}) {
+  const resolvedSelectors = {
+    mode: taskModeArtifact?.mode || null,
+    task_class: taskModeArtifact?.mode || null,
+    outputs: outputIdsForWorkflowContext(taskModeArtifact, maintainedBoundary),
+    integration_categories: integrationCategoriesForWorkflowContext(taskModeArtifact, importPlan),
+    query_family: "workflow-activation",
+    manual_context: Boolean(importPlan?.requires_human_review?.length),
+    ...selectors
+  };
+  const inventory = buildWorkflowPresetInventory({
+    workspace,
+    providerPresets,
+    teamPresets,
+    providerManifests,
+    selectors: resolvedSelectors
+  });
+  const activation = activeWorkflowPresetsForContext({
+    workspace,
+    providerPresets,
+    teamPresets,
+    providerManifests,
+    selectors: resolvedSelectors
+  });
+  return {
+    type: "workflow_preset_activation_query",
+    mode: resolvedSelectors.mode,
+    selectors: resolvedSelectors,
+    active_presets: [
+      ...activation.active_provider_presets.map((preset) => summarizeWorkflowPreset(preset, resolvedSelectors)),
+      ...activation.active_team_presets.map((preset) => summarizeWorkflowPreset(preset, resolvedSelectors))
+    ].sort((a, b) => `${a.kind}:${a.priority}:${a.id}`.localeCompare(`${b.kind}:${b.priority}:${b.id}`)),
+    skipped_presets: activation.skipped_presets,
+    provider_manifest_declarations: inventory.provider_manifest_declarations || [],
+    summary: {
+      active_provider_count: activation.active_provider_presets.length,
+      active_team_count: activation.active_team_presets.length,
+      skipped_count: activation.skipped_presets.length,
+      missing_declared_workflow_preset_count: (inventory.provider_manifest_summary?.missing_declared_workflow_preset_count || 0)
+    }
+  };
+}
+
+export function composeWorkflowToolHints(providerPresets, teamPresets) {
+  const merged = {};
+  for (const preset of [...providerPresets, ...teamPresets]) {
+    for (const [toolName, value] of Object.entries(preset.tool_hints || {})) {
+      merged[toolName] = {
+        ...(merged[toolName] || {}),
+        ...(value && typeof value === "object" ? value : { value })
+      };
+    }
+  }
+  return merged;
+}
+
+export function buildResolvedWorkflowContextPayload({
+  workspace = null,
+  taskModeArtifact,
+  importPlan = null,
+  reviewBoundary = null,
+  maintainedBoundary = null,
+  generatorTargets = [],
+  providerPresets = null,
+  teamPresets = null,
+  providerManifests = null,
+  selectors = {}
+}) {
+  const resolvedSelectors = {
+    mode: taskModeArtifact?.mode || null,
+    task_class: taskModeArtifact?.mode || null,
+    outputs: outputIdsForWorkflowContext(taskModeArtifact, maintainedBoundary),
+    integration_categories: integrationCategoriesForWorkflowContext(taskModeArtifact, importPlan),
+    query_family: "workflow",
+    manual_context: Boolean(importPlan?.requires_human_review?.length),
+    ...selectors
+  };
+  const presetInventory = buildWorkflowPresetInventory({
+    workspace,
+    providerPresets,
+    teamPresets,
+    providerManifests,
+    selectors: resolvedSelectors
+  });
+  const activePresets = activeWorkflowPresetsForContext({
+    workspace,
+    providerPresets,
+    teamPresets,
+    providerManifests,
+    selectors: resolvedSelectors
+  });
+  const providerPresetSummaries = activePresets.active_provider_presets.map((preset) => summarizeWorkflowPreset(preset, resolvedSelectors));
+  const teamPresetSummaries = activePresets.active_team_presets.map((preset) => summarizeWorkflowPreset(preset, resolvedSelectors));
+
+  const conflictNotes = [];
+  const policyNotes = [];
+  const appliedPresets = [];
+  let resolvedTaskMode = taskModeArtifact?.mode || null;
+  const fieldResolution = {
+    recommended_task_mode: [],
+    preferred_queries: [],
+    artifact_load_order: [],
+    review_policy: [],
+    verification_policy: [],
+    multi_agent_policy: [],
+    handoff_defaults: [],
+    tool_hints: []
+  };
+  for (const preset of [...activePresets.active_provider_presets, ...activePresets.active_team_presets]) {
+    if (preset.recommended_task_mode) {
+      fieldResolution.recommended_task_mode.push(...mergeFieldResolution([preset]));
+      if (CANONICAL_TASK_MODES.has(preset.recommended_task_mode)) {
+        if (resolvedTaskMode !== taskModeArtifact?.mode && resolvedTaskMode !== preset.recommended_task_mode) {
+          conflictNotes.push(`Preset ${preset.id} overrode an earlier task-mode recommendation; highest-precedence canonical task mode wins.`);
+        }
+        resolvedTaskMode = preset.recommended_task_mode;
+      } else {
+        conflictNotes.push(`Preset ${preset.id} requested unsupported task mode ${preset.recommended_task_mode}; ignoring override.`);
+      }
+    }
+    if (preset.write_scope || preset.ownership_boundary) {
+      conflictNotes.push(`Preset ${preset.id} attempted to override protected workflow boundaries; ignoring override.`);
+    }
+    appliedPresets.push({
+      id: preset.id,
+      kind: preset.kind,
+      source_priority: preset.source_priority,
+      provenance: preset.provenance || null
+    });
+  }
+
+  const coreQueries = coreWorkflowQueriesForMode(resolvedTaskMode);
+  const providerQueries = activePresets.active_provider_presets.flatMap((preset) => preset.preferred_queries || []);
+  const teamQueries = activePresets.active_team_presets.flatMap((preset) => preset.preferred_queries || []);
+  const preferredQueries = stableOrderedUnion([
+    ...teamQueries,
+    ...providerQueries,
+    ...coreQueries
+  ]);
+  fieldResolution.preferred_queries = mergeFieldResolution([
+    ...activePresets.active_team_presets.filter((preset) => (preset.preferred_queries || []).length > 0),
+    ...activePresets.active_provider_presets.filter((preset) => (preset.preferred_queries || []).length > 0)
+  ]);
+  const artifactLoadOrder = stableOrderedUnion([
+    ...activePresets.active_team_presets.flatMap((preset) => preset.artifact_load_order || []),
+    ...activePresets.active_provider_presets.flatMap((preset) => preset.artifact_load_order || []),
+    ...(taskModeArtifact?.preferred_context_artifacts || []),
+    ...artifactLoadOrderFromGeneratorTargets(generatorTargets)
+  ]);
+  const recommendedArtifactQueries = recommendedArtifactQueriesFromGeneratorTargets(generatorTargets);
+  fieldResolution.artifact_load_order = mergeFieldResolution([
+    ...activePresets.active_team_presets.filter((preset) => (preset.artifact_load_order || []).length > 0),
+    ...activePresets.active_provider_presets.filter((preset) => (preset.artifact_load_order || []).length > 0)
+  ]);
+
+  const risk = classifyRisk({
+    reviewBoundary,
+    maintainedBoundary,
+    importPlan,
+    verificationTargets: taskModeArtifact?.verification_targets || null,
+    maintainedRisk: importPlan?.maintained_risk || null
+  });
+
+  const requiredVerification = stableOrderedUnion([
+    ...flattenVerificationTargets(taskModeArtifact?.verification_targets || null),
+    ...activePresets.active_provider_presets.flatMap((preset) => preset.verification_policy?.required || []),
+    ...activePresets.active_team_presets.flatMap((preset) => preset.verification_policy?.required || [])
+  ]);
+  const recommendedVerification = stableOrderedUnion([
+    ...activePresets.active_provider_presets.flatMap((preset) => preset.verification_policy?.recommended || []),
+    ...activePresets.active_team_presets.flatMap((preset) => preset.verification_policy?.recommended || [])
+  ]).filter((entry) => !requiredVerification.includes(entry));
+  fieldResolution.verification_policy = mergeFieldResolution([
+    ...activePresets.active_provider_presets.filter((preset) =>
+      (preset.verification_policy?.required || []).length > 0 ||
+      (preset.verification_policy?.recommended || []).length > 0
+    ),
+    ...activePresets.active_team_presets.filter((preset) =>
+      (preset.verification_policy?.required || []).length > 0 ||
+      (preset.verification_policy?.recommended || []).length > 0
+    )
+  ]);
+
+  const reviewBlockers = stableSortedStrings([
+    "no_go",
+    ...(risk.overall_risk === "manual_decision" || risk.overall_risk === "no_go" ? ["manual_decision"] : []),
+    ...activePresets.active_provider_presets.flatMap((preset) => preset.review_policy?.block_on || []),
+    ...activePresets.active_team_presets.flatMap((preset) => preset.review_policy?.block_on || [])
+  ]);
+  const reviewEscalations = stableSortedStrings([
+    ...activePresets.active_provider_presets.flatMap((preset) => preset.review_policy?.escalate_categories || []),
+    ...activePresets.active_team_presets.flatMap((preset) => preset.review_policy?.escalate_categories || [])
+  ]);
+  fieldResolution.review_policy = mergeFieldResolution([
+    ...activePresets.active_provider_presets.filter((preset) =>
+      (preset.review_policy?.block_on || []).length > 0 || (preset.review_policy?.escalate_categories || []).length > 0
+    ),
+    ...activePresets.active_team_presets.filter((preset) =>
+      (preset.review_policy?.block_on || []).length > 0 || (preset.review_policy?.escalate_categories || []).length > 0
+    )
+  ]);
+  if ((presetInventory.provider_manifest_summary?.missing_declared_workflow_preset_count || 0) > 0) {
+    policyNotes.push(`${presetInventory.provider_manifest_summary.missing_declared_workflow_preset_count} manifest-declared workflow preset(s) are not yet imported.`);
+  }
+  if (activePresets.skipped_presets.some((preset) => preset.reason === "inactive")) {
+    policyNotes.push("At least one workflow preset is present but inactive by local policy.");
+  }
+
+  const providerMultiAgentAllowed = activePresets.active_provider_presets.every((preset) => preset.multi_agent_policy?.allowed !== false);
+  const teamMultiAgentAllowed = activePresets.active_team_presets.every((preset) => preset.multi_agent_policy?.allowed !== false);
+  const teamDefaultStrategy = [...activePresets.active_team_presets].reverse().find((preset) => preset.multi_agent_policy?.default_strategy)?.multi_agent_policy?.default_strategy || null;
+  const providerDefaultStrategy = [...activePresets.active_provider_presets].reverse().find((preset) => preset.multi_agent_policy?.default_strategy)?.multi_agent_policy?.default_strategy || null;
+  fieldResolution.multi_agent_policy = mergeFieldResolution([
+    ...activePresets.active_provider_presets.filter((preset) =>
+      preset.multi_agent_policy?.allowed !== undefined || preset.multi_agent_policy?.default_strategy
+    ),
+    ...activePresets.active_team_presets.filter((preset) =>
+      preset.multi_agent_policy?.allowed !== undefined || preset.multi_agent_policy?.default_strategy
+    )
+  ]);
+  fieldResolution.handoff_defaults = mergeFieldResolution([
+    ...activePresets.active_provider_presets.filter((preset) => (preset.handoff_defaults?.required_fields || []).length > 0),
+    ...activePresets.active_team_presets.filter((preset) => (preset.handoff_defaults?.required_fields || []).length > 0)
+  ]);
+  fieldResolution.tool_hints = mergeFieldResolution([
+    ...activePresets.active_provider_presets.filter((preset) => Object.keys(preset.tool_hints || {}).length > 0),
+    ...activePresets.active_team_presets.filter((preset) => Object.keys(preset.tool_hints || {}).length > 0)
+  ]);
+
+  return {
+    type: "resolved_workflow_context_query",
+    resolved_task_mode: resolvedTaskMode,
+    preferred_queries: preferredQueries,
+    artifact_load_order: artifactLoadOrder,
+    recommended_artifact_queries: recommendedArtifactQueries,
+    effective_write_scope: taskModeArtifact?.write_scope || null,
+    effective_review_policy: {
+      block_on: reviewBlockers,
+      escalate_categories: reviewEscalations,
+      overall_risk: risk.overall_risk,
+      risk_reasons: risk.risk_reasons || []
+    },
+    effective_verification_policy: {
+      required: requiredVerification,
+      recommended: recommendedVerification,
+      output_verification_targets: taskModeArtifact?.verification_targets?.output_verification_targets || []
+    },
+    effective_multi_agent_policy: {
+      allowed: providerMultiAgentAllowed && teamMultiAgentAllowed,
+      default_strategy: teamDefaultStrategy || providerDefaultStrategy || null
+    },
+    effective_handoff_defaults: {
+      required_fields: stableOrderedUnion([
+        ...activePresets.active_provider_presets.flatMap((preset) => preset.handoff_defaults?.required_fields || []),
+        ...activePresets.active_team_presets.flatMap((preset) => preset.handoff_defaults?.required_fields || [])
+      ])
+    },
+    tool_hints: composeWorkflowToolHints(activePresets.active_provider_presets, activePresets.active_team_presets),
+    applied_presets: appliedPresets,
+    skipped_presets: activePresets.skipped_presets,
+    field_resolution: fieldResolution,
+    conflict_notes: conflictNotes,
+    policy_notes: policyNotes,
+    workflow_presets: presetInventory
+  };
+}
+
+export function buildSingleAgentPlanPayload({
+  workspace,
+  taskModeArtifact,
+  importPlan = null,
+  resolvedWorkflowContext = null
+}) {
+  const primaryArtifacts = stableOrderedUnion([
+    ...(resolvedWorkflowContext?.artifact_load_order || []),
+    ...(taskModeArtifact?.preferred_context_artifacts || [])
+  ]);
+  const presetGuidanceSummary = buildPresetGuidanceSummary(importPlan?.workflow_presets || null, resolvedWorkflowContext);
+  return {
+    type: "single_agent_plan",
+    workspace: workspace || null,
+    mode: taskModeArtifact?.mode || null,
+    summary: taskModeArtifact?.summary || null,
+    current_focus: currentFocusFromTaskMode(taskModeArtifact),
+    next_action: taskModeArtifact?.next_action || null,
+    write_scope: taskModeArtifact?.write_scope || null,
+    review_boundaries: buildReviewBoundaries(taskModeArtifact, importPlan),
+    proof_targets: taskModeArtifact?.verification_targets || null,
+    operator_loop: buildOperatorLoopSummary({
+      mode: taskModeArtifact?.mode || null,
+      nextAction: taskModeArtifact?.next_action || null,
+      primaryArtifacts,
+      verificationTargets: taskModeArtifact?.verification_targets || null,
+      currentSurface: "single-agent-plan"
+    }),
+    recommended_sequence: buildRecommendedSequence(taskModeArtifact, importPlan),
+    blocking_conditions: buildBlockingConditions(taskModeArtifact, importPlan),
+    primary_artifacts: primaryArtifacts,
+    preset_guidance_summary: presetGuidanceSummary,
+    active_preset_ids: presetGuidanceSummary.active_preset_ids,
+    preset_blockers: presetGuidanceSummary.preset_blockers,
+    recommended_preset_action: presetGuidanceSummary.recommended_preset_action,
+    resolved_workflow_context: resolvedWorkflowContext || null
+  };
+}