snipara-companion 3.4.1 → 3.5.1

package/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 Release notes for `snipara-companion`, newest first.
 
+## New In 3.5.1
+
+- Adds Context Control V1 hosted diff/apply commands for declarative
+  `snipara.project-context.json` sources.
+- Binds hosted mutations to tenant-scoped server plans, remote compare-and-set
+  hashes, explicit resolved Decision Requests, EDITOR API-key access, and
+  detailed apply/reindex receipts.
+- Keeps reconciliation add/update-only: unmanaged hosted documents are reported
+  but never deleted, managed authority promotions are blocked, and stale plans
+  fail before writes.
+- Makes local V0 `context-control apply` enforce its review flag through an
+  explicit `--approve` acknowledgement.
+
+## New In 3.5.0
+
+- Adds an explicit `workflow run --strong-repair` handoff contract for one
+  bounded strong-adapter repair after local proof or output failure.
+- Keeps Companion recommendation-only: it records final authority, proof,
+  scope, and `main_agent` fallback without silently launching workers.
+
 ## New In 3.4.1
 
 - Declares provider API keys by environment-variable name and supports

package/README.md

@@ -100,7 +100,7 @@ These commands are useful without hosted Snipara:
 | `workflow producer-triage`                                                            | Ask for human review of unreviewed Producer Loop samples                     |
 | `workflow producer-report`                                                            | Local Producer Loop adoption and calibration report                          |
 | `workflow producer-review`                                                            | Mark local Producer Loop samples reviewed or rejected                        |
-| `context-control plan` / `apply` / `drift` / `validate`                               | Preview/apply local context mutations, report drift, and validate manifests  |
+| `context-control plan` / `apply` / `drift` / `validate` / `hosted-*`                  | Review local state and reconcile Context as Code with hosted project context |
 | `context-pack`                                                                        | Reversible local packs for long logs, diffs, and tool output                 |
 | `judgment-card`, `verify`, `lead-plan`, `agent-readiness`                             | Local review artifacts and delegation contracts                              |
 | `intelligence ledger-export`                                                          | Structured redacted ledger JSON for replay and review                        |
@@ -111,8 +111,9 @@ These commands are useful without hosted Snipara:
 `context-control` is the local trust layer for Project Intelligence state. It
 borrows Terraform's useful product grammar without copying Terraform: preview a
 bounded context mutation, inspect drift, then apply only the exact reviewed
-plan. V0 is intentionally local-only: it creates trust artifacts for review, not
-hosted context mutations.
+plan. V0 remains the local trust-artifact layer. Context Control V1 adds an
+authenticated hosted diff/apply path with tenant scoping, compare-and-set hashes,
+explicit Decision Request approval, detailed receipts, and add/update-only writes.
 
 ```bash
 npx -y snipara-companion context-control plan \
@@ -120,7 +121,8 @@ npx -y snipara-companion context-control plan \
   --output .snipara/context-control/plans/demo.json
 
 npx -y snipara-companion context-control apply \
-  --plan .snipara/context-control/plans/demo.json
+  --plan .snipara/context-control/plans/demo.json \
+  --approve
 
 npx -y snipara-companion context-control drift
 ```
@@ -151,6 +153,21 @@ locally:
 }
 ```
 
+To reconcile that manifest with hosted project context, first write a reviewed
+plan and Decision Request, resolve the request, then apply the exact plan:
+
+```text
+snipara-companion context-control hosted-diff --manifest snipara.project-context.json --output .snipara/context-control/plans/hosted.json --emit-decision-request
+snipara-companion workflow decide <request-id> --choose approve_hosted_apply --reviewer <name>
+snipara-companion context-control hosted-apply --plan .snipara/context-control/plans/hosted.json --approval .snipara/decisions/resolved/<request-id>.json --output .snipara/context-control/applied/hosted.json
+```
+
+V1 never deletes remote documents. It reports hosted paths outside the manifest,
+blocks authority promotions on existing managed sources, rejects stale remote
+hashes, and requires an EDITOR-authorized API key for mutation. The local
+approval artifact records declared human review; the API key remains the actual
+hosted mutation authority.
+
 ```bash
 npx -y snipara-companion context-control validate --manifest snipara.project-context.json
 npx -y snipara-companion context-control plan --manifest snipara.project-context.json

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { AdvisorInfluenceLifecycle, ProjectIntentDetectionResult, ProjectPolicyDecision, ProjectRealityCheckResult, ContextMutationPlan, ContextMutationApplyReceipt, ProjectContextValidationReport, ProjectDriftReport, ProjectIntelligenceEngineeringLeadPlanSummary, ProjectPolicyRule, DecisionRequest, AdvisorInfluenceLifecycleState, OutcomeIntelligenceCalibration, ControlledWorkerExecutionMode, WorkerTrustCategory, ControlledWorkerExecutionReceipt, UnifiedReceiptEnvelope, WorkerTrustCandidate, WorkerProfile, WorkerTrustEvent } from '@snipara/project-intelligence-contracts';
+import { AdvisorInfluenceLifecycle, HostedContextControlSource, HostedContextControlPlan, HostedContextControlApplyReceipt, ProjectIntentDetectionResult, ProjectPolicyDecision, ProjectRealityCheckResult, ContextMutationPlan, ContextMutationApplyReceipt, ProjectContextValidationReport, ProjectDriftReport, ProjectIntelligenceEngineeringLeadPlanSummary, ProjectPolicyRule, DecisionRequest, AdvisorInfluenceLifecycleState, OutcomeIntelligenceCalibration, ControlledWorkerExecutionMode, WorkerTrustCategory, ControlledWorkerExecutionReceipt, UnifiedReceiptEnvelope, WorkerTrustCandidate, WorkerProfile, WorkerTrustEvent } from '@snipara/project-intelligence-contracts';
 
 declare function resolveQueryFromToolInput(toolInput?: string, tool?: string): string | null;
 
@@ -299,6 +299,22 @@ interface AnswerPack {
     };
     token_count?: number;
 }
+interface HostedContextControlDiffResponse {
+    project: {
+        id: string;
+        name: string;
+        slug: string;
+    };
+    plan: HostedContextControlPlan;
+}
+interface HostedContextControlApplyResponse {
+    project: {
+        id: string;
+        name: string;
+        slug: string;
+    };
+    receipt: HostedContextControlApplyReceipt;
+}
 interface CodeGraphNodeResult {
     symbol_key: string;
     qualified_name: string;
@@ -1439,6 +1455,14 @@ declare class RLMClient {
     createClientProject(options: CreateClientProjectOptions): Promise<Record<string, unknown>>;
     syncDocuments(documents: SyncDocumentInput[], deleteMissing?: boolean): Promise<Record<string, unknown>>;
     syncProjectPolicyLedger(artifacts: ProjectPolicyLedgerSyncArtifactInput[]): Promise<Record<string, unknown>>;
+    diffHostedContextControl(input: {
+        manifestHash: string;
+        sources: HostedContextControlSource[];
+    }): Promise<HostedContextControlDiffResponse>;
+    applyHostedContextControl(input: {
+        plan: HostedContextControlPlan;
+        approval?: unknown;
+    }): Promise<HostedContextControlApplyResponse>;
     reindex(options: {
         kind?: "doc" | "code";
         mode?: "incremental" | "full";
@@ -2167,6 +2191,14 @@ interface RealityCheckCommandOptions {
 declare function buildLocalProjectRealityCheck(options: RealityCheckCommandOptions): ProjectRealityCheckResult;
 declare function realityCheckCommand(options: RealityCheckCommandOptions): Promise<void>;
 
+interface DecisionRequestWriteResult {
+    status: "written" | "duplicate_pending" | "duplicate_resolved";
+    requestId: string;
+    fingerprint: string;
+    path?: string;
+    relativePath?: string;
+}
+
 interface ContextControlPlanCommandOptions {
     summary?: string;
     target?: string;
@@ -2180,6 +2212,19 @@ interface ContextControlPlanCommandOptions {
 interface ContextControlApplyCommandOptions {
     plan: string;
     allowStaleBase?: boolean;
+    approved?: boolean;
+    json?: boolean;
+}
+interface ContextControlHostedDiffCommandOptions {
+    manifest?: string;
+    output?: string;
+    emitDecisionRequest?: boolean;
+    json?: boolean;
+}
+interface ContextControlHostedApplyCommandOptions {
+    plan: string;
+    approval?: string;
+    output?: string;
     json?: boolean;
 }
 interface ContextControlDriftCommandOptions {
@@ -2219,14 +2264,8 @@ declare function contextControlPlanCommand(options: ContextControlPlanCommandOpt
 declare function contextControlApplyCommand(options: ContextControlApplyCommandOptions): Promise<void>;
 declare function contextControlDriftCommand(options: ContextControlDriftCommandOptions): Promise<void>;
 declare function contextControlValidateCommand(options: ContextControlValidateCommandOptions): Promise<void>;
-
-interface DecisionRequestWriteResult {
-    status: "written" | "duplicate_pending" | "duplicate_resolved";
-    requestId: string;
-    fingerprint: string;
-    path?: string;
-    relativePath?: string;
-}
+declare function contextControlHostedDiffCommand(options: ContextControlHostedDiffCommandOptions): Promise<void>;
+declare function contextControlHostedApplyCommand(options: ContextControlHostedApplyCommandOptions): Promise<void>;
 
 interface MemoryHealthCommandOptions {
     scope?: MemoryScope;
@@ -3238,6 +3277,14 @@ interface AdaptiveRoutingResolution {
     warnings?: string[];
     rejectedReasons?: Record<string, string[]>;
 }
+interface AdaptiveStrongRepairContract {
+    enabled: boolean;
+    maxAttempts: 1;
+    finalAuthority: "strong_adapter";
+    proofRequired: true;
+    scopePreserved: true;
+    fallback: "main_agent";
+}
 interface AdaptiveWorkRoutingRecommendation {
     workProfile: AdaptiveWorkProfile;
     requirements: AdaptiveModelRequirements;
@@ -3245,6 +3292,7 @@ interface AdaptiveWorkRoutingRecommendation {
     gateway?: AdaptiveRoutingGatewayStatus;
     runtimeCatalog?: AdaptiveRoutingRuntimeCatalog;
     resolution?: AdaptiveRoutingResolution;
+    strongRepair?: AdaptiveStrongRepairContract;
 }
 interface AdaptiveWorkRoutingOptions {
     query: string;
@@ -3259,6 +3307,7 @@ interface AdaptiveWorkRoutingOptions {
     catalogLimit?: number;
     dailyBudgetCents?: number;
     monthlyBudgetCents?: number;
+    strongRepair?: boolean;
 }
 interface OrchestratorHandoffArtifact {
     schemaVersion: "snipara.orchestrator.handoff.v1";
@@ -3289,6 +3338,7 @@ interface OrchestratorHandoffArtifact {
         gateway?: AdaptiveRoutingGatewayStatus;
         runtimeCatalog?: AdaptiveRoutingRuntimeCatalog;
         resolution?: AdaptiveRoutingResolution;
+        strongRepair?: AdaptiveStrongRepairContract;
     };
     task: {
         title: string;
@@ -4856,4 +4906,4 @@ declare function installAutomationBundle(args: {
 }): Promise<AutomationInstallResult>;
 declare function getAutomationStatus(projectDir?: string): AutomationStatusResult;
 
-export { 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, 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, 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, buildLocalCallersResult, buildLocalCodeOverlay, buildLocalContextMutationPlan, buildLocalContextPackReceipt, buildLocalContextPackReceipts, buildLocalImpactResult, buildLocalImportsResult, buildLocalNeighborsResult, buildLocalProjectContextValidationReport, buildLocalProjectDriftReport, buildLocalProjectRealityCheck, 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, contextControlPlanCommand, contextControlValidateCommand, contextPackCleanCommand, contextPackPackCommand, contextPackRetrieveCommand, contextPackStatsCommand, controlledWorkerExecuteCommand, createClient, createEmptyCollaborationState, createEmptyTeamSyncState, createLocalQueryCache, deriveLocalCollaborationResourcesFromFiles, detectReleaseSurfacesFromFiles, detectRuntimeEnvironment, evalExportCommand, evalRunCommand, evaluateProjectPolicyGates, extractCommandFromToolInput, extractFilesFromToolInput, 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, normalizeCollaborationFiles, normalizeGuardTag, normalizeWorkflowPlanInput, outcomeCapturePreviewCommand, packContext, parseCollaborationResources, projectIntelligenceBriefCommand, projectIntelligenceRunCommand, readActivityTimeline, readLocalCodeOverlayCache, readLocalCodePromotionState, readLocalSourceSnapshot, readLocalWorkersConfig, readSessionSnapshot, readWorkerTrustEvent, realityCheckCommand, referencesIngestCommand, referencesScanCommand, resolveAutoWorkflowMode, 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 { 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, 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, 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, buildLocalCallersResult, buildLocalCodeOverlay, buildLocalContextMutationPlan, buildLocalContextPackReceipt, buildLocalContextPackReceipts, buildLocalImpactResult, buildLocalImportsResult, buildLocalNeighborsResult, buildLocalProjectContextValidationReport, buildLocalProjectDriftReport, buildLocalProjectRealityCheck, 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, 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, normalizeCollaborationFiles, normalizeGuardTag, normalizeWorkflowPlanInput, outcomeCapturePreviewCommand, packContext, parseCollaborationResources, projectIntelligenceBriefCommand, projectIntelligenceRunCommand, readActivityTimeline, readLocalCodeOverlayCache, readLocalCodePromotionState, readLocalSourceSnapshot, readLocalWorkersConfig, readSessionSnapshot, readWorkerTrustEvent, realityCheckCommand, referencesIngestCommand, referencesScanCommand, resolveAutoWorkflowMode, 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

@@ -142,6 +142,8 @@ __export(index_exports, {
   completeTeamSyncWorkFromEvidence: () => completeTeamSyncWorkFromEvidence,
   contextControlApplyCommand: () => contextControlApplyCommand,
   contextControlDriftCommand: () => contextControlDriftCommand,
+  contextControlHostedApplyCommand: () => contextControlHostedApplyCommand,
+  contextControlHostedDiffCommand: () => contextControlHostedDiffCommand,
   contextControlPlanCommand: () => contextControlPlanCommand,
   contextControlValidateCommand: () => contextControlValidateCommand,
   contextPackCleanCommand: () => contextPackCleanCommand,
@@ -1609,6 +1611,26 @@ var RLMClient = class {
       }
     );
   }
+  async diffHostedContextControl(input) {
+    return this.dashboardProjectRequest(
+      "/context-control",
+      { method: "POST", body: { action: "diff", ...input } },
+      {
+        invalidMessage: "Invalid hosted Context Control diff response",
+        validate: (data) => Boolean(data.project?.id && data.plan?.planHash)
+      }
+    );
+  }
+  async applyHostedContextControl(input) {
+    return this.dashboardProjectRequest(
+      "/context-control",
+      { method: "POST", body: { action: "apply", ...input } },
+      {
+        invalidMessage: "Invalid hosted Context Control apply response",
+        validate: (data) => Boolean(data.project?.id && data.receipt?.receiptId)
+      }
+    );
+  }
   async reindex(options) {
     return this.mcpCall("snipara_reindex", {
       ...options.kind ? { kind: options.kind } : {},
@@ -11519,6 +11541,8 @@ var CONTEXT_MUTATION_APPLY_RECEIPT_VERSION = "snipara.context_mutation_apply_rec
 var PROJECT_DRIFT_REPORT_VERSION = "snipara.project_drift_report.v0";
 var PROJECT_CONTEXT_MANIFEST_VERSION = "snipara.project_context_manifest.v0";
 var PROJECT_CONTEXT_VALIDATION_VERSION = "snipara.project_context_validation.v0";
+var HOSTED_CONTEXT_CONTROL_PLAN_VERSION = "snipara.hosted_context_control_plan.v1";
+var HOSTED_CONTEXT_CONTROL_APPLY_RECEIPT_VERSION = "snipara.hosted_context_control_apply_receipt.v1";
 function buildContextMutationPlan(input) {
   const operations = normalizeOperations(input.operations);
   if (operations.length === 0) {
@@ -11637,6 +11661,14 @@ function validateProjectContextManifest(input) {
     ]
   };
 }
+function isHostedContextControlPlan(value) {
+  if (!isRecord4(value)) return false;
+  return value.schemaVersion === HOSTED_CONTEXT_CONTROL_PLAN_VERSION && typeof value.planId === "string" && typeof value.planHash === "string" && typeof value.createdAt === "string" && typeof value.projectId === "string" && typeof value.manifestHash === "string" && typeof value.approvalRequired === "boolean" && Array.isArray(value.sources) && Array.isArray(value.operations) && Array.isArray(value.unmanagedRemotePaths) && Array.isArray(value.warnings) && Array.isArray(value.caveats);
+}
+function isHostedContextControlApplyReceipt(value) {
+  if (!isRecord4(value)) return false;
+  return value.schemaVersion === HOSTED_CONTEXT_CONTROL_APPLY_RECEIPT_VERSION && typeof value.receiptId === "string" && typeof value.planId === "string" && typeof value.planHash === "string" && typeof value.projectId === "string" && typeof value.appliedAt === "string" && typeof value.status === "string" && Array.isArray(value.sources) && isRecord4(value.reindex) && Array.isArray(value.caveats);
+}
 function hashContextMutationPlanContent(value) {
   return hashDecisionJsonValue(value);
 }
@@ -14207,7 +14239,8 @@ function buildOrchestratorHandoff(options) {
         routingCard: options.adaptiveRouting.routingCard,
         ...options.adaptiveRouting.gateway ? { gateway: options.adaptiveRouting.gateway } : {},
         ...options.adaptiveRouting.runtimeCatalog ? { runtimeCatalog: options.adaptiveRouting.runtimeCatalog } : {},
-        ...options.adaptiveRouting.resolution ? { resolution: options.adaptiveRouting.resolution } : {}
+        ...options.adaptiveRouting.resolution ? { resolution: options.adaptiveRouting.resolution } : {},
+        ...options.adaptiveRouting.strongRepair ? { strongRepair: options.adaptiveRouting.strongRepair } : {}
       } : {}
     },
     task: {
@@ -14324,7 +14357,17 @@ function buildAdaptiveWorkRoutingRecommendation(options) {
   return {
     workProfile,
     requirements,
-    routingCard
+    routingCard,
+    ...options.strongRepair ? {
+      strongRepair: {
+        enabled: true,
+        maxAttempts: 1,
+        finalAuthority: "strong_adapter",
+        proofRequired: true,
+        scopePreserved: true,
+        fallback: "main_agent"
+      }
+    } : {}
   };
 }
 function inferAdaptiveTaskType(query, changedFiles) {
@@ -25167,6 +25210,10 @@ function printAdaptiveRoutingRecommendation(routing) {
   if (routing.requirements.plannerRetainsReasoning) {
     printKeyValue2("Planner retains reasoning:", "yes");
   }
+  if (routing.strongRepair?.enabled) {
+    printKeyValue2("Strong repair:", "one bounded attempt after proof/output failure");
+    printKeyValue2("Repair authority:", routing.strongRepair.finalAuthority);
+  }
   if (routing.gateway) {
     printKeyValue2(
       routing.gateway.source === "local_orchestrator" ? "Local route:" : "Hosted catalog:",
@@ -27501,7 +27548,7 @@ async function workflowRunCommand(options) {
 }
 function shouldBuildAdaptiveRouting(options) {
   return Boolean(
-    options.adaptiveRoutingDryRun || options.routeLocalWorkers || options.routingLocalWorker || options.routingWorkerRole || options.routingPreferredEndpoints?.length || options.routingAllowedEndpoints?.length || options.routingLocalBaseUrl || options.routingLocalModel || options.routingLocalPreferModel || options.routingLocalProvider || options.routingLocalApiKeyEnv || options.plannerRetainsReasoning
+    options.adaptiveRoutingDryRun || options.routeLocalWorkers || options.routingLocalWorker || options.routingWorkerRole || options.routingPreferredEndpoints?.length || options.routingAllowedEndpoints?.length || options.routingLocalBaseUrl || options.routingLocalModel || options.routingLocalPreferModel || options.routingLocalProvider || options.routingLocalApiKeyEnv || options.plannerRetainsReasoning || options.strongRepair
   );
 }
 function buildWorkflowAdaptiveRouting(options, policy = null, intentWarnings = []) {
@@ -27545,6 +27592,7 @@ function buildWorkflowAdaptiveRouting(options, policy = null, intentWarnings = [
     allowedEndpointTypes,
     workerRole,
     plannerRetainsReasoning: options.plannerRetainsReasoning ?? policy?.plannerRetainsReasoning ?? (options.routeLocalWorkers ? true : void 0),
+    strongRepair: options.strongRepair,
     catalogLimit: policy?.catalogLimit ?? DEFAULT_ADAPTIVE_ROUTING_CATALOG_LIMIT,
     dailyBudgetCents: policy?.dailyBudgetCents,
     monthlyBudgetCents: policy?.monthlyBudgetCents
@@ -35221,6 +35269,24 @@ function applyLocalContextMutationPlan(options) {
     });
     return { plan, receipt: receipt2, writtenFiles: [] };
   }
+  if (plan.approvalRequired && !options.approved) {
+    const receipt2 = buildContextMutationApplyReceipt({
+      plan,
+      appliedAt: options.now,
+      status: "blocked",
+      baseRevisionAtApply: resolveGitBaseRevision(cwd),
+      skippedOperations: plan.operations.map((operation) => ({
+        opId: operation.opId,
+        kind: operation.kind,
+        target: operation.target,
+        status: "skipped",
+        contentHash: operation.contentHash,
+        message: "Explicit --approve acknowledgement was not provided."
+      })),
+      caveats: ["Re-run context-control apply with --approve after reviewing the plan."]
+    });
+    return { plan, receipt: receipt2, writtenFiles: [] };
+  }
   const currentRevision = resolveGitBaseRevision(cwd);
   const staleBase = Boolean(plan.baseRevision.headSha && currentRevision.headSha) && plan.baseRevision.headSha !== currentRevision.headSha;
   if (staleBase && !options.allowStaleBase) {
@@ -35742,6 +35808,155 @@ async function contextControlValidateCommand(options) {
     process.exitCode = 1;
   }
 }
+function resolveHostedContextSources(cwd, manifestPath, report) {
+  if (!report.manifest || report.status === "invalid") {
+    throw new Error("ProjectContext manifest is invalid; run context-control validate first.");
+  }
+  const workspaceRoot2 = fs33.realpathSync(cwd);
+  return report.manifest.sources.map((source2) => {
+    const candidate = path33.resolve(cwd, source2.path);
+    if (!fs33.existsSync(candidate)) {
+      throw new Error(`ProjectContext source is missing: ${source2.path}`);
+    }
+    if (fs33.lstatSync(candidate).isSymbolicLink()) {
+      throw new Error(`ProjectContext source symlinks are not allowed: ${source2.path}`);
+    }
+    const canonical = fs33.realpathSync(candidate);
+    if (canonical !== workspaceRoot2 && !canonical.startsWith(`${workspaceRoot2}${path33.sep}`)) {
+      throw new Error(`ProjectContext source escapes the workspace: ${source2.path}`);
+    }
+    if (!fs33.statSync(canonical).isFile()) {
+      throw new Error(`ProjectContext source must be a file: ${source2.path}`);
+    }
+    const content = fs33.readFileSync(canonical, "utf8");
+    if (Buffer.byteLength(content, "utf8") > 1e6) {
+      throw new Error(`ProjectContext source exceeds 1 MB: ${source2.path}`);
+    }
+    return { ...source2, content };
+  });
+}
+async function contextControlHostedDiffCommand(options) {
+  const cwd = process.cwd();
+  const manifestPath = resolveManifestPath(cwd, options.manifest);
+  const report = buildLocalProjectContextValidationReport({ cwd, manifest: manifestPath });
+  const sources = resolveHostedContextSources(cwd, manifestPath, report);
+  const response = await createClient(6e4, { cwd }).diffHostedContextControl({
+    manifestHash: report.manifestHash,
+    sources
+  });
+  const result = {
+    project: response.project,
+    plan: response.plan
+  };
+  if (options.output) {
+    const planPath = path33.resolve(cwd, options.output);
+    writeStableJsonFile(planPath, response.plan);
+    result.planPath = toProjectRelativePath4(planPath, cwd);
+  }
+  if (options.emitDecisionRequest && response.plan.approvalRequired) {
+    if (response.plan.operations.some((operation) => operation.action === "blocked")) {
+      throw new Error("Blocked hosted operations must be removed before requesting approval.");
+    }
+    const request = buildDecisionRequest({
+      producer: {
+        kind: "hosted_context_control",
+        command: "context-control hosted-diff --emit-decision-request",
+        sourceRef: response.plan.planId
+      },
+      decision: "Apply reviewed ProjectContext sources to hosted context",
+      question: `Approve hosted Context Control plan ${response.plan.planId}?`,
+      evidence: {
+        summary: `${response.plan.operations.filter((operation) => operation.action === "create").length} create, ${response.plan.operations.filter((operation) => operation.action === "update").length} update, zero deletes.`,
+        refs: [response.plan.planHash, toProjectRelativePath4(manifestPath, cwd)],
+        items: [
+          {
+            ref: response.plan.planId,
+            title: "Hosted Context Control plan",
+            kind: "hosted_context_control_plan",
+            metadata: {
+              planHash: response.plan.planHash,
+              projectId: response.plan.projectId
+            }
+          }
+        ],
+        reasonCodes: ["hosted_context_control_apply", "human_approval_required", "no_delete"],
+        files: response.plan.sources.map((source2) => source2.path),
+        applyPath: "context-control hosted-apply",
+        applyCommand: `snipara-companion context-control hosted-apply --plan ${options.output ?? "<plan.json>"} --approval <resolved-decision.json>`
+      },
+      options: ["approve_hosted_apply", "reject_hosted_apply"],
+      recommendation: "approve_hosted_apply",
+      rationale: "The plan is bounded to reviewed add/update operations and contains no deletes.",
+      blocking: true,
+      expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1e3),
+      fingerprintParts: [
+        "hosted_context_control",
+        response.plan.projectId,
+        response.plan.planHash,
+        response.plan.operations.map((operation) => ({
+          path: operation.path,
+          action: operation.action,
+          contentHash: operation.contentHash,
+          previousHash: operation.previousHash ?? null
+        }))
+      ]
+    });
+    result.decisionRequest = writeDecisionRequest(request, cwd);
+  }
+  if (options.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log(import_chalk13.default.bold("Hosted Context Control Diff"));
+  console.log(`Project: ${response.project.name} (${response.project.id})`);
+  console.log(`Plan: ${response.plan.planId}`);
+  console.log(`Hash: ${response.plan.planHash}`);
+  for (const operation of response.plan.operations) {
+    console.log(`- ${operation.action} ${operation.path}`);
+  }
+  if (result.planPath) console.log(`Plan written: ${result.planPath}`);
+  if (result.decisionRequest?.relativePath) {
+    console.log(`Decision Request: ${result.decisionRequest.relativePath}`);
+  }
+}
+async function contextControlHostedApplyCommand(options) {
+  const cwd = process.cwd();
+  const rawPlan = readJsonFile4(path33.resolve(cwd, options.plan));
+  if (!isHostedContextControlPlan(rawPlan)) {
+    throw new Error(`Invalid hosted Context Control plan: ${options.plan}`);
+  }
+  const approval = options.approval ? readJsonFile4(path33.resolve(cwd, options.approval)) : void 0;
+  const response = await createClient(12e4, { cwd }).applyHostedContextControl({
+    plan: rawPlan,
+    approval
+  });
+  if (!isHostedContextControlApplyReceipt(response.receipt)) {
+    throw new Error("Hosted Context Control apply returned an invalid receipt.");
+  }
+  const result = {
+    project: response.project,
+    receipt: response.receipt
+  };
+  if (options.output) {
+    const receiptPath = path33.resolve(cwd, options.output);
+    writeStableJsonFile(receiptPath, response.receipt);
+    result.receiptPath = toProjectRelativePath4(receiptPath, cwd);
+  }
+  if (options.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log(import_chalk13.default.bold("Hosted Context Control Apply"));
+  console.log(`Status: ${response.receipt.status}`);
+  console.log(`Receipt: ${response.receipt.receiptId}`);
+  for (const source2 of response.receipt.sources) {
+    console.log(`- ${source2.action} ${source2.path}`);
+  }
+  if (result.receiptPath) console.log(`Receipt written: ${result.receiptPath}`);
+  if (response.receipt.reindex.warning) {
+    console.log(import_chalk13.default.yellow(`Reindex warning: ${response.receipt.reindex.warning}`));
+  }
+}
 function uniqueStrings22(values) {
   return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
 }
@@ -38658,13 +38873,33 @@ contextControl.command("plan").description("Create a previewable local context m
     json: Boolean(options.json)
   });
 });
-contextControl.command("apply").description("Apply a saved local context mutation plan idempotently").requiredOption("--plan <file>", "Plan JSON produced by context-control plan").option("--allow-stale-base", "Apply even when Git HEAD changed since planning").option("--json", "Print raw JSON").action(async (options) => {
+contextControl.command("apply").description("Apply a saved local context mutation plan idempotently").requiredOption("--plan <file>", "Plan JSON produced by context-control plan").option("--approve", "Acknowledge manual review when the local plan requires approval").option("--allow-stale-base", "Apply even when Git HEAD changed since planning").option("--json", "Print raw JSON").action(async (options) => {
   await contextControlApplyCommand({
     plan: options.plan,
+    approved: Boolean(options.approve),
     allowStaleBase: Boolean(options.allowStaleBase),
     json: Boolean(options.json)
   });
 });
+contextControl.command("hosted-diff").description("Compare a local ProjectContext manifest with tenant-scoped hosted context").option("--manifest <file>", "ProjectContext manifest path", "snipara.project-context.json").option("-o, --output <file>", "Write the immutable hosted plan JSON").option(
+  "--emit-decision-request",
+  "Write a pending Decision Request bound to the hosted plan hash"
+).option("--json", "Print raw JSON").action(async (options) => {
+  await contextControlHostedDiffCommand({
+    manifest: options.manifest,
+    output: options.output,
+    emitDecisionRequest: Boolean(options.emitDecisionRequest),
+    json: Boolean(options.json)
+  });
+});
+contextControl.command("hosted-apply").description("Apply an approved add/update-only hosted Context Control plan").requiredOption("--plan <file>", "Plan JSON produced by context-control hosted-diff").option("--approval <file>", "Resolved Decision Request artifact for mutating plans").option("-o, --output <file>", "Write the hosted apply receipt JSON").option("--json", "Print raw JSON").action(async (options) => {
+  await contextControlHostedApplyCommand({
+    plan: options.plan,
+    approval: options.approval,
+    output: options.output,
+    json: Boolean(options.json)
+  });
+});
 contextControl.command("drift").description("Report local project drift across git, workflow, decisions, and context plans").option("--json", "Print raw JSON").action(async (options) => {
   await contextControlDriftCommand({ json: Boolean(options.json) });
 });
@@ -38959,6 +39194,9 @@ workflow.command("run").description("Run a LITE/STANDARD/FULL/orchestrate workfl
 ).option(
   "--planner-retains-reasoning",
   "Mark the main planner as retaining deep reasoning while the worker executes scoped work"
+).option(
+  "--strong-repair",
+  "Allow one bounded strong-adapter repair after local proof or output validation fails"
 ).option("--write-plan-file <file>", "Write the generated FULL-mode plan as workflow JSON").option(
   "--start-workflow-from-plan",
   "Start a local managed workflow from the generated FULL-mode plan"
@@ -38987,6 +39225,7 @@ workflow.command("run").description("Run a LITE/STANDARD/FULL/orchestrate workfl
     routingLocalApiKeyEnv: options.routingLocalApiKeyEnv,
     routingLocalApiKeyHeader: options.routingLocalApiKeyHeader,
     plannerRetainsReasoning: options.plannerRetainsReasoning ? true : void 0,
+    strongRepair: Boolean(options.strongRepair),
     writePlanFile: options.writePlanFile,
     startWorkflowFromPlan: Boolean(options.startWorkflowFromPlan),
     workflowId: options.workflowId,
@@ -40118,6 +40357,8 @@ if (require.main === module) {
   completeTeamSyncWorkFromEvidence,
   contextControlApplyCommand,
   contextControlDriftCommand,
+  contextControlHostedApplyCommand,
+  contextControlHostedDiffCommand,
   contextControlPlanCommand,
   contextControlValidateCommand,
   contextPackCleanCommand,

package/docs/FULL_REFERENCE.md

@@ -233,7 +233,7 @@ snipara-companion workflow producer-report
 snipara-companion workflow producer-review --latest --outcome useful --reviewer alice
 snipara-companion workflow run --adaptive-routing-dry-run --route-local-workers "document a scoped change"
 snipara-companion context-control plan --summary "record reviewed context state" --output .snipara/context-control/plans/demo.json
-snipara-companion context-control apply --plan .snipara/context-control/plans/demo.json
+snipara-companion context-control apply --plan .snipara/context-control/plans/demo.json --approve
 snipara-companion context-control drift
 snipara-companion context-control validate --manifest snipara.project-context.json
 snipara-companion lead-plan --task "ship auth hardening" --changed-files src/auth.ts --proof "pnpm test auth" --acceptance "auth tests pass"
@@ -339,8 +339,9 @@ snipara-companion workflow resume --include-session-context
 - `context-control plan` writes a content-hashed local Context Mutation Plan V0
   for a bounded operation. The plan records the Git base and remains a preview
   until `context-control apply` writes the exact planned state.
-- `context-control apply --plan <file>` verifies the plan hash, rejects stale
-  Git bases by default, writes only under `.snipara/context-control/`, and emits
+- `context-control apply --plan <file> --approve` verifies the plan hash, records
+  explicit review, rejects stale Git bases by default, writes only under
+  `.snipara/context-control/`, and emits
   an apply receipt linked to the plan hash.
 - `context-control drift` is a read-only Project Drift V0 report. It checks Git
   upstream state, scoped Git dirty files, managed workflow state, pending
@@ -352,9 +353,21 @@ snipara-companion workflow resume --include-session-context
   `IN_SYNC`.
 - `context-control validate --manifest snipara.project-context.json` validates
   Context as Code V0. The manifest is JSON metadata declaring context sources,
-  tiers, authority, freshness, and review policies. It does not upload content,
-  refresh hosted context, reconcile manifest-vs-hosted state, or mutate hosted
-  Snipara state; hosted refresh/apply belongs to the future V1 surface.
+  tiers, authority, freshness, and review policies. Validation itself does not
+  upload content or mutate hosted state.
+- Context Control V1 uses `context-control hosted-diff` to produce a
+  tenant-scoped immutable plan and optional Decision Request, then
+  `context-control hosted-apply` to apply the resolved plan. The server rechecks
+  remote hashes atomically, allows only create/update, never deletes unmanaged
+  remote paths, blocks managed authority promotions, requires EDITOR API-key
+  access, and returns a per-source receipt plus reindex status.
+
+```text
+$ snipara-companion context-control hosted-diff --manifest snipara.project-context.json --output .snipara/context-control/plans/hosted.json --emit-decision-request
+$ snipara-companion workflow decide <request-id> --choose approve_hosted_apply --reviewer <name>
+$ snipara-companion context-control hosted-apply --plan .snipara/context-control/plans/hosted.json --approval .snipara/decisions/resolved/<request-id>.json
+```
+
 - `lead-plan` turns local workflow state, Team Sync, file scope, context refs,
   proof gates, and acceptance criteria into an advisory Engineering Lead Plan.
   It emits worker recommendations and handoff contracts, keeps
@@ -421,6 +434,7 @@ snipara-companion workflow run \
   --routing-allowed-endpoint local \
   --routing-allowed-endpoint cloud \
   --planner-retains-reasoning \
+  --strong-repair \
   "Update documentation for the new gateway"
 ```
 
@@ -523,6 +537,12 @@ routing/handoff contract: Companion resolves the local candidate through
 `snipara-orchestrator`, records metadata, and leaves execution plus proof review
 to the supervising agent workflow.
 
+Add `--strong-repair` when the supervising workflow should permit one strong
+adapter repair after a local proof or output failure. The handoff records the
+contract (`maxAttempts: 1`, same scope and proof, strong adapter as final
+authority, `main_agent` fallback); Companion remains recommendation-only and
+does not launch the worker.
+
 Use Qwen for reflection, architecture, and documentation:
 
 ```bash
@@ -576,6 +596,21 @@ snipara-orchestrator host run \
   --write-scope docs/** --proof "git diff --check" --execute
 ```
 
+For a loopback local worker with one explicit strong repair attempt:
+
+```bash
+snipara-orchestrator host run \
+  --adapter openai_compatible --base-url http://127.0.0.1:1234 \
+  --model local/coder --task "Bounded task" --workspace . \
+  --write-scope docs/** --proof "git diff --check" \
+  --strong-repair --repair-adapter codex_app_server --execute
+```
+
+The repair reuses the approval envelope when approval is required, reruns the
+same proof, and records redacted repair metrics in the durable host receipt.
+Scope violations, unavailable repair hosts, skipped proof, or a failed repair
+escalate without a retry loop.
+
 Native host proof commands run automatically after dispatch. Use
 `--no-run-proof` only when a reviewer will validate the receipt; the state then
 remains `verification_required`. Use `--require-approval` with both an approval

package/package.json

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