snipara-companion 3.6.8 → 3.6.9

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 Release notes for `snipara-companion`, newest first.
 
+## New In 3.6.9
+
+- Auto-accepts only `info` and `watch` Advisor recommendations in managed
+  workflows, with an auditable `policy_auto` source and stable reason codes;
+  `risk` and `block` recommendations still require explicit authority.
+- Adds an evidence-derived Judgment Resolution V1 beside the immutable original
+  card. Verification-only warnings can become `ready` after a completed outcome
+  and matching passed evidence, while failed evidence, collaboration blockers,
+  `resolve_blocker` actions, and explicit blocked decisions remain hard blocks.
+- Preserves superseded responses and refreshed cards in bounded local history,
+  and normalizes older Judgment V1 states without a migration or schema reset.
+- Makes action-to-evidence matching explicit for tests, type checks, lint,
+  builds, package review, deployment/guard review, impact inspection, and Team
+  Sync handoffs.
+
 ## New In 3.6.8
 
 - Redacts macOS workspace paths consistently when the same temporary directory

package/README.md

@@ -313,6 +313,7 @@ After the first impact check, keep the work resumable:
 
 ```bash
 npx -y snipara-companion workflow start --goal "ship auth hardening"
+npx -y snipara-companion workflow judgment
 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
@@ -332,6 +333,14 @@ npx -y snipara-companion workflow producer-review --latest --outcome useful --re
 npx -y snipara-companion handoff --summary "auth impact mapped" --next "run auth tests"
 ```
 
+Managed workflow judgments use risk-based authority. `info` and `watch`
+recommendations are accepted locally by policy and remain auditable; `risk` and
+`block` recommendations still need `workflow judgment-respond`. The immutable
+card is never rewritten. Companion appends an effective resolution and can lift
+a verification-only `proof_required` state only after a completed outcome and
+matching passed evidence. Failed evidence, a blocked collaboration guard, a
+`resolve_blocker` action, or an explicit blocked response remains a hard stop.
+
 `snipara-companion` writes local state under `.snipara/` so a coding agent can
 resume with the current phase, recent handoffs, timeline, context packs, and
 verification hints.
@@ -489,8 +498,10 @@ Release notes live in [CHANGELOG.md](./CHANGELOG.md).
 When project auth is configured, `workflow phase-commit`, `final-commit`, and
 `team-sync handoff` also run reviewed Why Capture. The Companion first sends a
 read-only preview and confirms only when the server detects durable rationale.
-Confirmed candidates enter the pending review queue; capture failures remain
-visible but do not block the primary workflow command. No documentation prompt
-is shown. `final-commit` remains handoff-only: the report explains what was
-stored or proposed, but it does not approve pending candidates or write final
-summary text as durable memory.
+Low-risk, directly confirmed and sufficiently evidenced captures can be
+approved by the hosted memory policy; shared-scope, conflicting, weakly
+supported, imported, or canonical decision-draft candidates remain reviewed.
+Capture failures stay visible but do not block the primary workflow command. No
+documentation prompt is shown. `final-commit` remains handoff-only: the report
+explains what was stored or proposed, but it does not itself approve canonical
+decision drafts or write final summary text as durable memory.

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { AdvisorInfluenceLifecycle, HostedContextControlSource, HostedContextControlPlan, HostedContextControlApplyReceipt, ProjectIntentDetectionResult, ProjectPolicyDecision, ProjectRealityCheckResult, ContextMutationPlan, ContextMutationApplyReceipt, ProjectContextValidationReport, ProjectDriftReport, AgentContextResolution, AgentContextValidationReport, AgentContextEvidenceReceipt, AgentContextEvidenceReport, ProjectIntelligenceEngineeringLeadPlanSummary, ProjectPolicyRule, DecisionRequest, AdvisorInfluenceLifecycleState, OutcomeIntelligenceCalibration, OutcomeIntelligenceReceipt, ControlledWorkerExecutionMode, WorkerTrustCategory, ControlledWorkerExecutionReceipt, UnifiedReceiptEnvelope, WorkerTrustCandidate, WorkerProfile, WorkerTrustEvent } from '@snipara/project-intelligence-contracts';
+import { AdvisorInfluenceLifecycle, HostedContextControlSource, HostedContextControlPlan, HostedContextControlApplyReceipt, ProjectIntentDetectionResult, ProjectPolicyDecision, ProjectRealityCheckResult, ContextMutationPlan, ContextMutationApplyReceipt, ProjectContextValidationReport, ProjectDriftReport, AgentContextResolution, AgentContextValidationReport, AgentContextEvidenceReceipt, AgentContextEvidenceReport, ProjectIntelligenceEngineeringLeadPlanSummary, ProjectPolicyRule, AdvisorInfluenceLifecycleState, DecisionRequest, OutcomeIntelligenceCalibration, OutcomeIntelligenceReceipt, OutcomeIntelligenceEvidence, ControlledWorkerExecutionMode, WorkerTrustCategory, ControlledWorkerExecutionReceipt, UnifiedReceiptEnvelope, WorkerTrustCandidate, WorkerProfile, WorkerTrustEvent } from '@snipara/project-intelligence-contracts';
 
 declare function resolveQueryFromToolInput(toolInput?: string, tool?: string): string | null;
 
@@ -4316,12 +4316,39 @@ interface ManagedWorkflowJudgmentResponse {
     recommendationId: string;
     decision: AdvisorInfluenceAgentDecision;
     respondedAt: string;
+    source: "explicit" | "policy_auto";
+    policyVersion?: "snipara.workflow.judgment-autonomy.v1";
+    reasonCodes: string[];
     planBefore?: string;
     planAfter?: string;
     initialReceipt?: ProjectRunAdvisorReceiptCapture;
     closeoutReceipt?: ProjectRunAdvisorReceiptCapture;
     outcomeReceipts?: OutcomeIntelligenceReceipt[];
 }
+interface ManagedWorkflowJudgmentResolution {
+    version: "snipara.workflow.judgment-resolution.v1";
+    evaluatedAt: string;
+    state: ProjectJudgmentState;
+    canProceed: ProjectJudgmentCanProceed;
+    originalCard: {
+        generatedAt: string;
+        state: ProjectJudgmentState;
+        canProceed: ProjectJudgmentCanProceed;
+        score: number;
+    };
+    reasonCodes: string[];
+    hardBlockerCodes: string[];
+    pendingExplicitRecommendationIds: string[];
+    autoResponseCount: number;
+    evidence: {
+        passedCount: number;
+        failedCount: number;
+        skippedCount: number;
+        requiredActionCount: number;
+        satisfiedRequiredActionCount: number;
+        unsatisfiedRequiredActions: string[];
+    };
+}
 interface ManagedWorkflowJudgmentState {
     version: "snipara.workflow.judgment.v1";
     generatedAt: string;
@@ -4329,6 +4356,8 @@ interface ManagedWorkflowJudgmentState {
     brief: ManagedWorkflowJudgmentBrief;
     card: ProjectIntelligenceJudgmentCard;
     responses: ManagedWorkflowJudgmentResponse[];
+    responseHistory?: ManagedWorkflowJudgmentResponse[];
+    resolution?: ManagedWorkflowJudgmentResolution;
 }
 interface ManagedWorkflowState {
     schemaVersion: ManagedWorkflowSchemaVersion;
@@ -4344,6 +4373,7 @@ interface ManagedWorkflowState {
     runtime?: ManagedWorkflowRuntimeState;
     coordination?: ManagedWorkflowCoordinationState;
     judgment?: ManagedWorkflowJudgmentState;
+    judgmentHistory?: ManagedWorkflowJudgmentState[];
     phaseCommitReceipts?: WorkflowPhaseCommitReceipt[];
     finalReport?: FinalCommitReportArtifact;
     lastCommit?: {
@@ -4743,6 +4773,12 @@ declare function buildSyncDocumentsDryRun(documents: SyncDocumentInput[], option
     reindexMode?: ReindexMode;
     now?: Date;
 }): SyncDocumentsDryRunSummary;
+declare function applyManagedWorkflowPolicyAutoResponses(judgment: ManagedWorkflowJudgmentState, respondedAt?: string): ManagedWorkflowJudgmentResponse[];
+declare function deriveManagedWorkflowJudgmentResolution(judgment: ManagedWorkflowJudgmentState, options?: {
+    evidence?: OutcomeIntelligenceEvidence[];
+    outcome?: TaskCommitOutcome;
+    evaluatedAt?: string;
+}): ManagedWorkflowJudgmentResolution;
 declare function buildAgenticWorkStatus(cwd?: string): AgenticWorkStatus;
 declare function buildAgenticTimeline(options?: {
     limit?: number;
@@ -5232,4 +5268,4 @@ declare function installAutomationBundle(args: {
 }): Promise<AutomationInstallResult>;
 declare function getAutomationStatus(projectDir?: string): AutomationStatusResult;
 
-export { AGENT_CONTEXT_EVIDENCE_DEFAULT_LEDGER, AUTOMATION_MANIFEST_RELATIVE_PATH, AutomationInstallConflictError, AutomationUnsupportedHookBundleError, CODING_INTELLIGENCE_LEDGER_VERSION, COLLABORATION_STATE_RELATIVE_PATH, ENGINEERING_LEAD_EXECUTION_RECEIPT_STAGES, ENGINEERING_LEAD_EXECUTION_RECEIPT_STATUSES, ENGINEERING_LEAD_POSTURES, ENGINEERING_LEAD_PROOF_VERIFICATION_SOURCES, ENGINEERING_LEAD_PROOF_VERIFICATION_STATUSES, ENGINEERING_LEAD_ROUTING_MODES, ENGINEERING_LEAD_STATUSES, ENGINEERING_LEAD_SUPERVISION_STATUSES, ENGINEERING_LEAD_WORKER_ROLES, ENGINEERING_LEAD_WORK_PACKAGE_STATUSES, FINAL_COMMIT_REPORT_RELATIVE_PATH, FINAL_COMMIT_REPORT_VERSION, MEMORY_GUARD_CONTEXT_TIMEOUT_MS, MEMORY_GUARD_RECALL_TIMEOUT_MS, ORCHESTRATOR_HANDOFF_RELATIVE_PATH, POLICY_LEDGER_SYNC_REPORT_VERSION, PRODUCER_LOOP_ARTIFACT_VERSION, PRODUCER_LOOP_RELATIVE_DIR, PRODUCER_LOOP_REPORT_VERSION, TEAM_SYNC_STATE_RELATIVE_PATH, WHY_OUTCOME_CAPTURE_VERSION, WORKFLOW_PLANS_RELATIVE_DIR, WORKFLOW_STATE_RELATIVE_PATH, addLocalWorker, agentContextEvidenceRecordCommand, agentContextEvidenceStatusCommand, agentContextEvidenceTemplateCommand, agentContextResolveCommand, agentContextValidateCommand, agentReadinessAuditCommand, appendActivityEvent, applyLocalContextMutationPlan, archiveInactiveTeamSyncWork, attachLocalContextPackReceipts, autoArchiveTeamSyncState, buildAdaptiveWorkRoutingRecommendation, buildAgentReadinessAuditReport, buildAgenticHandoffMarkdown, buildAgenticTimeline, buildAgenticWorkStatus, buildAutomationInstallPlan, buildCanonicalEvent, buildCodeHooksInstallPlan, buildCodePromotionResult, buildCodeStatusResult, buildCodeSyncResult, buildCodingIntelligenceLedger, buildCollaborationActor, buildCollaborationGuardActionCards, buildCollaborationHooksInstallPlan, buildCommitResultMetadata, buildCompanionEngineeringLeadPlanReport, buildContextPackStats, buildEvalCaseArtifact, buildFinalCommitReport, buildGeneratedWorkflowPlanDocument, buildHostedCodeOverlayUploadPayload, buildHostedGuardPayload, buildJournalCheckpointEntry, buildLocalAgentContextValidationReport, buildLocalCallersResult, buildLocalCodeOverlay, buildLocalContextMutationPlan, buildLocalContextPackReceipt, buildLocalContextPackReceipts, buildLocalImpactResult, buildLocalImportsResult, buildLocalNeighborsResult, buildLocalProjectContextValidationReport, buildLocalProjectDriftReport, buildLocalProjectRealityCheck, buildLocalProjectRealityCheckWithAutoContext, buildLocalShortestPathResult, buildLocalSourceSnapshot, buildLocalSourceStatus, buildLocalSourceSyncResult, buildMemoryAudit, buildOnboardFolderManifest, buildOrchestratorHandoff, buildPolicyLedgerSyncReport, buildProducerLoopReport, buildProjectIntelligenceBrief, buildProjectIntelligenceRun, buildProjectJudgmentCard, buildSessionBootstrapBrief, buildSessionBootstrapQuality, buildSessionSnapshot, buildSyncDocumentsDryRun, buildTeamSyncHandoffRecord, buildTeamSyncStartWorkRecord, buildTeamSyncSummary, buildToolCallPayload, buildToolResultPayload, buildVerificationPlan, buildWhyOutcomeCaptureReport, buildWorkerTrustCandidates, buildWorkflowImpactGate, buildWorkflowPhaseCommitReceipt, buildWorkflowPhaseCommitSummary, buildWorkflowPlanScaffold, categoryFromGuardTag, classifyToolResult, cleanContextPacks, codingLedgerExportCommand, collaborationIdeStatusCommand, collectAgentReadinessLocalSignals, collectPolicyLedgerSyncArtifacts, collectSyncDocuments, collectSyncDocumentsInput, compactHostedGuardResources, compareLocalSourceSnapshots, completeTeamSyncStateFromEvidence, completeTeamSyncWorkFromEvidence, contextControlApplyCommand, contextControlDriftCommand, contextControlHostedApplyCommand, contextControlHostedDiffCommand, contextControlPlanCommand, contextControlValidateCommand, contextPackCleanCommand, contextPackPackCommand, contextPackRetrieveCommand, contextPackStatsCommand, controlledWorkerExecuteCommand, createClient, createEmptyCollaborationState, createEmptyTeamSyncState, createLocalQueryCache, deriveLocalCollaborationResourcesFromFiles, detectReleaseSurfacesFromFiles, detectRuntimeEnvironment, evalExportCommand, evalRunCommand, evaluateProjectPolicyGates, extractCommandFromToolInput, extractFilesFromToolInput, formatAgentContextResolution, formatAgentReadinessAuditReport, formatCompanionEngineeringLeadPlanReport, formatFinalCommitReport, formatOrchestratorRecommendationReason, formatPolicyGateDecision, formatProjectJudgmentCard, formatStuckGuardDecision, getAutomationManifestPath, getAutomationStatus, getCollaborationStatePath, getConfigPath, getContextPackStoragePaths, getLocalCodeOverlayCachePath, getLocalCodePromotionStatePath, getLocalSourceSnapshotPath, getOrchestratorRecommendation, getPlanStepDisplayTitle, getStagedFiles, getStuckGuardInjection, getTeamSyncStatePath, hashWorkerProfile, ingestReferences, installAutomationBundle, leadPlanCommand, listProjectsForApiKey, loadAutomationManifest, loadCollaborationState, loadConfig, loadTeamSyncState, memoryAuditCommand, memoryCleanCandidatesCommand, memoryCompactCommand, memoryHealthCommand, memoryLocalCommand, memoryReviewsCommand, mergeHybridCodeResults, normalizeCollaborationFiles, normalizeGuardTag, normalizeWorkflowPlanInput, outcomeCapturePreviewCommand, packContext, parseCollaborationResources, projectIntelligenceBriefCommand, projectIntelligenceRunCommand, readActivityTimeline, readAgentContextEvidenceLedger, readLocalCodeOverlayCache, readLocalCodePromotionState, readLocalSourceSnapshot, readLocalWorkersConfig, readSessionSnapshot, readWorkerTrustEvent, realityCheckCommand, referencesIngestCommand, referencesScanCommand, resolveAutoWorkflowMode, resolveCodeGraphMode, resolveContextPackRecord, resolveFullWorkflowTokenBudget, resolveLocalWorkerRoutingDefaults, resolveQueryFromToolInput, retrieveContextPack, runMemoryGuardCheck, saveCollaborationState, saveConfig, saveTeamSyncState, scanReferences, shouldFailCollaborationGuard, shouldSuggestOrchestratorForWorkflow, shouldSuggestRuntimeForWorkflow, summarizeLocalCodeOverlay, teamSyncSweepCommand, validatePlanResult, verifyCommand, workerTrustCandidateCommand, workerTrustReviewCommand, workerTrustStatusCommand, workersLocalAddCommand, workersLocalListCommand, workersLocalProbePrintCommand, workersLocalRemoveCommand, workersLocalStatusCommand, workflowSyncPolicyLedgerCommand, writeFinalCommitReport, writeLocalCodeOverlayCache, writeLocalCodePromotionState, writeLocalSourceSnapshot, writeOrchestratorHandoff, writeProducerLoopArtifact, writeSessionSnapshot };
+export { AGENT_CONTEXT_EVIDENCE_DEFAULT_LEDGER, AUTOMATION_MANIFEST_RELATIVE_PATH, AutomationInstallConflictError, AutomationUnsupportedHookBundleError, CODING_INTELLIGENCE_LEDGER_VERSION, COLLABORATION_STATE_RELATIVE_PATH, ENGINEERING_LEAD_EXECUTION_RECEIPT_STAGES, ENGINEERING_LEAD_EXECUTION_RECEIPT_STATUSES, ENGINEERING_LEAD_POSTURES, ENGINEERING_LEAD_PROOF_VERIFICATION_SOURCES, ENGINEERING_LEAD_PROOF_VERIFICATION_STATUSES, ENGINEERING_LEAD_ROUTING_MODES, ENGINEERING_LEAD_STATUSES, ENGINEERING_LEAD_SUPERVISION_STATUSES, ENGINEERING_LEAD_WORKER_ROLES, ENGINEERING_LEAD_WORK_PACKAGE_STATUSES, FINAL_COMMIT_REPORT_RELATIVE_PATH, FINAL_COMMIT_REPORT_VERSION, MEMORY_GUARD_CONTEXT_TIMEOUT_MS, MEMORY_GUARD_RECALL_TIMEOUT_MS, ORCHESTRATOR_HANDOFF_RELATIVE_PATH, POLICY_LEDGER_SYNC_REPORT_VERSION, PRODUCER_LOOP_ARTIFACT_VERSION, PRODUCER_LOOP_RELATIVE_DIR, PRODUCER_LOOP_REPORT_VERSION, TEAM_SYNC_STATE_RELATIVE_PATH, WHY_OUTCOME_CAPTURE_VERSION, WORKFLOW_PLANS_RELATIVE_DIR, WORKFLOW_STATE_RELATIVE_PATH, addLocalWorker, agentContextEvidenceRecordCommand, agentContextEvidenceStatusCommand, agentContextEvidenceTemplateCommand, agentContextResolveCommand, agentContextValidateCommand, agentReadinessAuditCommand, appendActivityEvent, applyLocalContextMutationPlan, applyManagedWorkflowPolicyAutoResponses, archiveInactiveTeamSyncWork, attachLocalContextPackReceipts, autoArchiveTeamSyncState, buildAdaptiveWorkRoutingRecommendation, buildAgentReadinessAuditReport, buildAgenticHandoffMarkdown, buildAgenticTimeline, buildAgenticWorkStatus, buildAutomationInstallPlan, buildCanonicalEvent, buildCodeHooksInstallPlan, buildCodePromotionResult, buildCodeStatusResult, buildCodeSyncResult, buildCodingIntelligenceLedger, buildCollaborationActor, buildCollaborationGuardActionCards, buildCollaborationHooksInstallPlan, buildCommitResultMetadata, buildCompanionEngineeringLeadPlanReport, buildContextPackStats, buildEvalCaseArtifact, buildFinalCommitReport, buildGeneratedWorkflowPlanDocument, buildHostedCodeOverlayUploadPayload, buildHostedGuardPayload, buildJournalCheckpointEntry, buildLocalAgentContextValidationReport, buildLocalCallersResult, buildLocalCodeOverlay, buildLocalContextMutationPlan, buildLocalContextPackReceipt, buildLocalContextPackReceipts, buildLocalImpactResult, buildLocalImportsResult, buildLocalNeighborsResult, buildLocalProjectContextValidationReport, buildLocalProjectDriftReport, buildLocalProjectRealityCheck, buildLocalProjectRealityCheckWithAutoContext, buildLocalShortestPathResult, buildLocalSourceSnapshot, buildLocalSourceStatus, buildLocalSourceSyncResult, buildMemoryAudit, buildOnboardFolderManifest, buildOrchestratorHandoff, buildPolicyLedgerSyncReport, buildProducerLoopReport, buildProjectIntelligenceBrief, buildProjectIntelligenceRun, buildProjectJudgmentCard, buildSessionBootstrapBrief, buildSessionBootstrapQuality, buildSessionSnapshot, buildSyncDocumentsDryRun, buildTeamSyncHandoffRecord, buildTeamSyncStartWorkRecord, buildTeamSyncSummary, buildToolCallPayload, buildToolResultPayload, buildVerificationPlan, buildWhyOutcomeCaptureReport, buildWorkerTrustCandidates, buildWorkflowImpactGate, buildWorkflowPhaseCommitReceipt, buildWorkflowPhaseCommitSummary, buildWorkflowPlanScaffold, categoryFromGuardTag, classifyToolResult, cleanContextPacks, codingLedgerExportCommand, collaborationIdeStatusCommand, collectAgentReadinessLocalSignals, collectPolicyLedgerSyncArtifacts, collectSyncDocuments, collectSyncDocumentsInput, compactHostedGuardResources, compareLocalSourceSnapshots, completeTeamSyncStateFromEvidence, completeTeamSyncWorkFromEvidence, contextControlApplyCommand, contextControlDriftCommand, contextControlHostedApplyCommand, contextControlHostedDiffCommand, contextControlPlanCommand, contextControlValidateCommand, contextPackCleanCommand, contextPackPackCommand, contextPackRetrieveCommand, contextPackStatsCommand, controlledWorkerExecuteCommand, createClient, createEmptyCollaborationState, createEmptyTeamSyncState, createLocalQueryCache, deriveLocalCollaborationResourcesFromFiles, deriveManagedWorkflowJudgmentResolution, detectReleaseSurfacesFromFiles, detectRuntimeEnvironment, evalExportCommand, evalRunCommand, evaluateProjectPolicyGates, extractCommandFromToolInput, extractFilesFromToolInput, formatAgentContextResolution, formatAgentReadinessAuditReport, formatCompanionEngineeringLeadPlanReport, formatFinalCommitReport, formatOrchestratorRecommendationReason, formatPolicyGateDecision, formatProjectJudgmentCard, formatStuckGuardDecision, getAutomationManifestPath, getAutomationStatus, getCollaborationStatePath, getConfigPath, getContextPackStoragePaths, getLocalCodeOverlayCachePath, getLocalCodePromotionStatePath, getLocalSourceSnapshotPath, getOrchestratorRecommendation, getPlanStepDisplayTitle, getStagedFiles, getStuckGuardInjection, getTeamSyncStatePath, hashWorkerProfile, ingestReferences, installAutomationBundle, leadPlanCommand, listProjectsForApiKey, loadAutomationManifest, loadCollaborationState, loadConfig, loadTeamSyncState, memoryAuditCommand, memoryCleanCandidatesCommand, memoryCompactCommand, memoryHealthCommand, memoryLocalCommand, memoryReviewsCommand, mergeHybridCodeResults, normalizeCollaborationFiles, normalizeGuardTag, normalizeWorkflowPlanInput, outcomeCapturePreviewCommand, packContext, parseCollaborationResources, projectIntelligenceBriefCommand, projectIntelligenceRunCommand, readActivityTimeline, readAgentContextEvidenceLedger, readLocalCodeOverlayCache, readLocalCodePromotionState, readLocalSourceSnapshot, readLocalWorkersConfig, readSessionSnapshot, readWorkerTrustEvent, realityCheckCommand, referencesIngestCommand, referencesScanCommand, resolveAutoWorkflowMode, resolveCodeGraphMode, resolveContextPackRecord, resolveFullWorkflowTokenBudget, resolveLocalWorkerRoutingDefaults, resolveQueryFromToolInput, retrieveContextPack, runMemoryGuardCheck, saveCollaborationState, saveConfig, saveTeamSyncState, scanReferences, shouldFailCollaborationGuard, shouldSuggestOrchestratorForWorkflow, shouldSuggestRuntimeForWorkflow, summarizeLocalCodeOverlay, teamSyncSweepCommand, validatePlanResult, verifyCommand, workerTrustCandidateCommand, workerTrustReviewCommand, workerTrustStatusCommand, workersLocalAddCommand, workersLocalListCommand, workersLocalProbePrintCommand, workersLocalRemoveCommand, workersLocalStatusCommand, workflowSyncPolicyLedgerCommand, writeFinalCommitReport, writeLocalCodeOverlayCache, writeLocalCodePromotionState, writeLocalSourceSnapshot, writeOrchestratorHandoff, writeProducerLoopArtifact, writeSessionSnapshot };

package/dist/index.js

@@ -69,6 +69,7 @@ __export(index_exports, {
   agentReadinessAuditCommand: () => agentReadinessAuditCommand,
   appendActivityEvent: () => appendActivityEvent,
   applyLocalContextMutationPlan: () => applyLocalContextMutationPlan,
+  applyManagedWorkflowPolicyAutoResponses: () => applyManagedWorkflowPolicyAutoResponses,
   archiveInactiveTeamSyncWork: () => archiveInactiveTeamSyncWork,
   attachLocalContextPackReceipts: () => attachLocalContextPackReceipts,
   autoArchiveTeamSyncState: () => autoArchiveTeamSyncState,
@@ -166,6 +167,7 @@ __export(index_exports, {
   createEmptyTeamSyncState: () => createEmptyTeamSyncState,
   createLocalQueryCache: () => createLocalQueryCache,
   deriveLocalCollaborationResourcesFromFiles: () => deriveLocalCollaborationResourcesFromFiles,
+  deriveManagedWorkflowJudgmentResolution: () => deriveManagedWorkflowJudgmentResolution,
   detectReleaseSurfacesFromFiles: () => detectReleaseSurfacesFromFiles,
   detectRuntimeEnvironment: () => detectRuntimeEnvironment,
   evalExportCommand: () => evalExportCommand,
@@ -28461,13 +28463,32 @@ function normalizeManagedWorkflowState(state) {
   if (state.schemaVersion !== "snipara.workflow.v1" && state.schemaVersion !== "snipara.workflow.v2") {
     throw new Error(`${WORKFLOW_STATE_RELATIVE_PATH} is not a valid Snipara workflow state file`);
   }
+  const judgment = state.judgment ? {
+    ...state.judgment,
+    responses: (Array.isArray(state.judgment.responses) ? state.judgment.responses : []).map(
+      (response) => ({
+        ...response,
+        source: response.source === "policy_auto" ? "policy_auto" : "explicit",
+        reasonCodes: uniqueStringList(response.reasonCodes) ?? (response.source === "policy_auto" ? ["low_risk_advisory_auto_accepted"] : ["explicit_agent_response"])
+      })
+    ),
+    responseHistory: (Array.isArray(state.judgment.responseHistory) ? state.judgment.responseHistory : []).map((response) => ({
+      ...response,
+      source: response.source === "policy_auto" ? "policy_auto" : "explicit",
+      reasonCodes: uniqueStringList(response.reasonCodes) ?? (response.source === "policy_auto" ? ["low_risk_advisory_auto_accepted"] : ["explicit_agent_response"])
+    }))
+  } : void 0;
+  if (judgment) {
+    applyManagedWorkflowPolicyAutoResponses(judgment, judgment.generatedAt);
+    judgment.resolution ??= deriveManagedWorkflowJudgmentResolution(judgment, {
+      evaluatedAt: judgment.generatedAt
+    });
+  }
   return {
     ...state,
     runtime: normalizeManagedWorkflowRuntimeState(state.runtime),
-    judgment: state.judgment ? {
-      ...state.judgment,
-      responses: Array.isArray(state.judgment.responses) ? state.judgment.responses : []
-    } : void 0,
+    judgment,
+    judgmentHistory: Array.isArray(state.judgmentHistory) ? state.judgmentHistory : [],
     phaseCommitReceipts: Array.isArray(state.phaseCommitReceipts) ? state.phaseCommitReceipts : []
   };
 }
@@ -30145,14 +30166,19 @@ function printManagedWorkflowState(state) {
     }
   }
   if (state.judgment) {
+    const resolution = state.judgment.resolution ?? deriveManagedWorkflowJudgmentResolution(state.judgment);
     printKeyValue2(
       "Judgment:",
-      `${state.judgment.card.state} (${state.judgment.responses.length}/${state.judgment.card.advisorRecommendations.length} response(s))`
+      `${resolution.state} (original ${state.judgment.card.state}; ${state.judgment.responses.length}/${state.judgment.card.advisorRecommendations.length} response(s))`
     );
+    printKeyValue2("Judgment authority:", resolution.canProceed);
     printKeyValue2(
       "Judgment identity:",
       state.judgment.brief.servedJudgmentId ? "linked" : "missing"
     );
+    if ((state.judgmentHistory ?? []).length > 0) {
+      printKeyValue2("Prior judgment cards:", String(state.judgmentHistory?.length ?? 0));
+    }
   }
   console.log("");
   console.log(import_chalk9.default.bold("Phases"));
@@ -30172,7 +30198,20 @@ function printManagedWorkflowJudgmentNextCommands(state) {
   const judgment = state.judgment;
   if (!judgment) return;
   console.log("");
-  console.log(import_chalk9.default.bold("Explicit advisor responses"));
+  const resolution = judgment.resolution ?? deriveManagedWorkflowJudgmentResolution(judgment);
+  console.log(import_chalk9.default.bold("Effective judgment resolution"));
+  printKeyValue2("State:", resolution.state);
+  printKeyValue2("Can proceed:", resolution.canProceed);
+  printKeyValue2("Original card:", `${resolution.originalCard.state}/${resolution.originalCard.canProceed}`);
+  printKeyValue2("Reason codes:", resolution.reasonCodes.join(", "));
+  if (resolution.evidence.unsatisfiedRequiredActions.length > 0) {
+    printKeyValue2(
+      "Unsatisfied actions:",
+      resolution.evidence.unsatisfiedRequiredActions.join(" | ")
+    );
+  }
+  console.log("");
+  console.log(import_chalk9.default.bold("Advisor responses"));
   if (!judgment.brief.servedJudgmentId) {
     console.log(
       "No served judgment identity was returned. The card is inspectable, but hosted influence receipts cannot be linked yet."
@@ -30186,7 +30225,7 @@ function printManagedWorkflowJudgmentNextCommands(state) {
   for (const recommendation of judgment.card.advisorRecommendations) {
     const response = judgment.responses.find((item) => item.recommendationId === recommendation.id);
     console.log(
-      `- ${recommendation.id}: ${response ? `${response.decision} (${response.initialReceipt?.status ?? "local"})` : "pending explicit response"}`
+      `- ${recommendation.id}: ${response ? `${response.decision} [${response.source}] (${response.initialReceipt?.status ?? "local"})` : "pending explicit response"}`
     );
     if (!response) {
       console.log(
@@ -30195,7 +30234,7 @@ function printManagedWorkflowJudgmentNextCommands(state) {
     }
   }
   console.log(
-    "Use --decision modified with distinct --plan-before/--plan-after snapshots when the judgment changed the plan; use ignored or blocked explicitly when applicable."
+    "Info/watch recommendations are accepted locally by policy. Risk/block recommendations still require an explicit response. Use --decision modified with distinct --plan-before/--plan-after snapshots when the judgment changed the plan."
   );
   console.log("");
 }
@@ -34036,7 +34075,9 @@ function workflowOutcomeEvidence(values) {
     const detail = (matched?.[2] ?? text).trim();
     const status = rawStatus === "passed" || rawStatus === "pass" || rawStatus === "ok" || rawStatus === "success" ? "passed" : rawStatus === "failed" || rawStatus === "fail" || rawStatus === "error" ? "failed" : "skipped";
     const normalizedDetail = detail.toLowerCase();
-    const source2 = normalizedDetail.includes("typecheck") ? "typecheck" : normalizedDetail.includes("lint") ? "lint" : normalizedDetail.includes("build") ? "build" : normalizedDetail.includes("deploy") || normalizedDetail.includes("health") ? "deploy_health" : normalizedDetail.includes("publish") || normalizedDetail.includes("npm") ? "package_publish" : normalizedDetail.includes("guard") ? "guard" : normalizedDetail.includes("test") || normalizedDetail.includes("smoke") ? "test" : "manual";
+    const source2 = /\b(type[-_ ]?check|tsc)\b/.test(
+      normalizedDetail
+    ) ? "typecheck" : /\b(lint|eslint|ruff|black)\b/.test(normalizedDetail) ? "lint" : /\b(build|compile)\b/.test(normalizedDetail) ? "build" : /\b(deploy|health)\b/.test(normalizedDetail) ? "deploy_health" : /\b(npm|package|publish|pack(?::|\b))\b/.test(normalizedDetail) ? "package_publish" : /\bguard\b/.test(normalizedDetail) ? "guard" : /\b(test|vitest|jest|pytest|smoke)\b/.test(normalizedDetail) ? "test" : "manual";
     return [
       {
         source: source2,
@@ -34047,6 +34088,242 @@ function workflowOutcomeEvidence(values) {
     ];
   });
 }
+var MANAGED_WORKFLOW_JUDGMENT_AUTONOMY_VERSION = "snipara.workflow.judgment-autonomy.v1";
+function isPolicyAutoEligibleRecommendation(recommendation) {
+  return recommendation.severity === "info" || recommendation.severity === "watch";
+}
+function applyManagedWorkflowPolicyAutoResponses(judgment, respondedAt = (/* @__PURE__ */ new Date()).toISOString()) {
+  const created = [];
+  for (const recommendation of judgment.card.advisorRecommendations) {
+    if (!isPolicyAutoEligibleRecommendation(recommendation) || judgment.responses.some((response) => response.recommendationId === recommendation.id)) {
+      continue;
+    }
+    created.push({
+      recommendationId: recommendation.id,
+      decision: "accepted",
+      respondedAt,
+      source: "policy_auto",
+      policyVersion: MANAGED_WORKFLOW_JUDGMENT_AUTONOMY_VERSION,
+      reasonCodes: [
+        "low_risk_advisory_auto_accepted",
+        `advisor_severity_${recommendation.severity}`,
+        "no_plan_mutation"
+      ]
+    });
+  }
+  if (created.length > 0) {
+    judgment.responses = [...judgment.responses, ...created];
+  }
+  return created;
+}
+function judgmentResponseEvidence(judgment) {
+  const receipts = [...judgment.responseHistory ?? [], ...judgment.responses].flatMap((response) => response.outcomeReceipts ?? []).sort((left, right) => left.generatedAt.localeCompare(right.generatedAt));
+  return receipts.flatMap((receipt) => receipt.verification.evidence);
+}
+function effectiveJudgmentEvidence(judgment, currentEvidence) {
+  const latestBySemanticKey = /* @__PURE__ */ new Map();
+  for (const evidence of [...judgmentResponseEvidence(judgment), ...currentEvidence]) {
+    const label = (evidence.command ?? evidence.label).toLowerCase().replace(/\s+/g, " ").trim();
+    latestBySemanticKey.set(`${evidence.source}:${label}`, evidence);
+  }
+  return [...latestBySemanticKey.values()];
+}
+function completedJudgmentOutcomeRecorded(judgment) {
+  return [...judgment.responseHistory ?? [], ...judgment.responses].some(
+    (response) => (response.outcomeReceipts ?? []).some((receipt) => receipt.outcome.status === "success")
+  );
+}
+function judgmentTextTokens(value) {
+  const ignored = /* @__PURE__ */ new Set([
+    "and",
+    "before",
+    "check",
+    "close",
+    "command",
+    "for",
+    "from",
+    "into",
+    "review",
+    "run",
+    "the",
+    "this",
+    "with"
+  ]);
+  return value.toLowerCase().match(/[a-z0-9][a-z0-9_-]{2,}/g)?.filter((token) => !ignored.has(token)) ?? [];
+}
+function judgmentEvidenceText(evidence) {
+  return `${evidence.label} ${evidence.command ?? ""} ${evidence.detail ?? ""}`.toLowerCase();
+}
+function expectedEvidenceSourceForAction(action) {
+  const text = `${action.title} ${action.command ?? ""}`.toLowerCase();
+  if (/\b(type[-_ ]?check|tsc)\b/.test(text)) return "typecheck";
+  if (/\b(lint|eslint|ruff|black)\b/.test(text)) return "lint";
+  if (/\b(pre-?deploy guard|collaboration guard|guard)\b/.test(text)) return "guard";
+  if (/\b(deploy|production health|health check)\b/.test(text)) return "deploy_health";
+  if (/\b(npm|package|pack(?::|\b)|publish)\b/.test(text)) return "package_publish";
+  if (/\b(test|vitest|jest|pytest|smoke)\b/.test(text)) return "test";
+  if (/\b(build|compile)\b/.test(text)) return "build";
+  return void 0;
+}
+function passedEvidenceSatisfiesAction(action, passedEvidence) {
+  if (action.type === "resolve_blocker") return false;
+  if (action.type === "acknowledge") {
+    return passedEvidence.some((evidence) => evidence.source === "guard");
+  }
+  if (action.type === "package_review") {
+    return passedEvidence.some((evidence) => evidence.source === "package_publish");
+  }
+  if (action.type === "deploy_review") {
+    const expected2 = expectedEvidenceSourceForAction(action);
+    return passedEvidence.some((evidence) => evidence.source === (expected2 ?? "deploy_health"));
+  }
+  if (action.type === "handoff") {
+    return passedEvidence.some((evidence) => /\b(team sync|handoff)\b/i.test(judgmentEvidenceText(evidence)));
+  }
+  const actionText = `${action.title} ${action.command ?? ""}`;
+  const expected = expectedEvidenceSourceForAction(action);
+  if (action.type === "run_check" && expected) {
+    return passedEvidence.some((evidence) => evidence.source === expected);
+  }
+  if (/\bcode impact\b/i.test(actionText)) {
+    return passedEvidence.some((evidence) => /\bcode impact\b/i.test(judgmentEvidenceText(evidence)));
+  }
+  if (/\bverification gap\b/i.test(actionText)) {
+    return passedEvidence.some(
+      (evidence) => ["test", "typecheck", "lint", "build", "manual"].includes(evidence.source)
+    );
+  }
+  if (expected) {
+    return passedEvidence.some((evidence) => evidence.source === expected);
+  }
+  const tokens = judgmentTextTokens(actionText);
+  return passedEvidence.some((evidence) => {
+    const evidenceText = judgmentEvidenceText(evidence);
+    return tokens.some((token) => evidenceText.includes(token));
+  });
+}
+function unresolvedJudgmentReasonCodes(card, passedEvidence) {
+  const passedText = passedEvidence.map(judgmentEvidenceText).join(" ");
+  return card.reasons.flatMap((reason) => {
+    if (reason.code.startsWith("surface_unavailable_")) return [reason.code];
+    if (reason.code === "memory_health_low") return [reason.code];
+    if (reason.code === "code_impact_degraded" && !/\b(local (read|inspection)|code impact)\b/.test(passedText)) {
+      return [reason.code];
+    }
+    if (reason.code === "code_graph_stale" && !/\b(local (read|inspection)|code impact)\b/.test(passedText)) {
+      return [reason.code];
+    }
+    if (reason.code === "team_sync_proof_required" && !/\b(team sync|handoff)\b/.test(passedText)) {
+      return [reason.code];
+    }
+    return [];
+  });
+}
+function deriveManagedWorkflowJudgmentResolution(judgment, options = {}) {
+  const evidence = effectiveJudgmentEvidence(judgment, options.evidence ?? []);
+  const passedEvidence = evidence.filter((item) => item.status === "passed");
+  const failedEvidence = evidence.filter((item) => item.status === "failed");
+  const skippedEvidence = evidence.filter(
+    (item) => item.status === "skipped" || item.status === "warning"
+  );
+  const responsesByRecommendation = new Map(
+    judgment.responses.map((response) => [response.recommendationId, response])
+  );
+  const pendingExplicitRecommendations = judgment.card.advisorRecommendations.filter(
+    (recommendation) => !isPolicyAutoEligibleRecommendation(recommendation) && !responsesByRecommendation.has(recommendation.id)
+  );
+  const ignoredRiskRecommendations = judgment.card.advisorRecommendations.filter((recommendation) => {
+    const response = responsesByRecommendation.get(recommendation.id);
+    return recommendation.severity === "risk" && response?.decision === "ignored";
+  });
+  const ignoredBlockRecommendations = judgment.card.advisorRecommendations.filter(
+    (recommendation) => {
+      const response = responsesByRecommendation.get(recommendation.id);
+      return recommendation.severity === "block" && response?.decision === "ignored";
+    }
+  );
+  const unsatisfiedActions = judgment.card.requiredActions.filter(
+    (action) => !passedEvidenceSatisfiesAction(action, passedEvidence)
+  );
+  const unresolvedSignals = unresolvedJudgmentReasonCodes(judgment.card, passedEvidence);
+  const hardBlockerCodes = uniqueStrings23([
+    ...judgment.card.reasons.filter((reason) => reason.code === "guard_blocked").map((reason) => reason.code),
+    ...judgment.card.requiredActions.filter((action) => action.type === "resolve_blocker").map(() => "required_action_resolve_blocker"),
+    ...judgment.responses.filter((response) => response.decision === "blocked").map(() => "explicit_blocked_decision"),
+    ...pendingExplicitRecommendations.filter((recommendation) => recommendation.severity === "block").map(() => "pending_block_recommendation"),
+    ...ignoredBlockRecommendations.map(() => "ignored_block_recommendation"),
+    ...failedEvidence.length > 0 ? ["failed_verification_evidence"] : []
+  ]);
+  const reasonCodes = ["original_judgment_card_preserved"];
+  const autoResponseCount = judgment.responses.filter(
+    (response) => response.source === "policy_auto"
+  ).length;
+  if (autoResponseCount > 0) reasonCodes.push("low_risk_advisories_auto_accepted");
+  let state;
+  let canProceed;
+  if (hardBlockerCodes.length > 0) {
+    state = "blocked";
+    canProceed = "block";
+    reasonCodes.push(...hardBlockerCodes);
+  } else if (pendingExplicitRecommendations.some((recommendation) => recommendation.severity === "risk") || ignoredRiskRecommendations.length > 0 || unresolvedSignals.length > 0) {
+    state = "review";
+    canProceed = "review";
+    if (pendingExplicitRecommendations.some((item) => item.severity === "risk")) {
+      reasonCodes.push("pending_risk_recommendation");
+    }
+    if (ignoredRiskRecommendations.length > 0) reasonCodes.push("ignored_risk_recommendation");
+    if (unresolvedSignals.length > 0) reasonCodes.push("unresolved_review_signal");
+  } else {
+    const proofRequired = judgment.card.canProceed !== "yes" || judgment.card.requiredActions.length > 0;
+    const completedOutcome = options.outcome === "completed" || completedJudgmentOutcomeRecorded(judgment);
+    if (unsatisfiedActions.length > 0 || proofRequired && (!completedOutcome || passedEvidence.length === 0)) {
+      state = "proof_required";
+      canProceed = "review";
+      if (unsatisfiedActions.length > 0) reasonCodes.push("required_action_unsatisfied");
+      if (!completedOutcome) reasonCodes.push("workflow_outcome_incomplete");
+      if (passedEvidence.length === 0) reasonCodes.push("verification_evidence_missing");
+    } else if (judgment.card.state === "watch" || autoResponseCount > 0) {
+      state = "watch";
+      canProceed = "yes";
+      reasonCodes.push("required_actions_verified");
+    } else {
+      state = "ready";
+      canProceed = "yes";
+      reasonCodes.push("required_actions_verified");
+    }
+  }
+  return {
+    version: "snipara.workflow.judgment-resolution.v1",
+    evaluatedAt: options.evaluatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    state,
+    canProceed,
+    originalCard: {
+      generatedAt: judgment.card.generatedAt,
+      state: judgment.card.state,
+      canProceed: judgment.card.canProceed,
+      score: judgment.card.score
+    },
+    reasonCodes: uniqueStrings23(reasonCodes),
+    hardBlockerCodes,
+    pendingExplicitRecommendationIds: pendingExplicitRecommendations.map((item) => item.id),
+    autoResponseCount,
+    evidence: {
+      passedCount: passedEvidence.length,
+      failedCount: failedEvidence.length,
+      skippedCount: skippedEvidence.length,
+      requiredActionCount: judgment.card.requiredActions.length,
+      satisfiedRequiredActionCount: judgment.card.requiredActions.length - unsatisfiedActions.length,
+      unsatisfiedRequiredActions: unsatisfiedActions.map(
+        (action) => action.command ?? action.title
+      )
+    }
+  };
+}
+function updateManagedWorkflowJudgmentResolution(judgment, options = {}) {
+  applyManagedWorkflowPolicyAutoResponses(judgment, options.evaluatedAt);
+  judgment.resolution = deriveManagedWorkflowJudgmentResolution(judgment, options);
+  return judgment.resolution;
+}
 function workflowOutcomeSurfaces(files) {
   const surfaces = /* @__PURE__ */ new Set(["workflow"]);
   for (const file of files) {
@@ -34097,8 +34374,10 @@ function buildManagedWorkflowOutcomeReceipt(args) {
   });
 }
 async function closeManagedWorkflowJudgment(args) {
-  if (!args.state?.judgment || args.state.judgment.responses.length === 0) return [];
-  if (args.requireEvidence && workflowOutcomeEvidence(args.evidence).length === 0) return [];
+  if (!args.state?.judgment) return [];
+  const parsedEvidence = workflowOutcomeEvidence(args.evidence);
+  if (args.requireEvidence && parsedEvidence.length === 0) return [];
+  applyManagedWorkflowPolicyAutoResponses(args.state.judgment);
   const captures = [];
   for (const response of args.state.judgment.responses) {
     const outcomeReceipt = buildManagedWorkflowOutcomeReceipt({
@@ -34127,7 +34406,13 @@ async function closeManagedWorkflowJudgment(args) {
       captures.push(capture);
     }
   }
-  args.state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const evaluatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  updateManagedWorkflowJudgmentResolution(args.state.judgment, {
+    evidence: parsedEvidence,
+    outcome: args.outcome,
+    evaluatedAt
+  });
+  args.state.updatedAt = evaluatedAt;
   writeWorkflowState(args.state);
   return captures;
 }
@@ -34243,11 +34528,6 @@ async function workflowJudgmentCommand(options) {
     printManagedWorkflowJudgmentNextCommands(state);
     return;
   }
-  if (state.judgment?.responses.length) {
-    throw new Error(
-      "Cannot refresh a managed judgment after responses were recorded; start a new workflow for a new served judgment."
-    );
-  }
   const result = await buildProjectIntelligenceRun({
     task: state.goal,
     changedFiles: managedWorkflowJudgmentFiles(state),
@@ -34255,7 +34535,10 @@ async function workflowJudgmentCommand(options) {
     skipGuard: true,
     skipAdvisorReceipts: true
   });
-  state.judgment = {
+  if (state.judgment) {
+    state.judgmentHistory = [...state.judgmentHistory ?? [], state.judgment].slice(-5);
+  }
+  const judgment = {
     version: "snipara.workflow.judgment.v1",
     generatedAt: result.generatedAt,
     runEnvelope: result.runEnvelope,
@@ -34263,13 +34546,18 @@ async function workflowJudgmentCommand(options) {
     card: result.judgmentCard,
     responses: []
   };
+  const autoResponses = applyManagedWorkflowPolicyAutoResponses(judgment, result.generatedAt);
+  const resolution = updateManagedWorkflowJudgmentResolution(judgment, {
+    evaluatedAt: result.generatedAt
+  });
+  state.judgment = judgment;
   state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
   writeWorkflowState(state);
   appendActivityEvent({
     source: "workflow",
     kind: "workflow-judgment",
     title: state.judgment.card.summary,
-    summary: `${state.judgment.card.advisorRecommendations.length} advisor recommendation(s) served for explicit response.`,
+    summary: `${autoResponses.length} low-risk recommendation(s) accepted by policy; ${resolution.pendingExplicitRecommendationIds.length} recommendation(s) require explicit authority.`,
     workflowId: state.workflowId,
     files: state.judgment.brief.changedFiles,
     refs: [state.judgment.brief.servedJudgmentId].filter(Boolean),
@@ -34277,7 +34565,11 @@ async function workflowJudgmentCommand(options) {
     metadata: {
       state: state.judgment.card.state,
       canProceed: state.judgment.card.canProceed,
+      effectiveState: resolution.state,
+      effectiveCanProceed: resolution.canProceed,
       recommendationCount: state.judgment.card.advisorRecommendations.length,
+      autoResponseCount: autoResponses.length,
+      pendingExplicitRecommendationCount: resolution.pendingExplicitRecommendationIds.length,
       identityStatus: state.judgment.brief.servedJudgmentId ? "linked" : "missing"
     }
   });
@@ -34311,6 +34603,8 @@ async function workflowJudgmentRespondCommand(options) {
     recommendationId: recommendation.id,
     decision,
     respondedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    source: "explicit",
+    reasonCodes: ["explicit_agent_response"],
     ...planBefore ? { planBefore } : {},
     ...planAfter ? { planAfter } : {}
   };
@@ -34319,23 +34613,35 @@ async function workflowJudgmentRespondCommand(options) {
     response,
     trigger: "snipara-companion workflow judgment-respond"
   });
+  const supersededResponses = judgment.responses.filter(
+    (item) => item.recommendationId === recommendation.id
+  );
+  if (supersededResponses.length > 0) {
+    judgment.responseHistory = [...judgment.responseHistory ?? [], ...supersededResponses];
+  }
   judgment.responses = [
     ...judgment.responses.filter((item) => item.recommendationId !== recommendation.id),
     response
   ];
+  const resolution = updateManagedWorkflowJudgmentResolution(judgment, {
+    evaluatedAt: response.respondedAt
+  });
   state.updatedAt = response.respondedAt;
   writeWorkflowState(state);
   appendActivityEvent({
     source: "workflow",
     kind: "workflow-judgment-response",
     title: recommendation.title,
-    summary: `Agent explicitly ${decision} recommendation ${recommendation.id}.`,
+    summary: `Agent explicitly ${decision} recommendation ${recommendation.id}; effective judgment is ${resolution.state}.`,
     workflowId: state.workflowId,
     files: judgment.brief.changedFiles,
     refs: [judgment.brief.servedJudgmentId, recommendation.id].filter(Boolean),
     timestamp: response.respondedAt,
     metadata: {
       decision,
+      responseSource: response.source,
+      effectiveState: resolution.state,
+      effectiveCanProceed: resolution.canProceed,
       receiptStatus: response.initialReceipt?.status ?? "unavailable",
       recordedCount: response.initialReceipt?.recordedCount ?? 0
     }
@@ -34348,6 +34654,8 @@ async function workflowJudgmentRespondCommand(options) {
   console.log(import_chalk9.default.bold("Workflow judgment response"));
   printKeyValue2("Recommendation:", recommendation.id);
   printKeyValue2("Decision:", decision);
+  printKeyValue2("Source:", response.source);
+  printKeyValue2("Effective judgment:", `${resolution.state}/${resolution.canProceed}`);
   printKeyValue2("Receipt:", response.initialReceipt?.status ?? "unavailable");
   if (response.initialReceipt?.reason) {
     printKeyValue2("Reason:", response.initialReceipt.reason);
@@ -35599,22 +35907,27 @@ async function workflowPhaseCommitCommand(options) {
 }
 async function finalCommitCommand(options) {
   const state = readWorkflowState2();
-  const pendingJudgmentResponses = state?.judgment?.card.advisorRecommendations.filter(
-    (recommendation) => !state.judgment?.responses.some((response) => response.recommendationId === recommendation.id)
-  );
-  if (pendingJudgmentResponses && pendingJudgmentResponses.length > 0) {
-    throw new Error(
-      `Managed workflow judgment has ${pendingJudgmentResponses.length} unanswered recommendation(s): ${pendingJudgmentResponses.map((item) => item.id).join(
-        ", "
-      )}. Record accepted, modified, ignored, or blocked explicitly before final-commit.`
-    );
+  const outcome = options.outcome ?? "completed";
+  if (state?.judgment) {
+    const evaluatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const resolution = updateManagedWorkflowJudgmentResolution(state.judgment, {
+      evidence: workflowOutcomeEvidence(options.evidence),
+      outcome,
+      evaluatedAt
+    });
+    state.updatedAt = evaluatedAt;
+    writeWorkflowState(state);
+    if (outcome === "completed" && resolution.canProceed !== "yes") {
+      throw new Error(
+        `Managed workflow judgment is ${resolution.state}/${resolution.canProceed}. Pending authority: ${resolution.pendingExplicitRecommendationIds.join(", ") || "none"}. Hard blockers: ${resolution.hardBlockerCodes.join(", ") || "none"}. Unsatisfied actions: ${resolution.evidence.unsatisfiedRequiredActions.join(" | ") || "none"}. Respond to risk/block recommendations explicitly, clear hard blockers with a refreshed judgment, and attach passed evidence before final-commit.`
+      );
+    }
   }
   await memoryGuardCheckCommand({
     trigger: "pre-final",
     files: options.files,
     strict: true
   });
-  const outcome = options.outcome ?? "completed";
   const category = normalizeFinalCommitCategory(options.category);
   const structuredWhy = structuredTaskCommitWhy(options);
   const result = await commitFinalTaskMemory({
@@ -44669,6 +44982,7 @@ if (require.main === module) {
   agentReadinessAuditCommand,
   appendActivityEvent,
   applyLocalContextMutationPlan,
+  applyManagedWorkflowPolicyAutoResponses,
   archiveInactiveTeamSyncWork,
   attachLocalContextPackReceipts,
   autoArchiveTeamSyncState,
@@ -44766,6 +45080,7 @@ if (require.main === module) {
   createEmptyTeamSyncState,
   createLocalQueryCache,
   deriveLocalCollaborationResourcesFromFiles,
+  deriveManagedWorkflowJudgmentResolution,
   detectReleaseSurfacesFromFiles,
   detectRuntimeEnvironment,
   evalExportCommand,

package/docs/FULL_REFERENCE.md

@@ -1433,7 +1433,9 @@ package-review, and policy-gate diagnostics remain available in compatibility
 metadata, but they do not advance this lifecycle by themselves.
 
 Managed FULL workflows expose the same contract directly. Serve one bounded
-card before editing, then answer every recommendation explicitly:
+card before editing. Companion auto-accepts only `info` and `watch`
+recommendations with `source=policy_auto`; answer `risk` and `block`
+recommendations explicitly:
 
 ```bash
 snipara-companion workflow judgment
@@ -1450,9 +1452,25 @@ non-application decisions and cannot carry plan snapshots. Companion writes a
 targeted Advisor Influence receipt immediately, then idempotently replays that
 same `(served judgment, recommendation)` receipt when `workflow phase-commit`
 has explicit `--evidence` and again at `final-commit`. The backend preserves
-monotone lifecycle progress and owns canonical OutcomeSignal linking. A final
-commit fails closed while any served recommendation is unanswered; there is no
-implicit ignored receipt.
+monotone lifecycle progress and owns canonical OutcomeSignal linking.
+
+The stored card stays immutable. Companion appends
+`snipara.workflow.judgment-resolution.v1`, which reports the original state,
+effective state, reason codes, pending explicit recommendation ids, hard
+blockers, and per-action evidence coverage. A completed phase or final outcome
+can resolve verification-only warnings when passed evidence matches every
+required action. `run_check` matches its concrete test/typecheck/lint/build
+source; package and deployment reviews require package or guard/deploy proof;
+code-impact inspection and Team Sync handoff require matching labeled proof.
+Generic tests never resolve `resolve_blocker`. Failed evidence, `guard_blocked`,
+a `resolve_blocker` action, a pending `block` recommendation, or an explicit
+blocked decision remains non-proceedable. A completed final commit also fails
+closed while any `risk` or `block` recommendation lacks explicit authority.
+
+`workflow judgment --refresh` archives the prior card and response history
+locally before serving a new immutable card. Older Judgment V1 state files are
+normalized additively: missing response sources are treated as explicit, while
+eligible low-risk recommendations receive policy responses on load.
 
 `run` can also consume Outcome Intelligence V0 receipts:
 
@@ -1698,7 +1716,7 @@ Use this when the user's LLM has already produced a plan and Snipara should enfo
 
 1. Generate or save a visible plan into a JSON file. `snipara-companion plan --query "<goal>" --write-plan-file ./plan.json` converts hosted `snipara_plan` output into a managed workflow plan; keep a Markdown/Text copy only when you also want a human-facing contract alongside the machine plan. Keep simple Q&A and single-source lookups on targeted `snipara_context_query`; for FULL-mode audits, comparisons, roadmap/implementation planning, release readiness, or package-surface reviews, preserve the axes with `snipara_decompose` and execute independent follow-up questions with `snipara_multi_query` when those tools are exposed.
 2. Run `snipara-companion workflow start --goal "<goal>" --plan-file ./plan.json`.
-3. Run `snipara-companion workflow judgment`, then answer every served Advisor recommendation with `workflow judgment-respond <recommendation-id> --decision accepted|modified|ignored|blocked`. Use distinct `--plan-before` and `--plan-after` snapshots only for `modified`.
+3. Run `snipara-companion workflow judgment`. Companion handles `info`/`watch` recommendations with auditable policy responses; answer every `risk`/`block` recommendation with `workflow judgment-respond <recommendation-id> --decision accepted|modified|ignored|blocked`. Use distinct `--plan-before` and `--plan-after` snapshots only for `modified`.
 4. At each phase/chunk, run `snipara-companion workflow phase-start <phase_id>`, then `snipara-companion workflow run --mode full --query "<phase query>"`. Add `--include-session-context` after compaction, handoff, or another agent's work may matter.
 5. Before risky code changes, routes/services/jobs work, or any "what is missing" conclusion, run `snipara-companion code impact --changed-files <files...> --diff-summary "<change>"`. For an important symbol, run `snipara-companion code symbol-card --qualified-name <symbol>`.
 6. After compaction, first run `snipara-companion workflow resume --include-session-context`, then rerun `workflow judgment` to inspect the persisted card and `workflow phase-start <phase_id>` before editing again.

package/package.json

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