Sync VCC Plus 3.7.1 build 67 source

Refresh reviewed MCP output export, four-drive owned playtests, bounded BASIC readiness, and pinned CMOC 0.1.101 source/patches. Preserve independent source-edition identity, empty libraries, notices and privacy boundaries.

Validated 74 export/privacy checks, pinned dependency sources, and an independent unsigned universal Release build. A subsequent documentation-only correction removes an excluded qualification link; all build inputs remain identical.
This commit is contained in:
Brian Holman committed 2026-11-17 08:42:27 -07:00
1 parent 4abc194001
commit 5534005799
54 files changed
+2950 -435

No files matched your search

+305 -19
View File
@@ -59,15 +59,23 @@ struct MCPPlaytestDiskStore: Sendable {
let originArtifactDiskSHA256: String?
let mediaKey: String?
let mediaBaseSHA256: String?
let writeProtected: Bool?
init(projectKey: String?, artifactID: String?, artifactDiskSHA256: String?, parentDiskID: String? = nil,
origin: String = "verified_artifact", originArtifactID: String? = nil, originArtifactDiskSHA256: String? = nil,
mediaKey: String? = nil, mediaBaseSHA256: String? = nil) {
mediaKey: String? = nil, mediaBaseSHA256: String? = nil, writeProtected: Bool? = nil) {
self.projectKey = projectKey; self.artifactID = artifactID; self.artifactDiskSHA256 = artifactDiskSHA256
self.parentDiskID = parentDiskID; self.origin = origin
self.originArtifactID = originArtifactID ?? (origin == "verified_artifact" ? artifactID : nil)
self.originArtifactDiskSHA256 = originArtifactDiskSHA256 ?? (origin == "verified_artifact" ? artifactDiskSHA256 : nil)
self.mediaKey = mediaKey; self.mediaBaseSHA256 = mediaBaseSHA256
self.mediaKey = mediaKey; self.mediaBaseSHA256 = mediaBaseSHA256; self.writeProtected = writeProtected
}
func protecting(_ enabled: Bool) -> Self {
Self(projectKey: projectKey, artifactID: artifactID, artifactDiskSHA256: artifactDiskSHA256,
parentDiskID: parentDiskID, origin: origin, originArtifactID: originArtifactID,
originArtifactDiskSHA256: originArtifactDiskSHA256, mediaKey: mediaKey,
mediaBaseSHA256: mediaBaseSHA256, writeProtected: enabled)
}
var publicFields: [String: Any] {
@@ -76,6 +84,8 @@ struct MCPPlaytestDiskStore: Sendable {
"origin_artifact_id": originArtifactID as Any? ?? NSNull(),
"origin_artifact_disk_sha256": originArtifactDiskSHA256 as Any? ?? NSNull()]
if let parentDiskID { fields["parent_disk_id"] = parentDiskID }
fields["write_protected"] = writeProtected ?? false
fields["write_protection_recorded"] = writeProtected != nil
fields["media_key"] = mediaKey ?? "primary"
fields["media_base_sha256"] = (mediaBaseSHA256 ?? artifactDiskSHA256) as Any? ?? NSNull()
return fields
@@ -485,11 +495,19 @@ final class MCPPlaytest {
let source: MCPPlaytestMedium
var data: Data
var dirty = false
var writeProtected = false
var retained: MCPPlaytestDiskStore.Record?
var pendingRecordID: String?
}
private var media: [String: MediumState]?
private var mediaOrder: [String] = []
private let multiDrive: Bool
private var mountedMediaIDs: [String?] = Array(repeating: nil, count: 4)
private var pendingMediaDrive: Int?
private var lastSafeMediaExports: [Int: [String: Any]] = [:]
private var frozenDriveExports = Set<Int>()
private var mediaFreezeAcknowledged = false
private var mediaStopDrained = false
private var mountedMediaID: String?
private var mediaExchangeTask: Task<[String: Any], Error>?
private var mediaFailures: [String: (Data, String)] = [:]
@@ -499,16 +517,17 @@ final class MCPPlaytest {
private init(worker: Worker, projectID: String, revision: Int, artifactID: String, retentionDirectory: URL,
diskProvenance: MCPPlaytestDiskStore.Provenance, resumedDiskID: String?, runID: String,
processor: MCPPlaytestProcessor, media: [MCPPlaytestMedium]?,
processor: MCPPlaytestProcessor, media: [MCPPlaytestMedium]?, multiDrive: Bool,
videoArtifactWillVerify: (@Sendable (URL) throws -> Void)?) {
self.runID = runID
self.worker = worker; self.projectID = projectID; self.revision = revision; self.artifactID = artifactID
self.retentionDirectory = retentionDirectory; self.diskProvenance = diskProvenance; self.resumedDiskID = resumedDiskID
self.processor = processor
self.processor = processor; self.multiDrive = multiDrive
self.videoArtifactWillVerify = videoArtifactWillVerify
if let media {
self.media = Dictionary(uniqueKeysWithValues: media.map { ($0.id, MediumState(source: $0, data: $0.data)) })
self.media = Dictionary(uniqueKeysWithValues: media.map { ($0.id, MediumState(source: $0, data: $0.data, writeProtected: $0.provenance.writeProtected ?? false)) })
self.mediaOrder = media.map(\.id); self.mountedMediaID = media.first?.id
self.mountedMediaIDs[0] = media.first?.id
}
}
@@ -517,7 +536,7 @@ final class MCPPlaytest {
modules: [[String: Any]] = [], stopAt: UInt16? = nil, stopModule: String? = nil, flatGuards: [[String: Any]] = [], cpu: String = "6809", helperURL: URL? = nil, retentionDirectory: URL? = nil,
diskProvenance: MCPPlaytestDiskStore.Provenance? = nil, resumedDiskID: String? = nil,
graphicsBuffers: [[String: Any]] = [], runID: String = UUID().uuidString,
media: [MCPPlaytestMedium]? = nil,
media: [MCPPlaytestMedium]? = nil, multiDrive: Bool = false,
videoArtifactWillVerify: (@Sendable (URL) throws -> Void)? = nil) async throws -> MCPPlaytest {
guard let reservedID = UUID(uuidString: runID) else { throw failure("invalid_playtest_run_id") }
guard systemROM.count == 32768, diskROM.count == 8192, !disk.isEmpty, disk.count <= 512 * 1024,
@@ -561,12 +580,18 @@ final class MCPPlaytest {
let test = MCPPlaytest(worker: worker, projectID: projectID, revision: revision, artifactID: artifactID,
retentionDirectory: retentionDirectory ?? AppIdentity.supportDirectory.appendingPathComponent("Development Runs/Assistant Playtests"),
diskProvenance: provenance, resumedDiskID: resumedDiskID.map { UUID(uuidString: $0)!.uuidString }, runID: reservedID.uuidString,
processor: cpu == "6309" ? .hd6309 : .mc6809, media: media, videoArtifactWillVerify: videoArtifactWillVerify)
processor: cpu == "6309" ? .hd6309 : .mc6809, media: media, multiDrive: multiDrive, videoArtifactWillVerify: videoArtifactWillVerify)
var setup: [String: Any] = ["op": "init", "system_rom": systemROM.base64EncodedString(),
"disk_rom": diskROM.base64EncodedString(), "disk": disk.base64EncodedString(),
"boot_keys": paste.chords.map { NSNumber(value: $0) }, "modules": modules, "cpu": cpu,
"graphics_buffers": graphicsBuffers, "flat_guards": flatGuards]
if let media { setup["media_id"] = media[0].id }
if let protection = provenance.writeProtected { setup["write_protected"] = protection }
if multiDrive {
guard media != nil else { await test.invalidate().value; throw failure("invalid_playtest_media") }
setup["multi_drive"] = true
setup["write_protected"] = media?.first?.provenance.writeProtected ?? false
}
if let stopAt {
guard (modules.isEmpty && !flatGuards.isEmpty && stopModule == nil) ||
(!modules.isEmpty && flatGuards.isEmpty && stopModule != nil) else {
@@ -665,7 +690,237 @@ final class MCPPlaytest {
}
}
private func driveRow(_ status: [String: Any], drive: Int) throws -> [String: Any] {
guard let rows = status["drives"] as? [[String: Any]], rows.count == 4,
rows.enumerated().allSatisfy({ index, row in
guard let number = row["drive"] as? NSNumber, CFGetTypeID(number) != CFBooleanGetTypeID() else { return false }
return number.doubleValue == Double(index)
}) else { throw Self.failure("invalid_playtest_media_reply") }
return rows[drive]
}
private func multiMediaFields(status: [String: Any]) -> [String: Any] {
var fields = status
let workerRows = status["drives"] as? [[String: Any]] ?? []
fields["media_contract_version"] = 2
fields["drive"] = "FD0" // Existing top-level compatibility field.
fields["drives"] = (0..<4).map { drive -> [String: Any] in
var row = workerRows.count == 4 ? workerRows[drive] : ["drive": drive, "label": "FD\(drive)", "unavailable": true]
if let id = row["media_id"] as? String, let item = media?[id] {
row["base_sha256"] = item.source.baseSHA256
row["media_sha256"] = row["disk_sha256"]
row["media_key"] = item.source.key
row["name"] = item.source.name
row["provenance"] = item.source.provenance.protecting(row["write_protected"] as? Bool ?? item.writeProtected).publicFields
row["modified_from_artifact"] = row["disk_sha256"] as? String != item.source.baseSHA256
let retained = item.retained
row["retained"] = retained?.diskSHA256 == row["disk_sha256"] as? String && retained?.provenance.writeProtected == row["write_protected"] as? Bool
if let retained { row["retained_disk"] = retained.publicFields }
}
return row
}
fields["media"] = mediaOrder.compactMap { id -> [String: Any]? in
guard let item = media?[id] else { return nil }
let mounted = workerRows.first { $0["media_id"] as? String == id && $0["disk_present"] as? Bool == true }
let hash = mounted?["disk_sha256"] as? String ?? CMOCProject.sha256(item.data)
let protection = mounted?["write_protected"] as? Bool ?? item.writeProtected
var row: [String: Any] = ["media_id": id, "name": item.source.name, "media_key": item.source.key,
"base_sha256": item.source.baseSHA256, "media_sha256": hash, "byte_count": item.data.count,
"inserted": mounted != nil, "drive": mounted?["drive"] as Any? ?? NSNull(),
"dirty": mounted?["disk_dirty"] as? Bool ?? item.dirty, "write_protected": protection,
"provenance": item.source.provenance.protecting(protection).publicFields,
"modified_from_artifact": hash != item.source.baseSHA256,
"retained": item.retained?.diskSHA256 == hash && item.retained?.provenance.writeProtected == protection]
if let retained = item.retained { row["retained_disk"] = retained.publicFields }
if let parent = item.source.provenance.parentDiskID { row["resumed_from_disk_id"] = parent }
if status["media_selection_uncertain"] as? Bool == true { row["placement_uncertain"] = true }
return row
}
return fields
}
/// One bounded worker message contains one drive's bytes plus a coherent
/// four-drive metadata observation. Never concatenate four disk payloads.
private func receiveMultiMediaExport(_ status: [String: Any], drive: Int) throws {
let row = try driveRow(status, drive: drive)
guard let exported = status["exported_drive"] as? [String: Any], NSDictionary(dictionary: exported).isEqual(to: row),
let present = row["disk_present"] as? Bool, let hash = row["disk_sha256"] as? String,
let protection = row["write_protected"] as? Bool else { throw Self.failure("invalid_playtest_media_reply") }
let id = row["media_id"] as? String
let pendingMatches = mediaCommitPending && pendingMediaDrive == drive && id == pendingMediaSelection
guard id == mountedMediaIDs[drive] || pendingMatches else { throw Self.failure("invalid_playtest_media_reply") }
if !present {
guard id == nil, hash.isEmpty, status["disk_base64"] == nil,
(row["byte_count"] as? NSNumber)?.intValue == 0 else { throw Self.failure("invalid_playtest_media_reply") }
mountedMediaIDs[drive] = nil
} else {
guard let id, var item = media?[id], let encoded = status["disk_base64"] as? String,
let bytes = Data(base64Encoded: encoded), !bytes.isEmpty, bytes.count <= 512 * 1024,
bytes.count == (row["byte_count"] as? NSNumber)?.intValue,
CMOCProject.sha256(bytes) == hash else { throw Self.failure("invalid_playtest_media_reply") }
if item.data != bytes || item.writeProtected != protection { item.pendingRecordID = nil }
item.data = bytes; item.dirty = row["disk_dirty"] as? Bool ?? false; item.writeProtected = protection
media?[id] = item; mountedMediaIDs[drive] = id
}
mountedMediaID = mountedMediaIDs[0]
}
private func exchangeMultiMedia(_ selected: String?, expectedSHA: String?, drive: Int,
writeProtected: Bool?, isCurrent: (() -> Bool)?) async throws -> [String: Any] {
guard valid, isCurrent?() != false else { throw Self.failure("stale_run") }
if let selected {
guard media?[selected] != nil else { throw Self.failure("invalid_playtest_media_selection") }
guard !mountedMediaIDs.enumerated().contains(where: { $0.offset != drive && $0.element == selected }) else {
throw Self.failure("playtest_media_already_inserted")
}
}
var frozen: [Int: [String: Any]] = [:]
for index in 0..<4 {
let snapshot = try await worker.request(["op": "export_media", "drive": index])
try receiveMultiMediaExport(snapshot, drive: index)
if let first = frozen[0] {
for key in ["field_clock", "cycles", "generation", "boot", "pc"] {
guard let a = first[key] as? NSNumber, let b = snapshot[key] as? NSNumber, a == b else {
throw WorkerTransportFailure(reason: "playtest_media_advanced_guest")
}
}
}
frozen[index] = snapshot
}
guard let before = frozen[drive] else { throw Self.failure("invalid_playtest_media_reply") }
let oldRow = try driveRow(before, drive: drive), expectedOldID = mountedMediaIDs[drive]
guard valid, isCurrent?() != false, let generation = oldRow["media_generation"] as? NSNumber,
let oldHash = oldRow["disk_sha256"] as? String else { throw Self.failure("stale_playtest_media") }
if let selected, let item = media?[selected], expectedSHA != CMOCProject.sha256(item.data) {
throw Self.failure("playtest_media_hash_mismatch")
}
var old: [String: Any] = ["media_id": expectedOldID as Any? ?? NSNull(), "media_sha256": oldHash,
"drive": drive, "dirty": oldRow["disk_dirty"] as? Bool ?? false, "retained": false,
"write_protected": oldRow["write_protected"] as? Bool ?? false]
if let expectedOldID {
let retained = try await retainMedium(expectedOldID)
old["retained"] = true; old["retained_disk"] = retained.publicFields
}
guard valid, isCurrent?() != false, mountedMediaIDs[drive] == expectedOldID else { throw Self.failure("stale_run") }
var request: [String: Any] = ["op": "exchange_media", "drive": drive,
"expected_media_generation": generation, "expected_disk_sha256": oldHash]
if let selected, let item = media?[selected] {
request["media_id"] = selected; request["disk_base64"] = item.data.base64EncodedString()
request["write_protected"] = writeProtected ?? item.writeProtected
}
lastSafeMediaExports = frozen
mediaCommitPending = true; pendingMediaDrive = drive; pendingMediaSelection = selected
let after: [String: Any]
do { after = try await worker.request(request) }
catch let error as WorkerRejection { mediaCommitPending = false; pendingMediaDrive = nil; pendingMediaSelection = nil; throw error }
// Acknowledged commit is authoritative even if the grant expires now.
mountedMediaIDs[drive] = selected; mountedMediaID = mountedMediaIDs[0]
mediaCommitPending = false; pendingMediaDrive = nil; pendingMediaSelection = nil
let next = try driveRow(after, drive: drive)
let selectedSHA = selected.flatMap { media?[$0] }.map { CMOCProject.sha256($0.data) } ?? ""
guard next["disk_sha256"] as? String == selectedSHA, next["media_id"] as? String == selected,
next["disk_present"] as? Bool == (selected != nil),
(next["media_generation"] as? NSNumber)?.intValue == generation.intValue + 1,
after["previous_disk_sha256"] as? String == oldHash else { throw WorkerTransportFailure(reason: "invalid_playtest_media_reply") }
if let selected, var item = media?[selected], let effective = next["write_protected"] as? Bool {
if effective != item.writeProtected { item.pendingRecordID = nil }
item.writeProtected = effective; media?[selected] = item
}
for index in 0..<4 where index != drive {
guard NSDictionary(dictionary: try driveRow(before, drive: index)).isEqual(to: try driveRow(after, drive: index)) else {
throw WorkerTransportFailure(reason: "playtest_unrelated_drive_changed")
}
}
for key in ["field_clock", "cycles", "generation", "boot", "pc"] {
guard let a = before[key] as? NSNumber, let b = after[key] as? NSNumber, a == b else { throw WorkerTransportFailure(reason: "playtest_media_advanced_guest") }
}
var result = mediaFields(status: after)
result["target_drive"] = drive; result["previous_media"] = old
result["exchange"] = selected == nil ? "ejected" : "inserted"
result["guest_advanced"] = false; result["guest_reset"] = false
return result
}
private func performMultiMediaPersistence() async throws -> [String: Any] {
if let pending = mediaExchangeTask { _ = await pending.result }
if finished, let finalReceipt { return finalReceipt }
if !mediaFreezeAcknowledged {
do {
var result = try await worker.request(["op": "stop"])
guard result["media_frozen"] as? Bool == true else { throw Self.failure("invalid_playtest_media_reply") }
_ = try driveRow(result, drive: 0)
mediaFreezeAcknowledged = true; exportedStatus = result
guard let primary = mediaOrder.first, let bytes = media?[primary]?.data else { throw Self.failure("invalid_playtest_media") }
exportedDisk = bytes // Retry marker, not a claim that all drives were drained.
do { try await retainVideoMetadata(result) }
catch { result["video_retention_error"] = "The video artifact could not be verified; disk retention continues."; exportedStatus = result }
} catch let error as WorkerTransportFailure {
// Only a fully observed paused four-drive export can recover a
// lost exchange reply. It is never substituted after execution.
guard lastSafeMediaExports.count == 4, let before = lastSafeMediaExports[0] else { throw error }
var result = before
result.removeValue(forKey: "disk_base64"); result.removeValue(forKey: "exported_drive")
result["media_selection_uncertain"] = true
result["uncertain_drives"] = pendingMediaDrive.map { [$0] } ?? Array(0..<4)
if var rows = result["drives"] as? [[String: Any]] {
for index in (pendingMediaDrive.map { [$0] } ?? Array(0..<4)) {
rows[index]["media_id"] = NSNull(); rows[index]["disk_present"] = NSNull()
rows[index]["inserted"] = NSNull(); rows[index]["selection_uncertain"] = true
rows[index]["disk_sha256"] = NSNull(); rows[index]["media_generation"] = NSNull()
mountedMediaIDs[index] = nil
}
result["drives"] = rows
if pendingMediaDrive == nil || pendingMediaDrive == 0 {
result["media_id"] = NSNull(); result["disk_present"] = NSNull(); result["disk_sha256"] = NSNull()
}
}
mountedMediaID = mountedMediaIDs[0]
exportedStatus = result; mediaFreezeAcknowledged = true; mediaStopDrained = true
frozenDriveExports = Set(0..<4)
exportedDisk = mediaOrder.first.flatMap { media?[$0]?.data }
}
}
do {
for drive in 0..<4 where !frozenDriveExports.contains(drive) {
let result = try await worker.request(["op": "export_media", "drive": drive])
try receiveMultiMediaExport(result, drive: drive)
// Each reply must match the STOP observation, with no execution
// or selection change while bounded exports are drained.
guard let frozen = exportedStatus,
NSDictionary(dictionary: try driveRow(frozen, drive: drive)).isEqual(to: try driveRow(result, drive: drive)) else {
throw Self.failure("playtest_frozen_media_changed")
}
frozenDriveExports.insert(drive)
}
if !mediaStopDrained {
do { _ = try await worker.request(["op": "finish_stop"]) }
catch is WorkerTransportFailure { /* Every mounted disk was already drained and verified. */ }
mediaStopDrained = true
}
var retained: [[String: Any]] = []
for id in mediaOrder {
let record = try await retainMedium(id)
var fields = record.publicFields; fields["media_id"] = id; fields["name"] = media?[id]?.source.name
retained.append(fields)
}
guard let primary = mediaOrder.first, let record = media?[primary]?.retained else { throw Self.failure("playtest_disk_export_failed") }
retainedDiskRecord = record; retainedDiskURL = try MCPPlaytestDiskStore.diskURL(directory: retentionDirectory, id: record.id)
var result = mediaFields(status: exportedStatus ?? [:])
result["disk_retained"] = true; result["retained_disk_id"] = record.id
result["retained_disk_sha256"] = record.diskSHA256; result["retained_disk"] = record.publicFields
result["retained_media"] = retained; result["status"] = "stopped"
finished = true; retentionError = nil; worker.close()
let receipt = scoped(result); finalReceipt = receipt
exportedDisk = nil; exportedStatus = nil; Self.pendingRetentions.removeValue(forKey: runID)
return receipt
} catch {
retentionError = error.localizedDescription; Self.pendingRetentions[runID] = self
throw error
}
}
private func mediaFields(status: [String: Any]) -> [String: Any] {
if multiDrive { return multiMediaFields(status: status) }
var fields = status
let actualID = status["media_id"] == nil ? mountedMediaID : status["media_id"] as? String
let present = status["disk_present"] as? Bool ?? (mountedMediaID != nil)
@@ -689,6 +944,7 @@ final class MCPPlaytest {
/// Only called with a bounded, complete export from the app-owned helper.
/// Keep these bytes even if the lease was revoked while the pipe was read.
private func receiveMediaExport(_ status: [String: Any]) throws {
if multiDrive { try receiveMultiMediaExport(status, drive: 0); return }
guard media != nil, let present = status["disk_present"] as? Bool else { throw Self.failure("invalid_playtest_media_reply") }
if !present {
guard (mountedMediaID == nil || (mediaCommitPending && pendingMediaSelection == nil)),
@@ -713,11 +969,22 @@ final class MCPPlaytest {
private func retainMedium(_ id: String) async throws -> MCPPlaytestDiskStore.Record {
guard var item = media?[id] else { throw Self.failure("invalid_playtest_media_selection") }
let hash = CMOCProject.sha256(item.data)
if let existing = item.retained, existing.diskSHA256 == hash { return existing }
if let existing = item.retained, existing.diskSHA256 == hash,
!multiDrive || existing.provenance.writeProtected == item.writeProtected {
guard let projectKey = existing.provenance.projectKey,
let artifactHash = existing.provenance.artifactDiskSHA256 else { throw Self.failure("invalid_playtest_disk_provenance") }
let loaded = try await MCPPlaytestDiskStore.load(directory: retentionDirectory, id: existing.id,
expectedSHA256: hash, projectKey: projectKey, artifactDiskSHA256: artifactHash,
mediaKey: existing.provenance.mediaKey ?? "primary", mediaBaseSHA256: existing.provenance.mediaBaseSHA256)
guard loaded.record.id == existing.id, loaded.record.runID == existing.runID,
loaded.record.provenance == existing.provenance, loaded.record.diskSHA256 == existing.diskSHA256,
loaded.record.byteCount == existing.byteCount, loaded.data == item.data else { throw Self.failure("retained_disk_changed") }
return existing
}
let recordID = item.pendingRecordID ?? UUID().uuidString
item.pendingRecordID = recordID; media?[id] = item
let stored = try await MCPPlaytestDiskStore.save(directory: retentionDirectory, runID: runID,
data: item.data, provenance: item.source.provenance, recordID: recordID)
data: item.data, provenance: multiDrive ? item.source.provenance.protecting(item.writeProtected) : item.source.provenance, recordID: recordID)
// The paused worker and serialized owner cannot change this medium
// during the off-main-thread durable write.
guard var current = media?[id], current.data == item.data else { throw Self.failure("playtest_media_changed") }
@@ -725,7 +992,9 @@ final class MCPPlaytest {
return stored
}
private func exchangeMedia(_ selected: String?, expectedSHA: String?, isCurrent: (() -> Bool)?) async throws -> [String: Any] {
private func exchangeMedia(_ selected: String?, expectedSHA: String?, isCurrent: (() -> Bool)?,
drive: Int = 0, writeProtected: Bool? = nil) async throws -> [String: Any] {
if multiDrive { return try await exchangeMultiMedia(selected, expectedSHA: expectedSHA, drive: drive, writeProtected: writeProtected, isCurrent: isCurrent) }
guard valid, isCurrent?() != false else { throw Self.failure("stale_run") }
let before = try await worker.request(["op": "export_media"])
let expectedOldID = mountedMediaID
@@ -751,6 +1020,7 @@ final class MCPPlaytest {
"expected_disk_sha256": oldHash]
if let selected, let item = media?[selected] {
request["media_id"] = selected; request["disk_base64"] = item.data.base64EncodedString()
if let protection = item.source.provenance.writeProtected { request["write_protected"] = protection }
}
lastSafeMediaExport = before
mediaCommitPending = true; pendingMediaSelection = selected
@@ -781,6 +1051,7 @@ final class MCPPlaytest {
}
private func performMediaPersistence() async throws -> [String: Any] {
if multiDrive { return try await performMultiMediaPersistence() }
if let pending = mediaExchangeTask { _ = await pending.result }
if finished, let finalReceipt { return finalReceipt }
if exportedDisk == nil {
@@ -835,6 +1106,8 @@ final class MCPPlaytest {
/// The host rechecks project/revision/artifact identity before dispatching.
/// Cached write receipts are still bound to this live lease, never replayed.
func reply(_ tool: String, arguments: [String: Any], isCurrent: (() -> Bool)? = nil) async throws -> [String: Any] {
var arguments = arguments
if tool == "exchange_playtest_media", multiDrive, arguments["drive"] == nil { arguments["drive"] = 0 }
guard valid, arguments["run_id"] as? String == runID else { throw Self.failure("stale_run") }
guard !busy else { throw Self.failure("playtest_busy") }
busy = true
@@ -903,10 +1176,22 @@ final class MCPPlaytest {
}
if tool == "exchange_playtest_media" {
guard media != nil, let action = arguments["action"] as? String,
["insert", "eject"].contains(action),
Set(arguments.keys) == (action == "insert" ? ["run_id", "request_id", "action", "media_id", "media_sha256"] : ["run_id", "request_id", "action"]) else {
throw Self.failure("invalid_arguments")
}
["insert", "eject"].contains(action) else { throw Self.failure("invalid_arguments") }
var required: Set<String> = action == "insert" ? ["run_id", "request_id", "action", "media_id", "media_sha256"] : ["run_id", "request_id", "action"]
if multiDrive { required.insert("drive") }
let optional: Set<String> = multiDrive && action == "insert" ? ["write_protected"] : []
guard required.isSubset(of: Set(arguments.keys)), Set(arguments.keys).isSubset(of: required.union(optional)) else { throw Self.failure("invalid_arguments") }
let drive: Int
if multiDrive {
guard let value = arguments["drive"] as? NSNumber, CFGetTypeID(value) != CFBooleanGetTypeID(),
value.doubleValue.isFinite, value.doubleValue == Double(value.intValue), (0...3).contains(value.intValue) else { throw Self.failure("invalid_arguments") }
drive = value.intValue
} else { drive = 0 }
let protection: Bool?
if let value = arguments["write_protected"] {
guard let number = value as? NSNumber, CFGetTypeID(number) == CFBooleanGetTypeID() else { throw Self.failure("invalid_arguments") }
protection = number.boolValue
} else { protection = nil }
let selected: String?
if action == "insert" {
guard let id = arguments["media_id"] as? String, media?[id] != nil,
@@ -918,7 +1203,7 @@ final class MCPPlaytest {
} else { selected = nil }
mutationRequestsAccepted += 1
accepted[requestID] = (signature, scoped(["request_id": requestID, "status": "interrupted"]))
let exchange = Task { try await self.exchangeMedia(selected, expectedSHA: arguments["media_sha256"] as? String, isCurrent: isCurrent) }
let exchange = Task { try await self.exchangeMedia(selected, expectedSHA: arguments["media_sha256"] as? String, isCurrent: isCurrent, drive: drive, writeProtected: protection) }
mediaExchangeTask = exchange
defer { mediaExchangeTask = nil }
var result: [String: Any]
@@ -1045,7 +1330,7 @@ final class MCPPlaytest {
}
}
do {
lastSafeMediaExport = nil
lastSafeMediaExport = nil; lastSafeMediaExports.removeAll()
var result = try await worker.request(request)
guard valid else { throw Self.failure("stale_run") }
try await retainVideoMetadata(result)
@@ -1089,7 +1374,7 @@ final class MCPPlaytest {
guard !busy else { throw Self.failure("playtest_busy") }
busy = true
defer { busy = false }
if let operation = request["op"] as? String, ["continue", "step", "stop_at"].contains(operation) { lastSafeMediaExport = nil }
if let operation = request["op"] as? String, ["continue", "step", "stop_at"].contains(operation) { lastSafeMediaExport = nil; lastSafeMediaExports.removeAll() }
let result = try await worker.request(request)
guard valid else { throw Self.failure("stale_run") }
try await retainVideoMetadata(result)
@@ -1097,7 +1382,7 @@ final class MCPPlaytest {
}
private func scoped(_ result: [String: Any]) -> [String: Any] {
var result = result
var result = multiDrive && media != nil ? mediaFields(status: result) : result
result["run_id"] = runID; result["project_id"] = projectID
result["revision"] = revision; result["artifact_id"] = artifactID
result["requested_processor"] = processor.rawValue
@@ -1122,7 +1407,8 @@ final class MCPPlaytest {
result["boot_disk_provenance"] = diskProvenance.publicFields
if let id = mountedMediaID, let current = media?[id] {
result["disk_origin"] = current.source.provenance.origin
result["disk_provenance"] = current.source.provenance.publicFields
let currentProtection = (result["drives"] as? [[String: Any]])?.first?["write_protected"] as? Bool ?? current.writeProtected
result["disk_provenance"] = multiDrive ? current.source.provenance.protecting(currentProtection).publicFields : current.source.provenance.publicFields
} else {
result["disk_origin"] = NSNull(); result["disk_provenance"] = NSNull()
}