snipara-companion 3.5.0 → 3.5.2

package/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 Release notes for `snipara-companion`, newest first.
 
+## New In 3.5.2
+
+- Replaces the retired Windsurf preset with Kimi Code CLI across setup,
+  automation, readiness, handoff, and help surfaces.
+- Adds merge-safe `.kimi-code/mcp.json` installation plus a reviewable Kimi
+  plugin bundle for Companion lifecycle hooks, skills, and commands.
+- Keeps the Kimi adapter fail-open and requires explicit plugin installation;
+  risky tool approval and Hosted MCP tenant boundaries remain authoritative.
+
+## 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

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;
@@ -2357,7 +2396,7 @@ declare function memoryLocalCommand(options: LocalMemoryCommandOptions): Promise
 declare function evalExportCommand(options: EvalExportOptions): Promise<void>;
 declare function evalRunCommand(options: EvalRunOptions): Promise<void>;
 
-type AgentReadinessTarget = "codex" | "claude-code" | "cursor" | "orca" | "windsurf" | "custom";
+type AgentReadinessTarget = "codex" | "claude-code" | "cursor" | "orca" | "kimi" | "custom";
 type AgentReadinessCheckStatus = "pass" | "warning" | "fail" | "manual";
 type AgentReadinessGapSeverity = "low" | "medium" | "high" | "blocker";
 type AgentReadinessScoreBand = "ready" | "mostly_ready" | "needs_hardening" | "blocked";
@@ -3507,7 +3546,7 @@ interface TeamSyncSweepExplanation {
     remainingStaleCount: number;
     message: string;
 }
-type AgenticHandoffAdapterTarget = "codex" | "claude-code" | "cursor" | "orca" | "windsurf" | "custom";
+type AgenticHandoffAdapterTarget = "codex" | "claude-code" | "cursor" | "orca" | "kimi" | "custom";
 type AgenticHandoffConflictPosture = "continue" | "wait" | "split_work" | "review_only" | "handoff";
 interface AgenticHandoffAdapterPack {
     version: "snipara.ade_adapter_pack.v1";
@@ -4867,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,
@@ -271,7 +273,7 @@ var WORKSPACE_MARKERS = [
   ".snipara",
   ".claude",
   ".cursor",
-  ".windsurf",
+  ".kimi-code",
   ".vibe",
   "package.json",
   "pnpm-workspace.yaml",
@@ -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 } : {},
@@ -1707,7 +1729,7 @@ var SUPPORTED_CLIENTS = /* @__PURE__ */ new Set([
   "claude-code",
   "cursor",
   "continue",
-  "windsurf",
+  "kimi",
   "gemini",
   "mistral",
   "chatgpt",
@@ -1730,18 +1752,11 @@ var MERGEABLE_JSON_CONFIG_FILES = /* @__PURE__ */ new Set([
   ".cursor/hooks.json",
   ".cursor/mcp.json",
   ".gemini/settings.json",
+  ".kimi-code/mcp.json",
   ".vscode/mcp.json",
-  ".windsurf/cascade-hooks.json",
-  ".windsurf/mcp.json",
   "mcp.json"
 ]);
-var NATIVE_HOOK_CAPABLE_CLIENTS = /* @__PURE__ */ new Set([
-  "claude-code",
-  "cursor",
-  "windsurf",
-  "gemini",
-  "codex"
-]);
+var NATIVE_HOOK_CAPABLE_CLIENTS = /* @__PURE__ */ new Set(["claude-code", "cursor", "kimi", "gemini", "codex"]);
 var LOCAL_API_KEY_LOADER = `API_KEY=""
 if command -v node >/dev/null 2>&1; then
   SNIPARA_CONFIG_ROOT="\${PROJECT_DIR:-$(pwd)}"
@@ -1809,7 +1824,8 @@ function ensureSupportedClient(client) {
 }
 function configuredAutomationClient(projectDir) {
   const config = loadConfig({ cwd: projectDir });
-  return config.client && SUPPORTED_CLIENTS.has(config.client) ? config.client : void 0;
+  const client = config.client === "windsurf" ? "custom" : config.client;
+  return client && SUPPORTED_CLIENTS.has(client) ? client : void 0;
 }
 function resolveAutomationClient(args) {
   const configuredClient = configuredAutomationClient(args.projectDir);
@@ -1975,7 +1991,7 @@ function withLocalApiKeyLoader(file) {
 }
 function isNativeHookFilePath(filePath) {
   const normalized = normalizeRelativePath(filePath);
-  return normalized.startsWith(".claude/hooks/") || normalized.startsWith(".cursor/hooks/") || normalized === ".cursor/hooks.json" || normalized.startsWith(".windsurf/hooks/") || normalized === ".windsurf/cascade-hooks.json" || normalized.startsWith(".gemini/hooks/") || normalized.startsWith(".codex/hooks/") || normalized === ".codex/hooks.json" || normalized.startsWith(".vscode/hooks/");
+  return normalized.startsWith(".claude/hooks/") || normalized.startsWith(".cursor/hooks/") || normalized === ".cursor/hooks.json" || normalized.startsWith(".kimi-code/snipara-plugin/") || normalized.startsWith(".gemini/hooks/") || normalized.startsWith(".codex/hooks/") || normalized === ".codex/hooks.json" || normalized.startsWith(".vscode/hooks/");
 }
 function assertBundleCompatibleWithClient(client, bundle) {
   if (canInstallNativeHookBundle(client)) {
@@ -5479,7 +5495,7 @@ function appendDeviceFlowHints(url, hints) {
 }
 function setupClientToDeviceClientId(client) {
   const normalized = typeof client === "string" ? client.trim().toLowerCase() : void 0;
-  if (normalized === "claude-code" || normalized === "cursor" || normalized === "windsurf" || normalized === "gemini" || normalized === "codex" || normalized === "mistral" || normalized === "continue") {
+  if (normalized === "claude-code" || normalized === "cursor" || normalized === "kimi" || normalized === "gemini" || normalized === "codex" || normalized === "mistral" || normalized === "continue") {
     return normalized;
   }
   return PROJECT_DEVICE_CLIENT_ID;
@@ -5578,7 +5594,7 @@ async function runProjectDeviceAuthorization(args) {
 var SETUP_CLIENTS = /* @__PURE__ */ new Set([
   "claude-code",
   "cursor",
-  "windsurf",
+  "kimi",
   "codex",
   "gemini",
   "mistral",
@@ -5594,13 +5610,13 @@ function maybeNormalizeClient(input) {
   return SETUP_CLIENTS.has(input) ? input : void 0;
 }
 function isHookClient(client) {
-  return client === "claude-code" || client === "cursor" || client === "windsurf" || client === "gemini" || client === "codex";
+  return client === "claude-code" || client === "cursor" || client === "kimi" || client === "gemini" || client === "codex";
 }
 function canInstallNativeHookClient(client) {
-  return client === "claude-code" || client === "cursor" || client === "windsurf" || client === "gemini" || client === "codex";
+  return client === "claude-code" || client === "cursor" || client === "kimi" || client === "gemini" || client === "codex";
 }
 function canUseLegacyHookFallback(client) {
-  return client === "claude-code" || client === "cursor" || client === "windsurf";
+  return client === "claude-code" || client === "cursor";
 }
 function getNativeHookBlockReason(client) {
   if (canInstallNativeHookClient(client)) {
@@ -5619,7 +5635,7 @@ function formatClientName(client) {
   const names = {
     "claude-code": "Claude Code",
     cursor: "Cursor",
-    windsurf: "Windsurf",
+    kimi: "Kimi Code CLI",
     codex: "OpenAI Codex",
     gemini: "Gemini",
     mistral: "Mistral Le Chat / Vibe",
@@ -5942,6 +5958,21 @@ env_http_headers = { "X-Snipara-Session-Id" = "SNIPARA_SESSION_ID" }
 `;
 }
 function generateGenericMcpReferenceString(client, projectSlug) {
+  if (client === "kimi") {
+    return `${JSON.stringify(
+      {
+        mcpServers: {
+          snipara: {
+            url: `https://api.snipara.com/mcp/${projectSlug}`,
+            bearerTokenEnvVar: "SNIPARA_API_KEY"
+          }
+        }
+      },
+      null,
+      2
+    )}
+`;
+  }
   if (client === "chatgpt") {
     return `${JSON.stringify(
       {
@@ -6090,10 +6121,16 @@ function generateHookConfigString(client, projectSlug = "YOUR_PROJECT_SLUG") {
   if (client === "cursor") {
     return JSON.stringify(generateCursorHookConfig(), null, 2);
   }
+  if (client === "kimi") {
+    return generateGenericMcpReferenceString(client, projectSlug);
+  }
   if (!canInstallNativeHookClient(client)) {
     return generateGenericMcpReferenceString(client, projectSlug);
   }
-  const config = client === "windsurf" ? generateWindsurfHookConfig() : generateClaudeHookConfig({ preserveOnCompaction: true, restoreOnSessionStart: true });
+  const config = generateClaudeHookConfig({
+    preserveOnCompaction: true,
+    restoreOnSessionStart: true
+  });
   return JSON.stringify(config, null, 2);
 }
 function generateClaudeHookPreamble(description) {
@@ -6330,51 +6367,6 @@ else
 fi
 `;
 }
-function generateWindsurfHookConfig() {
-  return {
-    hooks: {
-      pre_read_code: { command: ".windsurf/hooks/pre-read.sh", timeout: 10 },
-      post_read_code: { command: ".windsurf/hooks/post-read.sh", timeout: 5 },
-      post_write_code: { command: ".windsurf/hooks/post-write.sh", timeout: 5 }
-    }
-  };
-}
-function generateWindsurfPreReadScript() {
-  return `#!/bin/bash
-# Windsurf pre_read_code Hook for Snipara Context Injection
-
-INPUT=$(cat)
-if [ -z "$INPUT" ]; then
-  exit 0
-fi
-
-snipara-companion pre-tool "$INPUT" || true
-`;
-}
-function generateWindsurfPostReadScript() {
-  return `#!/bin/bash
-# Windsurf post_read_code Hook for Snipara File Tracking
-
-INPUT=$(cat)
-if [ -z "$INPUT" ]; then
-  exit 0
-fi
-
-snipara-companion post-tool "$INPUT" || true
-`;
-}
-function generateWindsurfPostWriteScript() {
-  return `#!/bin/bash
-# Windsurf post_write_code Hook for Snipara File Tracking
-
-INPUT=$(cat)
-if [ -z "$INPUT" ]; then
-  exit 0
-fi
-
-snipara-companion post-tool "$INPUT" || true
-`;
-}
 function installHooks(projectDir, projectId, _apiKey, client) {
   try {
     if (client === "cursor") {
@@ -6402,28 +6394,6 @@ function installHooks(projectDir, projectId, _apiKey, client) {
       fs8.writeFileSync(hooksPath, JSON.stringify(generateCursorHookConfig(), null, 2));
       return { success: true };
     }
-    if (client === "windsurf") {
-      const windsurfDir = path8.join(projectDir, ".windsurf");
-      const hooksDir2 = path8.join(windsurfDir, "hooks");
-      const hooksPath = path8.join(windsurfDir, "cascade-hooks.json");
-      if (!fs8.existsSync(windsurfDir)) {
-        fs8.mkdirSync(windsurfDir, { recursive: true });
-      }
-      if (!fs8.existsSync(hooksDir2)) {
-        fs8.mkdirSync(hooksDir2, { recursive: true });
-      }
-      const preReadPath = path8.join(hooksDir2, "pre-read.sh");
-      fs8.writeFileSync(preReadPath, generateWindsurfPreReadScript());
-      fs8.chmodSync(preReadPath, "755");
-      const postReadPath = path8.join(hooksDir2, "post-read.sh");
-      fs8.writeFileSync(postReadPath, generateWindsurfPostReadScript());
-      fs8.chmodSync(postReadPath, "755");
-      const postWritePath = path8.join(hooksDir2, "post-write.sh");
-      fs8.writeFileSync(postWritePath, generateWindsurfPostWriteScript());
-      fs8.chmodSync(postWritePath, "755");
-      fs8.writeFileSync(hooksPath, JSON.stringify(generateWindsurfHookConfig(), null, 2));
-      return { success: true };
-    }
     const claudeDir = path8.join(projectDir, ".claude");
     const hooksDir = path8.join(claudeDir, "hooks");
     const settingsPath = path8.join(claudeDir, "settings.json");
@@ -6682,9 +6652,11 @@ async function initCommand(options) {
       console.log(
         "Add this to .cursor/hooks.json, or rerun with --with-hooks to install the full bundle:\n"
       );
-    } else if (hookClient === "windsurf") {
-      console.log("\n\u{1F4DD} Windsurf Hook Configuration\n");
-      console.log("Add this to your .windsurf/cascade-hooks.json:\n");
+    } else if (hookClient === "kimi") {
+      console.log("\n\u{1F4DD} Kimi Code CLI MCP Configuration\n");
+      console.log(
+        "Save this as .kimi-code/mcp.json, or rerun with --with-hooks for the plugin bundle:\n"
+      );
     } else if (hookClient === "codex") {
       console.log("\n\u{1F4DD} OpenAI Codex MCP Configuration\n");
       console.log("Merge this into ~/.codex/config.toml or project .codex/config.toml:\n");
@@ -6729,9 +6701,10 @@ async function initCommand(options) {
     if (hookClient === "cursor") {
       console.log("  1. Restart Cursor to load the new MCP, rules, and hooks");
       console.log("  2. Verify with: cursor mcp list");
-    } else if (hookClient === "windsurf") {
-      console.log("  1. Restart Windsurf to load the new hooks");
-      console.log("  2. Verify your cascade hooks are enabled");
+    } else if (hookClient === "kimi") {
+      console.log("  1. Review and install .kimi-code/snipara-plugin with /plugins install");
+      console.log("  2. Run /reload or start a new Kimi Code CLI session");
+      console.log("  3. Run /mcp and verify the Snipara Hosted MCP tools");
     } else if (hookClient === "codex") {
       console.log("  1. Restart Codex to load the MCP config and hooks");
       console.log("  2. Verify the snipara MCP tools and /hooks are available in Codex");
@@ -6757,9 +6730,9 @@ async function initCommand(options) {
     if (hookClient === "cursor") {
       console.log("  2. Add it to .cursor/hooks.json in your project");
       console.log("  3. Restart Cursor");
-    } else if (hookClient === "windsurf") {
-      console.log("  2. Add it to .windsurf/cascade-hooks.json in your project");
-      console.log("  3. Restart Windsurf");
+    } else if (hookClient === "kimi") {
+      console.log("  2. Save it as .kimi-code/mcp.json in your project");
+      console.log("  3. Restart Kimi Code CLI and run /mcp");
     } else if (hookClient === "codex") {
       console.log("  2. Add it to ~/.codex/config.toml or project .codex/config.toml");
       console.log("  3. Restart Codex");
@@ -11519,6 +11492,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 +11612,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);
 }
@@ -18370,10 +18353,10 @@ var ADAPTER_TARGETS = {
     profile: "External ADE worker using portable MCP and receipt echo",
     instruction: "Use the portable MCP plus companion handoff path, echo the receipt fields, and do not assume native hooks."
   },
-  windsurf: {
-    label: "Windsurf",
-    profile: "IDE coding assistant with portable context and proof gates",
-    instruction: "Use portable context, file scope, and proof gates around the IDE workflow; return evidence through companion handoff."
+  kimi: {
+    label: "Kimi Code CLI",
+    profile: "CLI coding agent with project MCP and an explicit Companion plugin",
+    instruction: "Load the project MCP config, install the generated Snipara plugin, keep hook failures fail-open, and return evidence through companion handoff."
   },
   custom: {
     label: "Custom worker",
@@ -30725,9 +30708,9 @@ var TARGETS = {
     label: "Orca",
     posture: "Use MCP plus companion handoffs; avoid assuming native Snipara task control."
   },
-  windsurf: {
-    label: "Windsurf",
-    posture: "Use portable context, proof, and resume artifacts around the IDE workflow."
+  kimi: {
+    label: "Kimi Code CLI",
+    posture: "Use project-local MCP plus the explicit Snipara plugin for fail-open hooks, resume state, and proof gates."
   },
   custom: {
     label: "Custom worker",
@@ -31214,7 +31197,7 @@ var TARGET_LABELS = {
   "claude-code": "Claude Code",
   cursor: "Cursor",
   orca: "Orca",
-  windsurf: "Windsurf",
+  kimi: "Kimi Code CLI",
   custom: "Custom worker"
 };
 function normalizeTarget2(target) {
@@ -35237,6 +35220,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) {
@@ -35758,6 +35759,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))];
 }
@@ -37881,7 +38031,7 @@ program.command("login").description("Authenticate this workspace through the Sn
 });
 program.command("init").description("Initialize Snipara companion configuration").option("-k, --api-key <key>", "API key").option("-p, --project <project>", "Project slug or ID").option("--project-id <id>", "Project slug or ID (deprecated alias)").option(
   "-c, --client <client>",
-  "Client type (claude-code|cursor|windsurf|codex|gemini|mistral|chatgpt|vscode|continue|custom)"
+  "Client type (claude-code|cursor|kimi|codex|gemini|mistral|chatgpt|vscode|continue|custom)"
 ).option("-f, --force", "Force overwrite existing configuration").option("-w, --with-hooks", "Install hooks automatically").option("-d, --dir <directory>", "Project directory for hooks (default: current)").action(async (options) => {
   await initCommand({
     ...options,
@@ -37907,7 +38057,7 @@ program.command("timeline").description("Show recent workflow phase commits, che
 });
 program.command("handoff").description("Create an agent-ready handoff artifact and persist Team Sync continuity").option("--summary <summary>", "What changed in this session").option("--next <next>", "Recommended next action").option("--files <files...>", "Relevant files").option("--attention <attention>", "Attention level (note|watch|review|proof)").option("--risk <risk>", "Compatibility alias for --attention").option("--actor <actor>", "Actor or agent name").option("--adapter-pack", "Attach an ADE Adapter Pack V1 to the handoff artifact").option(
   "--target <target>",
-  "ADE adapter-pack target (codex|claude-code|cursor|orca|windsurf|custom)"
+  "ADE adapter-pack target (codex|claude-code|cursor|orca|kimi|custom)"
 ).option("--context <refs...>", "Context references for the adapter pack").option("--proof <proof...>", "Proof gates expected from the receiving agent").option("--acceptance <criteria...>", "Acceptance criteria for the receiving agent").option(
   "--conflict-posture <posture>",
   "Conflict posture (continue|wait|split_work|review_only|handoff)"
@@ -37948,7 +38098,7 @@ program.command("agent-readiness").description("Audit whether a repo/task is rea
     "Create a local readiness report with proof gaps and a service-pack recommendation"
   ).option(
     "--target <target>",
-    "Target agent or ADE (codex|claude-code|cursor|orca|windsurf|custom)"
+    "Target agent or ADE (codex|claude-code|cursor|orca|kimi|custom)"
   ).option("--task <task>", "Delegated task summary").option("--changed-files <files...>", "Changed or relevant files").option("--context <refs...>", "Context references, decisions, docs, or source facts").option("--proof <proof...>", "Required proof gates or verification evidence").option("--acceptance <criteria...>", "Acceptance criteria for the delegated work").option("--risk <risks...>", "Known risks or caveats").option("-d, --dir <directory>", "Project directory (default: current)").option("-o, --output <file>", "Write Markdown or JSON report").option("--json", "Print raw JSON").action(async (options) => {
     await agentReadinessAuditCommand({
       target: options.target,
@@ -38004,10 +38154,7 @@ program.command("outcome-capture").description("Extract review-pending why/outco
     });
   })
 );
-program.command("lead-plan").description("Create a fail-closed Companion Engineering Lead Plan").option("--task <task>", "Current task or work package summary").option(
-  "--target <target>",
-  "Target agent or ADE (codex|claude-code|cursor|orca|windsurf|custom)"
-).option("--changed-files <files...>", "Changed or relevant files").option("--context <refs...>", "Context references, decisions, docs, or source facts").option("--proof <proof...>", "Required proof gates or verification evidence").option("--acceptance <criteria...>", "Acceptance criteria for the delegated work").option("--risk <risks...>", "Known risks or caveats").option("--from-cockpit <file>", "Read a Project Health cockpit JSON export").option("--from-plan <file>", "Read a Companion or Project Health Engineering Lead Plan JSON").option("--reconcile", "Reconcile an imported lead plan against current local Companion signals").option("-d, --dir <directory>", "Project directory (default: current)").option("-o, --output <file>", "Write Markdown or JSON report").option("--out <file>", "Alias for --output").option("--json", "Print raw JSON").action(async (options) => {
+program.command("lead-plan").description("Create a fail-closed Companion Engineering Lead Plan").option("--task <task>", "Current task or work package summary").option("--target <target>", "Target agent or ADE (codex|claude-code|cursor|orca|kimi|custom)").option("--changed-files <files...>", "Changed or relevant files").option("--context <refs...>", "Context references, decisions, docs, or source facts").option("--proof <proof...>", "Required proof gates or verification evidence").option("--acceptance <criteria...>", "Acceptance criteria for the delegated work").option("--risk <risks...>", "Known risks or caveats").option("--from-cockpit <file>", "Read a Project Health cockpit JSON export").option("--from-plan <file>", "Read a Companion or Project Health Engineering Lead Plan JSON").option("--reconcile", "Reconcile an imported lead plan against current local Companion signals").option("-d, --dir <directory>", "Project directory (default: current)").option("-o, --output <file>", "Write Markdown or JSON report").option("--out <file>", "Alias for --output").option("--json", "Print raw JSON").action(async (options) => {
   await leadPlanCommand({
     task: options.task,
     target: options.target,
@@ -38171,7 +38318,7 @@ program.command("htask").description(
 program.command("automations").description("Install and inspect dashboard-generated automation hook bundles").addCommand(
   new import_commander.Command("install").description("Fetch and install the project automation bundle").option(
     "-c, --client <client>",
-    "Client type (claude-code|cursor|windsurf|codex|gemini|mistral|chatgpt|vscode|continue|custom)"
+    "Client type (claude-code|cursor|kimi|codex|gemini|mistral|chatgpt|vscode|continue|custom)"
   ).option("-d, --dir <directory>", "Project directory (default: current)").option("-f, --force", "Overwrite local files even when they differ").option("--dry-run", "Preview writes without changing files").action(async (options) => {
     await automationsInstallCommand({
       client: options.client,
@@ -38674,13 +38821,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) });
 });
@@ -40138,6 +40305,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
@@ -690,7 +703,7 @@ Output includes:
 ## Agent Readiness Audits
 
 Use `agent-readiness audit` when a team wants to know whether a task can be
-delegated safely to Codex, Claude Code, Cursor, Orca, Windsurf, or a custom
+delegated safely to Codex, Claude Code, Cursor, Orca, Kimi Code CLI, or a custom
 worker:
 
 ```bash
@@ -770,7 +783,7 @@ Project Policy.
 ## ADE Adapter Pack Handoffs
 
 Use `handoff --adapter-pack` when the receiving execution cockpit is Codex,
-Claude Code, Cursor, Orca, Windsurf, or a custom worker:
+Claude Code, Cursor, Orca, Kimi Code CLI, or a custom worker:
 
 ```bash
 snipara-companion handoff \
@@ -800,7 +813,7 @@ The built-in `init` and `automations` flows share these client names:
 
 - `claude-code`
 - `cursor`
-- `windsurf`
+- `kimi`
 - `codex`
 - `gemini`
 - `mistral`
@@ -809,7 +822,7 @@ The built-in `init` and `automations` flows share these client names:
 - `continue`
 - `custom`
 
-Claude Code, Cursor, Windsurf, Codex, and Gemini have native or generated hook
+Claude Code, Cursor, Kimi Code CLI, Codex, and Gemini have native or generated hook
 surfaces. Mistral, ChatGPT, VS Code, Continue, and custom clients are MCP-first presets: companion
 prints the hosted MCP config/reference and installs dashboard-generated
 automation files only when the hosted project exposes a bundle for that client.
@@ -828,12 +841,21 @@ npx -y snipara-companion@latest init --with-hooks --client claude-code
 npx -y snipara-companion@latest init --with-hooks --client cursor
 ```
 
-### Windsurf
+### Kimi Code CLI
 
 ```bash
-npx -y snipara-companion@latest init --with-hooks --client windsurf
+npx -y snipara-companion@latest init --with-hooks --client kimi
+npx -y snipara-companion@latest automations install --client kimi
+# In Kimi Code, after reviewing the generated files:
+/plugins install .kimi-code/snipara-plugin
 ```
 
+Kimi reads `.kimi-code/mcp.json` and resolves `SNIPARA_API_KEY` from the launch
+environment. Its plugin hooks are fail-open, so keep manual approval for risky
+tools and treat Hosted MCP tenant checks plus Companion guards as the hard
+boundary. Kimi installs plugins per user; the generated handler no-ops outside
+workspaces carrying a Snipara project or Companion marker.
+
 ### Codex
 
 ```bash
@@ -858,7 +880,7 @@ bundle generated by Project Automation in the dashboard:
 ```bash
 npx -y snipara-companion@latest automations install --client claude-code
 npx -y snipara-companion@latest automations install --client cursor
-npx -y snipara-companion@latest automations install --client windsurf
+npx -y snipara-companion@latest automations install --client kimi
 npx -y snipara-companion@latest automations install --client codex
 npx -y snipara-companion@latest automations status
 npx -y snipara-companion@latest automations diff
@@ -876,7 +898,7 @@ unless you pass `--force`.
 Agent instruction files are always merged, not replaced. Existing `AGENTS.md`,
 `CLAUDE.md`, `GEMINI.md`, `.cursorrules`, and Copilot instructions keep their
 local content while Snipara adds or refreshes a marked Snipara section. Known
-client JSON configs for Claude, Cursor, Continue.dev, Windsurf, Gemini, VS Code,
+client JSON configs for Claude, Cursor, Continue.dev, Kimi, Gemini, VS Code,
 and root `mcp.json` are deep-merged so existing servers and hooks are preserved.
 Mistral generates MCP-first files (`MISTRAL.md`, Vibe config, Le Chat connector
 reference, and LangChain `ChatMistralAI.bindTools` snippets); Mistral request
@@ -912,7 +934,7 @@ Options:
 - `--api-key <key>` - Skip prompt for API key
 - `--project <project>` - Skip prompt for project slug or ID
 - `--project-id <id>` - Deprecated alias for `--project`
-- `--client <client>` - `claude-code`, `cursor`, `windsurf`, `codex`, `gemini`, `chatgpt`, `vscode`, `continue`, or `custom`
+- `--client <client>` - `claude-code`, `cursor`, `kimi`, `codex`, `gemini`, `mistral`, `chatgpt`, `vscode`, `continue`, or `custom`
 - `--with-hooks` - Install hooks automatically
 - `--force` - Overwrite existing generated files
 - `--dir <directory>` - Target directory for generated files

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "snipara-companion",
-  "version": "3.5.0",
+  "version": "3.5.2",
   "description": "Local-first CLI that asks your repo what breaks before an AI coding agent edits it.",
   "main": "dist/index.js",
   "bin": {
@@ -31,7 +31,7 @@
     "llm",
     "claude",
     "cursor",
-    "windsurf",
+    "kimi",
     "codex",
     "gemini",
     "mistral",