Transit branch T-2380/mcp-write-safety commits 3 + working-tree fixes files 98 touched lines +5483 / -1666

Pre-push review: T-2380/mcp-write-safety

Local retry-safe MCP writes and optimistic concurrency. Three unpushed commits plus the reviewed working-tree fixes.

At a glance

  • Eight protected writes use durable retry guards/receipts and local revision preconditions.

  • Maintenance is linear; incomplete saved outcomes fail closed; shared scalar parsing and docs are corrected.

  • Current evidence: targeted production probes and validators. No detected structured Xcode runner; fresh JUnit/coverage unavailable.

Verdict

Ready to push after committing fixes

All four findings are fixed and the focused production probes, lint, syntax and whitespace checks pass. The review fixes are uncommitted. The configured runner map does not match this Xcode-only repository, so no fresh structured whole-suite or coverage data is available. The committed implementation previously passed 1,853 macOS and 1,308 iOS unit/UI tests; those results predate these fixes.

Review findings

4 raised · 4 fixed · 0 skipped

Jump to findings →

Tests

Pass rate: n/a

New tests: 35

Diff coverage: n/a

Jump to tests →

Commits

Three-level explanation

What This Does

A caller gives each logical write a key. Transit remembers the saved result and returns it when that same request is retried, even if the record later changes or disappears. An update also includes a revision from the caller's read; a different current revision rejects the write instead of overwriting intervening edits.

Why It Matters

A timeout cannot tell a caller whether a save happened. The saved receipt answers that question when storage is readable. A durable local guard keeps the key reserved when the outcome cannot be recovered, preventing a blind repeat.

Key Concepts

  • A receipt stores the saved record and outcome with the write in one local save.
  • A revision is a fingerprint of covered local content, not a global edit counter.
  • A retry repeats the same key and arguments; a corrected request uses a new key.

Changes Overview

MCPToolHandler translates eight protected tools into typed commands for an app-lifetime coordinator. Read services still share the UI's main context. Creation prepares display IDs before insertion; the final validation, mutation, result encoding, and receipt save contain no suspension.

Implementation Approach

The coordinator reserves a durable guard, confirms an accepted receipt, prepares asynchronous work, saves a baseline, and checks the current record snapshot. Domain changes and terminal response are committed together. Recovery reads durable receipts rather than inferring success from target existence; replay validates the complete stored envelope. Maintenance validates receipts and guards once per pass, then repairs expiry or removes eligible entries without repeated scans.

Trade-offs

Receipts sync with the domain store, while their namespace and guards remain local. Content hashes detect changes from any local writer without adding counters, but identical restored content has the same token. Baseline saves can persist other pending local work, matching the shared-context behavior.

Technical Deep Dive

Canonical request identity preserves absent/null, Boolean/number, and original payload differences while ignoring object key order. Revisions hash exact persisted scalar state, assignment UUIDs, and comment snapshots. Terminal replay checks metadata timestamps, entity identity, complete records and revisions, deletion preimages, optional status comments, and rejected/conflict details. All binding validation precedes maintenance writes; unresolved guards never expire through terminal cleanup.

Architecture Impact

The local advisory lock and MainActor synchronous commit section protect this process/store boundary. One-pass maintenance is linear in retained records and payload size. It avoids a persistent in-memory cache that could become stale, while retaining fail-closed validation before any file or receipt deletion.

Potential Issues

Preconditions cannot detect CloudKit edits not yet imported, and later sync can still conflict. Replay protection ends at the returned terminal deadline; unresolved outcomes require reconciliation. Schema publication is a separate release prerequisite. No global deduplication, batch atomicity, or automatic force-retry is claimed.

Important changes — detailed

Coordinator binds retry identity to atomic saved outcomes

Transit/Transit/MCP/Writes/MCPWriteCoordinator.swift

Why it matters. Lost responses can be retried without a second domain effect; preconditions use live local state.

What to look at. MCPWriteCoordinator.execute

Takeaway. Persist evidence with the effect and separate asynchronous preparation from synchronous commit.
Rationale. Decision 2 selects same-store receipts; Decision 4 retains the shared main context with saved baselines.

Guard maintenance validates once per pass

Transit/Transit/MCP/Writes/MCPLocalReservationStore.swift

Why it matters. Keeps seven-day retention from causing quadratic request/startup I/O on MainActor.

What to look at. reconcileTerminalBindings

Takeaway. Use an operation-scoped validated index instead of rescanning persistent metadata or retaining a stale cache.
Rationale. Quick Decision Q16 records the complexity fix while preserving fail-closed validation before changes.

Receipt replay requires a complete saved result

Transit/Transit/MCP/Writes/MCPWriteReceiptStore.swift

Why it matters. A corrupted partial envelope must not claim committed or rejected completion.

What to look at. validateTerminal / validateRecord / validateRejection

Takeaway. Validate the entire durable protocol record, not merely routing headers.
Rationale. The design recovery table and requirements 5.1/5.3 require uncertain outcomes for malformed receipts.

Snapshots provide revisions across local write paths

Transit/Transit/MCP/Writes/MCPRecordSnapshot.swift

Why it matters. UI, intents, maintenance and imported sync state participate without writer-specific counters.

What to look at. MCPRecordSnapshot.task

Takeaway. Derive equality tokens from explicit covered state and produce response/revision from one capture.
Rationale. Decisions 1 and 3 limit revision coverage and choose content equality over counters.

Creation prepares IDs before synchronous insertion

Transit/Transit/Services/TaskService.swift

Why it matters. Revalidates references/cancellation after allocation and avoids staging models across suspension.

What to look at. prepareTaskCreation / applyTaskCreation

Takeaway. Pin reference identities in prepared commands, then validate again at the mutation boundary.
Rationale. Decision 4 isolates rollback to staged work after a saved baseline.

MCP schemas expose the breaking safety contract

Transit/Transit/MCP/MCPToolDefinitions.swift

Why it matters. All eight writes require keys; four update/deletion tools require revisions and return saved outcomes.

What to look at. Protected write input schemas

Takeaway. Publish retry scope, expiry and error classification with the schema callers consume.
Rationale. Quick Decision Q3 accepts caller updates rather than maintaining omitted-safety compatibility.

Key decisions

Same-store outcomes, local key scope

Decision 2 commits the domain effect and result together. Local guards preserve unresolved payload binding even though receipts sync; no cross-device deduplication is promised.

Explicit revision coverage and content equality

Decisions 1/3 cover own scalar state, task assignments and comments; parent descriptive changes and derived summaries do not invalidate a task. Identical restored content has the same token.

Durable guards before acceptance

Decision 5 prevents an in-memory quarantine from disappearing on restart. Unresolved bindings never expire under terminal cleanup.

Per-pass validated maintenance snapshot

Q16 removes repeated directory/receipt scans without introducing a persistent cache that could become stale. All validation precedes repairs/removals.

Review findings

SeverityAreaFindingResolution
majorGuard maintenancePer-receipt guard scans made cleanup quadratic on MainActor.Validate one receipt pass and one keyed guard snapshot before repairing/removing bindings.
majorTerminal replay validationIncomplete committed/rejected result bodies could replay as valid completion.Validate metadata, full record/revision, identity, preimages/comments and error/conflict details; 21 malformed cases remain uncertain with guards preserved.
minorScalar parsing reuseNSNumber-to-Double validation rejected exact integer boundaries and duplicated shared parsing.Reuse IntentHelpers.parseIntValue/parseBoolValue with exact Int.max and strict-invalid regressions.
minorDocumentation entry pointsREADME, CLAUDE and MCP notes omitted required safety inputs and described obsolete response parity.Link the current write contract and update model/coordinator ownership, keyed examples and domain-parity guidance.

Tests

Source: local run at 2026-10-03T15:06:41.986390+10:00 · snapshot ef29b2baabbaa8a4886e63a03a267d6d7db86519 (dirty working tree)

Baseline: none

Execution: not run · JUnit: none · Coverage: none · Baseline: absent

No test results

The test runner could not be detected.

New and removed tests

Derived by declaration name, from the diff (no baseline run).

Blast radius

Files that import a changed file on the left, changed files in the centre, files a changed file imports on the right. Snapshot working-tree against base 93f1b1908f7724a97cabfb574e4171710dc58a07.

Dependents none found Changed Dependencies none found . Transit/Transit Transit/Transit/Extensions Transit/Transit/MCP Transit/Transit/MCP/Writes Transit/Transit/Models Transit/Transit/Services Transit/TransitTests tests/mcp-write-probe MakefileMakefile Transit/Transit/TransitApp.swift…nsit/Transit/TransitApp.swift Transit/Transit/Extensions/ModelContext+SafeRollback.swift…delContext+SafeRollback.swift Transit/Transit/MCP/MCPToolDefinitions.swift…/MCP/MCPToolDefinitions.swift Transit/Transit/MCP/MCPToolHandler.swift…nsit/MCP/MCPToolHandler.swift Transit/Transit/MCP/MCPTypes.swift…it/Transit/MCP/MCPTypes.swift Transit/Transit/MCP/Writes/MCPCanonicalJSON.swift…Writes/MCPCanonicalJSON.swift Transit/Transit/MCP/Writes/MCPLocalReservationStore.swift…CPLocalReservationStore.swift Transit/Transit/MCP/Writes/MCPRecordRevision.swift…rites/MCPRecordRevision.swift Transit/Transit/MCP/Writes/MCPRecordSnapshot.swift…rites/MCPRecordSnapshot.swift Transit/Transit/MCP/Writes/MCPWriteCommand.swift…/Writes/MCPWriteCommand.swift Transit/Transit/MCP/Writes/MCPWriteCoordinator.swift…tes/MCPWriteCoordinator.swift Transit/Transit/MCP/Writes/MCPWriteOutcome.swift…/Writes/MCPWriteOutcome.swift Transit/Transit/MCP/Writes/MCPWriteReceiptStore.swift…es/MCPWriteReceiptStore.swift Transit/Transit/Models/MCPWriteReceipt.swift…/Models/MCPWriteReceipt.swift Transit/Transit/Services/MilestoneService.swift…rvices/MilestoneService.swift Transit/Transit/Services/ProjectService.swift…Services/ProjectService.swift Transit/Transit/Services/TaskService.swift…it/Services/TaskService.swift Transit/TransitTests/BoolAsIntIdRejectionTests.swift…olAsIntIdRejectionTests.swift Transit/TransitTests/CreateRequiredStringValidationTests.swift…edStringValidationTests.swift Transit/TransitTests/CreateTaskMetadataShapeValidationTests.swift…ataShapeValidationTests.swift Transit/TransitTests/CreationProjectDeletionTests.swift…ionProjectDeletionTests.swift Transit/TransitTests/DeferredMutationServiceTests.swift…redMutationServiceTests.swift Transit/TransitTests/FallbackOutcomeFixture.swift…/FallbackOutcomeFixture.swift Transit/TransitTests/MCPAddCommentTypeValidationTests.swift…mentTypeValidationTests.swift Transit/TransitTests/MCPCanonicalJSONTests.swift…s/MCPCanonicalJSONTests.swift Transit/TransitTests/MCPCommentFetchFailureTests.swift…ommentFetchFailureTests.swift Transit/TransitTests/MCPCommentTests.swift…itTests/MCPCommentTests.swift Transit/TransitTests/MCPCommentTypeValidationTests.swift…mentTypeValidationTests.swift Transit/TransitTests/MCPCreateNonStringProjectTests.swift…teNonStringProjectTests.swift Transit/TransitTests/MCPCreateProjectTests.swift…s/MCPCreateProjectTests.swift Transit/TransitTests/MCPCreateTaskAtomicityTests.swift…reateTaskAtomicityTests.swift Transit/TransitTests/MCPCreateTaskMetadataTests.swift…CreateTaskMetadataTests.swift Transit/TransitTests/MCPCreateTaskTerminalMilestoneTests.swift…kTerminalMilestoneTests.swift Transit/TransitTests/MCPDuplicateTaskDisplayIDTests.swift…icateTaskDisplayIDTests.swift Transit/TransitTests/MCPFallbackStorageRejectionTests.swift…ckStorageRejectionTests.swift Transit/TransitTests/MCPHTTPTestHelpers.swift…ests/MCPHTTPTestHelpers.swift Transit/TransitTests/MCPLocalReservationStoreTests.swift…alReservationStoreTests.swift Transit/TransitTests/MCPMilestoneClearDescriptionTests.swift…neClearDescriptionTests.swift Transit/TransitTests/MCPMilestoneDeleteTests.swift…MCPMilestoneDeleteTests.swift Transit/TransitTests/MCPMilestoneIntegrationTests.swift…lestoneIntegrationTests.swift Transit/TransitTests/MCPMilestoneRenameValidationTests.swift…neRenameValidationTests.swift Transit/TransitTests/MCPMilestoneSameStatusTests.swift…ilestoneSameStatusTests.swift Transit/TransitTests/MCPMilestoneStatusValidationTests.swift…neStatusValidationTests.swift Transit/TransitTests/MCPMilestoneToolTests.swift…s/MCPMilestoneToolTests.swift Transit/TransitTests/MCPNonIntegerDisplayIdTests.swift…onIntegerDisplayIdTests.swift Transit/TransitTests/MCPNonStringDescriptionTests.swift…nStringDescriptionTests.swift Transit/TransitTests/MCPNonStringMilestoneArgTests.swift…StringMilestoneArgTests.swift Transit/TransitTests/MCPNonStringMilestoneIdTests.swift…nStringMilestoneIdTests.swift Transit/TransitTests/MCPNotificationDispatchTests.swift…tificationDispatchTests.swift Transit/TransitTests/MCPPriorityTests.swift…tTests/MCPPriorityTests.swift Transit/TransitTests/MCPProtectedWriteTestHelpers.swift…otectedWriteTestHelpers.swift Transit/TransitTests/MCPRecordRevisionTests.swift…/MCPRecordRevisionTests.swift Transit/TransitTests/MCPServerBatchRequestTests.swift…ServerBatchRequestTests.swift Transit/TransitTests/MCPServerLifecycleTests.swift…MCPServerLifecycleTests.swift Transit/TransitTests/MCPServerOriginValidationTests.swift…erOriginValidationTests.swift Transit/TransitTests/MCPTaskIdentifierValidationTests.swift…entifierValidationTests.swift Transit/TransitTests/MCPTestHelpers.swift…sitTests/MCPTestHelpers.swift Transit/TransitTests/MCPToolHandlerCommentTests.swift…ToolHandlerCommentTests.swift Transit/TransitTests/MCPToolHandlerTests.swift…sts/MCPToolHandlerTests.swift Transit/TransitTests/MCPUpdateStatusValidationTests.swift…teStatusValidationTests.swift Transit/TransitTests/MCPUpdateTaskTests.swift…ests/MCPUpdateTaskTests.swift Transit/TransitTests/MCPWriteContractTests.swift…s/MCPWriteContractTests.swift Transit/TransitTests/MCPWriteCoordinatorTests.swift…CPWriteCoordinatorTests.swift Transit/TransitTests/MCPWriteLifecycleTests.swift…/MCPWriteLifecycleTests.swift Transit/TransitTests/MCPWritePersistenceProbeTests.swift…tePersistenceProbeTests.swift Transit/TransitTests/MCPWriteServerLifecycleTests.swift…iteServerLifecycleTests.swift Transit/TransitTests/MilestoneCrossDeviceUniquenessTests.swift…ssDeviceUniquenessTests.swift Transit/TransitTests/MilestoneNameLookupStorageFailureSurfaceTests.swift…rageFailureSurfaceTests.swift Transit/TransitTests/NonIntegerMilestoneDisplayIdTests.swift…MilestoneDisplayIdTests.swift Transit/TransitTests/NumericDisplayIdParsingTests.swift…icDisplayIdParsingTests.swift Transit/TransitTests/ProjectLookupStorageFailureSurfaceTests.swift…rageFailureSurfaceTests.swift Transit/TransitTests/SyncDisabledGatingTests.swift…SyncDisabledGatingTests.swift Transit/TransitTests/TestModelContainer.swift…ests/TestModelContainer.swift Transit/TransitTests/UpdateTaskAllFieldsParityTests.swift…askAllFieldsParityTests.swift tests/mcp-write-probe/CoordinatorProbe.swift…-probe/CoordinatorProbe.swift tests/mcp-write-probe/CoordinatorRegressionProbe.swift…rdinatorRegressionProbe.swift tests/mcp-write-probe/FoundationProbe.swift…e-probe/FoundationProbe.swift tests/mcp-write-probe/GuardProbe.swift…-write-probe/GuardProbe.swift tests/mcp-write-probe/Probe.swift…s/mcp-write-probe/Probe.swift tests/mcp-write-probe/ServiceProbe.swift…rite-probe/ServiceProbe.swift tests/mcp-write-probe/guards.py…sts/mcp-write-probe/guards.py tests/mcp-write-probe/run.pytests/mcp-write-probe/run.py
addedmodifieddeletedrenamedunchangedcollapsed package group or +N more⚑N test files with an edge to the node

Per-file diffs

98 files: 84 code · 14 docs. Click to expand.

Code (84)

Makefile Modified +78 / -1
diff --git a/Makefile b/Makefileindex a899e55..968d95e 100644--- a/Makefile+++ b/Makefile@@ -142,6 +142,83 @@ build-macos: prepare-cache-dirs build: build-ios build-macos  # Testing+# Nested macro sandboxing is unavailable in some already-sandboxed runners.+# Set MCP_PROBE_SWIFT_FLAGS=-disable-sandbox there; the outer runner policy stays active.+MCP_PROBE_SWIFT_FLAGS ?=+MCP_PROBE_MODELS = Transit/Transit/Models/{Project,TransitTask,Comment,Milestone,SyncHeartbeat,DisplayID,TaskPriority,TaskStatus,TaskType,MilestoneStatus,MCPWriteReceipt}.swift+.PHONY: test-mcp-write-guards+test-mcp-write-guards: prepare-cache-dirs+	xcrun swiftc $(MCP_PROBE_SWIFT_FLAGS) -parse-as-library -default-isolation MainActor -module-cache-path $(CLANG_MODULE_CACHE) \+		Transit/Transit/MCP/Writes/{MCPCanonicalJSON,MCPLocalReservationStore}.swift tests/mcp-write-probe/GuardProbe.swift \+		-o $(DERIVED_DATA)/mcp-write-guard-probe+	python3 tests/mcp-write-probe/guards.py $(DERIVED_DATA)/mcp-write-guard-probe++.PHONY: test-mcp-write-foundation+test-mcp-write-foundation: prepare-cache-dirs+	xcrun swiftc $(MCP_PROBE_SWIFT_FLAGS) -parse-as-library -default-isolation MainActor -module-cache-path $(CLANG_MODULE_CACHE) \+		$(MCP_PROBE_MODELS) Transit/Transit/MCP/Writes/{MCPCanonicalJSON,MCPRecordSnapshot,MCPRecordRevision,MCPLocalReservationStore,MCPWriteReceiptStore}.swift \+		Transit/Transit/Services/CommentService.swift Transit/Transit/Extensions/ModelContext+{Save,SafeRollback}.swift \+		tests/mcp-write-probe/FoundationProbe.swift -o $(DERIVED_DATA)/mcp-write-foundation-probe+	$(DERIVED_DATA)/mcp-write-foundation-probe++.PHONY: test-mcp-write-services+MCP_PROBE_SERVICES = Transit/Transit/Services/{TaskService,TaskService+Error,MilestoneService,MilestoneService+Error,ProjectService,CommentService,ModelFetching,UsedDisplayIDs,DisplayIDAllocator,DisplayIDRecordLookup,CloudKitCounterStore,CreationProjectValidator,TaskCreationMilestoneValidator,ProjectNameReconciler,MilestoneNameReconciler,StatusEngine,PersistenceAvailability,ContainerFactory}.swift+MCP_PROBE_DEPENDENCIES ?= $(DERIVED_DATA)/Build/Products/Debug+.PHONY: format-mcp-write+format-mcp-write:+	xcrun swift-format format --in-place --configuration tests/mcp-write-probe/swift-format.json \+		Transit/Transit/MCP/Writes/{MCPWriteCommand,MCPWriteCoordinator,MCPWriteOutcome}.swift \+		Transit/Transit/MCP/{MCPToolDefinitions,MCPToolHandler,MCPTypes}.swift \+		Transit/TransitTests/{MCPWriteCoordinatorTests,MCPWriteContractTests}.swift \+		tests/mcp-write-probe/CoordinatorProbe.swift++.PHONY: check-mcp-write-handler+.PHONY: check-mcp-write-lifecycle-syntax+check-mcp-write-lifecycle-syntax:+	xcrun swiftc -frontend -parse -swift-version 6 Transit/Transit/TransitApp.swift Transit/TransitTests/*.swift++.PHONY: check-mcp-write-handler-syntax+check-mcp-write-handler-syntax:+	xcrun swiftc -frontend -parse -swift-version 6 \+		Transit/Transit/MCP/{MCPToolHandler,MCPToolDefinitions,MCPTypes}.swift++check-mcp-write-handler: prepare-cache-dirs+	xcrun swiftc $(MCP_PROBE_SWIFT_FLAGS) -swift-version 6 -typecheck -default-isolation MainActor \+		-module-cache-path $(CLANG_MODULE_CACHE) -I $(MCP_PROBE_DEPENDENCIES) \+		$(MCP_PROBE_MODELS) $(MCP_PROBE_SERVICES) Transit/Transit/MCP/Writes/*.swift \+		Transit/Transit/MCP/{MCPTypes,MCPToolDefinitions,MCPToolHandler,MCPSettings,MCPToolListChangeBroadcaster,MCPHelperTypes}.swift \+		Transit/Transit/Services/{DisplayIDMaintenanceService,DisplayIDMaintenanceTypes}.swift \+		Transit/Transit/Intents/{IntentHelpers,IntentError,TaskUpdateValidator,QueryMilestonesIntent}.swift \+		Transit/Transit/Intents/Shared/TaskFetching.swift \+		Transit/Transit/Extensions/ModelContext+{Save,SafeRollback}.swift++.PHONY: test-mcp-write-coordinator+test-mcp-write-coordinator: prepare-cache-dirs+	xcrun swiftc $(MCP_PROBE_SWIFT_FLAGS) -swift-version 6 -parse-as-library -default-isolation MainActor -module-cache-path $(CLANG_MODULE_CACHE) \+		$(MCP_PROBE_MODELS) $(MCP_PROBE_SERVICES) Transit/Transit/MCP/Writes/*.swift \+		Transit/Transit/MCP/{MCPTypes,MCPToolDefinitions}.swift \+		Transit/Transit/Intents/{IntentHelpers,IntentError,TaskUpdateValidator}.swift \+		Transit/Transit/Extensions/ModelContext+{Save,SafeRollback}.swift \+		tests/mcp-write-probe/{CoordinatorProbe,CoordinatorRegressionProbe}.swift -o $(DERIVED_DATA)/mcp-write-coordinator-probe+	$(DERIVED_DATA)/mcp-write-coordinator-probe++test-mcp-write-services: prepare-cache-dirs+	xcrun swiftc $(MCP_PROBE_SWIFT_FLAGS) -parse-as-library -default-isolation MainActor -module-cache-path $(CLANG_MODULE_CACHE) \+		$(MCP_PROBE_MODELS) Transit/Transit/Services/{TaskService,TaskService+Error,MilestoneService,MilestoneService+Error,ProjectService,CommentService,ModelFetching,UsedDisplayIDs,DisplayIDAllocator,DisplayIDRecordLookup,CloudKitCounterStore,CreationProjectValidator,TaskCreationMilestoneValidator,ProjectNameReconciler,MilestoneNameReconciler,StatusEngine,PersistenceAvailability,ContainerFactory}.swift \+		Transit/Transit/Intents/{IntentHelpers,IntentError}.swift Transit/Transit/Extensions/ModelContext+{Save,SafeRollback}.swift \+		tests/mcp-write-probe/ServiceProbe.swift -o $(DERIVED_DATA)/mcp-write-service-probe+	$(DERIVED_DATA)/mcp-write-service-probe++.PHONY: test-mcp-write-persistence+test-mcp-write-persistence: prepare-cache-dirs+	xcrun swiftc $(MCP_PROBE_SWIFT_FLAGS) -parse-as-library -default-isolation MainActor -module-cache-path $(CLANG_MODULE_CACHE) \+		$(MCP_PROBE_MODELS) \+		Transit/Transit/Extensions/ModelContext+SafeRollback.swift tests/mcp-write-probe/Probe.swift \+		-o $(DERIVED_DATA)/mcp-write-disk-probe+	python3 tests/mcp-write-probe/run.py $(DERIVED_DATA)/mcp-write-disk-probe++TEST_TARGETS ?= TransitTests+ .PHONY: test-quick test-quick: prepare-cache-dirs test-create-task-project-schema-guard 	$(PIPEFAIL) $(XCODEBUILD_ENV) xcodebuild test \@@ -150,7 +227,7 @@ test-quick: prepare-cache-dirs test-create-task-project-schema-guard 		-destination 'platform=macOS' \ 		-configuration Debug \ 		$(XCODEBUILD_CACHE_FLAGS) \-		-only-testing:TransitTests \+		$(foreach target,$(TEST_TARGETS),-only-testing:$(target)) \ 		$(PIPE_PRETTY)  .PHONY: test
Transit/Transit/Extensions/ModelContext+SafeRollback.swift Modified +1 / -0
diff --git a/Transit/Transit/Extensions/ModelContext+SafeRollback.swift b/Transit/Transit/Extensions/ModelContext+SafeRollback.swiftindex b5e5144..ed60139 100644--- a/Transit/Transit/Extensions/ModelContext+SafeRollback.swift+++ b/Transit/Transit/Extensions/ModelContext+SafeRollback.swift@@ -28,5 +28,6 @@ extension ModelContext {         _ = try? fetch(FetchDescriptor<Comment>())         _ = try? fetch(FetchDescriptor<Milestone>())         _ = try? fetch(FetchDescriptor<SyncHeartbeat>())+        _ = try? fetch(FetchDescriptor<MCPWriteReceipt>())     } }
Transit/Transit/MCP/MCPToolDefinitions.swift Modified +248 / -173
diff --git a/Transit/Transit/MCP/MCPToolDefinitions.swift b/Transit/Transit/MCP/MCPToolDefinitions.swiftindex 500df1c..1b2c8e7 100644--- a/Transit/Transit/MCP/MCPToolDefinitions.swift+++ b/Transit/Transit/MCP/MCPToolDefinitions.swift@@ -25,85 +25,104 @@ nonisolated enum MCPToolDefinitions {     /// derived from `maintenanceTools` so adding a tool there is a single edit.     static let maintenanceToolNames: Set<String> = Set(maintenanceTools.map(\.name)) +}++extension MCPToolDefinitions {     // MARK: - Maintenance Tools -    // swiftlint:disable:next line_length-    private static let scanDuplicateDisplayIdsDescription = "Scan tasks and milestones for duplicate permanentDisplayId values. Returns groups of duplicates (winner + losers) without modifying any data. Read-only."+    nonisolated private static let scanDuplicateDisplayIdsDescription = """+        Scan tasks and milestones for duplicate permanentDisplayId values. Returns groups of duplicates \+        (winner + losers) without modifying any data. Read-only.+        """ -    static let scanDuplicateDisplayIds = MCPToolDefinition(+    nonisolated static let scanDuplicateDisplayIds = MCPToolDefinition(         name: "scan_duplicate_display_ids",         description: scanDuplicateDisplayIdsDescription,         inputSchema: .object(properties: [:], required: [])     ) -    // swiftlint:disable:next line_length-    private static let reassignDuplicateDisplayIdsDescription = "Reassign fresh permanentDisplayId values to losers in each duplicate group. Advances the CloudKit counter past the highest observed ID before allocation. Best-effort per group; returns per-group outcomes."+    nonisolated private static let reassignDuplicateDisplayIdsDescription = """+        Reassign fresh permanentDisplayId values to losers in each duplicate group. Advances the CloudKit \+        counter past the highest observed ID before allocation. Best-effort per group; returns per-group \+        outcomes.+        """ -    static let reassignDuplicateDisplayIds = MCPToolDefinition(+    nonisolated static let reassignDuplicateDisplayIds = MCPToolDefinition(         name: "reassign_duplicate_display_ids",         description: reassignDuplicateDisplayIdsDescription,         inputSchema: .object(properties: [:], required: [])     ) -    private static let createTaskDescription = """+    nonisolated private static let createTaskDescription = """         Create a new task in Transit. The task starts in Idea status. \         At least one of 'project' or 'projectId' is required to identify the task's project.         """ -    static let createTask = MCPToolDefinition(-        name: "create_task",-        description: createTaskDescription,-        inputSchema: .object(-            properties: [-                "name": .string("Task name (required)"),-                "type": .stringEnum(-                    "Task type (required)",-                    values: TaskType.allCases.map(\.rawValue)-                ),-                "priority": .stringEnum(-                    "Task priority (optional, defaults to medium)",-                    values: TaskPriority.allCases.map(\.rawValue)-                ),-                "projectId": .string(-                    "Project UUID. At least one of projectId or project is required; projectId takes precedence."-                ),-                "project": .string(-                    "Project name (case-insensitive). At least one of projectId or project is required."-                ),-                "description": .string("Task description (optional)"),-                "metadata": .object("Key-value metadata (optional, string values)"),-                "milestone": .string("Milestone name (within the task's project)"),-                "milestoneDisplayId": .integer("Milestone display ID (e.g. 3 for M-3, takes precedence over name)")-            ],-            required: ["name", "type"]-        )-    )--    // swiftlint:disable:next line_length-    private static let updateTaskStatusDescription = "Move a task to a different status. Identify the task by displayId (e.g. 42 for T-42) or taskId (UUID)."--    static let updateTaskStatus = MCPToolDefinition(-        name: "update_task_status",-        description: updateTaskStatusDescription,-        inputSchema: .object(-            properties: [-                "displayId": .integer("Task display ID (e.g. 42 for T-42)"),-                "taskId": .string("Task UUID"),-                "status": .stringEnum(-                    "Target status (required)",-                    values: TaskStatus.allCases.map(\.rawValue)-                ),-                "comment": .string("Optional comment to add with status change"),-                "authorName": .string("Author name (required when comment is provided)")-            ],-            required: ["status"]-        )-    )+    nonisolated static let createTask = protected(+        MCPToolDefinition(+            name: "create_task",+            description: createTaskDescription,+            inputSchema: .object(+                properties: [+                    "name": .string("Task name (required)"),+                    "type": .stringEnum(+                        "Task type (required)",+                        values: TaskType.allCases.map(\.rawValue)+                    ),+                    "priority": .stringEnum(+                        "Task priority (optional, defaults to medium)",+                        values: TaskPriority.allCases.map(\.rawValue)+                    ),+                    "projectId": .string(+                        "Project UUID. At least one of projectId or project is required; projectId takes precedence."+                    ),+                    "project": .string(+                        "Project name (case-insensitive). At least one of projectId or project is required."+                    ),+                    "description": .string("Task description (optional)"),+                    "metadata": .object("Key-value metadata (optional, string values)"),+                    "milestone": .string("Milestone name (within the task's project)"),+                    "milestoneDisplayId": .integer(+                        "Milestone display ID (e.g. 3 for M-3, takes precedence over name)")+                ],+                required: ["name", "type"]+            )+        ))++    nonisolated private static let updateTaskStatusDescription = """+        Move a task to a different status. Identify the task by displayId (e.g. 42 for T-42) or taskId \+        (UUID).+        """ -    // swiftlint:disable:next line_length-    private static let queryTasksDescription = "Search and filter tasks. All filters are optional — omit all to return every task. Use displayId for single-task lookup with full details. Use project for case-insensitive name filtering. status accepts an array of statuses to include. not_status accepts an array of statuses to exclude. priority accepts an array of priorities to include. unfinished=true excludes done and abandoned tasks (merged with not_status if both provided). Use search for case-insensitive substring matching on task name and description."+    nonisolated static let updateTaskStatus = protected(+        MCPToolDefinition(+            name: "update_task_status",+            description: updateTaskStatusDescription,+            inputSchema: .object(+                properties: [+                    "displayId": .integer("Task display ID (e.g. 42 for T-42)"),+                    "taskId": .string("Task UUID"),+                    "status": .stringEnum(+                        "Target status (required)",+                        values: TaskStatus.allCases.map(\.rawValue)+                    ),+                    "comment": .string("Optional comment to add with status change"),+                    "authorName": .string("Author name (required when comment is provided)")+                ],+                required: ["status"]+            )+        ))++    nonisolated private static let queryTasksDescription = """+        Search and filter tasks. All filters are optional — omit all to return every task. Use displayId for \+        single-task lookup with full details. Use project for case-insensitive name filtering. status \+        accepts an array of statuses to include. not_status accepts an array of statuses to exclude. \+        priority accepts an array of priorities to include. unfinished=true excludes done and abandoned \+        tasks (merged with not_status if both provided). Use search for case-insensitive substring matching \+        on task name and description.+        """ -    static let queryTasks = MCPToolDefinition(+    nonisolated static let queryTasks = MCPToolDefinition(         name: "query_tasks",         description: queryTasksDescription,         inputSchema: .object(@@ -136,37 +155,42 @@ nonisolated enum MCPToolDefinitions {         )     ) -    private static let addCommentDescription = "Add a comment to a task. Identify the task by displayId or taskId."--    static let addComment = MCPToolDefinition(-        name: "add_comment",-        description: addCommentDescription,-        inputSchema: .object(-            properties: [-                "displayId": .integer("Task display ID (e.g. 42 for T-42)"),-                "taskId": .string("Task UUID"),-                "content": .string("Comment text (required)"),-                "authorName": .string("Author name (required)")-            ],-            required: ["content", "authorName"]-        )-    )--    static let createProject = MCPToolDefinition(-        name: "create_project",-        description: "Create a project. Returns projectId and metadata for subsequent task creation.",-        inputSchema: .object(-            properties: [-                "name": .string("Project name (required; trimmed, non-empty, case-insensitively unique)"),-                "colorHex": .string("Project color (required; six hexadecimal digits, optionally prefixed by #)"),-                "description": .string("Project description (optional, defaults to an empty string)"),-                "gitRepo": .string("Git repository URL or path (optional, free-form)")-            ],-            required: ["name", "colorHex"]-        )-    )+    nonisolated private static let addCommentDescription = """+        Add a comment to a task. Identify the task by displayId or taskId.+        """ -    static let getProjects = MCPToolDefinition(+    nonisolated static let addComment = protected(+        MCPToolDefinition(+            name: "add_comment",+            description: addCommentDescription,+            inputSchema: .object(+                properties: [+                    "displayId": .integer("Task display ID (e.g. 42 for T-42)"),+                    "taskId": .string("Task UUID"),+                    "content": .string("Comment text (required)"),+                    "authorName": .string("Author name (required)")+                ],+                required: ["content", "authorName"]+            )+        ))++    nonisolated static let createProject = protected(+        MCPToolDefinition(+            name: "create_project",+            description: "Create a project. Returns projectId and metadata for subsequent task creation.",+            inputSchema: .object(+                properties: [+                    "name": .string("Project name (required; trimmed, non-empty, case-insensitively unique)"),+                    "colorHex": .string(+                        "Project color (required; six hexadecimal digits, optionally prefixed by #)"),+                    "description": .string("Project description (optional, defaults to an empty string)"),+                    "gitRepo": .string("Git repository URL or path (optional, free-form)")+                ],+                required: ["name", "colorHex"]+            )+        ))++    nonisolated static let getProjects = MCPToolDefinition(         name: "get_projects",         description: "List all projects with metadata. Returns an array of project objects sorted by name.",         inputSchema: .object(properties: [:], required: [])@@ -174,27 +198,30 @@ nonisolated enum MCPToolDefinitions {      // MARK: - Milestone Tools -    // swiftlint:disable:next line_length-    private static let createMilestoneDescription = "Create a new milestone within a project. At least one of 'project' or 'projectId' is required."--    static let createMilestone = MCPToolDefinition(-        name: "create_milestone",-        description: createMilestoneDescription,-        inputSchema: .object(-            properties: [-                "name": .string("Milestone name (unique within project)"),-                "project": .string("Project name (case-insensitive)"),-                "projectId": .string("Project UUID (takes precedence over name)"),-                "description": .string("Optional description")-            ],-            required: ["name"]-        )-    )+    nonisolated private static let createMilestoneDescription = """+        Create a new milestone within a project. At least one of 'project' or 'projectId' is required.+        """ -    // swiftlint:disable:next line_length-    private static let queryMilestonesDescription = "List milestones with optional filters. Returns all milestones if no filters specified."+    nonisolated static let createMilestone = protected(+        MCPToolDefinition(+            name: "create_milestone",+            description: createMilestoneDescription,+            inputSchema: .object(+                properties: [+                    "name": .string("Milestone name (unique within project)"),+                    "project": .string("Project name (case-insensitive)"),+                    "projectId": .string("Project UUID (takes precedence over name)"),+                    "description": .string("Optional description")+                ],+                required: ["name"]+            )+        ))++    nonisolated private static let queryMilestonesDescription = """+        List milestones with optional filters. Returns all milestones if no filters specified.+        """ -    static let queryMilestones = MCPToolDefinition(+    nonisolated static let queryMilestones = MCPToolDefinition(         name: "query_milestones",         description: queryMilestonesDescription,         inputSchema: .object(@@ -212,76 +239,124 @@ nonisolated enum MCPToolDefinitions {         )     ) -    // swiftlint:disable:next line_length-    private static let updateMilestoneDescription = "Update a milestone's name, description, or status. Identify by displayId or milestoneId."+    nonisolated private static let updateMilestoneDescription = """+        Update a milestone's name, description, or status. Identify by displayId or milestoneId.+        """ -    static let updateMilestone = MCPToolDefinition(-        name: "update_milestone",-        description: updateMilestoneDescription,-        inputSchema: .object(-            properties: [-                "displayId": .integer("Milestone display ID (e.g. 3 for M-3)"),-                "milestoneId": .string("Milestone UUID"),-                "name": .string("New name"),-                "description": .string(-                    "New description. Pass \"\" or whitespace-only to clear."-                ),-                "status": .stringEnum(-                    "New status",-                    values: MilestoneStatus.allCases.map(\.rawValue)-                )-            ],-            required: []-        )-    )+    nonisolated static let updateMilestone = protected(+        MCPToolDefinition(+            name: "update_milestone",+            description: updateMilestoneDescription,+            inputSchema: .object(+                properties: [+                    "displayId": .integer("Milestone display ID (e.g. 3 for M-3)"),+                    "milestoneId": .string("Milestone UUID"),+                    "name": .string("New name"),+                    "description": .string(+                        "New description. Pass \"\" or whitespace-only to clear."+                    ),+                    "status": .stringEnum(+                        "New status",+                        values: MilestoneStatus.allCases.map(\.rawValue)+                    )+                ],+                required: []+            )+        ))++    nonisolated private static let deleteMilestoneDescription = """+        Delete a milestone. Tasks assigned to it lose their association but are not deleted. Identify by \+        displayId or milestoneId.+        """ -    // swiftlint:disable:next line_length-    private static let deleteMilestoneDescription = "Delete a milestone. Tasks assigned to it lose their association but are not deleted. Identify by displayId or milestoneId."+    nonisolated static let deleteMilestone = protected(+        MCPToolDefinition(+            name: "delete_milestone",+            description: deleteMilestoneDescription,+            inputSchema: .object(+                properties: [+                    "displayId": .integer("Milestone display ID (e.g. 3 for M-3)"),+                    "milestoneId": .string("Milestone UUID")+                ],+                required: []+            )+        ))++    nonisolated private static let updateTaskDescription = """+        Update a task's mutable fields (name, description, type, metadata, milestone) in a single atomic \+        call. Identify task by displayId or taskId.+        """ -    static let deleteMilestone = MCPToolDefinition(-        name: "delete_milestone",-        description: deleteMilestoneDescription,-        inputSchema: .object(-            properties: [-                "displayId": .integer("Milestone display ID (e.g. 3 for M-3)"),-                "milestoneId": .string("Milestone UUID")-            ],-            required: []-        )-    )+    nonisolated static let updateTask = protected(+        MCPToolDefinition(+            name: "update_task",+            description: updateTaskDescription,+            inputSchema: .object(+                properties: [+                    "displayId": .integer("Task display ID (e.g. 42 for T-42)"),+                    "taskId": .string("Task UUID"),+                    "name": .string("New task name (trimmed; must be non-empty after trim)"),+                    "description": .string(+                        "New task description. Pass \"\" or whitespace-only to clear."+                    ),+                    "type": .stringEnum(+                        "New task type (exact lowercase match required)",+                        values: TaskType.allCases.map(\.rawValue)+                    ),+                    "priority": .stringEnum(+                        "New task priority (exact lowercase match required; omit to leave unchanged)",+                        values: TaskPriority.allCases.map(\.rawValue)+                    ),+                    "metadata": .object(+                        "Replaces all metadata. Pass {} to clear it. Values must be strings."+                    ),+                    "milestone": .string("Milestone name (within task's project). Use clearMilestone to unassign."),+                    "milestoneDisplayId": .integer(+                        "Milestone display ID (e.g. 3 for M-3, takes precedence over name)"),+                    "clearMilestone": .boolean("Set to true to remove milestone assignment")+                ],+                required: []+            )+        ))+} -    // swiftlint:disable:next line_length-    private static let updateTaskDescription = "Update a task's mutable fields (name, description, type, metadata, milestone) in a single atomic call. Identify task by displayId or taskId."+extension MCPToolDefinitions {+    nonisolated private static let writeSafetyContract = """+        Requires a case-sensitive idempotencyKey matching [A-Za-z0-9._:-]{1,128}. \+        Retried identical arguments replay the original saved outcome for seven days across local-store restarts; \+        JSON object order is ignored and different payloads return IDEMPOTENCY_KEY_REUSED. \+        Results are JSON committed/rejected/in_progress/uncertain envelopes with saved records and r1 revisions. \+        Replay expiry is fixed; after it a retry may execute again. Uncertain outcomes require reconciliation; \+        never retry them with a fresh key. Revisions compare exact locally observed content, remain stable for no-ops \+        and restored content, and cannot detect edits not yet imported from CloudKit or prevent later sync conflicts. \+        Read a task or milestone first, write with its expectedRevision and a fresh key, then retry identical \+        arguments \+        with that key after a timeout. REVISION_CONFLICT returns the currentRecord and no effect; use a new key after \+        reviewing it. Keys are scoped to this local store and tool, independently of connection/session/request ID. \+        Cross-device deduplication and atomic batches are not provided.+        """++    nonisolated private static func protected(_ definition: MCPToolDefinition) -> MCPToolDefinition {+        var properties = definition.inputSchema.properties ?? [:]+        var key = JSONSchemaProperty.string("Required retry key; UUID strings are suitable")+        key.pattern = "^[A-Za-z0-9._:-]{1,128}$"+        properties["idempotencyKey"] = key+        var required = definition.inputSchema.required ?? []+        required.append("idempotencyKey")+        if ["update_task", "update_task_status", "update_milestone", "delete_milestone"].contains(definition.name) {+            var revision = JSONSchemaProperty.string("Required target revision from the full read response")+            revision.pattern = "^r1:[0-9a-f]{64}$"+            properties["expectedRevision"] = revision+            required.append("expectedRevision")+        }+        var schema = JSONSchema.object(properties: properties, required: required)+        schema.additionalProperties = false+        return MCPToolDefinition(+            name: definition.name,+            description: definition.description + " " + writeSafetyContract,+            inputSchema: schema)+    } -    static let updateTask = MCPToolDefinition(-        name: "update_task",-        description: updateTaskDescription,-        inputSchema: .object(-            properties: [-                "displayId": .integer("Task display ID (e.g. 42 for T-42)"),-                "taskId": .string("Task UUID"),-                "name": .string("New task name (trimmed; must be non-empty after trim)"),-                "description": .string(-                    "New task description. Pass \"\" or whitespace-only to clear."-                ),-                "type": .stringEnum(-                    "New task type (exact lowercase match required)",-                    values: TaskType.allCases.map(\.rawValue)-                ),-                "priority": .stringEnum(-                    "New task priority (exact lowercase match required; omit to leave unchanged)",-                    values: TaskPriority.allCases.map(\.rawValue)-                ),-                "metadata": .object(-                    "Replaces the entire metadata dictionary. Pass {} to clear all metadata. Values must be strings."-                ),-                "milestone": .string("Milestone name (within task's project). Use clearMilestone to unassign."),-                "milestoneDisplayId": .integer("Milestone display ID (e.g. 3 for M-3, takes precedence over name)"),-                "clearMilestone": .boolean("Set to true to remove milestone assignment")-            ],-            required: []-        )-    ) }  #endif
Transit/Transit/MCP/MCPToolHandler.swift Modified +60 / -764
diff --git a/Transit/Transit/MCP/MCPToolHandler.swift b/Transit/Transit/MCP/MCPToolHandler.swiftindex 5e0c3b3..d427744 100644--- a/Transit/Transit/MCP/MCPToolHandler.swift+++ b/Transit/Transit/MCP/MCPToolHandler.swift@@ -19,7 +19,6 @@ final class MCPToolHandler {     private let taskService: TaskService     private let taskFetcher: any TaskFetching     private let projectService: ProjectService-    private let commentService: CommentService     private let commentFetcher: any CommentFetching     private let milestoneService: MilestoneService     private let milestoneFetcher: any MilestoneFetching@@ -27,6 +26,7 @@ final class MCPToolHandler {     private let maintenanceService: DisplayIDMaintenanceService     private let settings: MCPSettings     private let persistence: PersistenceAvailability+    private let writeCoordinator: MCPWriteCoordinator?      /// Tools that only read.     private static let readOnlyToolNames: Set<String> = [@@ -47,23 +47,24 @@ final class MCPToolHandler {         milestoneService: MilestoneService,         maintenanceService: DisplayIDMaintenanceService,         settings: MCPSettings,-        persistence: PersistenceAvailability = .shared,+        persistence: PersistenceAvailability? = nil,         taskFetcher: (any TaskFetching)? = nil,         commentFetcher: (any CommentFetching)? = nil,         milestoneFetcher: (any MilestoneFetching)? = nil,-        milestoneDisplayIDFinder: (any MilestoneDisplayIDFinding)? = nil+        milestoneDisplayIDFinder: (any MilestoneDisplayIDFinding)? = nil,+        writeCoordinator: MCPWriteCoordinator? = nil     ) {         self.taskService = taskService         self.taskFetcher = taskFetcher ?? taskService         self.projectService = projectService-        self.commentService = commentService         self.commentFetcher = commentFetcher ?? commentService         self.milestoneService = milestoneService         self.milestoneFetcher = milestoneFetcher ?? milestoneService         self.milestoneDisplayIDFinder = milestoneDisplayIDFinder ?? milestoneService         self.maintenanceService = maintenanceService         self.settings = settings-        self.persistence = persistence+        self.persistence = persistence ?? .shared+        self.writeCoordinator = writeCoordinator     }      // MARK: - JSON-RPC Dispatch@@ -162,7 +163,8 @@ final class MCPToolHandler {             return invalidInitializeParams(id: id, message: error.message)         } -        let protocolVersion = Self.supportedProtocolVersions.contains(requestedProtocolVersion)+        let protocolVersion =+            Self.supportedProtocolVersions.contains(requestedProtocolVersion)             ? requestedProtocolVersion             : Self.latestSupportedProtocolVersion         let version = Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String ?? "1.0"@@ -244,7 +246,8 @@ final class MCPToolHandler {         params: AnyCodable?     ) async -> JSONRPCResponse {         guard let dict = params?.value as? [String: Any],-              let name = dict["name"] as? String else {+            let name = dict["name"] as? String+        else {             return JSONRPCResponse.error(                 id: id,                 code: JSONRPCErrorCode.invalidParams,@@ -272,6 +275,30 @@ final class MCPToolHandler {             )         } +        if MCPWriteCommand.protectedTools.contains(name) {+            let result: MCPToolResult+            if let writeCoordinator {+                result = await writeCoordinator.execute(tool: name, arguments: arguments)+            } else {+                do {+                    let command = try MCPWriteCommand.validate(tool: name, arguments: arguments)+                    result = MCPWriteOutcome.result(+                        MCPWriteOutcome.failure(+                            tool: name, key: command.key,+                            failure: .init("PERSISTENCE_UNAVAILABLE", "Protected write storage is not available"),+                            accepted: false, retryAction: "retry_same_request"+                        ), isError: true)+                } catch {+                    result = MCPWriteOutcome.result(+                        MCPWriteOutcome.failure(+                            tool: name, key: arguments["idempotencyKey"] as? String,+                            failure: MCPWriteFailure.from(error), accepted: false+                        ), isError: true)+                }+            }+            return JSONRPCResponse.success(id: id, result: result)+        }+         // Reject mutations while Transit is running on the in-memory fallback container. The         // write would look successful and then vanish on restart, and an MCP client never sees         // the app's degraded-storage alert, so success is indistinguishable from durable@@ -285,28 +312,12 @@ final class MCPToolHandler {          let result: MCPToolResult         switch name {-        case "create_task":-            result = await handleCreateTask(arguments)-        case "update_task_status":-            result = handleUpdateStatus(arguments)         case "query_tasks":             result = handleQueryTasks(arguments)-        case "add_comment":-            result = handleAddComment(arguments)-        case "create_project":-            result = handleCreateProject(arguments)         case "get_projects":             result = handleGetProjects()-        case "create_milestone":-            result = await handleCreateMilestone(arguments)         case "query_milestones":             result = handleQueryMilestones(arguments)-        case "update_milestone":-            result = handleUpdateMilestone(arguments)-        case "delete_milestone":-            result = handleDeleteMilestone(arguments)-        case "update_task":-            result = handleUpdateTask(arguments)         case "scan_duplicate_display_ids":             result = handleScanDuplicateDisplayIds()         case "reassign_duplicate_display_ids":@@ -344,215 +355,6 @@ final class MCPToolHandler {      // MARK: - create_task -    // swiftlint:disable:next cyclomatic_complexity function_body_length-    private func handleCreateTask(_ args: [String: Any]) async -> MCPToolResult {-        let name: String-        switch requiredString(args, key: "name") {-        case .success(let value): name = value-        case .failure(.message(let message)): return errorResult(message)-        }-        guard args["type"] != nil else {-            return errorResult("Missing required argument: type")-        }-        guard let typeRaw = args["type"] as? String else {-            return errorResult("type must be a string")-        }-        guard let taskType = TaskType(rawValue: typeRaw) else {-            let valid = TaskType.allCases.map(\.rawValue).joined(separator: ", ")-            return errorResult("Invalid type: \(typeRaw). Must be one of: \(valid)")-        }-        // A present metadata value must be an object. Keep the distinction from omission so-        // malformed values cannot be silently converted to nil by stringMetadata [T-1991].-        if let rawMetadata = args["metadata"], !IntentHelpers.isMetadataObject(rawMetadata) {-            return errorResult("metadata must be an object")-        }--        // Priority is optional and defaults to medium. A present-but-invalid value-        // is rejected before any task is created (Req 5.5).-        let priority: TaskPriority-        if let priorityRaw = args["priority"] {-            guard let priorityStr = priorityRaw as? String else {-                return errorResult("priority must be a string")-            }-            guard let parsed = TaskPriority(rawValue: priorityStr) else {-                let valid = TaskPriority.allCases.map(\.rawValue).joined(separator: ", ")-                return errorResult("Invalid priority: \(priorityStr). Must be one of: \(valid)")-            }-            priority = parsed-        } else {-            priority = .medium-        }--        // Reject malformed or non-string projectId when the key is present-        // [T-743, T-788].-        let projectId: UUID?-        switch parseProjectIdArgument(args) {-        case .failure(.message(let message)): return errorResult(message)-        case .success(let parsed): projectId = parsed-        }-        // Reject a present non-string `project` when projectId is absent [T-1453].-        // Without this guard `as? String` silently drops the malformed value and the-        // request falls through to the generic missing-project error instead of-        // surfacing the type mismatch. projectId-takes-precedence is preserved: when a-        // valid projectId is present the `project` name is ignored regardless of type.-        if projectId == nil, let rawProject = args["project"], !(rawProject is String) {-            return errorResult("project must be a string")-        }-        let projectName = args["project"] as? String-        let project: Project-        switch projectService.findProject(id: projectId, name: projectName) {-        case .success(let found):-            project = found-        case .failure(let error):-            return errorResult(IntentHelpers.mapProjectLookupError(error).hint)-        }--        // Pre-validate milestone before creating the task to avoid orphans.-        // Reject non-integer milestoneDisplayId when key is present [T-613]-        if args["milestoneDisplayId"] != nil, IntentHelpers.parseIntValue(args["milestoneDisplayId"]) == nil {-            return errorResult("milestoneDisplayId must be an integer")-        }-        var resolvedMilestone: Milestone?-        if let milestoneDisplayId = IntentHelpers.parseIntValue(args["milestoneDisplayId"]) {-            do {-                resolvedMilestone = try milestoneService.findByDisplayID(milestoneDisplayId)-            } catch MilestoneService.Error.milestoneNotFound {-                return errorResult("No milestone with displayId \(milestoneDisplayId)")-            } catch MilestoneService.Error.duplicateDisplayID {-                return errorResult("Duplicate milestone identifier detected for displayId \(milestoneDisplayId)")-            } catch {-                return errorResult("Failed to find milestone: \(error)")-            }-            guard let milestoneProject = resolvedMilestone?.project,-                  milestoneProject.id == project.id else {-                return errorResult("Milestone and task must belong to the same project")-            }-        } else if args["milestone"] != nil {-            // Reject non-string milestone values [T-1114]. Without this guard-            // a numeric or boolean milestone arg would fall through to the-            // "absent" branch and the task would be created without the-            // requested assignment.-            guard let milestoneName = args["milestone"] as? String else {-                return errorResult("milestone must be a string")-            }-            do {-                guard let milestone = try milestoneService.findByName(milestoneName, in: project) else {-                    return errorResult("No milestone named '\(milestoneName)' in project '\(project.name)'")-                }-                resolvedMilestone = milestone-            } catch MilestoneService.Error.ambiguousName {-                return errorResult(-                    "Multiple milestones named '\(milestoneName)' exist in project '\(project.name)'"-                )-            } catch {-                return errorResult("Failed to look up milestone: \(error)")-            }-        }--        // Reject non-string description: as? String silently drops-        // present-but-wrong-type values, making a malformed request look successful. [T-1192]-        if args["description"] != nil, args["description"] as? String == nil {-            return errorResult("description must be a string")-        }--        let task: TransitTask-        do {-            task = try await taskService.createTask(-                name: name,-                description: args["description"] as? String,-                type: taskType,-                project: project,-                metadata: IntentHelpers.stringMetadata(from: args["metadata"]),-                priority: priority,-                milestone: resolvedMilestone-            )-        } catch TaskService.Error.milestoneNotOpen {-            return errorResult("The selected milestone is no longer open")-        } catch TaskService.Error.projectNotFound {-            return errorResult("No matching project found")-        } catch {-            return errorResult("Task creation failed: \(error)")-        }--        var response: [String: Any] = [-            "taskId": task.id.uuidString,-            "status": task.statusRawValue,-            "priority": task.priority.rawValue-        ]-        if let displayId = task.permanentDisplayId {-            response["displayId"] = displayId-        }-        if let milestone = task.milestone {-            var milestoneDict: [String: Any] = [-                "milestoneId": milestone.id.uuidString,-                "name": milestone.name-            ]-            if let mDisplayId = milestone.permanentDisplayId {-                milestoneDict["displayId"] = mDisplayId-            }-            response["milestone"] = milestoneDict-        }-        return textResult(IntentHelpers.encodeJSON(response))-    }--    // MARK: - update_task_status--    private func handleUpdateStatus(_ args: [String: Any]) -> MCPToolResult {-        // When the "status" argument is present it MUST be a string — a non-string-        // value would otherwise be silently dropped by `as? String` and misreported-        // as missing. Reject it before any mutation, like the milestone paths [T-1544].-        guard args["status"] != nil else {-            return errorResult("Missing required argument: status")-        }-        guard let statusString = args["status"] as? String else {-            return errorResult("status must be a string")-        }-        guard let newStatus = TaskStatus(rawValue: statusString) else {-            let valid = TaskStatus.allCases.map(\.rawValue).joined(separator: ", ")-            return errorResult("Invalid status: \(statusString). Must be one of: \(valid)")-        }--        // Reject non-integer displayId when key is present [T-634]-        if args["displayId"] != nil, IntentHelpers.parseIntValue(args["displayId"]) == nil {-            return errorResult("displayId must be an integer")-        }--        let task: TransitTask-        switch resolveTaskArgument(args) {-        case .success(let resolved): task = resolved-        case .failure(.message(let message)): return errorResult(message)-        }--        // Reject non-string comment/authorName: as? String silently drops-        // present-but-wrong-type values, dropping the audit-trail entry. [T-1205]-        if args["comment"] != nil, !(args["comment"] is String) {-            return errorResult("comment must be a string")-        }-        if args["authorName"] != nil, !(args["authorName"] is String) {-            return errorResult("authorName must be a string")-        }-        let commentText = args["comment"] as? String-        let commentAuthor = args["authorName"] as? String-        if let commentError = validateCommentArgs(comment: commentText, author: commentAuthor) {-            return commentError-        }--        let previousStatus = task.statusRawValue-        let createdComment: Comment?-        do {-            createdComment = try taskService.updateStatus(-                task: task, to: newStatus,-                comment: commentText, commentAuthor: commentAuthor, commentService: commentService-            )-        } catch {-            return errorResult("Status update failed: \(error)")-        }--        var response = statusResponse(task: task, previousStatus: previousStatus, newStatus: newStatus)-        response["comment"] = createdComment.map(commentResponse)-        return textResult(IntentHelpers.encodeJSON(response))-    }-     // MARK: - query_tasks      // swiftlint:disable:next cyclomatic_complexity function_body_length@@ -582,7 +384,7 @@ final class MCPToolHandler {             case .failure(let err): return errorResult(IntentHelpers.mapProjectLookupError(err).hint)             }         } else if let name = args["project"] as? String,-                  !name.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {+            !name.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {             switch projectService.findProject(id: nil, name: name) {             case .success(let found):                 resolvedProject = found@@ -645,8 +447,8 @@ final class MCPToolHandler {                 return errorResult("Failed to look up milestone: \(error)")             }         } else if let milestoneName = args["milestone"] as? String,-                  !milestoneName.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {-            if let projectFilter {+            !milestoneName.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {+            if projectFilter != nil {                 // Scoped to a single project — at most one milestone matches.                 guard let project = resolvedProject else {                     return textResult(IntentHelpers.encodeJSONArray([]))@@ -750,68 +552,6 @@ final class MCPToolHandler {  } -// MARK: - create_milestone--extension MCPToolHandler {--    // swiftlint:disable:next cyclomatic_complexity-    private func handleCreateMilestone(_ args: [String: Any]) async -> MCPToolResult {-        let name: String-        switch requiredString(args, key: "name") {-        case .success(let value): name = value-        case .failure(.message(let message)): return errorResult(message)-        }--        // Reject malformed or non-string projectId when the key is present-        // [T-743, T-788].-        let projectId: UUID?-        switch parseProjectIdArgument(args) {-        case .failure(.message(let message)): return errorResult(message)-        case .success(let parsed): projectId = parsed-        }-        // Reject a present non-string `project` when projectId is absent [T-1453].-        // Mirrors handleCreateTask: a malformed `project` must surface as a type-        // mismatch rather than being silently dropped by `as? String`.-        if projectId == nil, let rawProject = args["project"], !(rawProject is String) {-            return errorResult("project must be a string")-        }-        let projectName = args["project"] as? String-        let project: Project-        switch projectService.findProject(id: projectId, name: projectName) {-        case .success(let found):-            project = found-        case .failure(let error):-            return errorResult(IntentHelpers.mapProjectLookupError(error).hint)-        }--        // Reject non-string description: as? String silently drops-        // present-but-wrong-type values, making a malformed request look successful. [T-1192]-        if args["description"] != nil, args["description"] as? String == nil {-            return errorResult("description must be a string")-        }--        let milestone: Milestone-        do {-            milestone = try await milestoneService.createMilestone(-                name: name,-                description: args["description"] as? String,-                project: project-            )-        } catch MilestoneService.Error.duplicateName {-            return errorResult("A milestone with this name already exists in the project")-        } catch MilestoneService.Error.invalidName {-            return errorResult("Milestone name cannot be empty")-        } catch MilestoneService.Error.projectNotFound {-            return errorResult("No matching project found")-        } catch {-            return errorResult("Milestone creation failed: \(error)")-        }--        let formatter = ISO8601DateFormatter()-        return textResult(IntentHelpers.encodeJSON(milestoneToDict(milestone, formatter: formatter)))-    }-}- // MARK: - query_milestones  extension MCPToolHandler {@@ -855,8 +595,10 @@ extension MCPToolHandler {          let filtered = allMilestones.filter { milestoneMatches($0, args: args, projectFilter: projectFilter) }         let formatter = ISO8601DateFormatter()-        let results = filtered.map { milestoneToDict($0, formatter: formatter) }-        return textResult(IntentHelpers.encodeJSONArray(results))+        do {+            let results = try filtered.map { try milestoneToDict($0, formatter: formatter) }+            return textResult(IntentHelpers.encodeJSONArray(results))+        } catch { return errorResult("Failed to capture milestones: \(error)") }     }      /// Returns true when `milestone` satisfies the project/status/search filters in `args`.@@ -873,7 +615,7 @@ extension MCPToolHandler {             if milestone.statusRawValue != statusSingle { return false }         }         if let search = args["search"] as? String,-           !search.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {+            !search.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {             let nameMatch = milestone.name.localizedCaseInsensitiveContains(search)             let descMatch = milestone.milestoneDescription?.localizedCaseInsensitiveContains(search) ?? false             if !nameMatch && !descMatch { return false }@@ -890,7 +632,7 @@ extension MCPToolHandler {                 return textResult(IntentHelpers.encodeJSONArray([]))             }             let formatter = ISO8601DateFormatter()-            let dict = milestoneToDict(milestone, formatter: formatter, detailed: true)+            let dict = try milestoneToDict(milestone, formatter: formatter, detailed: true)             return textResult(IntentHelpers.encodeJSONArray([dict]))         } catch MilestoneService.Error.milestoneNotFound {             return textResult(IntentHelpers.encodeJSONArray([]))@@ -925,7 +667,7 @@ extension MCPToolHandler {                 return .error("project must be a string")             }             if let name = args["project"] as? String,-               !name.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {+                !name.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {                 switch projectService.findProject(id: nil, name: name) {                 case .success(let found):                     return .resolved(found.id)@@ -938,301 +680,13 @@ extension MCPToolHandler {     } } -// MARK: - update_milestone--extension MCPToolHandler {--    private func handleUpdateMilestone(_ args: [String: Any]) -> MCPToolResult {-        let milestone: Milestone-        switch resolveMilestone(from: args) {-        case .success(let found): milestone = found-        case .failure(.message(let message)): return errorResult(message)-        }--        let previousStatus = milestone.statusRawValue--        // Validate all inputs before applying any changes (T-391: avoid partial updates)-        let validated: ValidatedMilestoneUpdate-        switch validateMilestoneUpdate(args, milestone: milestone) {-        case .valid(let update): validated = update-        case .invalid(let error): return error-        }--        // Apply all changes in memory, then save atomically-        applyMilestoneUpdate(validated, to: milestone)--        if validated.hasChanges {-            do {-                try milestoneService.save()-            } catch {-                return errorResult("Update failed: \(error)")-            }-        }--        let formatter = ISO8601DateFormatter()-        var response = milestoneToDict(milestone, formatter: formatter)-        response["previousStatus"] = previousStatus-        return textResult(IntentHelpers.encodeJSON(response))-    }--    private struct ValidatedMilestoneUpdate {-        let status: MilestoneStatus?-        let name: String?-        let description: FieldChange<String>-        var hasChanges: Bool { status != nil || name != nil || description.isChange }-    }--    private enum MilestoneValidation {-        case valid(ValidatedMilestoneUpdate)-        case invalid(MCPToolResult)-    }--    private func validateMilestoneUpdate(-        _ args: [String: Any], milestone: Milestone-    ) -> MilestoneValidation {-        // When the key is present it MUST be a string — a non-string value (e.g. integer,-        // boolean, null) would otherwise be silently dropped by `as? String`, letting other-        // update fields (name, description) apply with the malformed status quietly ignored [T-830].-        var newStatus: MilestoneStatus?-        if args["status"] != nil {-            guard let statusRaw = args["status"] as? String else {-                return .invalid(errorResult("status must be a string"))-            }-            guard let parsed = MilestoneStatus(rawValue: statusRaw) else {-                let valid = MilestoneStatus.allCases.map(\.rawValue).joined(separator: ", ")-                return .invalid(errorResult("Invalid status: \(statusRaw). Must be one of: \(valid)"))-            }-            newStatus = parsed-        }--        // Validate name. When the key is present it MUST be a string — a non-string-        // value (integer, boolean, null, array) would otherwise be silently dropped-        // by `as? String`, letting other update fields apply with the malformed-        // rename quietly ignored [T-1230].-        var trimmedName: String?-        if let rawName = args["name"] {-            guard let newName = rawName as? String else {-                return .invalid(errorResult("name must be a string"))-            }-            let trimmed = newName.trimmingCharacters(in: .whitespacesAndNewlines)-            guard !trimmed.isEmpty else {-                return .invalid(errorResult("Milestone name cannot be empty"))-            }-            if let conflict = milestoneRenameConflict(trimmed, milestone: milestone) {-                return .invalid(conflict)-            }-            trimmedName = trimmed-        }--        // Validate description. Same reasoning as name: a present-but-non-string-        // value must be rejected rather than silently dropped [T-1230]. An empty-        // or whitespace-only string is an explicit clear signal that sets the-        // description back to nil, mirroring update_task's clear semantics [T-1555].-        let newDescription: FieldChange<String>-        if let rawDescription = args["description"] {-            guard let descriptionString = rawDescription as? String else {-                return .invalid(errorResult("description must be a string"))-            }-            let trimmed = descriptionString.trimmingCharacters(in: .whitespacesAndNewlines)-            newDescription = trimmed.isEmpty ? .clear : .set(trimmed)-        } else {-            newDescription = .noChange-        }--        return .valid(ValidatedMilestoneUpdate(-            status: newStatus, name: trimmedName, description: newDescription-        ))-    }--    /// Error result for a rename that collides with an existing milestone in the same-    /// project, or `nil` when the name is free.-    ///-    /// A failed duplicate check reports the storage error rather than "no conflict":-    /// CloudKit-backed SwiftData has no unique constraint, so this check is the whole-    /// uniqueness invariant and a swallowed fetch failure would commit a duplicate-    /// name [T-1614].-    private func milestoneRenameConflict(_ name: String, milestone: Milestone) -> MCPToolResult? {-        guard let project = milestone.project else { return nil }-        do {-            guard try milestoneService.milestoneNameExists(name, in: project, excluding: milestone.id) else {-                return nil-            }-            return errorResult("A milestone with this name already exists in the project")-        } catch {-            return errorResult("Milestone name check failed: \(error)")-        }-    }--    private func applyMilestoneUpdate(_ update: ValidatedMilestoneUpdate, to milestone: Milestone) {-        // T-923: Skip timestamp writes when the requested status matches the-        // current status so same-status retries don't rewrite completion dates.-        if let newStatus = update.status, milestone.statusRawValue != newStatus.rawValue {-            milestone.statusRawValue = newStatus.rawValue-            milestone.lastStatusChangeDate = Date.now-            milestone.completionDate = newStatus.isTerminal ? Date.now : nil-        }-        if let name = update.name {-            milestone.name = name-        }-        switch update.description {-        case .noChange:-            break-        case .set(let value):-            milestone.milestoneDescription = value-        case .clear:-            milestone.milestoneDescription = nil-        }-    }-}--// MARK: - delete_milestone--extension MCPToolHandler {--    private func handleDeleteMilestone(_ args: [String: Any]) -> MCPToolResult {-        let milestone: Milestone-        switch resolveMilestone(from: args) {-        case .success(let found): milestone = found-        case .failure(.message(let message)): return errorResult(message)-        }--        let milestoneId = milestone.id.uuidString-        let displayId = milestone.permanentDisplayId-        let name = milestone.name-        let affectedTasks = (milestone.tasks ?? []).count--        do {-            try milestoneService.deleteMilestone(milestone)-        } catch {-            return errorResult("Delete failed: \(error)")-        }--        var response: [String: Any] = [-            "deleted": true,-            "milestoneId": milestoneId,-            "name": name,-            "affectedTasks": affectedTasks-        ]-        if let displayId { response["displayId"] = displayId }-        return textResult(IntentHelpers.encodeJSON(response))-    }-}--// MARK: - update_task--extension MCPToolHandler {--    /// Updates one or more mutable fields on a task in a single atomic call.-    ///-    /// Field validation, milestone resolution, and applier logic are delegated-    /// to `TaskUpdateValidator` so that the MCP tool and `UpdateTaskIntent`-    /// share identical semantics. The identifier-resolution preamble preserves-    /// the existing T-634/T-808 behavior — present-but-malformed identifiers-    /// surface as field-specific INVALID_INPUT messages, not as a generic-    /// not-found. The response shape is built by-    /// `IntentHelpers.taskUpdateResponseDict` (AC 9.1).-    private func handleUpdateTask(_ args: [String: Any]) -> MCPToolResult {-        // Identifier resolution (preserve existing T-634 / T-808 behavior)-        // Reject non-integer displayId when key is present [T-634]-        if args["displayId"] != nil, IntentHelpers.parseIntValue(args["displayId"]) == nil {-            return errorResult("displayId must be an integer")-        }--        let task: TransitTask-        switch resolveTaskArgument(args) {-        case .success(let resolved): task = resolved-        case .failure(.message(let message)): return errorResult(message)-        }--        // Validate every field before applying any change. The validator is-        // pure — no mutations occur on success or failure, so an early return-        // here leaves the task untouched.-        let update: ValidatedTaskUpdate-        switch TaskUpdateValidator.validate(args, task: task, milestoneService: milestoneService) {-        case .success(let validated):-            update = validated-        case .failure(let error):-            return errorResult(error.mcpMessage)-        }--        // No-op echo: when the request includes only an identifier (and no-        // mutating field), skip the save and return the current task JSON.-        guard update.hasChanges else {-            return textResult(IntentHelpers.encodeJSON(IntentHelpers.taskUpdateResponseDict(task)))-        }--        // Apply in memory. If a service call throws between the two underlying-        // service calls (`updateTask` then `setMilestone`), explicitly roll-        // back so any partial mutation does not leak into the saved state.-        do {-            try TaskUpdateValidator.apply(-                update, to: task, taskService: taskService, milestoneService: milestoneService-            )-        } catch {-            taskService.rollback()-            return errorResult("Update failed: \(error)")-        }--        // Save. `TaskService.save()` already calls `safeRollback()` on failure.-        do {-            try taskService.save()-        } catch {-            return errorResult("Update failed: \(error)")-        }--        return textResult(IntentHelpers.encodeJSON(IntentHelpers.taskUpdateResponseDict(task)))-    }-}- // MARK: - get_projects, add_comment & Helpers  extension MCPToolHandler { -    private func handleCreateProject(_ args: [String: Any]) -> MCPToolResult {-        let name: String-        switch requiredString(args, key: "name") {-        case .success(let value): name = value-        case .failure(.message(let message)): return errorResult(message)-        }-        let colorHex: String-        switch requiredString(args, key: "colorHex") {-        case .success(let value): colorHex = value-        case .failure(.message(let message)): return errorResult(message)-        }-        // Compare the whole range: regex $ can also match before a final newline.-        guard let range = colorHex.range(of: "^#?[0-9A-Fa-f]{6}$", options: .regularExpression),-              range == colorHex.startIndex..<colorHex.endIndex else {-            return errorResult("Invalid colorHex: expected six hexadecimal digits, optionally prefixed by #")-        }-        for key in ["description", "gitRepo"] {-            if let raw = args[key], !(raw is String) {-                return errorResult("\(key) must be a string")-            }-        }-        do {-            let project = try projectService.createProject(-                name: name,-                description: args["description"] as? String ?? "",-                gitRepo: args["gitRepo"] as? String,-                colorHex: colorHex-            )-            return textResult(IntentHelpers.encodeJSON(projectMetadataDict(project)))-        } catch ProjectMutationError.invalidName {-            return errorResult("Project name must not be empty or whitespace-only")-        } catch ProjectMutationError.duplicateName(let name) {-            return errorResult("A project named \"\(name)\" already exists")-        } catch {-            return errorResult("Failed to create project: \(error)")-        }-    }--    private func projectMetadataDict(_ project: Project) -> [String: Any] {-        var dict: [String: Any] = [-            "projectId": project.id.uuidString, "name": project.name,-            "description": project.projectDescription, "colorHex": project.colorHex,-            "activeTaskCount": projectService.activeTaskCount(for: project)-        ]-        if let gitRepo = project.gitRepo { dict["gitRepo"] = gitRepo }+    private func projectMetadataDict(_ project: Project) throws -> [String: Any] {+        var dict = try MCPRecordSnapshot.project(project).record+        dict["activeTaskCount"] = projectService.activeTaskCount(for: project)         return dict     } @@ -1245,7 +699,10 @@ extension MCPToolHandler {         }         var results: [[String: Any]] = []         for project in projects {-            var dict = projectMetadataDict(project)+            var dict: [String: Any]+            do { dict = try projectMetadataDict(project) } catch {+                return errorResult("Failed to capture project: \(error)")+            }              let milestones: [Milestone]             do {@@ -1261,110 +718,12 @@ extension MCPToolHandler {         return textResult(IntentHelpers.encodeJSONArray(results))     } -    private func handleAddComment(_ args: [String: Any]) -> MCPToolResult {-        // Distinguish a missing required field from a present-but-non-string one.-        // A bare `as? String` would silently drop a number/bool/array/null and-        // misreport it as "Missing required argument", so reject the type-        // mismatch with a field-specific message first, mirroring-        // update_task_status [T-1205, T-1579].-        let content: String-        switch requiredString(args, key: "content") {-        case .success(let value): content = value-        case .failure(.message(let message)): return errorResult(message)-        }-        let authorName: String-        switch requiredString(args, key: "authorName") {-        case .success(let value): authorName = value-        case .failure(.message(let message)): return errorResult(message)-        }--        // Reject non-integer displayId when key is present [T-634]-        if args["displayId"] != nil, IntentHelpers.parseIntValue(args["displayId"]) == nil {-            return errorResult("displayId must be an integer")-        }--        let task: TransitTask-        switch resolveTaskArgument(args) {-        case .success(let resolved): task = resolved-        case .failure(.message(let message)): return errorResult(message)-        }--        let comment: Comment-        do {-            comment = try commentService.addComment(-                to: task, content: content, authorName: authorName, isAgent: true-            )-        } catch CommentService.Error.emptyContent {-            return errorResult("Comment content cannot be empty")-        } catch CommentService.Error.emptyAuthorName {-            return errorResult("Author name cannot be empty")-        } catch {-            return errorResult("Failed to add comment: \(error)")-        }--        return textResult(IntentHelpers.encodeJSON(commentResponse(comment)))-    }-     // MARK: - Helpers -    private func validateCommentArgs(comment: String?, author: String?) -> MCPToolResult? {-        guard let comment, !comment.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {-            return nil-        }-        guard let author, !author.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {-            return errorResult("authorName is required when comment is provided")-        }-        return nil-    }--    private func statusResponse(-        task: TransitTask, previousStatus: String, newStatus: TaskStatus-    ) -> [String: Any] {-        var res: [String: Any] = [-            "taskId": task.id.uuidString, "previousStatus": previousStatus, "status": newStatus.rawValue-        ]-        if let displayId = task.permanentDisplayId { res["displayId"] = displayId }-        return res-    }--    private func commentResponse(_ comment: Comment) -> [String: Any] {-        let formatter = ISO8601DateFormatter()-        return [-            "id": comment.id.uuidString,-            "authorName": comment.authorName,-            "content": comment.content,-            "creationDate": formatter.string(from: comment.creationDate)-        ]-    }-     enum ResolveError: Error {         case message(String)     } -    /// Resolves the task identified by `args`, mapping resolver failures to MCP messages.-    ///-    /// Shared by every task mutation tool so the three surfaces cannot drift apart.-    /// `duplicateDisplayID` needs its own branch: more than one task carries the-    /// requested display ID, which the operator repairs with display-ID maintenance.-    /// The catch-all used to report it as "provide either displayId or taskId", so-    /// duplicate-ID corruption was indistinguishable from a missing task. Wording-    /// mirrors the milestone resolver's duplicate branch. [T-1837]-    private func resolveTaskArgument(_ args: [String: Any]) -> Result<TransitTask, ResolveError> {-        do {-            return .success(try taskService.resolveTask(from: args))-        } catch TaskService.Error.invalidIdentifier(let field) {-            // Reject malformed identifiers with a field-specific message-            // instead of returning the generic not-found error. [T-808]-            return .failure(.message(IntentHelpers.invalidIdentifierHint(for: field)))-        } catch TaskService.Error.duplicateDisplayID {-            return .failure(.message(-                duplicateTaskIdentifierMessage(displayId: IntentHelpers.parseIntValue(args["displayId"]))-            ))-        } catch {-            return .failure(.message("Provide either displayId (integer) or taskId (UUID string)"))-        }-    }-     /// Message for a display ID matched by more than one task. [T-1837]     private func duplicateTaskIdentifierMessage(displayId: Int?) -> String {         guard let displayId else { return "Duplicate task identifier detected" }@@ -1391,26 +750,6 @@ extension MCPToolHandler {         return .success(dict)     } -    /// Validates a required string argument by key, distinguishing a missing-    /// field from a present-but-malformed one. Returns `.success(value)` for a-    /// non-empty string, or `.failure` with "Missing required argument: <key>"-    /// when absent/empty and "<key> must be a string" when present but not a-    /// string (number, boolean, array, null). Without the explicit type check a-    /// bare `as? String` collapses malformed values into the missing-field-    /// error [T-1579].-    private func requiredString(_ args: [String: Any], key: String) -> Result<String, ResolveError> {-        guard let raw = args[key] else {-            return .failure(.message("Missing required argument: \(key)"))-        }-        guard let value = raw as? String else {-            return .failure(.message("\(key) must be a string"))-        }-        guard !value.isEmpty else {-            return .failure(.message("Missing required argument: \(key)"))-        }-        return .success(value)-    }-     /// Validates a UUID-shaped argument by key. Returns `.success(nil)` when the     /// key is absent, `.success(uuid)` when the value is a valid UUID string,     /// or `.failure(.message(...))` when the key is present but the value is not@@ -1472,52 +811,10 @@ extension MCPToolHandler {         return nil     } -    private func resolveMilestone(from args: [String: Any]) -> Result<Milestone, ResolveError> {-        // Reject non-integer displayId when key is present [T-634]-        if args["displayId"] != nil {-            guard let displayId = IntentHelpers.parseIntValue(args["displayId"]) else {-                return .failure(.message("displayId must be an integer"))-            }-            do {-                return .success(try milestoneService.findByDisplayID(displayId))-            } catch MilestoneService.Error.duplicateDisplayID {-                return .failure(.message("Duplicate milestone identifier detected for displayId \(displayId)"))-            } catch {-                return .failure(.message("No milestone with displayId \(displayId)"))-            }-        } else if args["milestoneId"] != nil {-            // Validate type and UUID format separately from presence [T-769, T-810]-            guard let idStr = args["milestoneId"] as? String,-                  let milestoneId = UUID(uuidString: idStr) else {-                return .failure(.message("milestoneId must be a valid UUID string"))-            }-            do {-                return .success(try milestoneService.findByID(milestoneId))-            } catch {-                return .failure(.message("No milestone with milestoneId \(idStr)"))-            }-        } else {-            return .failure(.message("Provide either displayId (integer) or milestoneId (UUID string)"))-        }-    }-     private func milestoneToDict(-        _ milestone: Milestone, formatter: ISO8601DateFormatter, detailed: Bool = false-    ) -> [String: Any] {-        var dict: [String: Any] = [-            "milestoneId": milestone.id.uuidString,-            "name": milestone.name,-            "status": milestone.statusRawValue,-            "creationDate": formatter.string(from: milestone.creationDate),-            "lastStatusChangeDate": formatter.string(from: milestone.lastStatusChangeDate)-        ]-        if let displayId = milestone.permanentDisplayId { dict["displayId"] = displayId }-        if let description = milestone.milestoneDescription { dict["description"] = description }-        if let projectId = milestone.project?.id.uuidString { dict["projectId"] = projectId }-        if let projectName = milestone.project?.name { dict["projectName"] = projectName }-        if let completionDate = milestone.completionDate {-            dict["completionDate"] = formatter.string(from: completionDate)-        }+        _ milestone: Milestone, formatter _: ISO8601DateFormatter, detailed: Bool = false+    ) throws -> [String: Any] {+        var dict = try MCPRecordSnapshot.milestone(milestone).record         let tasks = milestone.tasks ?? []         dict["taskCount"] = tasks.count         if detailed {@@ -1551,13 +848,12 @@ extension MCPToolHandler {     private func taskToDict(         _ task: TransitTask, formatter: ISO8601DateFormatter, detailed: Bool = false     ) throws -> [String: Any] {-        var dict = IntentHelpers.taskToDict(task, formatter: formatter, detailed: detailed)-        let comments = try commentFetcher.fetchComments(for: task.id)-        dict["comments"] = comments.map { [-            "id": $0.id.uuidString, "authorName": $0.authorName, "content": $0.content,-            "isAgent": $0.isAgent, "creationDate": formatter.string(from: $0.creationDate)-        ] as [String: Any] }-        return dict+        let snapshot = try MCPRecordSnapshot.task(task) { try commentFetcher.fetchComments(for: $0) }+        if detailed { return snapshot.record }+        var summary = IntentHelpers.taskToDict(task, formatter: formatter)+        summary["comments"] = snapshot.record["comments"]+        summary["revision"] = snapshot.revision+        return summary     } } 
Transit/Transit/MCP/MCPTypes.swift Modified +3 / -1
diff --git a/Transit/Transit/MCP/MCPTypes.swift b/Transit/Transit/MCP/MCPTypes.swiftindex 962b268..eea98b7 100644--- a/Transit/Transit/MCP/MCPTypes.swift+++ b/Transit/Transit/MCP/MCPTypes.swift@@ -206,6 +206,7 @@ nonisolated struct JSONSchema: Encodable, Sendable {     let type: String     let properties: [String: JSONSchemaProperty]?     let required: [String]?+    var additionalProperties: Bool?      static func object(         properties: [String: JSONSchemaProperty],@@ -230,9 +231,10 @@ nonisolated struct JSONSchemaProperty: Encodable, Sendable {     let description: String?     let enumValues: [String]?     let items: JSONSchemaItems?+    var pattern: String?      nonisolated enum CodingKeys: String, CodingKey {-        case type, description, items+        case type, description, items, pattern         case enumValues = "enum"     } 
Transit/Transit/MCP/Writes/MCPCanonicalJSON.swift Added +64 / -0
diff --git a/Transit/Transit/MCP/Writes/MCPCanonicalJSON.swift b/Transit/Transit/MCP/Writes/MCPCanonicalJSON.swiftnew file mode 100644index 0000000..896da9f--- /dev/null+++ b/Transit/Transit/MCP/Writes/MCPCanonicalJSON.swift@@ -0,0 +1,64 @@+import Foundation+import CoreFoundation++/// Version 1 remains available for retained receipts across app upgrades.+enum MCPCanonicalJSON {+    enum Error: Swift.Error { case unsupportedVersion, invalidValue }++    static func request(_ arguments: [String: Any], version: Int = 1) throws -> String {+        var payload = arguments+        payload.removeValue(forKey: "idempotencyKey")+        return try encode(payload, version: version)+    }++    static func encode(_ value: Any, version: Int = 1) throws -> String {+        guard version == 1 else { throw Error.unsupportedVersion }+        if value is NSNull { return "null" }+        if let string = value as? String {+            let data = try JSONSerialization.data(withJSONObject: string, options: [.fragmentsAllowed])+            guard let encoded = String(data: data, encoding: .utf8) else { throw Error.invalidValue }+            return encoded+        }+        if let number = value as? NSNumber {+            if CFGetTypeID(number) == CFBooleanGetTypeID() { return number.boolValue ? "true" : "false" }+            guard number.doubleValue.isFinite else { throw Error.invalidValue }+            return try encodeNumber(number)+        }+        if let object = value as? [String: Any] {+            let fields = try object.keys.sorted().map { key in+                try encode(key) + ":" + encode(object[key]!)+            }+            return "{" + fields.joined(separator: ",") + "}"+        }+        if let array = value as? [Any] {+            return "[" + (try array.map { try encode($0) }).joined(separator: ",") + "]"+        }+        throw Error.invalidValue+    }++    /// Foundation emits a round-trippable JSON number. Normalize its decimal+    /// spelling without Decimal conversion, which rounds adjacent Doubles and+    /// cannot represent the full finite Double exponent range.+    private static func encodeNumber(_ number: NSNumber) throws -> String {+        let data = try JSONSerialization.data(withJSONObject: number, options: [.fragmentsAllowed])+        guard var spelling = String(data: data, encoding: .utf8) else { throw Error.invalidValue }+        let negative = spelling.hasPrefix("-")+        if negative { spelling.removeFirst() }+        let parts = spelling.lowercased().split(separator: "e", omittingEmptySubsequences: false)+        var exponent = 0+        if parts.count == 2 {+            guard let parsed = Int(parts[1]) else { throw Error.invalidValue }+            exponent = parsed+        }+        let mantissa = parts[0].split(separator: ".", omittingEmptySubsequences: false)+        guard mantissa.count <= 2 else { throw Error.invalidValue }+        var digits = mantissa.joined()+        guard !digits.isEmpty, digits.allSatisfy({ $0.isASCII && $0.isNumber }) else { throw Error.invalidValue }+        if mantissa.count == 2 { exponent -= mantissa[1].count }+        while digits.first == "0" { digits.removeFirst() }+        if digits.isEmpty { return "0" } // Positive and negative zero compare equally.+        while digits.last == "0" { digits.removeLast(); exponent += 1 }+        return (negative ? "-" : "") + digits + (exponent == 0 ? "" : "e" + String(exponent))+    }++}
Transit/Transit/MCP/Writes/MCPLocalReservationStore.swift Added +204 / -0
diff --git a/Transit/Transit/MCP/Writes/MCPLocalReservationStore.swift b/Transit/Transit/MCP/Writes/MCPLocalReservationStore.swiftnew file mode 100644index 0000000..e60eb7d--- /dev/null+++ b/Transit/Transit/MCP/Writes/MCPLocalReservationStore.swift@@ -0,0 +1,204 @@+import Foundation+import CryptoKit+import Darwin++nonisolated struct MCPLocalReservation: Codable, Equatable, Sendable {+    var scopeID: String+    var tool: String+    var key: String+    var requestJSON: String+    var formatVersion: Int+    var receiptID: UUID+    var expiresAt: Date?+}++/// Only payload bindings live here; domain results commit with SwiftData.+@MainActor final class MCPLocalReservationStore {+    enum Error: Swift.Error, Equatable { case storeBusy, unreadable, keyReused, inconsistent }++    let scopeID: String+    private let directory: URL+    private let guardsDirectory: URL+    private let lockDescriptor: Int32++    init(directory: URL) throws {+        self.directory = directory+        self.guardsDirectory = directory.appendingPathComponent("guards", isDirectory: true)+        try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)+        let descriptor = open(directory.appendingPathComponent("lock").path, O_CREAT | O_RDWR, 0o600)+        guard descriptor >= 0 else { throw Error.unreadable }+        guard flock(descriptor, LOCK_EX | LOCK_NB) == 0 else {+            close(descriptor)+            throw Error.storeBusy+        }+        self.lockDescriptor = descriptor+        do {+            let identityURL = directory.appendingPathComponent("scope")+            if FileManager.default.fileExists(atPath: identityURL.path) {+                let value = try String(contentsOf: identityURL, encoding: .utf8)+                guard let uuid = UUID(uuidString: value), value == uuid.uuidString.lowercased() else {+                    throw Error.inconsistent+                }+                scopeID = value+            } else {+                // A lost identity never creates a fresh namespace over old bindings.+                if FileManager.default.fileExists(atPath: guardsDirectory.path),+                   !(try FileManager.default.contentsOfDirectory(atPath: guardsDirectory.path)).isEmpty {+                    throw Error.inconsistent+                }+                let value = UUID().uuidString.lowercased()+                try Self.durableReplace(Data(value.utf8), at: identityURL)+                scopeID = value+            }+            try FileManager.default.createDirectory(at: guardsDirectory, withIntermediateDirectories: true)+            try Self.syncDirectory(directory)+            _ = try all()+        } catch {+            flock(descriptor, LOCK_UN)+            close(descriptor)+            throw error+        }+    }++    deinit {+        flock(lockDescriptor, LOCK_UN)+        close(lockDescriptor)+    }++    func lookup(tool: String, key: String) throws -> MCPLocalReservation? {+        // Validate the entire scope so corruption cannot silently permit a new key.+        try all().first { $0.tool == tool && $0.key == key }+    }++    func reserve(tool: String, key: String, requestJSON: String, formatVersion: Int = 1,+                 receiptID: UUID = UUID()) throws -> MCPLocalReservation {+        if let existing = try lookup(tool: tool, key: key) {+            guard existing.requestJSON == requestJSON && existing.formatVersion == formatVersion else {+                throw Error.keyReused+            }+            return existing+        }+        guard !tool.isEmpty, !key.isEmpty, formatVersion == 1 else { throw Error.inconsistent }+        try validatePayload(requestJSON)+        let reservation = MCPLocalReservation(scopeID: scopeID, tool: tool, key: key,+                                              requestJSON: requestJSON, formatVersion: formatVersion,+                                              receiptID: receiptID)+        try persist(reservation)+        return reservation+    }++    func recordExpiry(_ reservation: MCPLocalReservation, expiresAt: Date) throws {+        guard var saved = try lookup(tool: reservation.tool, key: reservation.key),+              saved.receiptID == reservation.receiptID, saved.requestJSON == reservation.requestJSON,+              expiresAt.timeIntervalSinceReferenceDate.isFinite else { throw Error.inconsistent }+        if let original = saved.expiresAt {+            guard original == expiresAt else { throw Error.inconsistent }+            return+        }+        saved.expiresAt = expiresAt+        try persist(saved)+    }++    func removeExpired(now: Date) throws {+        for reservation in try all() {+            guard let expiry = reservation.expiresAt, expiry <= now else { continue }+            try FileManager.default.removeItem(at: file(tool: reservation.tool, key: reservation.key))+            try Self.syncDirectory(guardsDirectory)+        }+    }++    /// The process lock and MainActor keep this verified snapshot stable for the+    /// whole maintenance pass. Validate every binding before changing any file.+    func reconcileTerminalBindings(_ terminal: [MCPLocalReservation], now: Date) throws {+        var snapshot: [BindingKey: MCPLocalReservation] = [:]+        for binding in try all() {+            guard snapshot.updateValue(binding, forKey: BindingKey(binding)) == nil else { throw Error.inconsistent }+        }+        for binding in terminal {+            guard binding.scopeID == scopeID, binding.formatVersion == 1,+                  let expiry = binding.expiresAt, expiry.timeIntervalSinceReferenceDate.isFinite else {+                throw Error.inconsistent+            }+            if let saved = snapshot[BindingKey(binding)] {+                guard saved.receiptID == binding.receiptID, saved.requestJSON == binding.requestJSON,+                      saved.formatVersion == binding.formatVersion,+                      saved.expiresAt == nil || saved.expiresAt == expiry else { throw Error.inconsistent }+            }+        }+        for binding in terminal {+            let key = BindingKey(binding)+            if snapshot[key]?.expiresAt == nil { try persist(binding) }+            snapshot[key] = binding+        }+        for binding in snapshot.values where binding.expiresAt.map({ $0 <= now }) == true {+            try FileManager.default.removeItem(at: file(tool: binding.tool, key: binding.key))+            try Self.syncDirectory(guardsDirectory)+        }+    }++    struct BindingKey: Hashable {+        let tool: String+        let key: String++        init(_ binding: MCPLocalReservation) {+            tool = binding.tool+            key = binding.key+        }++        init(tool: String, key: String) {+            self.tool = tool+            self.key = key+        }+    }++    func all() throws -> [MCPLocalReservation] {+        let files = try FileManager.default.contentsOfDirectory(at: guardsDirectory,+                                                               includingPropertiesForKeys: nil)+        return try files.map { url in+            // Temp files can survive a crash before rename: ignore only our+            // incomplete replacement files; they never prove acceptance.+            if url.lastPathComponent.hasPrefix(".pending-") { return nil }+            let value = try JSONDecoder().decode(MCPLocalReservation.self, from: Data(contentsOf: url))+            guard value.scopeID == scopeID, value.formatVersion == 1, !value.tool.isEmpty, !value.key.isEmpty,+                  url.lastPathComponent == file(tool: value.tool, key: value.key).lastPathComponent,+                  value.expiresAt?.timeIntervalSinceReferenceDate.isFinite != false else { throw Error.inconsistent }+            try validatePayload(value.requestJSON)+            return value+        }.compactMap { $0 }+    }++    private func validatePayload(_ json: String) throws {+        guard let object = try JSONSerialization.jsonObject(with: Data(json.utf8)) as? [String: Any],+              try MCPCanonicalJSON.encode(object) == json else { throw Error.inconsistent }+    }++    private func persist(_ reservation: MCPLocalReservation) throws {+        try Self.durableReplace(JSONEncoder().encode(reservation),+                                at: file(tool: reservation.tool, key: reservation.key))+    }++    private func file(tool: String, key: String) -> URL {+        let input = Data((tool + "\u{0000}" + key).utf8)+        let name = SHA256.hash(data: input).map { String(format: "%02x", $0) }.joined()+        return guardsDirectory.appendingPathComponent(name + ".json")+    }++    private static func durableReplace(_ data: Data, at url: URL) throws {+        let temporary = url.deletingLastPathComponent().appendingPathComponent(".pending-" + UUID().uuidString)+        defer { try? FileManager.default.removeItem(at: temporary) }+        try data.write(to: temporary, options: .withoutOverwriting)+        let descriptor = open(temporary.path, O_RDWR)+        guard descriptor >= 0 else { throw Error.unreadable }+        defer { close(descriptor) }+        guard fcntl(descriptor, F_FULLFSYNC) == 0 else { throw Error.unreadable }+        guard rename(temporary.path, url.path) == 0 else { throw Error.unreadable }+        try syncDirectory(url.deletingLastPathComponent())+    }++    private static func syncDirectory(_ directory: URL) throws {+        let descriptor = open(directory.path, O_RDONLY)+        guard descriptor >= 0 else { throw Error.unreadable }+        defer { close(descriptor) }+        guard fsync(descriptor) == 0 else { throw Error.unreadable }+    }+}
Transit/Transit/MCP/Writes/MCPRecordRevision.swift Added +21 / -0
diff --git a/Transit/Transit/MCP/Writes/MCPRecordRevision.swift b/Transit/Transit/MCP/Writes/MCPRecordRevision.swiftnew file mode 100644index 0000000..b0f1be8--- /dev/null+++ b/Transit/Transit/MCP/Writes/MCPRecordRevision.swift@@ -0,0 +1,21 @@+import Foundation+import CryptoKit++enum MCPRecordRevision {+    static func token(entity: String, fields: [String: Any]) throws -> String {+        let canonical = try MCPCanonicalJSON.encode(["version": 1, "entity": entity, "fields": fields])+        let digest = SHA256.hash(data: Data(canonical.utf8))+        return "r1:" + digest.map { String(format: "%02x", $0) }.joined()+    }++    static func exactDate(_ date: Date?) throws -> Any {+        guard let date else { return NSNull() }+        let interval = date.timeIntervalSinceReferenceDate+        guard interval.isFinite else { throw MCPCanonicalJSON.Error.invalidValue }+        return String(interval.bitPattern, radix: 16)+    }++    static func uuid(_ value: UUID?) -> Any {+        value?.uuidString.lowercased() as Any? ?? NSNull()+    }+}
Transit/Transit/MCP/Writes/MCPRecordSnapshot.swift Added +123 / -0
diff --git a/Transit/Transit/MCP/Writes/MCPRecordSnapshot.swift b/Transit/Transit/MCP/Writes/MCPRecordSnapshot.swiftnew file mode 100644index 0000000..dcfbbd7--- /dev/null+++ b/Transit/Transit/MCP/Writes/MCPRecordSnapshot.swift@@ -0,0 +1,123 @@+import Foundation+import SwiftData++/// Captures value dictionaries once, so response and token describe one state.+struct MCPRecordSnapshot {+    let entityID: UUID+    let revision: String+    let record: [String: Any]+    let coveredFields: [String: Any]++    private init(entityID: UUID, entity: String, covered: [String: Any], record: [String: Any]) throws {+        self.entityID = entityID+        self.coveredFields = covered+        let revision = try MCPRecordRevision.token(entity: entity, fields: covered)+        self.revision = revision+        var response = record+        response["revision"] = revision+        self.record = response+    }++    static func project(_ project: Project) throws -> Self {+        let fields: [String: Any] = [+            "id": MCPRecordRevision.uuid(project.id), "name": project.name,+            "projectDescription": project.projectDescription,+            "gitRepo": project.gitRepo as Any? ?? NSNull(), "colorHex": project.colorHex+        ]+        var record: [String: Any] = [+            "projectId": project.id.uuidString, "name": project.name,+            "description": project.projectDescription, "colorHex": project.colorHex+        ]+        record["gitRepo"] = project.gitRepo+        return try Self(entityID: project.id, entity: "project", covered: fields, record: record)+    }++    static func comment(_ comment: Comment) throws -> Self {+        let fields: [String: Any] = [+            "id": MCPRecordRevision.uuid(comment.id), "content": comment.content,+            "authorName": comment.authorName, "isAgent": comment.isAgent,+            "creationDate": try MCPRecordRevision.exactDate(comment.creationDate),+            "taskId": MCPRecordRevision.uuid(comment.task?.id)+        ]+        var record: [String: Any] = [+            "id": comment.id.uuidString, "content": comment.content, "authorName": comment.authorName,+            "isAgent": comment.isAgent, "creationDate": timestamp(comment.creationDate)+        ]+        record["taskId"] = comment.task?.id.uuidString+        return try Self(entityID: comment.id, entity: "comment", covered: fields, record: record)+    }++    static func milestone(_ milestone: Milestone) throws -> Self {+        let fields: [String: Any] = [+            "id": MCPRecordRevision.uuid(milestone.id), "name": milestone.name,+            "milestoneDescription": milestone.milestoneDescription as Any? ?? NSNull(),+            "permanentDisplayId": milestone.permanentDisplayId as Any? ?? NSNull(),+            "statusRawValue": milestone.statusRawValue,+            "creationDate": try MCPRecordRevision.exactDate(milestone.creationDate),+            "lastStatusChangeDate": try MCPRecordRevision.exactDate(milestone.lastStatusChangeDate),+            "completionDate": try MCPRecordRevision.exactDate(milestone.completionDate),+            "projectId": MCPRecordRevision.uuid(milestone.project?.id)+        ]+        var record: [String: Any] = [+            "milestoneId": milestone.id.uuidString, "name": milestone.name,+            "status": milestone.statusRawValue, "creationDate": timestamp(milestone.creationDate),+            "lastStatusChangeDate": timestamp(milestone.lastStatusChangeDate),+            "taskCount": (milestone.tasks ?? []).count+        ]+        record["displayId"] = milestone.permanentDisplayId+        record["description"] = milestone.milestoneDescription+        record["projectId"] = milestone.project?.id.uuidString+        record["projectName"] = milestone.project?.name+        record["completionDate"] = milestone.completionDate.map(timestamp)+        return try Self(entityID: milestone.id, entity: "milestone", covered: fields, record: record)+    }++    static func task(_ task: TransitTask, in context: ModelContext) throws -> Self {+        try Self.task(task) { try context.fetch(CommentService.descriptor(for: $0)) }+    }++    static func task(_ task: TransitTask, fetchComments: (UUID) throws -> [Comment]) throws -> Self {+        let comments = try fetchComments(task.id).sorted {+            ($0.creationDate, $0.id.uuidString) < ($1.creationDate, $1.id.uuidString)+        }.map { try Self.comment($0) }+        let fields: [String: Any] = [+            "id": MCPRecordRevision.uuid(task.id), "name": task.name,+            "taskDescription": task.taskDescription as Any? ?? NSNull(),+            "permanentDisplayId": task.permanentDisplayId as Any? ?? NSNull(),+            "statusRawValue": task.statusRawValue, "typeRawValue": task.typeRawValue,+            "priorityRawValue": task.priorityRawValue,+            "creationDate": try MCPRecordRevision.exactDate(task.creationDate),+            "lastStatusChangeDate": try MCPRecordRevision.exactDate(task.lastStatusChangeDate),+            "completionDate": try MCPRecordRevision.exactDate(task.completionDate),+            "metadataJSON": task.metadataJSON as Any? ?? NSNull(),+            "projectId": MCPRecordRevision.uuid(task.project?.id),+            "milestoneId": MCPRecordRevision.uuid(task.milestone?.id),+            "comments": comments.sorted { $0.entityID.uuidString < $1.entityID.uuidString }.map(\.coveredFields)+        ]+        var record: [String: Any] = [+            "taskId": task.id.uuidString, "name": task.name, "status": task.statusRawValue,+            "type": task.typeRawValue, "priority": task.priority.rawValue,+            "creationDate": timestamp(task.creationDate),+            "lastStatusChangeDate": timestamp(task.lastStatusChangeDate),+            "description": task.taskDescription as Any? ?? NSNull(), "metadata": task.metadata,+            "comments": comments.map(\.record)+        ]+        record["displayId"] = task.permanentDisplayId+        record["projectId"] = task.project?.id.uuidString+        record["projectName"] = task.project?.name+        record["completionDate"] = task.completionDate.map(timestamp)+        if let milestone = task.milestone {+            var summary: [String: Any] = ["milestoneId": milestone.id.uuidString, "name": milestone.name,+                                           "status": milestone.statusRawValue]+            summary["displayId"] = milestone.permanentDisplayId+            record["milestone"] = summary+        }+        return try Self(entityID: task.id, entity: "task", covered: fields, record: record)+    }++    static func timestamp(_ date: Date) -> String {+        let formatter = ISO8601DateFormatter()+        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]+        return formatter.string(from: date)+    }+}
Transit/Transit/MCP/Writes/MCPWriteCommand.swift Added +298 / -0
diff --git a/Transit/Transit/MCP/Writes/MCPWriteCommand.swift b/Transit/Transit/MCP/Writes/MCPWriteCommand.swiftnew file mode 100644index 0000000..a254262--- /dev/null+++ b/Transit/Transit/MCP/Writes/MCPWriteCommand.swift@@ -0,0 +1,298 @@+#if os(macOS)+import Foundation+import CoreFoundation+import SwiftData++struct MCPWriteCommandServices {+    let tasks: TaskService+    let projects: ProjectService+    let comments: CommentService+    let milestones: MilestoneService+    let context: ModelContext+}++enum PreparedMCPWrite {+    case taskCreation(TaskService.PreparedCreation)+    case milestoneCreation(MilestoneService.PreparedCreation)+    case task(UUID)+    case milestone(UUID)+    case project+}++struct MCPWriteCommand {+    static let protectedTools: Set<String> = [+        "create_task", "create_project", "create_milestone", "add_comment",+        "update_task", "update_task_status", "update_milestone", "delete_milestone"+    ]+    static let revisionTools: Set<String> = [+        "update_task", "update_task_status", "update_milestone", "delete_milestone"+    ]+    let tool: String+    let key: String+    let arguments: [String: Any]+    var expectedRevision: String? { arguments["expectedRevision"] as? String }++    static func validate(tool: String, arguments: [String: Any]) throws -> Self {+        guard protectedTools.contains(tool),+            let definition = MCPToolDefinitions.coreTools.first(where: { $0.name == tool })+        else {+            throw MCPWriteFailure("INVALID_INPUT", "Unknown protected tool")+        }+        let properties = definition.inputSchema.properties ?? [:]+        let safetyFields: Set<String> =+            revisionTools.contains(tool)+            ? ["idempotencyKey", "expectedRevision"] : ["idempotencyKey"]+        for field in arguments.keys where properties[field] == nil && !safetyFields.contains(field) {+            throw MCPWriteFailure("INVALID_INPUT", "Unknown argument: \(field)")+        }+        for field in definition.inputSchema.required ?? [] where arguments[field] == nil {+            throw MCPWriteFailure("INVALID_INPUT", "Missing required argument: \(field)")+        }+        let usesProjectID = ["create_task", "create_milestone"].contains(tool)+            && (arguments["projectId"] as? String).flatMap(UUID.init(uuidString:)) != nil+        for (field, value) in arguments where !safetyFields.contains(field) {+            if field == "project", usesProjectID { continue }+            try validateValue(value, field: field, schema: properties[field]!)+        }+        guard let key = arguments["idempotencyKey"] as? String,+            key.range(of: "^[A-Za-z0-9._:-]{1,128}$", options: .regularExpression) == key.startIndex..<key.endIndex+        else {+            throw MCPWriteFailure("INVALID_INPUT", "idempotencyKey must match [A-Za-z0-9._:-]{1,128}")+        }+        if revisionTools.contains(tool) {+            guard let revision = arguments["expectedRevision"] as? String,+                revision.range(of: "^r1:[0-9a-f]{64}$", options: .regularExpression) == revision+                    .startIndex..<revision.endIndex+            else {+                throw MCPWriteFailure("INVALID_INPUT", "expectedRevision must match r1:[0-9a-f]{64}")+            }+        }+        for field in ["taskId", "projectId", "milestoneId"] {+            if let value = arguments[field] as? String, UUID(uuidString: value) == nil {+                throw MCPWriteFailure("INVALID_INPUT", "\(field) must be a valid UUID string")+            }+        }+        return Self(tool: tool, key: key, arguments: arguments)+    }++    private static func validateValue(_ value: Any, field: String, schema: JSONSchemaProperty) throws {+        let valid: Bool+        switch schema.type {+        case "string": valid = value is String+        case "integer": valid = IntentHelpers.parseIntValue(value) != nil+        case "boolean": valid = IntentHelpers.parseBoolValue(value) != nil+        case "object": valid = value is [String: Any]+        default: valid = false+        }+        guard valid else {+            if ["projectId", "taskId", "milestoneId"].contains(field) {+                throw MCPWriteFailure("INVALID_INPUT", "\(field) must be a valid UUID string")+            }+            let article = schema.type == "integer" || schema.type == "object" ? "an" : "a"+            throw MCPWriteFailure("INVALID_INPUT", "\(field) must be \(article) \(schema.type ?? "JSON")")+        }+    }++    func prepare(using services: MCPWriteCommandServices) async throws -> PreparedMCPWrite {+        try Task.checkCancellation()+        switch tool {+        case "create_task":+            let project = try project(using: services)+            guard let type = TaskType(rawValue: try string("type")) else {+                throw MCPWriteFailure("INVALID_TYPE", "Invalid task type")+            }+            let priority = try taskPriority()+            let milestone = try assignedMilestone(project: project, using: services)+            return .taskCreation(+                try await services.tasks.prepareTaskCreation(+                    name: try string("name"), description: arguments["description"] as? String,+                    type: type, project: project, metadata: IntentHelpers.stringMetadata(from: arguments["metadata"]),+                    priority: priority, milestone: milestone+                ))+        case "create_milestone":+            return .milestoneCreation(+                try await services.milestones.prepareMilestoneCreation(+                    name: try string("name"), description: arguments["description"] as? String,+                    project: project(using: services)+                ))+        case "create_project": return .project+        case "update_milestone", "delete_milestone":+            if let id = arguments["milestoneId"] as? String {+                return .milestone(try services.milestones.findByID(UUID(uuidString: id)!).id)+            }+            if let id = arguments["displayId"] as? NSNumber {+                return .milestone(try services.milestones.findByDisplayID(id.intValue).id)+            }+            throw MCPWriteFailure("INVALID_INPUT", "Provide either displayId or milestoneId")+        default: return .task(try services.tasks.resolveTask(from: arguments).id)+        }+    }++    func apply(_ prepared: PreparedMCPWrite, using services: MCPWriteCommandServices) throws -> [String: Any] {+        try Task.checkCancellation()+        switch prepared {+        case .taskCreation(let creation):+            let task = try services.tasks.applyTaskCreation(creation)+            return try saved(MCPRecordSnapshot.task(task, in: services.context))+        case .milestoneCreation(let creation):+            let milestone = try services.milestones.applyMilestoneCreation(creation)+            return try saved(MCPRecordSnapshot.milestone(milestone))+        case .project:+            let raw = try string("colorHex")+            let hex = raw.hasPrefix("#") ? String(raw.dropFirst()) : raw+            guard hex.range(of: "^[0-9a-fA-F]{6}$", options: .regularExpression) == hex.startIndex..<hex.endIndex+            else {+                throw MCPWriteFailure("INVALID_INPUT", "colorHex must contain six hexadecimal digits")+            }+            let project = try services.projects.createProject(+                name: try string("name"), description: arguments["description"] as? String ?? "",+                gitRepo: arguments["gitRepo"] as? String, colorHex: raw, save: false+            )+            return try saved(MCPRecordSnapshot.project(project))+        case .task(let id): return try applyTask(id, using: services)+        case .milestone(let id): return try applyMilestone(id, using: services)+        }+    }++    private func applyTask(_ id: UUID, using services: MCPWriteCommandServices) throws -> [String: Any] {+        let task = try services.tasks.findByID(id)+        if expectedRevision != nil { try check(MCPRecordSnapshot.task(task, in: services.context)) }+        if tool == "add_comment" {+            let comment = try services.comments.addComment(+                to: task, content: try string("content"),+                authorName: try string("authorName"),+                isAgent: true, save: nil)+            return try saved(MCPRecordSnapshot.comment(comment))+        }+        if tool == "update_task" {+            let update = try TaskUpdateValidator.validate(+                arguments, task: task, milestoneService: services.milestones+            ).get()+            try TaskUpdateValidator.apply(+                update, to: task, taskService: services.tasks,+                milestoneService: services.milestones)+            return try saved(MCPRecordSnapshot.task(task, in: services.context))+        }+        guard let status = TaskStatus(rawValue: try string("status")) else {+            throw MCPWriteFailure("INVALID_STATUS", "Invalid task status")+        }+        if arguments["comment"] != nil,+            (arguments["authorName"] as? String)?.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty != false {+            throw MCPWriteFailure("INVALID_INPUT", "authorName is required when comment is provided")+        }+        let comment = try services.tasks.updateStatus(+            task: task, to: status,+            comment: arguments["comment"] as? String,+            commentAuthor: arguments["authorName"] as? String,+            commentService: services.comments, save: false)+        var result = try saved(MCPRecordSnapshot.task(task, in: services.context))+        result["comment"] = try comment.map { try MCPRecordSnapshot.comment($0).record } as Any? ?? NSNull()+        return result+    }++    private func applyMilestone(_ id: UUID, using services: MCPWriteCommandServices) throws -> [String: Any] {+        let milestone = try services.milestones.findByID(id)+        let before = try MCPRecordSnapshot.milestone(milestone)+        try check(before)+        if tool == "delete_milestone" {+            try services.milestones.deleteMilestone(milestone, save: false)+            return ["entityId": id.uuidString, "deleted": true, "recordBeforeDeletion": before.record]+        }+        var name: String?+        if let input = arguments["name"] as? String {+            let trimmed = input.trimmingCharacters(in: .whitespacesAndNewlines)+            guard !trimmed.isEmpty else { throw MilestoneService.Error.invalidName }+            if let project = milestone.project,+                try services.milestones.milestoneNameExists(trimmed, in: project, excluding: id) {+                throw MilestoneService.Error.duplicateName+            }+            name = trimmed+        }+        var status: MilestoneStatus?+        if let raw = arguments["status"] as? String {+            guard let parsed = MilestoneStatus(rawValue: raw) else {+                throw MCPWriteFailure("INVALID_STATUS", "Invalid milestone status")+            }+            status = parsed+        }+        if let name { milestone.name = name }+        if let description = arguments["description"] as? String {+            let trimmed = description.trimmingCharacters(in: .whitespacesAndNewlines)+            milestone.milestoneDescription = trimmed.isEmpty ? nil : trimmed+        }+        if let status, milestone.statusRawValue != status.rawValue {+            milestone.status = status+            milestone.lastStatusChangeDate = Date()+            milestone.completionDate = status.isTerminal ? milestone.lastStatusChangeDate : nil+        }+        return try saved(MCPRecordSnapshot.milestone(milestone))+    }++    private func project(using services: MCPWriteCommandServices) throws -> Project {+        try services.projects.findProject(+            id: (arguments["projectId"] as? String).flatMap(UUID.init(uuidString:)),+            name: arguments["project"] as? String+        ).get()+    }++    private func string(_ key: String) throws -> String {+        guard let value = arguments[key] as? String else {+            throw MCPWriteFailure("INVALID_INPUT", "\(key) must be a string")+        }+        return value+    }++    private func taskPriority() throws -> TaskPriority {+        guard let raw = arguments["priority"] as? String else { return .medium }+        guard let priority = TaskPriority(rawValue: raw) else {+            throw MCPWriteFailure("INVALID_PRIORITY", "Invalid task priority")+        }+        return priority+    }++    private func check(_ snapshot: MCPRecordSnapshot) throws {+        guard snapshot.revision == expectedRevision else {+            throw MCPWriteFailure(+                "REVISION_CONFLICT", "Record changed since it was read", currentRecord: snapshot.record)+        }+    }++    private func saved(_ snapshot: MCPRecordSnapshot) -> [String: Any] {+        ["entityId": snapshot.entityID.uuidString, "record": snapshot.record]+    }+}+extension MCPWriteCommand {+    private func assignedMilestone(project: Project, using services: MCPWriteCommandServices) throws -> Milestone? {+        if let id = arguments["milestoneDisplayId"] as? NSNumber {+            do {+                return try services.milestones.findByDisplayID(id.intValue)+            } catch MilestoneService.Error.milestoneNotFound {+                throw MCPWriteFailure("MILESTONE_NOT_FOUND", "No milestone with displayId \(id.intValue)")+            } catch MilestoneService.Error.duplicateDisplayID {+                throw MCPWriteFailure("INTERNAL_ERROR",+                    "Duplicate milestone identifier detected for displayId \(id.intValue)")+            } catch {+                throw MCPWriteFailure("INTERNAL_ERROR", "Failed to find milestone: \(error)")+            }+        }+        if let name = arguments["milestone"] as? String {+            do {+                guard let milestone = try services.milestones.findByName(name, in: project) else {+                    throw MCPWriteFailure("MILESTONE_NOT_FOUND",+                        "No milestone named '\(name)' in project '\(project.name)'")+                }+                return milestone+            } catch let failure as MCPWriteFailure {+                throw failure+            } catch MilestoneService.Error.ambiguousName {+                throw MCPWriteFailure("AMBIGUOUS_MILESTONE",+                    "Multiple milestones named '\(name)' exist in project '\(project.name)'")+            } catch {+                throw MCPWriteFailure("INTERNAL_ERROR", "Failed to look up milestone: \(error)")+            }+        }+        return nil+    }+}++#endif
Transit/Transit/MCP/Writes/MCPWriteCoordinator.swift Added +363 / -0
diff --git a/Transit/Transit/MCP/Writes/MCPWriteCoordinator.swift b/Transit/Transit/MCP/Writes/MCPWriteCoordinator.swiftnew file mode 100644index 0000000..514f645--- /dev/null+++ b/Transit/Transit/MCP/Writes/MCPWriteCoordinator.swift@@ -0,0 +1,363 @@+#if os(macOS)+import Foundation+import SwiftData++@MainActor final class MCPWriteCoordinator {+    enum SaveStage { case baseline, acceptance, commit, rejection, cleanup }+    private let services: MCPWriteCommandServices+    private let clock: @MainActor () -> Date+    private let save: @MainActor (ModelContext, SaveStage) throws -> Void+    private let encode: @MainActor ([String: Any]) throws -> String+    private let preparationHook: @MainActor (MCPWriteCommand) async throws -> Void+    private let recoveryHook: @MainActor () throws -> Void+    private let persistence: PersistenceAvailability+    private let reservations: MCPLocalReservationStore?+    private let receipts: MCPWriteReceiptStore?+    private let startupFailure: MCPWriteFailure?+    private var active: [String: String] = [:]++    init(+        services: MCPWriteCommandServices, sidecarDirectory: URL,+        persistence: PersistenceAvailability? = nil,+        clock: @escaping @MainActor () -> Date = Date.init,+        save: @escaping @MainActor (ModelContext, SaveStage) throws -> Void = { context, _ in try context.save() },+        encode: @escaping @MainActor ([String: Any]) throws -> String = MCPWriteOutcome.encode,+        preparationHook: @escaping @MainActor (MCPWriteCommand) async throws -> Void = { _ in },+        recoveryHook: @escaping @MainActor () throws -> Void = {}+    ) {+        self.services = services+        let persistence = persistence ?? .shared+        self.persistence = persistence+        self.clock = clock+        self.save = save+        self.encode = encode+        self.preparationHook = preparationHook+        self.recoveryHook = recoveryHook+        if persistence.isFallbackStorageActive {+            reservations = nil+            receipts = nil+            startupFailure = .init("PERSISTENCE_UNAVAILABLE", PersistenceAvailability.unavailableHint)+        } else {+            do {+                let store = try MCPLocalReservationStore(directory: sidecarDirectory)+                reservations = store+                receipts = MCPWriteReceiptStore(context: services.context, scopeID: store.scopeID)+                startupFailure = nil+            } catch MCPLocalReservationStore.Error.storeBusy {+                reservations = nil+                receipts = nil+                startupFailure = .init("STORE_BUSY", "Another process owns this local store")+            } catch {+                reservations = nil+                receipts = nil+                startupFailure = .init("OUTCOME_UNCERTAIN", "Local retry binding storage cannot be read")+            }+        }+    }++    /// Startup maintenance retains the same app-owned lock used by listener restarts.+    func cleanupExpiredOutcomes() throws {+        guard let reservations, let receipts else { return }+        if services.context.hasChanges { try save(services.context, .baseline) }+        try receipts.cleanup(now: clock(), reservations: reservations)+        if services.context.hasChanges { try save(services.context, .cleanup) }+    }++    func execute(tool: String, arguments: [String: Any]) async -> MCPToolResult {+        let command: MCPWriteCommand+        do { command = try MCPWriteCommand.validate(tool: tool, arguments: arguments) } catch {+            return MCPWriteOutcome.result(+                MCPWriteOutcome.failure(+                    tool: tool, key: arguments["idempotencyKey"] as? String,+                    failure: MCPWriteFailure.from(error), accepted: false+                ), isError: true)+        }+        if persistence.isFallbackStorageActive {+            return transient(+                command, .init("PERSISTENCE_UNAVAILABLE", PersistenceAvailability.unavailableHint),+                accepted: false, retry: "retry_same_request")+        }+        guard let reservations, let receipts else {+            let failure = startupFailure ?? .init("PERSISTENCE_UNAVAILABLE", "Retry storage unavailable")+            return transient(+                command, failure, accepted: failure.code == "OUTCOME_UNCERTAIN" ? nil : false,+                outcome: failure.code == "OUTCOME_UNCERTAIN" ? "uncertain" : "rejected",+                retry: failure.code == "OUTCOME_UNCERTAIN" ? "reconcile" : "retry_same_request")+        }+        let payload: String+        do { payload = try MCPCanonicalJSON.request(arguments) } catch {+            return transient(+                command, .init("INVALID_INPUT", "Arguments must contain finite JSON values"), accepted: false)+        }+        let namespace = tool + "\u{0000}" + command.key+        if let executing = active[namespace] {+            if executing != payload { return reused(command) }+            return transient(+                command, .init("OPERATION_IN_PROGRESS", "Retry the same request after completion"),+                accepted: true, outcome: "in_progress", retry: "retry_same_request")+        }+        return await accept(+            command, payload: payload, namespace: namespace,+            reservations: reservations, receipts: receipts)+    }+}++extension MCPWriteCoordinator {+    fileprivate func existingOutcome(+        _ command: MCPWriteCommand, payload: String,+        reservations: MCPLocalReservationStore, receipts: MCPWriteReceiptStore+    ) -> MCPToolResult? {+        let tool = command.tool+        do {+            if let guardRecord = try reservations.lookup(tool: tool, key: command.key) {+                if guardRecord.expiresAt.map({ $0 <= clock() }) != true {+                    guard guardRecord.requestJSON == payload else { return reused(command) }+                    return recover(command, guardRecord: guardRecord)+                }+            }+            if let receipt = try receipts.lookup(tool: tool, key: command.key, durable: true) {+                if receipt.expiresAt.map({ $0 <= clock() }) != true {+                    guard receipt.requestJSON == payload else { return reused(command) }+                    let repaired = try reservations.reserve(+                        tool: tool, key: command.key, requestJSON: payload,+                        formatVersion: receipt.formatVersion, receiptID: receipt.id)+                    return recover(command, guardRecord: repaired)+                }+            }+        } catch {+            // If storage inspection cannot establish prior acceptance, do not+            // describe the key as free or offer a fresh-key retry.+            return transient(+                command, .init("OUTCOME_UNCERTAIN", "Unable to inspect durable retry state"),+                accepted: nil, outcome: "uncertain", retry: "reconcile")+        }+        return nil+    }++    fileprivate func accept(+        _ command: MCPWriteCommand, payload: String, namespace: String,+        reservations: MCPLocalReservationStore, receipts: MCPWriteReceiptStore+    ) async -> MCPToolResult {+        let tool = command.tool+        if let existing = existingOutcome(command, payload: payload, reservations: reservations, receipts: receipts) {+            return existing+        }+        do {+            if services.context.hasChanges { try save(services.context, .baseline) }+        } catch {+            return transient(+                command, .init("PERSISTENCE_UNAVAILABLE", "Unable to save existing pending edits"),+                accepted: false, retry: "retry_same_request")+        }+        do {+            try receipts.cleanup(now: clock(), reservations: reservations)+            if services.context.hasChanges { try save(services.context, .cleanup) }+        } catch {+            return transient(+                command, .init("OUTCOME_UNCERTAIN", "Unable to complete retry-state cleanup"),+                accepted: nil, outcome: "uncertain", retry: "reconcile")+        }+        let guardRecord: MCPLocalReservation+        do {+            guardRecord = try reservations.reserve(tool: tool, key: command.key, requestJSON: payload)+        } catch {+            return transient(+                command, .init("OUTCOME_UNCERTAIN", "Unable to confirm durable key acceptance"),+                accepted: nil, outcome: "uncertain", retry: "reconcile")+        }+        active[namespace] = payload+        defer { active.removeValue(forKey: namespace) }+        return await runAccepted(command, guardRecord: guardRecord, receipts: receipts)+    }++    fileprivate func runAccepted(+        _ command: MCPWriteCommand, guardRecord: MCPLocalReservation,+        receipts: MCPWriteReceiptStore+    ) async -> MCPToolResult {+        let receipt: MCPWriteReceipt+        do {+            receipt = try receipts.insert(guardRecord, acceptedAt: clock())+            try save(services.context, .acceptance)+        } catch {+            // No domain command has run. Repair a missing acceptance receipt+            // only as a terminal no-effect rejection, never as a fresh request.+            for model in services.context.insertedModelsArray { services.context.delete(model) }+            services.context.safeRollback()+            return rejectBeforeDomain(+                command, guardRecord: guardRecord,+                failure: .init("INTERNAL_ERROR", "Unable to save request acceptance"))+        }+        let prepared: PreparedMCPWrite+        do {+            try await preparationHook(command)+            prepared = try await command.prepare(using: services)+            try Task.checkCancellation()+        } catch {+            // Preparation never mutates domain models. Save the baseline of+            // edits made during allocation before retaining its rejection.+            do { if services.context.hasChanges { try save(services.context, .baseline) } } catch {+                return uncertain(command)+            }+            return completeRejection(command, receipt: receipt, failure: MCPWriteFailure.from(error))+        }+        do { if services.context.hasChanges { try save(services.context, .baseline) } } catch {+            return uncertain(command)+        }+        return commit(command, prepared: prepared, receipt: receipt, guardRecord: guardRecord)+    }++    fileprivate func commit(+        _ command: MCPWriteCommand, prepared: PreparedMCPWrite,+        receipt: MCPWriteReceipt, guardRecord: MCPLocalReservation+    ) -> MCPToolResult {+        let context = services.context+        let autosave = context.autosaveEnabled+        context.autosaveEnabled = false+        defer { context.autosaveEnabled = autosave }+        do {+            var envelope = try command.apply(prepared, using: services)+            envelope["contractVersion"] = 1+            envelope["tool"] = command.tool+            envelope["idempotencyKey"] = command.key+            envelope["outcome"] = "committed"+            envelope["accepted"] = true+            let result = try stageTerminal(receipt, envelope: envelope, rejected: false)+            try save(context, .commit)+            // Failed expiry repair never downgrades a committed domain/result.+            try? reservations?.recordExpiry(guardRecord, expiresAt: receipt.expiresAt!)+            return result+        } catch {+            let failure = MCPWriteFailure.from(error)+            for model in context.insertedModelsArray { context.delete(model) }+            context.safeRollback()+            do {+                try recoveryHook()+                guard let durable = try receipts?.lookup(tool: command.tool, key: command.key, durable: true),+                    durable.id == guardRecord.receiptID+                else { return uncertain(command) }+                if let result = replay(durable) { return result }+                // The disk probe establishes that durable accepted means the+                // domain/result transaction did not commit.+                guard let live = try receipts?.lookup(tool: command.tool, key: command.key) else {+                    return uncertain(command)+                }+                return completeRejection(command, receipt: live, failure: failure)+            } catch { return uncertain(command) }+        }+    }++    fileprivate func recover(_ command: MCPWriteCommand, guardRecord: MCPLocalReservation) -> MCPToolResult {+        do {+            try recoveryHook()+            guard let receipt = try receipts?.lookup(tool: command.tool, key: command.key, durable: true),+                receipt.id == guardRecord.receiptID, receipt.requestJSON == guardRecord.requestJSON+            else {+                return uncertain(command)+            }+            if let result = replay(receipt) {+                if let expiry = receipt.expiresAt {+                    try? reservations?.recordExpiry(guardRecord, expiresAt: expiry)+                }+                return result+            }+            guard let live = try receipts?.lookup(tool: command.tool, key: command.key) else {+                return uncertain(command)+            }+            if services.context.hasChanges { try save(services.context, .baseline) }+            return completeRejection(+                command, receipt: live,+                failure: .init("INTERRUPTED_BEFORE_COMMIT", "Accepted operation did not commit"))+        } catch { return uncertain(command) }+    }++    fileprivate func rejectBeforeDomain(+        _ command: MCPWriteCommand, guardRecord: MCPLocalReservation,+        failure: MCPWriteFailure+    ) -> MCPToolResult {+        do {+            try recoveryHook()+            if let durable = try receipts?.lookup(tool: command.tool, key: command.key, durable: true),+                let result = replay(durable) {+                return result+            }+            guard let receipts else { return uncertain(command) }+            let live =+                try receipts.lookup(tool: command.tool, key: command.key)+                ?? receipts.insert(guardRecord, acceptedAt: clock())+            return completeRejection(command, receipt: live, failure: failure)+        } catch { return uncertain(command) }+    }++    fileprivate func completeRejection(+        _ command: MCPWriteCommand, receipt: MCPWriteReceipt,+        failure: MCPWriteFailure+    ) -> MCPToolResult {+        let envelope = MCPWriteOutcome.failure(+            tool: command.tool, key: command.key, failure: failure, accepted: true)+        do {+            let result = try stageTerminal(receipt, envelope: envelope, rejected: true)+            try save(services.context, .rejection)+            if let binding = try? reservations?.lookup(tool: command.tool, key: command.key),+                let expiry = receipt.expiresAt {+                try? reservations?.recordExpiry(binding, expiresAt: expiry)+            }+            return result+        } catch {+            for model in services.context.insertedModelsArray { services.context.delete(model) }+            services.context.safeRollback()+            do {+                try recoveryHook()+                if let durable = try receipts?.lookup(tool: command.tool, key: command.key, durable: true),+                    let result = replay(durable) {+                    return result+                }+            } catch {}+            return uncertain(command)+        }+    }++    fileprivate func stageTerminal(_ receipt: MCPWriteReceipt, envelope: [String: Any], rejected: Bool) throws+        -> MCPToolResult {+        let completed = clock()+        let expiry = completed.addingTimeInterval(604800)+        var envelope = envelope+        envelope["completedAt"] = MCPRecordSnapshot.timestamp(completed)+        envelope["replayExpiresAt"] = MCPRecordSnapshot.timestamp(expiry)+        let json = try encode(envelope)+        receipt.stateRawValue = rejected ? "rejected" : "committed"+        receipt.completedAt = completed+        receipt.expiresAt = expiry+        receipt.resultJSON = json+        receipt.resultIsError = rejected+        return MCPToolResult(content: [.text(json)], isError: rejected ? true : nil)+    }++    fileprivate func replay(_ receipt: MCPWriteReceipt) -> MCPToolResult? {+        guard let json = receipt.resultJSON, let isError = receipt.resultIsError else { return nil }+        return MCPToolResult(content: [.text(json)], isError: isError ? true : nil)+    }++    fileprivate func reused(_ command: MCPWriteCommand) -> MCPToolResult {+        transient(+            command, .init("IDEMPOTENCY_KEY_REUSED", "The key is already bound to different arguments"),+            accepted: false)+    }++    fileprivate func uncertain(_ command: MCPWriteCommand) -> MCPToolResult {+        transient(+            command, .init("OUTCOME_UNCERTAIN", "Reconcile the original operation before issuing another write"),+            accepted: true, outcome: "uncertain", retry: "reconcile")+    }++    fileprivate func transient(+        _ command: MCPWriteCommand, _ failure: MCPWriteFailure, accepted: Bool?,+        outcome: String = "rejected", retry: String? = nil+    ) -> MCPToolResult {+        MCPWriteOutcome.result(+            MCPWriteOutcome.failure(+                tool: command.tool, key: command.key,+                failure: failure, accepted: accepted,+                outcome: outcome, retryAction: retry), isError: true)+    }+}+#endif
Transit/Transit/MCP/Writes/MCPWriteOutcome.swift Added +86 / -0
diff --git a/Transit/Transit/MCP/Writes/MCPWriteOutcome.swift b/Transit/Transit/MCP/Writes/MCPWriteOutcome.swiftnew file mode 100644index 0000000..fe8d9c9--- /dev/null+++ b/Transit/Transit/MCP/Writes/MCPWriteOutcome.swift@@ -0,0 +1,86 @@+#if os(macOS)+import Foundation++@MainActor final class MCPWriteFailure: Error {+    let code: String+    let message: String+    let currentRecord: [String: Any]?++    init(_ code: String, _ message: String, currentRecord: [String: Any]? = nil) {+        self.code = code+        self.message = message+        self.currentRecord = currentRecord+    }++    static func from(_ error: any Error) -> MCPWriteFailure {+        if let failure = error as? MCPWriteFailure { return failure }+        if error is CancellationError { return .init("CANCELLED", "The operation was cancelled") }+        if let error = error as? TaskUpdateValidationError {+            return .init(error.intentError.code, error.mcpMessage)+        }+        if let error = error as? ProjectLookupError {+            let mapped = IntentHelpers.mapProjectLookupError(error)+            return .init(mapped.code, mapped.hint)+        }+        if let error = error as? MilestoneService.Error {+            let mapped = IntentHelpers.mapMilestoneError(error)+            return .init(mapped.code, mapped.hint)+        }+        if let error = error as? TaskService.Error {+            return taskFailure(error)+        }+        if let error = error as? CommentService.Error {+            return .init(error == .taskNotFound ? "TASK_NOT_FOUND" : "INVALID_INPUT", "Invalid comment: \(error)")+        }+        if let error = error as? ProjectMutationError {+            switch error {+            case .invalidName: return .init("INVALID_INPUT", "Project name must not be empty or whitespace-only")+            case .duplicateName(let name):+                return .init("DUPLICATE_PROJECT_NAME", "A project named \"\(name)\" already exists")+            }+        }+        return .init("INTERNAL_ERROR", error.localizedDescription)+    }++    private static func taskFailure(_ error: TaskService.Error) -> MCPWriteFailure {+        switch error {+        case .taskNotFound: return .init("TASK_NOT_FOUND", error.localizedDescription)+        case .projectNotFound: return .init("PROJECT_NOT_FOUND", error.localizedDescription)+        case .milestoneProjectMismatch: return .init("MILESTONE_PROJECT_MISMATCH", error.localizedDescription)+        case .milestoneNotOpen: return .init("MILESTONE_NOT_OPEN", error.localizedDescription)+        case .duplicateDisplayID: return .init("DUPLICATE_TASK_IDENTIFIER", error.localizedDescription)+        default: return .init("INVALID_INPUT", error.localizedDescription)+        }+    }+}++enum MCPWriteOutcome {+    static func failure(+        tool: String, key: String?, failure: MCPWriteFailure,+        accepted: Bool?, outcome: String = "rejected", retryAction: String? = nil+    ) -> [String: Any] {+        var result: [String: Any] = [+            "contractVersion": 1, "tool": tool, "outcome": outcome,+            "accepted": accepted as Any? ?? NSNull(),+            "error": ["code": failure.code, "message": failure.message],+            "retryAction": retryAction ?? "new_request_new_key"+        ]+        result["idempotencyKey"] = key+        result["currentRecord"] = failure.currentRecord+        return result+    }++    static func result(_ envelope: [String: Any], isError: Bool) -> MCPToolResult {+        // Envelopes contain only validated JSON values; callers use the throwing+        // encoder before committing terminal receipts.+        let text = (try? encode(envelope)) ?? "{\"error\":{\"code\":\"INTERNAL_ERROR\"},\"outcome\":\"uncertain\"}"+        return MCPToolResult(content: [.text(text)], isError: isError ? true : nil)+    }++    static func encode(_ envelope: [String: Any]) throws -> String {+        let data = try JSONSerialization.data(withJSONObject: envelope, options: [.sortedKeys])+        guard let string = String(data: data, encoding: .utf8) else { throw MCPCanonicalJSON.Error.invalidValue }+        return string+    }+}+#endif
Transit/Transit/MCP/Writes/MCPWriteReceiptStore.swift Added +263 / -0
diff --git a/Transit/Transit/MCP/Writes/MCPWriteReceiptStore.swift b/Transit/Transit/MCP/Writes/MCPWriteReceiptStore.swiftnew file mode 100644index 0000000..f4ae865--- /dev/null+++ b/Transit/Transit/MCP/Writes/MCPWriteReceiptStore.swift@@ -0,0 +1,263 @@+import CoreFoundation+import Foundation+import SwiftData++/// Stages receipts in the shared context; it never saves a domain operation.+@MainActor final class MCPWriteReceiptStore {+    enum Error: Swift.Error { case inconsistentReceipt }+    let scopeID: String+    private let context: ModelContext+    private let container: ModelContainer++    init(context: ModelContext, scopeID: String) {+        self.context = context+        self.container = context.container+        self.scopeID = scopeID+    }++    func lookup(tool: String, key: String, durable: Bool = false) throws -> MCPWriteReceipt? {+        let source = durable ? ModelContext(container) : context+        let scope = scopeID+        let descriptor = FetchDescriptor<MCPWriteReceipt>(+            predicate: #Predicate {+                $0.localScopeID == scope && $0.tool == tool && $0.key == key+            })+        let receipts = try source.fetch(descriptor)+        guard receipts.count <= 1 else { throw Error.inconsistentReceipt }+        if let receipt = receipts.first { try validate(receipt) }+        return receipts.first+    }++    func insert(_ reservation: MCPLocalReservation, acceptedAt: Date) throws -> MCPWriteReceipt {+        guard reservation.scopeID == scopeID,+            try lookup(tool: reservation.tool, key: reservation.key) == nil+        else { throw Error.inconsistentReceipt }+        let receipt = MCPWriteReceipt(+            id: reservation.receiptID, localScopeID: scopeID,+            tool: reservation.tool, key: reservation.key,+            formatVersion: reservation.formatVersion,+            requestJSON: reservation.requestJSON, acceptedAt: acceptedAt)+        context.insert(receipt)+        return receipt+    }++    func validate(_ receipt: MCPWriteReceipt) throws {+        guard receipt.localScopeID == scopeID, receipt.formatVersion == 1,+            !receipt.tool.isEmpty, !receipt.key.isEmpty,+            receipt.acceptedAt.timeIntervalSinceReferenceDate.isFinite,+            let data = receipt.requestJSON.data(using: .utf8),+            let request = try JSONSerialization.jsonObject(with: data) as? [String: Any],+            try MCPCanonicalJSON.encode(request) == receipt.requestJSON+        else {+            throw Error.inconsistentReceipt+        }+        if receipt.stateRawValue == "accepted" {+            guard receipt.completedAt == nil, receipt.expiresAt == nil,+                receipt.resultJSON == nil, receipt.resultIsError == nil+            else { throw Error.inconsistentReceipt }+        } else {+            guard ["committed", "rejected"].contains(receipt.stateRawValue),+                let completed = receipt.completedAt, completed.timeIntervalSinceReferenceDate.isFinite,+                completed >= receipt.acceptedAt,+                let expiry = receipt.expiresAt, expiry.timeIntervalSinceReferenceDate.isFinite,+                expiry == completed.addingTimeInterval(604800),+                let result = receipt.resultJSON?.data(using: .utf8),+                let envelope = try JSONSerialization.jsonObject(with: result) as? [String: Any],+                let version = envelope["contractVersion"], try MCPCanonicalJSON.encode(version) == "1",+                envelope["outcome"] as? String == receipt.stateRawValue,+                envelope["tool"] as? String == receipt.tool,+                envelope["idempotencyKey"] as? String == receipt.key,+                let accepted = envelope["accepted"], try MCPCanonicalJSON.encode(accepted) == "true",+                envelope["completedAt"] as? String == MCPRecordSnapshot.timestamp(completed),+                envelope["replayExpiresAt"] as? String == MCPRecordSnapshot.timestamp(expiry),+                receipt.resultIsError == (receipt.stateRawValue == "rejected")+            else {+                throw Error.inconsistentReceipt+            }+            try validateTerminal(envelope, receipt: receipt, request: request)+        }+    }++    /// Repair terminal guard deadlines before deleting either side. The caller+    /// saves staged receipt deletions; a remaining receipt can restore its guard.+    func cleanup(now: Date, reservations: MCPLocalReservationStore) throws {+        guard reservations.scopeID == scopeID else { throw Error.inconsistentReceipt }+        let scope = scopeID+        let receipts = try context.fetch(+            FetchDescriptor<MCPWriteReceipt>(+                predicate: #Predicate {+                    $0.localScopeID == scope+                }))+        var seenKeys = Set<MCPLocalReservationStore.BindingKey>()+        var seenIDs = Set<UUID>()+        var terminal: [MCPLocalReservation] = []+        for receipt in receipts {+            guard seenKeys.insert(.init(tool: receipt.tool, key: receipt.key)).inserted,+                seenIDs.insert(receipt.id).inserted+            else { throw Error.inconsistentReceipt }+            try validate(receipt)+            guard let expiry = receipt.expiresAt else { continue }+            terminal.append(+                MCPLocalReservation(+                    scopeID: scopeID, tool: receipt.tool, key: receipt.key, requestJSON: receipt.requestJSON,+                    formatVersion: receipt.formatVersion, receiptID: receipt.id, expiresAt: expiry))+        }+        try reservations.reconcileTerminalBindings(terminal, now: now)+        for receipt in receipts where receipt.expiresAt.map({ $0 <= now }) == true {+            context.delete(receipt)+        }+    }+}++extension MCPWriteReceiptStore {+    fileprivate func validateTerminal(+        _ envelope: [String: Any], receipt: MCPWriteReceipt, request: [String: Any]+    ) throws {+        if receipt.stateRawValue == "rejected" {+            try validateRejection(envelope, tool: receipt.tool)+            return+        }+        guard let entity = envelope["entityId"] as? String, let id = UUID(uuidString: entity) else {+            throw Error.inconsistentReceipt+        }+        switch receipt.tool {+        case "create_project": try validateRecord(envelope["record"], kind: "project", id: id)+        case "add_comment": try validateRecord(envelope["record"], kind: "comment", id: id)+        case "create_milestone", "update_milestone":+            try validateRecord(envelope["record"], kind: "milestone", id: id)+        case "delete_milestone":+            guard let deleted = envelope["deleted"], try MCPCanonicalJSON.encode(deleted) == "true" else {+                throw Error.inconsistentReceipt+            }+            try validateRecord(envelope["recordBeforeDeletion"], kind: "milestone", id: id)+        case "create_task", "update_task", "update_task_status":+            try validateRecord(envelope["record"], kind: "task", id: id)+            if receipt.tool == "update_task_status" {+                try validateStatusComment(envelope["comment"], taskID: id, request: request)+            }+        default: throw Error.inconsistentReceipt+        }+    }++    fileprivate func validateRejection(_ envelope: [String: Any], tool: String) throws {+        guard let error = envelope["error"] as? [String: Any],+            let code = error["code"] as? String, !code.isEmpty,+            error["message"] is String,+            envelope["retryAction"] as? String == "new_request_new_key"+        else { throw Error.inconsistentReceipt }+        if code == "REVISION_CONFLICT" || envelope["currentRecord"] != nil {+            let kind = ["update_milestone", "delete_milestone"].contains(tool) ? "milestone" : "task"+            try validateRecord(envelope["currentRecord"], kind: kind)+        }++    }++    fileprivate func validateStatusComment(_ value: Any?, taskID: UUID, request: [String: Any]) throws {+        guard let value else { throw Error.inconsistentReceipt }+        if let record = value as? [String: Any] {+            try validateRecord(record, kind: "comment")+            guard (record["taskId"] as? String).flatMap(UUID.init(uuidString:)) == taskID else {+                throw Error.inconsistentReceipt+            }+        } else {+            let requested = (request["comment"] as? String)?.trimmingCharacters(in: .whitespacesAndNewlines)+            guard value is NSNull, requested?.isEmpty != false else { throw Error.inconsistentReceipt }+        }+    }++    fileprivate func validateRecord(_ value: Any?, kind: String, id: UUID? = nil) throws {+        guard let record = value as? [String: Any], let revision = record["revision"] as? String,+            revision.range(of: "^r1:[0-9a-f]{64}$", options: .regularExpression) == revision+                .startIndex..<revision.endIndex+        else { throw Error.inconsistentReceipt }+        let idField = kind == "comment" ? "id" : kind + "Id"+        guard let rawID = record[idField] as? String, let recordID = UUID(uuidString: rawID),+            id == nil || id == recordID+        else { throw Error.inconsistentReceipt }+        let strings: [String]+        switch kind {+        case "project": strings = ["name", "description", "colorHex"]+        case "comment": strings = ["content", "authorName", "creationDate"]+        case "milestone": strings = ["name", "status", "creationDate", "lastStatusChangeDate"]+        default: strings = ["name", "status", "type", "priority", "creationDate", "lastStatusChangeDate"]+        }+        guard strings.allSatisfy({ record[$0] is String }) else { throw Error.inconsistentReceipt }+        try validateRecordDatesAndIDs(record, idField: idField)+        try validateOptionalRecordFields(record, kind: kind)+        try validateRecordContent(record, kind: kind, id: recordID)+    }++    fileprivate func validateRecordDatesAndIDs(_ record: [String: Any], idField: String) throws {+        let formatter = ISO8601DateFormatter()+        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]+        for field in ["creationDate", "lastStatusChangeDate", "completionDate"] {+            if let value = record[field] {+                guard let string = value as? String, formatter.date(from: string) != nil else {+                    throw Error.inconsistentReceipt+                }+            }+        }+        for field in ["projectId", "taskId"] where field != idField {+            if let value = record[field] {+                guard let string = value as? String, UUID(uuidString: string) != nil else {+                    throw Error.inconsistentReceipt+                }+            }+        }+    }++    fileprivate func validateOptionalRecordFields(_ record: [String: Any], kind: String) throws {+        for field in ["description", "gitRepo", "projectName"] {+            if let value = record[field] {+                guard value is String || (kind == "task" && field == "description" && value is NSNull) else {+                    throw Error.inconsistentReceipt+                }+            }+        }+        if let displayID = record["displayId"] {+            guard let number = displayID as? NSNumber, CFGetTypeID(number) != CFBooleanGetTypeID(),+                displayID is Int+            else { throw Error.inconsistentReceipt }+        }+        if let milestone = record["milestone"] {+            guard let summary = milestone as? [String: Any],+                let rawID = summary["milestoneId"] as? String, UUID(uuidString: rawID) != nil,+                summary["name"] is String, summary["status"] is String+            else { throw Error.inconsistentReceipt }+            if let displayID = summary["displayId"] {+                guard let number = displayID as? NSNumber, CFGetTypeID(number) != CFBooleanGetTypeID(),+                    displayID is Int+                else { throw Error.inconsistentReceipt }+            }+        }+    }++    fileprivate func validateRecordContent(_ record: [String: Any], kind: String, id: UUID) throws {+        if kind == "comment" {+            guard let number = record["isAgent"] as? NSNumber,+                CFGetTypeID(number) == CFBooleanGetTypeID(), record["taskId"] is String+            else {+                throw Error.inconsistentReceipt+            }+        }+        if kind == "milestone" {+            guard let count = record["taskCount"] as? NSNumber,+                CFGetTypeID(count) != CFBooleanGetTypeID(), let integer = Int(exactly: count.doubleValue),+                integer >= 0+            else { throw Error.inconsistentReceipt }+        }+        if kind == "task" {+            guard record["description"] is String || record["description"] is NSNull,+                let metadata = record["metadata"] as? [String: Any],+                metadata.values.allSatisfy({ $0 is String }),+                let comments = record["comments"] as? [[String: Any]]+            else { throw Error.inconsistentReceipt }+            for comment in comments {+                try validateRecord(comment, kind: "comment")+                guard (comment["taskId"] as? String).flatMap(UUID.init(uuidString:)) == id else {+                    throw Error.inconsistentReceipt+                }+            }+        }+    }+}
Transit/Transit/Models/MCPWriteReceipt.swift Added +31 / -0
diff --git a/Transit/Transit/Models/MCPWriteReceipt.swift b/Transit/Transit/Models/MCPWriteReceipt.swiftnew file mode 100644index 0000000..a7aef6f--- /dev/null+++ b/Transit/Transit/Models/MCPWriteReceipt.swift@@ -0,0 +1,31 @@+import Foundation+import SwiftData++/// Completed outcomes share the domain store's commit boundary. Scope remains+/// local even when CloudKit imports receipts created by another device.+@Model+final class MCPWriteReceipt {+    var id: UUID = UUID()+    var localScopeID: String = ""+    var tool: String = ""+    var key: String = ""+    var formatVersion: Int = 1+    var requestJSON: String = ""+    var stateRawValue: String = "accepted"+    var acceptedAt: Date = Date()+    var completedAt: Date?+    var expiresAt: Date?+    var resultJSON: String?+    var resultIsError: Bool?++    init(id: UUID = UUID(), localScopeID: String, tool: String, key: String,+         formatVersion: Int = 1, requestJSON: String, acceptedAt: Date) {+        self.id = id+        self.localScopeID = localScopeID+        self.tool = tool+        self.key = key+        self.formatVersion = formatVersion+        self.requestJSON = requestJSON+        self.acceptedAt = acceptedAt+    }+}
Transit/Transit/Services/MilestoneService.swift Modified +36 / -30
diff --git a/Transit/Transit/Services/MilestoneService.swift b/Transit/Transit/Services/MilestoneService.swiftindex 439b1f7..18b3000 100644--- a/Transit/Transit/Services/MilestoneService.swift+++ b/Transit/Transit/Services/MilestoneService.swift@@ -41,14 +41,25 @@ final class MilestoneService {         project: Project,         save: ((ModelContext) throws -> Void)? = nil     ) async throws -> Milestone {-        let trimmedName = name.trimmingCharacters(in: .whitespacesAndNewlines)-        guard !trimmedName.isEmpty else {-            throw Error.invalidName-        }+        let prepared = try await prepareMilestoneCreation(name: name, description: description, project: project)+        return try applyMilestoneCreation(prepared, save: save ?? mutationSave)+    } -        guard try !milestoneNameExists(trimmedName, in: project) else {-            throw Error.duplicateName-        }+    struct PreparedCreation {+        let name: String+        let description: String?+        let projectID: UUID+        let displayID: DisplayID+    }++    /// Allocates an ID without inserting or saving a milestone.+    func prepareMilestoneCreation(+        name: String, description: String?, project: Project+    ) async throws -> PreparedCreation {+        let trimmedName = name.trimmingCharacters(in: .whitespacesAndNewlines)+        guard !trimmedName.isEmpty else { throw Error.invalidName }+        guard try !milestoneNameExists(trimmedName, in: project) else { throw Error.duplicateName }+        let projectID = project.id          let displayID: DisplayID         do {@@ -75,31 +86,26 @@ final class MilestoneService {             displayID = .provisional         } -        // Counter stores are not required to cooperate with Swift cancellation.-        // Re-check after allocation handling and before any post-await model work-        // so a successfully allocated ID cannot turn a cancelled operation into a-        // persisted milestone (T-1765).         try Task.checkCancellation()-        try CreationProjectValidator.validate(project, in: modelContext, error: Error.projectNotFound)--        // Re-check uniqueness after the allocation await. The check above ran-        // before this method suspended, so a concurrent create could have-        // committed the same name in the meantime (T-1764). CloudKit-backed-        // SwiftData cannot express `@Attribute(.unique)`, so this service check-        // *is* the invariant — and it only holds if the last check and the insert-        // are not separated by a suspension point, which is the case from here on.-        guard try !milestoneNameExists(trimmedName, in: project) else {-            throw Error.duplicateName-        }+        return PreparedCreation(name: trimmedName, description: description, projectID: projectID, displayID: displayID)+    } +    /// Validates live references and name uniqueness, then inserts synchronously without saving by default.+    @discardableResult+    func applyMilestoneCreation(+        _ prepared: PreparedCreation,+        save: ((ModelContext) throws -> Void)? = nil+    ) throws -> Milestone {+        try Task.checkCancellation()+        let projectID = prepared.projectID+        let descriptor = FetchDescriptor<Project>(predicate: #Predicate { $0.id == projectID })+        guard let project = try modelContext.fetch(descriptor).first else { throw Error.projectNotFound }+        try CreationProjectValidator.validate(project, in: modelContext, error: Error.projectNotFound)+        guard try !milestoneNameExists(prepared.name, in: project) else { throw Error.duplicateName }         let milestone = Milestone(-            name: trimmedName,-            description: description,-            project: project,-            displayID: displayID+            name: prepared.name, description: prepared.description, project: project, displayID: prepared.displayID         )--        try modelContext.insertOrDelete(milestone, save: save ?? mutationSave)+        try modelContext.insertOrDelete(milestone, save: save ?? { _ in })         return milestone     } @@ -151,9 +157,9 @@ final class MilestoneService {         try modelContext.saveOrRollback(save: mutationSave)     } -    func deleteMilestone(_ milestone: Milestone) throws {+    func deleteMilestone(_ milestone: Milestone, save: Bool = true) throws {         modelContext.delete(milestone)-        try modelContext.saveOrRollback(save: mutationSave)+        if save { try modelContext.saveOrRollback(save: mutationSave) }     }      // MARK: - Assignment
Transit/Transit/Services/ProjectService.swift Modified +4 / -2
diff --git a/Transit/Transit/Services/ProjectService.swift b/Transit/Transit/Services/ProjectService.swiftindex e339436..f9ebdfb 100644--- a/Transit/Transit/Services/ProjectService.swift+++ b/Transit/Transit/Services/ProjectService.swift@@ -42,7 +42,9 @@ final class ProjectService {     /// name (case-insensitive) already exists. Rethrows the underlying storage     /// error when the duplicate check itself cannot be read (T-1614).     @discardableResult-    func createProject(name: String, description: String, gitRepo: String?, colorHex: String) throws -> Project {+    func createProject(+        name: String, description: String, gitRepo: String?, colorHex: String, save: Bool = true+    ) throws -> Project {         let trimmedName = name.trimmingCharacters(in: .whitespacesAndNewlines)         guard !trimmedName.isEmpty else {             throw ProjectMutationError.invalidName@@ -51,7 +53,7 @@ final class ProjectService {             throw ProjectMutationError.duplicateName(trimmedName)         }         let project = Project(name: trimmedName, description: description, gitRepo: gitRepo, colorHex: colorHex)-        try modelContext.insertOrDelete(project)+        try modelContext.insertOrDelete(project, save: save ? { try $0.save() } : { _ in })         return project     } 
Transit/Transit/Services/TaskService.swift Modified +90 / -63
diff --git a/Transit/Transit/Services/TaskService.swift b/Transit/Transit/Services/TaskService.swiftindex 7df651e..0c37e27 100644--- a/Transit/Transit/Services/TaskService.swift+++ b/Transit/Transit/Services/TaskService.swift@@ -83,70 +83,11 @@ final class TaskService {         milestone: Milestone? = nil,         save: ((ModelContext) throws -> Void)? = nil     ) async throws -> TransitTask {-        let trimmedName = name.trimmingCharacters(in: .whitespacesAndNewlines)-        guard !trimmedName.isEmpty else {-            throw Error.invalidName-        }--        // Keep this validation at the aggregate boundary even though automation-        // surfaces pre-validate resolved milestones: direct UI and future callers-        // must not allocate an ID or insert a cross-project relationship.-        if let milestone, milestone.project?.id != project.id {-            throw Error.milestoneProjectMismatch-        }--        let displayID: DisplayID-        do {-            // Pass a closure so the set of display IDs already committed locally-            // is snapshotted inside the allocation gate — fresh relative to any-            // concurrent create that committed just before us — so the allocator-            // never hands back an in-use ID even against a stale counter read-            // (T-1395).-            let id = try await displayIDAllocator.allocateNextID(excluding: { try self.usedDisplayIDs.tasks() })-            displayID = .permanent(id)-        } catch let error as CancellationError {-            // The allocation gate propagates CancellationError when this caller is-            // cancelled while waiting for an ID (T-1395). Cancellation must abort the-            // create before any insert/save so a cancelled request never mutates-            // persistent state — only genuine CloudKit/offline failures fall back to-            // a provisional ID (T-1426).-            throw error-        } catch DisplayIDAllocator.Error.usedIDLookupFailed(let description) {-            // The local store could not be read, so the collision guard never ran.-            // That is not the offline condition provisional IDs exist for, and a-            // provisional ID would hide a broken store behind a normal-looking-            // create — surface it instead (T-1621).-            throw DisplayIDAllocator.Error.usedIDLookupFailed(description: description)-        } catch {-            displayID = .provisional-        }--        // Counter stores are not required to cooperate with Swift cancellation.-        // Re-check after allocation handling and immediately before constructing-        // and inserting the model so a successfully allocated ID cannot turn a-        // cancelled operation into a persisted task (T-1765).-        try Task.checkCancellation()-        try CreationProjectValidator.validate(project, in: modelContext, error: Error.projectNotFound)-        try TaskCreationMilestoneValidator.validate(-            milestone,-            projectID: project.id,-            in: modelContext-        )--        let task = TransitTask(-            name: trimmedName,-            description: description,-            type: type,-            project: project,-            displayID: displayID,-            metadata: metadata,-            priority: priority+        let prepared = try await prepareTaskCreation(+            name: name, description: description, type: type, project: project,+            metadata: metadata, priority: priority, milestone: milestone         )-        StatusEngine.initializeNewTask(task)-        task.milestone = milestone--        try modelContext.insertOrDelete(task, save: save ?? createSave)-        return task+        return try applyTaskCreation(prepared, save: save ?? createSave)     }      // MARK: - Status Changes@@ -370,3 +311,89 @@ final class TaskService {         modelContext.safeRollback()     } }++extension TaskService {+    /// Immutable input and allocated ID only; preparation never inserts domain models.+    struct PreparedCreation {+        let name: String+        let description: String?+        let type: TaskType+        let projectID: UUID+        let milestoneID: UUID?+        let metadata: [String: String]?+        let priority: TaskPriority+        let displayID: DisplayID+    }++    func prepareTaskCreation(+        name: String,+        description: String?,+        type: TaskType,+        project: Project,+        metadata: [String: String]? = nil,+        priority: TaskPriority = .medium,+        milestone: Milestone? = nil+    ) async throws -> PreparedCreation {+        let trimmedName = name.trimmingCharacters(in: .whitespacesAndNewlines)+        guard !trimmedName.isEmpty else { throw Error.invalidName }+        let projectID = project.id+        let milestoneID = milestone?.id+        if let milestone, milestone.project?.id != projectID {+            throw Error.milestoneProjectMismatch+        }++        let displayID: DisplayID+        do {+            // Pass a closure so the set of display IDs already committed locally+            // is snapshotted inside the allocation gate — fresh relative to any+            // concurrent create that committed just before us — so the allocator+            // never hands back an in-use ID even against a stale counter read+            // (T-1395).+            let id = try await displayIDAllocator.allocateNextID(excluding: { try self.usedDisplayIDs.tasks() })+            displayID = .permanent(id)+        } catch let error as CancellationError {+            // Cancellation is not an offline fallback; abort without inserting.+            throw error+        } catch DisplayIDAllocator.Error.usedIDLookupFailed(let description) {+            // Unreadable collision guards fail closed instead of using provisional IDs.+            throw DisplayIDAllocator.Error.usedIDLookupFailed(description: description)+        } catch {+            displayID = .provisional+        }++        try Task.checkCancellation()+        return PreparedCreation(+            name: trimmedName, description: description, type: type, projectID: projectID,+            milestoneID: milestoneID, metadata: metadata, priority: priority, displayID: displayID+        )+    }++    /// Re-resolves pinned UUIDs and validates immediately before inserting. No suspension or save by default.+    @discardableResult+    func applyTaskCreation(+        _ prepared: PreparedCreation,+        save: ((ModelContext) throws -> Void)? = nil+    ) throws -> TransitTask {+        try Task.checkCancellation()+        let projectID = prepared.projectID+        let projectDescriptor = FetchDescriptor<Project>(predicate: #Predicate { $0.id == projectID })+        guard let project = try modelContext.fetch(projectDescriptor).first else { throw Error.projectNotFound }+        try CreationProjectValidator.validate(project, in: modelContext, error: Error.projectNotFound)+        var milestone: Milestone?+        if let milestoneID = prepared.milestoneID {+            let descriptor = FetchDescriptor<Milestone>(predicate: #Predicate { $0.id == milestoneID })+            guard !modelContext.deletedModelsArray.contains(where: { ($0 as? Milestone)?.id == milestoneID }),+                  let resolved = try modelContext.fetch(descriptor).first else { throw Error.milestoneNotOpen }+            milestone = resolved+        }+        try TaskCreationMilestoneValidator.validate(milestone, projectID: projectID, in: modelContext)+        let task = TransitTask(+            name: prepared.name, description: prepared.description, type: prepared.type,+            project: project, displayID: prepared.displayID, metadata: prepared.metadata, priority: prepared.priority+        )+        StatusEngine.initializeNewTask(task)+        task.milestone = milestone+        try modelContext.insertOrDelete(task, save: save ?? { _ in })+        return task+    }+}
Transit/Transit/TransitApp.swift Modified +16 / -2
diff --git a/Transit/Transit/TransitApp.swift b/Transit/Transit/TransitApp.swiftindex f525293..f288f60 100644--- a/Transit/Transit/TransitApp.swift+++ b/Transit/Transit/TransitApp.swift@@ -29,6 +29,7 @@ struct TransitApp: App {     #if os(macOS)     private let mcpSettings: MCPSettings     private let mcpServer: MCPServer+    private let mcpWriteCoordinator: MCPWriteCoordinator     #endif      #if os(iOS)@@ -49,7 +50,9 @@ struct TransitApp: App {         let syncManager = SyncManager()         self.syncManager = syncManager -        let schema = Schema([Project.self, TransitTask.self, Comment.self, Milestone.self, SyncHeartbeat.self])+        let schema = Schema([+            Project.self, TransitTask.self, Comment.self, Milestone.self, SyncHeartbeat.self, MCPWriteReceipt.self+        ])         let config: ModelConfiguration         if isInert || Self.uiTestScenario != nil {             config = ModelConfiguration(schema: schema, isStoredInMemoryOnly: true, cloudKitDatabase: .none)@@ -147,11 +150,22 @@ struct TransitApp: App {         #if os(macOS)         let mcpSettings = MCPSettings()         self.mcpSettings = mcpSettings+        let writeServices = MCPWriteCommandServices(+            tasks: taskService, projects: projectService,+            comments: commentService, milestones: milestoneService, context: context)+        // Own the retry scope and lock for the app lifetime, across listener restarts.+        let sidecar = isInert || Self.uiTestScenario != nil+            ? FileManager.default.temporaryDirectory.appendingPathComponent("mcp-tests-" + UUID().uuidString)+            : config.url.appendingPathExtension("mcp-writes")+        let writeCoordinator = MCPWriteCoordinator(services: writeServices,+            sidecarDirectory: sidecar, persistence: persistence)+        self.mcpWriteCoordinator = writeCoordinator+        try? writeCoordinator.cleanupExpiredOutcomes()         let mcpToolHandler = MCPToolHandler(             taskService: taskService, projectService: projectService,             commentService: commentService, milestoneService: milestoneService,             maintenanceService: maintenanceService, settings: mcpSettings,-            persistence: persistence+            persistence: persistence, writeCoordinator: writeCoordinator         )         self.mcpServer = MCPServer(toolHandler: mcpToolHandler)         #endif
Transit/TransitTests/BoolAsIntIdRejectionTests.swift Modified +14 / -14
diff --git a/Transit/TransitTests/BoolAsIntIdRejectionTests.swift b/Transit/TransitTests/BoolAsIntIdRejectionTests.swiftindex 68f81c7..2428131 100644--- a/Transit/TransitTests/BoolAsIntIdRejectionTests.swift+++ b/Transit/TransitTests/BoolAsIntIdRejectionTests.swift@@ -282,8 +282,8 @@ struct BoolAsIntIdRejectionMCPTests {             name: "Task", description: nil, type: .feature, project: project         ) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task_status",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task_status",             arguments: ["displayId": Self.trueNum, "status": "planning"]         )) @@ -297,8 +297,8 @@ struct BoolAsIntIdRejectionMCPTests {     @Test func mcpUpdateTaskRejectsBooleanDisplayId() async throws {         let env = try MCPTestHelpers.makeEnv() -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: ["displayId": Self.falseNum]         )) @@ -314,8 +314,8 @@ struct BoolAsIntIdRejectionMCPTests {             name: "Task", description: nil, type: .feature, project: project         ) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: [                 "displayId": task.permanentDisplayId!,                 "milestoneDisplayId": Self.trueNum@@ -333,8 +333,8 @@ struct BoolAsIntIdRejectionMCPTests {         let env = try MCPTestHelpers.makeEnv()         let project = MCPTestHelpers.makeProject(in: env.context) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: [                 "name": "New Task",                 "type": "feature",@@ -353,8 +353,8 @@ struct BoolAsIntIdRejectionMCPTests {     @Test func mcpAddCommentRejectsBooleanDisplayId() async throws {         let env = try MCPTestHelpers.makeEnv() -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "add_comment",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "add_comment",             arguments: [                 "displayId": Self.trueNum,                 "content": "A comment",@@ -372,8 +372,8 @@ struct BoolAsIntIdRejectionMCPTests {     @Test func mcpUpdateMilestoneRejectsBooleanDisplayId() async throws {         let env = try MCPTestHelpers.makeEnv() -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_milestone",             arguments: ["displayId": Self.falseNum, "name": "Updated"]         )) @@ -387,8 +387,8 @@ struct BoolAsIntIdRejectionMCPTests {     @Test func mcpDeleteMilestoneRejectsBooleanDisplayId() async throws {         let env = try MCPTestHelpers.makeEnv() -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "delete_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "delete_milestone",             arguments: ["displayId": Self.trueNum]         )) 
Transit/TransitTests/CreateRequiredStringValidationTests.swift Modified +14 / -13
diff --git a/Transit/TransitTests/CreateRequiredStringValidationTests.swift b/Transit/TransitTests/CreateRequiredStringValidationTests.swiftindex 850a4b9..dc970fb 100644--- a/Transit/TransitTests/CreateRequiredStringValidationTests.swift+++ b/Transit/TransitTests/CreateRequiredStringValidationTests.swift@@ -64,8 +64,8 @@ struct CreateRequiredStringValidationTests {         let project = MCPTestHelpers.makeProject(in: env.context)          for entry in nonStringValues {-            let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-                tool: "create_task",+            let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",                 arguments: try jsonRoundTripped([                     "name": entry.value,                     "type": "feature",@@ -77,8 +77,8 @@ struct CreateRequiredStringValidationTests {         }          for entry in nonStringValues {-            let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-                tool: "create_task",+            let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",                 arguments: try jsonRoundTripped([                     "name": "Task",                     "type": entry.value,@@ -89,17 +89,18 @@ struct CreateRequiredStringValidationTests {             #expect(try MCPTestHelpers.errorText(response) == "type must be a string")         } -        let missingName = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let missingName = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: ["type": "feature", "projectId": project.id.uuidString]         ))         #expect(try MCPTestHelpers.errorText(missingName) == "Missing required argument: name") -        let invalidType = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let invalidType = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: ["name": "Task", "type": "epic", "projectId": project.id.uuidString]         ))-        #expect(try MCPTestHelpers.errorText(invalidType).hasPrefix("Invalid type: epic."))+        #expect(try MCPTestHelpers.errorCode(invalidType) == "INVALID_TYPE")+        #expect(try env.context.fetch(FetchDescriptor<TransitTask>()).isEmpty)          let tasks = try env.context.fetch(FetchDescriptor<TransitTask>())         #expect(tasks.isEmpty, "Malformed create_task requests must not create tasks")@@ -168,16 +169,16 @@ struct CreateRequiredStringValidationTests {         let project = MCPTestHelpers.makeProject(in: env.context)          for entry in nonStringValues {-            let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-                tool: "create_milestone",+            let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_milestone",                 arguments: try jsonRoundTripped(["name": entry.value, "projectId": project.id.uuidString])             ))             #expect(try MCPTestHelpers.isError(response))             #expect(try MCPTestHelpers.errorText(response) == "name must be a string")         } -        let missingName = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_milestone",+        let missingName = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_milestone",             arguments: ["projectId": project.id.uuidString]         ))         #expect(try MCPTestHelpers.errorText(missingName) == "Missing required argument: name")
Transit/TransitTests/CreateTaskMetadataShapeValidationTests.swift Modified +5 / -5
diff --git a/Transit/TransitTests/CreateTaskMetadataShapeValidationTests.swift b/Transit/TransitTests/CreateTaskMetadataShapeValidationTests.swiftindex 20148f9..ad56dc5 100644--- a/Transit/TransitTests/CreateTaskMetadataShapeValidationTests.swift+++ b/Transit/TransitTests/CreateTaskMetadataShapeValidationTests.swift@@ -95,20 +95,20 @@ struct CreateTaskMetadataShapeValidationTests {     @Test func mcpCreateTaskRejectsEveryNonObjectMetadataShapeWithoutMutation() async throws {         let env = try MCPTestHelpers.makeEnv()         let project = MCPTestHelpers.makeProject(in: env.context)-        let validResponse = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let validResponse = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: [                 "name": "Task without metadata",                 "type": "feature",                 "projectId": project.id.uuidString             ]         ))-        let validTaskID = try #require(try MCPTestHelpers.decodeResult(validResponse)["taskId"] as? String)+        let validTaskID = try #require(try MCPTestHelpers.decodeSavedRecord(validResponse)["taskId"] as? String)         let validTaskUUID = try #require(UUID(uuidString: validTaskID))          for entry in nonObjectValues {-            let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-                tool: "create_task",+            let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",                 arguments: [                     "name": "Task with invalid metadata \(entry.label)",                     "type": "feature",
Transit/TransitTests/CreationProjectDeletionTests.swift Modified +6 / -9
diff --git a/Transit/TransitTests/CreationProjectDeletionTests.swift b/Transit/TransitTests/CreationProjectDeletionTests.swiftindex 2daf0f0..a9024b3 100644--- a/Transit/TransitTests/CreationProjectDeletionTests.swift+++ b/Transit/TransitTests/CreationProjectDeletionTests.swift@@ -95,15 +95,12 @@ struct CreationProjectDeletionTests {         let project = try makeProject(in: env.context)         let projectID = project.id +        let request = try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",+            arguments: ["name": "Must Not Persist", "type": "bug", "projectId": projectID.uuidString]+        )         let creation = Task { @MainActor in-            await env.handler.handle(MCPTestHelpers.toolCallRequest(-                tool: "create_task",-                arguments: [-                    "name": "Must Not Persist",-                    "type": "bug",-                    "projectId": projectID.uuidString-                ]-            ))+            await env.handler.handle(request)         }          let allocationStarted = await store.waitUntilAllocationStarts()@@ -120,7 +117,7 @@ struct CreationProjectDeletionTests {          let response = await creation.value         #expect(try MCPTestHelpers.isError(response))-        #expect(try MCPTestHelpers.errorText(response) == "No matching project found")+        #expect(try MCPTestHelpers.errorCode(response) == "PROJECT_NOT_FOUND")         try expectNoProjectsOrTasks(in: env.context.container)     } #endif
Transit/TransitTests/DeferredMutationServiceTests.swift Added +116 / -0
diff --git a/Transit/TransitTests/DeferredMutationServiceTests.swift b/Transit/TransitTests/DeferredMutationServiceTests.swiftnew file mode 100644index 0000000..18fd2df--- /dev/null+++ b/Transit/TransitTests/DeferredMutationServiceTests.swift@@ -0,0 +1,116 @@+import Foundation+import SwiftData+import Testing+@testable import Transit++@MainActor @Suite(.serialized)+struct DeferredMutationServiceTests {+    @Test func taskPreparationPinsReferencesWithoutInserting() async throws {+        let fixture = try TestModelContainer()+        let context = fixture.context+        context.autosaveEnabled = false+        let project = Project(name: "P", description: "", gitRepo: nil, colorHex: "red")+        context.insert(project)+        let milestone = Milestone(name: "M", project: project, displayID: .permanent(1))+        context.insert(milestone)+        try context.save()+        let counter = DeferredServiceCounter()+        let service = TaskService(modelContext: context, displayIDAllocator: DisplayIDAllocator(store: counter))+        let operation = Task {+            try await service.prepareTaskCreation(name: " T ", description: nil, type: .feature,+                                                   project: project, milestone: milestone)+        }+        await counter.waitForLoad()+        #expect(try context.fetch(FetchDescriptor<TransitTask>()).isEmpty)+        milestone.statusRawValue = MilestoneStatus.done.rawValue+        try context.save()+        await counter.release()+        let prepared = try await operation.value+        #expect(throws: TaskService.Error.milestoneNotOpen) { try service.applyTaskCreation(prepared) }+        #expect(try context.fetch(FetchDescriptor<TransitTask>()).isEmpty)+    }++    @Test func milestonePreparationRechecksCompetingNamesAfterSuspension() async throws {+        let fixture = try TestModelContainer()+        let context = fixture.context+        context.autosaveEnabled = false+        let project = Project(name: "P", description: "", gitRepo: nil, colorHex: "red")+        context.insert(project)+        try context.save()+        let counter = DeferredServiceCounter()+        let service = MilestoneService(modelContext: context, displayIDAllocator: DisplayIDAllocator(store: counter))+        let operation = Task {+            try await service.prepareMilestoneCreation(name: "M", description: nil, project: project)+        }+        await counter.waitForLoad()+        let competitor = Milestone(name: "m", project: project, displayID: .permanent(50))+        context.insert(competitor)+        try context.save()+        await counter.release()+        let prepared = try await operation.value+        #expect(throws: MilestoneService.Error.duplicateName) { try service.applyMilestoneCreation(prepared) }+        #expect(try context.fetch(FetchDescriptor<Milestone>()).count == 1)+    }++    @Test func cancelledAllocationNeverInserts() async throws {+        let fixture = try TestModelContainer()+        let context = fixture.context+        let project = Project(name: "P", description: "", gitRepo: nil, colorHex: "red")+        context.insert(project)+        try context.save()+        let counter = DeferredServiceCounter()+        let service = TaskService(modelContext: context, displayIDAllocator: DisplayIDAllocator(store: counter))+        let operation = Task {+            _ = try await service.createTask(name: "T", description: nil, type: .feature, project: project)+        }+        await counter.waitForLoad()+        operation.cancel()+        await counter.release()+        do {+            _ = try await operation.value+            Issue.record("Cancelled creation succeeded")+        } catch is CancellationError { }+        #expect(try context.fetch(FetchDescriptor<TransitTask>()).isEmpty)+    }++    @Test func projectAndMilestoneDeletionDeferPersistence() async throws {+        let fixture = try TestModelContainer()+        let context = fixture.context+        context.autosaveEnabled = false+        let project = try ProjectService(modelContext: context).createProject(+            name: "P", description: "", gitRepo: nil, colorHex: "red", save: false+        )+        #expect(try ModelContext(fixture.container).fetch(FetchDescriptor<Project>()).isEmpty)+        try context.save()+        let milestones = MilestoneService(modelContext: context,+            displayIDAllocator: DisplayIDAllocator(store: InMemoryCounterStore()))+        let milestone = try await milestones.createMilestone(name: "M", description: nil, project: project)+        try milestones.deleteMilestone(milestone, save: false)+        #expect(try ModelContext(fixture.container).fetch(FetchDescriptor<Milestone>()).count == 1)+        try context.save()+        #expect(try ModelContext(fixture.container).fetch(FetchDescriptor<Milestone>()).isEmpty)+    }+}++private actor DeferredServiceCounter: DisplayIDAllocator.CounterStore {+    private var loadContinuation: CheckedContinuation<Void, Never>?+    private var startedContinuation: CheckedContinuation<Void, Never>?+    private var started = false++    func waitForLoad() async {+        if started { return }+        await withCheckedContinuation { startedContinuation = $0 }+    }++    func release() { loadContinuation?.resume(); loadContinuation = nil }++    func loadCounter() async throws -> DisplayIDAllocator.CounterSnapshot {+        started = true+        startedContinuation?.resume()+        startedContinuation = nil+        await withCheckedContinuation { loadContinuation = $0 }+        return .init(nextDisplayID: 1, changeTag: nil)+    }++    func saveCounter(nextDisplayID: Int, expectedChangeTag: String?) async throws { }+}
Transit/TransitTests/FallbackOutcomeFixture.swift Modified +3 / -1
diff --git a/Transit/TransitTests/FallbackOutcomeFixture.swift b/Transit/TransitTests/FallbackOutcomeFixture.swiftindex 418c98d..b8b6b6d 100644--- a/Transit/TransitTests/FallbackOutcomeFixture.swift+++ b/Transit/TransitTests/FallbackOutcomeFixture.swift@@ -33,7 +33,9 @@ enum FallbackOutcomeFixture {     }      private static func makeOutcome(failPrimaryStore: Bool) -> ContainerFactory.ContainerOutcome {-        let schema = Schema([Project.self, TransitTask.self, Comment.self, Milestone.self, SyncHeartbeat.self])+        let schema = Schema([+            Project.self, TransitTask.self, Comment.self, Milestone.self, SyncHeartbeat.self, MCPWriteReceipt.self+        ])         let config = ModelConfiguration(             "FallbackOutcomeFixture-\(UUID().uuidString)",             schema: schema,
Transit/TransitTests/MCPAddCommentTypeValidationTests.swift Modified +16 / -16
diff --git a/Transit/TransitTests/MCPAddCommentTypeValidationTests.swift b/Transit/TransitTests/MCPAddCommentTypeValidationTests.swiftindex 65f526e..5ee3a8f 100644--- a/Transit/TransitTests/MCPAddCommentTypeValidationTests.swift+++ b/Transit/TransitTests/MCPAddCommentTypeValidationTests.swift@@ -22,8 +22,8 @@ struct MCPAddCommentTypeValidationTests {         )         let displayId = try #require(task.permanentDisplayId) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "add_comment",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "add_comment",             arguments: [                 "displayId": displayId,                 "content": 123,@@ -49,8 +49,8 @@ struct MCPAddCommentTypeValidationTests {         )         let displayId = try #require(task.permanentDisplayId) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "add_comment",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "add_comment",             arguments: [                 "displayId": displayId,                 "content": true,@@ -74,8 +74,8 @@ struct MCPAddCommentTypeValidationTests {         )         let displayId = try #require(task.permanentDisplayId) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "add_comment",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "add_comment",             arguments: [                 "displayId": displayId,                 "content": ["nested"],@@ -100,8 +100,8 @@ struct MCPAddCommentTypeValidationTests {         )         let displayId = try #require(task.permanentDisplayId) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "add_comment",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "add_comment",             arguments: [                 "displayId": displayId,                 "content": NSNull(),@@ -127,8 +127,8 @@ struct MCPAddCommentTypeValidationTests {         )         let displayId = try #require(task.permanentDisplayId) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "add_comment",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "add_comment",             arguments: [                 "displayId": displayId,                 "content": "Note",@@ -154,8 +154,8 @@ struct MCPAddCommentTypeValidationTests {         )         let displayId = try #require(task.permanentDisplayId) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "add_comment",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "add_comment",             arguments: [                 "displayId": displayId,                 "content": "Note",@@ -179,8 +179,8 @@ struct MCPAddCommentTypeValidationTests {         )         let displayId = try #require(task.permanentDisplayId) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "add_comment",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "add_comment",             arguments: [                 "displayId": displayId,                 "content": "Note",@@ -204,8 +204,8 @@ struct MCPAddCommentTypeValidationTests {         )         let displayId = try #require(task.permanentDisplayId) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "add_comment",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "add_comment",             arguments: [                 "displayId": displayId,                 "content": "Note",
Transit/TransitTests/MCPCanonicalJSONTests.swift Added +45 / -0
diff --git a/Transit/TransitTests/MCPCanonicalJSONTests.swift b/Transit/TransitTests/MCPCanonicalJSONTests.swiftnew file mode 100644index 0000000..214b161--- /dev/null+++ b/Transit/TransitTests/MCPCanonicalJSONTests.swift@@ -0,0 +1,45 @@+import Foundation+import Testing+@testable import Transit++@MainActor struct MCPCanonicalJSONTests {+    @Test func generatedObjectPermutationsRoundTrip() throws {+        for seed in 0..<100 {+            let entries: [(String, Any)] = [+                ("z", [seed, true, NSNull()] as [Any]),+                ("a", ["nested": ["value": "\(seed)", "null": NSNull()] as [String: Any]]),+                ("quoted\"", "backslash\\\n\u{0000}")+            ]+            let forward = Dictionary(uniqueKeysWithValues: entries)+            let reverse = Dictionary(uniqueKeysWithValues: entries.reversed())+            let encoded = try MCPCanonicalJSON.encode(forward)+            #expect(encoded == (try MCPCanonicalJSON.encode(reverse)))+            let decoded = try JSONSerialization.jsonObject(with: Data(encoded.utf8))+            #expect(encoded == (try MCPCanonicalJSON.encode(decoded)))+        }+    }++    @Test func finiteNumbersRetainLosslessIdentity() throws {+        let adjacent = [1.0, 1.0000000000000002, 1.0000000000000004]+        let encodings = try adjacent.map { try MCPCanonicalJSON.encode($0) }+        #expect(Set(encodings).count == adjacent.count)+        for value in [1e300, 1e-300, Double.leastNonzeroMagnitude, Double.greatestFiniteMagnitude] {+            let encoded = try MCPCanonicalJSON.encode(value)+            let decoded = try JSONSerialization.jsonObject(with: Data(encoded.utf8), options: [.fragmentsAllowed])+            #expect((decoded as? NSNumber)?.doubleValue == value)+            #expect(try MCPCanonicalJSON.encode(decoded) == encoded)+        }+        for value in [1.0, 10.0, 1000.0, -10.0] {+            #expect(try MCPCanonicalJSON.encode(value) == MCPCanonicalJSON.encode(Int(value)))+        }+    }++    @Test func typedValuesAndPresenceRemainDistinct() throws {+        #expect(try MCPCanonicalJSON.encode(["v": true]) != MCPCanonicalJSON.encode(["v": 1]))+        #expect(try MCPCanonicalJSON.encode(["v": NSNull()]) != MCPCanonicalJSON.encode([String: Any]()))+        #expect(try MCPCanonicalJSON.encode(["v": 1]) == MCPCanonicalJSON.encode(["v": 1.0]))+        #expect(try MCPCanonicalJSON.encode(["v": -0.0]) == MCPCanonicalJSON.encode(["v": 0]))+        #expect(try MCPCanonicalJSON.encode([1, 2]) != MCPCanonicalJSON.encode([2, 1]))+        #expect(throws: (any Error).self) { try MCPCanonicalJSON.encode(Double.infinity) }+    }+}
Transit/TransitTests/MCPCommentFetchFailureTests.swift Modified +3 / -3
diff --git a/Transit/TransitTests/MCPCommentFetchFailureTests.swift b/Transit/TransitTests/MCPCommentFetchFailureTests.swiftindex c305826..383d13b 100644--- a/Transit/TransitTests/MCPCommentFetchFailureTests.swift+++ b/Transit/TransitTests/MCPCommentFetchFailureTests.swift@@ -87,8 +87,8 @@ struct MCPCommentFetchFailureTests {         )         let displayId = try #require(task.permanentDisplayId) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task_status",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task_status",             arguments: [                 "displayId": displayId, "status": "planning",                 "comment": "Persisted exactly once", "authorName": "TestBot"@@ -96,7 +96,7 @@ struct MCPCommentFetchFailureTests {         ))          let result = try MCPTestHelpers.decodeResult(response)-        #expect(result["status"] as? String == "planning")+        #expect((result["record"] as? [String: Any])?["status"] as? String == "planning")         #expect((result["comment"] as? [String: Any])?["content"] as? String == "Persisted exactly once")         #expect(failingFetcher.fetchCallCount == 0) 
Transit/TransitTests/MCPCommentTests.swift Modified +30 / -30
diff --git a/Transit/TransitTests/MCPCommentTests.swift b/Transit/TransitTests/MCPCommentTests.swiftindex 76cab71..505d2c2 100644--- a/Transit/TransitTests/MCPCommentTests.swift+++ b/Transit/TransitTests/MCPCommentTests.swift@@ -16,8 +16,8 @@ struct MCPCommentTests {             name: "Task", description: nil, type: .feature, project: project         ) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "add_comment",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "add_comment",             arguments: [                 "displayId": 1,                 "content": "Test comment",@@ -25,7 +25,7 @@ struct MCPCommentTests {             ]         )) -        let result = try MCPTestHelpers.decodeResult(response)+        let result = try MCPTestHelpers.decodeSavedRecord(response)         #expect(result["id"] is String)         #expect(result["authorName"] as? String == "TestBot")         #expect(result["content"] as? String == "Test comment")@@ -39,8 +39,8 @@ struct MCPCommentTests {     @Test func addCommentMissingContentReturnsError() async throws {         let env = try MCPTestHelpers.makeEnv() -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "add_comment",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "add_comment",             arguments: ["displayId": 1, "authorName": "Bot"]         )) @@ -50,8 +50,8 @@ struct MCPCommentTests {     @Test func addCommentMissingAuthorNameReturnsError() async throws {         let env = try MCPTestHelpers.makeEnv() -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "add_comment",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "add_comment",             arguments: ["displayId": 1, "content": "Hello"]         )) @@ -61,8 +61,8 @@ struct MCPCommentTests {     @Test func addCommentTaskNotFoundReturnsError() async throws {         let env = try MCPTestHelpers.makeEnv() -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "add_comment",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "add_comment",             arguments: ["displayId": 999, "content": "Hello", "authorName": "Bot"]         )) @@ -78,8 +78,8 @@ struct MCPCommentTests {             name: "Task", description: nil, type: .feature, project: project         ) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task_status",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task_status",             arguments: [                 "displayId": 1,                 "status": "planning",@@ -89,7 +89,7 @@ struct MCPCommentTests {         ))          let result = try MCPTestHelpers.decodeResult(response)-        #expect(result["status"] as? String == "planning")+        #expect((result["record"] as? [String: Any])?["status"] as? String == "planning")          let comments = try env.commentService.fetchComments(for: task.id)         #expect(comments.count == 1)@@ -109,8 +109,8 @@ struct MCPCommentTests {             name: "Task", description: nil, type: .feature, project: project         ) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task_status",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task_status",             arguments: [                 "displayId": 1,                 "status": "planning",@@ -128,14 +128,14 @@ struct MCPCommentTests {             name: "Task", description: nil, type: .feature, project: project         ) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task_status",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task_status",             arguments: ["displayId": 1, "status": "planning"]         ))          let result = try MCPTestHelpers.decodeResult(response)-        #expect(result["status"] as? String == "planning")-        #expect(result["comment"] == nil)+        #expect((result["record"] as? [String: Any])?["status"] as? String == "planning")+        #expect(result["comment"] is NSNull)          let comments = try env.commentService.fetchComments(for: task.id)         #expect(comments.isEmpty)@@ -148,8 +148,8 @@ struct MCPCommentTests {             name: "Task", description: nil, type: .feature, project: project         ) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task_status",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task_status",             arguments: [                 "displayId": 1,                 "status": "planning",@@ -159,8 +159,8 @@ struct MCPCommentTests {         ))          let result = try MCPTestHelpers.decodeResult(response)-        #expect(result["status"] as? String == "planning")-        #expect(result["comment"] == nil)+        #expect((result["record"] as? [String: Any])?["status"] as? String == "planning")+        #expect(result["comment"] is NSNull)          let comments = try env.commentService.fetchComments(for: task.id)         #expect(comments.isEmpty)@@ -178,8 +178,8 @@ struct MCPCommentTests {         // Swift string "C:\\new\\notes" is runtime C:\new\notes (literal backslash-n).         // This simulates a JSON-decoded string from: "C:\\new\\notes" in JSON,         // where the user intended to keep the literal backslash-n (e.g., Windows path).-        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "add_comment",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "add_comment",             arguments: [                 "displayId": 1,                 "content": "Path: C:\\new\\notes",@@ -187,7 +187,7 @@ struct MCPCommentTests {             ]         )) -        let result = try MCPTestHelpers.decodeResult(response)+        let result = try MCPTestHelpers.decodeSavedRecord(response)         #expect(result["content"] as? String == "Path: C:\\new\\notes")          let comments = try env.commentService.fetchComments(for: task.id)@@ -203,8 +203,8 @@ struct MCPCommentTests {         )          // The comment contains a literal backslash-n that should NOT be turned into a newline.-        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task_status",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task_status",             arguments: [                 "displayId": 1,                 "status": "planning",@@ -228,8 +228,8 @@ struct MCPCommentTests {             name: "Task", description: nil, type: .feature, project: project         ) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "add_comment",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "add_comment",             arguments: [                 "displayId": 1,                 "content": "Line one\nLine two",@@ -237,7 +237,7 @@ struct MCPCommentTests {             ]         )) -        let result = try MCPTestHelpers.decodeResult(response)+        let result = try MCPTestHelpers.decodeSavedRecord(response)         #expect(result["content"] as? String == "Line one\nLine two")     } 
Transit/TransitTests/MCPCommentTypeValidationTests.swift Modified +10 / -10
diff --git a/Transit/TransitTests/MCPCommentTypeValidationTests.swift b/Transit/TransitTests/MCPCommentTypeValidationTests.swiftindex 950fbe3..234a7d1 100644--- a/Transit/TransitTests/MCPCommentTypeValidationTests.swift+++ b/Transit/TransitTests/MCPCommentTypeValidationTests.swift@@ -18,8 +18,8 @@ struct MCPCommentTypeValidationTests {         let displayId = try #require(task.permanentDisplayId)         let originalStatus = task.statusRawValue -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task_status",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task_status",             arguments: [                 "displayId": displayId,                 "status": "planning",@@ -50,8 +50,8 @@ struct MCPCommentTypeValidationTests {         let displayId = try #require(task.permanentDisplayId)         let originalStatus = task.statusRawValue -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task_status",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task_status",             arguments: [                 "displayId": displayId,                 "status": "planning",@@ -77,8 +77,8 @@ struct MCPCommentTypeValidationTests {         let displayId = try #require(task.permanentDisplayId)         let originalStatus = task.statusRawValue -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task_status",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task_status",             arguments: [                 "displayId": displayId,                 "status": "planning",@@ -104,8 +104,8 @@ struct MCPCommentTypeValidationTests {         let displayId = try #require(task.permanentDisplayId)         let originalStatus = task.statusRawValue -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task_status",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task_status",             arguments: [                 "displayId": displayId,                 "status": "planning",@@ -136,8 +136,8 @@ struct MCPCommentTypeValidationTests {         let displayId = try #require(task.permanentDisplayId)         let originalStatus = task.statusRawValue -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task_status",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task_status",             arguments: [                 "displayId": displayId,                 "status": "planning",
Transit/TransitTests/MCPCreateNonStringProjectTests.swift Modified +22 / -22
diff --git a/Transit/TransitTests/MCPCreateNonStringProjectTests.swift b/Transit/TransitTests/MCPCreateNonStringProjectTests.swiftindex a844cd0..1f8a17a 100644--- a/Transit/TransitTests/MCPCreateNonStringProjectTests.swift+++ b/Transit/TransitTests/MCPCreateNonStringProjectTests.swift@@ -20,8 +20,8 @@ struct MCPCreateNonStringProjectTests {         let env = try MCPTestHelpers.makeEnv()         _ = MCPTestHelpers.makeProject(in: env.context, name: "Alpha") -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: ["name": "X", "type": "bug", "project": 123]         )) @@ -34,8 +34,8 @@ struct MCPCreateNonStringProjectTests {         let env = try MCPTestHelpers.makeEnv()         _ = MCPTestHelpers.makeProject(in: env.context, name: "Alpha") -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: ["name": "X", "type": "bug", "project": true]         )) @@ -48,8 +48,8 @@ struct MCPCreateNonStringProjectTests {         let env = try MCPTestHelpers.makeEnv()         _ = MCPTestHelpers.makeProject(in: env.context, name: "Alpha") -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: ["name": "X", "type": "bug", "project": ["Alpha"]]         )) @@ -62,8 +62,8 @@ struct MCPCreateNonStringProjectTests {         let env = try MCPTestHelpers.makeEnv()         _ = MCPTestHelpers.makeProject(in: env.context, name: "Alpha") -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: ["name": "X", "type": "bug", "project": [String: Any]()]         )) @@ -78,15 +78,15 @@ struct MCPCreateNonStringProjectTests {         let env = try MCPTestHelpers.makeEnv()         let target = MCPTestHelpers.makeProject(in: env.context, name: "Target") -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: [                 "name": "X", "type": "bug",                 "projectId": target.id.uuidString, "project": 123             ]         )) -        let result = try MCPTestHelpers.decodeResult(response)+        let result = try MCPTestHelpers.decodeSavedRecord(response)         let taskIdStr = try #require(result["taskId"] as? String)         let taskId = try #require(UUID(uuidString: taskIdStr))         let task = try env.taskService.findByID(taskId)@@ -99,8 +99,8 @@ struct MCPCreateNonStringProjectTests {         let env = try MCPTestHelpers.makeEnv()         _ = MCPTestHelpers.makeProject(in: env.context, name: "Alpha") -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_milestone",             arguments: ["name": "v1.0", "project": 123]         )) @@ -113,8 +113,8 @@ struct MCPCreateNonStringProjectTests {         let env = try MCPTestHelpers.makeEnv()         _ = MCPTestHelpers.makeProject(in: env.context, name: "Alpha") -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_milestone",             arguments: ["name": "v1.0", "project": false]         )) @@ -127,8 +127,8 @@ struct MCPCreateNonStringProjectTests {         let env = try MCPTestHelpers.makeEnv()         _ = MCPTestHelpers.makeProject(in: env.context, name: "Alpha") -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_milestone",             arguments: ["name": "v1.0", "project": ["Alpha"]]         )) @@ -141,8 +141,8 @@ struct MCPCreateNonStringProjectTests {         let env = try MCPTestHelpers.makeEnv()         _ = MCPTestHelpers.makeProject(in: env.context, name: "Alpha") -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_milestone",             arguments: ["name": "v1.0", "project": [String: Any]()]         )) @@ -155,15 +155,15 @@ struct MCPCreateNonStringProjectTests {         let env = try MCPTestHelpers.makeEnv()         let target = MCPTestHelpers.makeProject(in: env.context, name: "Target") -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_milestone",             arguments: [                 "name": "v1.0",                 "projectId": target.id.uuidString, "project": 123             ]         )) -        let result = try MCPTestHelpers.decodeResult(response)+        let result = try MCPTestHelpers.decodeSavedRecord(response)         let projectId = try #require(result["projectId"] as? String)         #expect(projectId == target.id.uuidString)     }
Transit/TransitTests/MCPCreateProjectTests.swift Modified +31 / -25
diff --git a/Transit/TransitTests/MCPCreateProjectTests.swift b/Transit/TransitTests/MCPCreateProjectTests.swiftindex f53dec3..92e9bbf 100644--- a/Transit/TransitTests/MCPCreateProjectTests.swift+++ b/Transit/TransitTests/MCPCreateProjectTests.swift@@ -23,7 +23,7 @@ struct MCPCreateProjectTests {         let tools = try #require(result["tools"] as? [[String: Any]])         let tool = try #require(tools.first { $0["name"] as? String == "create_project" })         let schema = try #require(tool["inputSchema"] as? [String: Any])-        #expect(Set(try #require(schema["required"] as? [String])) == ["name", "colorHex"])+        #expect(Set(try #require(schema["required"] as? [String])) == ["name", "colorHex", "idempotencyKey"])         let properties = try #require(schema["properties"] as? [String: [String: Any]])         for key in ["name", "colorHex", "description", "gitRepo"] {             #expect(properties[key]?["type"] as? String == "string")@@ -34,29 +34,33 @@ struct MCPCreateProjectTests {         let env = try MCPTestHelpers.makeEnv()         let description = "Line one\nLine two \\n"         let repo = "git@example.com:team/project.git"-        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_project", arguments: [+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_project", arguments: [                 "name": "  New Project\n", "colorHex": "#aB12ef", "description": description, "gitRepo": repo             ]         ))         #expect(try !MCPTestHelpers.isError(response))-        let result = try MCPTestHelpers.decodeResult(response)+        let result = try MCPTestHelpers.decodeSavedRecord(response)         let projectId = try #require(result["projectId"] as? String)         #expect(UUID(uuidString: projectId) != nil)         #expect(result["name"] as? String == "New Project")         #expect(result["description"] as? String == description)         #expect(result["gitRepo"] as? String == repo)         #expect(result["colorHex"] as? String == "#aB12ef")-        #expect(result["activeTaskCount"] as? Int == 0)         let persisted = try #require(env.context.fetch(FetchDescriptor<Project>()).first)+        #expect(env.projectService.activeTaskCount(for: persisted) == 0)         #expect(persisted.id.uuidString == projectId)         #expect(persisted.projectDescription == description)         let listed = await env.handler.handle(MCPTestHelpers.toolCallRequest(tool: "get_projects", arguments: [:]))         let projects = try MCPTestHelpers.decodeArrayResult(listed)         #expect(projects.count == 1)-        #expect(NSDictionary(dictionary: try #require(projects.first)) == NSDictionary(dictionary: result))-        let taskResponse = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task", arguments: ["name": "First task", "type": "feature", "projectId": projectId]+        let listedProject = try #require(projects.first)+        #expect(listedProject["activeTaskCount"] as? Int == 0)+        let savedFields = listedProject.filter { result[$0.key] != nil }+        #expect(NSDictionary(dictionary: savedFields) == NSDictionary(dictionary: result))+        let taskResponse = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",+            arguments: ["name": "First task", "type": "feature", "projectId": projectId]         ))         #expect(try !MCPTestHelpers.isError(taskResponse))         let task = try #require(env.context.fetch(FetchDescriptor<TransitTask>()).first)@@ -65,17 +69,17 @@ struct MCPCreateProjectTests {      @Test func optionalFieldsCanBeOmittedOrEmpty() async throws {         let env = try MCPTestHelpers.makeEnv()-        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_project", arguments: ["name": "Minimal", "colorHex": "000000"]+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_project", arguments: ["name": "Minimal", "colorHex": "000000"]         ))-        let result = try MCPTestHelpers.decodeResult(response)+        let result = try MCPTestHelpers.decodeSavedRecord(response)         #expect(result["description"] as? String == "")         #expect(result["gitRepo"] == nil)-        let empty = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_project",+        let empty = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_project",             arguments: ["name": "Empty", "colorHex": "#FFFFFF", "description": "", "gitRepo": ""]         ))-        #expect(try MCPTestHelpers.decodeResult(empty)["gitRepo"] as? String == "")+        #expect(try MCPTestHelpers.decodeSavedRecord(empty)["gitRepo"] as? String == "")     }      @Test func rejectsMissingAndMalformedFieldsWithoutInsertion() async throws {@@ -86,7 +90,8 @@ struct MCPCreateProjectTests {                 var args: [String: Any] = ["name": "New", "colorHex": "#123ABC"]                 args[key] = value                 let response = await env.handler.handle(-                    MCPTestHelpers.toolCallRequest(tool: "create_project", arguments: args)+                    try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_project", arguments: args)                 )                 #expect(try MCPTestHelpers.isError(response))                 #expect(try MCPTestHelpers.errorText(response) == "\(key) must be a string")@@ -98,7 +103,8 @@ struct MCPCreateProjectTests {             var args: [String: Any] = ["name": "New", "colorHex": "#123ABC"]             args.removeValue(forKey: key)             let response = await env.handler.handle(-                MCPTestHelpers.toolCallRequest(tool: "create_project", arguments: args)+                try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_project", arguments: args)             )             #expect(try MCPTestHelpers.errorText(response) == "Missing required argument: \(key)")             #expect(try env.context.fetch(FetchDescriptor<Project>()).isEmpty)@@ -108,8 +114,8 @@ struct MCPCreateProjectTests {     @Test(arguments: ["", " \n\t", "#ABC", "#12345G", "#12345678", "#123456\n", "#123456\r\n", "#123456", " #123456"])     func rejectsInvalidColors(color: String) async throws {         let env = try MCPTestHelpers.makeEnv()-        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_project", arguments: ["name": "New", "colorHex": color]+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_project", arguments: ["name": "New", "colorHex": color]         ))         #expect(try MCPTestHelpers.isError(response))         #expect(try env.context.fetch(FetchDescriptor<Project>()).isEmpty)@@ -118,8 +124,8 @@ struct MCPCreateProjectTests {     @Test(arguments: ["", " \n\t"])     func rejectsBlankNames(name: String) async throws {         let env = try MCPTestHelpers.makeEnv()-        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_project", arguments: ["name": name, "colorHex": "#123456"]+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_project", arguments: ["name": name, "colorHex": "#123456"]         ))         #expect(try MCPTestHelpers.isError(response))         #expect(try env.context.fetch(FetchDescriptor<Project>()).isEmpty)@@ -130,8 +136,8 @@ struct MCPCreateProjectTests {         let existing = try env.projectService.createProject(             name: "Existing", description: "Original", gitRepo: nil, colorHex: "#123456"         )-        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_project", arguments: ["name": "  eXISTING\n", "colorHex": "#ABCDEF"]+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_project", arguments: ["name": "  eXISTING\n", "colorHex": "#ABCDEF"]         ))         #expect(try MCPTestHelpers.isError(response))         #expect(try MCPTestHelpers.errorText(response).contains("already exists"))@@ -143,11 +149,11 @@ struct MCPCreateProjectTests {      @Test func failedUniquenessReadDoesNotCreateProject() async throws {         let env = try MCPTestHelpers.makeEnv(projectFetcher: FailingFetcher())-        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_project", arguments: ["name": "New", "colorHex": "#ABCDEF"]+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_project", arguments: ["name": "New", "colorHex": "#ABCDEF"]         ))         #expect(try MCPTestHelpers.isError(response))-        #expect(try MCPTestHelpers.errorText(response).contains("Failed to create project"))+        #expect(try MCPTestHelpers.errorCode(response) == "INTERNAL_ERROR")         #expect(try env.context.fetch(FetchDescriptor<Project>()).isEmpty)     } }
Transit/TransitTests/MCPCreateTaskAtomicityTests.swift Modified +2 / -2
diff --git a/Transit/TransitTests/MCPCreateTaskAtomicityTests.swift b/Transit/TransitTests/MCPCreateTaskAtomicityTests.swiftindex 92f240f..4d80df3 100644--- a/Transit/TransitTests/MCPCreateTaskAtomicityTests.swift+++ b/Transit/TransitTests/MCPCreateTaskAtomicityTests.swift@@ -21,8 +21,8 @@ struct MCPCreateTaskAtomicityTests {         )         expectedMilestoneID = milestone.id -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: [                 "name": "Atomic Task",                 "type": "bug",
Transit/TransitTests/MCPCreateTaskMetadataTests.swift Modified +9 / -9
diff --git a/Transit/TransitTests/MCPCreateTaskMetadataTests.swift b/Transit/TransitTests/MCPCreateTaskMetadataTests.swiftindex 8e250b5..a0b0ef6 100644--- a/Transit/TransitTests/MCPCreateTaskMetadataTests.swift+++ b/Transit/TransitTests/MCPCreateTaskMetadataTests.swift@@ -13,8 +13,8 @@ struct MCPCreateTaskMetadataTests {         let env = try MCPTestHelpers.makeEnv()         let project = MCPTestHelpers.makeProject(in: env.context) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: [                 "name": "Meta Task",                 "type": "feature",@@ -23,7 +23,7 @@ struct MCPCreateTaskMetadataTests {             ]         )) -        let result = try MCPTestHelpers.decodeResult(response)+        let result = try MCPTestHelpers.decodeSavedRecord(response)         let taskIdStr = try #require(result["taskId"] as? String)         let taskId = try #require(UUID(uuidString: taskIdStr))         let task = try env.taskService.findByID(taskId)@@ -35,8 +35,8 @@ struct MCPCreateTaskMetadataTests {         let env = try MCPTestHelpers.makeEnv()         let project = MCPTestHelpers.makeProject(in: env.context) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: [                 "name": "Meta Task",                 "type": "feature",@@ -45,7 +45,7 @@ struct MCPCreateTaskMetadataTests {             ]         )) -        let result = try MCPTestHelpers.decodeResult(response)+        let result = try MCPTestHelpers.decodeSavedRecord(response)         let taskIdStr = try #require(result["taskId"] as? String)         let taskId = try #require(UUID(uuidString: taskIdStr))         let task = try env.taskService.findByID(taskId)@@ -56,8 +56,8 @@ struct MCPCreateTaskMetadataTests {         let env = try MCPTestHelpers.makeEnv()         let project = MCPTestHelpers.makeProject(in: env.context) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: [                 "name": "Meta Task",                 "type": "feature",@@ -66,7 +66,7 @@ struct MCPCreateTaskMetadataTests {             ]         )) -        let result = try MCPTestHelpers.decodeResult(response)+        let result = try MCPTestHelpers.decodeSavedRecord(response)         let taskIdStr = try #require(result["taskId"] as? String)         let taskId = try #require(UUID(uuidString: taskIdStr))         let task = try env.taskService.findByID(taskId)
Transit/TransitTests/MCPCreateTaskTerminalMilestoneTests.swift Modified +2 / -2
diff --git a/Transit/TransitTests/MCPCreateTaskTerminalMilestoneTests.swift b/Transit/TransitTests/MCPCreateTaskTerminalMilestoneTests.swiftindex 88b6365..0242047 100644--- a/Transit/TransitTests/MCPCreateTaskTerminalMilestoneTests.swift+++ b/Transit/TransitTests/MCPCreateTaskTerminalMilestoneTests.swift@@ -20,8 +20,8 @@ struct MCPCreateTaskTerminalMilestoneTests {         )         try env.milestoneService.updateStatus(milestone, to: terminalStatus) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: [                 "name": "Terminal Milestone Task",                 "type": "feature",
Transit/TransitTests/MCPDuplicateTaskDisplayIDTests.swift Modified +14 / -11
diff --git a/Transit/TransitTests/MCPDuplicateTaskDisplayIDTests.swift b/Transit/TransitTests/MCPDuplicateTaskDisplayIDTests.swiftindex de49ca1..48d01f5 100644--- a/Transit/TransitTests/MCPDuplicateTaskDisplayIDTests.swift+++ b/Transit/TransitTests/MCPDuplicateTaskDisplayIDTests.swift@@ -46,12 +46,13 @@ struct MCPDuplicateTaskDisplayIDTests {         let env = try MCPTestHelpers.makeEnv()         let (first, second) = makeDuplicatePair(in: env.context, displayId: 42) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task_status",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task_status",             arguments: ["displayId": 42, "status": "in-progress"]         )) -        try expectDuplicateError(response, displayId: 42)+        #expect(try MCPTestHelpers.isError(response))+        #expect(try MCPTestHelpers.errorCode(response) == "DUPLICATE_TASK_IDENTIFIER")         #expect(first.statusRawValue == "idea")         #expect(second.statusRawValue == "idea")     }@@ -59,8 +60,8 @@ struct MCPDuplicateTaskDisplayIDTests {     @Test func updateStatusStillReportsMissingTaskGenerically() async throws {         let env = try MCPTestHelpers.makeEnv() -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task_status",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task_status",             arguments: ["displayId": 999, "status": "in-progress"]         )) @@ -75,12 +76,13 @@ struct MCPDuplicateTaskDisplayIDTests {         let env = try MCPTestHelpers.makeEnv()         let (first, second) = makeDuplicatePair(in: env.context, displayId: 42) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: ["displayId": 42, "name": "Renamed"]         )) -        try expectDuplicateError(response, displayId: 42)+        #expect(try MCPTestHelpers.isError(response))+        #expect(try MCPTestHelpers.errorCode(response) == "DUPLICATE_TASK_IDENTIFIER")         #expect(first.name == "First")         #expect(second.name == "Second")     }@@ -91,12 +93,13 @@ struct MCPDuplicateTaskDisplayIDTests {         let env = try MCPTestHelpers.makeEnv()         let (first, second) = makeDuplicatePair(in: env.context, displayId: 42) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "add_comment",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "add_comment",             arguments: ["displayId": 42, "content": "Hello", "authorName": "TestBot"]         )) -        try expectDuplicateError(response, displayId: 42)+        #expect(try MCPTestHelpers.isError(response))+        #expect(try MCPTestHelpers.errorCode(response) == "DUPLICATE_TASK_IDENTIFIER")         #expect(try env.commentService.fetchComments(for: first.id).isEmpty)         #expect(try env.commentService.fetchComments(for: second.id).isEmpty)     }
Transit/TransitTests/MCPFallbackStorageRejectionTests.swift Modified +10 / -31
diff --git a/Transit/TransitTests/MCPFallbackStorageRejectionTests.swift b/Transit/TransitTests/MCPFallbackStorageRejectionTests.swiftindex c77e1b5..6595373 100644--- a/Transit/TransitTests/MCPFallbackStorageRejectionTests.swift+++ b/Transit/TransitTests/MCPFallbackStorageRejectionTests.swift@@ -29,30 +29,9 @@ struct MCPFallbackStorageRejectionTests {             ? FallbackOutcomeFixture.degraded             : FallbackOutcomeFixture.makeHealthy() -        let testContainer = try TestModelContainer()--        let context = testContainer.context-        let taskAllocator = DisplayIDAllocator(store: InMemoryCounterStore())-        let milestoneAllocator = DisplayIDAllocator(store: InMemoryCounterStore())-        let commentService = CommentService(modelContext: context)-        let settings = MCPSettings()-        settings.maintenanceToolsEnabled = true--        let handler = MCPToolHandler(-            taskService: TaskService(modelContext: context, displayIDAllocator: taskAllocator),-            projectService: ProjectService(modelContext: context),-            commentService: commentService,-            milestoneService: MilestoneService(modelContext: context, displayIDAllocator: milestoneAllocator),-            maintenanceService: DisplayIDMaintenanceService(-                modelContext: context,-                taskAllocator: taskAllocator,-                milestoneAllocator: milestoneAllocator,-                commentService: commentService-            ),-            settings: settings,-            persistence: persistence-        )-        return Env(handler: handler, context: context, persistence: persistence)+        let env = try MCPTestHelpers.makeEnv(persistence: persistence)+        env.mcpSettings.maintenanceToolsEnabled = true+        return Env(handler: env.handler, context: env.context, persistence: persistence)     }      @discardableResult@@ -93,7 +72,7 @@ struct MCPFallbackStorageRejectionTests {             seedProjectAndTask(in: env.context)              let response = await env.handler.handle(-                MCPTestHelpers.toolCallRequest(tool: call.tool, arguments: call.args)+                try MCPTestHelpers.protectedToolCallRequest(in: env.context, tool: call.tool, arguments: call.args)             )              #expect(try MCPTestHelpers.isError(response), "\(call.tool) should be rejected")@@ -110,8 +89,8 @@ struct MCPFallbackStorageRejectionTests {         let project = Project(name: "Fallback Project", description: "", gitRepo: nil, colorHex: "#FF0000")         env.context.insert(project) -        _ = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        _ = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: ["name": "Doomed", "type": "bug", "project": "Fallback Project"]         )) @@ -123,8 +102,8 @@ struct MCPFallbackStorageRejectionTests {         let env = try makeEnv()         let (_, task) = seedProjectAndTask(in: env.context) -        _ = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task_status", arguments: ["displayId": 1, "status": "done"]+        _ = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task_status", arguments: ["displayId": 1, "status": "done"]         ))          #expect(task.statusRawValue == TaskStatus.idea.rawValue)@@ -168,8 +147,8 @@ struct MCPFallbackStorageRejectionTests {         let project = Project(name: "Fallback Project", description: "", gitRepo: nil, colorHex: "#FF0000")         env.context.insert(project) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: ["name": "Fine", "type": "bug", "project": "Fallback Project"]         )) 
Transit/TransitTests/MCPHTTPTestHelpers.swift Modified +8 / -0
diff --git a/Transit/TransitTests/MCPHTTPTestHelpers.swift b/Transit/TransitTests/MCPHTTPTestHelpers.swiftindex 0d71292..5b19bdb 100644--- a/Transit/TransitTests/MCPHTTPTestHelpers.swift+++ b/Transit/TransitTests/MCPHTTPTestHelpers.swift@@ -7,10 +7,18 @@ import NIOConcurrencyHelpers import NIOCore import NIOEmbedded import NIOFoundationCompat+import Testing @testable import Transit  @MainActor extension MCPTestHelpers {+    static func decodeHTTPToolResult(_ object: [String: Any]) throws -> [String: Any] {+        let result = try #require(object["result"] as? [String: Any])+        let content = try #require(result["content"] as? [[String: Any]])+        let text = try #require(content.first?["text"] as? String)+        let bytes = try #require(text.data(using: .utf8))+        return try #require(try JSONSerialization.jsonObject(with: bytes) as? [String: Any])+    }      static func respond(         handler: MCPToolHandler,
Transit/TransitTests/MCPLocalReservationStoreTests.swift Added +78 / -0
diff --git a/Transit/TransitTests/MCPLocalReservationStoreTests.swift b/Transit/TransitTests/MCPLocalReservationStoreTests.swiftnew file mode 100644index 0000000..bbf0a3d--- /dev/null+++ b/Transit/TransitTests/MCPLocalReservationStoreTests.swift@@ -0,0 +1,78 @@+import Foundation+import SwiftData+import Testing+@testable import Transit++@MainActor @Suite(.serialized)+struct MCPLocalReservationStoreTests {+    @Test func bindingSurvivesRestartAndUnresolvedNeverExpires() throws {+        let directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)+        defer { try? FileManager.default.removeItem(at: directory) }+        var store: MCPLocalReservationStore? = try MCPLocalReservationStore(directory: directory)+        let scope = store!.scopeID+        let guardRecord = try store!.reserve(tool: "create_task", key: "key", requestJSON: "{}")+        store = nil+        let reopened = try MCPLocalReservationStore(directory: directory)+        #expect(reopened.scopeID == scope)+        #expect(try reopened.lookup(tool: "create_task", key: "key") == guardRecord)+        #expect(throws: MCPLocalReservationStore.Error.keyReused) {+            try reopened.reserve(tool: "create_task", key: "key", requestJSON: "{\"x\":1}")+        }+        try reopened.removeExpired(now: Date.distantFuture)+        #expect(try reopened.lookup(tool: "create_task", key: "key") != nil)+    }++    @Test func unreadableGuardsFailClosed() throws {+        let directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)+        defer { try? FileManager.default.removeItem(at: directory) }+        var store: MCPLocalReservationStore? = try MCPLocalReservationStore(directory: directory)+        _ = try store!.reserve(tool: "create_task", key: "key", requestJSON: "{}")+        store = nil+        let files = try FileManager.default.contentsOfDirectory(at: directory.appendingPathComponent("guards"),+                                                               includingPropertiesForKeys: nil)+        try Data("corrupted".utf8).write(to: files[0])+        #expect(throws: (any Error).self) { try MCPLocalReservationStore(directory: directory) }+    }++    @Test func terminalExpiryIsFixedAndRepairUsesOriginalDeadline() throws {+        let directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)+        defer { try? FileManager.default.removeItem(at: directory) }+        let store = try MCPLocalReservationStore(directory: directory)+        let guardRecord = try store.reserve(tool: "create_task", key: "key", requestJSON: "{}")+        let expiry = Date(timeIntervalSinceReferenceDate: 604800)+        try store.recordExpiry(guardRecord, expiresAt: expiry)+        try store.recordExpiry(guardRecord, expiresAt: expiry)+        #expect(throws: (any Error).self) {+            try store.recordExpiry(guardRecord, expiresAt: expiry.addingTimeInterval(1))+        }+        try store.removeExpired(now: expiry.addingTimeInterval(-1))+        #expect(try store.lookup(tool: "create_task", key: "key") != nil)+        try store.removeExpired(now: expiry)+        #expect(try store.lookup(tool: "create_task", key: "key") == nil)+    }++    @Test func receiptScopeDuplicateAndUnresolvedCleanup() throws {+        let owner = try TestModelContainer()+        let directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)+        defer { try? FileManager.default.removeItem(at: directory) }+        let guards = try MCPLocalReservationStore(directory: directory)+        let store = MCPWriteReceiptStore(context: owner.context, scopeID: guards.scopeID)+        let binding = try guards.reserve(tool: "create_task", key: "key", requestJSON: "{}")+        let receipt = try store.insert(binding, acceptedAt: Date(timeIntervalSinceReferenceDate: 0))+        owner.context.insert(MCPWriteReceipt(localScopeID: "another-device", tool: "create_task", key: "key",+                                             requestJSON: "{}", acceptedAt: Date()))+        try owner.context.save()+        #expect(try store.lookup(tool: "create_task", key: "key", durable: true)?.id == receipt.id)+        try store.cleanup(now: Date.distantFuture, reservations: guards)+        #expect(try guards.lookup(tool: "create_task", key: "key") != nil)+        owner.context.delete(receipt)+        try owner.context.save()+        #expect(try store.lookup(tool: "create_task", key: "key", durable: true) == nil)+        #expect(try guards.lookup(tool: "create_task", key: "key") != nil,+                "Missing receipt must preserve the unresolved payload binding")+        _ = try store.insert(binding, acceptedAt: Date())+        owner.context.insert(MCPWriteReceipt(localScopeID: guards.scopeID, tool: "create_task", key: "key",+                                             requestJSON: "{}", acceptedAt: Date()))+        #expect(throws: (any Error).self) { try store.lookup(tool: "create_task", key: "key") }+    }+}
Transit/TransitTests/MCPMilestoneClearDescriptionTests.swift Modified +12 / -12
diff --git a/Transit/TransitTests/MCPMilestoneClearDescriptionTests.swift b/Transit/TransitTests/MCPMilestoneClearDescriptionTests.swiftindex 703092a..4230e74 100644--- a/Transit/TransitTests/MCPMilestoneClearDescriptionTests.swift+++ b/Transit/TransitTests/MCPMilestoneClearDescriptionTests.swift@@ -18,12 +18,12 @@ struct MCPMilestoneClearDescriptionTests {             name: "v1.0", description: "old", project: project         ) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_milestone",             arguments: ["milestoneId": milestone.id.uuidString, "description": "  text  "]         )) -        let result = try MCPTestHelpers.decodeResult(response)+        let result = try MCPTestHelpers.decodeSavedRecord(response)         #expect(result["description"] as? String == "text")         let refreshed = try env.milestoneService.findByID(milestone.id)         #expect(refreshed.milestoneDescription == "text")@@ -36,12 +36,12 @@ struct MCPMilestoneClearDescriptionTests {             name: "v1.0", description: "current", project: project         ) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_milestone",             arguments: ["milestoneId": milestone.id.uuidString, "description": ""]         )) -        let result = try MCPTestHelpers.decodeResult(response)+        let result = try MCPTestHelpers.decodeSavedRecord(response)         #expect(result["description"] == nil, "Response should omit description when cleared")         let refreshed = try env.milestoneService.findByID(milestone.id)         #expect(refreshed.milestoneDescription == nil)@@ -54,12 +54,12 @@ struct MCPMilestoneClearDescriptionTests {             name: "v1.0", description: "current", project: project         ) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_milestone",             arguments: ["milestoneId": milestone.id.uuidString, "description": "   "]         )) -        let result = try MCPTestHelpers.decodeResult(response)+        let result = try MCPTestHelpers.decodeSavedRecord(response)         #expect(result["description"] == nil, "Response should omit description when cleared")         let refreshed = try env.milestoneService.findByID(milestone.id)         #expect(refreshed.milestoneDescription == nil)@@ -73,8 +73,8 @@ struct MCPMilestoneClearDescriptionTests {             name: "v1.0", description: "current", project: project         ) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_milestone",             arguments: [                 "milestoneId": milestone.id.uuidString,                 "description": "",@@ -82,7 +82,7 @@ struct MCPMilestoneClearDescriptionTests {             ]         )) -        let result = try MCPTestHelpers.decodeResult(response)+        let result = try MCPTestHelpers.decodeSavedRecord(response)         #expect(result["description"] == nil, "Response should omit description when cleared")         #expect(result["status"] as? String == "done")         let refreshed = try env.milestoneService.findByID(milestone.id)
Transit/TransitTests/MCPMilestoneDeleteTests.swift Modified +7 / -6
diff --git a/Transit/TransitTests/MCPMilestoneDeleteTests.swift b/Transit/TransitTests/MCPMilestoneDeleteTests.swiftindex 4dd0ff0..5a43376 100644--- a/Transit/TransitTests/MCPMilestoneDeleteTests.swift+++ b/Transit/TransitTests/MCPMilestoneDeleteTests.swift@@ -20,22 +20,23 @@ struct MCPMilestoneDeleteTests {         )         try env.milestoneService.setMilestone(milestone, on: task) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "delete_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "delete_milestone",             arguments: ["displayId": 1]         ))          let result = try MCPTestHelpers.decodeResult(response)         #expect(result["deleted"] as? Bool == true)-        #expect(result["name"] as? String == "v1.0")-        #expect(result["affectedTasks"] as? Int == 1)+        #expect((result["recordBeforeDeletion"] as? [String: Any])?["name"] as? String == "v1.0")+        #expect(task.milestone == nil)+        #expect(try env.context.fetch(FetchDescriptor<Milestone>()).isEmpty)     }      @Test func deleteMilestoneNotFoundReturnsError() async throws {         let env = try MCPTestHelpers.makeEnv() -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "delete_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "delete_milestone",             arguments: ["displayId": 999]         )) 
Transit/TransitTests/MCPMilestoneIntegrationTests.swift Modified +27 / -27
diff --git a/Transit/TransitTests/MCPMilestoneIntegrationTests.swift b/Transit/TransitTests/MCPMilestoneIntegrationTests.swiftindex 8c723d6..c0c5351 100644--- a/Transit/TransitTests/MCPMilestoneIntegrationTests.swift+++ b/Transit/TransitTests/MCPMilestoneIntegrationTests.swift@@ -22,15 +22,15 @@ struct MCPMilestoneIntegrationTests {             name: "Task A", description: nil, type: .feature, project: project         ) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: [                 "displayId": 1,                 "milestoneDisplayId": milestone.permanentDisplayId!             ]         )) -        let result = try MCPTestHelpers.decodeResult(response)+        let result = try MCPTestHelpers.decodeSavedRecord(response)         let milestoneInfo = try #require(result["milestone"] as? [String: Any])         #expect(milestoneInfo["name"] as? String == "v1.0")     }@@ -43,12 +43,12 @@ struct MCPMilestoneIntegrationTests {             name: "Task A", description: nil, type: .feature, project: project         ) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: ["displayId": 1, "milestone": "v1.0"]         )) -        let result = try MCPTestHelpers.decodeResult(response)+        let result = try MCPTestHelpers.decodeSavedRecord(response)         let milestoneInfo = try #require(result["milestone"] as? [String: Any])         #expect(milestoneInfo["name"] as? String == "v1.0")     }@@ -64,12 +64,12 @@ struct MCPMilestoneIntegrationTests {         )         try env.milestoneService.setMilestone(milestone, on: task) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: ["displayId": 1, "clearMilestone": true]         )) -        let result = try MCPTestHelpers.decodeResult(response)+        let result = try MCPTestHelpers.decodeSavedRecord(response)         #expect(result["milestone"] == nil)     } @@ -84,8 +84,8 @@ struct MCPMilestoneIntegrationTests {             name: "Task A", description: nil, type: .feature, project: projectA         ) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: [                 "displayId": 1,                 "milestoneDisplayId": milestone.permanentDisplayId!@@ -102,8 +102,8 @@ struct MCPMilestoneIntegrationTests {             name: "Task A", description: nil, type: .feature, project: project         ) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: ["displayId": 1, "milestoneDisplayId": 999]         )) @@ -117,8 +117,8 @@ struct MCPMilestoneIntegrationTests {         let project = MCPTestHelpers.makeProject(in: env.context)         _ = try await env.milestoneService.createMilestone(name: "v1.0", description: nil, project: project) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: [                 "name": "New Task",                 "type": "feature",@@ -127,7 +127,7 @@ struct MCPMilestoneIntegrationTests {             ]         )) -        let result = try MCPTestHelpers.decodeResult(response)+        let result = try MCPTestHelpers.decodeSavedRecord(response)         let milestoneInfo = try #require(result["milestone"] as? [String: Any])         #expect(milestoneInfo["name"] as? String == "v1.0")     }@@ -139,8 +139,8 @@ struct MCPMilestoneIntegrationTests {             name: "v1.0", description: nil, project: project         ) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: [                 "name": "New Task",                 "type": "feature",@@ -149,7 +149,7 @@ struct MCPMilestoneIntegrationTests {             ]         )) -        let result = try MCPTestHelpers.decodeResult(response)+        let result = try MCPTestHelpers.decodeSavedRecord(response)         let milestoneInfo = try #require(result["milestone"] as? [String: Any])         #expect(milestoneInfo["name"] as? String == "v1.0")     }@@ -158,8 +158,8 @@ struct MCPMilestoneIntegrationTests {         let env = try MCPTestHelpers.makeEnv()         let project = MCPTestHelpers.makeProject(in: env.context) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: [                 "name": "New Task",                 "type": "feature",@@ -177,8 +177,8 @@ struct MCPMilestoneIntegrationTests {         let env = try MCPTestHelpers.makeEnv()         let project = MCPTestHelpers.makeProject(in: env.context) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: [                 "name": "Orphan Candidate",                 "type": "bug",@@ -198,8 +198,8 @@ struct MCPMilestoneIntegrationTests {         let env = try MCPTestHelpers.makeEnv()         let project = MCPTestHelpers.makeProject(in: env.context) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: [                 "name": "Orphan Candidate",                 "type": "bug",@@ -223,8 +223,8 @@ struct MCPMilestoneIntegrationTests {             name: "v1.0", description: nil, project: projectB         ) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: [                 "name": "Orphan Candidate",                 "type": "feature",
Transit/TransitTests/MCPMilestoneRenameValidationTests.swift Modified +12 / -12
diff --git a/Transit/TransitTests/MCPMilestoneRenameValidationTests.swift b/Transit/TransitTests/MCPMilestoneRenameValidationTests.swiftindex 95bdad5..4361808 100644--- a/Transit/TransitTests/MCPMilestoneRenameValidationTests.swift+++ b/Transit/TransitTests/MCPMilestoneRenameValidationTests.swift@@ -17,8 +17,8 @@ struct MCPMilestoneRenameValidationTests {             name: "v1.0", description: nil, project: project         ) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_milestone",             arguments: [                 "milestoneId": milestone.id.uuidString,                 "name": 123,@@ -43,8 +43,8 @@ struct MCPMilestoneRenameValidationTests {             name: "v1.0", description: nil, project: project         ) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_milestone",             arguments: [                 "milestoneId": milestone.id.uuidString,                 "name": false@@ -63,8 +63,8 @@ struct MCPMilestoneRenameValidationTests {             name: "v1.0", description: nil, project: project         ) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_milestone",             arguments: [                 "milestoneId": milestone.id.uuidString,                 "name": NSNull(),@@ -89,8 +89,8 @@ struct MCPMilestoneRenameValidationTests {             name: "v1.0", description: nil, project: project         ) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_milestone",             arguments: [                 "milestoneId": milestone.id.uuidString,                 "name": ["v2.0"]@@ -111,8 +111,8 @@ struct MCPMilestoneRenameValidationTests {             name: "v1.0", description: nil, project: project         ) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_milestone",             arguments: [                 "milestoneId": milestone.id.uuidString,                 "description": 42,@@ -139,8 +139,8 @@ struct MCPMilestoneRenameValidationTests {             name: "v1.0", description: nil, project: project         ) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_milestone",             arguments: [                 "milestoneId": milestone.id.uuidString,                 "description": NSNull(),
Transit/TransitTests/MCPMilestoneSameStatusTests.swift Modified +9 / -9
diff --git a/Transit/TransitTests/MCPMilestoneSameStatusTests.swift b/Transit/TransitTests/MCPMilestoneSameStatusTests.swiftindex ee1b1e3..ac949ae 100644--- a/Transit/TransitTests/MCPMilestoneSameStatusTests.swift+++ b/Transit/TransitTests/MCPMilestoneSameStatusTests.swift@@ -20,12 +20,12 @@ struct MCPMilestoneSameStatusTests {         let originalLastStatusChangeDate = milestone.lastStatusChangeDate         let displayId = try #require(milestone.permanentDisplayId) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_milestone",             arguments: ["displayId": displayId, "status": "done"]         )) -        _ = try MCPTestHelpers.decodeResult(response)+        _ = try MCPTestHelpers.decodeSavedRecord(response)         let refetched = try env.milestoneService.findByDisplayID(displayId)         #expect(refetched.completionDate == originalCompletionDate)         #expect(refetched.lastStatusChangeDate == originalLastStatusChangeDate)@@ -40,12 +40,12 @@ struct MCPMilestoneSameStatusTests {         let originalLastStatusChangeDate = milestone.lastStatusChangeDate         let displayId = try #require(milestone.permanentDisplayId) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_milestone",             arguments: ["displayId": displayId, "status": "done", "description": "Now with notes"]         )) -        _ = try MCPTestHelpers.decodeResult(response)+        _ = try MCPTestHelpers.decodeSavedRecord(response)         let refetched = try env.milestoneService.findByDisplayID(displayId)         #expect(refetched.milestoneDescription == "Now with notes")         #expect(refetched.completionDate == originalCompletionDate)@@ -60,12 +60,12 @@ struct MCPMilestoneSameStatusTests {         let originalLastStatusChangeDate = milestone.lastStatusChangeDate         let displayId = try #require(milestone.permanentDisplayId) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_milestone",             arguments: ["displayId": displayId, "status": "open"]         )) -        _ = try MCPTestHelpers.decodeResult(response)+        _ = try MCPTestHelpers.decodeSavedRecord(response)         let refetched = try env.milestoneService.findByDisplayID(displayId)         #expect(refetched.lastStatusChangeDate == originalLastStatusChangeDate)         #expect(refetched.completionDate == nil)
Transit/TransitTests/MCPMilestoneStatusValidationTests.swift Modified +4 / -4
diff --git a/Transit/TransitTests/MCPMilestoneStatusValidationTests.swift b/Transit/TransitTests/MCPMilestoneStatusValidationTests.swiftindex 941bce6..7196da2 100644--- a/Transit/TransitTests/MCPMilestoneStatusValidationTests.swift+++ b/Transit/TransitTests/MCPMilestoneStatusValidationTests.swift@@ -35,8 +35,8 @@ struct MCPMilestoneStatusValidationTests {             name: "v1.0", description: nil, project: project         ) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_milestone",             arguments: [                 "milestoneId": milestone.id.uuidString,                 "status": 123,@@ -61,8 +61,8 @@ struct MCPMilestoneStatusValidationTests {             name: "v1.0", description: nil, project: project         ) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_milestone",             arguments: [                 "milestoneId": milestone.id.uuidString,                 "status": false
Transit/TransitTests/MCPMilestoneToolTests.swift Modified +32 / -31
diff --git a/Transit/TransitTests/MCPMilestoneToolTests.swift b/Transit/TransitTests/MCPMilestoneToolTests.swiftindex 1782659..85cff8e 100644--- a/Transit/TransitTests/MCPMilestoneToolTests.swift+++ b/Transit/TransitTests/MCPMilestoneToolTests.swift@@ -35,8 +35,8 @@ struct MCPMilestoneToolTests {         let env = try MCPTestHelpers.makeEnv()         let project = MCPTestHelpers.makeProject(in: env.context) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_milestone",             arguments: [                 "name": "v1.0",                 "projectId": project.id.uuidString,@@ -44,7 +44,7 @@ struct MCPMilestoneToolTests {             ]         )) -        let result = try MCPTestHelpers.decodeResult(response)+        let result = try MCPTestHelpers.decodeSavedRecord(response)         #expect(result["name"] as? String == "v1.0")         #expect(result["status"] as? String == "open")         #expect(result["displayId"] as? Int == 1)@@ -56,12 +56,12 @@ struct MCPMilestoneToolTests {         let env = try MCPTestHelpers.makeEnv()         MCPTestHelpers.makeProject(in: env.context, name: "Alpha") -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_milestone",             arguments: ["name": "v1.0", "project": "Alpha"]         )) -        let result = try MCPTestHelpers.decodeResult(response)+        let result = try MCPTestHelpers.decodeSavedRecord(response)         #expect(result["name"] as? String == "v1.0")         #expect(result["projectName"] as? String == "Alpha")     }@@ -69,8 +69,8 @@ struct MCPMilestoneToolTests {     @Test func createMilestoneMissingNameReturnsError() async throws {         let env = try MCPTestHelpers.makeEnv() -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_milestone",             arguments: ["project": "Test"]         )) @@ -80,8 +80,8 @@ struct MCPMilestoneToolTests {     @Test func createMilestoneMissingProjectReturnsError() async throws {         let env = try MCPTestHelpers.makeEnv() -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_milestone",             arguments: ["name": "v1.0"]         )) @@ -93,8 +93,8 @@ struct MCPMilestoneToolTests {         let project = MCPTestHelpers.makeProject(in: env.context)         _ = try await env.milestoneService.createMilestone(name: "v1.0", description: nil, project: project) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_milestone",             arguments: ["name": "v1.0", "projectId": project.id.uuidString]         )) @@ -107,8 +107,8 @@ struct MCPMilestoneToolTests {         let env = try MCPTestHelpers.makeEnv()         MCPTestHelpers.makeProject(in: env.context, name: "Decoy") -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_milestone",             arguments: ["name": "v1.0", "projectId": "not-a-uuid", "project": "Decoy"]         )) @@ -122,8 +122,8 @@ struct MCPMilestoneToolTests {         let env = try MCPTestHelpers.makeEnv()         MCPTestHelpers.makeProject(in: env.context, name: "Decoy") -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_milestone",             arguments: ["name": "v1.0", "projectId": 456, "project": "Decoy"]         )) @@ -135,8 +135,8 @@ struct MCPMilestoneToolTests {     @Test func createMilestoneNumericProjectIdWithoutFallbackReturnsError() async throws {         let env = try MCPTestHelpers.makeEnv() -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_milestone",             arguments: ["name": "v1.0", "projectId": 456]         )) @@ -503,14 +503,15 @@ struct MCPMilestoneToolTests {         let project = MCPTestHelpers.makeProject(in: env.context)         _ = try await env.milestoneService.createMilestone(name: "v1.0", description: nil, project: project) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_milestone",+        #expect(try env.context.fetch(FetchDescriptor<Milestone>()).first?.statusRawValue == "open")++        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_milestone",             arguments: ["displayId": 1, "status": "done"]         )) -        let result = try MCPTestHelpers.decodeResult(response)+        let result = try MCPTestHelpers.decodeSavedRecord(response)         #expect(result["status"] as? String == "done")-        #expect(result["previousStatus"] as? String == "open")     }      @Test func updateMilestoneName() async throws {@@ -518,20 +519,20 @@ struct MCPMilestoneToolTests {         let project = MCPTestHelpers.makeProject(in: env.context)         _ = try await env.milestoneService.createMilestone(name: "v1.0", description: nil, project: project) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_milestone",             arguments: ["displayId": 1, "name": "v1.1"]         )) -        let result = try MCPTestHelpers.decodeResult(response)+        let result = try MCPTestHelpers.decodeSavedRecord(response)         #expect(result["name"] as? String == "v1.1")     }      @Test func updateMilestoneNotFoundReturnsError() async throws {         let env = try MCPTestHelpers.makeEnv() -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_milestone",             arguments: ["displayId": 999, "name": "v2.0"]         )) @@ -543,8 +544,8 @@ struct MCPMilestoneToolTests {         let project = MCPTestHelpers.makeProject(in: env.context)         _ = try await env.milestoneService.createMilestone(name: "v1.0", description: nil, project: project) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_milestone",             arguments: ["displayId": 1, "status": "invalid"]         )) @@ -563,8 +564,8 @@ struct MCPMilestoneToolTests {         let targetDisplayId = try #require(target.permanentDisplayId)          // Attempt to change status to "done" AND rename to "Existing" (duplicate) in one call-        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_milestone",             arguments: ["displayId": targetDisplayId, "status": "done", "name": "Existing"]         )) 
Transit/TransitTests/MCPNonIntegerDisplayIdTests.swift Modified +18 / -18
diff --git a/Transit/TransitTests/MCPNonIntegerDisplayIdTests.swift b/Transit/TransitTests/MCPNonIntegerDisplayIdTests.swiftindex 00d48b2..98c1536 100644--- a/Transit/TransitTests/MCPNonIntegerDisplayIdTests.swift+++ b/Transit/TransitTests/MCPNonIntegerDisplayIdTests.swift@@ -120,8 +120,8 @@ struct MCPNonIntegerDisplayIdTests {     @Test func updateStatusWithNonIntegerDisplayIdReturnsError() async throws {         let env = try MCPTestHelpers.makeEnv() -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task_status",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task_status",             arguments: ["displayId": "abc", "status": "planning"]         )) @@ -135,8 +135,8 @@ struct MCPNonIntegerDisplayIdTests {     @Test func addCommentWithNonIntegerDisplayIdReturnsError() async throws {         let env = try MCPTestHelpers.makeEnv() -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "add_comment",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "add_comment",             arguments: [                 "displayId": "abc",                 "content": "A comment",@@ -154,8 +154,8 @@ struct MCPNonIntegerDisplayIdTests {     @Test func updateTaskWithNonIntegerDisplayIdReturnsError() async throws {         let env = try MCPTestHelpers.makeEnv() -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: ["displayId": "abc"]         )) @@ -169,8 +169,8 @@ struct MCPNonIntegerDisplayIdTests {     @Test func updateMilestoneWithNonIntegerDisplayIdReturnsError() async throws {         let env = try MCPTestHelpers.makeEnv() -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_milestone",             arguments: ["displayId": "abc", "name": "Updated"]         )) @@ -184,8 +184,8 @@ struct MCPNonIntegerDisplayIdTests {     @Test func deleteMilestoneWithNonIntegerDisplayIdReturnsError() async throws {         let env = try MCPTestHelpers.makeEnv() -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "delete_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "delete_milestone",             arguments: ["displayId": "abc"]         )) @@ -206,8 +206,8 @@ struct MCPNonIntegerDisplayIdTests {             name: "v1.0", description: nil, project: project         ) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_milestone",             arguments: ["milestoneId": milestoneId, "name": "v2.0"]         )) @@ -224,8 +224,8 @@ struct MCPNonIntegerDisplayIdTests {             name: "v1.0", description: nil, project: project         ) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "delete_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "delete_milestone",             arguments: ["milestoneId": milestoneId]         )) @@ -243,8 +243,8 @@ struct MCPNonIntegerDisplayIdTests {          // Both displayId (malformed) and milestoneId (valid) are present.         // The handler must reject due to malformed displayId, not fall back to milestoneId.-        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_milestone",             arguments: [                 "displayId": "abc",                 "milestoneId": milestone.id.uuidString,@@ -270,8 +270,8 @@ struct MCPNonIntegerDisplayIdTests {          // Both displayId (malformed) and milestoneId (valid) are present.         // The handler must reject due to malformed displayId, not fall back to milestoneId.-        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "delete_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "delete_milestone",             arguments: [                 "displayId": "abc",                 "milestoneId": milestone.id.uuidString
Transit/TransitTests/MCPNonStringDescriptionTests.swift Modified +24 / -24
diff --git a/Transit/TransitTests/MCPNonStringDescriptionTests.swift b/Transit/TransitTests/MCPNonStringDescriptionTests.swiftindex ebe455b..39e3cb3 100644--- a/Transit/TransitTests/MCPNonStringDescriptionTests.swift+++ b/Transit/TransitTests/MCPNonStringDescriptionTests.swift@@ -19,8 +19,8 @@ struct MCPNonStringDescriptionTests {         let env = try MCPTestHelpers.makeEnv()         let project = MCPTestHelpers.makeProject(in: env.context) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: [                 "name": "Task", "type": "bug",                 "projectId": project.id.uuidString, "description": 123@@ -38,8 +38,8 @@ struct MCPNonStringDescriptionTests {         let env = try MCPTestHelpers.makeEnv()         let project = MCPTestHelpers.makeProject(in: env.context) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: [                 "name": "Task", "type": "bug",                 "projectId": project.id.uuidString, "description": false@@ -57,8 +57,8 @@ struct MCPNonStringDescriptionTests {         let env = try MCPTestHelpers.makeEnv()         let project = MCPTestHelpers.makeProject(in: env.context) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: [                 "name": "Task", "type": "bug",                 "projectId": project.id.uuidString, "description": ["x"]@@ -76,8 +76,8 @@ struct MCPNonStringDescriptionTests {         let env = try MCPTestHelpers.makeEnv()         let project = MCPTestHelpers.makeProject(in: env.context) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: [                 "name": "Task", "type": "bug",                 "projectId": project.id.uuidString, "description": NSNull()@@ -95,8 +95,8 @@ struct MCPNonStringDescriptionTests {         let env = try MCPTestHelpers.makeEnv()         let project = MCPTestHelpers.makeProject(in: env.context) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: [                 "name": "Task", "type": "bug",                 "projectId": project.id.uuidString, "description": "A description"@@ -112,8 +112,8 @@ struct MCPNonStringDescriptionTests {         let env = try MCPTestHelpers.makeEnv()         let project = MCPTestHelpers.makeProject(in: env.context) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: [                 "name": "Task", "type": "bug",                 "projectId": project.id.uuidString@@ -131,8 +131,8 @@ struct MCPNonStringDescriptionTests {         let env = try MCPTestHelpers.makeEnv()         let project = MCPTestHelpers.makeProject(in: env.context) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_milestone",             arguments: [                 "name": "v1.0", "projectId": project.id.uuidString, "description": 123             ]@@ -149,8 +149,8 @@ struct MCPNonStringDescriptionTests {         let env = try MCPTestHelpers.makeEnv()         let project = MCPTestHelpers.makeProject(in: env.context) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_milestone",             arguments: [                 "name": "v1.0", "projectId": project.id.uuidString, "description": true             ]@@ -167,8 +167,8 @@ struct MCPNonStringDescriptionTests {         let env = try MCPTestHelpers.makeEnv()         let project = MCPTestHelpers.makeProject(in: env.context) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_milestone",             arguments: [                 "name": "v1.0", "projectId": project.id.uuidString, "description": ["x"]             ]@@ -185,8 +185,8 @@ struct MCPNonStringDescriptionTests {         let env = try MCPTestHelpers.makeEnv()         let project = MCPTestHelpers.makeProject(in: env.context) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_milestone",             arguments: [                 "name": "v1.0", "projectId": project.id.uuidString, "description": NSNull()             ]@@ -203,8 +203,8 @@ struct MCPNonStringDescriptionTests {         let env = try MCPTestHelpers.makeEnv()         let project = MCPTestHelpers.makeProject(in: env.context) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_milestone",             arguments: [                 "name": "v1.0", "projectId": project.id.uuidString, "description": "Beta release"             ]@@ -219,8 +219,8 @@ struct MCPNonStringDescriptionTests {         let env = try MCPTestHelpers.makeEnv()         let project = MCPTestHelpers.makeProject(in: env.context) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_milestone",             arguments: [                 "name": "v1.0", "projectId": project.id.uuidString             ]
Transit/TransitTests/MCPNonStringMilestoneArgTests.swift Modified +16 / -16
diff --git a/Transit/TransitTests/MCPNonStringMilestoneArgTests.swift b/Transit/TransitTests/MCPNonStringMilestoneArgTests.swiftindex 816804b..95a0af7 100644--- a/Transit/TransitTests/MCPNonStringMilestoneArgTests.swift+++ b/Transit/TransitTests/MCPNonStringMilestoneArgTests.swift@@ -21,8 +21,8 @@ struct MCPNonStringMilestoneArgTests {             name: "v1.0", description: nil, project: project         ) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: [                 "name": "Task",                 "type": "bug",@@ -44,8 +44,8 @@ struct MCPNonStringMilestoneArgTests {         let env = try MCPTestHelpers.makeEnv()         let project = MCPTestHelpers.makeProject(in: env.context) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: [                 "name": "Task",                 "type": "bug",@@ -66,8 +66,8 @@ struct MCPNonStringMilestoneArgTests {         let env = try MCPTestHelpers.makeEnv()         let project = MCPTestHelpers.makeProject(in: env.context) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: [                 "name": "Task",                 "type": "bug",@@ -88,8 +88,8 @@ struct MCPNonStringMilestoneArgTests {         let env = try MCPTestHelpers.makeEnv()         let project = MCPTestHelpers.makeProject(in: env.context) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: [                 "name": "Task",                 "type": "bug",@@ -120,8 +120,8 @@ struct MCPNonStringMilestoneArgTests {         try env.milestoneService.setMilestone(milestone, on: task)         let taskDisplayId = try #require(task.permanentDisplayId) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: ["displayId": taskDisplayId, "milestone": 42]         )) @@ -143,8 +143,8 @@ struct MCPNonStringMilestoneArgTests {         try env.milestoneService.setMilestone(milestone, on: task)         let taskDisplayId = try #require(task.permanentDisplayId) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: ["displayId": taskDisplayId, "milestone": true]         )) @@ -166,8 +166,8 @@ struct MCPNonStringMilestoneArgTests {         try env.milestoneService.setMilestone(milestone, on: task)         let taskDisplayId = try #require(task.permanentDisplayId) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: ["displayId": taskDisplayId, "milestone": ["v1.0"]]         )) @@ -189,8 +189,8 @@ struct MCPNonStringMilestoneArgTests {         try env.milestoneService.setMilestone(milestone, on: task)         let taskDisplayId = try #require(task.permanentDisplayId) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: ["displayId": taskDisplayId, "milestone": NSNull()]         )) 
Transit/TransitTests/MCPNonStringMilestoneIdTests.swift Modified +8 / -8
diff --git a/Transit/TransitTests/MCPNonStringMilestoneIdTests.swift b/Transit/TransitTests/MCPNonStringMilestoneIdTests.swiftindex df58035..36dce6d 100644--- a/Transit/TransitTests/MCPNonStringMilestoneIdTests.swift+++ b/Transit/TransitTests/MCPNonStringMilestoneIdTests.swift@@ -17,8 +17,8 @@ struct MCPNonStringMilestoneIdTests {             name: "v1.0", description: nil, project: project         ) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_milestone",             arguments: ["milestoneId": 42, "name": "v2.0"]         )) @@ -34,8 +34,8 @@ struct MCPNonStringMilestoneIdTests {             name: "v1.0", description: nil, project: project         ) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "delete_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "delete_milestone",             arguments: ["milestoneId": 42]         )) @@ -51,8 +51,8 @@ struct MCPNonStringMilestoneIdTests {             name: "v1.0", description: nil, project: project         ) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_milestone",             arguments: ["milestoneId": true, "name": "v2.0"]         )) @@ -68,8 +68,8 @@ struct MCPNonStringMilestoneIdTests {             name: "v1.0", description: nil, project: project         ) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "delete_milestone",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "delete_milestone",             arguments: ["milestoneId": false]         )) 
Transit/TransitTests/MCPNotificationDispatchTests.swift Modified +5 / -1
diff --git a/Transit/TransitTests/MCPNotificationDispatchTests.swift b/Transit/TransitTests/MCPNotificationDispatchTests.swiftindex d7cecd8..a961baf 100644--- a/Transit/TransitTests/MCPNotificationDispatchTests.swift+++ b/Transit/TransitTests/MCPNotificationDispatchTests.swift@@ -24,6 +24,7 @@ struct MCPNotificationDispatchTests {                   "params":{                     "name":"create_task",                     "arguments":{+                      "idempotencyKey":"direct-notification",                       "name":"Direct notification task",                       "type":"bug",                       "projectId":"\(project.id.uuidString)"@@ -57,6 +58,7 @@ struct MCPNotificationDispatchTests {             "name":"add_comment",             "arguments":{               "displayId":\(displayId),+              "idempotencyKey":"http-comment",               "content":"Created over HTTP",               "authorName":"TestBot"             }@@ -100,7 +102,9 @@ struct MCPNotificationDispatchTests {             "method":"tools/call",             "params":{               "name":"update_task_status",-              "arguments":{"displayId":\(displayId),"status":"planning"}+              "arguments":{"displayId":\(displayId),"status":"planning",+              "idempotencyKey":"notification-status",+              "expectedRevision":"\(try MCPTestHelpers.readRevision(task, in: env.context))"}             }           },           {
Transit/TransitTests/MCPPriorityTests.swift Modified +8 / -8
diff --git a/Transit/TransitTests/MCPPriorityTests.swift b/Transit/TransitTests/MCPPriorityTests.swiftindex 940b9b7..3a2bd3e 100644--- a/Transit/TransitTests/MCPPriorityTests.swift+++ b/Transit/TransitTests/MCPPriorityTests.swift@@ -17,12 +17,12 @@ struct MCPPriorityTests {         let env = try MCPTestHelpers.makeEnv()         let project = MCPTestHelpers.makeProject(in: env.context) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: ["name": "Task", "type": "feature", "projectId": project.id.uuidString]         )) -        let result = try MCPTestHelpers.decodeResult(response)+        let result = try MCPTestHelpers.decodeSavedRecord(response)         #expect(result["priority"] as? String == "medium")     } @@ -30,15 +30,15 @@ struct MCPPriorityTests {         let env = try MCPTestHelpers.makeEnv()         let project = MCPTestHelpers.makeProject(in: env.context) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: [                 "name": "Task", "type": "feature",                 "projectId": project.id.uuidString, "priority": "high"             ]         )) -        let result = try MCPTestHelpers.decodeResult(response)+        let result = try MCPTestHelpers.decodeSavedRecord(response)         #expect(result["priority"] as? String == "high")          // The created task itself must carry the requested priority.@@ -51,8 +51,8 @@ struct MCPPriorityTests {         let env = try MCPTestHelpers.makeEnv()         let project = MCPTestHelpers.makeProject(in: env.context) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: [                 "name": "Task", "type": "feature",                 "projectId": project.id.uuidString, "priority": "urgent"
Transit/TransitTests/MCPProtectedWriteTestHelpers.swift Added +64 / -0
diff --git a/Transit/TransitTests/MCPProtectedWriteTestHelpers.swift b/Transit/TransitTests/MCPProtectedWriteTestHelpers.swiftnew file mode 100644index 0000000..013fccb--- /dev/null+++ b/Transit/TransitTests/MCPProtectedWriteTestHelpers.swift@@ -0,0 +1,64 @@+#if os(macOS)+import Foundation+import SwiftData+import Testing+@testable import Transit++@MainActor+extension MCPTestHelpers {+    /// Opt-in fixture for legacy domain tests. Raw protocol and missing-safety tests use toolCallRequest.+    static func protectedToolCallRequest(+        in context: ModelContext, tool: String, arguments: [String: Any], id: Int = 1+    ) throws -> JSONRPCRequest {+        guard MCPWriteCommand.protectedTools.contains(tool) else {+            return toolCallRequest(tool: tool, arguments: arguments, id: id)+        }+        var args = arguments+        args["idempotencyKey"] = args["idempotencyKey"] ?? freshWriteKey()+        if MCPWriteCommand.revisionTools.contains(tool), args["expectedRevision"] == nil {+            // A syntactically valid sentinel lets missing/malformed/ambiguous identifier tests+            // reach domain validation without fabricating a target or swallowing a fetch failure.+            var revision = "r1:" + String(repeating: "0", count: 64)+            if tool == "update_task" || tool == "update_task_status" {+                let records = try context.fetch(FetchDescriptor<TransitTask>()).filter { task in+                    if let displayID = IntentHelpers.parseIntValue(args["displayId"]) {+                        return task.permanentDisplayId == displayID+                    }+                    return task.id.uuidString == args["taskId"] as? String+                }+                if records.count == 1 { revision = try readRevision(records[0], in: context) }+            } else {+                let records = try context.fetch(FetchDescriptor<Milestone>()).filter { milestone in+                    if let displayID = IntentHelpers.parseIntValue(args["displayId"]) {+                        return milestone.permanentDisplayId == displayID+                    }+                    return milestone.id.uuidString == args["milestoneId"] as? String+                }+                if records.count == 1 { revision = try readRevision(records[0]) }+            }+            args["expectedRevision"] = revision+        }+        return toolCallRequest(tool: tool, arguments: args, id: id)+    }++    static func errorCode(_ response: JSONRPCResponse?) throws -> String {+        let result = try decodeResult(response)+        let error = try #require(result["error"] as? [String: Any])+        return try #require(error["code"] as? String)+    }++    /// Asserts the saved-outcome contract before exposing its record for domain assertions.+    static func decodeSavedRecord(_ response: JSONRPCResponse?) throws -> [String: Any] {+        let outcome = try decodeResult(response)+        #expect(outcome["contractVersion"] as? Int == 1)+        #expect(outcome["outcome"] as? String == "committed")+        #expect(outcome["accepted"] as? Bool == true)+        #expect(outcome["idempotencyKey"] is String)+        #expect(outcome["entityId"] is String)+        #expect(outcome["replayExpiresAt"] is String)+        let record = try #require(outcome["record"] as? [String: Any])+        #expect((record["revision"] as? String)?.hasPrefix("r1:") == true)+        return record+    }+}+#endif
Transit/TransitTests/MCPRecordRevisionTests.swift Added +125 / -0
diff --git a/Transit/TransitTests/MCPRecordRevisionTests.swift b/Transit/TransitTests/MCPRecordRevisionTests.swiftnew file mode 100644index 0000000..a13df70--- /dev/null+++ b/Transit/TransitTests/MCPRecordRevisionTests.swift@@ -0,0 +1,125 @@+import Foundation+import SwiftData+import Testing+@testable import Transit++@MainActor @Suite(.serialized)+struct MCPRecordRevisionTests {+    @Test func taskCoveredScalarsAndRestoration() throws {+        let owner = try TestModelContainer()+        let project = Project(name: "Project", description: "", gitRepo: nil, colorHex: "red")+        owner.context.insert(project)+        let task = TransitTask(name: "Task", type: .feature, project: project, displayID: .provisional)+        owner.context.insert(task)+        let baseline = try MCPRecordSnapshot.task(task, in: owner.context)+        let changes: [(TransitTask) -> Void] = [+            { $0.id = UUID() }, { $0.name = "changed" }, { $0.taskDescription = "" },+            { $0.statusRawValue = "invalid" }, { $0.typeRawValue = "invalid" },+            { $0.priorityRawValue = "legacy" }, { $0.permanentDisplayId = 10 },+            { $0.creationDate = Date(timeIntervalSinceReferenceDate: 1) },+            { $0.lastStatusChangeDate = Date(timeIntervalSinceReferenceDate: 2) },+            { $0.completionDate = Date(timeIntervalSinceReferenceDate: 3) },+            { $0.metadataJSON = "{}" }, { $0.project = nil },+            { $0.milestone = Milestone(name: "M", project: project, displayID: .provisional) }+        ]+        for change in changes {+            let copy = TransitTask(name: task.name, type: .feature, project: project, displayID: .provisional)+            copy.id = task.id+            copy.creationDate = task.creationDate+            copy.lastStatusChangeDate = task.lastStatusChangeDate+            change(copy)+            let changed = try MCPRecordSnapshot.task(copy) { _ in [] }+            #expect(changed.revision != baseline.revision)+        }+        task.name = "changed"+        task.name = "Task"+        project.name = "rename excluded"+        #expect(try MCPRecordSnapshot.task(task, in: owner.context).revision == baseline.revision)+        task.creationDate = Date(+            timeIntervalSinceReferenceDate: task.creationDate.timeIntervalSinceReferenceDate.nextUp+        )+        #expect(try MCPRecordSnapshot.task(task, in: owner.context).revision != baseline.revision)+    }++    @Test func commentOrderAndFetchFailure() throws {+        let project = Project(name: "Project", description: "", gitRepo: nil, colorHex: "red")+        let task = TransitTask(name: "Task", type: .feature, project: project, displayID: .provisional)+        let first = Transit.Comment(content: "one", authorName: "A", isAgent: true, task: task)+        let second = Transit.Comment(content: "two", authorName: "B", isAgent: false, task: task)+        let snapshot = try MCPRecordSnapshot.task(task) { _ in [first, second] }+        #expect(snapshot.revision == (try MCPRecordSnapshot.task(task) { _ in [second, first] }.revision))+        first.content = "changed"+        #expect(snapshot.revision != (try MCPRecordSnapshot.task(task) { _ in [first, second] }.revision))+        #expect(throws: CocoaError.self) {+            try MCPRecordSnapshot.task(task) { _ in throw CocoaError(.fileReadUnknown) }+        }+        #expect((snapshot.record["revision"] as? String) == snapshot.revision)+    }++    @Test func projectMilestoneAndCommentCoverage() throws {+        let project = Project(name: "Project", description: "", gitRepo: nil, colorHex: "red")+        let milestone = Milestone(name: "M", project: project, displayID: .provisional)+        let task = TransitTask(name: "Task", type: .feature, project: project, displayID: .provisional)+        let comment = Transit.Comment(content: "C", authorName: "A", isAgent: false, task: task)+        let baseline = try MCPRecordSnapshot.project(project).revision+        project.tasks = [task]+        project.milestones = [milestone]+        #expect(try MCPRecordSnapshot.project(project).revision == baseline)+        project.gitRepo = ""+        #expect(try MCPRecordSnapshot.project(project).revision != baseline)+        let milestoneBaseline = try MCPRecordSnapshot.milestone(milestone).revision+        milestone.tasks = [task]+        project.name = "renamed"+        #expect(try MCPRecordSnapshot.milestone(milestone).revision == milestoneBaseline)+        milestone.project = nil+        #expect(try MCPRecordSnapshot.milestone(milestone).revision != milestoneBaseline)+        let commentBaseline = try MCPRecordSnapshot.comment(comment).revision+        comment.isAgent = true+        #expect(try MCPRecordSnapshot.comment(comment).revision != commentBaseline)+    }++    @Test func everyProjectMilestoneAndCommentScalarChangesItsToken() throws {+        let owner = try TestModelContainer()+        let project = Project(name: "Project", description: "", gitRepo: nil, colorHex: "red")+        let milestone = Milestone(name: "M", project: project, displayID: .provisional)+        let task = TransitTask(name: "T", type: .feature, project: project, displayID: .provisional)+        let comment = Transit.Comment(content: "C", authorName: "A", isAgent: false, task: task)+        owner.context.insert(project)+        owner.context.insert(milestone)+        owner.context.insert(task)+        owner.context.insert(comment)+        try owner.context.save()+        let projectBaseline = try MCPRecordSnapshot.project(project).revision+        let projectChanges: [(Project) -> Void] = [+            { $0.id = UUID() }, { $0.name = "new" }, { $0.projectDescription = "new" },+            { $0.gitRepo = "" }, { $0.colorHex = "blue" }+        ]+        for change in projectChanges {+            change(project)+            #expect(try MCPRecordSnapshot.project(project).revision != projectBaseline)+            owner.context.safeRollback()+        }+        let milestoneBaseline = try MCPRecordSnapshot.milestone(milestone).revision+        let milestoneChanges: [(Milestone) -> Void] = [+            { $0.id = UUID() }, { $0.name = "new" }, { $0.milestoneDescription = "" },+            { $0.permanentDisplayId = 4 }, { $0.statusRawValue = "invalid" },+            { $0.creationDate = .distantPast }, { $0.lastStatusChangeDate = .distantPast },+            { $0.completionDate = .distantPast }, { $0.project = nil }+        ]+        for change in milestoneChanges {+            change(milestone)+            #expect(try MCPRecordSnapshot.milestone(milestone).revision != milestoneBaseline)+            owner.context.safeRollback()+        }+        let commentBaseline = try MCPRecordSnapshot.comment(comment).revision+        let commentChanges: [(Transit.Comment) -> Void] = [+            { $0.id = UUID() }, { $0.content = "new" }, { $0.authorName = "new" },+            { $0.isAgent = true }, { $0.creationDate = .distantPast }, { $0.task = nil }+        ]+        for change in commentChanges {+            change(comment)+            #expect(try MCPRecordSnapshot.comment(comment).revision != commentBaseline)+            owner.context.safeRollback()+        }+    }+}
Transit/TransitTests/MCPServerBatchRequestTests.swift Modified +1 / -0
diff --git a/Transit/TransitTests/MCPServerBatchRequestTests.swift b/Transit/TransitTests/MCPServerBatchRequestTests.swiftindex 1c5bac9..1a476e3 100644--- a/Transit/TransitTests/MCPServerBatchRequestTests.swift+++ b/Transit/TransitTests/MCPServerBatchRequestTests.swift@@ -57,6 +57,7 @@ struct MCPServerBatchRequestTests {           "params":{             "name":"create_task",             "arguments":{+              "idempotencyKey":"batch-notification",               "name":"Notification task",               "type":"bug",               "projectId":"\(project.id.uuidString)"
Transit/TransitTests/MCPServerLifecycleTests.swift Modified +3 / -2
diff --git a/Transit/TransitTests/MCPServerLifecycleTests.swift b/Transit/TransitTests/MCPServerLifecycleTests.swiftindex 75f1093..ccdd327 100644--- a/Transit/TransitTests/MCPServerLifecycleTests.swift+++ b/Transit/TransitTests/MCPServerLifecycleTests.swift@@ -3,6 +3,7 @@ import Darwin import Foundation import Logging import ServiceLifecycle+import SwiftData import Testing @testable import Transit @@ -202,7 +203,7 @@ struct MCPServerLifecycleTests {         )     } -    private func waitUntilListening(+    func waitUntilListening(         port: Int,         timeout: Duration = .seconds(3)     ) async -> Bool {@@ -303,7 +304,7 @@ struct MCPServerLifecycleTests {         )     } -    private func availableLoopbackPort() throws -> Int {+    func availableLoopbackPort() throws -> Int {         let descriptor = socket(AF_INET, SOCK_STREAM, 0)         guard descriptor >= 0 else {             throw LifecycleTestError.socketCreationFailed(errno)
Transit/TransitTests/MCPServerOriginValidationTests.swift Modified +2 / -1
diff --git a/Transit/TransitTests/MCPServerOriginValidationTests.swift b/Transit/TransitTests/MCPServerOriginValidationTests.swiftindex 07d8ba8..6af6ed9 100644--- a/Transit/TransitTests/MCPServerOriginValidationTests.swift+++ b/Transit/TransitTests/MCPServerOriginValidationTests.swift@@ -218,7 +218,8 @@ struct MCPServerOriginValidationTests {      private static let createTaskBody = """     {"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"create_task",\-    "arguments":{"project":"Transit","name":"Origin test task","type":"bug"}}}+    "arguments":{"project":"Transit","name":"Origin test task","type":"bug",\+    "idempotencyKey":"origin-test"}}}     """      private func respond(
Transit/TransitTests/MCPTaskIdentifierValidationTests.swift Modified +10 / -10
diff --git a/Transit/TransitTests/MCPTaskIdentifierValidationTests.swift b/Transit/TransitTests/MCPTaskIdentifierValidationTests.swiftindex 35c79e0..c35b85f 100644--- a/Transit/TransitTests/MCPTaskIdentifierValidationTests.swift+++ b/Transit/TransitTests/MCPTaskIdentifierValidationTests.swift@@ -18,8 +18,8 @@ struct MCPTaskIdentifierValidationTests {             name: "Task", description: nil, type: .feature, project: project         ) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task_status",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task_status",             arguments: [                 "displayId": "abc",                 "taskId": task.id.uuidString,@@ -44,8 +44,8 @@ struct MCPTaskIdentifierValidationTests {             name: "Task", description: nil, type: .feature, project: project         ) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task_status",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task_status",             arguments: [                 "taskId": 123,                 "status": "in-progress"@@ -67,8 +67,8 @@ struct MCPTaskIdentifierValidationTests {             name: "M1", description: nil, project: project         ) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: [                 "displayId": "abc",                 "taskId": task.id.uuidString,@@ -92,8 +92,8 @@ struct MCPTaskIdentifierValidationTests {             name: "Task", description: nil, type: .feature, project: project         ) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "add_comment",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "add_comment",             arguments: [                 "displayId": "abc",                 "taskId": task.id.uuidString,@@ -118,8 +118,8 @@ struct MCPTaskIdentifierValidationTests {             name: "Task", description: nil, type: .feature, project: project         ) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "add_comment",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "add_comment",             arguments: [                 "taskId": 123,                 "content": "Hello",
Transit/TransitTests/MCPTestHelpers.swift Modified +33 / -9
diff --git a/Transit/TransitTests/MCPTestHelpers.swift b/Transit/TransitTests/MCPTestHelpers.swiftindex 1e78e28..5e6a9f6 100644--- a/Transit/TransitTests/MCPTestHelpers.swift+++ b/Transit/TransitTests/MCPTestHelpers.swift@@ -13,21 +13,26 @@ struct MCPTestEnv {     let maintenanceService: DisplayIDMaintenanceService     let mcpSettings: MCPSettings     let context: ModelContext+    let writeCoordinator: MCPWriteCoordinator+    let sidecarDirectory: URL }  @MainActor enum MCPTestHelpers { +    // swiftlint:disable:next function_body_length     static func makeEnv(-        taskCreateSave: @escaping (ModelContext) throws -> Void = { try $0.save() },-        taskStatusSave: @escaping (ModelContext) throws -> Void = { try $0.save() },+        taskCreateSave: ((ModelContext) throws -> Void)? = nil,+        taskStatusSave: ((ModelContext) throws -> Void)? = nil,+        writeCommitSave: ((ModelContext) throws -> Void)? = nil,         projectFetcher: (any ModelFetching)? = nil,         taskFetcher: (any TaskFetching)? = nil,         commentFetcher: (any CommentFetching)? = nil,         milestoneFetcher: (any MilestoneFetching)? = nil,         milestoneDisplayIDFinder: (any MilestoneDisplayIDFinding)? = nil,         milestoneServiceFetcher: (any ModelFetching)? = nil,-        taskCounterStore: (any DisplayIDAllocator.CounterStore)? = nil+        taskCounterStore: (any DisplayIDAllocator.CounterStore)? = nil,+        persistence: PersistenceAvailability? = nil     ) throws -> MCPTestEnv {         let testContainer = try TestModelContainer()         let context = testContainer.context@@ -36,8 +41,8 @@ enum MCPTestHelpers {         let taskService = TaskService(             modelContext: context,             displayIDAllocator: taskAllocator,-            createSave: taskCreateSave,-            statusSave: taskStatusSave+            createSave: taskCreateSave ?? { try $0.save() },+            statusSave: taskStatusSave ?? { try $0.save() }         )         let projectService = ProjectService(modelContext: context, fetcher: projectFetcher)         let commentService = CommentService(modelContext: context)@@ -57,13 +62,26 @@ enum MCPTestHelpers {         let mcpSettings = MCPSettings()         // Default to off so existing tests don't see maintenance tools unless they opt in.         mcpSettings.maintenanceToolsEnabled = false+        let sidecar = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)+        let writeCoordinator = MCPWriteCoordinator(+            services: MCPWriteCommandServices(tasks: taskService, projects: projectService,+                comments: commentService, milestones: milestoneService, context: context),+            sidecarDirectory: sidecar, persistence: persistence,+            save: { context, stage in+                if case .commit = stage, let injectedSave = writeCommitSave ?? taskCreateSave ?? taskStatusSave {+                    try injectedSave(context)+                } else {+                    try context.save()+                }+            }+        )         let handler = MCPToolHandler(             taskService: taskService, projectService: projectService,             commentService: commentService, milestoneService: milestoneService,-            maintenanceService: maintenanceService, settings: mcpSettings,+            maintenanceService: maintenanceService, settings: mcpSettings, persistence: persistence,             taskFetcher: taskFetcher, commentFetcher: commentFetcher,             milestoneFetcher: milestoneFetcher,-            milestoneDisplayIDFinder: milestoneDisplayIDFinder+            milestoneDisplayIDFinder: milestoneDisplayIDFinder, writeCoordinator: writeCoordinator         )         return MCPTestEnv(             handler: handler,@@ -73,7 +91,7 @@ enum MCPTestHelpers {             milestoneService: milestoneService,             maintenanceService: maintenanceService,             mcpSettings: mcpSettings,-            context: context+            context: context, writeCoordinator: writeCoordinator, sidecarDirectory: sidecar         )     } @@ -131,7 +149,13 @@ enum MCPTestHelpers {         let json = try JSONSerialization.jsonObject(with: data) as? [String: Any]         let result = try #require(json?["result"] as? [String: Any])         let content = try #require(result["content"] as? [[String: Any]])-        return try #require(content.first?["text"] as? String)+        let text = try #require(content.first?["text"] as? String)+        if let bytes = text.data(using: .utf8),+           let envelope = try? JSONSerialization.jsonObject(with: bytes) as? [String: Any],+           let error = envelope["error"] as? [String: Any], let message = error["message"] as? String {+            return message+        }+        return text     }      /// Decodes the JSON-RPC `error` object from a response. Use this for cases
Transit/TransitTests/MCPToolHandlerCommentTests.swift Modified +18 / -13
diff --git a/Transit/TransitTests/MCPToolHandlerCommentTests.swift b/Transit/TransitTests/MCPToolHandlerCommentTests.swiftindex f2f0a29..5ad46ca 100644--- a/Transit/TransitTests/MCPToolHandlerCommentTests.swift+++ b/Transit/TransitTests/MCPToolHandlerCommentTests.swift@@ -22,8 +22,10 @@ struct MCPToolHandlerCommentTests {         )          // No-op status change WITH a new comment-        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task_status",+        #expect(try env.context.fetch(FetchDescriptor<TransitTask>()).first?.statusRawValue == "planning")++        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task_status",             arguments: [                 "displayId": displayId, "status": "planning",                 "comment": "Fresh note", "authorName": "NewAgent"@@ -31,8 +33,7 @@ struct MCPToolHandlerCommentTests {         ))          let result = try MCPTestHelpers.decodeResult(response)-        #expect(result["previousStatus"] as? String == "planning")-        #expect(result["status"] as? String == "planning")+        #expect((result["record"] as? [String: Any])?["status"] as? String == "planning")          // The returned comment must be the NEW one, not the stale old one         let comment = try #require(result["comment"] as? [String: Any])@@ -54,8 +55,8 @@ struct MCPToolHandlerCommentTests {         futureComment.creationDate = Date.now.addingTimeInterval(60 * 60)         try env.context.save() -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task_status",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task_status",             arguments: [                 "displayId": displayId, "status": "planning",                 "comment": "Created by this call", "authorName": "CurrentAgent"@@ -76,7 +77,7 @@ struct MCPToolHandlerCommentTests {      @Test func updateStatusWithCommentSaveFailureReturnsErrorAndRollsBack() async throws {         let env = try MCPTestHelpers.makeEnv(-            taskStatusSave: { _ in throw SaveFailure.simulated }+            writeCommitSave: { _ in throw SaveFailure.simulated }         )         let project = MCPTestHelpers.makeProject(in: env.context)         let task = try await env.taskService.createTask(@@ -84,8 +85,8 @@ struct MCPToolHandlerCommentTests {         )         let displayId = try #require(task.permanentDisplayId) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task_status",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task_status",             arguments: [                 "displayId": displayId, "status": "planning",                 "comment": "Must not survive", "authorName": "CurrentAgent"@@ -93,7 +94,11 @@ struct MCPToolHandlerCommentTests {         ))          #expect(try MCPTestHelpers.isError(response))-        #expect(try MCPTestHelpers.errorText(response).contains("Status update failed"))+        #expect(try MCPTestHelpers.errorCode(response) == "INTERNAL_ERROR")+        let outcome = try MCPTestHelpers.decodeResult(response)+        #expect(outcome["outcome"] as? String == "rejected")+        #expect(outcome["accepted"] as? Bool == true)+        #expect(outcome["replayExpiresAt"] is String)         #expect(task.status == .idea)         #expect(try env.commentService.fetchComments(for: task.id).isEmpty) @@ -116,13 +121,13 @@ struct MCPToolHandlerCommentTests {         )          // No-op status change WITHOUT a comment — must not return stale comment-        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task_status",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task_status",             arguments: ["displayId": displayId, "status": "planning"]         ))          let result = try MCPTestHelpers.decodeResult(response)-        #expect(result["comment"] == nil, "No-op without comment should not return stale comment details")+        #expect(result["comment"] is NSNull, "No-op without comment should not return stale comment details")     } } 
Transit/TransitTests/MCPToolHandlerTests.swift Modified +37 / -34
diff --git a/Transit/TransitTests/MCPToolHandlerTests.swift b/Transit/TransitTests/MCPToolHandlerTests.swiftindex 2eeb878..1a503a5 100644--- a/Transit/TransitTests/MCPToolHandlerTests.swift+++ b/Transit/TransitTests/MCPToolHandlerTests.swift@@ -98,8 +98,8 @@ struct MCPToolHandlerTests {         let env = try MCPTestHelpers.makeEnv()         let project = MCPTestHelpers.makeProject(in: env.context) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: [                 "name": "New Task",                 "type": "feature",@@ -107,7 +107,7 @@ struct MCPToolHandlerTests {             ]         )) -        let result = try MCPTestHelpers.decodeResult(response)+        let result = try MCPTestHelpers.decodeSavedRecord(response)         #expect(result["taskId"] is String)         #expect(result["status"] as? String == "idea")         #expect(result["displayId"] as? Int == 1)@@ -116,8 +116,8 @@ struct MCPToolHandlerTests {     @Test func createTaskMissingNameReturnsError() async throws {         let env = try MCPTestHelpers.makeEnv() -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: ["type": "bug"]         )) @@ -128,8 +128,8 @@ struct MCPToolHandlerTests {         let env = try MCPTestHelpers.makeEnv()         let project = MCPTestHelpers.makeProject(in: env.context) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: ["name": "Task", "type": "epic", "projectId": project.id.uuidString]         )) @@ -140,20 +140,20 @@ struct MCPToolHandlerTests {         let env = try MCPTestHelpers.makeEnv()         MCPTestHelpers.makeProject(in: env.context, name: "Alpha") -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: ["name": "Task", "type": "bug", "project": "Alpha"]         )) -        let result = try MCPTestHelpers.decodeResult(response)+        let result = try MCPTestHelpers.decodeSavedRecord(response)         #expect(result["status"] as? String == "idea")     }      @Test func createTaskUnknownProjectReturnsError() async throws {         let env = try MCPTestHelpers.makeEnv() -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: ["name": "Task", "type": "bug", "project": "Nonexistent"]         )) @@ -166,8 +166,8 @@ struct MCPToolHandlerTests {         let env = try MCPTestHelpers.makeEnv()         MCPTestHelpers.makeProject(in: env.context, name: "Decoy") -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: ["name": "Task", "type": "bug", "projectId": "not-a-uuid", "project": "Decoy"]         )) @@ -181,8 +181,8 @@ struct MCPToolHandlerTests {         let env = try MCPTestHelpers.makeEnv()         MCPTestHelpers.makeProject(in: env.context, name: "Decoy") -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: ["name": "Task", "type": "bug", "projectId": 123, "project": "Decoy"]         )) @@ -194,8 +194,8 @@ struct MCPToolHandlerTests {     @Test func createTaskNumericProjectIdWithoutFallbackReturnsError() async throws {         let env = try MCPTestHelpers.makeEnv() -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: ["name": "Task", "type": "bug", "projectId": 123]         )) @@ -229,13 +229,14 @@ struct MCPToolHandlerTests {             name: "Task", description: nil, type: .feature, project: project         ) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task_status",+        #expect(try env.context.fetch(FetchDescriptor<TransitTask>()).first?.statusRawValue == "idea")++        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task_status",             arguments: ["displayId": 1, "status": "planning"]         )) -        let result = try MCPTestHelpers.decodeResult(response)-        #expect(result["previousStatus"] as? String == "idea")+        let result = try MCPTestHelpers.decodeSavedRecord(response)         #expect(result["status"] as? String == "planning")     } @@ -246,13 +247,14 @@ struct MCPToolHandlerTests {             name: "Task", description: nil, type: .feature, project: project         ) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task_status",+        #expect(try env.context.fetch(FetchDescriptor<TransitTask>()).first?.statusRawValue == "idea")++        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task_status",             arguments: ["taskId": task.id.uuidString, "status": "in-progress"]         )) -        let result = try MCPTestHelpers.decodeResult(response)-        #expect(result["previousStatus"] as? String == "idea")+        let result = try MCPTestHelpers.decodeSavedRecord(response)         #expect(result["status"] as? String == "in-progress")     } @@ -270,13 +272,14 @@ struct MCPToolHandlerTests {         task.lastStatusChangeDate = originalStatusChangeDate         task.completionDate = originalCompletionDate -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task_status",+        #expect(try env.context.fetch(FetchDescriptor<TransitTask>()).first?.statusRawValue == "done")++        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task_status",             arguments: ["displayId": displayId, "status": "done"]         )) -        let result = try MCPTestHelpers.decodeResult(response)-        #expect(result["previousStatus"] as? String == "done")+        let result = try MCPTestHelpers.decodeSavedRecord(response)         #expect(result["status"] as? String == "done")         #expect(task.lastStatusChangeDate == originalStatusChangeDate)         #expect(task.completionDate == originalCompletionDate)@@ -285,8 +288,8 @@ struct MCPToolHandlerTests {     @Test func updateStatusMissingStatusReturnsError() async throws {         let env = try MCPTestHelpers.makeEnv() -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task_status",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task_status",             arguments: ["displayId": 1]         )) @@ -296,8 +299,8 @@ struct MCPToolHandlerTests {     @Test func updateStatusTaskNotFoundReturnsError() async throws {         let env = try MCPTestHelpers.makeEnv() -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task_status",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task_status",             arguments: ["displayId": 999, "status": "done"]         )) 
Transit/TransitTests/MCPUpdateStatusValidationTests.swift Modified +10 / -10
diff --git a/Transit/TransitTests/MCPUpdateStatusValidationTests.swift b/Transit/TransitTests/MCPUpdateStatusValidationTests.swiftindex 439f30b..56b7db9 100644--- a/Transit/TransitTests/MCPUpdateStatusValidationTests.swift+++ b/Transit/TransitTests/MCPUpdateStatusValidationTests.swift@@ -25,8 +25,8 @@ struct MCPUpdateStatusValidationTests {         let project = MCPTestHelpers.makeProject(in: env.context)         let task = makeTask(in: env.context, project: project, displayId: 1) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task_status",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task_status",             arguments: ["displayId": 1, "status": 123]         )) @@ -43,8 +43,8 @@ struct MCPUpdateStatusValidationTests {         let project = MCPTestHelpers.makeProject(in: env.context)         makeTask(in: env.context, project: project, displayId: 1) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task_status",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task_status",             arguments: ["displayId": 1, "status": true]         )) @@ -58,8 +58,8 @@ struct MCPUpdateStatusValidationTests {         let project = MCPTestHelpers.makeProject(in: env.context)         makeTask(in: env.context, project: project, displayId: 1) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task_status",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task_status",             arguments: ["displayId": 1, "status": ["done"]]         )) @@ -73,8 +73,8 @@ struct MCPUpdateStatusValidationTests {         let project = MCPTestHelpers.makeProject(in: env.context)         makeTask(in: env.context, project: project, displayId: 1) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task_status",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task_status",             arguments: ["displayId": 1, "status": NSNull()]         )) @@ -89,8 +89,8 @@ struct MCPUpdateStatusValidationTests {         let project = MCPTestHelpers.makeProject(in: env.context)         makeTask(in: env.context, project: project, displayId: 1) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task_status",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task_status",             arguments: ["displayId": 1]         )) 
Transit/TransitTests/MCPUpdateTaskTests.swift Modified +113 / -106
diff --git a/Transit/TransitTests/MCPUpdateTaskTests.swift b/Transit/TransitTests/MCPUpdateTaskTests.swiftindex 291ad8b..c1f7392 100644--- a/Transit/TransitTests/MCPUpdateTaskTests.swift+++ b/Transit/TransitTests/MCPUpdateTaskTests.swift@@ -24,12 +24,12 @@ struct MCPUpdateTaskTests {         let taskDisplayId = try #require(task.permanentDisplayId)         let milestoneDisplayId = try #require(milestone.permanentDisplayId) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: ["displayId": taskDisplayId, "milestoneDisplayId": milestoneDisplayId]         )) -        let result = try MCPTestHelpers.decodeResult(response)+        let result = try MCPTestHelpers.decodeSavedRecord(response)         #expect(result["name"] as? String == "Task")         #expect(task.milestone?.id == milestone.id)     }@@ -47,12 +47,12 @@ struct MCPUpdateTaskTests {         #expect(task.milestone != nil)          let taskDisplayId = try #require(task.permanentDisplayId)-        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: ["displayId": taskDisplayId, "clearMilestone": true]         )) -        let result = try MCPTestHelpers.decodeResult(response)+        let result = try MCPTestHelpers.decodeSavedRecord(response)         #expect(result["name"] as? String == "Task")         #expect(task.milestone == nil)     }@@ -70,8 +70,8 @@ struct MCPUpdateTaskTests {         let taskDisplayId = try #require(task.permanentDisplayId)         let milestoneDisplayId = try #require(milestone.permanentDisplayId) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: ["displayId": taskDisplayId, "milestoneDisplayId": milestoneDisplayId]         )) @@ -88,8 +88,8 @@ struct MCPUpdateTaskTests {         )         let taskDisplayId = try #require(task.permanentDisplayId) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: ["displayId": taskDisplayId, "milestoneDisplayId": 999]         )) @@ -113,8 +113,8 @@ struct MCPUpdateTaskTests {         try env.milestoneService.setMilestone(milestone, on: task)         let taskDisplayId = try #require(task.permanentDisplayId) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: ["displayId": taskDisplayId, "clearMilestone": "true"]         )) @@ -135,8 +135,8 @@ struct MCPUpdateTaskTests {         try env.milestoneService.setMilestone(milestone, on: task)         let taskDisplayId = try #require(task.permanentDisplayId) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: ["displayId": taskDisplayId, "clearMilestone": 1]         )) @@ -157,8 +157,8 @@ struct MCPUpdateTaskTests {         try env.milestoneService.setMilestone(milestone, on: task)         let taskDisplayId = try #require(task.permanentDisplayId) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: ["displayId": taskDisplayId, "clearMilestone": false]         )) @@ -184,8 +184,8 @@ struct MCPUpdateTaskTests {         let milestoneDisplayId = try #require(milestone.permanentDisplayId)          // Attempt assignment with project mismatch — should fail-        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: ["displayId": taskDisplayId, "milestoneDisplayId": milestoneDisplayId]         )) @@ -216,12 +216,12 @@ struct MCPUpdateTaskTests {         )         let taskDisplayId = try #require(task.permanentDisplayId) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: ["displayId": taskDisplayId, "name": "  hello  "]         )) -        let result = try MCPTestHelpers.decodeResult(response)+        let result = try MCPTestHelpers.decodeSavedRecord(response)         #expect(result["name"] as? String == "hello")         #expect(task.name == "hello")     }@@ -234,8 +234,8 @@ struct MCPUpdateTaskTests {         )         let taskDisplayId = try #require(task.permanentDisplayId) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: ["displayId": taskDisplayId, "name": ""]         )) @@ -251,8 +251,8 @@ struct MCPUpdateTaskTests {         )         let taskDisplayId = try #require(task.permanentDisplayId) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: ["displayId": taskDisplayId, "name": "   "]         )) @@ -269,8 +269,8 @@ struct MCPUpdateTaskTests {         let taskDisplayId = try #require(task.permanentDisplayId)          let args = try Self.jsonRoundTrip("{\"displayId\": \(taskDisplayId), \"name\": 42}")-        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task", arguments: args+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task", arguments: args         ))          #expect(try MCPTestHelpers.isError(response))@@ -289,12 +289,12 @@ struct MCPUpdateTaskTests {         )         let taskDisplayId = try #require(task.permanentDisplayId) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: ["displayId": taskDisplayId, "description": "  text  "]         )) -        let result = try MCPTestHelpers.decodeResult(response)+        let result = try MCPTestHelpers.decodeSavedRecord(response)         #expect(result["description"] as? String == "text")         #expect(task.taskDescription == "text")     }@@ -307,13 +307,13 @@ struct MCPUpdateTaskTests {         )         let taskDisplayId = try #require(task.permanentDisplayId) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: ["displayId": taskDisplayId, "description": ""]         )) -        let result = try MCPTestHelpers.decodeResult(response)-        #expect(result["description"] == nil, "Response should omit description when cleared")+        let result = try MCPTestHelpers.decodeSavedRecord(response)+        #expect(result["description"] is NSNull, "Full saved record must expose a cleared description as null")         #expect(task.taskDescription == nil)     } @@ -325,13 +325,13 @@ struct MCPUpdateTaskTests {         )         let taskDisplayId = try #require(task.permanentDisplayId) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: ["displayId": taskDisplayId, "description": "   "]         )) -        let result = try MCPTestHelpers.decodeResult(response)-        #expect(result["description"] == nil, "Response should omit description when cleared")+        let result = try MCPTestHelpers.decodeSavedRecord(response)+        #expect(result["description"] is NSNull, "Full saved record must expose a cleared description as null")         #expect(task.taskDescription == nil)     } @@ -344,8 +344,8 @@ struct MCPUpdateTaskTests {         let taskDisplayId = try #require(task.permanentDisplayId)          let args = try Self.jsonRoundTrip("{\"displayId\": \(taskDisplayId), \"description\": 42}")-        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task", arguments: args+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task", arguments: args         ))          #expect(try MCPTestHelpers.isError(response))@@ -362,12 +362,12 @@ struct MCPUpdateTaskTests {         )         let taskDisplayId = try #require(task.permanentDisplayId) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: ["displayId": taskDisplayId, "type": "feature"]         )) -        let result = try MCPTestHelpers.decodeResult(response)+        let result = try MCPTestHelpers.decodeSavedRecord(response)         #expect(result["type"] as? String == "feature")         #expect(task.type == .feature)     }@@ -380,8 +380,8 @@ struct MCPUpdateTaskTests {         )         let taskDisplayId = try #require(task.permanentDisplayId) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: ["displayId": taskDisplayId, "type": "epic"]         )) @@ -398,8 +398,8 @@ struct MCPUpdateTaskTests {         let taskDisplayId = try #require(task.permanentDisplayId)          let args = try Self.jsonRoundTrip("{\"displayId\": \(taskDisplayId), \"type\": 1}")-        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task", arguments: args+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task", arguments: args         ))          #expect(try MCPTestHelpers.isError(response))@@ -417,12 +417,12 @@ struct MCPUpdateTaskTests {         )         let taskDisplayId = try #require(task.permanentDisplayId) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: ["displayId": taskDisplayId, "metadata": ["c": "3"]]         )) -        let result = try MCPTestHelpers.decodeResult(response)+        let result = try MCPTestHelpers.decodeSavedRecord(response)         let metadata = try #require(result["metadata"] as? [String: String])         #expect(metadata == ["c": "3"])         #expect(task.metadata == ["c": "3"])@@ -437,13 +437,14 @@ struct MCPUpdateTaskTests {         )         let taskDisplayId = try #require(task.permanentDisplayId) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: ["displayId": taskDisplayId, "metadata": [String: String]()]         )) -        let result = try MCPTestHelpers.decodeResult(response)-        #expect(result["metadata"] == nil, "Response should omit metadata when cleared")+        let result = try MCPTestHelpers.decodeSavedRecord(response)+        #expect((result["metadata"] as? [String: String])?.isEmpty == true,+                "Full saved record must expose cleared metadata")         #expect(task.metadata.isEmpty)     } @@ -456,8 +457,8 @@ struct MCPUpdateTaskTests {         )         let taskDisplayId = try #require(task.permanentDisplayId) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: ["displayId": taskDisplayId, "metadata": "string"]         )) @@ -478,8 +479,8 @@ struct MCPUpdateTaskTests {         let args = try Self.jsonRoundTrip(             "{\"displayId\": \(taskDisplayId), \"metadata\": {\"a\": 1}}"         )-        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task", arguments: args+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task", arguments: args         ))          #expect(try MCPTestHelpers.isError(response))@@ -498,12 +499,12 @@ struct MCPUpdateTaskTests {         )         let taskDisplayId = try #require(task.permanentDisplayId) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: ["displayId": taskDisplayId, "description": "ignored"]         )) -        let result = try MCPTestHelpers.decodeResult(response)+        let result = try MCPTestHelpers.decodeSavedRecord(response)         #expect(result["name"] as? String == "X")         #expect(task.name == "X")     }@@ -517,12 +518,12 @@ struct MCPUpdateTaskTests {         let taskDisplayId = try #require(task.permanentDisplayId)          // Update something other than description-        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: ["displayId": taskDisplayId, "name": "Renamed"]         )) -        let result = try MCPTestHelpers.decodeResult(response)+        let result = try MCPTestHelpers.decodeSavedRecord(response)         #expect(result["description"] as? String == "current")         #expect(task.taskDescription == "current")     }@@ -535,12 +536,12 @@ struct MCPUpdateTaskTests {         )         let taskDisplayId = try #require(task.permanentDisplayId) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: ["displayId": taskDisplayId, "name": "Renamed"]         )) -        let result = try MCPTestHelpers.decodeResult(response)+        let result = try MCPTestHelpers.decodeSavedRecord(response)         #expect(result["type"] as? String == "bug")         #expect(task.type == .bug)     }@@ -554,12 +555,12 @@ struct MCPUpdateTaskTests {         )         let taskDisplayId = try #require(task.permanentDisplayId) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: ["displayId": taskDisplayId, "name": "Renamed"]         )) -        let result = try MCPTestHelpers.decodeResult(response)+        let result = try MCPTestHelpers.decodeSavedRecord(response)         let metadata = try #require(result["metadata"] as? [String: String])         #expect(metadata == ["a": "1"])         #expect(task.metadata == ["a": "1"])@@ -580,8 +581,8 @@ struct MCPUpdateTaskTests {         let taskDisplayId = try #require(task.permanentDisplayId)         let milestoneDisplayId = try #require(milestone.permanentDisplayId) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: [                 "displayId": taskDisplayId,                 "name": "Renamed",@@ -592,7 +593,7 @@ struct MCPUpdateTaskTests {             ]         )) -        let result = try MCPTestHelpers.decodeResult(response)+        let result = try MCPTestHelpers.decodeSavedRecord(response)         #expect(result["name"] as? String == "Renamed")         #expect(result["description"] as? String == "new desc")         #expect(result["type"] as? String == "chore")@@ -614,8 +615,8 @@ struct MCPUpdateTaskTests {         let taskDisplayId = try #require(task.permanentDisplayId)          // Valid name + invalid type → whole call rejected-        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: [                 "displayId": taskDisplayId,                 "name": "NewName",@@ -654,8 +655,8 @@ struct MCPUpdateTaskTests {         let taskDisplayId = try #require(task.permanentDisplayId)         let milestoneDisplayId = try #require(milestone.permanentDisplayId) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: [                 "displayId": taskDisplayId,                 "name": "NewName",@@ -688,12 +689,12 @@ struct MCPUpdateTaskTests {         let taskDisplayId = try #require(task.permanentDisplayId)         let originalLastStatusChange = task.lastStatusChangeDate -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: ["displayId": taskDisplayId]         )) -        let result = try MCPTestHelpers.decodeResult(response)+        let result = try MCPTestHelpers.decodeSavedRecord(response)         #expect(result["name"] as? String == "Task")         #expect(result["description"] as? String == "desc")         // No mutation → no timestamp tick from any side-effect@@ -711,8 +712,8 @@ struct MCPUpdateTaskTests {         )         let taskDisplayId = try #require(task.permanentDisplayId) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: ["displayId": taskDisplayId, "metadata": [String: String]()]         )) @@ -720,7 +721,7 @@ struct MCPUpdateTaskTests {         #expect(task.metadata.isEmpty)     } -    @Test func unknownFieldsIgnored_doNotBlockNoOp() async throws {+    @Test func unknownFieldsRejectWithoutMutation() async throws {         let env = try MCPTestHelpers.makeEnv()         let project = MCPTestHelpers.makeProject(in: env.context)         let task = try await env.taskService.createTask(@@ -728,15 +729,17 @@ struct MCPUpdateTaskTests {         )         let taskDisplayId = try #require(task.permanentDisplayId) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: ["displayId": taskDisplayId, "frob": "bar"]         )) -        let result = try MCPTestHelpers.decodeResult(response)-        #expect(result["name"] as? String == "Task")-        #expect(result["description"] as? String == "desc")+        #expect(try MCPTestHelpers.isError(response))+        #expect(try MCPTestHelpers.errorCode(response) == "INVALID_INPUT")+        #expect(try MCPTestHelpers.errorText(response).contains("frob"))         #expect(task.name == "Task")+        #expect(task.taskDescription == "desc")+        #expect(try env.context.fetch(FetchDescriptor<MCPWriteReceipt>()).isEmpty)     }      // MARK: - Milestone Parity (AC 7.x)@@ -753,8 +756,8 @@ struct MCPUpdateTaskTests {         let taskDisplayId = try #require(task.permanentDisplayId)         let milestoneDisplayId = try #require(milestone.permanentDisplayId) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: [                 "displayId": taskDisplayId,                 "name": "Renamed",@@ -778,19 +781,19 @@ struct MCPUpdateTaskTests {         #expect(task.milestone == nil)         let taskDisplayId = try #require(task.permanentDisplayId) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: ["displayId": taskDisplayId, "clearMilestone": true]         )) -        let result = try MCPTestHelpers.decodeResult(response)+        let result = try MCPTestHelpers.decodeSavedRecord(response)         #expect(result["milestone"] == nil, "Response should omit milestone when nil")         #expect(task.milestone == nil)     }      // MARK: - Response Shape (AC 9.1) -    @Test func responseOmitsClearedDescriptionAndMetadata() async throws {+    @Test func responseExposesClearedDescriptionAndMetadata() async throws {         let env = try MCPTestHelpers.makeEnv()         let project = MCPTestHelpers.makeProject(in: env.context)         let task = try await env.taskService.createTask(@@ -799,8 +802,8 @@ struct MCPUpdateTaskTests {         )         let taskDisplayId = try #require(task.permanentDisplayId) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: [                 "displayId": taskDisplayId,                 "description": "",@@ -808,12 +811,14 @@ struct MCPUpdateTaskTests {             ]         )) -        let result = try MCPTestHelpers.decodeResult(response)-        #expect(result["description"] == nil)-        #expect(result["metadata"] == nil)+        let result = try MCPTestHelpers.decodeSavedRecord(response)+        #expect(result["description"] is NSNull)+        #expect((result["metadata"] as? [String: String])?.isEmpty == true)+        #expect(task.taskDescription == nil)+        #expect(task.metadata.isEmpty)     } -    @Test func responseExcludesCommentsAndDateFields() async throws {+    @Test func responseIncludesSavedCommentsAndDateFields() async throws {         let env = try MCPTestHelpers.makeEnv()         let project = MCPTestHelpers.makeProject(in: env.context)         let task = try await env.taskService.createTask(@@ -824,15 +829,17 @@ struct MCPUpdateTaskTests {         )         let taskDisplayId = try #require(task.permanentDisplayId) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: ["displayId": taskDisplayId, "name": "Renamed"]         )) -        let result = try MCPTestHelpers.decodeResult(response)-        #expect(result["comments"] == nil)-        #expect(result["creationDate"] == nil)-        #expect(result["lastStatusChangeDate"] == nil)+        let result = try MCPTestHelpers.decodeSavedRecord(response)+        let comments = try #require(result["comments"] as? [[String: Any]])+        #expect(comments.count == 1)+        #expect(comments.first?["content"] as? String == "First")+        #expect(result["creationDate"] is String)+        #expect(result["lastStatusChangeDate"] is String)         #expect(result["completionDate"] == nil)     } 
Transit/TransitTests/MCPWriteContractTests.swift Added +54 / -0
diff --git a/Transit/TransitTests/MCPWriteContractTests.swift b/Transit/TransitTests/MCPWriteContractTests.swiftnew file mode 100644index 0000000..761a1d2--- /dev/null+++ b/Transit/TransitTests/MCPWriteContractTests.swift@@ -0,0 +1,54 @@+#if os(macOS)+import Foundation+import SwiftData+import Testing+@testable import Transit++@MainActor struct MCPWriteContractTests {+    @Test func allProtectedSchemasPublishRequiredSafety() {+        for definition in MCPToolDefinitions.coreTools+        where MCPWriteCommand.protectedTools.contains(definition.name) {+            #expect(definition.inputSchema.required?.contains("idempotencyKey") == true)+            #expect(definition.inputSchema.properties?["idempotencyKey"]?.pattern == "^[A-Za-z0-9._:-]{1,128}$")+            #expect(definition.inputSchema.additionalProperties == false)+            if MCPWriteCommand.revisionTools.contains(definition.name) {+                #expect(definition.inputSchema.required?.contains("expectedRevision") == true)+                #expect(definition.inputSchema.properties?["expectedRevision"]?.pattern == "^r1:[0-9a-f]{64}$")+            }+        }+    }++    @Test func exactIntegerBoundaryIsAccepted() throws {+        let args: [String: Any] = ["displayId": Int.max, "content": "C", "authorName": "A", "idempotencyKey": "max"]+        _ = try MCPWriteCommand.validate(tool: "add_comment", arguments: args)+        for value in [true, 1.5, Double(Int.max), NSNumber(value: UInt64.max)] as [Any] {+            var invalid = args+            invalid["displayId"] = value+            #expect(throws: (any Error).self) {+                try MCPWriteCommand.validate(tool: "add_comment", arguments: invalid)+            }+        }+    }++    @Test func malformedInputsRemainPreAcceptance() {+        let valid: [String: Any] = ["name": "P", "colorHex": "#112233", "idempotencyKey": "key"]+        for value in [true, 1, NSNull(), "", "key\n", String(repeating: "a", count: 129)] as [Any] {+            var args = valid+            args["idempotencyKey"] = value+            #expect(throws: (any Error).self) {+                try MCPWriteCommand.validate(tool: "create_project", arguments: args)+            }+        }+    }+}++extension MCPTestHelpers {+    static func freshWriteKey() -> String { UUID().uuidString }+    static func readRevision(_ task: TransitTask, in context: ModelContext) throws -> String {+        try MCPRecordSnapshot.task(task, in: context).revision+    }+    static func readRevision(_ milestone: Milestone) throws -> String {+        try MCPRecordSnapshot.milestone(milestone).revision+    }+}+#endif
Transit/TransitTests/MCPWriteCoordinatorTests.swift Added +198 / -0
diff --git a/Transit/TransitTests/MCPWriteCoordinatorTests.swift b/Transit/TransitTests/MCPWriteCoordinatorTests.swiftnew file mode 100644index 0000000..9416abd--- /dev/null+++ b/Transit/TransitTests/MCPWriteCoordinatorTests.swift@@ -0,0 +1,198 @@+#if os(macOS)+import Foundation+import SwiftData+import Testing+@testable import Transit++@MainActor @Suite(.serialized)+struct MCPWriteCoordinatorTests {+    @Test func requiredSafetyAndUnknownFieldsReserveNothing() throws {+        for tool in MCPWriteCommand.protectedTools {+            #expect(throws: (any Error).self) { try MCPWriteCommand.validate(tool: tool, arguments: [:]) }+            #expect(throws: (any Error).self) {+                try MCPWriteCommand.validate(tool: tool, arguments: ["idempotencyKey": "key", "unknown": 1])+            }+        }+    }++    // swiftlint:disable:next function_body_length+    @Test func malformedTerminalReplayFailsClosed() async throws {+        let fixture = try MCPWriteCoordinatorTestFixture()+        let services = fixture.services+        let coordinator = fixture.coordinator!+        let projectArgs: [String: Any] = [+            "name": "malformed P", "colorHex": "#112233", "idempotencyKey": "malformed-project"+        ]+        let project = try fixture.decode(await coordinator.execute(tool: "create_project", arguments: projectArgs))+        let task = try await services.tasks.createTask(+            name: "malformed T", description: nil, type: .feature,+            project: services.projects.findProject(id: UUID(uuidString: project["entityId"] as? String ?? "")!)+                .get())+        let statusArgs: [String: Any] = [+            "taskId": task.id.uuidString, "status": "done", "comment": "C",+            "authorName": "A", "expectedRevision": try MCPRecordSnapshot.task(task, in: services.context).revision,+            "idempotencyKey": "malformed-status"+        ]+        let status = try fixture.decode(+            await coordinator.execute(tool: "update_task_status", arguments: statusArgs))+        var conflictArgs = statusArgs+        conflictArgs["idempotencyKey"] = "malformed-conflict"+        let conflict = try fixture.decode(+            await coordinator.execute(tool: "update_task_status", arguments: conflictArgs))+        let milestone = try await services.milestones.createMilestone(+            name: "malformed M", description: nil, project: task.project!)+        let deleteArgs: [String: Any] = [+            "milestoneId": milestone.id.uuidString,+            "expectedRevision": try MCPRecordSnapshot.milestone(milestone).revision,+            "idempotencyKey": "malformed-delete"+        ]+        let deletion = try fixture.decode(+            await coordinator.execute(tool: "delete_milestone", arguments: deleteArgs))+        let rejectArgs: [String: Any] = [+            "name": "reject", "colorHex": "invalid", "idempotencyKey": "malformed-reject"+        ]+        let rejection = try fixture.decode(await coordinator.execute(tool: "create_project", arguments: rejectArgs))+        let cases: [((String, [String: Any]), ([String: Any], [String]))] = [+            (+                ("create_project", projectArgs),+                (+                    project,+                    [+                        "entityId", "record", "record.revision", "record.name", "completedAt", "replayExpiresAt",+                        "completedAtMismatch", "entityIdMismatch"+                    ]+                )+            ),+            (+                ("update_task_status", statusArgs),+                (status, ["record.comments", "record.creationDate", "comment", "comment.revision"])+            ),+            (+                ("delete_milestone", deleteArgs),+                (deletion, ["deleted", "recordBeforeDeletion", "recordBeforeDeletion.revision"])+            ),+            (("update_task_status", conflictArgs), (conflict, ["currentRecord", "currentRecord.revision"])),+            (("create_project", rejectArgs), (rejection, ["error", "error.code", "error.message", "retryAction"]))+        ]+        for ((tool, args), (original, fields)) in cases {+            let receipt = try services.context.fetch(FetchDescriptor<MCPWriteReceipt>()).first {+                $0.key == args["idempotencyKey"] as? String+            }!+            let saved = receipt.resultJSON!+            for field in fields {+                var malformed = original+                let components = field.split(separator: ".").map(String.init)+                if field == "completedAtMismatch" {+                    malformed["completedAt"] = MCPRecordSnapshot.timestamp(.distantPast)+                } else if field == "entityIdMismatch" {+                    malformed["entityId"] = UUID().uuidString+                } else if components.count == 2 {+                    var record = try #require(malformed[components[0]] as? [String: Any])+                    record.removeValue(forKey: components[1])+                    malformed[components[0]] = record+                } else {+                    malformed.removeValue(forKey: field)+                }+                receipt.resultJSON = try MCPWriteOutcome.encode(malformed)+                try services.context.save()+                let result = try fixture.decode(await coordinator.execute(tool: tool, arguments: args))+                #expect(result["outcome"] as? String == "uncertain")+                #expect((result["error"] as? [String: Any])?["code"] as? String == "OUTCOME_UNCERTAIN")+                #expect(result["retryAction"] as? String == "reconcile")+                #expect(receipt.resultJSON == (try MCPWriteOutcome.encode(malformed)))+                let files = try FileManager.default.contentsOfDirectory(+                    at: fixture.directory.appendingPathComponent("guards"),+                    includingPropertiesForKeys: nil)+                let bindings = try files.filter { $0.pathExtension == "json" }.map {+                    try JSONDecoder().decode(MCPLocalReservation.self, from: Data(contentsOf: $0))+                }+                #expect(bindings.contains { $0.tool == tool && $0.key == args["idempotencyKey"] as? String })+            }+            receipt.resultJSON = saved+            try services.context.save()+            let replay = try fixture.decode(await coordinator.execute(tool: tool, arguments: args))+            let identical = try MCPCanonicalJSON.encode(replay) == MCPCanonicalJSON.encode(original)+            #expect(identical)+        }+    }++    @Test func committedReplayPreservesSavedProjectionAfterEdit() async throws {+        let fixture = try MCPWriteCoordinatorTestFixture()+        let args: [String: Any] = ["name": " original ", "colorHex": "#112233", "idempotencyKey": "key"]+        let first = await fixture.coordinator.execute(tool: "create_project", arguments: args)+        let project = try #require(try fixture.owner.context.fetch(FetchDescriptor<Project>()).first)+        project.name = "changed later"+        try fixture.owner.context.save()+        let replay = await fixture.coordinator.execute(tool: "create_project", arguments: args)+        #expect(first.content.first?.text == replay.content.first?.text)+        #expect(try fixture.owner.context.fetch(FetchDescriptor<Project>()).count == 1)+    }++    @Test func staleStatusWithCommentPreservesInterveningEdit() async throws {+        let fixture = try MCPWriteCoordinatorTestFixture()+        let context = fixture.owner.context+        let project = try fixture.services.projects.createProject(+            name: "P", description: "", gitRepo: nil,+            colorHex: "#112233")+        let task = try await fixture.services.tasks.createTask(+            name: "T", description: nil, type: .feature, project: project)+        let oldRevision = try MCPRecordSnapshot.task(task, in: context).revision+        task.name = "UI edit"+        try context.save()+        let result = await fixture.coordinator.execute(+            tool: "update_task_status",+            arguments: [+                "taskId": task.id.uuidString, "status": "done", "comment": "must not appear", "authorName": "A",+                "expectedRevision": oldRevision, "idempotencyKey": "conflict"+            ])+        let envelope = try fixture.decode(result)+        #expect((envelope["error"] as? [String: Any])?["code"] as? String == "REVISION_CONFLICT")+        #expect(task.name == "UI edit" && task.status == .idea)+        #expect(try context.fetch(FetchDescriptor<Transit.Comment>()).isEmpty)+        #expect(envelope["replayExpiresAt"] is String)+    }++    @Test func missingReceiptDoesNotRunAgainAcrossRestart() async throws {+        let fixture = try MCPWriteCoordinatorTestFixture()+        let args: [String: Any] = ["name": "P", "colorHex": "#112233", "idempotencyKey": "missing"]+        _ = await fixture.coordinator.execute(tool: "create_project", arguments: args)+        let receipt = try #require(try fixture.owner.context.fetch(FetchDescriptor<MCPWriteReceipt>()).first)+        fixture.owner.context.delete(receipt)+        try fixture.owner.context.save()+        fixture.coordinator = nil+        fixture.coordinator = MCPWriteCoordinator(services: fixture.services, sidecarDirectory: fixture.directory)+        let envelope = try fixture.decode(+            await fixture.coordinator.execute(tool: "create_project", arguments: args))+        #expect(envelope["outcome"] as? String == "uncertain")+        #expect(envelope["retryAction"] as? String == "reconcile")+        #expect(try fixture.owner.context.fetch(FetchDescriptor<Project>()).count == 1)+    }+}++@MainActor private final class MCPWriteCoordinatorTestFixture {+    let owner: TestModelContainer+    let directory: URL+    let services: MCPWriteCommandServices+    var coordinator: MCPWriteCoordinator!++    init() throws {+        owner = try TestModelContainer()+        directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)+        let context = owner.context+        context.autosaveEnabled = false+        let allocator = DisplayIDAllocator(store: InMemoryCounterStore(), isCloudSyncActive: false)+        services = MCPWriteCommandServices(+            tasks: TaskService(modelContext: context, displayIDAllocator: allocator),+            projects: ProjectService(modelContext: context), comments: CommentService(modelContext: context),+            milestones: MilestoneService(modelContext: context, displayIDAllocator: allocator), context: context+        )+        coordinator = MCPWriteCoordinator(services: services, sidecarDirectory: directory)+    }++    deinit { try? FileManager.default.removeItem(at: directory) }++    func decode(_ result: MCPToolResult) throws -> [String: Any] {+        try #require(try JSONSerialization.jsonObject(with: Data(result.content[0].text.utf8)) as? [String: Any])+    }+}+#endif
Transit/TransitTests/MCPWriteLifecycleTests.swift Added +133 / -0
diff --git a/Transit/TransitTests/MCPWriteLifecycleTests.swift b/Transit/TransitTests/MCPWriteLifecycleTests.swiftnew file mode 100644index 0000000..5e00e54--- /dev/null+++ b/Transit/TransitTests/MCPWriteLifecycleTests.swift@@ -0,0 +1,133 @@+#if os(macOS)+import Foundation+import HTTPTypes+import SwiftData+import Testing+@testable import Transit++@MainActor @Suite(.serialized)+struct MCPWriteLifecycleTests {+    @Test func protectedNotificationPersistsAndReplaysAcrossResponderReplacement() async throws {+        let env = try MCPTestHelpers.makeEnv()+        let key = MCPTestHelpers.freshWriteKey()+        let args: [String: Any] = ["name": "notification", "colorHex": "#123456", "idempotencyKey": key]+        let notification: [String: Any] = ["jsonrpc": "2.0", "method": "tools/call",+                                          "params": ["name": "create_project", "arguments": args]]+        let data = try JSONSerialization.data(withJSONObject: notification)+        let body = try #require(String(data: data, encoding: .utf8))+        let response = try await MCPTestHelpers.respond(handler: env.handler, contentType: "application/json",+                                                        body: body, loggerLabel: "write.notification")+        #expect(response.status == .accepted)+        #expect(response.body.isEmpty)+        let retry: [String: Any] = ["jsonrpc": "2.0", "id": 7, "method": "tools/call",+                                   "params": ["name": "create_project", "arguments": args]]+        let retryData = try JSONSerialization.data(withJSONObject: retry)+        let retryBody = try #require(String(data: retryData, encoding: .utf8))+        let replay = try await MCPTestHelpers.respond(handler: env.handler, contentType: "application/json",+                                                      body: retryBody, loggerLabel: "write.notification.replay")+        let envelope = try MCPTestHelpers.decodeHTTPToolResult(try #require(replay.json as? [String: Any]))+        #expect(envelope["outcome"] as? String == "committed")+        #expect(try env.context.fetch(FetchDescriptor<Project>()).count == 1)+        #expect(try env.context.fetch(FetchDescriptor<MCPWriteReceipt>()).count == 1)+    }++    @Test func orderedBatchRetainsFirstCommitWhenSecondWriteRejects() async throws {+        let env = try MCPTestHelpers.makeEnv()+        let body = """+        [+          {"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"create_project",+          "arguments":{"name":"first","colorHex":"#123456","idempotencyKey":"batch-first"}}},+          {"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"create_project",+          "arguments":{"name":"first","colorHex":"#123456","idempotencyKey":"batch-second"}}}+        ]+        """+        let response = try await MCPTestHelpers.respond(handler: env.handler, contentType: "application/json",+                                                        body: body, loggerLabel: "write.batch")+        let objects = try #require(response.json as? [[String: Any]])+        #expect(objects.count == 2)+        #expect(try MCPTestHelpers.decodeHTTPToolResult(objects[0])["outcome"] as? String == "committed")+        #expect(try MCPTestHelpers.decodeHTTPToolResult(objects[1])["outcome"] as? String == "rejected")+        #expect(try env.context.fetch(FetchDescriptor<Project>()).map(\.name) == ["first"])+    }++    @Test func localAndSeparatelySavedChangesInvalidateObservedRevision() async throws {+        let env = try MCPTestHelpers.makeEnv()+        let project = MCPTestHelpers.makeProject(in: env.context)+        let task = try await env.taskService.createTask(name: "original", description: nil, type: .feature,+                                                       project: project)+        let original = try MCPTestHelpers.readRevision(task, in: env.context)+        try env.taskService.updateTask(task, name: "UI edit")+        #expect(try MCPTestHelpers.readRevision(task, in: env.context) != original)+        let peer = ModelContext(env.context.container)+        let taskID = task.id+        let descriptor = FetchDescriptor<TransitTask>(predicate: #Predicate { $0.id == taskID })+        let imported = try #require(try peer.fetch(descriptor).first)+        let before = try MCPRecordSnapshot.task(imported, in: peer).revision+        imported.name = "separately saved"+        try peer.save()+        let observer = ModelContext(env.context.container)+        let observed = try #require(try observer.fetch(descriptor).first)+        #expect(try MCPRecordSnapshot.task(observed, in: observer).revision != before)+    }++    @Test func disconnectedRequestKeepsAcceptedCancellationForReplay() async throws {+        let counter = MCPWriteLifecycleCounter()+        let env = try MCPTestHelpers.makeEnv(taskCounterStore: counter)+        let project = MCPTestHelpers.makeProject(in: env.context)+        let args: [String: Any] = ["name": "disconnect", "type": "feature",+                                  "projectId": project.id.uuidString, "idempotencyKey": "disconnect"]+        let request = MCPTestHelpers.toolCallRequest(tool: "create_task", arguments: args)+        let object: [String: Any] = ["jsonrpc": "2.0", "id": 1, "method": "tools/call",+                                    "params": ["name": "create_task", "arguments": args]]+        let data = try JSONSerialization.data(withJSONObject: object)+        let body = try #require(String(data: data, encoding: .utf8))+        let connection = Task {+            try await MCPTestHelpers.respond(handler: env.handler, contentType: "application/json",+                                              body: body, loggerLabel: "write.disconnect")+        }+        await counter.waitForLoad()+        connection.cancel()+        await counter.release()+        _ = try? await connection.value+        let replay = await env.handler.handle(request)+        let result = try MCPTestHelpers.decodeResult(replay)+        #expect(result["accepted"] as? Bool == true)+        #expect(try MCPTestHelpers.errorCode(replay) == "CANCELLED")+        #expect(try env.context.fetch(FetchDescriptor<TransitTask>()).isEmpty)+        #expect(try env.context.fetch(FetchDescriptor<MCPWriteReceipt>()).count == 1)+    }++    @Test func missingSafetyIsRejectedWithoutReservingAKey() async throws {+        let env = try MCPTestHelpers.makeEnv()+        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(+            tool: "create_project", arguments: ["name": "raw", "colorHex": "#123456"]+        ))+        let result = try MCPTestHelpers.decodeResult(response)+        #expect((result["error"] as? [String: Any])?["code"] as? String == "INVALID_INPUT")+        #expect(result["accepted"] as? Bool == false)+        #expect(try env.context.fetch(FetchDescriptor<MCPWriteReceipt>()).isEmpty)+    }+}+actor MCPWriteLifecycleCounter: DisplayIDAllocator.CounterStore {+    private var continuation: CheckedContinuation<Void, Never>?+    private var observer: CheckedContinuation<Void, Never>?+    private var started = false++    func waitForLoad() async {+        if started { return }+        await withCheckedContinuation { observer = $0 }+    }++    func release() { continuation?.resume(); continuation = nil }++    func loadCounter() async throws -> DisplayIDAllocator.CounterSnapshot {+        started = true+        observer?.resume()+        observer = nil+        await withCheckedContinuation { continuation = $0 }+        return .init(nextDisplayID: 1, changeTag: nil)+    }++    func saveCounter(nextDisplayID: Int, expectedChangeTag: String?) async throws { }+}+#endif
Transit/TransitTests/MCPWritePersistenceProbeTests.swift Added +78 / -0
diff --git a/Transit/TransitTests/MCPWritePersistenceProbeTests.swift b/Transit/TransitTests/MCPWritePersistenceProbeTests.swiftnew file mode 100644index 0000000..d87ae7d--- /dev/null+++ b/Transit/TransitTests/MCPWritePersistenceProbeTests.swift@@ -0,0 +1,78 @@+import Foundation+import SwiftData+import Testing+@testable import Transit++@MainActor @Suite(.serialized)+struct MCPWritePersistenceProbeTests {+    private var schema: Schema {+        Schema([Project.self, TransitTask.self, Comment.self, Milestone.self,+                SyncHeartbeat.self, MCPWriteReceipt.self])+    }++    private func diskFixture(at url: URL, writable: Bool = true) throws -> TestModelContainer {+        let configuration = ModelConfiguration(schema: schema, url: url,+                                               allowsSave: writable, cloudKitDatabase: .none)+        let fixture = try TestModelContainer(schema: schema, configurations: [configuration])+        fixture.context.autosaveEnabled = false+        return fixture+    }++    @Test func completedReceiptAndEffectReopenTogether() throws {+        let directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)+        try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)+        defer { try? FileManager.default.removeItem(at: directory) }+        let url = directory.appendingPathComponent("test.store")+        let owner = try diskFixture(at: url)+        let context = owner.context+        let project = Project(name: "Project", description: "", gitRepo: nil, colorHex: "#000000")+        let task = TransitTask(name: "Task", type: .feature, project: project, displayID: .permanent(1))+        context.insert(project)+        context.insert(task)+        let receipt = MCPWriteReceipt(localScopeID: "scope", tool: "update_task_status", key: "key",+                                      requestJSON: "{}", acceptedAt: Date())+        context.insert(receipt)+        try context.save()+        task.status = .done+        context.insert(Transit.Comment(content: "saved", authorName: "agent", isAgent: true, task: task))+        receipt.stateRawValue = "committed"+        receipt.completedAt = Date()+        receipt.expiresAt = receipt.completedAt!.addingTimeInterval(604800)+        receipt.resultJSON = "{\"outcome\":\"committed\"}"+        receipt.resultIsError = false+        try context.save()+        let reopened = try diskFixture(at: url)+        #expect(try reopened.context.fetch(FetchDescriptor<TransitTask>())[0].status == .done)+        #expect(try reopened.context.fetch(FetchDescriptor<Transit.Comment>()).count == 1)+        let saved = try reopened.context.fetch(FetchDescriptor<MCPWriteReceipt>())[0]+        #expect(saved.resultJSON == receipt.resultJSON)+        #expect(saved.stateRawValue == "committed")+    }++    @Test func actualReadOnlySaveFailureLeavesNoDurableEffect() throws {+        let directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)+        try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)+        defer { try? FileManager.default.removeItem(at: directory) }+        let url = directory.appendingPathComponent("readonly.store")+        let owner = try diskFixture(at: url)+        let project = Project(name: "Original", description: "", gitRepo: nil, colorHex: "#000000")+        owner.context.insert(project)+        try owner.context.save()+        let readOnly = try diskFixture(at: url, writable: false)+        let live = try readOnly.context.fetch(FetchDescriptor<Project>())[0]+        live.name = "Not saved"+        let receipt = MCPWriteReceipt(localScopeID: "scope", tool: "create_project", key: "failure",+                                      requestJSON: "{}", acceptedAt: Date())+        readOnly.context.insert(receipt)+        #expect(throws: (any Error).self) { try readOnly.context.save() }+        readOnly.context.delete(receipt)+        readOnly.context.safeRollback()+        let reopened = try diskFixture(at: url)+        #expect(try reopened.context.fetch(FetchDescriptor<Project>())[0].name == "Original")+        #expect(try reopened.context.fetch(FetchDescriptor<MCPWriteReceipt>()).isEmpty)+        let saved = try reopened.context.fetch(FetchDescriptor<Project>())[0]+        saved.name = "Unrelated"+        try reopened.context.save()+        #expect(try reopened.context.fetch(FetchDescriptor<MCPWriteReceipt>()).isEmpty)+    }+}
Transit/TransitTests/MCPWriteServerLifecycleTests.swift Added +42 / -0
diff --git a/Transit/TransitTests/MCPWriteServerLifecycleTests.swift b/Transit/TransitTests/MCPWriteServerLifecycleTests.swiftnew file mode 100644index 0000000..0f380b9--- /dev/null+++ b/Transit/TransitTests/MCPWriteServerLifecycleTests.swift@@ -0,0 +1,42 @@+#if os(macOS)+import Foundation+import SwiftData+import Testing+@testable import Transit++extension MCPServerLifecycleTests {+    @Test func listenerRestartKeepsAcceptedWriteAndScopeLock() async throws {+        let counter = MCPWriteLifecycleCounter()+        let env = try MCPTestHelpers.makeEnv(taskCounterStore: counter)+        let project = MCPTestHelpers.makeProject(in: env.context)+        let server = MCPServer(toolHandler: env.handler)+        let port = try availableLoopbackPort()+        await server.start(port: port)+        try #require(await waitUntilListening(port: port))+        let args: [String: Any] = ["name": "restart", "type": "feature",+                                  "projectId": project.id.uuidString, "idempotencyKey": "restart-write"]+        let operation = Task {+            await env.handler.handle(MCPTestHelpers.toolCallRequest(tool: "create_task", arguments: args))+        }+        await counter.waitForLoad()+        await server.restart(port: port)+        #expect(await waitUntilListening(port: port))+        let competing = MCPWriteCoordinator(+            services: MCPWriteCommandServices(tasks: env.taskService, projects: env.projectService,+                comments: env.commentService, milestones: env.milestoneService, context: env.context),+            sidecarDirectory: env.sidecarDirectory+        )+        let busy = await competing.execute(tool: "create_project", arguments: [+            "name": "blocked", "colorHex": "#123456", "idempotencyKey": "competing"+        ])+        #expect(busy.content.first?.text.contains("STORE_BUSY") == true)+        await counter.release()+        let response = await operation.value+        #expect(try MCPTestHelpers.decodeResult(response)["outcome"] as? String == "committed")+        let replay = await env.handler.handle(MCPTestHelpers.toolCallRequest(tool: "create_task", arguments: args))+        #expect(try MCPTestHelpers.decodeResult(replay)["outcome"] as? String == "committed")+        #expect(try env.context.fetch(FetchDescriptor<TransitTask>()).count == 1)+        await server.stop()+    }+}+#endif
Transit/TransitTests/MilestoneCrossDeviceUniquenessTests.swift Modified +2 / -2
diff --git a/Transit/TransitTests/MilestoneCrossDeviceUniquenessTests.swift b/Transit/TransitTests/MilestoneCrossDeviceUniquenessTests.swiftindex ed83a50..4233bff 100644--- a/Transit/TransitTests/MilestoneCrossDeviceUniquenessTests.swift+++ b/Transit/TransitTests/MilestoneCrossDeviceUniquenessTests.swift@@ -158,8 +158,8 @@ struct MilestoneCrossDeviceUniquenessTests {         ))         try env.context.save() -        let request = MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let request = try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: [                 "name": "Must not be created",                 "type": "feature",
Transit/TransitTests/MilestoneNameLookupStorageFailureSurfaceTests.swift Modified +9 / -6
diff --git a/Transit/TransitTests/MilestoneNameLookupStorageFailureSurfaceTests.swift b/Transit/TransitTests/MilestoneNameLookupStorageFailureSurfaceTests.swiftindex 26bc4e0..11048af 100644--- a/Transit/TransitTests/MilestoneNameLookupStorageFailureSurfaceTests.swift+++ b/Transit/TransitTests/MilestoneNameLookupStorageFailureSurfaceTests.swift@@ -126,12 +126,12 @@ struct MilestoneNameLookupFailureTests {         let taskDisplayId = try #require(task.permanentDisplayId)         let expectedHint = "Failed to look up milestone: simulated milestone name lookup fetch failure" -        let createResponse = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let createResponse = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: ["projectId": project.id.uuidString, "name": "New", "type": "feature", "milestone": "Sprint"]         ))-        let updateResponse = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let updateResponse = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: ["displayId": taskDisplayId, "milestone": "Sprint"]         ))         let queryResponse = await env.handler.handle(MCPTestHelpers.toolCallRequest(@@ -139,10 +139,13 @@ struct MilestoneNameLookupFailureTests {             arguments: ["projectId": project.id.uuidString, "milestone": "Sprint"]         )) -        for response in [createResponse, updateResponse, queryResponse] {+        for response in [createResponse, updateResponse] {             #expect(try MCPTestHelpers.isError(response))-            #expect(try MCPTestHelpers.errorText(response) == expectedHint)+            #expect(try MCPTestHelpers.errorCode(response) == "INTERNAL_ERROR")+            #expect(try MCPTestHelpers.errorText(response).contains("simulated milestone name lookup fetch failure"))         }+        #expect(try MCPTestHelpers.isError(queryResponse))+        #expect(try MCPTestHelpers.errorText(queryResponse) == expectedHint)         #expect(try env.context.fetch(FetchDescriptor<TransitTask>()).count == 1)         #expect(task.name == "Existing")         #expect(task.milestone == nil)
Transit/TransitTests/NonIntegerMilestoneDisplayIdTests.swift Modified +8 / -8
diff --git a/Transit/TransitTests/NonIntegerMilestoneDisplayIdTests.swift b/Transit/TransitTests/NonIntegerMilestoneDisplayIdTests.swiftindex f790e5b..816c243 100644--- a/Transit/TransitTests/NonIntegerMilestoneDisplayIdTests.swift+++ b/Transit/TransitTests/NonIntegerMilestoneDisplayIdTests.swift@@ -49,8 +49,8 @@ struct NonIntegerMilestoneDisplayIdTests {         let env = try MCPTestHelpers.makeEnv()         let project = MCPTestHelpers.makeProject(in: env.context) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: [                 "name": "Task",                 "type": "bug",@@ -68,8 +68,8 @@ struct NonIntegerMilestoneDisplayIdTests {         let env = try MCPTestHelpers.makeEnv()         let project = MCPTestHelpers.makeProject(in: env.context) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: [                 "name": "Task",                 "type": "bug",@@ -92,8 +92,8 @@ struct NonIntegerMilestoneDisplayIdTests {             name: "Task", description: nil, type: .feature, project: project         ) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: [                 "displayId": task.permanentDisplayId!,                 "milestoneDisplayId": "abc"@@ -112,8 +112,8 @@ struct NonIntegerMilestoneDisplayIdTests {             name: "Task", description: nil, type: .feature, project: project         ) -        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task",+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",             arguments: [                 "displayId": task.permanentDisplayId!,                 "milestoneDisplayId": 1.5
Transit/TransitTests/NumericDisplayIdParsingTests.swift Modified +7 / -7
diff --git a/Transit/TransitTests/NumericDisplayIdParsingTests.swift b/Transit/TransitTests/NumericDisplayIdParsingTests.swiftindex 3e7d486..cee733d 100644--- a/Transit/TransitTests/NumericDisplayIdParsingTests.swift+++ b/Transit/TransitTests/NumericDisplayIdParsingTests.swift@@ -141,15 +141,15 @@ struct NumericDisplayIdMCPTests {          // Double value simulates what JSONSerialization produces from {"displayId": 42}         let response = await env.handler.handle(-            MCPTestHelpers.toolCallRequest(-                tool: "update_task_status",+            try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task_status",                 arguments: ["displayId": 42 as Double, "status": "planning"]             )         )          let isErr = try MCPTestHelpers.isError(response)         #expect(!isErr, "Expected success but got error")-        let result = try MCPTestHelpers.decodeResult(response)+        let result = try MCPTestHelpers.decodeSavedRecord(response)         #expect(result["status"] as? String == "planning")     } @@ -204,8 +204,8 @@ struct NumericDisplayIdMCPTests {         env.context.insert(milestone)          let response = await env.handler.handle(-            MCPTestHelpers.toolCallRequest(-                tool: "create_task",+            try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",                 arguments: [                     "name": "New task",                     "type": "feature",@@ -235,8 +235,8 @@ struct NumericDisplayIdMCPTests {         env.context.insert(milestone)          let response = await env.handler.handle(-            MCPTestHelpers.toolCallRequest(-                tool: "update_task",+            try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task",                 arguments: ["displayId": 42 as Double, "milestoneDisplayId": 1 as Double]             )         )
Transit/TransitTests/ProjectLookupStorageFailureSurfaceTests.swift Modified +4 / -4
diff --git a/Transit/TransitTests/ProjectLookupStorageFailureSurfaceTests.swift b/Transit/TransitTests/ProjectLookupStorageFailureSurfaceTests.swiftindex 96e21e1..fc95282 100644--- a/Transit/TransitTests/ProjectLookupStorageFailureSurfaceTests.swift+++ b/Transit/TransitTests/ProjectLookupStorageFailureSurfaceTests.swift@@ -82,16 +82,16 @@ struct ProjectLookupStorageFailureSurfaceTests {         let env = try MCPTestHelpers.makeEnv(projectFetcher: FailingProjectFetcher())         let projectID = UUID().uuidString -        let createTask = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_task",+        let createTask = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_task",             arguments: ["projectId": projectID, "name": "Task", "type": "feature"]         ))         let queryTasks = await env.handler.handle(MCPTestHelpers.toolCallRequest(             tool: "query_tasks",             arguments: ["projectId": projectID]         ))-        let createMilestone = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "create_milestone",+        let createMilestone = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "create_milestone",             arguments: ["projectId": projectID, "name": "Milestone"]         ))         let queryMilestones = await env.handler.handle(MCPTestHelpers.toolCallRequest(
Transit/TransitTests/SyncDisabledGatingTests.swift Modified +12 / -4
diff --git a/Transit/TransitTests/SyncDisabledGatingTests.swift b/Transit/TransitTests/SyncDisabledGatingTests.swiftindex 8e8e6ca..fe35cb3 100644--- a/Transit/TransitTests/SyncDisabledGatingTests.swift+++ b/Transit/TransitTests/SyncDisabledGatingTests.swift@@ -67,7 +67,9 @@ struct SyncDisabledGatingTests {      @Test("Fallback container outcome disables counters while preserving interactive writes")     func fallbackOutcomeDisablesCounterUseWhileInteractiveWritesRemainAvailable() async throws {-        let schema = Schema([Project.self, TransitTask.self, Comment.self, Milestone.self, SyncHeartbeat.self])+        let schema = Schema([+            Project.self, TransitTask.self, Comment.self, Milestone.self, SyncHeartbeat.self, MCPWriteReceipt.self+        ])         let config = ModelConfiguration(             schema: schema,             isStoredInMemoryOnly: true,@@ -116,7 +118,9 @@ struct SyncDisabledGatingTests {      @Test("Bootstrap derivation preserves active and preference-disabled modes after a healthy outcome")     func bootstrapDerivationPreservesHealthyModes() {-        let schema = Schema([Project.self, TransitTask.self, Comment.self, Milestone.self, SyncHeartbeat.self])+        let schema = Schema([+            Project.self, TransitTask.self, Comment.self, Milestone.self, SyncHeartbeat.self, MCPWriteReceipt.self+        ])         let config = ModelConfiguration(             schema: schema,             isStoredInMemoryOnly: true,@@ -251,7 +255,9 @@ struct SyncDisabledGatingTests {         withSavedDefaults {             UserDefaults.standard.set(false, forKey: "syncEnabled")             let manager = SyncManager()-            let schema = Schema([Project.self, TransitTask.self, Comment.self, Milestone.self, SyncHeartbeat.self])+            let schema = Schema([+                Project.self, TransitTask.self, Comment.self, Milestone.self, SyncHeartbeat.self, MCPWriteReceipt.self+            ])              _ = manager.makeModelConfiguration(schema: schema) @@ -265,7 +271,9 @@ struct SyncDisabledGatingTests {         withSavedDefaults {             UserDefaults.standard.set(true, forKey: "syncEnabled")             let manager = SyncManager()-            let schema = Schema([Project.self, TransitTask.self, Comment.self, Milestone.self, SyncHeartbeat.self])+            let schema = Schema([+                Project.self, TransitTask.self, Comment.self, Milestone.self, SyncHeartbeat.self, MCPWriteReceipt.self+            ])             _ = manager.makeModelConfiguration(schema: schema)             #expect(manager.isCloudSyncActive == true) 
Transit/TransitTests/TestModelContainer.swift Modified +3 / -1
diff --git a/Transit/TransitTests/TestModelContainer.swift b/Transit/TransitTests/TestModelContainer.swiftindex a380989..cdf062f 100644--- a/Transit/TransitTests/TestModelContainer.swift+++ b/Transit/TransitTests/TestModelContainer.swift@@ -19,7 +19,9 @@ struct TestModelContainer {     private static var retainedContainers: [ModelContainer] = []      init() throws {-        let schema = Schema([Project.self, TransitTask.self, Comment.self, Milestone.self, SyncHeartbeat.self])+        let schema = Schema([+            Project.self, TransitTask.self, Comment.self, Milestone.self, SyncHeartbeat.self, MCPWriteReceipt.self+        ])         let config = ModelConfiguration(             "TransitTests-\(UUID().uuidString)",             schema: schema,
Transit/TransitTests/UpdateTaskAllFieldsParityTests.swift Modified +50 / -26
diff --git a/Transit/TransitTests/UpdateTaskAllFieldsParityTests.swift b/Transit/TransitTests/UpdateTaskAllFieldsParityTests.swiftindex 058acc0..00778ce 100644--- a/Transit/TransitTests/UpdateTaskAllFieldsParityTests.swift+++ b/Transit/TransitTests/UpdateTaskAllFieldsParityTests.swift@@ -4,28 +4,8 @@ import SwiftData import Testing @testable import Transit -/// Cross-surface parity tests for the `update_task` MCP tool and-/// `UpdateTaskIntent` App Intent (T-650 AC 8.1).-///-/// Both surfaces share `TaskUpdateValidator` and-/// `IntentHelpers.taskUpdateResponseDict`, so structural equality of the-/// success response is guaranteed by construction. These tests make that-/// contract explicit, so a future divergence (an extra key in one surface, a-/// JSON serialization quirk, etc.) is caught at test time rather than-/// silently changing the wire format for one caller.-///-/// Strategy: each test prepares a single task and a single set of update args,-/// then invokes both surfaces against that same task in the same context. The-/// first call mutates the task; the second call sees the post-mutation state-/// and either:-///   - re-applies the same change (idempotent, response unchanged), or-///   - is a true no-op for identifier-only cases.-/// Either way, both responses are computed from the task's final model state-/// via the shared response builder, so the dictionaries must match exactly.-///-/// Error-response parity is explicitly NOT asserted here — AC 5.2 permits the-/// two surfaces to surface different error messages for the same invalid-/// input. Success-only coverage is what this test exists for.+/// MCP's protected envelope contains a full saved record. App Intents retain their+/// existing response shape; compare every intended update field across the surfaces. @MainActor @Suite(.serialized) struct UpdateTaskAllFieldsParityTests { @@ -37,6 +17,7 @@ struct UpdateTaskAllFieldsParityTests {     private func assertParity(         mcp mcpJSON: String,         intent intentJSON: String,+        task: TransitTask,         sourceLocation: SourceLocation = #_sourceLocation     ) throws {         let mcpData = try #require(mcpJSON.data(using: .utf8))@@ -63,7 +44,12 @@ struct UpdateTaskAllFieldsParityTests {             sourceLocation: sourceLocation         ) -        let mcpNS = mcpDict as NSDictionary+        #expect(mcpDict["outcome"] as? String == "committed", sourceLocation: sourceLocation)+        #expect(mcpDict["accepted"] as? Bool == true, sourceLocation: sourceLocation)+        let record = try #require(mcpDict["record"] as? [String: Any])+        #expect((record["revision"] as? String)?.hasPrefix("r1:") == true, sourceLocation: sourceLocation)+        let domain = try intentDomainRecord(record, task: task, sourceLocation: sourceLocation)+        let mcpNS = domain as NSDictionary         let intentNS = intentDict as NSDictionary         #expect(             mcpNS == intentNS,@@ -88,8 +74,8 @@ struct UpdateTaskAllFieldsParityTests {         env: MCPTestEnv,         arguments: [String: Any]     ) async throws -> String {-        let response = await env.handler.handle(MCPTestHelpers.toolCallRequest(-            tool: "update_task", arguments: arguments+        let response = await env.handler.handle(try MCPTestHelpers.protectedToolCallRequest(+            in: env.context, tool: "update_task", arguments: arguments         ))         return try mcpResponseText(response)     }@@ -122,14 +108,25 @@ struct UpdateTaskAllFieldsParityTests {         arguments: [String: Any],         sourceLocation: SourceLocation = #_sourceLocation     ) async throws {+        let task = try env.taskService.resolveTask(from: arguments)         let intentInput = try encodeArgsAsJSON(arguments)         let mcpJSON = try await callMCP(env: env, arguments: arguments)         let intentJSON = callIntent(env: env, inputJSON: intentInput)-        try assertParity(mcp: mcpJSON, intent: intentJSON, sourceLocation: sourceLocation)+        try assertParity(mcp: mcpJSON, intent: intentJSON, task: task, sourceLocation: sourceLocation)     }      // MARK: - Per-Field Parity +    @Test func provisionalTaskWithoutProject_parity() async throws {+        let env = try MCPTestHelpers.makeEnv()+        let project = MCPTestHelpers.makeProject(in: env.context)+        let task = TransitTask(name: "Orphan", type: .feature, project: project, displayID: .provisional)+        task.project = nil+        env.context.insert(task)+        try env.context.save()+        try await runParityCase(env: env, arguments: ["taskId": task.id.uuidString, "name": "Renamed"])+    }+     @Test func updateName_parity() async throws {         let env = try MCPTestHelpers.makeEnv()         let project = MCPTestHelpers.makeProject(in: env.context)@@ -324,4 +321,31 @@ struct UpdateTaskAllFieldsParityTests {     } } +extension UpdateTaskAllFieldsParityTests {+    /// Verify the full MCP values first, then apply the Intent serializer's omission policy.+    private func intentDomainRecord(+        _ record: [String: Any], task: TransitTask, sourceLocation: SourceLocation+    ) throws -> [String: Any] {+        let domainFields: Set<String> = ["taskId", "name", "type", "priority", "status", "displayId",+                                         "projectId", "projectName", "description", "metadata", "milestone"]+        var domain = record.filter { domainFields.contains($0.key) }+        if let milestone = domain["milestone"] as? [String: Any] {+            domain["milestone"] = milestone.filter { ["milestoneId", "name", "displayId"].contains($0.key) }+        }+        if let description = task.taskDescription {+            #expect(record["description"] as? String == description, sourceLocation: sourceLocation)+            if description.isEmpty { domain.removeValue(forKey: "description") }+        } else {+            #expect(record["description"] is NSNull, sourceLocation: sourceLocation)+            domain.removeValue(forKey: "description")+        }+        let metadata = try #require(record["metadata"] as? [String: String])+        #expect(metadata == task.metadata, sourceLocation: sourceLocation)+        if metadata.isEmpty { domain.removeValue(forKey: "metadata") }+        // Both serializers omit nil display/project IDs, names and milestone assignment.+        // Those fields stay in the comparison, including their presence or absence.+        return domain+    }+}+ #endif
tests/mcp-write-probe/CoordinatorProbe.swift Added +349 / -0
diff --git a/tests/mcp-write-probe/CoordinatorProbe.swift b/tests/mcp-write-probe/CoordinatorProbe.swiftnew file mode 100644index 0000000..37224ca--- /dev/null+++ b/tests/mcp-write-probe/CoordinatorProbe.swift@@ -0,0 +1,349 @@+import Foundation+import SwiftData++@main+struct MCPWriteCoordinatorProbe {+    // swiftlint:disable:next function_body_length+    @MainActor static func main() async throws {+        let directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)+        try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)+        defer { try? FileManager.default.removeItem(at: directory) }+        let schema = Schema([+            Project.self, TransitTask.self, Comment.self, Milestone.self,+            SyncHeartbeat.self, MCPWriteReceipt.self+        ])+        let configuration = ModelConfiguration(+            schema: schema, url: directory.appendingPathComponent("probe.store"),+            cloudKitDatabase: .none)+        let container = try ModelContainer(for: schema, configurations: configuration)+        let context = container.mainContext+        context.autosaveEnabled = false+        let allocator = DisplayIDAllocator(store: CoordinatorCounter(), isCloudSyncActive: false)+        let tasks = TaskService(modelContext: context, displayIDAllocator: allocator)+        let projects = ProjectService(modelContext: context)+        let comments = CommentService(modelContext: context)+        let milestones = MilestoneService(modelContext: context, displayIDAllocator: allocator)+        let services = MCPWriteCommandServices(+            tasks: tasks, projects: projects, comments: comments,+            milestones: milestones, context: context)+        var coordinator: MCPWriteCoordinator? = MCPWriteCoordinator(+            services: services, sidecarDirectory: directory.appendingPathComponent("sidecar")+        )+        let projectArgs: [String: Any] = ["name": " P ", "colorHex": "#112233", "idempotencyKey": "project"]+        let first = try decode(await coordinator!.execute(tool: "create_project", arguments: projectArgs))+        precondition(first["outcome"] as? String == "committed")+        let project = try context.fetch(FetchDescriptor<Project>())[0]+        precondition(project.name == "P")+        project.name = "later edit"+        try context.save()+        let replay = try decode(await coordinator!.execute(tool: "create_project", arguments: projectArgs))+        let sameReplay = try MCPCanonicalJSON.encode(first) == MCPCanonicalJSON.encode(replay)+        precondition(sameReplay)+        let taskArgs: [String: Any] = [+            "name": "T", "type": "feature", "projectId": project.id.uuidString,+            "idempotencyKey": "task"+        ]+        let created = try decode(await coordinator!.execute(tool: "create_task", arguments: taskArgs))+        precondition(created["outcome"] as? String == "committed")+        let task = try context.fetch(FetchDescriptor<TransitTask>())[0]+        let revision = try MCPRecordSnapshot.task(task, in: context).revision+        let statusArgs: [String: Any] = [+            "taskId": task.id.uuidString, "status": "done", "comment": "saved",+            "authorName": "agent", "expectedRevision": revision,+            "idempotencyKey": "status"+        ]+        let status = try decode(await coordinator!.execute(tool: "update_task_status", arguments: statusArgs))+        precondition(status["outcome"] as? String == "committed")+        precondition(task.status == .done)+        let savedComments = try context.fetch(FetchDescriptor<Comment>())+        precondition(savedComments.count == 1)+        var stale = statusArgs+        stale["idempotencyKey"] = "stale"+        let conflict = try decode(await coordinator!.execute(tool: "update_task_status", arguments: stale))+        precondition((conflict["error"] as? [String: Any])?["code"] as? String == "REVISION_CONFLICT")+        let noMoreComments = try context.fetch(FetchDescriptor<Comment>())+        precondition(noMoreComments.count == 1)+        coordinator = nil+        coordinator = MCPWriteCoordinator(+            services: services,+            sidecarDirectory: directory.appendingPathComponent("sidecar"))+        let restarted = try decode(await coordinator!.execute(tool: "update_task_status", arguments: statusArgs))+        let sameRestarted = try MCPCanonicalJSON.encode(status) == MCPCanonicalJSON.encode(restarted)+        precondition(sameRestarted)+        context.delete(task)+        try context.save()+        let deletedReplay = try decode(await coordinator!.execute(tool: "create_task", arguments: taskArgs))+        let sameDeletedreplay = try MCPCanonicalJSON.encode(created) == MCPCanonicalJSON.encode(deletedReplay)+        precondition(sameDeletedreplay)+        let receipt = try context.fetch(FetchDescriptor<MCPWriteReceipt>()).first { $0.key == "task" }!+        context.delete(receipt)+        try context.save()+        let uncertain = try decode(await coordinator!.execute(tool: "create_task", arguments: taskArgs))+        precondition((uncertain["error"] as? [String: Any])?["code"] as? String == "OUTCOME_UNCERTAIN")+        let noRepeatedTasks = try context.fetch(FetchDescriptor<TransitTask>())+        precondition(noRepeatedTasks.isEmpty)+        print("PASS real-service coordinator commit/replay/restart/deleted-target/conflict/uncertainty")+        coordinator = nil+        try await remainingCommands(services: services, directory: directory)+        try await faults(services: services, directory: directory)+        try await activeKeys(services: services, directory: directory)+        try await expiryAndAvailability(services: services, directory: directory)+        try await malformedTerminals(services: services, directory: directory)+        integerBoundaries()+        schemas()+    }++    // swiftlint:disable:next function_body_length+    @MainActor static func remainingCommands(services: MCPWriteCommandServices, directory: URL) async throws {+        let coordinator = MCPWriteCoordinator(+            services: services, sidecarDirectory: directory.appendingPathComponent("all-tools"))+        let project = try services.projects.createProject(+            name: "all-tools", description: "", gitRepo: nil, colorHex: "red")+        let context = services.context+        let create = try decode(+            await coordinator.execute(+                tool: "create_milestone",+                arguments: [+                    "projectId": project.id.uuidString, "name": "M", "idempotencyKey": "m"+                ]))+        precondition(create["outcome"] as? String == "committed")+        let milestone = try context.fetch(FetchDescriptor<Milestone>()).first { $0.project?.id == project.id }!+        let task = try await services.tasks.createTask(+            name: "T", description: nil, type: .feature, project: project)+        let comment = try decode(+            await coordinator.execute(+                tool: "add_comment",+                arguments: [+                    "taskId": task.id.uuidString, "content": "C", "authorName": "agent", "idempotencyKey": "c"+                ]))+        precondition(comment["outcome"] as? String == "committed")+        let mixedMetadata: [String: Any] = [+            "name": "metadata", "type": "feature", "projectId": project.id.uuidString,+            "metadata": ["owner": "sam", "count": 4, "labels": ["one"]],+            "idempotencyKey": "mixed-metadata"+        ]+        let metadataResult = try decode(await coordinator.execute(tool: "create_task", arguments: mixedMetadata))+        precondition(metadataResult["outcome"] as? String == "committed")+        let metadataRecord = metadataResult["record"] as? [String: Any]+        precondition(metadataRecord?["metadata"] as? [String: String] == ["owner": "sam"])+        let metadataReplay = try decode(await coordinator.execute(tool: "create_task", arguments: mixedMetadata))+        let identicalMetadataReplay =+            try MCPCanonicalJSON.encode(metadataResult) == MCPCanonicalJSON.encode(metadataReplay)+        precondition(identicalMetadataReplay)+        try await distinctNumericMetadata(coordinator: coordinator, metadata: mixedMetadata)+        print("PASS mixed metadata retains original retry payload and drops nonstring domain entries")+        let revision = try MCPRecordSnapshot.task(task, in: context).revision+        let update = try decode(+            await coordinator.execute(+                tool: "update_task",+                arguments: [+                    "taskId": task.id.uuidString, "name": "edited", "expectedRevision": revision,+                    "idempotencyKey": "u"+                ]))+        precondition(update["outcome"] as? String == "committed" && task.name == "edited")+        let milestoneRevision = try MCPRecordSnapshot.milestone(milestone).revision+        let updatedMilestone = try decode(+            await coordinator.execute(+                tool: "update_milestone",+                arguments: [+                    "milestoneId": milestone.id.uuidString, "name": "edited milestone",+                    "expectedRevision": milestoneRevision,+                    "idempotencyKey": "um"+                ]))+        precondition(updatedMilestone["outcome"] as? String == "committed")+        let before = try MCPRecordSnapshot.milestone(milestone)+        let deleted = try decode(+            await coordinator.execute(+                tool: "delete_milestone",+                arguments: [+                    "milestoneId": milestone.id.uuidString, "expectedRevision": before.revision,+                    "idempotencyKey": "dm"+                ]))+        precondition(deleted["deleted"] as? Bool == true)+        precondition((deleted["recordBeforeDeletion"] as? [String: Any])?["revision"] as? String == before.revision)+        print("PASS all eight command families and milestone deletion preimage")+    }++    // swiftlint:disable:next function_body_length cyclomatic_complexity+    @MainActor static func faults(services: MCPWriteCommandServices, directory: URL) async throws {+        let context = services.context+        for kind in ["before", "after", "serialize", "recovery", "acceptance", "baseline"] {+            var fired = false+            var pendingProject: Project?+            let coordinator = MCPWriteCoordinator(+                services: services, sidecarDirectory: directory.appendingPathComponent(kind),+                save: { context, stage in+                    if kind == "acceptance", stage == .acceptance, !fired {+                        fired = true+                        throw CocoaError(.fileWriteUnknown)+                    }+                    if kind == "baseline", stage == .baseline, !fired {+                        fired = true+                        throw CocoaError(.fileWriteUnknown)+                    }+                    if ["before", "after", "recovery"].contains(kind), stage == .commit, !fired {+                        fired = true+                        if kind == "after" { try context.save() }+                        throw CocoaError(.fileWriteUnknown)+                    }+                    try context.save()+                },+                encode: { envelope in+                    if kind == "serialize", envelope["outcome"] as? String == "committed", !fired {+                        fired = true+                        throw CocoaError(.coderInvalidValue)+                    }+                    return try MCPWriteOutcome.encode(envelope)+                },+                recoveryHook: { if kind == "recovery" { throw CocoaError(.fileReadUnknown) } }+            )+            if kind == "baseline" {+                let userEdit = try context.fetch(FetchDescriptor<Project>())[0]+                userEdit.name = "pending user edit"+                pendingProject = userEdit+            }+            let args: [String: Any] = ["name": "fault-" + kind, "colorHex": "#112233", "idempotencyKey": kind]+            let outcome = try decode(await coordinator.execute(tool: "create_project", arguments: args))+            precondition(+                outcome["outcome"] as? String+                    == (kind == "after" ? "committed" : kind == "recovery" ? "uncertain" : "rejected"))+            if kind == "baseline" {+                precondition(outcome["accepted"] as? Bool == false && context.hasChanges)+                precondition(pendingProject?.name == "pending user edit")+            }+            try context.save()+            let freshProjects = try ModelContext(context.container).fetch(FetchDescriptor<Project>())+            if let pendingProject {+                precondition(freshProjects.first { $0.id == pendingProject.id }?.name == "pending user edit")+            }+            precondition(freshProjects.contains { $0.name == "fault-" + kind } == (kind == "after"))+            if kind != "baseline" {+                let replay = try decode(await coordinator.execute(tool: "create_project", arguments: args))+                precondition(replay["outcome"] as? String == outcome["outcome"] as? String)+            }+        }+        print(+            "PASS commit-before/after-throw; serialization/recovery/acceptance faults; pending baseline edits survive"+        )+    }++    @MainActor static func activeKeys(services: MCPWriteCommandServices, directory: URL) async throws {+        let gate = CoordinatorGate()+        let coordinator = MCPWriteCoordinator(+            services: services,+            sidecarDirectory: directory.appendingPathComponent("active"),+            preparationHook: { _ in await gate.park() })+        let args: [String: Any] = ["name": "active", "colorHex": "#112233", "idempotencyKey": "active"]+        let first = Task { await coordinator.execute(tool: "create_project", arguments: args) }+        await gate.waitForStart()+        let concurrent = try decode(await coordinator.execute(tool: "create_project", arguments: args))+        precondition(concurrent["outcome"] as? String == "in_progress")+        var mismatched = args+        mismatched["name"] = "different"+        let mismatch = try decode(await coordinator.execute(tool: "create_project", arguments: mismatched))+        precondition((mismatch["error"] as? [String: Any])?["code"] as? String == "IDEMPOTENCY_KEY_REUSED")+        await gate.release()+        let committed = try decode(await first.value)+        precondition(committed["outcome"] as? String == "committed")+        print("PASS suspended concurrent matching/mismatched keys")+    }++    @MainActor static func decode(_ result: MCPToolResult) throws -> [String: Any] {+        guard+            let decoded = try JSONSerialization.jsonObject(with: Data(result.content[0].text.utf8))+                as? [String: Any]+        else {+            throw CocoaError(.coderInvalidValue)+        }+        return decoded+    }++}++extension MCPWriteCoordinatorProbe {+    @MainActor static func schemas() {+        for definition in MCPToolDefinitions.coreTools+        where MCPWriteCommand.protectedTools.contains(definition.name) {+            precondition(definition.inputSchema.required?.contains("idempotencyKey") == true)+            if MCPWriteCommand.revisionTools.contains(definition.name) {+                precondition(definition.inputSchema.required?.contains("expectedRevision") == true)+            }+        }+        print("PASS eight protected published schemas and four required preconditions")+    }++    @MainActor static func expiryAndAvailability(services: MCPWriteCommandServices, directory: URL) async throws {+        var now = Date(timeIntervalSinceReferenceDate: 1_000_000)+        let coordinator = MCPWriteCoordinator(+            services: services,+            sidecarDirectory: directory.appendingPathComponent("expiry"), clock: { now })+        let args: [String: Any] = ["name": "expiry", "colorHex": "#112233", "idempotencyKey": "expiry"]+        let first = try decode(await coordinator.execute(tool: "create_project", arguments: args))+        now = now.addingTimeInterval(604799)+        let replay = try decode(await coordinator.execute(tool: "create_project", arguments: args))+        precondition(first["replayExpiresAt"] as? String == replay["replayExpiresAt"] as? String)+        now = now.addingTimeInterval(1)+        var next = args+        next["name"] = "reused after expiry"+        let expired = try decode(await coordinator.execute(tool: "create_project", arguments: next))+        precondition(expired["outcome"] as? String == "committed")+        let badDirectory = directory.appendingPathComponent("unreadable")+        try FileManager.default.createDirectory(at: badDirectory, withIntermediateDirectories: true)+        try Data("broken scope".utf8).write(to: badDirectory.appendingPathComponent("scope"))+        let unreadable = MCPWriteCoordinator(services: services, sidecarDirectory: badDirectory)+        let uncertain = try decode(await unreadable.execute(tool: "create_project", arguments: args))+        precondition(uncertain["accepted"] is NSNull && uncertain["outcome"] as? String == "uncertain")+        let busy = MCPWriteCoordinator(+            services: services, sidecarDirectory: directory.appendingPathComponent("expiry"))+        let contention = try decode(await busy.execute(tool: "create_project", arguments: args))+        precondition((contention["error"] as? [String: Any])?["code"] as? String == "STORE_BUSY")+        print(+            "PASS fixed seven-day expiry and fresh acceptance after removal; unreadable null acceptance; busy scope"+        )+    }+}++actor CoordinatorCounter {}+extension CoordinatorCounter: DisplayIDAllocator.CounterStore {+    func loadCounter() async throws -> DisplayIDAllocator.CounterSnapshot {+        .init(nextDisplayID: 1, changeTag: "probe")+    }+    func saveCounter(nextDisplayID: Int, expectedChangeTag: String?) async throws {}+}++actor CoordinatorGate {+    private var parked: CheckedContinuation<Void, Never>?+    private var waiter: CheckedContinuation<Void, Never>?+    private var started = false+    func park() async {+        started = true+        waiter?.resume()+        waiter = nil+        await withCheckedContinuation { parked = $0 }+    }+    func waitForStart() async {+        if !started { await withCheckedContinuation { waiter = $0 } }+    }+    func release() {+        parked?.resume()+        parked = nil+    }+}++extension MCPWriteCoordinatorProbe {+    @MainActor static func distinctNumericMetadata(+        coordinator: MCPWriteCoordinator, metadata: [String: Any]+    ) async throws {+        var differentNumericMetadata = metadata+        differentNumericMetadata["metadata"] = ["owner": "sam", "count": 1.0000000000000002]+        differentNumericMetadata["idempotencyKey"] = "adjacent-metadata"+        differentNumericMetadata["name"] = "adjacent metadata"+        let numericFirst = try decode(+            await coordinator.execute(tool: "create_task", arguments: differentNumericMetadata))+        precondition(numericFirst["outcome"] as? String == "committed")+        differentNumericMetadata["metadata"] = ["owner": "sam", "count": 1.0000000000000004]+        let reusedNumber = try decode(+            await coordinator.execute(tool: "create_task", arguments: differentNumericMetadata))+        precondition((reusedNumber["error"] as? [String: Any])?["code"] as? String == "IDEMPOTENCY_KEY_REUSED")+    }+}
tests/mcp-write-probe/FoundationProbe.swift Added +95 / -0
diff --git a/tests/mcp-write-probe/FoundationProbe.swift b/tests/mcp-write-probe/FoundationProbe.swiftnew file mode 100644index 0000000..ca90eb2--- /dev/null+++ b/tests/mcp-write-probe/FoundationProbe.swift@@ -0,0 +1,95 @@+import Foundation+import SwiftData++@main+struct MCPWriteFoundationProbe {+    @MainActor static func main() throws {+        for seed in 0..<100 {+            let value: [String: Any] = ["nested": ["b": seed, "a": true], "array": [NSNull(), "x"]]+            let encoded = try MCPCanonicalJSON.encode(value)+            let decoded = try JSONSerialization.jsonObject(with: Data(encoded.utf8))+            let roundtrip = try MCPCanonicalJSON.encode(decoded)+            precondition(encoded == roundtrip)+        }+        let boolean = try MCPCanonicalJSON.encode(true)+        let number = try MCPCanonicalJSON.encode(1)+        let float = try MCPCanonicalJSON.encode(1.0)+        precondition(boolean != number && number == float)+        try numericPrecision()+        let project = Project(name: "P", description: "", gitRepo: nil, colorHex: "red")+        let task = TransitTask(name: "T", type: .feature, project: project, displayID: .permanent(1))+        let comment = Comment(content: "C", authorName: "A", isAgent: false, task: task)+        let original = try MCPRecordSnapshot.task(task) { _ in [comment] }+        project.name = "excluded"+        let excluded = try MCPRecordSnapshot.task(task) { _ in [comment] }+        precondition(original.revision == excluded.revision)+        comment.content = "changed"+        let changed = try MCPRecordSnapshot.task(task) { _ in [comment] }+        precondition(original.revision != changed.revision)+        comment.content = "C"+        let restored = try MCPRecordSnapshot.task(task) { _ in [comment] }+        precondition(original.revision == restored.revision)+        print("PASS canonical roundtrip and content revisions")+        try receiptStorage()+    }++    @MainActor static func numericPrecision() throws {+        let adjacent = [1.0, 1.0000000000000002, 1.0000000000000004]+        let encodings = try adjacent.map { try MCPCanonicalJSON.encode($0) }+        precondition(Set(encodings).count == adjacent.count, "Adjacent finite Doubles must retain distinct identity")+        for value in [1e300, 1e-300, Double.leastNonzeroMagnitude, Double.greatestFiniteMagnitude] {+            let encoded = try MCPCanonicalJSON.encode(value)+            let decoded = try JSONSerialization.jsonObject(with: Data(encoded.utf8), options: [.fragmentsAllowed])+            precondition((decoded as? NSNumber)?.doubleValue == value)+            let roundtrip = try MCPCanonicalJSON.encode(decoded)+            precondition(roundtrip == encoded)+        }+        let negativeZero = try MCPCanonicalJSON.encode(-0.0)+        let zero = try MCPCanonicalJSON.encode(0)+        precondition(negativeZero == zero)+        print("PASS adjacent-double distinction, finite exponent extremes and signed-zero equivalence")+    }++    @MainActor static func receiptStorage() throws {+        let schema = Schema([Project.self, TransitTask.self, Comment.self, Milestone.self,+                             SyncHeartbeat.self, MCPWriteReceipt.self])+        let configuration = ModelConfiguration("receipt-probe", schema: schema,+                                               isStoredInMemoryOnly: true, cloudKitDatabase: .none)+        let container = try ModelContainer(for: schema, configurations: configuration)+        let context = container.mainContext+        context.autosaveEnabled = false+        let directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)+        defer { try? FileManager.default.removeItem(at: directory) }+        let reservations = try MCPLocalReservationStore(directory: directory)+        let store = MCPWriteReceiptStore(context: context, scopeID: reservations.scopeID)+        let binding = try reservations.reserve(tool: "create_project", key: "key", requestJSON: "{}")+        let receipt = try store.insert(binding, acceptedAt: Date(timeIntervalSinceReferenceDate: 0))+        try context.save()+        receipt.stateRawValue = "committed"+        receipt.completedAt = Date(timeIntervalSinceReferenceDate: 10)+        receipt.expiresAt = Date(timeIntervalSinceReferenceDate: 604810)+        let project = Project(name: "P", description: "", gitRepo: nil, colorHex: "#112233")+        let snapshot = try MCPRecordSnapshot.project(project)+        let result: [String: Any] = [+            "contractVersion": 1, "tool": "create_project", "idempotencyKey": "key",+            "outcome": "committed", "accepted": true, "entityId": project.id.uuidString,+            "record": snapshot.record,+            "completedAt": MCPRecordSnapshot.timestamp(receipt.completedAt!),+            "replayExpiresAt": MCPRecordSnapshot.timestamp(receipt.expiresAt!)+        ]+        receipt.resultJSON = String(data: try JSONSerialization.data(withJSONObject: result), encoding: .utf8)!+        receipt.resultIsError = false+        try context.save()+        let durable = try store.lookup(tool: "create_project", key: "key", durable: true)+        precondition(durable?.stateRawValue == "committed")+        try store.cleanup(now: Date(timeIntervalSinceReferenceDate: 20), reservations: reservations)+        let repaired = try reservations.lookup(tool: "create_project", key: "key")+        precondition(repaired?.expiresAt == receipt.expiresAt)+        try store.cleanup(now: Date(timeIntervalSinceReferenceDate: 604810), reservations: reservations)+        try context.save()+        let expired = try store.lookup(tool: "create_project", key: "key", durable: true)+        let removed = try reservations.lookup(tool: "create_project", key: "key")+        precondition(expired == nil && removed == nil)+        print("PASS scoped receipt staging, durable lookup, expiry repair and cleanup")+    }+}
tests/mcp-write-probe/GuardProbe.swift Added +52 / -0
diff --git a/tests/mcp-write-probe/GuardProbe.swift b/tests/mcp-write-probe/GuardProbe.swiftnew file mode 100644index 0000000..fe7741f--- /dev/null+++ b/tests/mcp-write-probe/GuardProbe.swift@@ -0,0 +1,52 @@+import Foundation++@main+struct MCPWriteGuardProbe {+    @MainActor static func main() throws {+        let directory = URL(fileURLWithPath: CommandLine.arguments[2])+        if CommandLine.arguments[1] == "hold" {+            let store = try MCPLocalReservationStore(directory: directory)+            _ = try store.reserve(tool: "create_task", key: "key", requestJSON: "{}")+            print("LOCKED")+            fflush(stdout)+            _ = readLine()+            withExtendedLifetime(store) {}+        } else if CommandLine.arguments[1] == "busy" {+            do {+                _ = try MCPLocalReservationStore(directory: directory)+                fatalError("Second process acquired lock")+            } catch MCPLocalReservationStore.Error.storeBusy { print("BUSY") }+        } else if CommandLine.arguments[1] == "corrupt" {+            do {+                _ = try MCPLocalReservationStore(directory: directory)+                fatalError("Corrupt scope enabled writes")+            } catch { print("FAIL_CLOSED") }+        } else {+            let store = try MCPLocalReservationStore(directory: directory)+            let record = try store.lookup(tool: "create_task", key: "key")+            precondition(record != nil)+            try store.removeExpired(now: Date.distantFuture)+            let unresolved = try store.lookup(tool: "create_task", key: "key")+            precondition(unresolved == record)+            do {+                _ = try store.reserve(tool: "create_task", key: "key", requestJSON: "{\"x\":1}")+                fatalError("Mismatched payload accepted")+            } catch MCPLocalReservationStore.Error.keyReused {}+            let terminal = try store.reserve(tool: "create_project", key: "terminal", requestJSON: "{}")+            let expiry = Date(timeIntervalSinceReferenceDate: 604800)+            try store.recordExpiry(terminal, expiresAt: expiry)+            try store.recordExpiry(terminal, expiresAt: expiry)+            do {+                try store.recordExpiry(terminal, expiresAt: expiry.addingTimeInterval(1))+                fatalError("Deadline changed")+            } catch MCPLocalReservationStore.Error.inconsistent {}+            try store.removeExpired(now: expiry.addingTimeInterval(-1))+            let before = try store.lookup(tool: "create_project", key: "terminal")+            precondition(before != nil)+            try store.removeExpired(now: expiry)+            let after = try store.lookup(tool: "create_project", key: "terminal")+            precondition(after == nil)+            print("RECOVERED")+        }+    }+}
tests/mcp-write-probe/Probe.swift Added +149 / -0
diff --git a/tests/mcp-write-probe/Probe.swift b/tests/mcp-write-probe/Probe.swiftnew file mode 100644index 0000000..1f4602a--- /dev/null+++ b/tests/mcp-write-probe/Probe.swift@@ -0,0 +1,149 @@+import Foundation+import SwiftData+import Darwin++/// A separate process is essential: retained containers must not turn a reopen+/// into a cache read, and SIGKILL must bypass normal shutdown/checkpointing.+@main+struct MCPWriteDiskProbe {+    @MainActor static func main() throws {+        let arguments = CommandLine.arguments+        let mode = arguments[1]+        let url = URL(fileURLWithPath: arguments[2])+        var models: [any PersistentModel.Type] = [+            Project.self, TransitTask.self, Comment.self, Milestone.self, SyncHeartbeat.self+        ]+        if mode != "seed-old" { models.append(MCPWriteReceipt.self) }+        let schema = Schema(models)+        let configuration = ModelConfiguration(schema: schema, url: url,+                                               allowsSave: mode != "readonly", cloudKitDatabase: .none)+        let container = try ModelContainer(for: schema, configurations: configuration)+        let context = container.mainContext+        context.autosaveEnabled = false++        switch mode {+        case "seed-old": try seedOld(context: context)+        case "stage": try stage(context: context)+        case "verify": try verify(context: context)+        case "cleanup": try cleanup(container: container)+        case "readonly": try readOnly(context: context)+        case "verify-clean": try verifyClean(context: context)+        default: fatalError("Unknown mode")+        }+    }++    @MainActor static func seedOld(context: ModelContext) throws {+        let project = Project(name: "Disk", description: "preserved", gitRepo: nil, colorHex: "#123456")+        let task = TransitTask(name: "Baseline", type: .feature, project: project, displayID: .permanent(1))+        context.insert(project)+        context.insert(task)+        try context.save()+    }++    @MainActor static func stage(context: ModelContext) throws {+        let task = try context.fetch(FetchDescriptor<TransitTask>())[0]+        let receipt = MCPWriteReceipt(localScopeID: "probe", tool: "update_task_status", key: "crash",+                                      requestJSON: "{}", acceptedAt: Date())+        context.insert(receipt)+        try context.save()+        task.status = .done+        task.completionDate = Date(timeIntervalSinceReferenceDate: 10)+        for index in 0..<200 {+            context.insert(Comment(content: "comment-\(index)", authorName: "Probe", isAgent: true, task: task))+        }+        receipt.stateRawValue = "committed"+        receipt.completedAt = Date(timeIntervalSinceReferenceDate: 10)+        receipt.expiresAt = Date(timeIntervalSinceReferenceDate: 604810)+        receipt.resultJSON = "{\"outcome\":\"committed\"}"+        receipt.resultIsError = false+        print("STAGED")+        fflush(stdout)+        _ = readLine()+        print("SAVING")+        fflush(stdout)+        try context.save()+        print("SAVED")+        fflush(stdout)+        _ = readLine()+    }++    @MainActor static func verify(context: ModelContext) throws {+        let tasks = try context.fetch(FetchDescriptor<TransitTask>())+        let projects = try context.fetch(FetchDescriptor<Project>())+        let comments = try context.fetch(FetchDescriptor<Comment>())+        let receipts = try context.fetch(FetchDescriptor<MCPWriteReceipt>())+        precondition(tasks.count == 1 && projects.count == 1)+        precondition(projects[0].projectDescription == "preserved")+        precondition(receipts.count == 1)+        let committed = receipts[0].stateRawValue == "committed"+        precondition(tasks[0].status == (committed ? .done : .idea))+        precondition(comments.count == (committed ? 200 : 0))+        precondition((tasks[0].completionDate != nil) == committed)+        precondition((receipts[0].resultJSON != nil) == committed)+        if committed { precondition(receipts[0].resultIsError == false) }+        print(committed ? "COMMITTED" : "ACCEPTED")+    }++    @MainActor static func cleanup(container: ModelContainer) throws {+        let context = container.mainContext+        let task = try context.fetch(FetchDescriptor<TransitTask>())[0]+        let original = task.statusRawValue+        let receipt = MCPWriteReceipt(localScopeID: "probe", tool: "add_comment", key: "failure",+                                      requestJSON: "{}", acceptedAt: Date())+        context.insert(receipt)+        try context.save()+        task.status = .done+        let comment = Comment(content: "ghost", authorName: "Probe", isAgent: true, task: task)+        context.insert(comment)+        receipt.stateRawValue = "committed"+        // Deterministic save seam throws before commit, then the same+        // context must still support an unrelated successful save.+        do { throw CocoaError(.fileWriteNoPermission) } catch {+            context.delete(comment)+            context.safeRollback()+        }+        precondition(task.statusRawValue == original)+        precondition(receipt.stateRawValue == "accepted")+        let project = try context.fetch(FetchDescriptor<Project>())[0]+        project.name = "Unrelated saved edit"+        try context.save()+        let fresh = ModelContext(container)+        let savedComments = try fresh.fetch(FetchDescriptor<Comment>())+        let savedTasks = try fresh.fetch(FetchDescriptor<TransitTask>())+        let savedReceipts = try fresh.fetch(FetchDescriptor<MCPWriteReceipt>())+        precondition(savedComments.isEmpty)+        precondition(savedTasks[0].statusRawValue == original)+        precondition(savedReceipts[0].stateRawValue == "accepted")+        print("CLEAN")+    }++    @MainActor static func readOnly(context: ModelContext) throws {+        let task = try context.fetch(FetchDescriptor<TransitTask>())[0]+        task.status = .done+        let receipt = MCPWriteReceipt(localScopeID: "probe", tool: "add_comment", key: "readonly",+                                      requestJSON: "{}", acceptedAt: Date())+        let comment = Comment(content: "ghost", authorName: "Probe", isAgent: true, task: task)+        context.insert(receipt)+        context.insert(comment)+        do {+            try context.save()+            fatalError("Read-only save unexpectedly succeeded")+        } catch {+            context.delete(comment)+            context.delete(receipt)+            context.safeRollback()+        }+        print("FAILED_AS_EXPECTED")+    }++    @MainActor static func verifyClean(context: ModelContext) throws {+        let tasks = try context.fetch(FetchDescriptor<TransitTask>())+        let comments = try context.fetch(FetchDescriptor<Comment>())+        let receipts = try context.fetch(FetchDescriptor<MCPWriteReceipt>())+        precondition(tasks[0].status == .idea && comments.isEmpty && receipts.isEmpty)+        let project = try context.fetch(FetchDescriptor<Project>())[0]+        project.name = "Later unrelated save"+        try context.save()+        print("CLEAN")+    }+}
tests/mcp-write-probe/ServiceProbe.swift Added +172 / -0
diff --git a/tests/mcp-write-probe/ServiceProbe.swift b/tests/mcp-write-probe/ServiceProbe.swiftnew file mode 100644index 0000000..7683de7--- /dev/null+++ b/tests/mcp-write-probe/ServiceProbe.swift@@ -0,0 +1,172 @@+import Foundation+import SwiftData++@main+struct MCPWriteServiceProbe {+    // swiftlint:disable:next function_body_length+    @MainActor static func main() async throws {+        let schema = Schema([Project.self, TransitTask.self, Comment.self, Milestone.self,+                             SyncHeartbeat.self, MCPWriteReceipt.self])+        let config = ModelConfiguration("service-probe", schema: schema,+                                        isStoredInMemoryOnly: true, cloudKitDatabase: .none)+        let container = try ModelContainer(for: schema, configurations: config)+        let context = container.mainContext+        context.autosaveEnabled = false+        let allocator = DisplayIDAllocator(store: ProbeCounter(), isCloudSyncActive: false)+        let tasks = TaskService(modelContext: context, displayIDAllocator: allocator)+        let milestones = MilestoneService(modelContext: context, displayIDAllocator: allocator)+        let projects = ProjectService(modelContext: context)+        let project = try projects.createProject(name: " P ", description: "", gitRepo: nil,+                                                  colorHex: "red", save: false)+        precondition(context.hasChanges)+        let unsavedProjects = try ModelContext(container).fetch(FetchDescriptor<Project>())+        precondition(unsavedProjects.isEmpty)+        try context.save()+        let milestonePlan = try await milestones.prepareMilestoneCreation(name: " M ", description: nil,+                                                                           project: project)+        let beforeInsert = try context.fetch(FetchDescriptor<Milestone>())+        precondition(beforeInsert.isEmpty)+        let milestone = try milestones.applyMilestoneCreation(milestonePlan)+        try context.save()+        let taskPlan = try await tasks.prepareTaskCreation(name: " T ", description: nil, type: .feature,+                                                           project: project, milestone: milestone)+        let noTasks = try context.fetch(FetchDescriptor<TransitTask>())+        precondition(noTasks.isEmpty)+        milestone.statusRawValue = MilestoneStatus.done.rawValue+        try context.save()+        do {+            _ = try tasks.applyTaskCreation(taskPlan)+            preconditionFailure("Closed milestone must reject prepared task")+        } catch TaskService.Error.milestoneNotOpen { }+        milestone.statusRawValue = MilestoneStatus.open.rawValue+        try context.save()+        let task = try tasks.applyTaskCreation(taskPlan)+        precondition(task.name == "T" && context.hasChanges)+        try context.save()+        let comments = CommentService(modelContext: context)+        let comment = try tasks.updateStatus(task: task, to: .planning, comment: "hello",+                                              commentAuthor: "agent", commentService: comments, save: false)+        precondition(comment != nil)+        let durable = ModelContext(container)+        let savedTask = try durable.fetch(FetchDescriptor<TransitTask>()).first!+        let savedComments = try durable.fetch(FetchDescriptor<Comment>())+        precondition(savedTask.status == .idea && savedComments.isEmpty)+        try context.save()+        let saved = ModelContext(container)+        let committedTask = try saved.fetch(FetchDescriptor<TransitTask>()).first!+        let committedComments = try saved.fetch(FetchDescriptor<Comment>())+        precondition(committedTask.status == .planning && committedComments.count == 1)+        let duplicatePlan = try await milestones.prepareMilestoneCreation(name: "competing", description: nil,+                                                                           project: project)+        _ = try await milestones.createMilestone(name: "COMPETING", description: nil, project: project)+        do {+            _ = try milestones.applyMilestoneCreation(duplicatePlan)+            preconditionFailure("Competing name must reject")+        } catch MilestoneService.Error.duplicateName { }+        try milestones.deleteMilestone(milestone, save: false)+        let beforeDeletionSave = try ModelContext(container).fetch(FetchDescriptor<Milestone>())+        precondition(beforeDeletionSave.contains { $0.id == milestone.id })+        try context.save()+        let afterDeletionSave = try ModelContext(container).fetch(FetchDescriptor<Milestone>())+        precondition(!afterDeletionSave.contains { $0.id == milestone.id })+        let orphanPlan = try await tasks.prepareTaskCreation(name: "orphan", description: nil,+                                                             type: .feature, project: project)+        context.delete(project)+        try context.save()+        do {+            _ = try tasks.applyTaskCreation(orphanPlan)+            preconditionFailure("Missing pinned project must reject")+        } catch TaskService.Error.projectNotFound { }+        try await suspendedAllocation(container: container, context: context)+        print("PASS preparation has no inserts; pinned references/name revalidate; "+              + "deferred project/delete/status-comment save")+    }++    // swiftlint:disable:next function_body_length+    @MainActor static func suspendedAllocation(container: ModelContainer, context: ModelContext) async throws {+        let project = Project(name: "suspended", description: "", gitRepo: nil, colorHex: "red")+        context.insert(project)+        let milestone = Milestone(name: "open", project: project, displayID: .permanent(80))+        context.insert(milestone)+        try context.save()+        let counter = SuspendedProbeCounter()+        let tasks = TaskService(modelContext: context, displayIDAllocator: DisplayIDAllocator(store: counter))+        let operation = Task {+            try await tasks.prepareTaskCreation(name: "suspended task", description: nil, type: .feature,+                                                 project: project, milestone: milestone)+        }+        await counter.waitForLoad()+        let before = try context.fetch(FetchDescriptor<TransitTask>()).count+        milestone.project = nil+        try context.save()+        await counter.release()+        let prepared = try await operation.value+        do {+            _ = try tasks.applyTaskCreation(prepared)+            preconditionFailure("Reassignment during allocation must reject")+        } catch TaskService.Error.milestoneProjectMismatch { }+        let after = try context.fetch(FetchDescriptor<TransitTask>()).count+        precondition(before == after)+        let cancelCounter = SuspendedProbeCounter()+        let cancelService = TaskService(modelContext: context,+                                        displayIDAllocator: DisplayIDAllocator(store: cancelCounter))+        let cancelled = Task {+            try await cancelService.createTask(name: "cancelled", description: nil, type: .feature, project: project)+        }+        await cancelCounter.waitForLoad()+        cancelled.cancel()+        await cancelCounter.release()+        do {+            _ = try await cancelled.value+            preconditionFailure("Cancellation must prevent insert")+        } catch is CancellationError { }+        let afterCancellation = try context.fetch(FetchDescriptor<TransitTask>()).count+        precondition(before == afterCancellation)+        let deleteCounter = SuspendedProbeCounter()+        let milestones = MilestoneService(modelContext: context,+                                           displayIDAllocator: DisplayIDAllocator(store: deleteCounter))+        let deleted = Task { try await milestones.createMilestone(name: "missing", description: nil, project: project) }+        await deleteCounter.waitForLoad()+        let peer = ModelContext(container)+        let projectID = project.id+        let descriptor = FetchDescriptor<Project>(predicate: #Predicate { $0.id == projectID })+        if let record = try peer.fetch(descriptor).first { peer.delete(record); try peer.save() }+        await deleteCounter.release()+        do {+            _ = try await deleted.value+            preconditionFailure("Peer deletion during allocation must reject")+        } catch MilestoneService.Error.projectNotFound { }+        print("PASS real suspended allocation: milestone reassignment, cancellation, peer project deletion")+    }++}++private actor ProbeCounter: DisplayIDAllocator.CounterStore {+    func loadCounter() async throws -> DisplayIDAllocator.CounterSnapshot {+        .init(nextDisplayID: 1, changeTag: nil)+    }+    func saveCounter(nextDisplayID: Int, expectedChangeTag: String?) async throws { }+}++private actor SuspendedProbeCounter: DisplayIDAllocator.CounterStore {+    private var continuation: CheckedContinuation<Void, Never>?+    private var observer: CheckedContinuation<Void, Never>?+    private var started = false++    func waitForLoad() async {+        if started { return }+        await withCheckedContinuation { observer = $0 }+    }++    func release() { continuation?.resume(); continuation = nil }++    func loadCounter() async throws -> DisplayIDAllocator.CounterSnapshot {+        started = true+        observer?.resume()+        observer = nil+        await withCheckedContinuation { continuation = $0 }+        return .init(nextDisplayID: 100, changeTag: nil)+    }++    func saveCounter(nextDisplayID: Int, expectedChangeTag: String?) async throws { }+}
tests/mcp-write-probe/guards.py Added +27 / -0
diff --git a/tests/mcp-write-probe/guards.py b/tests/mcp-write-probe/guards.pynew file mode 100644index 0000000..aab453f--- /dev/null+++ b/tests/mcp-write-probe/guards.py@@ -0,0 +1,27 @@+"""Verify a real second process cannot acquire the lifetime coordinator lock."""+import pathlib+import subprocess+import sys+import tempfile+from run import marker, run+++with tempfile.TemporaryDirectory(prefix="transit-mcp-guards-") as temporary:+    directory = pathlib.Path(temporary) / "sidecar"+    process = subprocess.Popen([sys.argv[1], "hold", str(directory)], stdin=subprocess.PIPE,+                               stdout=subprocess.PIPE, text=True, bufsize=1)+    try:+        marker(process, "LOCKED")+        assert run(sys.argv[1], "busy", directory) == "BUSY"+        process.kill()+        process.wait(timeout=10)+        assert run(sys.argv[1], "recover", directory) == "RECOVERED"+        files = list((directory / "guards").glob("*.json"))+        assert len(files) == 1+        files[0].write_text("unreadable guard")+        assert run(sys.argv[1], "corrupt", directory) == "FAIL_CLOSED"+        print("PASS two-process lock, SIGKILL recovery, unresolved binding, fixed expiry and corrupt-store rejection")+    finally:+        if process.poll() is None:+            process.kill()+            process.wait(timeout=10)
tests/mcp-write-probe/run.py Added +74 / -0
diff --git a/tests/mcp-write-probe/run.py b/tests/mcp-write-probe/run.pynew file mode 100644index 0000000..6a16426--- /dev/null+++ b/tests/mcp-write-probe/run.py@@ -0,0 +1,74 @@+"""Terminate actual SwiftData writers around save, then reopen in new processes."""+import pathlib+import selectors+import subprocess+import sys+import tempfile+import time+++def marker(process, expected):+    selector = selectors.DefaultSelector()+    selector.register(process.stdout, selectors.EVENT_READ)+    deadline = time.monotonic() + 30+    while time.monotonic() < deadline:+        if selector.select(timeout=1):+            line = process.stdout.readline().strip()+            if line == expected:+                selector.close()+                return+            if not line and process.poll() is not None:+                raise RuntimeError(f"child exited before {expected}: {process.returncode}")+    process.kill()+    raise TimeoutError(f"child did not reach {expected}")+++def run(binary, mode, store):+    output = subprocess.check_output([binary, mode, str(store)], text=True, timeout=30).strip().splitlines()+    return output[-1] if output else ""+++def main():+    binary = sys.argv[1]+    with tempfile.TemporaryDirectory(prefix="transit-mcp-disk-") as temporary:+        root = pathlib.Path(temporary)+        for index, boundary in enumerate(["before", "after"] + ["during"] * 12):+            store = root / f"probe-{index}.store"+            run(binary, "seed-old", store)+            process = subprocess.Popen([binary, "stage", str(store)], stdin=subprocess.PIPE,+                                       stdout=subprocess.PIPE, text=True, bufsize=1)+            try:+                marker(process, "STAGED")+                if boundary != "before":+                    process.stdin.write("commit\n")+                    process.stdin.flush()+                    marker(process, "SAVED" if boundary == "after" else "SAVING")+                    if boundary == "during":+                        time.sleep(index * 0.002)+                process.kill()+                process.wait(timeout=10)+                outcome = run(binary, "verify", store)+                if boundary == "before":+                    assert outcome == "ACCEPTED", outcome+                elif boundary == "after":+                    assert outcome == "COMMITTED", outcome+                print(f"PASS {boundary} save: {outcome}")+            finally:+                if process.poll() is None:+                    process.kill()+                    process.wait(timeout=10)+        cleanup_store = root / "cleanup.store"+        run(binary, "seed-old", cleanup_store)+        assert run(binary, "cleanup", cleanup_store) == "CLEAN"+        print("PASS additive old-store reopen and rollback without ghost effects")+        readonly_store = root / "readonly.store"+        run(binary, "seed-old", readonly_store)+        # Migrate before opening read-only; otherwise opening attempts migration.+        assert run(binary, "verify-clean", readonly_store) == "CLEAN"+        assert run(binary, "readonly", readonly_store) == "FAILED_AS_EXPECTED"+        assert run(binary, "verify-clean", readonly_store) == "CLEAN"+        print("PASS actual read-only save failure and later unrelated save")+++if __name__ == "__main__":+    main()
tests/mcp-write-probe/swift-format.json Added +6 / -0
diff --git a/tests/mcp-write-probe/swift-format.json b/tests/mcp-write-probe/swift-format.jsonnew file mode 100644index 0000000..e55171b--- /dev/null+++ b/tests/mcp-write-probe/swift-format.json@@ -0,0 +1,6 @@+{+    "indentation": {"spaces": 4},+    "lineLength": 116,+    "indentConditionalCompilationBlocks": false,+    "multiElementCollectionTrailingCommas": false+}
tests/mcp-write-probe/CoordinatorRegressionProbe.swift Added +117 / -0
diff --git a/tests/mcp-write-probe/CoordinatorRegressionProbe.swift b/tests/mcp-write-probe/CoordinatorRegressionProbe.swiftnew file mode 100644index 0000000..413c5b6--- /dev/null+++ b/tests/mcp-write-probe/CoordinatorRegressionProbe.swift@@ -0,0 +1,117 @@+import Foundation+import SwiftData++extension MCPWriteCoordinatorProbe {+    @MainActor static func integerBoundaries() {+        let args: [String: Any] = ["displayId": Int.max, "content": "C", "authorName": "A", "idempotencyKey": "max"]+        precondition((try? MCPWriteCommand.validate(tool: "add_comment", arguments: args)) != nil)+        for value in [true, 1.5, Double(Int.max), NSNumber(value: UInt64.max)] as [Any] {+            var invalid = args+            invalid["displayId"] = value+            precondition((try? MCPWriteCommand.validate(tool: "add_comment", arguments: invalid)) == nil)+        }+        print("PASS exact Int.max acceptance and strict boolean/fraction/out-of-range rejection")+    }++    // swiftlint:disable:next function_body_length+    @MainActor static func malformedTerminals(services: MCPWriteCommandServices, directory: URL) async throws {+        let coordinator = MCPWriteCoordinator(+            services: services, sidecarDirectory: directory.appendingPathComponent("malformed"))+        let projectArgs: [String: Any] = [+            "name": "malformed P", "colorHex": "#112233", "idempotencyKey": "malformed-project"+        ]+        let project = try decode(await coordinator.execute(tool: "create_project", arguments: projectArgs))+        let task = try await services.tasks.createTask(+            name: "malformed T", description: nil, type: .feature,+            project: services.projects.findProject(id: UUID(uuidString: project["entityId"] as? String ?? "")!)+                .get())+        let statusArgs: [String: Any] = [+            "taskId": task.id.uuidString, "status": "done", "comment": "C",+            "authorName": "A", "expectedRevision": try MCPRecordSnapshot.task(task, in: services.context).revision,+            "idempotencyKey": "malformed-status"+        ]+        let status = try decode(await coordinator.execute(tool: "update_task_status", arguments: statusArgs))+        var conflictArgs = statusArgs+        conflictArgs["idempotencyKey"] = "malformed-conflict"+        let conflict = try decode(await coordinator.execute(tool: "update_task_status", arguments: conflictArgs))+        let milestone = try await services.milestones.createMilestone(+            name: "malformed M", description: nil, project: task.project!)+        let deleteArgs: [String: Any] = [+            "milestoneId": milestone.id.uuidString,+            "expectedRevision": try MCPRecordSnapshot.milestone(milestone).revision,+            "idempotencyKey": "malformed-delete"+        ]+        let deletion = try decode(await coordinator.execute(tool: "delete_milestone", arguments: deleteArgs))+        let rejectArgs: [String: Any] = [+            "name": "reject", "colorHex": "invalid", "idempotencyKey": "malformed-reject"+        ]+        let rejection = try decode(await coordinator.execute(tool: "create_project", arguments: rejectArgs))+        let cases: [((String, [String: Any]), ([String: Any], [String]))] = [+            (+                ("create_project", projectArgs),+                (+                    project,+                    [+                        "entityId", "record", "record.revision", "record.name", "completedAt", "replayExpiresAt",+                        "completedAtMismatch", "entityIdMismatch"+                    ]+                )+            ),+            (+                ("update_task_status", statusArgs),+                (status, ["record.comments", "record.creationDate", "comment", "comment.revision"])+            ),+            (+                ("delete_milestone", deleteArgs),+                (deletion, ["deleted", "recordBeforeDeletion", "recordBeforeDeletion.revision"])+            ),+            (("update_task_status", conflictArgs), (conflict, ["currentRecord", "currentRecord.revision"])),+            (("create_project", rejectArgs), (rejection, ["error", "error.code", "error.message", "retryAction"]))+        ]+        for ((tool, args), (original, fields)) in cases {+            let receipt = try services.context.fetch(FetchDescriptor<MCPWriteReceipt>()).first {+                $0.key == args["idempotencyKey"] as? String+            }!+            let saved = receipt.resultJSON!+            for field in fields {+                var malformed = original+                let components = field.split(separator: ".").map(String.init)+                if field == "completedAtMismatch" {+                    malformed["completedAt"] = MCPRecordSnapshot.timestamp(.distantPast)+                } else if field == "entityIdMismatch" {+                    malformed["entityId"] = UUID().uuidString+                } else if components.count == 2 {+                    var record = malformed[components[0]] as? [String: Any] ?? [:]+                    record.removeValue(forKey: components[1])+                    malformed[components[0]] = record+                } else {+                    malformed.removeValue(forKey: field)+                }+                let malformedJSON = try MCPWriteOutcome.encode(malformed)+                receipt.resultJSON = malformedJSON+                try services.context.save()+                let result = try decode(await coordinator.execute(tool: tool, arguments: args))+                precondition(result["outcome"] as? String == "uncertain")+                precondition((result["error"] as? [String: Any])?["code"] as? String == "OUTCOME_UNCERTAIN")+                precondition(result["retryAction"] as? String == "reconcile")+                precondition(receipt.resultJSON == malformedJSON)+                let files = try FileManager.default.contentsOfDirectory(+                    at: directory.appendingPathComponent("malformed/guards"),+                    includingPropertiesForKeys: nil)+                let bindings = try files.filter { $0.pathExtension == "json" }.map {+                    try JSONDecoder().decode(MCPLocalReservation.self, from: Data(contentsOf: $0))+                }+                precondition(bindings.contains { $0.tool == tool && $0.key == args["idempotencyKey"] as? String })+            }+            receipt.resultJSON = saved+            try services.context.save()+            let replay = try decode(await coordinator.execute(tool: tool, arguments: args))+            let identical = try MCPCanonicalJSON.encode(replay) == MCPCanonicalJSON.encode(original)+            precondition(identical)+        }+        print(+            "PASS malformed terminal records/deletion/status-comment return uncertainty and retain receipts"+        )+    }++}

Docs (14)

.claude/rules/swift-json.md Added +10 / -0
diff --git a/.claude/rules/swift-json.md b/.claude/rules/swift-json.mdnew file mode 100644index 0000000..af863b3--- /dev/null+++ b/.claude/rules/swift-json.md@@ -0,0 +1,10 @@+---+paths:+  - "**/*.swift"+---++# Swift JSON Number Identity++- Do not canonicalize JSON numbers through `NSNumber.decimalValue`: it can round distinct adjacent `Double` values together and overflow finite exponent values. This breaks payload identity for idempotency keys.+- Use a lossless numeric representation, keep Boolean values distinct from numbers, and preserve equality for equivalent parsed numeric encodings such as `1` and `1.0`.+- Cover adjacent representable doubles, finite exponent extremes, and integer/floating equivalents in canonicalization regressions.
.claude/rules/swiftdata-task-results.md Added +10 / -0
diff --git a/.claude/rules/swiftdata-task-results.md b/.claude/rules/swiftdata-task-results.mdnew file mode 100644index 0000000..35b14eb--- /dev/null+++ b/.claude/rules/swiftdata-task-results.md@@ -0,0 +1,10 @@+---+paths:+  - "**/*.swift"+---++# SwiftData Task Results++- Do not return a SwiftData `@Model` from a child `Task`: `Task.value` requires a Sendable result, and SwiftData explicitly rejects model Sendable conformance.+- Return a UUID, an immutable Sendable value, or `Void`; keep model access and re-resolution on the owning actor/context.+- Do not add `@unchecked Sendable` to persistent models to bypass this check. Regression tests must preserve the intended suspension/cancellation behavior while using a safe result boundary.
CHANGELOG.md Modified +1 / -0
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex 8465986..d69c1dc 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -8,6 +8,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).  ### Added +- T-2380: Eight standard MCP writes require retry keys, and task/milestone updates require revision preconditions. Local receipts retain saved outcomes for seven days, durable guards protect uncertain requests across restart, and full-record reads return content revisions for conflict detection. - T-2377: MCP `create_project` accepts a required name and six-digit colour, validates optional description/repository fields and case-insensitive name uniqueness, persists through `ProjectService`, and returns project ID and metadata for subsequent task creation. Regression tests cover discovery, validation, storage failures, fallback write rejection, and project-to-task creation.  ### Changed
CLAUDE.md Modified +6 / -2
diff --git a/CLAUDE.md b/CLAUDE.mdindex e1210a7..dd655eb 100644--- a/CLAUDE.md+++ b/CLAUDE.md@@ -57,12 +57,13 @@ xcodebuild test -project Transit/Transit.xcodeproj -scheme Transit \  ### Data Model -Five SwiftData entities:+Six SwiftData entities: - **Project** → has many **Tasks** and many **Milestones** - **TransitTask** → belongs to one Project, optionally belongs to one Milestone, has many Comments - **Milestone** → belongs to one Project, has many Tasks. Statuses: open / done / abandoned - **Comment** → belongs to one Task. Has `authorName`, `isAgent` flag, and `content` - **SyncHeartbeat** → singleton record whose `lastBeat` timestamp triggers CloudKit sync cycles+- **MCPWriteReceipt** → same-store accepted/terminal write state and saved replay result, scoped to the originating local store even when synced  Both tasks and milestones have a UUID and a separate `permanentDisplayId` integer for human-facing use (T-1, M-3), allocated via CloudKit counter records with optimistic locking and provisional fallback when offline. @@ -147,8 +148,11 @@ Key implementation files: - `MCP/MCPToolDefinitions.swift` — tool schemas with input validation - `MCP/MCPTypes.swift` — JSON-RPC request/response types - `MCP/MCPHelperTypes.swift` — query filter logic (`MCPQueryFilters`)+- `MCP/Writes/MCPWriteCoordinator.swift` — key acceptance, revision checks, atomic domain/result saves, and replay/recovery+- `MCP/Writes/MCPWriteReceiptStore.swift` and `MCPLocalReservationStore.swift` — synced receipts and local durable payload guards+- `MCP/Writes/MCPRecordSnapshot.swift` — normalized records and content revision coverage -The MCP server reuses the same service instances as the UI (shared `mainContext`), so changes from MCP calls appear immediately in the app.+The MCP server reuses the same service instances as the UI (shared `mainContext`), so changes from MCP calls appear immediately in the app. `TransitApp` retains one write coordinator and store-scoped sidecar for its lifetime; listener restarts do not release accepted operations or their lock. Protected writes require keys, and updates/deletion require revision preconditions; MCP results wrap full saved records rather than matching App Intent response envelopes. See [docs/mcp-write-contract.md](docs/mcp-write-contract.md) before changing schemas or examples. Domain changes and their terminal receipt share one synchronous save; guards remain durable when outcome recovery is uncertain.  ### Reports 
README.md Modified +2 / -0
diff --git a/README.md b/README.mdindex f725af1..cc4ba47 100644--- a/README.md+++ b/README.md@@ -68,6 +68,8 @@ Transit includes a built-in MCP server on macOS for AI agent integration. Enable  `create_task`, `update_task_status`, `query_tasks`, `update_task`, `add_comment`, `get_projects`, `create_project`, `create_milestone`, `query_milestones`, `update_milestone`, `delete_milestone` +The eight write tools require an `idempotencyKey`. Task/milestone updates and milestone deletion also require the target's current `expectedRevision`. Read a revision before updating, and retry an interrupted request with the same key and arguments. Responses use structured saved-record outcomes; see the [MCP write contract](docs/mcp-write-contract.md) for examples, seven-day replay retention, conflicts, and local-store limits. App Intent inputs are unchanged.+ ## Documentation  - `specs/transit-v1/` — requirements, design, architecture, tasks, and decision log
docs/agent-notes/mcp-server.md Modified +10 / -6
diff --git a/docs/agent-notes/mcp-server.md b/docs/agent-notes/mcp-server.mdindex 1897929..fb07c13 100644--- a/docs/agent-notes/mcp-server.md+++ b/docs/agent-notes/mcp-server.md@@ -7,7 +7,7 @@ Embedded MCP server in the Transit macOS app using Hummingbird HTTP server. Expo ## Architecture  ```-Claude Code ←→ HTTP POST + session GET/SSE /mcp (localhost:3141) ←→ MCPServer ←→ MCPToolHandler ←→ TaskService/ProjectService/CommentService ←→ SwiftData+Claude Code ←→ HTTP POST + session GET/SSE /mcp (localhost:3141) ←→ MCPServer ←→ MCPToolHandler ←→ read services / MCPWriteCoordinator ←→ SwiftData ```  - **Transport**: Streamable HTTP at `/mcp`. `POST /mcp` carries JSON-RPC requests and client notifications; a successful standalone `initialize` returns an `Mcp-Session-Id`. A GET with that session ID and an exact acceptable `text/event-stream` media range opens the optional SSE channel for server-initiated notifications. Missing session IDs return 400, unknown IDs return 404, and GET without SSE negotiation remains HTTP 405 with `Allow: POST`.@@ -41,6 +41,8 @@ Key challenge: Hummingbird runs on SwiftNIO event loops (nonisolated), but servi  ## Tools Exposed +All eight write tools require `idempotencyKey`; updates and milestone deletion also require `expectedRevision`. Their saved records and structured retry/conflict outcomes follow [the write contract](../mcp-write-contract.md). Read tools and gated maintenance tools retain their separate dispatch paths.+ | Tool | Description | |------|-------------| | `create_project` | Create a project (name and colorHex required; description and gitRepo optional). Returns projectId and project metadata for subsequent create_task calls. |@@ -130,6 +132,8 @@ Added `com.apple.security.network.server` and `com.apple.security.network.client  ## Testing with curl +Protected calls follow the [MCP write contract](../mcp-write-contract.md): supply a fresh key for a new logical request and reuse it unchanged for retries. Updates and milestone deletion also need the current revision from a read. The create example assumes an existing project named `Agent Work`.+ ```bash # List tools curl -X POST http://localhost:3141/mcp -H 'Content-Type: application/json' \@@ -137,7 +141,7 @@ curl -X POST http://localhost:3141/mcp -H 'Content-Type: application/json' \  # Create task curl -X POST http://localhost:3141/mcp -H 'Content-Type: application/json' \-  -d '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"create_task","arguments":{"name":"Test","type":"feature"}}}'+  -d '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"create_task","arguments":{"name":"Test","type":"feature","project":"Agent Work","idempotencyKey":"curl-create-task-001"}}}' ```  ## Claude Code Integration@@ -168,16 +172,16 @@ MCPToolHandler, App Intents, and IntentHelpers all delegate to these methods rat - **Always validate UUID filter parameters separately from presence checks.** Never use `flatMap(UUID.init)` or combined conditionals like `if let str = ..., let uuid = UUID(str)` for user-provided filter values — these silently drop invalid inputs. Instead, first check if the key is present, then validate the UUID format with a guard, returning an explicit error on failure. See `handleQueryTasks` for the correct pattern; `handleQueryMilestones` uses `resolveProjectFilter` helper (T-665). This applies to both query and create flows — T-743 fixed the same pattern in `handleCreateTask`, `handleCreateMilestone`, `CreateTaskIntent`, and `CreateMilestoneIntent`. The `resolveMilestone` helper also follows this pattern for both `displayId` (T-634) and `milestoneId` (T-769). - **Always validate enum filter values in query handlers.** When a handler accepts `status`, `not_status`, or `type` as filter parameters, validate each value against the enum's `allCases` before using them. Invalid values must return `isError: true` with a message listing valid options — never silently filter to empty results. Helper: `validateEnumFilter(_:key:type:)` in `MCPToolHandler` — generic over any `RawRepresentable & CaseIterable` enum with `String` raw values (T-732). - **Reuse IntentHelpers instead of implementing private handler-local helpers.** `IntentHelpers` provides shared utilities for metadata extraction, JSON parsing, task/milestone resolution, and error mapping. Don't duplicate this logic in MCPToolHandler — use the shared version to ensure consistent behavior across MCP and App Intent paths (T-723).-- **`update_task` distinguishes "omit" from "clear".** Omitting a field leaves the stored value untouched; passing `description: ""` or whitespace-only clears the description, and passing `metadata: {}` clears all metadata. An identifier-only request (no mutating field) is a no-op echo — the task is returned without a save. Both `update_task` and `UpdateTaskIntent` route through `TaskUpdateValidator` + `IntentHelpers.taskUpdateResponseDict`, so success payloads are equivalent across surfaces (enforced by `UpdateTaskAllFieldsParityTests`).+- **`update_task` distinguishes "omit" from "clear".** Omitting a field leaves the stored value untouched; passing `description: ""` or whitespace-only clears the description, and passing `metadata: {}` clears all metadata. A request with only identity and required safety inputs leaves domain state/revision unchanged but persists its replay receipt. MCP returns a full saved record inside a committed outcome; App Intents keep their existing response shape. `UpdateTaskAllFieldsParityTests` compares domain fields after explicitly checking MCP null/empty values and applying Intent omission rules.  ## Project creation -`create_project` accepts required `name` and `colorHex` strings. Names are trimmed and must be non-empty and unique under the same case-insensitive policy as UI creation. Colors must contain exactly six ASCII hexadecimal digits, optionally prefixed by `#`; case and prefix are preserved. Optional `description` defaults to `""`; `gitRepo` is omitted when absent. Both optional fields must be strings when present (JSON null is rejected). Their contents pass through unchanged, and gitRepo remains free-form like the UI field.+`create_project` accepts required `name`, `colorHex`, and `idempotencyKey` strings. Names are trimmed and must be non-empty and unique under the same case-insensitive policy as UI creation. Colors must contain exactly six ASCII hexadecimal digits, optionally prefixed by `#`; case and prefix are preserved. Optional `description` defaults to `""`; both description and gitRepo must be strings when present (JSON null is rejected). Their contents pass through unchanged, and gitRepo remains free-form like the UI field.  Example `tools/call` params:  ```json-{"name":"create_project","arguments":{"name":"Agent Work","colorHex":"007AFF","description":"Tasks created through MCP","gitRepo":"git@example.com:team/project.git"}}+{"name":"create_project","arguments":{"name":"Agent Work","colorHex":"007AFF","description":"Tasks created through MCP","gitRepo":"git@example.com:team/project.git","idempotencyKey":"agent-project-001"}} ``` -Success returns a JSON object inside `content[0].text` with `projectId` (UUID), `name`, `description`, `colorHex`, `activeTaskCount: 0`, and `gitRepo` when supplied. Pass the returned `projectId` to `create_task` as its projectId argument. `get_projects` includes the new project immediately. Invalid fields, duplicate names, and storage failures return `isError: true`. Creation uses ProjectService's insert/save cleanup and is blocked while fallback storage is active.+Success returns a committed JSON outcome inside `content[0].text`, with the full project in `record`, its UUID in `entityId`, and replay expiry. Pass `record.projectId` to `create_task` with a separate key. `get_projects` includes the new project immediately. Invalid fields, duplicate names, and storage failures return structured error outcomes with `isError: true`. The coordinator commits the project and terminal receipt together and blocks creation while fallback storage is active.
docs/mcp-write-contract.md Added +59 / -0
diff --git a/docs/mcp-write-contract.md b/docs/mcp-write-contract.mdnew file mode 100644index 0000000..7ee9416--- /dev/null+++ b/docs/mcp-write-contract.md@@ -0,0 +1,59 @@+# MCP write contract++Transit protects `create_task`, `create_project`, `create_milestone`, `add_comment`, `update_task`,+`update_task_status`, `update_milestone` and `delete_milestone`. Each requires `idempotencyKey`.+The four update/deletion tools also require the target's `expectedRevision` from a full read response.+Unknown fields and malformed inputs are rejected before accepting a key. Maintenance tools and App+Intents retain their existing input contracts.++Keys are case-sensitive and match `[A-Za-z0-9._:-]{1,128}`. Generate a fresh UUID for each logical write.+The namespace is one local store plus tool name, independent of JSON-RPC request ID, connection and+MCP session. Request identity includes every argument except the key, including the original revision.+Object order is ignored; array order, Boolean versus number, absence versus null and explicit versus+omitted defaults remain significant. JSON numbers are compared by value.++For example, read `query_tasks` with `{"displayId":42}`, then call `update_task` with:++```json+{"taskId":"<taskId from read>","name":"Reviewed","expectedRevision":"<revision from read>","idempotencyKey":"<fresh UUID>"}+```++If the response is lost, repeat those exact arguments with that same key. A retained completion+replays the original saved record, revision and metadata even after editing or deleting the target.+Reusing a retained key with different arguments returns `IDEMPOTENCY_KEY_REUSED` without mutation.++Protected responses are JSON in MCP `content[0].text`. Committed responses include `contractVersion:1`,+`tool`, `idempotencyKey`, `outcome:"committed"`, `accepted:true`, `entityId`, the full saved `record`,+`completedAt` and `replayExpiresAt`. The record contains its `revision`. Status with a comment also+returns the full saved `comment`; both persist together. Milestone deletion returns `deleted:true`+and `recordBeforeDeletion`, including its pre-deletion revision; it has no surviving milestone revision.++Errors set MCP `isError:true` and contain `error:{code,message}`, `outcome`, `accepted` and `retryAction`.+Malformed protocol envelopes and unknown/disabled tools continue to use JSON-RPC errors.++| Outcome | Meaning | Action |+|---|---|---|+| `rejected` | Proven no effect from this requested write. Accepted rejections are retained with expiry. | `new_request_new_key` after correction; storage-unavailable/busy requests use `retry_same_request`. |+| `in_progress` | Matching accepted work is active. | `retry_same_request`. |+| `uncertain` | Storage cannot establish the whole operation's commitment. | `reconcile`; never automatically issue a fresh-key retry. |++`accepted` is true for a confirmed durable payload binding, false for proven non-acceptance, and null+when retry storage cannot determine earlier acceptance. `REVISION_CONFLICT` is a retained no-effect+rejection containing `currentRecord` and its revision. Inspect that record before writing with a new+key. `INTERRUPTED_BEFORE_COMMIT` proves that an accepted operation's atomic domain/result save did+not complete; it is retained as a rejection rather than rerunning the operation.++Completed outcomes are retained for seven days from completion. Their absolute `replayExpiresAt`+does not extend on replay. Stop treating retries after that deadline as protected: once removed, a+key may be accepted as new work. Unresolved bindings never expire under this policy. Cross-device+deduplication is not provided, even when CloudKit synchronizes receipt records.++Revisions match `r1:[0-9a-f]{64}` and compare exact locally observed entity content. Task revisions+cover its own stored fields, assignments and comment content/membership; parent project/milestone+renames do not invalidate the task. Milestone revisions exclude its task collection; project revisions+exclude child collections. No-ops keep their revision; restoring identical covered content restores+the same token. Tokens are neither timestamps nor monotonic counters. Edits not yet imported from+CloudKit cannot be detected, and later sync merges can still conflict.++These outcome and revision semantics are shared vocabulary for T-2384. They introduce no batch+mutation application or dry-run behavior; existing ordered JSON-RPC batches remain non-atomic.
specs/OVERVIEW.md Modified +14 / -0
diff --git a/specs/OVERVIEW.md b/specs/OVERVIEW.mdindex f20cf02..a9e8ee2 100644--- a/specs/OVERVIEW.md+++ b/specs/OVERVIEW.md@@ -34,6 +34,7 @@ | [Search Empty State](#search-empty-state) | 2026-05-31 | Done | Show ContentUnavailableView.search empty state when dashboard text search has no matches | | [Task Priority](#task-priority) | 2026-06-06 | Done | Add a low/medium/high priority field with board glyph, filter, and MCP/Intent support | | [MCP Project Creation](#mcp-project-creation) | 2026-10-02 | Ready for Review | Create projects through MCP with validation and reusable project metadata |+| [MCP Write Safety](#mcp-write-safety) | 2026-10-03 | Done | Add retry-safe MCP writes, local revision preconditions, and structured saved outcomes |  --- @@ -326,3 +327,16 @@ Create projects through MCP with validation and a returned UUID for task creatio - [implementation.md](mcp-project-creation/implementation.md) - [explanation.md](mcp-project-creation/explanation.md) - The generated `pre-push-review.html` is a local, ignored review deliverable.++## MCP Write Safety++Protect MCP writes with durable retry receipts, local content revisions, and structured saved outcomes (T-2380). The approved plan starts with persistence probes before handler integration.++All 18 coding tasks are implemented and review findings are resolved. Verification passed 1,853 macOS unit tests and 1,308 iOS unit/UI tests; implementation and phase changelog commits are recorded in the implementation report.++- [requirements.md](mcp-write-safety/requirements.md)+- [design.md](mcp-write-safety/design.md)+- [decision_log.md](mcp-write-safety/decision_log.md)+- [tasks.md](mcp-write-safety/tasks.md)+- [prerequisites.md](mcp-write-safety/prerequisites.md)+- [implementation.md](mcp-write-safety/implementation.md)
specs/mcp-write-safety/decision_log.md Added +192 / -0
diff --git a/specs/mcp-write-safety/decision_log.md b/specs/mcp-write-safety/decision_log.mdnew file mode 100644index 0000000..2f7d84d--- /dev/null+++ b/specs/mcp-write-safety/decision_log.md@@ -0,0 +1,192 @@+# Decision Log: MCP Write Safety++## Quick Decisions++| ID | Date | Decision | Rationale |+|----|------|----------|-----------|+| Q1 | 2026-10-03 | Use the full spec workflow for T-2380. | Approved scope assessment: the feature changes a public mutation contract and may require persisted retry state. |+| Q2 | 2026-10-03 | Name the feature `mcp-write-safety`. | User approved the proposed name. |+| Q3 | 2026-10-03 | Compatibility with callers omitting safety fields is not required. | User stated existing MCP callers can update; draft requires keys on protected writes and revisions on updates/deletion. |+| Q4 | 2026-10-03 | Guarantee replay within the same local store across app restarts. | User accepted the recommendation; cross-device deduplication would need stronger coordination than local writes. |+| Q5 | 2026-10-03 | Guarantee replay for at least seven days after completion, with returned expiry. | User accepted the recommended retention window. |+| Q6 | 2026-10-03 | Clarify status-plus-comment persistence as both-or-neither through interruption; include expiry on retained rejection outcomes. | Critic and both independent validation peers found these necessary to make retry outcomes unambiguous. |+| Q7 | 2026-10-03 | Approve requirements and proceed to design. | User approved the reviewed requirements, including the revision boundary in Decision 1. |+| Q8 | 2026-10-03 | Approve design, including Decisions 3–5, and proceed to task planning. | User approved the design after final critic and peer review. |+| Q9 | 2026-10-03 | Approve the 14-task implementation plan. | User approved seven red/green pairs with persistence verification before dependent integration. |+| Q10 | 2026-10-03 | Create branch `T-2380/mcp-write-safety`. | User chose this branch and created it after sandbox access blocked the agent's attempt. Verified the checkout is now on this branch. |+| Q11 | 2026-10-03 | Mark T-2380 ready for implementation. | Requirements, design and all 14 planned tasks are approved; branch selection is complete. |+| Q12 | 2026-10-03 | Add review-fix red/green tasks 15–16 within the approved scope. | Phase review found lossy numeric request identity and missed legacy safety/envelope migrations; both fixes are required to satisfy existing acceptance criteria. |+| Q13 | 2026-10-03 | Retain In Progress status after coding and focused review. | All 16 tasks are implemented, but full application/transport verification and required Git commits are blocked by the current environment; do not claim these gates passed. |+| Q14 | 2026-10-03 | Add application-gate red/green tasks 17–18 and preserve established domain behavior. | Actual execution exposed compiler issues and 16 contract/fixture failures; fixes distinguish mandatory safety/full-write-record changes from unintended validation, normalization and summary-query regressions. |+| Q15 | 2026-10-03 | Complete implementation verification and move to review. | Permission restrictions resolved; all 18 tasks complete, focused 115/115, macOS 1,853/1,853 and iOS unit/UI 1,308/1,308 pass. Final review has no material findings; implementation and changelog commits are confirmed. |+| Q16 | 2026-10-03 | Validate one keyed guard snapshot and one receipt pass per cleanup. | Pre-push review found repeated guard scans made maintenance quadratic; a per-pass snapshot preserves validation and lock semantics without a stale persistent cache. |+| Q17 | 2026-10-03 | Require complete terminal envelopes before replay and reuse shared scalar parsers. | Malformed receipts must remain uncertain; exact integer boundaries must agree with existing intent parsing. Focused regression probes passed. |++## Decision 1: Limit Revisions to Defined Entity State++**Date**: 2026-10-03+**Status**: accepted++### Context++MCP responses can include related records and summaries. Covering every expanded value would make a project rename invalidate assigned tasks even when their own state did not change. Revision coverage must be explicit to make conflict behavior testable.++### Decision++Cover each entity's own stored scalar fields and explicit relationship IDs. Task revisions additionally cover comment membership and comment fields. Exclude related project/milestone descriptive fields, parent collections, and derived summaries.++### Rationale++This detects changes to a task's editable state and discussion while avoiding unrelated task conflicts after a project or milestone rename. The user approved this boundary with the requirements.++### Alternatives Considered++- **Cover all expanded response fields**: Detects any visible response difference but couples task updates to unrelated parent edits and summary changes.+- **Cover only each entity's scalar fields**: Reduces conflicts but misses task assignment changes and additions or edits to its discussion.++### Consequences++**Positive:**+- Callers have a defined conflict boundary across local write paths and imported sync.+- Renaming an assigned project or milestone does not invalidate task preconditions.++**Negative:**+- A task's revision does not prove that every related descriptive value in an expanded response is unchanged.+- Appending a comment invalidates outstanding task update preconditions.++---++## Decision 2: Persist Receipts Alongside Domain Records++**Date**: 2026-10-03+**Status**: accepted++### Context++Retry safety after restart requires durable evidence of whether a write completed. Storing that evidence separately from the domain store creates a failure window between two independent commits.++### Decision++Store receipts in the existing SwiftData store and complete them in the same save as domain changes. Scope keys using a local persistent identity even when CloudKit synchronizes receipts. Verify local crash atomicity before integrating the handlers.++### Rationale++The user approved this approach after considering its sync behavior. Apple documents a ModelContext save as the boundary grouping pending changes; the implementation probe checks that the required recovery behavior holds on Transit's runtime.++### Alternatives Considered++- **Separate local journal**: Avoids syncing receipts but requires recovery across independent commits, including an ambiguous window after domain persistence.+- **Memory-only receipts**: Avoids a schema change but fails replay protection across app restart.++### Consequences++**Positive:**+- Durable completion evidence does not depend on the target continuing to exist.+- One local commit binds the effect to its normalized result.++**Negative:**+- Receipt payloads and results consume synced storage when CloudKit is active.+- Shipping requires an additive entity and CloudKit schema publication.+- Local crash/save behavior must pass the early disk-backed probe.++---++## Decision 3: Derive Revisions from Covered Content++**Date**: 2026-10-03+**Status**: accepted++### Context++Tasks can change through UI, intents, maintenance, and imported sync. A counter updated only by MCP would miss these paths; a shared counter field would also need reliable distributed merge semantics.++### Decision++Hash exact versioned snapshots of the covered state with SHA-256. Do not add persisted revision counters. Treat tokens as content equality, including the possibility of an identical token after an edit is reverted completely.++### Rationale++Snapshots capture any locally visible change without new write hooks. Requirements define equality comparisons and stable no-op tokens rather than an edit-history sequence.++### Alternatives Considered++- **Increment a persisted counter on every write**: Requires hooks in all writers and still cannot detect imported edits reliably from merged counter values.+- **Use lastStatusChangeDate**: Misses ordinary field/comment edits and loses precision in current MCP timestamp formatting.++### Consequences++**Positive:**+- Local UI/intent/maintenance and synced state use the same revision logic.+- Identical covered state has a stable token across launches.++**Negative:**+- Tokens do not detect intervening changes that restore exactly the same state.+- Task snapshot capture requires reading its comments.++---++## Decision 4: Retain the Shared Main Context++**Date**: 2026-10-03+**Status**: accepted++### Context++Transit's services share the view context. A context-wide rollback can otherwise discard unrelated unsaved work, and creation helpers can leave ghost models if new inserts are not explicitly removed.++### Decision++Save any existing pending changes before acceptance and again after asynchronous preparation, before domain mutation. Keep the mutation, snapshot encoding, receipt completion, and final save synchronous; remove fresh inserts before rollback. A baseline save failure preserves pending edits and does not invoke rollback.++### Rationale++This retains the existing service/context integration while isolating rollback to the newly staged operation. It requires creation preparation to allocate IDs before inserting models.++### Alternatives Considered++- **Independent writable MCP context/services**: Isolates rollback but changes model visibility and would require independent fresh-read and UI merge behavior throughout the MCP service graph.+- **Hold an unsaved transaction across allocation waits**: Allows UI/autosave work to persist or become entangled with partial MCP changes.++### Consequences++**Positive:**+- Existing view/service model identity stays intact.+- Failure cleanup cannot discard edits made while ID allocation was suspended.++**Negative:**+- A protected request can flush pending changes from other local work, matching existing shared-context saves.+- Task/milestone create services need separate preparation and synchronous application APIs.++---++## Decision 5: Preserve Uncertain Bindings in Local Guards++**Date**: 2026-10-03+**Status**: accepted++### Context++A receipt can become unreadable or missing after confirmed acceptance. An in-memory block cannot protect that key after another restart; creating quarantine only after discovering the loss also leaves a crash window.++### Decision++Persist local reservation guards before acceptance, retaining canonical payload and receipt identity through terminal retention. A guard without a valid receipt yields uncertainty and prevents another effect. Unreadable guard storage fails closed for new writes in that scope. Domain outcomes still commit with receipts in the single SwiftData save.++### Rationale++The critic and both validation peers identified this gap. A durable payload binding enforces required uncertain-key retention without interpreting missing domain records as proof of rejection.++### Alternatives Considered++- **Reactive quarantine only**: Cannot cover a crash before the quarantine marker is persisted.+- **Volatile blocking or assuming missing means uncommitted**: Can lose accepted-key protection on restart and duplicate an uncertain effect.++### Consequences++**Positive:**+- Matching and mismatched uncertain retries remain identifiable across restart.+- Outcome persistence remains atomic with the domain effect.++**Negative:**+- A local guard store adds durable metadata and cleanup coordination.+- Receipt loss can require manual reconciliation even when no domain effect actually occurred.
specs/mcp-write-safety/design.md Added +171 / -0
diff --git a/specs/mcp-write-safety/design.md b/specs/mcp-write-safety/design.mdnew file mode 100644index 0000000..76ff558--- /dev/null+++ b/specs/mcp-write-safety/design.md@@ -0,0 +1,171 @@+# Design: MCP Write Safety++Ticket: T-2380 | Requirements: approved | Design: approved on 2026-10-03++## Overview++Protect the eight specified MCP writes with a durable receipt and a comparison against current local record state. The receipt's completed result and the domain mutation share one SwiftData save; replay reads the receipt without resolving or modifying the target.++## Architecture++`MCPToolHandler.handleToolCall` routes protected tools through one `MCPWriteCoordinator` owned by `TransitApp`. Existing read tools and gated maintenance tools retain their dispatch paths. The coordinator uses the existing services and `container.mainContext`; no view-provided model crosses into another writable context. The save boundary follows [Apple's description of SwiftData transactions](https://developer.apple.com/videos/play/wwdc2024/10075/); crash durability is an early verification gate below.++Add `MCPWriteReceipt` to the existing single-store schema on all platforms. Receipts sync with that store but are identified by `(localScopeID, tool, key)`. A local sidecar beside the configured store contains the scope UUID, created atomically on first use and retained across launches and sync preference changes. Failure to read or persist this identity disables protected writes; it never falls back to a session UUID. Reinstall, store replacement, or removal of local identity is outside the same-local-store guarantee. Test fixtures inject scope identity.++The local sidecar directory also holds reservation guards: scope/tool/key, canonical payload and format version, receipt UUID, and optional terminal expiry. Persist each guard before accepting its key using atomic file replacement and durability checks. Guards retain payload binding when a receipt cannot be read or is missing; they contain no domain result and do not participate in committing a domain effect. A guard without a valid receipt blocks that key as uncertain, including after restart. Unreadable or inconsistent guard storage disables new protected writes for the scope rather than regenerating it. Retain guards through terminal replay expiry; unresolved guards never expire.++A store-scoped advisory file lock is held for the lifetime of an active MCP write coordinator. A second process using the same store cannot enable protected writes while another holds it; failure returns `STORE_BUSY`. Within the process, an active-request map reserves each key before any suspension. All synchronous mutation sections execute on MainActor. No database uniqueness constraint or cross-device exclusion is assumed.++### Write sequence++1. Validate the arguments envelope, tool's allowed fields, key, revision syntax, and scalar input types. Reject unknown fields and malformed requests without reserving a key. Perform persistence-availability and store-lock checks.+2. Canonicalize arguments, then inspect the active map, durable local guards, and receipts after eligible expiry cleanup. Compare payloads before replay: mismatch returns `IDEMPOTENCY_KEY_REUSED`; matching active work returns `OPERATION_IN_PROGRESS`; matching completed work returns its stored result. No target lookup occurs on replay.+3. For a new key, establish a saved baseline of any existing main-context changes using `context.save()` before inserting the receipt. Failure leaves those changes intact and rejects before acceptance. Persist its local guard; the key is accepted once its payload binding is confirmed durable. Insert an `accepted` receipt and save it before asynchronous preparation. No domain command runs until this receipt is confirmed durable. A thrown guard/reservation save requires durable inspection before declaring rejection or allowing key reuse: it does not prove that acceptance failed. If no domain command has run, a live operation can prove no domain effect and persist a terminal rejection; inability to persist/read that outcome returns uncertainty with the guard intact.+4. Resolve identifiers and validate domain constraints. Task/milestone creation allocates a display ID without inserting a model. Its prepared command pins resolved reference UUIDs and normalized inputs. Allocation may consume a counter value even when the request is later rejected; counter gaps are not a domain effect.+5. After preparation, establish another saved baseline before touching domain models. If that save fails, leave existing edits intact and return an unresolved outcome for the accepted key. Otherwise re-resolve pinned UUIDs, validate references/uniqueness again, and check `expectedRevision` against a freshly captured local snapshot. There is no suspension from this check through the final save.+6. Apply the command without internal saves, build the normalized saved-record snapshot and revision, and encode the complete response. Set the receipt to `committed` with that response, completion time, and expiry. Save the domain changes and receipt together. Even a domain no-op completes its receipt while keeping the entity revision unchanged.+7. Record the terminal receipt's expiry on its guard, then return the persisted response. Failure to update the guard cannot undo a completed domain/result save: preserve the guard without expiry, replay the terminal receipt, and retry that metadata update later using the original deadline. Clear the active map only after completion or classification as unresolved; caller disconnect or notification response suppression does not discard a reserved key.++Only steps before domain mutation may suspend. Disable autosave for the synchronous mutation/serialization/save section and restore its prior setting afterward. Establishing the saved baseline is consistent with existing shared-context save behavior: it may persist pending changes from other local work, but rejection-with-no-effect refers to the requested MCP mutation. No baseline save failure invokes context-wide rollback.++### Rejections and recovery++Conclusive validation, lookup, revision, and cancellation failures after acceptance are saved as `rejected` receipts with a seven-day expiry. Preserve the exact rejected result, including the conflict snapshot. A corrected request uses a new key. If persisting that rejection fails, keep the accepted key unresolved and return `OUTCOME_UNCERTAIN` until storage is readable.++For mutation/serialization/save failure, remove newly inserted domain models before `safeRollback()`, which also refaults receipts. This happens only after a saved baseline, with no intervening suspension, so rollback cannot discard unrelated pending edits. Inspect the receipt through a fresh read-only context retaining its container:++| Durable receipt | Classification and action |+|---|---|+| Valid completed result | Return its stored committed/rejected outcome. |+| `accepted`, no active operation | The atomic domain/result save did not complete. Persist and return `INTERRUPTED_BEFORE_COMMIT`, rejected with no domain effect; never rerun this accepted request automatically. |+| `accepted`, active operation | Return `OPERATION_IN_PROGRESS`, retry the same request. |+| Unreadable, missing after confirmed acceptance, malformed, or conflicting duplicate receipts | Return `OUTCOME_UNCERTAIN`; the durable guard retains the original binding and stops automatic writes for that key across restart. A mismatched retry still returns `IDEMPOTENCY_KEY_REUSED`. |++The same recovery table applies after restart. Recovery uses durable receipt state, not target presence: the target may have been edited or deleted after a successful write. A thrown save is not alone evidence of rejection. Where storage cannot prove an outcome, callers must reconcile by reading domain records; this feature exposes no force-retry or key-reset tool.++Expired terminal receipts and guards are removed lazily before key lookup and during launch cleanup. First confirm the terminal receipt and record its original expiry in the guard; after that deadline either cleanup order is safe, because a remaining guard proves the protected window ended. A guard lacking terminal expiry prevents removal of its receipt until that metadata is repaired. Never remove accepted/unresolved receipts or guards under age-based cleanup. Only the originating scope cleans its receipts; imported receipts from other scopes never authorize replay, reserve a local key, or affect a local revision. Conflicting duplicates within the same scope fail closed rather than selecting a winner.++## Components and Interfaces++New code lives under `MCP/Writes/`, except the cross-platform receipt model in `Models/`.++| Component | Contract |+|---|---|+| `MCPWriteCoordinator.execute(tool:arguments:) async -> MCPToolResult` | Owns acceptance, active keys, preparation, commit, rejection persistence, and recovery. Inject clock, identity, lock, and save/read fault seams. |+| `MCPWriteCommand` / `PreparedMCPWrite` | Typed domain command; asynchronous preparation allocates IDs only. Synchronous application validates live references and returns immutable result snapshots, tracking inserted models for cleanup. |+| `MCPWriteReceiptStore` | Scoped fetch, terminal cleanup, duplicate detection, recovery reads, and same-context receipt staging. It never independently saves a domain mutation. |+| `MCPLocalReservationStore` | Local scope identity, durable payload guards, process lock, guard expiry repair, and fail-closed startup/lookup. Guard comparison occurs before receipt recovery; absent guard for an existing receipt blocks new execution until the binding is reconstructed durably from that receipt. |+| `MCPRecordSnapshot` / `MCPRecordRevision` | One captured set of fields produces both MCP record JSON and its revision. Throw on incomplete comment fetch; do not issue a token for incomplete state. |+| `MCPCanonicalJSON` | Deterministic, typed encoding used for request identity and revision hashing; no lossy timestamp formatting or implicit Boolean/number bridging. |+| `MCPWriteOutcome` | Codable terminal/transient envelope encoded into MCP text content and retained exactly for terminal replay. |++Expose narrowly scoped service APIs to prepare and apply task/milestone creation, plus deferred-save variants of project creation and milestone deletion. Existing public CRUD defaults keep their current save behavior. The coordinator owns the context via dependency injection; external callers do not access private service contexts.++### Integration and parity audit++| Existing sites/pattern | Equivalent needed | Change |+|---|---|---|+| `TransitApp` schema and MCP handler construction; `TestModelContainer`, `FallbackOutcomeFixture`, full-schema sync fixtures | Yes | Register receipt and inject one coordinator; keep older subset-only model tests unchanged. |+| `ModelContext+SafeRollback.refaultAllEntities` | Yes | Refault `MCPWriteReceipt` after rollback. |+| Handler create task/project/milestone and add-comment methods | Yes | Translate to prepared commands; use deferred domain persistence. |+| Handler status/update task/update milestone/delete milestone methods | Yes | Check snapshot precondition and complete receipt in the same save. |+| `taskToDict`, `milestoneToDict`, `projectMetadataDict`, `commentResponse`, `statusResponse` | Yes | MCP snapshot encoder emits full saved records and revisions, including nested full comments. Summary-only project/milestone entries remain summaries. |+| `TaskService.createTask` (UUID-project overload, AddTaskSheet, CreateTaskIntent, Visual/AddTaskIntent, MCP) | Yes for service internals; no new caller inputs outside MCP | Separate allocation from synchronous insert; existing callers retain create-and-save facade. |+| `MilestoneService.createMilestone` (CreateMilestoneIntent, MilestoneEditView, MCP) | Yes for service internals; no new caller inputs outside MCP | Same prepare/apply split; existing callers retain facade. |+| `ProjectService.createProject` (ProjectEditView, MCP); `deleteMilestone` (MilestoneListSection, DeleteMilestoneIntent, MCP) | Yes | Add deferred-save variants; current callers use saving defaults. |+| `updateStatus` (DashboardView, TaskEditMerge, UpdateStatusIntent, MCP), `setMilestone` (TaskEditMerge, TaskUpdateValidator, IntentHelpers), comment mutations | No new revision-write hooks | Snapshot-derived tokens detect changes regardless of entry point; existing deferred-save behavior serves the coordinator. |+| Shared `IntentHelpers.taskToDict`, `taskUpdateResponseDict`, `milestoneInfoDict` and their intent callers | No safety fields in App Intents | Keep shared serializers unchanged; MCP adds its snapshot projection. |+| `MCPToolDefinitions`; protected handler tests and HTTP tests | Yes | Required safety fields, structured envelopes, and read-then-write test helpers. |+| Notification dispatch and JSON-RPC batch transport | No new protocol path | Protected notifications still execute and record receipts; HTTP/JSON-RPC batching retains its current ordered, non-atomic behavior. |+| Maintenance scan/reassignment dispatch | No | Excluded from receipt protection; resulting domain changes still affect snapshot revisions. |++## Data Models++`MCPWriteReceipt` has no relationships and no unique attribute. All non-optional fields have CloudKit-compatible defaults; optional result fields default to nil.++| Field | Meaning |+|---|---|+| `id: UUID` | Receipt identity, generated before acceptance. |+| `localScopeID: String`, `tool: String`, `key: String` | Local retry namespace. |+| `formatVersion: Int` | Receipt format and canonical-request encoding version. |+| `requestJSON: String` | Canonical accepted payload, excluding key; exact comparison avoids reliance on a hash collision assumption. |+| `stateRawValue: String` | `accepted`, `committed`, or `rejected`. |+| `acceptedAt: Date` | Durable acceptance timestamp. |+| `completedAt: Date?`, `expiresAt: Date?` | Terminal retention deadline: completion + 604800 seconds. |+| `resultJSON: String?`, `resultIsError: Bool?` | Exact terminal response envelope and MCP error flag. |++There is no stored revision counter on domain models. Receipt creation/cleanup does not change their revisions. Add the model to the existing schema without renaming or changing current persisted fields. Production CloudKit schema publication must include the new entity before shipping.++### Revision encoding++Use CryptoKit SHA-256 over a versioned, typed canonical snapshot: `r1:<64 lowercase hex digits>`. This is a content equality token, not an edit-history sequence: editing A to B and back to identical A produces A's token. All comparisons use the current covered state; intermediate states not observed by the caller are not an audit log.++| Entity | Covered state |+|---|---|+| Task | All current scalar fields in `TransitTask` (including raw enum values, `metadataJSON`, timestamps, permanent display ID, and UUID); assigned project/milestone UUIDs; comments sorted by UUID, each including all comment scalar fields and task UUID. |+| Project | UUID, name, projectDescription, gitRepo, colorHex. |+| Milestone | All scalar fields in `Milestone`, plus project UUID. |+| Comment | UUID, content, authorName, isAgent, creationDate, task UUID. |++Encode dates as the exact finite `timeIntervalSinceReferenceDate` bit pattern, UUIDs in lowercase canonical form, and nil distinctly from empty values. Object fields have fixed names; collections whose order is not meaningful are sorted by UUID. Retain raw persisted scalar strings for revision coverage even where returned fields use normalized accessors. The metadata JSON string is covered as stored, so an encoding-only change to that field invalidates a token.++Task revision capture fetches comments from the child side using `CommentService.descriptor`; the same comment snapshot supplies response data. Capture, precondition comparison, mutation, response capture, and final save run without suspension. Imported sync state already visible in the context is included; edits not yet imported and later CloudKit merges remain outside the guarantee.++## Wire Contract and Error Handling++Keys match `[A-Za-z0-9._:-]{1,128}` and are case-sensitive; UUID strings are suitable keys. Expected revisions match `r1:[0-9a-f]{64}`. A request's canonical arguments preserve absent versus null fields, string contents, and array order; recursively sort object keys and compare JSON numbers by value (`1` equals `1.0`), with Booleans distinct from numbers. Omitted defaults and explicit defaults remain different payloads. The receipt version selects the canonicalizer for retained replay across app upgrades.++Protected tool results use JSON in `content[0].text`, with `isError: true` for rejected or unresolved outcomes. Keep JSON-RPC errors for invalid protocol envelopes or unknown/disabled tools. The full record body uses existing normalized MCP field names and includes `revision`. All full records from read tools use the same encoder.++```json+{+  "contractVersion": 1,+  "tool": "update_task_status",+  "idempotencyKey": "caller-generated-uuid",+  "outcome": "committed",+  "accepted": true,+  "entityId": "saved-task-uuid",+  "record": {"taskId": "saved-task-uuid", "revision": "r1:..."},+  "comment": null,+  "completedAt": "ISO-8601 timestamp with fractional seconds",+  "replayExpiresAt": "ISO-8601 timestamp with fractional seconds"+}+```++`record` is a complete saved record, not the abbreviated example. Status-plus-comment returns a full comment with UUID and revision alongside the task. Comment creation returns the full saved comment. Milestone deletion returns `deleted: true` and `recordBeforeDeletion`, including its original revision; no post-deletion milestone revision is returned.++Error results use the same envelope with `error: {code, message}`, `outcome`, `accepted`, and `retryAction`. `accepted` is true for a confirmed durable key binding, false when non-acceptance is proven, and null when unreadable reservation storage prevents determining prior acceptance. Terminal accepted rejections include completion and expiry. `REVISION_CONFLICT` additionally carries `currentRecord` with its revision; stored replay returns that original snapshot, not a later live one. Pre-acceptance errors contain the validated tool/key when available but no expiry. A key mismatch does not replace or complete its existing receipt.++| Error | Outcome / retry action |+|---|---|+| `INVALID_INPUT`, missing/ambiguous references, invalid enum/reference/name, `REVISION_CONFLICT`, `CANCELLED`, `INTERRUPTED_BEFORE_COMMIT` | `rejected` / `new_request_new_key`; receipt retained only when already accepted. |+| `IDEMPOTENCY_KEY_REUSED` | `rejected`, `accepted: false` for this mismatched payload / `new_request_new_key`; original receipt remains unchanged. |+| `STORE_BUSY`, `PERSISTENCE_UNAVAILABLE`, storage failure with non-acceptance proven | `rejected`, `accepted: false` / `retry_same_request`; key not reserved. |+| `OPERATION_IN_PROGRESS` | `in_progress`, `accepted: true` / `retry_same_request`. |+| `OUTCOME_UNCERTAIN` | `uncertain`, `accepted: true` (or null if binding storage cannot be read) / `reconcile`; never suggest retry with a fresh key. |++Assign stable codes to existing domain errors rather than embedding prose-only failures. Publish the contract in tool descriptions and `docs/mcp-write-contract.md`, including read→write→same-key replay examples, no-op behavior, expiry, content-token limitations, and T-2384's shared vocabulary. Do not add batch-specific behavior.++## Risks and Assumptions++- Risk: receipt/domain crash durability or refaulting differs on the shipped SwiftData runtime | Verify: first implementation task uses a disk-backed store, child-process termination around save, reopen, and forced save failures | If wrong: stop implementation and revise the persistence design before exposing protected writes.+- Risk: adding the synced receipt entity fails against a production-shaped existing store | Verify: migrate a copied local fixture and validate the CloudKit-compatible schema before wiring handlers | If wrong: preserve the original store and revise the additive migration plan.++## Testing Strategy++Use Swift Testing and the existing owning `TestModelContainer` fixture. Add disk-backed fixtures retaining their containers for restart/recovery tests; injection points control allocation suspension, time, cancellation, save faults, and recovery-read failure. The crash probe uses a temporary test store only.++| Requirements | Verification |+|---|---|+| 1.1–1.3 | All eight schemas and dispatch routes require keys; four require revisions; malformed/unknown inputs leave no receipt or domain effect. |+| 2.1–2.5 | Same-key replay across sessions/restart, mismatch and object reordering, concurrent requests during suspended allocation, replay after target edit/delete, and stale precondition replay precedence. |+| 3.1–3.5 | Fixed clock at expiry boundaries, no expiry extension, retained rejection, unresolved key beyond seven days, cancellation/crash before acceptance and before/after final commit. |+| 4.1–4.6 | Every covered field/relationship and each excluded relationship; UI/service/intent/maintenance edits, separately saved/imported context changes, comments, no-op revisions, unreadable comment fetch, and an intervening edit during allocation. |+| 5.1–5.5 | Normalized saved records/revisions, deletion preimage, all outcome/retry classifications, failed serialization/save/recovery read, both-or-neither status/comment, and later unrelated saves proving no ghost effects. |+| 6.1–6.2 | Contract examples checked against encoders; all preceding suites plus HTTP notification/batch regression coverage. |++Additional recovery tests cover guard persistence and failure/crash windows, a missing receipt followed by another restart with matching and mismatched retries, unreadable guard storage, terminal expiry repair/cleanup in either order, and two-process lock contention and reacquisition after process termination.++For canonicalization, use deterministic generated dictionaries and nested arrays in Swift Testing (no new testing dependency): permutation of object keys preserves identity, Boolean/number and absent/null remain distinct, and round-trip decoded payloads preserve identity. For revisions, generate covered-field mutations and comment-order permutations; tokens must change for different covered state and remain equal for identical covered state.++Run focused tests during implementation, then required `make lint` and `make test-quick`; pre-push checks remain `make test` and `make test-ui`. This design phase changes Markdown only and runs document validation, not application builds.
specs/mcp-write-safety/implementation.md Added +111 / -0
diff --git a/specs/mcp-write-safety/implementation.md b/specs/mcp-write-safety/implementation.mdnew file mode 100644index 0000000..d2dd702--- /dev/null+++ b/specs/mcp-write-safety/implementation.md@@ -0,0 +1,111 @@+# Implementation: MCP Write Safety++Branch: `T-2380/mcp-write-safety` | Ticket: T-2380++All 18 coding tasks are complete, including phase-review and application-gate fixes. The committed implementation passed macOS and iOS gates. The pre-push working-tree fixes described below passed focused production probes and review; the earlier full-suite results are not a fresh run of those fixes.++Implementation commit: `0e23351`. Separate phase changelog commit: `1bcd6d6`.++## Changes++- Added same-store receipts, durable local payload guards, scoped process locking, and seven-day terminal replay retention.+- Added content revisions and full saved-record outcomes; routed eight protected tools through the write coordinator.+- Split creation allocation from synchronous application, preserving existing UI/Intent service behavior and deferred atomic saves.+- Retained one coordinator for the app lifetime; added restart, notification, batch, cancellation, fallback, and imported-state regression fixtures.+- Migrated legacy callers and parity tests without masking malformed-input checks. Preserved tolerant create metadata behavior and fixed numeric identity collisions.++The phase design-critic's numeric-identity and legacy-test findings were fixed and re-reviewed. No material findings remain from that review.++## Confirmed Verification++- Standalone probes compiling actual production SwiftData models and services: additive migration, process termination around save, atomic status/comment/receipt outcomes, read-only save failures, and ghost cleanup.+- Foundation, guard, service, and coordinator probes: canonical numbers, revisions, all eight commands, exact replay, conflicts, concurrent keys, interrupted outcomes, expiry repair, locking, and pending-edit preservation.+- Numeric red probes reproduced adjacent-double collisions and changed-payload replay; green probes passed adjacent values, finite exponent extremes, and signed-zero equivalence.+- Parity probe passed 36 combinations using production serializers and the test projection.+- `make lint`, source syntax checks, and `git diff --check` passed.+- Focused application checks passed 115 tests with no failures.+- `make test-quick` passed all 1,853 macOS unit tests, including the MCP application/transport suites.+- `run_silent -t 15m make test` completed successfully with all 1,308 iOS unit/UI tests passing. An earlier five-minute wrapper timed out and is not counted as a successful command.++The standalone compiler option `MCP_PROBE_SWIFT_FLAGS=-disable-sandbox` disables Swift's nested macro-plugin sandbox only; commands still run inside the unchanged Codex sandbox.++## Application-Gate Fixes++After the permission restrictions were resolved, full compilation exposed a missing SwiftData import and a test returning a non-Sendable model from a child task. These were corrected without changing production actor ownership. The first runtime gate then exposed 16 contract/fixture failures; fixes restored selector precedence, milestone normalization and diagnostics, summary-query shape, and explicit coordinator fault injection. Intentional safety-input/full-write-response changes received matching assertions.++The prior build-cache and Git-index restrictions are resolved. CloudKit Production schema publication remains a separate release prerequisite in [prerequisites.md](prerequisites.md).++## Evidence++Full logs are retained outside the repository:++- `/tmp/t2380-storage-green.log`, `/tmp/t2380-foundation-green.log`, `/tmp/t2380-services-green.log`+- `/tmp/t2380-contract-green.log`, `/tmp/t2380-lifecycle-coordinator.log`+- `/tmp/t2380-review-fix-green.log`, `/tmp/t2380-parity-probe.log`+- `/tmp/t2380-parity-lint.log`, `/tmp/t2380-parity-syntax.log`+- `/tmp/t2380-foundation-test-quick.log`, `/tmp/t2380-foundation-test-quick-offline.log`, `/tmp/t2380-handler-typecheck.log`+- `/private/tmp/t2380-focused-tests.log`, `/private/tmp/t2380-app-test-retry.log`, `/private/tmp/t2380-ios-tests.log`++Complete test/build reports are retained in `DerivedData/Logs/Test/`, including:++- `Test-Transit-2026.10.03_11-54-30-+1000.xcresult` — focused tests.+- `Test-Transit-2026.10.03_11-56-36-+1000.xcresult` — full macOS suite.+- `Test-Transit-2026.10.03_14-15-51-+1000.xcresult` — completed iOS unit/UI suite.++## Pre-Push Review++Four findings are fixed in the working tree: quadratic guard maintenance, incomplete terminal replay validation, lossy duplicate integer validation, and stale MCP documentation. Guard reconciliation now validates one receipt pass and one keyed guard snapshot before changes. Complete terminal outcomes are required before replay; malformed results preserve their bindings and return uncertainty. Integer/Boolean validation reuses the shared intent helpers.++Current focused coordinator/foundation probes passed, including 21 malformed-terminal cases and exact integer boundaries. Lint, handler/lifecycle syntax checks, and whitespace validation passed. Logs: `/private/tmp/t2380-prepush-focused-final.log` and `/private/tmp/t2380-prepush-validation-final.log`.++The configured structured-test runner map matches Swift only through a root `Package.swift`. This Xcode-only repository has no matching runner, so this review reports no fresh JUnit or coverage data. Fixes remain uncommitted pending the user's next step.++## Beginner Explanation++### What This Does++A caller gives each logical write a key. Transit remembers the saved result and returns it when that same request is retried, even if the record later changes or disappears. An update also includes a revision from the caller's read; a different current revision rejects the write instead of overwriting intervening edits.++### Why It Matters++A timeout cannot tell a caller whether a save happened. The saved receipt answers that question when storage is readable. A durable local guard keeps the key reserved when the outcome cannot be recovered, preventing a blind repeat.++### Key Concepts++- A receipt stores the saved record and outcome with the write in one local save.+- A revision is a fingerprint of covered local content, not a global edit counter.+- A retry repeats the same key and arguments; a corrected request uses a new key.++## Intermediate Explanation++### Changes Overview++`MCPToolHandler` translates eight protected tools into typed commands for an app-lifetime coordinator. Read services still share the UI's main context. Creation prepares display IDs before insertion; the final validation, mutation, result encoding, and receipt save contain no suspension.++### Implementation Approach++The coordinator reserves a durable guard, confirms an accepted receipt, prepares asynchronous work, saves a baseline, and checks the current record snapshot. Domain changes and terminal response are committed together. Recovery reads durable receipts rather than inferring success from target existence; replay validates the complete stored envelope. Maintenance validates receipts and guards once per pass, then repairs expiry or removes eligible entries without repeated scans.++### Trade-offs++Receipts sync with the domain store, while their namespace and guards remain local. Content hashes detect changes from any local writer without adding counters, but identical restored content has the same token. Baseline saves can persist other pending local work, matching the shared-context behavior.++## Expert Explanation++### Technical Deep Dive++Canonical request identity preserves absent/null, Boolean/number, and original payload differences while ignoring object key order. Revisions hash exact persisted scalar state, assignment UUIDs, and comment snapshots. Terminal replay checks metadata timestamps, entity identity, complete records and revisions, deletion preimages, optional status comments, and rejected/conflict details. All binding validation precedes maintenance writes; unresolved guards never expire through terminal cleanup.++### Architecture Impact++The local advisory lock and MainActor synchronous commit section protect this process/store boundary. One-pass maintenance is linear in retained records and payload size. It avoids a persistent in-memory cache that could become stale, while retaining fail-closed validation before any file or receipt deletion.++### Potential Issues++Preconditions cannot detect CloudKit edits not yet imported, and later sync can still conflict. Replay protection ends at the returned terminal deadline; unresolved outcomes require reconciliation. Schema publication is a separate release prerequisite. No global deduplication, batch atomicity, or automatic force-retry is claimed.++## Completeness Assessment++- Fully implemented: all eight protected writes, scoped keys, replay/recovery, revision checks, structured outcomes, retention, and documented service/API integration. All review findings are resolved.+- Partially available review evidence: focused production probes and validators pass; fresh structured whole-suite and coverage data are unavailable under the configured runner map.+- Missing implementation requirements: none identified. Release still requires the documented CloudKit schema publication; batch mutations and UI conflict rebasing remain separate scope.
specs/mcp-write-safety/prerequisites.md Added +5 / -0
diff --git a/specs/mcp-write-safety/prerequisites.md b/specs/mcp-write-safety/prerequisites.mdnew file mode 100644index 0000000..296c57d--- /dev/null+++ b/specs/mcp-write-safety/prerequisites.md@@ -0,0 +1,5 @@+# Prerequisites: MCP Write Safety++## Before Shipping++- [ ] Using the Transit CloudKit container's Development environment, verify that the additive `MCPWriteReceipt` record type and its fields are present, then publish that schema to Production through CloudKit Console before releasing either platform. Do not remove or rename existing record types or fields. This is a release prerequisite; local implementation tasks and disk-backed tests do not depend on production publication.
specs/mcp-write-safety/requirements.md Added +89 / -0
diff --git a/specs/mcp-write-safety/requirements.md b/specs/mcp-write-safety/requirements.mdnew file mode 100644index 0000000..791fc5e--- /dev/null+++ b/specs/mcp-write-safety/requirements.md@@ -0,0 +1,89 @@+# Requirements: MCP Write Safety++Ticket: T-2380++## Introduction++MCP callers need to retry interrupted writes without duplicating tasks or comments, and update records without overwriting intervening edits. This feature adds retry keys, revision preconditions, and structured write outcomes within one local Transit store. CloudKit sync remains asynchronous, so these protections do not promise global ordering across devices.++## Non-Goals++- Cross-device deduplication or globally atomic compare-and-swap through CloudKit.+- Batch mutation submission or dry-run previews (T-2384).+- UI conflict rebasing (T-2002), duplicate consolidation, or maintenance-tool retry protection.+- Extending the safety inputs to App Intents in this feature.+- Preserving compatibility for MCP callers that omit required safety inputs.++## Requirements++### 1. Protected Write Inputs++**User Story:** As an MCP caller, I want explicit safety inputs, so that every supported write declares its retry and conflict protection.++**Acceptance Criteria:**++1. <a name="1.1"></a>WHEN calling `create_task`, `create_project`, `create_milestone`, `add_comment`, `update_task`, `update_task_status`, `update_milestone`, or `delete_milestone`, the system SHALL require a non-empty `idempotencyKey`; missing or invalid keys SHALL return `INVALID_INPUT` without mutation.  +2. <a name="1.2"></a>WHEN updating a task, changing its status, updating a milestone, or deleting a milestone, the system SHALL also require the target's `expectedRevision`; missing or invalid revisions SHALL return `INVALID_INPUT` without mutation.  +3. <a name="1.3"></a>The published MCP schemas SHALL identify the required safety fields, their accepted formats, protected operations, local-store scope, and retention limits.  ++### 2. Retry Identity and Replay++**User Story:** As an MCP caller, I want to retry the same logical request, so that a lost response cannot duplicate its effects.++**Acceptance Criteria:**++1. <a name="2.1"></a>The system SHALL scope each accepted key to one local store and tool name, independently of connection, MCP session, and JSON-RPC request ID; the accepted tool arguments, including preconditions but excluding the key, SHALL determine its request identity.  +2. <a name="2.2"></a>WHEN a retained key is retried with the same arguments, the system SHALL return its recorded completed outcome without another logical effect, even after app restart, subsequent record edits, or deletion of the created record.  +3. <a name="2.3"></a>WHEN a retained key is reused with different arguments, the system SHALL return `IDEMPOTENCY_KEY_REUSED` without mutation; JSON object key ordering SHALL NOT count as an argument difference.  +4. <a name="2.4"></a>WHEN simultaneous matching requests use the same key, the system SHALL permit at most one logical effect and SHALL return either the completed outcome or `OPERATION_IN_PROGRESS` to the other callers.  +5. <a name="2.5"></a>WHEN a completed outcome is replayed, the system SHALL preserve the original saved record, revision, and outcome metadata; replay SHALL precede reevaluation of the original revision precondition or target existence.  ++### 3. Retention and Interrupted Outcomes++**User Story:** As an MCP caller, I want a defined retry window and recovery outcome, so that I can safely continue after a timeout or interruption.++**Acceptance Criteria:**++1. <a name="3.1"></a>The system SHALL retain completed outcomes for at least seven days from completion and SHALL return their guaranteed replay expiry as an absolute timestamp; replay SHALL NOT extend that expiry.  +2. <a name="3.2"></a>WHEN a key's retained outcome has expired and been removed, the system MAY accept it as a new request; the published contract SHALL instruct callers to stop treating retries after the returned expiry as protected.  +3. <a name="3.3"></a>WHEN interruption occurs before, during, or after saving an accepted request, retry with its key SHALL resolve to the original completed outcome, a proven no-effect rejection, `OPERATION_IN_PROGRESS`, or `OUTCOME_UNCERTAIN`; the system SHALL NOT repeat a write whose commitment is uncertain.  +4. <a name="3.4"></a>WHILE an accepted key has an unresolved outcome, the system SHALL retain its payload binding across restart and SHALL NOT discard it under the completed-outcome retention policy.  +5. <a name="3.5"></a>WHEN an accepted request is conclusively rejected without effect, the system SHALL retain and replay that rejection; a corrected request SHALL require a new key. Invalid requests rejected before key acceptance SHALL NOT reserve the key.  ++### 4. Record Revisions and Preconditions++**User Story:** As an MCP caller, I want to compare the record I read with the record being changed, so that intervening edits are preserved.++**Acceptance Criteria:**++1. <a name="4.1"></a>WHEN returning a full task, project, milestone, or comment through MCP, the system SHALL return an opaque revision that can be compared for equality; applicable task and milestone read responses SHALL supply revisions usable in write preconditions.  +2. <a name="4.2"></a>WHEN revision-covered state changes locally, the next full response SHALL have a different revision, regardless of whether the change originated in MCP, the UI, App Intents, maintenance, or imported sync. Covered state SHALL be each entity's own persisted scalar fields; task project/milestone UUIDs and comment membership plus comment fields; milestone project UUID; and comment task UUID. Related project/milestone descriptive fields, project task/milestone membership, milestone task membership, and derived summaries SHALL NOT affect the parent's revision.  +3. <a name="4.3"></a>WHEN the target's locally observable revision differs from `expectedRevision`, the system SHALL reject the update or deletion with `REVISION_CONFLICT`, return the current record and revision, preserve the intervening edit, and create no accompanying comment.  +4. <a name="4.4"></a>WHEN a precondition matches, the system SHALL apply it to the state used for the local write, rather than an earlier read before intervening asynchronous work; success SHALL return the resulting saved revision.  +5. <a name="4.5"></a>The contract SHALL define revisions as comparisons against locally observed state, SHALL state that edits not yet imported from CloudKit cannot be detected, and SHALL NOT claim global serialization or prevention of later sync conflicts.  +6. <a name="4.6"></a>WHEN an update leaves the revision-covered state unchanged, the system SHALL preserve its revision; callers SHALL NOT be required to interpret revisions as timestamps or monotonic counters.  ++### 5. Saved Records and Structured Outcomes++**User Story:** As an MCP caller, I want structured saved outcomes, so that I can verify writes and decide how to recover without parsing prose.++**Acceptance Criteria:**++1. <a name="5.1"></a>WHEN a protected write succeeds, the system SHALL return a machine-readable committed outcome containing the tool name, key, saved entity UUID, saved normalized record and revision, and replay expiry; task status changes with a comment SHALL also identify and return the saved comment.  +2. <a name="5.2"></a>WHEN deleting a milestone succeeds, the system SHALL return its UUID, pre-deletion record and revision, and a committed deletion outcome; it SHALL NOT invent a surviving milestone revision.  +3. <a name="5.3"></a>WHEN a protected write fails, the system SHALL return a machine-readable error code and distinguish rejected-with-no-effect, in-progress, and uncertain outcomes; accepted-key outcomes SHALL include the key and tool name, retained conclusive rejections SHALL include replay expiry, and conflict responses SHALL include the current record and revision.  +4. <a name="5.4"></a>WHEN task status and an accompanying comment are submitted together, the system SHALL persist both or neither, including across interruption and restart, and treat them as one logical effect for replay and precondition checking; `OUTCOME_UNCERTAIN` SHALL describe uncertainty about that whole effect rather than permit partial persistence.  +5. <a name="5.5"></a>WHEN an unresolved key is retried, the system SHALL state whether to retry the same request, stop for reconciliation, or use a new key after a conclusive rejection; it SHALL NOT advise a new-key retry for an uncertain commitment.  ++### 6. Shared Contract and Verification++**User Story:** As a developer, I want tested write semantics reusable by batch mutations, so that callers receive consistent protection.++**Acceptance Criteria:**++1. <a name="6.1"></a>The published write contract SHALL define key identity, expiry, revisions, conflict responses, and outcome classifications for reuse by T-2384 without introducing batch application behavior in this feature.  +2. <a name="6.2"></a>Automated verification SHALL cover matching retries, mismatched payloads, concurrent matching requests, restart recovery, seven-day expiry, comment creation, status-with-comment writes, stale edits from supported local write paths, imported sync changes, and interruptions around commit.  ++## Review Status++Approved on 2026-10-03 after critic and independent peer review.
specs/mcp-write-safety/tasks.md Added +137 / -0
diff --git a/specs/mcp-write-safety/tasks.md b/specs/mcp-write-safety/tasks.mdnew file mode 100644index 0000000..f645475--- /dev/null+++ b/specs/mcp-write-safety/tasks.md@@ -0,0 +1,137 @@+---+references:+    - specs/mcp-write-safety/requirements.md+    - specs/mcp-write-safety/design.md+    - specs/mcp-write-safety/decision_log.md+---+# MCP Write Safety++- [x] 1. Red: Write disk durability and additive migration tests <!-- id:ztq9ldq -->+  - Add MCPWritePersistenceProbeTests, retained disk fixtures and a child-process termination test around save. Assert domain/status/comment and completed receipt persist together or neither; reopen an old-schema fixture, force save failure, and prove a later unrelated save leaves no ghost effects.+  - Stream: 1+  - Requirements: [2.2](requirements.md#2.2), [3.3](requirements.md#3.3), [5.4](requirements.md#5.4), [6.2](requirements.md#6.2)++- [x] 2. Green: Implement the receipt model and passing persistence probe <!-- id:ztq9ldr -->+  - Add Models/MCPWriteReceipt.swift with approved fields/defaults; register it in TransitApp and TestModelContainer and FallbackOutcomeFixture and full-schema sync fixtures; extend ModelContext+SafeRollback. Implement the temporary-store crash harness via a Makefile target. Stop and revise design if atomicity or migration or cleanup fails; this is the first integration gate. Verification: make test-mcp-write-persistence MCP_PROBE_SWIFT_FLAGS=-disable-sandbox passed actual-model old-schema migration plus SIGKILL before/after/during save plus read-only save failure and later-save ghost cleanup. Log: /tmp/t2380-storage-green.log. The compiler option disables only nested macro sandboxing; the outer runner sandbox remains active.+  - Blocked-by: ztq9ldq (Red: Write disk durability and additive migration tests)+  - Stream: 1+  - Requirements: [2.2](requirements.md#2.2), [3.3](requirements.md#3.3), [5.4](requirements.md#5.4), [6.2](requirements.md#6.2)++- [x] 3. Red: Write canonical request and revision property tests <!-- id:ztq9lds -->+  - Add MCPCanonicalJSONTests and MCPRecordRevisionTests with deterministic generated nested JSON and object/comment permutations. Cover Boolean/number and absent/null distinctions, every covered scalar/assignment/comment field, excluded relationships, no-ops, exact dates, content restoration, and incomplete comment-fetch failure.+  - Blocked-by: ztq9ldr (Green: Implement the receipt model and passing persistence probe)+  - Stream: 1+  - Requirements: [2.1](requirements.md#2.1), [2.3](requirements.md#2.3), [4.1](requirements.md#4.1), [4.2](requirements.md#4.2), [4.5](requirements.md#4.5), [4.6](requirements.md#4.6), [6.2](requirements.md#6.2)++- [x] 4. Green: Implement canonicalization and snapshot-derived revisions <!-- id:ztq9ldt -->+  - Create MCP/Writes/MCPCanonicalJSON.swift and MCPRecordSnapshot.swift and MCPRecordRevision.swift. Produce normalized records and r1 SHA-256 tokens from one immutable capture with raw scalar coverage and exact date bits and stable UUID ordering. Retain canonicalizer versions for completed replay. Verification: make test-mcp-write-foundation MCP_PROBE_SWIFT_FLAGS=-disable-sandbox passed standalone production-code canonicalization/revision checks. Swift Testing suites include all entity scalars plus comment ordering and fetch failure; full app execution remains pending because package manifest diagnostic writes are blocked.+  - Blocked-by: ztq9lds (Red: Write canonical request and revision property tests)+  - Stream: 1+  - Requirements: [2.1](requirements.md#2.1), [2.3](requirements.md#2.3), [4.1](requirements.md#4.1), [4.2](requirements.md#4.2), [4.5](requirements.md#4.5), [4.6](requirements.md#4.6), [6.2](requirements.md#6.2)++- [x] 5. Red: Write durable guard, process lock and expiry recovery tests <!-- id:ztq9ldu -->+  - Add MCPLocalReservationStoreTests with temporary sidecars and two-process lock fixtures. Cover guard save/crash ambiguity, scope identity, key mismatch, missing receipts across restart, unreadable guards, lock reacquisition, fixed expiry/repair, both cleanup orders and unresolved guards beyond seven days.+  - Blocked-by: ztq9ldt (Green: Implement canonicalization and snapshot-derived revisions)+  - Stream: 1+  - Requirements: [2.1](requirements.md#2.1), [2.3](requirements.md#2.3), [2.4](requirements.md#2.4), [3.1](requirements.md#3.1), [3.2](requirements.md#3.2), [3.4](requirements.md#3.4), [3.5](requirements.md#3.5), [5.5](requirements.md#5.5), [6.2](requirements.md#6.2)++- [x] 6. Green: Implement local guards and scoped receipt storage <!-- id:ztq9ldv -->+  - Create MCP/Writes/MCPLocalReservationStore.swift and MCPWriteReceiptStore.swift. Implement durable identity/guards and lifetime locking; scoped receipt reads plus duplicate detection and expiry repair/cleanup. Never expire unresolved bindings or infer rejection from missing records; keep domain results out of guards. Verification: standalone guards and foundation checks passed process lock contention/SIGKILL reacquisition plus unresolved payload retention and mismatched payload rejection and corrupt guard failure and fixed expiry and receipt staging/durable lookup and terminal cleanup repair. make lint passed with zero violations. make test-quick and configured Xcode fallback were blocked by runner permissions; app Swift Testing suites remain pending.+  - Blocked-by: ztq9ldu (Red: Write durable guard, process lock and expiry recovery tests)+  - Stream: 1+  - Requirements: [2.1](requirements.md#2.1), [2.3](requirements.md#2.3), [2.4](requirements.md#2.4), [3.1](requirements.md#3.1), [3.2](requirements.md#3.2), [3.4](requirements.md#3.4), [3.5](requirements.md#3.5), [5.5](requirements.md#5.5), [6.2](requirements.md#6.2)++- [x] 7. Red: Write deferred mutation service regression tests <!-- id:ztq9ldw -->+  - Add dedicated TaskService/MilestoneService prepare/apply tests and ProjectService/milestone-delete deferred-save tests. Suspend allocation before reference deletion/change, competing-name creation or cancellation; assert revalidation before insertion. Preserve existing UI/intent facades and atomic status/comment behavior. Use separate test files; do not edit stream 1 encoders/fixtures.+  - Blocked-by: ztq9ldr (Green: Implement the receipt model and passing persistence probe)+  - Stream: 2+  - Requirements: [3.3](requirements.md#3.3), [4.4](requirements.md#4.4), [5.4](requirements.md#5.4), [6.2](requirements.md#6.2)++- [x] 8. Green: Split creation preparation from synchronous application <!-- id:ztq9ldx -->+  - Modify TaskService.swift/MilestoneService.swift to allocate without inserting+  - then revalidate pinned UUIDs and apply synchronously. Add ProjectService deferred creation and MilestoneService deferred deletion+  - preserving current saving defaults. Reuse status/comment and task-update deferred application; audit design-listed callers and cancellation/reference invariants. Verification: make test-mcp-write-services MCP_PROBE_SWIFT_FLAGS=-disable-sandbox passed production-service preparation/no-insert+  - live milestone status/name checks+  - deferred project/delete/status-comment save+  - suspended allocation reassignment/cancellation and peer project deletion. make lint passed. Logs: /tmp/t2380-services-green.log and /tmp/t2380-services-lint.log. Dedicated Swift Testing suite added; full app runner remains blocked by environment permissions.+  - Blocked-by: ztq9ldw (Red: Write deferred mutation service regression tests)+  - Stream: 2+  - Requirements: [3.3](requirements.md#3.3), [4.4](requirements.md#4.4), [5.4](requirements.md#5.4), [6.2](requirements.md#6.2)++- [x] 9. Red: Write coordinator replay, conflict and uncertainty tests <!-- id:ztq9ldy -->+  - Add MCPWriteCoordinatorTests for all command families, concurrent keys, restart replay after edit/delete, stale-precondition replay, normalized records and deletion preimages. Inject acceptance/serialization/save/recovery faults; cover baseline edit preservation, guard-only/inconsistent state, null acceptance, cancellation and uncertain requests never executing again.+  - Blocked-by: ztq9ldv (Green: Implement local guards and scoped receipt storage), ztq9ldx (Green: Split creation preparation from synchronous application)+  - Stream: 1+  - Requirements: [2.1](requirements.md#2.1), [2.2](requirements.md#2.2), [2.3](requirements.md#2.3), [2.4](requirements.md#2.4), [2.5](requirements.md#2.5), [3.1](requirements.md#3.1), [3.2](requirements.md#3.2), [3.3](requirements.md#3.3), [3.4](requirements.md#3.4), [3.5](requirements.md#3.5), [4.3](requirements.md#4.3), [4.4](requirements.md#4.4), [5.1](requirements.md#5.1), [5.2](requirements.md#5.2), [5.3](requirements.md#5.3), [5.4](requirements.md#5.4), [5.5](requirements.md#5.5), [6.2](requirements.md#6.2)++- [x] 10. Green: Implement coordinated acceptance, mutation and recovery <!-- id:ztq9ldz -->+  - Create MCPWriteCoordinator.swift and MCPWriteCommand.swift and MCPWriteOutcome.swift under MCP/Writes. Bind keys durably before preparation; save baselines without rollback on failure; compare live state and apply/encode/commit without suspension. Manage autosave and remove fresh inserts before rollback; inspect durable receipts on thrown saves and classify recovery with injected clock/storage seams. Verification: Swift6 actual-production standalone coordinator checks passed all eight command families plus replay/restart/deleted-target/conflict/uncertainty plus active matching/mismatched keys plus commit-before/after-throw and serialization/recovery/acceptance/baseline faults plus fixed expiry/null acceptance/busy scope. Log: /tmp/t2380-contract-green.log. Dedicated app Swift Testing suites remain unexecuted due environment limitations.+  - Blocked-by: ztq9ldy (Red: Write coordinator replay, conflict and uncertainty tests)+  - Stream: 1+  - Requirements: [2.1](requirements.md#2.1), [2.2](requirements.md#2.2), [2.3](requirements.md#2.3), [2.4](requirements.md#2.4), [2.5](requirements.md#2.5), [3.1](requirements.md#3.1), [3.2](requirements.md#3.2), [3.3](requirements.md#3.3), [3.4](requirements.md#3.4), [3.5](requirements.md#3.5), [4.3](requirements.md#4.3), [4.4](requirements.md#4.4), [5.1](requirements.md#5.1), [5.2](requirements.md#5.2), [5.3](requirements.md#5.3), [5.4](requirements.md#5.4), [5.5](requirements.md#5.5), [6.2](requirements.md#6.2)++- [x] 11. Red: Write protected MCP schema and handler contract tests <!-- id:ztq9le0 -->+  - Extend MCPTestHelpers with fresh-key/read-revision helpers. Parameterize all eight protected tools and four preconditions; test malformed/unknown inputs reserve nothing, full reads expose revisions, saved comments/records share projections, and protocol/domain errors stay distinct. Define executable read/write/replay/conflict examples.+  - Blocked-by: ztq9ldz (Green: Implement coordinated acceptance, mutation and recovery)+  - Stream: 1+  - Requirements: [1.1](requirements.md#1.1), [1.2](requirements.md#1.2), [1.3](requirements.md#1.3), [4.1](requirements.md#4.1), [4.3](requirements.md#4.3), [5.1](requirements.md#5.1), [5.2](requirements.md#5.2), [5.3](requirements.md#5.3), [5.4](requirements.md#5.4), [5.5](requirements.md#5.5), [6.1](requirements.md#6.1), [6.2](requirements.md#6.2)++- [x] 12. Green: Route protected tools through the coordinator <!-- id:ztq9le1 -->+  - Modify MCPToolHandler.swift and MCPToolDefinitions.swift for required safety inputs and typed commands and snapshot projections and JSON outcome/error envelopes. Preserve shared intent serializers and maintenance paths. Publish scope/retention/revision limits and examples in tool descriptions and docs/mcp-write-contract.md. Verification: production coordinator/schema Swift6 executable passed; make lint and check-mcp-write-handler-syntax passed. Semantic handler typecheck could not import cached NIOCore built with Swift6.3.3 into current Swift6.4. App injection and legacy fixture migration remain planned in tasks13–14; app test execution remains pending.+  - Blocked-by: ztq9le0 (Red: Write protected MCP schema and handler contract tests)+  - Stream: 1+  - Requirements: [1.1](requirements.md#1.1), [1.2](requirements.md#1.2), [1.3](requirements.md#1.3), [4.1](requirements.md#4.1), [4.3](requirements.md#4.3), [5.1](requirements.md#5.1), [5.2](requirements.md#5.2), [5.3](requirements.md#5.3), [5.4](requirements.md#5.4), [5.5](requirements.md#5.5), [6.1](requirements.md#6.1), [6.2](requirements.md#6.2)++- [x] 13. Red: Write lifecycle and transport recovery integration tests <!-- id:ztq9le2 -->+  - Extend MCPHTTPTestHelpers and add actual-dependency lifecycle/transport tests: protected notifications, ordered non-atomic batches, listener restart/disconnect during allocation, lock lifetime and fallback rejection. Verify UI/service/intent/maintenance and separately saved imported-state revisions without claiming global sync ordering. Update legacy calls with keys/revisions while preserving their original assertions.+  - Blocked-by: ztq9le1 (Green: Route protected tools through the coordinator)+  - Stream: 1+  - Requirements: [2.2](requirements.md#2.2), [2.4](requirements.md#2.4), [3.3](requirements.md#3.3), [3.4](requirements.md#3.4), [4.2](requirements.md#4.2), [4.4](requirements.md#4.4), [4.5](requirements.md#4.5), [5.4](requirements.md#5.4), [6.1](requirements.md#6.1), [6.2](requirements.md#6.2)++- [x] 14. Green: Wire app lifecycle and complete transport regressions <!-- id:ztq9le3 -->+  - Inject one coordinator from TransitApp; integrate lock/guard startup+  - cleanup and shutdown with MCP ownership. Complete lifecycle/transport behavior and migrate fixtures without weakening regression checks. Run focused checks then make lint and make test-quick+  - retaining full logs; report unrelated inherited failures without expanding scope. Production schema publication is the separate release prerequisite. Verification: actual-production coordinator probe passed all eight tools plus mixed metadata normalization and retained original-payload replay+  - concurrency+  - restart+  - ambiguity+  - expiry and injected faults. make lint and Makefile app/MCP syntax checks passed. Notification/batch/active-write listener restart/disconnect/fallback/imported-state app suites authored and legacy calls migrated explicitly; full app execution remains unverified because the earlier make test-quick/Xcode fallback attempts were blocked by runner permissions/dependency environment. Logs: /tmp/t2380-lifecycle-coordinator.log+  - /tmp/t2380-lifecycle-lint.log+  - /tmp/t2380-lifecycle-syntax.log. Git index writes remain denied.+  - Blocked-by: ztq9le2 (Red: Write lifecycle and transport recovery integration tests)+  - Stream: 1+  - Requirements: [2.2](requirements.md#2.2), [2.4](requirements.md#2.4), [3.3](requirements.md#3.3), [3.4](requirements.md#3.4), [4.2](requirements.md#4.2), [4.4](requirements.md#4.4), [4.5](requirements.md#4.5), [5.4](requirements.md#5.4), [6.1](requirements.md#6.1), [6.2](requirements.md#6.2)++- [x] 15. Red: Reproduce phase review numeric precision and missed caller regressions <!-- id:ztq9le4 -->+  - Add adjacent-double and finite exponent-extreme cases to canonicalization/foundation and coordinator metadata replay probes. Audit the reviewed non-MCP-named regression suites for safety fields and structured records; preserve malformed-input coverage and original domain/storage paths.+  - Blocked-by: ztq9le3 (Green: Wire app lifecycle and complete transport regressions)+  - Stream: 1+  - Requirements: [2.3](requirements.md#2.3), [6.2](requirements.md#6.2)++- [x] 16. Green: Fix lossless numbers and complete regression migrations <!-- id:ztq9le5 -->+  - Fix lossless numeric identity and all missed protected callers+  - including full MCP versus Intent domain parity. Numeric red/green and migrated caller evidence remains in /tmp/t2380-review-fix-green.log. Focused re-review correction: assert raw MCP description null/empty/string and metadata empty/nonempty against the task+  - then apply only the Intent omission policy; display/project IDs+  - project names and milestone membership remain compared with presence intact. Added provisional orphan parity case. Executed focused temporary Makefile probe against actual production MCP/Intent serializers and the extracted test projection: all 36 description/metadata/project/display-ID/milestone combinations passed (/tmp/t2380-parity-probe.log; reproducible files /tmp/t2380-parity-probe.swift and /tmp/t2380-parity-probe.mk). make lint+  - app/all-test syntax check and git diff --check passed. Full app parity suite remains unexecuted due the documented environment block; no Git commit created.+  - Blocked-by: ztq9le4 (Red: Reproduce phase review numeric precision and missed caller regressions)+  - Stream: 1+  - Requirements: [2.3](requirements.md#2.3), [6.2](requirements.md#6.2)++- [x] 17. Red: Capture full application compilation and contract regressions <!-- id:ztq9le6 -->+  - Use the app gate evidence: missing SwiftData import and a non-Sendable test task return were corrected; 1,837 of 1,853 tests passed with 16 validation/normalization/response-fixture failures. Preserve original domain assertions while separating intentional required-key/full-write-record changes. Full failure details: /private/tmp/t2380-test-summary.json.+  - Blocked-by: ztq9le5 (Green: Fix lossless numbers and complete regression migrations)+  - Stream: 1+  - Requirements: [1.1](requirements.md#1.1), [1.3](requirements.md#1.3), [4.1](requirements.md#4.1), [5.1](requirements.md#5.1), [5.3](requirements.md#5.3), [5.4](requirements.md#5.4), [6.2](requirements.md#6.2)++- [x] 18. Green: Resolve runtime contract regressions and pass application checks <!-- id:ztq9le7 -->+  - Restore project-ID precedence+  - detailed milestone lookup errors+  - trimmed milestone descriptions and summary query shape where unchanged by scope. Migrate required-key schemas+  - full write-record null/empty assertions+  - strict unknown-field rejection+  - HTTP fixture safety and coordinator-owned save-failure injection. Parent-owned runtime verification passed: focused affected suites 115/115; full macOS application gate 1853/1853. Follow-up review found no material findings. Lint+  - syntax and diff checks passed before runtime verification. Parent owns the separate still-running combined iOS unit/UI gate and final phase documentation/commits; no additional tests or staging performed by this worker.+  - Blocked-by: ztq9le6 (Red: Capture full application compilation and contract regressions)+  - Stream: 1+  - Requirements: [1.1](requirements.md#1.1), [1.3](requirements.md#1.3), [4.1](requirements.md#4.1), [5.1](requirements.md#5.1), [5.3](requirements.md#5.3), [5.4](requirements.md#5.4), [6.2](requirements.md#6.2)

Things to double-check

Local guarantees and release prerequisite

CloudKit edits not yet imported cannot be detected by local preconditions. CloudKit schema publication remains required before shipping. Batch application and UI rebasing are separate scope.