snipara-companion 2.2.0 → 2.3.1

package/README.md

@@ -56,6 +56,7 @@ npx -y snipara-companion workflow start --goal "ship auth hardening"
 npx -y snipara-companion workflow phase-start audit
 npx -y snipara-companion lead-plan --task "ship auth hardening" --changed-files src/auth/session.ts --proof "pnpm test auth" --acceptance "auth tests pass"
 npx -y snipara-companion lead-plan --from-plan ./project-health-lead-plan.json --reconcile --changed-files src/auth/session.ts
+npx -y snipara-companion lead-plan --from-plan ./project-health-lead-plan.json --json | jq '.engineeringLeadPlan.executionReceipts'
 npx -y snipara-companion workflow phase-commit audit --summary "mapped auth impact"
 npx -y snipara-companion handoff --summary "auth impact mapped" --next "run auth tests"
 ```

package/dist/index.d.ts

@@ -2159,6 +2159,8 @@ declare const ENGINEERING_LEAD_WORKER_ROLES: readonly ["main_agent", "coding_wor
 declare const ENGINEERING_LEAD_ROUTING_MODES: readonly ["hold", "main_agent_execute", "explicit_handoff_ready", "needs_contract"];
 declare const ENGINEERING_LEAD_WORK_PACKAGE_STATUSES: readonly ["contracting", "ready_for_handoff", "executing", "verifying", "blocked", "closed", "unknown"];
 declare const ENGINEERING_LEAD_SUPERVISION_STATUSES: readonly ["on_track", "needs_review", "needs_replan", "blocked", "cold_start", "unknown"];
+declare const ENGINEERING_LEAD_EXECUTION_RECEIPT_STATUSES: readonly ["pending_handoff", "handoff_ready", "executing", "verification_required", "blocked", "closed", "unknown"];
+declare const ENGINEERING_LEAD_EXECUTION_RECEIPT_STAGES: readonly ["handoff", "claim", "approval", "proof", "outcome", "brain_update"];
 type EngineeringLeadPlanSummary = ProjectIntelligenceEngineeringLeadPlanSummary;
 interface CompanionEngineeringLeadReconciliation {
     status: "on_track" | "needs_review" | "needs_replan" | "blocked";
@@ -3363,6 +3365,7 @@ interface AdaptiveWorkProfile {
     contextBudget: string;
     reasoningDepth: string;
     evidenceRequirements?: string[];
+    preferredProfileStrengths?: string[];
     notes?: string[];
 }
 interface AdaptiveModelRequirements {
@@ -3375,6 +3378,7 @@ interface AdaptiveModelRequirements {
     capabilities: string[];
     forbiddenCapabilities: string[];
     writeScope: string[];
+    structuredOutputRequired?: boolean;
     preferredEndpointTypes?: string[];
     allowedEndpointTypes?: string[];
     catalogLimit?: number;
@@ -3392,13 +3396,13 @@ interface AdaptiveRoutingCard {
     requirements: AdaptiveModelRequirements;
     recommendedWorkerClass: string;
     costEstimate: AdaptiveRoutingCostEstimate;
-    humanApprovalRequired: true;
+    humanApprovalRequired: boolean;
     fallback: "main_agent";
     reasons: string[];
     warnings: string[];
 }
 interface AdaptiveRoutingGatewayStatus {
-    source: "hosted_mcp";
+    source: "hosted_mcp" | "local_orchestrator";
     success: boolean;
     resolutionStatus?: string;
     candidateCount: number;
@@ -3407,14 +3411,32 @@ interface AdaptiveRoutingGatewayStatus {
 }
 interface AdaptiveRoutingRuntimeCatalog {
     version?: string;
+    source?: string;
+    provider?: string;
+    baseUrl?: string;
+    models?: string[];
+    apiPaths?: Record<string, unknown>;
+    workerEndpoints?: Record<string, Record<string, unknown>>;
+    workerProfiles?: Record<string, Record<string, unknown>>;
     candidates: Array<Record<string, unknown>>;
 }
+interface AdaptiveRoutingResolution {
+    status?: string;
+    selected?: Record<string, unknown>;
+    policyDecision?: Record<string, unknown>;
+    evaluatedCount?: number;
+    rejectedCount?: number;
+    fallback?: string;
+    reasons?: string[];
+    warnings?: string[];
+}
 interface AdaptiveWorkRoutingRecommendation {
     workProfile: AdaptiveWorkProfile;
     requirements: AdaptiveModelRequirements;
     routingCard: AdaptiveRoutingCard;
     gateway?: AdaptiveRoutingGatewayStatus;
     runtimeCatalog?: AdaptiveRoutingRuntimeCatalog;
+    resolution?: AdaptiveRoutingResolution;
 }
 interface AdaptiveWorkRoutingOptions {
     query: string;
@@ -3424,6 +3446,8 @@ interface AdaptiveWorkRoutingOptions {
     allowedEndpointTypes?: string[];
     workerRole?: string;
     plannerRetainsReasoning?: boolean;
+    preferredProfileStrengths?: string[];
+    structuredOutputRequired?: boolean;
     catalogLimit?: number;
     dailyBudgetCents?: number;
     monthlyBudgetCents?: number;
@@ -3456,6 +3480,7 @@ interface OrchestratorHandoffArtifact {
         routingCard?: AdaptiveRoutingCard;
         gateway?: AdaptiveRoutingGatewayStatus;
         runtimeCatalog?: AdaptiveRoutingRuntimeCatalog;
+        resolution?: AdaptiveRoutingResolution;
     };
     task: {
         title: string;
@@ -3519,4 +3544,4 @@ declare function buildOrchestratorHandoff(options: OrchestratorHandoffOptions):
 declare function buildAdaptiveWorkRoutingRecommendation(options: AdaptiveWorkRoutingOptions): AdaptiveWorkRoutingRecommendation;
 declare function writeOrchestratorHandoff(options: OrchestratorHandoffOptions): WrittenOrchestratorHandoff;
 
-export { AUTOMATION_MANIFEST_RELATIVE_PATH, AutomationInstallConflictError, AutomationUnsupportedHookBundleError, COLLABORATION_STATE_RELATIVE_PATH, ENGINEERING_LEAD_POSTURES, ENGINEERING_LEAD_ROUTING_MODES, ENGINEERING_LEAD_STATUSES, ENGINEERING_LEAD_SUPERVISION_STATUSES, ENGINEERING_LEAD_WORKER_ROLES, ENGINEERING_LEAD_WORK_PACKAGE_STATUSES, ORCHESTRATOR_HANDOFF_RELATIVE_PATH, TEAM_SYNC_STATE_RELATIVE_PATH, WORKFLOW_PLANS_RELATIVE_DIR, WORKFLOW_STATE_RELATIVE_PATH, agentReadinessAuditCommand, archiveInactiveTeamSyncWork, attachLocalContextPackReceipts, autoArchiveTeamSyncState, buildAdaptiveWorkRoutingRecommendation, buildAgentReadinessAuditReport, buildAgenticHandoffMarkdown, buildAgenticTimeline, buildAgenticWorkStatus, buildAutomationInstallPlan, buildCanonicalEvent, buildCodeHooksInstallPlan, buildCodePromotionResult, buildCodeStatusResult, buildCodeSyncResult, buildCollaborationActor, buildCollaborationGuardActionCards, buildCollaborationHooksInstallPlan, buildCompanionEngineeringLeadPlanReport, buildContextPackStats, buildEvalCaseArtifact, buildGeneratedWorkflowPlanDocument, buildHostedCodeOverlayUploadPayload, buildHostedGuardPayload, buildJournalCheckpointEntry, buildLocalCallersResult, buildLocalCodeOverlay, buildLocalContextPackReceipt, buildLocalContextPackReceipts, buildLocalImpactResult, buildLocalImportsResult, buildLocalNeighborsResult, buildLocalShortestPathResult, buildMemoryAudit, buildOnboardFolderManifest, buildOrchestratorHandoff, buildProjectIntelligenceBrief, buildProjectIntelligenceRun, buildProjectJudgmentCard, buildSessionBootstrapQuality, buildSyncDocumentsDryRun, buildTeamSyncHandoffRecord, buildTeamSyncStartWorkRecord, buildTeamSyncSummary, buildToolCallPayload, buildToolResultPayload, buildVerificationPlan, buildWorkflowImpactGate, buildWorkflowPhaseCommitSummary, buildWorkflowPlanScaffold, categoryFromGuardTag, classifyToolResult, cleanContextPacks, collaborationIdeStatusCommand, collectAgentReadinessLocalSignals, collectSyncDocuments, collectSyncDocumentsInput, compactHostedGuardResources, completeTeamSyncStateFromEvidence, completeTeamSyncWorkFromEvidence, contextPackCleanCommand, contextPackPackCommand, contextPackRetrieveCommand, contextPackStatsCommand, createClient, createEmptyCollaborationState, createEmptyTeamSyncState, createLocalQueryCache, deriveLocalCollaborationResourcesFromFiles, detectReleaseSurfacesFromFiles, detectRuntimeEnvironment, evalExportCommand, evalRunCommand, evaluateProjectPolicyGates, extractCommandFromToolInput, extractFilesFromToolInput, formatAgentReadinessAuditReport, formatCompanionEngineeringLeadPlanReport, formatOrchestratorRecommendationReason, formatPolicyGateDecision, formatProjectJudgmentCard, formatStuckGuardDecision, getAutomationManifestPath, getAutomationStatus, getCollaborationStatePath, getConfigPath, getContextPackStoragePaths, getLocalCodeOverlayCachePath, getLocalCodePromotionStatePath, getOrchestratorRecommendation, getPlanStepDisplayTitle, getStagedFiles, getStuckGuardInjection, getTeamSyncStatePath, ingestReferences, installAutomationBundle, leadPlanCommand, listProjectsForApiKey, loadAutomationManifest, loadCollaborationState, loadConfig, loadTeamSyncState, memoryAuditCommand, memoryCleanCandidatesCommand, memoryCompactCommand, memoryHealthCommand, memoryLocalCommand, normalizeCollaborationFiles, normalizeGuardTag, normalizeWorkflowPlanInput, packContext, parseCollaborationResources, projectIntelligenceBriefCommand, projectIntelligenceRunCommand, readLocalCodeOverlayCache, readLocalCodePromotionState, referencesIngestCommand, referencesScanCommand, resolveContextPackRecord, resolveFullWorkflowTokenBudget, resolveQueryFromToolInput, retrieveContextPack, runMemoryGuardCheck, saveCollaborationState, saveConfig, saveTeamSyncState, scanReferences, shouldSuggestOrchestratorForWorkflow, shouldSuggestRuntimeForWorkflow, summarizeLocalCodeOverlay, teamSyncSweepCommand, validatePlanResult, verifyCommand, writeLocalCodeOverlayCache, writeLocalCodePromotionState, writeOrchestratorHandoff };
+export { AUTOMATION_MANIFEST_RELATIVE_PATH, AutomationInstallConflictError, AutomationUnsupportedHookBundleError, COLLABORATION_STATE_RELATIVE_PATH, ENGINEERING_LEAD_EXECUTION_RECEIPT_STAGES, ENGINEERING_LEAD_EXECUTION_RECEIPT_STATUSES, ENGINEERING_LEAD_POSTURES, ENGINEERING_LEAD_ROUTING_MODES, ENGINEERING_LEAD_STATUSES, ENGINEERING_LEAD_SUPERVISION_STATUSES, ENGINEERING_LEAD_WORKER_ROLES, ENGINEERING_LEAD_WORK_PACKAGE_STATUSES, ORCHESTRATOR_HANDOFF_RELATIVE_PATH, TEAM_SYNC_STATE_RELATIVE_PATH, WORKFLOW_PLANS_RELATIVE_DIR, WORKFLOW_STATE_RELATIVE_PATH, agentReadinessAuditCommand, archiveInactiveTeamSyncWork, attachLocalContextPackReceipts, autoArchiveTeamSyncState, buildAdaptiveWorkRoutingRecommendation, buildAgentReadinessAuditReport, buildAgenticHandoffMarkdown, buildAgenticTimeline, buildAgenticWorkStatus, buildAutomationInstallPlan, buildCanonicalEvent, buildCodeHooksInstallPlan, buildCodePromotionResult, buildCodeStatusResult, buildCodeSyncResult, buildCollaborationActor, buildCollaborationGuardActionCards, buildCollaborationHooksInstallPlan, buildCompanionEngineeringLeadPlanReport, buildContextPackStats, buildEvalCaseArtifact, buildGeneratedWorkflowPlanDocument, buildHostedCodeOverlayUploadPayload, buildHostedGuardPayload, buildJournalCheckpointEntry, buildLocalCallersResult, buildLocalCodeOverlay, buildLocalContextPackReceipt, buildLocalContextPackReceipts, buildLocalImpactResult, buildLocalImportsResult, buildLocalNeighborsResult, buildLocalShortestPathResult, buildMemoryAudit, buildOnboardFolderManifest, buildOrchestratorHandoff, buildProjectIntelligenceBrief, buildProjectIntelligenceRun, buildProjectJudgmentCard, buildSessionBootstrapQuality, buildSyncDocumentsDryRun, buildTeamSyncHandoffRecord, buildTeamSyncStartWorkRecord, buildTeamSyncSummary, buildToolCallPayload, buildToolResultPayload, buildVerificationPlan, buildWorkflowImpactGate, buildWorkflowPhaseCommitSummary, buildWorkflowPlanScaffold, categoryFromGuardTag, classifyToolResult, cleanContextPacks, collaborationIdeStatusCommand, collectAgentReadinessLocalSignals, collectSyncDocuments, collectSyncDocumentsInput, compactHostedGuardResources, completeTeamSyncStateFromEvidence, completeTeamSyncWorkFromEvidence, contextPackCleanCommand, contextPackPackCommand, contextPackRetrieveCommand, contextPackStatsCommand, createClient, createEmptyCollaborationState, createEmptyTeamSyncState, createLocalQueryCache, deriveLocalCollaborationResourcesFromFiles, detectReleaseSurfacesFromFiles, detectRuntimeEnvironment, evalExportCommand, evalRunCommand, evaluateProjectPolicyGates, extractCommandFromToolInput, extractFilesFromToolInput, formatAgentReadinessAuditReport, formatCompanionEngineeringLeadPlanReport, formatOrchestratorRecommendationReason, formatPolicyGateDecision, formatProjectJudgmentCard, formatStuckGuardDecision, getAutomationManifestPath, getAutomationStatus, getCollaborationStatePath, getConfigPath, getContextPackStoragePaths, getLocalCodeOverlayCachePath, getLocalCodePromotionStatePath, getOrchestratorRecommendation, getPlanStepDisplayTitle, getStagedFiles, getStuckGuardInjection, getTeamSyncStatePath, ingestReferences, installAutomationBundle, leadPlanCommand, listProjectsForApiKey, loadAutomationManifest, loadCollaborationState, loadConfig, loadTeamSyncState, memoryAuditCommand, memoryCleanCandidatesCommand, memoryCompactCommand, memoryHealthCommand, memoryLocalCommand, normalizeCollaborationFiles, normalizeGuardTag, normalizeWorkflowPlanInput, packContext, parseCollaborationResources, projectIntelligenceBriefCommand, projectIntelligenceRunCommand, readLocalCodeOverlayCache, readLocalCodePromotionState, referencesIngestCommand, referencesScanCommand, resolveContextPackRecord, resolveFullWorkflowTokenBudget, resolveQueryFromToolInput, retrieveContextPack, runMemoryGuardCheck, saveCollaborationState, saveConfig, saveTeamSyncState, scanReferences, shouldSuggestOrchestratorForWorkflow, shouldSuggestRuntimeForWorkflow, summarizeLocalCodeOverlay, teamSyncSweepCommand, validatePlanResult, verifyCommand, writeLocalCodeOverlayCache, writeLocalCodePromotionState, writeOrchestratorHandoff };

package/dist/index.js

@@ -35,6 +35,8 @@ __export(index_exports, {
   AutomationInstallConflictError: () => AutomationInstallConflictError,
   AutomationUnsupportedHookBundleError: () => AutomationUnsupportedHookBundleError,
   COLLABORATION_STATE_RELATIVE_PATH: () => COLLABORATION_STATE_RELATIVE_PATH,
+  ENGINEERING_LEAD_EXECUTION_RECEIPT_STAGES: () => ENGINEERING_LEAD_EXECUTION_RECEIPT_STAGES,
+  ENGINEERING_LEAD_EXECUTION_RECEIPT_STATUSES: () => ENGINEERING_LEAD_EXECUTION_RECEIPT_STATUSES,
   ENGINEERING_LEAD_POSTURES: () => ENGINEERING_LEAD_POSTURES,
   ENGINEERING_LEAD_ROUTING_MODES: () => ENGINEERING_LEAD_ROUTING_MODES,
   ENGINEERING_LEAD_STATUSES: () => ENGINEERING_LEAD_STATUSES,
@@ -10499,6 +10501,23 @@ var PROJECT_INTELLIGENCE_ENGINEERING_LEAD_SUPERVISION_STATUSES = [
   "cold_start",
   "unknown"
 ];
+var PROJECT_INTELLIGENCE_ENGINEERING_LEAD_EXECUTION_RECEIPT_STATUSES = [
+  "pending_handoff",
+  "handoff_ready",
+  "executing",
+  "verification_required",
+  "blocked",
+  "closed",
+  "unknown"
+];
+var PROJECT_INTELLIGENCE_ENGINEERING_LEAD_EXECUTION_RECEIPT_STAGES = [
+  "handoff",
+  "claim",
+  "approval",
+  "proof",
+  "outcome",
+  "brain_update"
+];
 
 // src/commands/lead-plan.ts
 var ENGINEERING_LEAD_STATUSES = PROJECT_HEALTH_COCKPIT_STATUSES;
@@ -10507,6 +10526,8 @@ var ENGINEERING_LEAD_WORKER_ROLES = PROJECT_INTELLIGENCE_ENGINEERING_LEAD_WORKER
 var ENGINEERING_LEAD_ROUTING_MODES = PROJECT_INTELLIGENCE_ENGINEERING_LEAD_ROUTING_MODES;
 var ENGINEERING_LEAD_WORK_PACKAGE_STATUSES = PROJECT_INTELLIGENCE_ENGINEERING_LEAD_WORK_PACKAGE_STATUSES;
 var ENGINEERING_LEAD_SUPERVISION_STATUSES = PROJECT_INTELLIGENCE_ENGINEERING_LEAD_SUPERVISION_STATUSES;
+var ENGINEERING_LEAD_EXECUTION_RECEIPT_STATUSES = PROJECT_INTELLIGENCE_ENGINEERING_LEAD_EXECUTION_RECEIPT_STATUSES;
+var ENGINEERING_LEAD_EXECUTION_RECEIPT_STAGES = PROJECT_INTELLIGENCE_ENGINEERING_LEAD_EXECUTION_RECEIPT_STAGES;
 var TARGET_LABELS = {
   codex: "Codex",
   "claude-code": "Claude Code",
@@ -10851,6 +10872,133 @@ function buildLocalSupervision(input) {
     ]
   };
 }
+function executionReceiptRequiredStagesForRecommendation(recommendation) {
+  const stages = /* @__PURE__ */ new Set(["handoff", "proof", "outcome"]);
+  if (recommendation && recommendation.role !== "main_agent") {
+    stages.add("claim");
+  }
+  if (recommendation?.contract.approvalRequired) {
+    stages.add("approval");
+  }
+  if ((recommendation?.brainUpdateCandidates.length ?? 0) > 0) {
+    stages.add("brain_update");
+  }
+  return ENGINEERING_LEAD_EXECUTION_RECEIPT_STAGES.filter((stage) => stages.has(stage));
+}
+function missingRequirementsForExecutionReceipt(input) {
+  const completed = new Set(input.completedStages);
+  const missing = /* @__PURE__ */ new Set();
+  if (!input.workPackage.owner) missing.add("owner");
+  if (input.workPackage.writeScope.length === 0) missing.add("write_scope");
+  if (input.workPackage.acceptanceCriteria.length === 0) missing.add("acceptance_criteria");
+  if (input.workPackage.proofRequired.length === 0) missing.add("proof_gate");
+  if (input.requiredStages.includes("handoff") && !completed.has("handoff")) {
+    missing.add("handoff_receipt");
+  }
+  if (input.requiredStages.includes("claim") && !completed.has("claim")) {
+    missing.add("claim_id");
+  }
+  if (input.requiredStages.includes("approval") && !completed.has("approval")) {
+    missing.add("approval_receipt");
+  }
+  if (input.requiredStages.includes("proof") && !completed.has("proof")) {
+    missing.add("proof_receipt");
+  }
+  if (input.requiredStages.includes("outcome") && !completed.has("outcome")) {
+    missing.add("outcome_receipt");
+  }
+  if (input.brainUpdateCandidates.length > 0 && input.requiredStages.includes("brain_update") && !completed.has("brain_update")) {
+    missing.add("brain_update_receipt");
+  }
+  return Array.from(missing).sort();
+}
+function executionReceiptStatusFromWorkPackage(input) {
+  if (input.workPackage.status === "blocked") return "blocked";
+  if (input.workPackage.status === "closed" && input.requiredStages.every((stage) => input.completedStages.includes(stage))) {
+    return "closed";
+  }
+  if (input.workPackage.status === "executing") return "executing";
+  if (input.workPackage.status === "verifying") return "verification_required";
+  if (input.workPackage.status === "ready_for_handoff") return "handoff_ready";
+  if (input.missingRequirements.length > 0) return "pending_handoff";
+  return "handoff_ready";
+}
+function executionReceiptNextAction(input) {
+  if (input.status === "blocked") {
+    return "Resolve the blocking receipt or proof issue before delegated execution.";
+  }
+  if (input.missingRequirements.includes("handoff_receipt")) {
+    return "Create or attach the handoff receipt before treating this package as delegated.";
+  }
+  if (input.missingRequirements.includes("approval_receipt")) {
+    return "Capture approval before delegated execution can proceed.";
+  }
+  if (input.missingRequirements.includes("proof_receipt")) {
+    return "Attach proof receipts before closure.";
+  }
+  if (input.missingRequirements.includes("outcome_receipt")) {
+    return "Attach an outcome or closure receipt before Brain promotion.";
+  }
+  if (input.missingRequirements.includes("brain_update_receipt")) {
+    return "Record the reviewed Project Brain update receipt.";
+  }
+  if (input.status === "closed") {
+    return "Keep the closed receipt linked for future routing calibration.";
+  }
+  if (input.status === "executing") {
+    return "Monitor liveness and collect proof, outcome, and Brain-update receipts.";
+  }
+  if (input.status === "verification_required") {
+    return "Verify proof and outcome receipts before closure.";
+  }
+  return "Issue the explicit handoff package and collect the required receipts.";
+}
+function buildExpectedExecutionReceipts(input) {
+  const recommendationsByWorkPackageId = new Map(
+    input.workerRecommendations.filter((recommendation) => recommendation.workPackageId).map((recommendation) => [recommendation.workPackageId, recommendation])
+  );
+  return input.workPackages.map((workPackage) => {
+    const recommendation = recommendationsByWorkPackageId.get(workPackage.id);
+    const requiredStages = executionReceiptRequiredStagesForRecommendation(recommendation);
+    const completedStages = [];
+    const brainUpdateCandidates2 = recommendation?.brainUpdateCandidates ?? [];
+    const missingRequirements = missingRequirementsForExecutionReceipt({
+      workPackage,
+      requiredStages,
+      completedStages,
+      brainUpdateCandidates: brainUpdateCandidates2
+    });
+    const status = executionReceiptStatusFromWorkPackage({
+      workPackage,
+      requiredStages,
+      completedStages,
+      missingRequirements
+    });
+    return {
+      id: `engineering-lead-receipt:${workPackage.id}`,
+      workPackageId: workPackage.id,
+      workPackageTitle: workPackage.title,
+      status,
+      requiredStages,
+      completedStages,
+      handoffReceiptId: null,
+      claimId: null,
+      htaskId: null,
+      approvalReceiptId: null,
+      proofReceiptIds: [],
+      outcomeReceiptId: null,
+      brainUpdateReceiptId: null,
+      proofRequired: workPackage.proofRequired,
+      proofExecuted: [],
+      missingRequirements,
+      nextAction: executionReceiptNextAction({ status, missingRequirements }),
+      replanTriggers: workPackage.replanTriggers,
+      brainUpdateCandidates: brainUpdateCandidates2,
+      evidence: workPackage.evidence,
+      reasonCodes: [`engineering_lead_execution_receipt_${status}`, ...workPackage.reasonCodes]
+    };
+  });
+}
 function buildLocalEngineeringLeadPlan(input) {
   const score = computeScore(input);
   const posture = postureForLocalPlan({ ...input, score });
@@ -10919,6 +11067,10 @@ function buildLocalEngineeringLeadPlan(input) {
     workPackages,
     localSignals: input.localSignals
   });
+  const executionReceipts = buildExpectedExecutionReceipts({
+    workPackages,
+    workerRecommendations: [worker]
+  });
   return {
     version: PROJECT_INTELLIGENCE_ENGINEERING_LEAD_PLAN_VERSION,
     contractVersion: PROJECT_INTELLIGENCE_ENGINEERING_LEAD_CONTRACT_VERSION,
@@ -10932,6 +11084,7 @@ function buildLocalEngineeringLeadPlan(input) {
     failClosedFallback: "main_agent",
     workPackages,
     supervision,
+    executionReceipts,
     workerRecommendations: [worker],
     proofGates: input.proofGates,
     brainUpdateActions: brainCandidates,
@@ -11048,6 +11201,93 @@ function normalizeWorkPackage(value, index) {
     reasonCodes
   };
 }
+function normalizeReceiptStages(field, value) {
+  if (!Array.isArray(value)) {
+    return { stages: [], reasonCodes: [] };
+  }
+  const stages = [];
+  const reasonCodes = /* @__PURE__ */ new Set();
+  for (const item of value) {
+    const stage = cockpitEnumValue(
+      field,
+      ENGINEERING_LEAD_EXECUTION_RECEIPT_STAGES,
+      item,
+      "handoff"
+    );
+    if (stage.droppedReasonCode) {
+      reasonCodes.add(stage.droppedReasonCode);
+      continue;
+    }
+    if (!stages.includes(stage.value)) {
+      stages.push(stage.value);
+    }
+  }
+  return { stages, reasonCodes: Array.from(reasonCodes) };
+}
+function normalizeExecutionReceipt(value, index, workPackages, workerRecommendations) {
+  const workPackageId = stringValue3(value.workPackageId) ?? workPackages[index]?.id ?? `work-package:${index + 1}`;
+  const workPackage = workPackages.find((candidate) => candidate.id === workPackageId);
+  const recommendation = workerRecommendations.find(
+    (candidate) => candidate.workPackageId === workPackageId
+  );
+  const fallbackRequiredStages = executionReceiptRequiredStagesForRecommendation(recommendation);
+  const requiredStages = normalizeReceiptStages("execution_receipt_stage", value.requiredStages);
+  const completedStages = normalizeReceiptStages("execution_receipt_stage", value.completedStages);
+  const normalizedRequiredStages = requiredStages.stages.length > 0 ? requiredStages.stages : fallbackRequiredStages;
+  const normalizedCompletedStages = completedStages.stages.filter(
+    (stage) => normalizedRequiredStages.includes(stage)
+  );
+  const brainUpdateCandidates2 = stringList(value.brainUpdateCandidates).length > 0 ? stringList(value.brainUpdateCandidates) : recommendation?.brainUpdateCandidates ?? [];
+  const derivedMissing = workPackage && missingRequirementsForExecutionReceipt({
+    workPackage,
+    requiredStages: normalizedRequiredStages,
+    completedStages: normalizedCompletedStages,
+    brainUpdateCandidates: brainUpdateCandidates2
+  });
+  const missingRequirements = stringList(value.missingRequirements).length > 0 ? stringList(value.missingRequirements) : derivedMissing ?? [];
+  const fallbackStatus = workPackage ? executionReceiptStatusFromWorkPackage({
+    workPackage,
+    requiredStages: normalizedRequiredStages,
+    completedStages: normalizedCompletedStages,
+    missingRequirements
+  }) : "pending_handoff";
+  const status = cockpitEnumValue(
+    "execution_receipt_status",
+    ENGINEERING_LEAD_EXECUTION_RECEIPT_STATUSES,
+    value.status,
+    fallbackStatus
+  );
+  return {
+    id: stringValue3(value.id) ?? `engineering-lead-receipt:${workPackageId}`,
+    workPackageId,
+    workPackageTitle: stringValue3(value.workPackageTitle) ?? workPackage?.title ?? `Imported work package ${index + 1}`,
+    status: status.value,
+    requiredStages: normalizedRequiredStages,
+    completedStages: normalizedCompletedStages,
+    handoffReceiptId: stringValue3(value.handoffReceiptId) ?? null,
+    claimId: stringValue3(value.claimId) ?? null,
+    htaskId: stringValue3(value.htaskId) ?? null,
+    approvalReceiptId: stringValue3(value.approvalReceiptId) ?? null,
+    proofReceiptIds: stringList(value.proofReceiptIds),
+    outcomeReceiptId: stringValue3(value.outcomeReceiptId) ?? null,
+    brainUpdateReceiptId: stringValue3(value.brainUpdateReceiptId) ?? null,
+    proofRequired: stringList(value.proofRequired).length > 0 ? stringList(value.proofRequired) : workPackage?.proofRequired ?? [],
+    proofExecuted: stringList(value.proofExecuted),
+    missingRequirements,
+    nextAction: stringValue3(value.nextAction) ?? executionReceiptNextAction({ status: status.value, missingRequirements }),
+    replanTriggers: stringList(value.replanTriggers).length > 0 ? stringList(value.replanTriggers) : workPackage?.replanTriggers ?? [],
+    brainUpdateCandidates: brainUpdateCandidates2,
+    evidence: normalizeEvidence(value.evidence).length > 0 ? normalizeEvidence(value.evidence) : workPackage?.evidence ?? [],
+    reasonCodes: [
+      .../* @__PURE__ */ new Set([
+        ...stringList(value.reasonCodes),
+        ...compactReasonCodes([status.droppedReasonCode]),
+        ...requiredStages.reasonCodes,
+        ...completedStages.reasonCodes
+      ])
+    ]
+  };
+}
 function summarizeSupervisionFromWorkPackages(workPackages) {
   const blockedWorkPackages = workPackages.filter(
     (workPackage) => workPackage.status === "blocked"
@@ -11150,6 +11390,10 @@ function normalizeCockpitPlan(cockpit) {
   );
   const workPackages = recordList2(rawPlan.workPackages).map(normalizeWorkPackage);
   const supervision = normalizeSupervision(rawPlan.supervision, workPackages);
+  const rawExecutionReceipts = recordList2(rawPlan.executionReceipts);
+  const executionReceipts = rawExecutionReceipts.length > 0 ? rawExecutionReceipts.map(
+    (receipt, index) => normalizeExecutionReceipt(receipt, index, workPackages, workerRecommendations)
+  ) : buildExpectedExecutionReceipts({ workPackages, workerRecommendations });
   const posture = cockpitEnumValue(
     "posture",
     ENGINEERING_LEAD_POSTURES,
@@ -11171,6 +11415,9 @@ function normalizeCockpitPlan(cockpit) {
   const supervisionDroppedReasonCodes = supervision.reasonCodes.filter(
     (code2) => code2.startsWith("companion_dropped_unknown_")
   );
+  const executionReceiptDroppedReasonCodes = executionReceipts.flatMap(
+    (receipt) => receipt.reasonCodes.filter((code2) => code2.startsWith("companion_dropped_unknown_"))
+  );
   return {
     version: PROJECT_INTELLIGENCE_ENGINEERING_LEAD_PLAN_VERSION,
     contractVersion: PROJECT_INTELLIGENCE_ENGINEERING_LEAD_CONTRACT_VERSION,
@@ -11184,6 +11431,7 @@ function normalizeCockpitPlan(cockpit) {
     failClosedFallback: "main_agent",
     workPackages,
     supervision,
+    executionReceipts,
     workerRecommendations,
     proofGates: stringList(rawPlan.proofGates),
     brainUpdateActions: stringList(rawPlan.brainUpdateActions),
@@ -11206,7 +11454,8 @@ function normalizeCockpitPlan(cockpit) {
         ...stringList(rawPlan.reasonCodes),
         ...workerDroppedReasonCodes,
         ...workPackageDroppedReasonCodes,
-        ...supervisionDroppedReasonCodes
+        ...supervisionDroppedReasonCodes,
+        ...executionReceiptDroppedReasonCodes
       ])
     ]
   };
@@ -11223,6 +11472,7 @@ function reconcileEngineeringLeadPlan(input) {
   const reasonCodes = /* @__PURE__ */ new Set(["companion_lead_plan_reconciled"]);
   const plannedScope = scopeSetForPlan(input.plan);
   const outOfScopeFiles = input.changedFiles.filter((file) => !plannedScope.has(file));
+  const executionReceipts = input.plan.executionReceipts ?? [];
   if (input.plan.workPackages.length === 0) {
     changedSignals.add("no_imported_work_packages");
     recommendedActions.add("Create or import bounded work packages before delegation.");
@@ -11270,9 +11520,25 @@ function reconcileEngineeringLeadPlan(input) {
   for (const trigger of input.plan.supervision.replanTriggers) {
     recommendedActions.add(trigger);
   }
-  const blocked = input.plan.supervision.status === "blocked" || input.plan.workPackages.some((workPackage) => workPackage.status === "blocked");
+  for (const receipt of executionReceipts) {
+    if (receipt.status === "blocked") {
+      changedSignals.add(`blocked_execution_receipt:${receipt.workPackageId}`);
+      recommendedActions.add(receipt.nextAction);
+      reasonCodes.add("companion_reconcile_execution_receipt_blocked");
+    }
+    if (receipt.missingRequirements.length > 0) {
+      changedSignals.add(
+        `execution_receipt_missing:${receipt.workPackageId}:${receipt.missingRequirements.join(",")}`
+      );
+      recommendedActions.add(
+        `Attach missing execution receipt requirement(s) for ${receipt.workPackageTitle}: ${receipt.missingRequirements.join(", ")}.`
+      );
+      reasonCodes.add("companion_reconcile_execution_receipt_missing_requirements");
+    }
+  }
+  const blocked = input.plan.supervision.status === "blocked" || input.plan.workPackages.some((workPackage) => workPackage.status === "blocked") || executionReceipts.some((receipt) => receipt.status === "blocked");
   const replanRequired = blocked || input.plan.supervision.replanRequired || outOfScopeFiles.length > 0 || !input.localSignals.workflow.present || input.localSignals.workflow.status !== "active";
-  const reviewRequired = replanRequired || input.plan.supervision.reviewRequired || !input.localSignals.teamSync.present || input.declaredRisks.length > 0;
+  const reviewRequired = replanRequired || input.plan.supervision.reviewRequired || executionReceipts.some((receipt) => receipt.missingRequirements.length > 0) || !input.localSignals.teamSync.present || input.declaredRisks.length > 0;
   const status = blocked ? "blocked" : replanRequired ? "needs_replan" : reviewRequired ? "needs_review" : "on_track";
   return {
     status,
@@ -11390,6 +11656,7 @@ function formatList2(values, empty = "none") {
 }
 function formatCompanionEngineeringLeadPlanReport(report) {
   const plan = report.engineeringLeadPlan;
+  const executionReceipts = plan.executionReceipts ?? [];
   const lines = [];
   lines.push("Companion Engineering Lead Plan");
   lines.push(`Generated: ${report.generatedAt}`);
@@ -11437,6 +11704,25 @@ function formatCompanionEngineeringLeadPlanReport(report) {
     }
   }
   lines.push("");
+  lines.push("Execution Receipts");
+  if (executionReceipts.length === 0) {
+    lines.push("- none");
+  } else {
+    for (const receipt of executionReceipts) {
+      lines.push(`- [${receipt.status}] ${receipt.workPackageTitle}`);
+      lines.push(`  package: ${receipt.workPackageId}`);
+      lines.push(`  required stages: ${formatList2(receipt.requiredStages)}`);
+      lines.push(`  completed stages: ${formatList2(receipt.completedStages)}`);
+      lines.push(`  handoff receipt: ${receipt.handoffReceiptId ?? "missing"}`);
+      lines.push(`  claim: ${receipt.claimId ?? "missing"}`);
+      lines.push(`  approval receipt: ${receipt.approvalReceiptId ?? "missing"}`);
+      lines.push(`  outcome receipt: ${receipt.outcomeReceiptId ?? "missing"}`);
+      lines.push(`  brain update receipt: ${receipt.brainUpdateReceiptId ?? "missing"}`);
+      lines.push(`  missing: ${formatList2(receipt.missingRequirements)}`);
+      lines.push(`  next: ${receipt.nextAction}`);
+    }
+  }
+  lines.push("");
   lines.push("Worker Recommendations");
   for (const worker of plan.workerRecommendations) {
     lines.push(`- [${worker.status}] ${worker.label} (${worker.role}, ${worker.routingMode})`);
@@ -14341,7 +14627,8 @@ function buildOrchestratorHandoff(options) {
         requirements: options.adaptiveRouting.requirements,
         routingCard: options.adaptiveRouting.routingCard,
         ...options.adaptiveRouting.gateway ? { gateway: options.adaptiveRouting.gateway } : {},
-        ...options.adaptiveRouting.runtimeCatalog ? { runtimeCatalog: options.adaptiveRouting.runtimeCatalog } : {}
+        ...options.adaptiveRouting.runtimeCatalog ? { runtimeCatalog: options.adaptiveRouting.runtimeCatalog } : {},
+        ...options.adaptiveRouting.resolution ? { resolution: options.adaptiveRouting.resolution } : {}
       } : {}
     },
     task: {
@@ -14394,8 +14681,12 @@ function buildAdaptiveWorkRoutingRecommendation(options) {
   const reasoningDepth = inferAdaptiveReasoningDepth(risk, taskType);
   const workerRole = options.workerRole ?? inferAdaptiveWorkerRole(taskType);
   const plannerRetainsReasoning = options.plannerRetainsReasoning ?? preferredEndpointTypes.includes("local");
+  const preferredProfileStrengths = normalizeProfileStrengths(
+    options.preferredProfileStrengths ?? inferAdaptivePreferredProfileStrengths(taskType, options.query, changedFiles, workerRole)
+  );
   const capabilities = inferAdaptiveCapabilities(taskType, workerRole);
   const forbiddenCapabilities = risk === "high" ? ["secrets", "prod_write"] : ["secrets"];
+  const structuredOutputRequired = options.structuredOutputRequired ?? inferAdaptiveStructuredOutputRequirement(taskType, options.query, changedFiles, workerRole);
   const workProfile = compactObject2({
     taskType,
     risk,
@@ -14403,6 +14694,7 @@ function buildAdaptiveWorkRoutingRecommendation(options) {
     contextBudget,
     reasoningDepth,
     evidenceRequirements: inferAdaptiveEvidenceRequirements(options.query, risk),
+    preferredProfileStrengths,
     notes: [
       "Generated by snipara-companion as recommendation-only routing metadata.",
       "snipara-orchestrator must resolve the worker against the runtime catalog before execution."
@@ -14418,6 +14710,7 @@ function buildAdaptiveWorkRoutingRecommendation(options) {
     capabilities,
     forbiddenCapabilities,
     writeScope: changedFiles,
+    structuredOutputRequired: structuredOutputRequired ? true : void 0,
     preferredEndpointTypes,
     allowedEndpointTypes,
     catalogLimit: options.catalogLimit,
@@ -14534,6 +14827,54 @@ function inferAdaptiveCapabilities(taskType, workerRole) {
   }
   return ["execution"];
 }
+function inferAdaptivePreferredProfileStrengths(taskType, query, changedFiles, workerRole) {
+  const normalizedQuery = query.toLowerCase();
+  const strengths = /* @__PURE__ */ new Set();
+  const codeLikeScope = workerRole === "coding" || workerRole === "testing" || taskType === "coding" || taskType === "critical_code" || changedFiles.some((file) => /\.(ts|tsx|js|jsx|py|go|rs|java|kt|swift|rb|php)$/i.test(file));
+  if (codeLikeScope) {
+    strengths.add("code");
+  }
+  if (/\b(structured|json|schema|signature|serialization|contract|patch|file operations?)\b/i.test(
+    normalizedQuery
+  ) || codeLikeScope) {
+    strengths.add("structured_output");
+  }
+  if (/\b(refactor|rewrite|rename|sweep|cross-file|multi-file)\b/i.test(normalizedQuery) || changedFiles.length > 8) {
+    strengths.add("refactor");
+  }
+  if (/\b(repo|repository|codebase|explore|scan|survey|context|continuity|architecture)\b/i.test(
+    normalizedQuery
+  ) || changedFiles.length > 5) {
+    strengths.add("long_context");
+    strengths.add("repo_scan");
+  }
+  if (/\b(agent|workflow|checkpoint|handoff|delegate|orchestrat)\b/i.test(normalizedQuery)) {
+    strengths.add("agentic_exploration");
+  }
+  if (taskType === "release" || taskType === "critical_code" || workerRole === "validation") {
+    strengths.add("execution_safe");
+  }
+  return Array.from(strengths).sort();
+}
+function inferAdaptiveStructuredOutputRequirement(taskType, query, changedFiles, workerRole) {
+  if (workerRole === "documentation" && taskType === "documentation") {
+    return false;
+  }
+  if (workerRole === "coding" || workerRole === "testing") {
+    return true;
+  }
+  if (taskType === "coding" || taskType === "critical_code" || taskType === "tests") {
+    return true;
+  }
+  if (/\b(structured|json|schema|signature|serialization|contract|patch|file operations?)\b/i.test(
+    query
+  )) {
+    return true;
+  }
+  return changedFiles.some(
+    (file) => /\.(ts|tsx|js|jsx|py|go|rs|java|kt|swift|rb|php)$/i.test(file)
+  );
+}
 function inferAdaptiveEvidenceRequirements(query, risk) {
   const evidence = /* @__PURE__ */ new Set();
   if (/\b(test|tests|pytest|unit|integration|e2e|smoke|verify|verification)\b/i.test(query)) {
@@ -14547,6 +14888,13 @@ function inferAdaptiveEvidenceRequirements(query, risk) {
   }
   return Array.from(evidence).sort();
 }
+function normalizeProfileStrengths(values) {
+  return Array.from(
+    new Set(
+      (values ?? []).map((value) => stringValue8(value)?.toLowerCase()).filter((value) => Boolean(value))
+    )
+  ).sort();
+}
 function normalizeEndpointTypes(values) {
   return Array.from(
     new Set(
@@ -17950,6 +18298,7 @@ var FINAL_COMMIT_RETRY_TIMEOUT_MS = 45e3;
 var FINAL_COMMIT_SUMMARY_MAX_CHARS = 1200;
 var FINAL_COMMIT_RETRY_SUMMARY_MAX_CHARS = 600;
 var DEFAULT_ADAPTIVE_ROUTING_CATALOG_LIMIT = 20;
+var DEFAULT_LOCAL_ORCHESTRATOR_TIMEOUT_MS = 8e3;
 var ADAPTIVE_ROUTING_POLICY_RELATIVE_PATH = path21.join(".snipara", "adaptive-routing.json");
 var SHARED_CONTEXT_INTENT_PATTERN = /\b(standard|standards|convention|conventions|guideline|guidelines|best practice|best practices|policy|policies|compliance|compliant|security rules|team rules|style guide|playbook|checklist)\b/i;
 var DOCUMENT_SYNC_FORMATS = {
@@ -20491,10 +20840,21 @@ function printAdaptiveRoutingRecommendation(routing) {
   }
   if (routing.gateway) {
     printKeyValue(
-      "Hosted catalog:",
+      routing.gateway.source === "local_orchestrator" ? "Local route:" : "Hosted catalog:",
       routing.gateway.success ? `${routing.gateway.candidateCount} candidate(s), ${routing.gateway.resolutionStatus ?? "ready"}` : "unavailable"
     );
   }
+  const selectedCandidate = adaptiveRoutingSelectedCandidate(routing.resolution);
+  if (selectedCandidate) {
+    printKeyValue("Selected candidate:", selectedCandidate.candidateId);
+    if (selectedCandidate.endpointType) {
+      printKeyValue("Selected endpoint:", selectedCandidate.endpointType);
+    }
+  }
+  const selectedWorkerEndpoint = selectedCandidate && routing.runtimeCatalog?.workerEndpoints ? routing.runtimeCatalog.workerEndpoints[selectedCandidate.candidateId] : void 0;
+  if (selectedWorkerEndpoint?.model) {
+    printKeyValue("Selected model:", String(selectedWorkerEndpoint.model));
+  }
   if (routing.routingCard.reasons.length > 0) {
     console.log("Reasons:");
     for (const reason of routing.routingCard.reasons) {
@@ -20679,11 +21039,191 @@ function normalizeAdaptiveRoutingCatalog(value) {
   const candidates = Array.isArray(record.candidates) ? record.candidates.filter(
     (candidate) => Boolean(candidate) && typeof candidate === "object" && !Array.isArray(candidate)
   ) : [];
+  const models = Array.isArray(record.models) ? record.models.map((item) => stringValue9(item)).filter((item) => Boolean(item)) : void 0;
+  const workerEndpoints = isRecord12(record.workerEndpoints) ? Object.fromEntries(
+    Object.entries(record.workerEndpoints).filter(
+      ([key, value2]) => Boolean(stringValue9(key)) && isRecord12(value2)
+    )
+  ) : void 0;
+  const workerProfiles = isRecord12(record.workerProfiles) ? Object.fromEntries(
+    Object.entries(record.workerProfiles).filter(
+      ([key, value2]) => Boolean(stringValue9(key)) && isRecord12(value2)
+    )
+  ) : void 0;
   return {
     version: stringValue9(record.version),
+    source: stringValue9(record.source),
+    provider: stringValue9(record.provider),
+    baseUrl: stringValue9(record.baseUrl),
+    ...models && models.length > 0 ? { models } : {},
+    ...isRecord12(record.apiPaths) ? { apiPaths: record.apiPaths } : {},
+    ...workerEndpoints ? { workerEndpoints } : {},
+    ...workerProfiles ? { workerProfiles } : {},
     candidates
   };
 }
+function adaptiveRoutingSelectedCandidate(resolution) {
+  if (!resolution || !isRecord12(resolution.selected)) {
+    return void 0;
+  }
+  const candidate = isRecord12(resolution.selected.candidate) ? resolution.selected.candidate : void 0;
+  const candidateId = stringValue9(candidate?.candidateId);
+  if (!candidateId) {
+    return void 0;
+  }
+  return {
+    candidateId,
+    workerClass: stringValue9(candidate?.workerClass),
+    endpointType: stringValue9(candidate?.endpointType),
+    catalogSource: stringValue9(candidate?.catalogSource)
+  };
+}
+function normalizeAdaptiveRoutingResolution(value) {
+  if (!isRecord12(value)) {
+    return void 0;
+  }
+  const selected = isRecord12(value.selected) ? value.selected : void 0;
+  const candidate = selected && isRecord12(selected.candidate) ? selected.candidate : void 0;
+  const selectedPayload = selected && candidate ? {
+    candidate,
+    ...numberValue6(selected.score) !== void 0 ? { score: numberValue6(selected.score) } : {},
+    ...isRecord12(selected.scoreBreakdown) ? { scoreBreakdown: selected.scoreBreakdown } : {},
+    ...normalizeStringArray3(selected.reasons) ? { reasons: normalizeStringArray3(selected.reasons) } : {}
+  } : void 0;
+  const reasons = normalizeStringArray3(value.reasons);
+  const warnings = normalizeStringArray3(value.warnings);
+  return {
+    status: stringValue9(value.status),
+    ...selectedPayload ? { selected: selectedPayload } : {},
+    ...isRecord12(value.policyDecision) ? { policyDecision: value.policyDecision } : {},
+    ...numberValue6(value.evaluatedCount) !== void 0 ? { evaluatedCount: numberValue6(value.evaluatedCount) } : {},
+    ...numberValue6(value.rejectedCount) !== void 0 ? { rejectedCount: numberValue6(value.rejectedCount) } : {},
+    ...stringValue9(value.fallback) ? { fallback: stringValue9(value.fallback) } : {},
+    ...reasons ? { reasons } : {},
+    ...warnings ? { warnings } : {}
+  };
+}
+function shouldResolveAdaptiveRoutingLocally(options, routing) {
+  if (!routing) {
+    return false;
+  }
+  if (!options.routeLocalWorkers && !options.routingLocalBaseUrl && !options.routingLocalModel && !options.routingLocalPreferModel && !options.routingLocalProvider) {
+    return false;
+  }
+  const preferred = routing.requirements.preferredEndpointTypes ?? [];
+  const allowed = routing.requirements.allowedEndpointTypes ?? [];
+  return preferred.includes("local") || allowed.length === 0 || allowed.includes("local");
+}
+function runOrchestratorJsonCommand(args, cwd = process.cwd()) {
+  const output = (0, import_node_child_process8.execFileSync)("snipara-orchestrator", args, {
+    cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: DEFAULT_LOCAL_ORCHESTRATOR_TIMEOUT_MS
+  }).trim();
+  return output ? parseJsonRecord(output, "snipara-orchestrator JSON output") : {};
+}
+function enrichAdaptiveRoutingWithLocalOrchestrator(routing, options, cwd = process.cwd()) {
+  try {
+    const catalogArgs = [
+      "local-model-catalog",
+      "--json",
+      "--worker-role",
+      routing.requirements.workerRole
+    ];
+    for (const writeScope of routing.requirements.writeScope ?? []) {
+      catalogArgs.push("--write-scope", writeScope);
+    }
+    if (options.routingLocalBaseUrl) {
+      catalogArgs.push("--base-url", options.routingLocalBaseUrl);
+    }
+    if (options.routingLocalModel) {
+      catalogArgs.push("--model", options.routingLocalModel);
+    } else if (options.routingLocalPreferModel) {
+      catalogArgs.push("--prefer-model", options.routingLocalPreferModel);
+    } else if (options.routeLocalWorkers) {
+      catalogArgs.push("--all-models");
+    }
+    if (options.routingLocalProvider) {
+      catalogArgs.push("--provider", options.routingLocalProvider);
+    }
+    const runtimeCatalog = normalizeAdaptiveRoutingCatalog(
+      runOrchestratorJsonCommand(catalogArgs, cwd)
+    );
+    const routeArgs = [
+      "route",
+      "--dry-run",
+      "--json",
+      "--work-profile-json",
+      JSON.stringify(routing.workProfile),
+      "--requirements-json",
+      JSON.stringify(routing.requirements)
+    ];
+    for (const candidate of runtimeCatalog.candidates) {
+      routeArgs.push("--candidate-json", JSON.stringify(candidate));
+    }
+    const resolution = normalizeAdaptiveRoutingResolution(
+      runOrchestratorJsonCommand(routeArgs, cwd)
+    );
+    const selectedCandidate = adaptiveRoutingSelectedCandidate(resolution);
+    const selectedEndpoint = selectedCandidate && runtimeCatalog.workerEndpoints ? runtimeCatalog.workerEndpoints[selectedCandidate.candidateId] : void 0;
+    const resolutionWarnings = normalizeStringArray3(resolution?.warnings) ?? [];
+    const resolutionReasons = normalizeStringArray3(resolution?.reasons) ?? [];
+    const approvalRequired = booleanValue2(
+      isRecord12(resolution?.policyDecision) ? resolution.policyDecision.approvalRequired : void 0
+    );
+    const gatewayWarnings = uniqueStrings5([
+      ...resolutionWarnings,
+      ...selectedCandidate ? [] : ["Local orchestrator did not select a worker candidate and will fail closed."]
+    ]);
+    const gateway = {
+      source: "local_orchestrator",
+      success: stringValue9(resolution?.status) === "resolved",
+      resolutionStatus: stringValue9(resolution?.status),
+      candidateCount: runtimeCatalog.candidates.length,
+      fallback: stringValue9(resolution?.fallback) ?? routing.requirements.fallback,
+      warnings: gatewayWarnings
+    };
+    return {
+      ...routing,
+      gateway,
+      runtimeCatalog,
+      ...resolution ? { resolution } : {},
+      routingCard: {
+        ...routing.routingCard,
+        ...selectedCandidate?.workerClass ? { recommendedWorkerClass: selectedCandidate.workerClass } : {},
+        ...approvalRequired !== void 0 ? { humanApprovalRequired: approvalRequired } : {},
+        reasons: uniqueStrings5([
+          ...routing.routingCard.reasons,
+          ...resolutionReasons,
+          ...selectedCandidate ? [
+            `local orchestrator resolved worker candidate ${selectedCandidate.candidateId}`,
+            ...selectedCandidate.endpointType ? [`selected worker endpoint is ${selectedCandidate.endpointType}`] : [],
+            ...stringValue9(selectedEndpoint?.model) ? [`selected local model ${String(selectedEndpoint?.model)}`] : []
+          ] : ["local orchestrator could not resolve a concrete worker candidate"]
+        ]),
+        warnings: uniqueStrings5([...routing.routingCard.warnings, ...gatewayWarnings])
+      }
+    };
+  } catch (error) {
+    const warning = `Local orchestrator routing unavailable; keeping current routing metadata (${toPreview(error)}).`;
+    return {
+      ...routing,
+      gateway: {
+        source: "local_orchestrator",
+        success: false,
+        resolutionStatus: "unavailable",
+        candidateCount: 0,
+        fallback: routing.requirements.fallback,
+        warnings: [warning]
+      },
+      routingCard: {
+        ...routing.routingCard,
+        warnings: uniqueStrings5([...routing.routingCard.warnings, warning])
+      }
+    };
+  }
+}
 function printUploadResult(path23, result) {
   printKeyValue("Uploaded:", path23);
   printCompactObject(result, ["message", "document_id", "documentId", "version", "status"]);
@@ -22170,7 +22710,8 @@ async function workflowRunCommand(options) {
     hostedConfigured
   );
   const adaptiveRoutingDryRun = adaptiveRoutingIntent.shouldBuild ? buildWorkflowAdaptiveRouting(options, adaptiveRoutingPolicy, adaptiveRoutingIntent.warnings) : null;
-  const adaptiveRouting = adaptiveRoutingDryRun && adaptiveRoutingIntent.shouldUseHostedCatalog && client ? await enrichAdaptiveRoutingWithHostedCatalog(client, adaptiveRoutingDryRun) : adaptiveRoutingDryRun;
+  const adaptiveRoutingWithCatalog = adaptiveRoutingDryRun && adaptiveRoutingIntent.shouldUseHostedCatalog && client ? await enrichAdaptiveRoutingWithHostedCatalog(client, adaptiveRoutingDryRun) : adaptiveRoutingDryRun;
+  const adaptiveRouting = shouldResolveAdaptiveRoutingLocally(options, adaptiveRoutingWithCatalog) ? enrichAdaptiveRoutingWithLocalOrchestrator(adaptiveRoutingWithCatalog, options) : adaptiveRoutingWithCatalog;
   const orchestratorRecommendation = getOrchestratorRecommendation(options.query, options.mode, {
     policyAutoRoute: options.autoRouteOrchestrator,
     policySource: options.orchestratorPolicySource,
@@ -22393,7 +22934,7 @@ async function workflowRunCommand(options) {
 }
 function shouldBuildAdaptiveRouting(options) {
   return Boolean(
-    options.adaptiveRoutingDryRun || options.routeLocalWorkers || options.routingWorkerRole || options.routingPreferredEndpoints?.length || options.routingAllowedEndpoints?.length || options.plannerRetainsReasoning
+    options.adaptiveRoutingDryRun || options.routeLocalWorkers || options.routingWorkerRole || options.routingPreferredEndpoints?.length || options.routingAllowedEndpoints?.length || options.routingLocalBaseUrl || options.routingLocalModel || options.routingLocalPreferModel || options.routingLocalProvider || options.plannerRetainsReasoning
   );
 }
 function buildWorkflowAdaptiveRouting(options, policy = null, intentWarnings = []) {
@@ -24508,6 +25049,12 @@ workflow.command("run").description("Run a LITE/STANDARD/FULL/orchestrate workfl
   collectOption,
   []
 ).option(
+  "--routing-local-base-url <url>",
+  "Local OpenAI-compatible runtime base URL for explicit worker routing"
+).option("--routing-local-model <id>", "Explicit local model id for worker routing").option(
+  "--routing-local-prefer-model <text>",
+  "Prefer a local /v1/models entry containing this text during worker routing"
+).option("--routing-local-provider <provider>", "Provider label for local worker routing").option(
   "--planner-retains-reasoning",
   "Mark the main planner as retaining deep reasoning while the worker executes scoped work"
 ).option("--write-plan-file <file>", "Write the generated FULL-mode plan as workflow JSON").option(
@@ -24530,6 +25077,10 @@ workflow.command("run").description("Run a LITE/STANDARD/FULL/orchestrate workfl
     routingWorkerRole: options.routingWorkerRole,
     routingPreferredEndpoints: options.routingPreferredEndpoint,
     routingAllowedEndpoints: options.routingAllowedEndpoint,
+    routingLocalBaseUrl: options.routingLocalBaseUrl,
+    routingLocalModel: options.routingLocalModel,
+    routingLocalPreferModel: options.routingLocalPreferModel,
+    routingLocalProvider: options.routingLocalProvider,
     plannerRetainsReasoning: options.plannerRetainsReasoning ? true : void 0,
     writePlanFile: options.writePlanFile,
     startWorkflowFromPlan: Boolean(options.startWorkflowFromPlan),
@@ -25326,6 +25877,8 @@ if (require.main === module) {
   AutomationInstallConflictError,
   AutomationUnsupportedHookBundleError,
   COLLABORATION_STATE_RELATIVE_PATH,
+  ENGINEERING_LEAD_EXECUTION_RECEIPT_STAGES,
+  ENGINEERING_LEAD_EXECUTION_RECEIPT_STATUSES,
   ENGINEERING_LEAD_POSTURES,
   ENGINEERING_LEAD_ROUTING_MODES,
   ENGINEERING_LEAD_STATUSES,

package/docs/FULL_REFERENCE.md

@@ -273,6 +273,62 @@ Project credentials stay server-side behind the hosted gateway; local endpoints
 such as Ollama, LM Studio, AnythingLLM, or other OpenAI-compatible servers must
 be reachable from the worker execution environment.
 
+For a local LM Studio or OpenAI-compatible worker, use Companion to emit the
+handoff, then let `snipara-orchestrator` resolve that handoff against an explicit
+local runtime catalog. In the Codex workflow, Codex remains the chief architect,
+lead orchestrator, and quality verifier; Qwen and Devstral are bounded local
+worker candidates whose outputs still need Codex review and proof gates.
+
+Use Qwen for reflection, architecture, and documentation:
+
+```bash
+snipara-companion workflow run \
+  --mode full \
+  --adaptive-routing-dry-run \
+  --route-local-workers \
+  --routing-worker-role documentation \
+  --routing-preferred-endpoint local \
+  --routing-allowed-endpoint local \
+  --planner-retains-reasoning \
+  "Update a scoped docs surface"
+
+snipara-orchestrator local-model-catalog \
+  --base-url http://127.0.0.1:1234 \
+  --model qwen/qwen3-30b-a3b-2507 \
+  --worker-role documentation \
+  --capability documentation \
+  --capability architecture_review \
+  --capability planning \
+  --json > .snipara/local-qwen-docs-runtime-catalog.json
+
+snipara-orchestrator route --dry-run \
+  --work-profile-json '{"taskType":"documentation","risk":"low","scope":["docs/**"],"contextBudget":"small","reasoningDepth":"low"}' \
+  --requirements-json '{"workerRole":"documentation","plannerRetainsReasoning":true,"preferredEndpointTypes":["local"],"allowedEndpointTypes":["local"],"writeScope":["docs/**"],"capabilities":["documentation"]}' \
+  --catalog-file .snipara/local-qwen-docs-runtime-catalog.json \
+  --json
+```
+
+Use Devstral for development and refactoring work:
+
+```bash
+snipara-orchestrator local-model-catalog \
+  --base-url http://127.0.0.1:1234 \
+  --prefer-model devstral \
+  --worker-role coding \
+  --capability code_edit \
+  --capability refactor \
+  --json > .snipara/local-devstral-runtime-catalog.json
+```
+
+The local catalog records the OpenAI-compatible routes exposed by LM Studio:
+`GET /v1/models`, `POST /v1/responses`, `POST /v1/chat/completions`,
+`POST /v1/completions`, and `POST /v1/embeddings`. `--prefer-model devstral`
+selects the first `/v1/models` id containing `devstral`; use `--model <id>` to
+pin Qwen or any other exact local model id. This makes Qwen, Devstral, or
+another local model routable through the Companion/Orchestrator contract while
+keeping execution fail-closed: the selected candidate is a receipt-backed worker
+target, not an automatically launched process.
+
 For the open package without Snipara SaaS, add a local policy file:
 
 ```json
@@ -313,6 +369,12 @@ Health: posture, score, routing mode, bounded worker contract, supervised work
 packages, supervision/replan status, proof gates, candidate Project Brain
 updates, `workersSpawned: 0`, and `main_agent` fallback.
 
+Engineering Lead Execution Receipts V1 adds `executionReceipts` to that plan.
+Each receipt records the expected handoff, claim, approval, proof, outcome, and
+Project Brain update stages for a work package, plus missing requirements and
+next actions. Unknown future receipt enum values fail closed with
+`companion_dropped_unknown_execution_receipt_*` reason codes.
+
 Use `--from-cockpit <file>` or `--from-plan <file>` when Project Health has
 exported a cockpit/lead-plan JSON artifact and Companion only needs to normalize
 it into Markdown or JSON for handoff. Add `--reconcile` to compare the imported

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "snipara-companion",
-  "version": "2.2.0",
+  "version": "2.3.1",
   "description": "Local-first CLI that asks your repo what breaks before an AI coding agent edits it.",
   "main": "dist/index.js",
   "bin": {