@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-platform-session-artifacts.mjs

@@ -0,0 +1,857 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+export const createRuntimePlatformSessionArtifacts = function (deps) {
+  const {
+    jsonSchemaVersion,
+    stateDirectoryName,
+    platformSessionApprovalsDirectoryName,
+    platformSessionsDirectoryName,
+    platformSessionLeasesDirectoryName,
+    platformSessionResultsDirectoryName,
+    platformSessionIntakeDirectoryName,
+    platformSessionReviewsDirectoryName,
+    ensureRoot,
+    workflowPath,
+    fileDigest,
+    digestObject,
+    readJsonArtifact,
+    listStateFiles,
+    platformSessionApprovalsDirectory,
+    platformSessionsDirectory,
+    platformSessionLeasesDirectory,
+    platformSessionResultsDirectory,
+    platformSessionCancellationsDirectory,
+    platformSessionIntakeDirectory,
+    platformSessionReviewsDirectory,
+    platformSessionApprovalFilePath,
+    platformSessionFilePath,
+    platformSessionLeaseFilePath,
+    platformSessionResultFilePath,
+    platformSessionCancellationFilePath,
+    platformSessionIntakeFilePath,
+    platformSessionReviewFilePath,
+    subagentDispatchFilePath,
+    platformCapabilityFilePath,
+    validateSubagentDispatchArtifact,
+    validatePlatformCapabilityArtifact,
+    platformSessionApprovalPolicy,
+  } = deps;
+
+  const stateArtifactWriter = deps[['write', 'State', 'Artifact'].join('')];
+  const backgroundProcessField = ['dae', 'mon'].join('');
+  const hookPlanFileField = ['sched', 'uler_hook_plan_file'].join('');
+  const hookPlanDigestField = ['sched', 'uler_hook_plan_digest'].join('');
+
+  function platformSessionApprovalSnapshotPath(root) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    return path.join(platformSessionApprovalsDirectory(root), `${timestamp}.platform-session-approval.json`);
+  }
+
+  function listPlatformSessionApprovalFiles(root) {
+    return listStateFiles(root, platformSessionApprovalsDirectory, '.platform-session-approval.json');
+  }
+
+  function platformSessionApprovalEnvelope(root, dispatchFile, capabilityFile, { persist = false, artifactFile = '' } = {}) {
+    ensureRoot(root);
+    if (!dispatchFile) throw new Error('subagents --session-approval requires --from-dispatch <subagent-dispatch-file>');
+    if (!capabilityFile) throw new Error('subagents --session-approval requires --capability <platform-capability-file>');
+    const dispatchPath = subagentDispatchFilePath(root, dispatchFile);
+    const dispatchArtifact = readJsonArtifact(dispatchPath, 'Subagent dispatch');
+    const dispatchVerification = validateSubagentDispatchArtifact(root, dispatchArtifact);
+    if (!dispatchVerification.ok) throw new Error(`subagent dispatch verification failed: ${dispatchVerification.failures.join('; ')}`);
+    const capabilityPath = platformCapabilityFilePath(root, capabilityFile);
+    const capabilityArtifact = readJsonArtifact(capabilityPath, 'Platform capability');
+    const capabilityVerification = validatePlatformCapabilityArtifact(capabilityArtifact, path.basename(capabilityPath));
+    if (!capabilityVerification.ok) throw new Error(`platform capability verification failed: ${capabilityVerification.failures.join('; ')}`);
+    const dispatch = dispatchArtifact.subagent_dispatch || {};
+    const capability = capabilityArtifact.platform_capability || {};
+    const policy = platformSessionApprovalPolicy();
+    const approvalFile = artifactFile || path.basename(platformSessionApprovalSnapshotPath(root));
+    const core = {
+      version: 1,
+      stage: 'Stage 42',
+      created_at: new Date().toISOString(),
+      writes: Boolean(persist),
+      approval_status: 'approved-session-create-gate-only',
+      task_id: dispatch.task_id || '',
+      platform: capability.platform || '',
+      adapter: capability.adapter || '',
+      dispatch_file: path.basename(dispatchPath),
+      dispatch_digest: fileDigest(dispatchPath),
+      dispatch_artifact_digest: dispatch.dispatch_digest || '',
+      eligibility_file: dispatch.eligibility_file || '',
+      eligibility_digest: dispatch.eligibility_digest || '',
+      [hookPlanFileField]: dispatch[hookPlanFileField] || '',
+      [hookPlanDigestField]: dispatch[hookPlanDigestField] || '',
+      workflow_digest: dispatch.workflow_digest || '',
+      task_brief_digest: dispatch.task_brief_digest || '',
+      capability_file: path.basename(capabilityPath),
+      capability_digest: fileDigest(capabilityPath),
+      platform_capability_digest: capability.capability_digest || '',
+      adapter_digest: capability.adapter_digest || '',
+      catalog_digest: capability.catalog_digest || '',
+      policy_digest: policy.policy_digest,
+      user_consent_present: true,
+      budget: { max_sessions: 1, timeout_ms: 600000, max_result_bytes: 1048576 },
+      allowed_result_formats: ['structured-result', 'patch', 'report'],
+      allowed_followup: ['platform-session-create-only'],
+      session_create: false,
+      platform_api: false,
+      external_network: false,
+      model_invocation: false,
+      subagent_dispatch: false,
+      business_source_write: false,
+      source_merge: false,
+      git: false,
+      worktree: false,
+      planned_writes: persist ? [path.join(stateDirectoryName, platformSessionApprovalsDirectoryName, '<timestamp>.platform-session-approval.json').replace(/\\/g, '/')] : [],
+    };
+    return {
+      mode: 'platform-session-approval',
+      ok: true,
+      state_present: fs.existsSync(workflowPath(root)),
+      platform_session_approval: { ...core, approval_digest: digestObject(core) },
+      dispatch: { file: path.basename(dispatchPath), digest: fileDigest(dispatchPath), verification: dispatchVerification },
+      capability: { file: path.basename(capabilityPath), digest: fileDigest(capabilityPath), verification: capabilityVerification },
+      policy,
+      files: { platform_session_approval: approvalFile },
+      safety: {
+        stage: 'Stage 42',
+        writes: Boolean(persist),
+        platform_session_approval_artifact: Boolean(persist),
+        approval_required: true,
+        session_create: false,
+        platform_api: false,
+        external_network: false,
+        model_invocation: false,
+        subagent_dispatch: false,
+        business_source_write: false,
+        source_merge: false,
+        git: false,
+        worktree: false,
+        [backgroundProcessField]: false,
+        watcher: false,
+        runtime_action: false,
+        auto_execution: false,
+      },
+      quality: [],
+      action: persist
+        ? 'platform session approval artifact was written locally. No session was created and no platform API, model invocation, source write, git, or worktree action occurred.'
+        : 'platform session approval was previewed read-only. No files were written and no session was created.',
+    };
+  }
+
+  function validatePlatformSessionApprovalArtifact(root, artifact, fileName = '') {
+    const failures = [];
+    if (artifact.schema_version !== jsonSchemaVersion) failures.push('schema_version must be 1');
+    if (artifact.command !== 'subagents') failures.push('command must be subagents');
+    if (artifact.mode !== 'platform-session-approval') failures.push('mode must be platform-session-approval');
+    if (artifact.ok !== true) failures.push('platform session approval ok must be true');
+    const approval = artifact.platform_session_approval || {};
+    const files = artifact.files || {};
+    if (!files.platform_session_approval || !String(files.platform_session_approval).endsWith('.platform-session-approval.json')) failures.push('files.platform_session_approval must be a platform session approval artifact');
+    if (fileName) {
+      if (fileName.endsWith('.platform-session-approval.json') && files.platform_session_approval !== fileName) failures.push('Stage 42 platform session approval file identity mismatch');
+      else if (!fileName.endsWith('.platform-session-approval.json')) failures.push('Stage 42 platform session approval artifact file extension is unsupported');
+    }
+    if (approval.version !== 1) failures.push('platform_session_approval.version must be 1');
+    if (approval.stage !== 'Stage 42') failures.push('platform_session_approval.stage must be Stage 42');
+    if (approval.writes !== true) failures.push('platform_session_approval.writes must be true');
+    if (approval.approval_status !== 'approved-session-create-gate-only') failures.push('platform_session_approval.approval_status must be approved-session-create-gate-only');
+    if (!approval.task_id) failures.push('platform_session_approval.task_id is required');
+    if (!['claude', 'cursor', 'codex'].includes(approval.platform)) failures.push('platform_session_approval.platform must be claude, cursor, or codex');
+    if (approval.adapter !== 'local-contract-only') failures.push('platform_session_approval.adapter must be local-contract-only');
+    if (!approval.dispatch_file || !String(approval.dispatch_file).endsWith('.subagent-dispatch.json')) failures.push('platform_session_approval.dispatch_file must be a subagent dispatch artifact');
+    if (!approval.capability_file || !String(approval.capability_file).endsWith('.platform-capability.json')) failures.push('platform_session_approval.capability_file must be a platform capability artifact');
+    if (approval.user_consent_present !== true) failures.push('platform_session_approval.user_consent_present must be true');
+    if (!Array.isArray(approval.allowed_followup) || digestObject(approval.allowed_followup) !== digestObject(['platform-session-create-only'])) failures.push('platform_session_approval.allowed_followup must equal platform-session-create-only');
+    if (!Array.isArray(approval.allowed_result_formats) || digestObject(approval.allowed_result_formats) !== digestObject(['structured-result', 'patch', 'report'])) failures.push('platform_session_approval.allowed_result_formats must match Stage 42 policy');
+    if (approval.budget?.max_sessions !== 1) failures.push('platform_session_approval.budget.max_sessions must be 1');
+    if (approval.budget?.timeout_ms !== 600000) failures.push('platform_session_approval.budget.timeout_ms must be 600000');
+    for (const key of ['session_create', 'platform_api', 'external_network', 'model_invocation', 'subagent_dispatch', 'business_source_write', 'source_merge', 'git', 'worktree']) {
+      if (approval[key] !== false) failures.push(`platform_session_approval.${key} must be false`);
+    }
+    if (!Array.isArray(approval.planned_writes) || digestObject(approval.planned_writes) !== digestObject([path.join(stateDirectoryName, platformSessionApprovalsDirectoryName, '<timestamp>.platform-session-approval.json').replace(/\\/g, '/')])) failures.push('platform_session_approval.planned_writes must only contain platform session approval artifact');
+    const policy = platformSessionApprovalPolicy();
+    if (approval.policy_digest !== policy.policy_digest) failures.push('platform_session_approval policy digest mismatch');
+    const digestPayload = { ...approval };
+    delete digestPayload.approval_digest;
+    if (approval.approval_digest !== digestObject(digestPayload)) failures.push('platform_session_approval digest mismatch');
+    if (root && approval.dispatch_file) {
+      try {
+        const dispatchPath = subagentDispatchFilePath(root, approval.dispatch_file);
+        if (fileDigest(dispatchPath) !== approval.dispatch_digest) failures.push('platform_session_approval dispatch digest mismatch');
+        const dispatchArtifact = readJsonArtifact(dispatchPath, 'Subagent dispatch');
+        const verification = validateSubagentDispatchArtifact(root, dispatchArtifact);
+        failures.push(...verification.failures.map((failure) => `subagent dispatch: ${failure}`));
+        const dispatch = dispatchArtifact.subagent_dispatch || {};
+        if ((dispatch.dispatch_digest || '') !== approval.dispatch_artifact_digest) failures.push('platform_session_approval dispatch artifact digest mismatch');
+        if ((dispatch.task_id || '') !== approval.task_id) failures.push('platform_session_approval task_id mismatch');
+        if ((dispatch.eligibility_file || '') !== approval.eligibility_file) failures.push('platform_session_approval eligibility file mismatch');
+        if ((dispatch.eligibility_digest || '') !== approval.eligibility_digest) failures.push('platform_session_approval eligibility digest mismatch');
+        if ((dispatch[hookPlanDigestField] || '') !== approval[hookPlanDigestField]) failures.push('platform_session_approval hook plan digest mismatch');
+        if ((dispatch.workflow_digest || '') !== approval.workflow_digest) failures.push('platform_session_approval workflow digest mismatch');
+        if ((dispatch.task_brief_digest || '') !== approval.task_brief_digest) failures.push('platform_session_approval task brief digest mismatch');
+      } catch (error) {
+        failures.push(error.message);
+      }
+    }
+    if (root && approval.capability_file) {
+      try {
+        const capabilityPath = platformCapabilityFilePath(root, approval.capability_file);
+        if (fileDigest(capabilityPath) !== approval.capability_digest) failures.push('platform_session_approval capability digest mismatch');
+        const capabilityArtifact = readJsonArtifact(capabilityPath, 'Platform capability');
+        const verification = validatePlatformCapabilityArtifact(capabilityArtifact, path.basename(capabilityPath));
+        failures.push(...verification.failures.map((failure) => `platform capability: ${failure}`));
+        const capability = capabilityArtifact.platform_capability || {};
+        if ((capability.platform || '') !== approval.platform) failures.push('platform_session_approval platform mismatch');
+        if ((capability.adapter || '') !== approval.adapter) failures.push('platform_session_approval adapter mismatch');
+        if ((capability.capability_digest || '') !== approval.platform_capability_digest) failures.push('platform_session_approval platform capability digest mismatch');
+        if ((capability.adapter_digest || '') !== approval.adapter_digest) failures.push('platform_session_approval adapter digest mismatch');
+        if ((capability.catalog_digest || '') !== approval.catalog_digest) failures.push('platform_session_approval catalog digest mismatch');
+      } catch (error) {
+        failures.push(error.message);
+      }
+    }
+    const safety = artifact.safety || {};
+    if (safety.stage !== 'Stage 42') failures.push('safety.stage must be Stage 42');
+    for (const key of ['writes', 'platform_session_approval_artifact', 'approval_required']) if (safety[key] !== true) failures.push(`safety.${key} must be true`);
+    for (const key of ['session_create', 'platform_api', 'external_network', 'model_invocation', 'subagent_dispatch', 'business_source_write', 'source_merge', 'git', 'worktree', backgroundProcessField, 'watcher', 'runtime_action', 'auto_execution']) {
+      if (safety[key] !== false) failures.push(`safety.${key} must be false`);
+    }
+    return { ok: failures.length === 0, failures };
+  }
+
+  function writePlatformSessionApproval(root, envelope) {
+    const fileName = envelope.files?.platform_session_approval || path.basename(platformSessionApprovalSnapshotPath(root));
+    const file = platformSessionApprovalFilePath(root, fileName);
+    const payload = { schema_version: jsonSchemaVersion, command: 'subagents', ...envelope, safety: { ...envelope.safety, platform_session_approval_artifact: true } };
+    const verification = validatePlatformSessionApprovalArtifact(root, payload, path.basename(file));
+    if (!verification.ok) throw new Error(`platform session approval verification failed: ${verification.failures.join('; ')}`);
+    return stateArtifactWriter(path.dirname(file), path.basename(file), payload);
+  }
+
+  function platformSessionSnapshotPaths(root) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    return {
+      timestamp,
+      session: path.join(platformSessionsDirectory(root), `${timestamp}.platform-session.json`),
+      lease: path.join(platformSessionLeasesDirectory(root), `${timestamp}.platform-session-lease.json`),
+      result: path.join(platformSessionResultsDirectory(root), `${timestamp}.platform-session-result.json`),
+    };
+  }
+
+  function platformSessionCancellationSnapshotPath(root) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    return path.join(platformSessionCancellationsDirectory(root), `${timestamp}.platform-session-cancel.json`);
+  }
+
+  function listPlatformSessionFiles(root) {
+    return listStateFiles(root, platformSessionsDirectory, '.platform-session.json');
+  }
+
+  function listPlatformSessionLeaseFiles(root) {
+    return listStateFiles(root, platformSessionLeasesDirectory, '.platform-session-lease.json');
+  }
+
+  function listPlatformSessionResultFiles(root) {
+    return listStateFiles(root, platformSessionResultsDirectory, '.platform-session-result.json');
+  }
+
+  function listPlatformSessionCancellationFiles(root) {
+    return listStateFiles(root, platformSessionCancellationsDirectory, '.platform-session-cancel.json');
+  }
+
+  function platformSessionAdapterOperation() {
+    const operation = {
+      name: 'stage-43-local-platform-session-simulation',
+      version: 1,
+      stage: 'Stage 43',
+      adapter: 'local-contract-only',
+      foreground_only: true,
+      max_sessions: 1,
+      transcript_capture: true,
+      result_capture: true,
+      patch_output_allowed: true,
+      source_write: false,
+      git: false,
+      worktree: false,
+    };
+    return { ...operation, operation_digest: digestObject(operation) };
+  }
+
+  function stage43PlatformSessionSafety({ persist = false } = {}) {
+    const writes = Boolean(persist);
+    return { stage: 'Stage 43', writes, platform_session_artifact: writes, platform_session_lease_artifact: writes, platform_session_result_artifact: writes, session_create: true, platform_api: true, model_invocation: true, external_network: false, result_capture: true, business_source_write: false, source_merge: false, git: false, worktree: false, [backgroundProcessField]: false, watcher: false, auto_execution: false };
+  }
+
+  function stage43PlatformSessionCancelSafety({ persist = false } = {}) {
+    return { stage: 'Stage 43', writes: Boolean(persist), platform_session_cancel_artifact: Boolean(persist), cancel_requested: true, cancelled: false, session_create: false, platform_api: false, model_invocation: false, business_source_write: false, source_merge: false, git: false, worktree: false, [backgroundProcessField]: false, watcher: false };
+  }
+
+  function platformSessionEnvelope(root, approvalFile, { persist = false } = {}) {
+    ensureRoot(root);
+    if (!approvalFile) throw new Error('subagents --create-session requires --from-approval <platform-session-approval-file>');
+    const approvalPath = platformSessionApprovalFilePath(root, approvalFile);
+    const approvalArtifact = readJsonArtifact(approvalPath, 'Platform session approval');
+    const approvalVerification = validatePlatformSessionApprovalArtifact(root, approvalArtifact, path.basename(approvalPath));
+    if (!approvalVerification.ok) throw new Error(`platform session approval verification failed: ${approvalVerification.failures.join('; ')}`);
+    const approval = approvalArtifact.platform_session_approval || {};
+    const paths = platformSessionSnapshotPaths(root);
+    const sessionFile = path.basename(paths.session);
+    const leaseFile = path.basename(paths.lease);
+    const resultFile = path.basename(paths.result);
+    const operation = platformSessionAdapterOperation();
+    const { prompt, transcript, session, lease, result } = platformSessionArtifacts(approval, {
+      approvalPath,
+      paths,
+      sessionFile,
+      leaseFile,
+      resultFile,
+      operation,
+      persist,
+    });
+    return {
+      mode: 'platform-session-create',
+      ok: true,
+      state_present: fs.existsSync(workflowPath(root)),
+      platform_session: session,
+      platform_session_lease: lease,
+      platform_session_result: result,
+      approval: { file: path.basename(approvalPath), digest: fileDigest(approvalPath), verification: approvalVerification },
+      prompt,
+      transcript,
+      adapter_operation: operation,
+      files: { platform_session: sessionFile, platform_session_lease: leaseFile, platform_session_result: resultFile },
+      safety: stage43PlatformSessionSafety({ persist }),
+      quality: [],
+      action: persist
+        ? 'platform session artifacts were written locally with result capture only. No business source, git, or worktree write occurred.'
+        : 'platform session creation was previewed. No files were written and no session was created.',
+    };
+  }
+
+  function platformSessionArtifacts(approval, { approvalPath, paths, sessionFile, leaseFile, resultFile, operation, persist }) {
+    const prompt = {
+      source: 'stage-42-approval-bound-brief', task_id: approval.task_id || '', dispatch_file: approval.dispatch_file || '',
+      approval_file: path.basename(approvalPath), allowed_result_formats: approval.allowed_result_formats || [],
+      boundary: ['no-business-source-write', 'result-artifact-only', 'no-git', 'no-worktree'],
+    };
+    const promptDigest = digestObject(prompt);
+    const sessionId = digestObject({ approval_file: path.basename(approvalPath), approval_digest: fileDigest(approvalPath), prompt_digest: promptDigest, timestamp: paths.timestamp }).slice(0, 24);
+    const transcript = { session_id: sessionId, events: ['session-created', 'brief-submitted', 'result-captured'], adapter: approval.adapter || '', platform: approval.platform || '' };
+    const transcriptDigest = digestObject(transcript);
+    const resultPayload = {
+      kind: 'structured-result', status: 'completed', summary: 'Stage 43 captured a platform session result artifact without writing business source.',
+      patch: '', files_touched: [], verification_evidence: ['session result captured as sidecar only'],
+    };
+    const resultPayloadDigest = digestObject(resultPayload);
+    const sessionCore = {
+      version: 1, stage: 'Stage 43', created_at: new Date().toISOString(), writes: Boolean(persist), session_status: 'completed-result-captured', session_id: sessionId,
+      platform: approval.platform || '', adapter: approval.adapter || '', adapter_operation_digest: operation.operation_digest, approval_file: path.basename(approvalPath), approval_digest: fileDigest(approvalPath),
+      approval_artifact_digest: approval.approval_digest || '', dispatch_file: approval.dispatch_file || '', dispatch_digest: approval.dispatch_digest || '', capability_file: approval.capability_file || '', capability_digest: approval.capability_digest || '',
+      prompt_digest: promptDigest, transcript_digest: transcriptDigest, result_file: resultFile, lease_file: leaseFile, session_create: true, platform_api: true, external_network: false,
+      model_invocation: true, result_capture: true, business_source_write: false, source_merge: false, git: false, worktree: false, allowed_followup: ['platform-session-result-ingest-only'],
+      planned_writes: persist ? expectedStage43PlannedWrites() : [],
+    };
+    const session = { ...sessionCore, session_digest: digestObject(sessionCore) };
+    const sessionDigest = digestObject(session);
+    const leaseCore = {
+      version: 1, stage: 'Stage 43', created_at: new Date().toISOString(), writes: Boolean(persist), lease_status: 'acquired-and-released', active: false,
+      session_file: sessionFile, session_digest: sessionDigest, approval_file: path.basename(approvalPath), approval_digest: fileDigest(approvalPath), session_id: sessionId,
+      acquired: true, released: true, duplicate_session_blocked: true,
+    };
+    const lease = { ...leaseCore, lease_digest: digestObject(leaseCore) };
+    const resultCore = {
+      version: 1, stage: 'Stage 43', created_at: new Date().toISOString(), writes: Boolean(persist), result_status: 'captured-review-required',
+      session_file: sessionFile, session_digest: sessionDigest, lease_file: leaseFile, lease_digest: digestObject(lease), approval_file: path.basename(approvalPath), approval_digest: fileDigest(approvalPath),
+      session_id: sessionId, prompt_digest: promptDigest, transcript_digest: transcriptDigest, result_payload: resultPayload, result_payload_digest: resultPayloadDigest,
+      review_required: true, review_completed: false, business_source_write: false, source_merge: false, git: false, worktree: false, allowed_followup: ['platform-session-result-review-only'],
+    };
+    return { prompt, transcript, session, lease, result: { ...resultCore, result_digest: digestObject(resultCore) } };
+  }
+
+  function expectedStage43PlannedWrites() {
+    return [
+      path.join(stateDirectoryName, platformSessionsDirectoryName, '<timestamp>.platform-session.json').replace(/\\/g, '/'),
+      path.join(stateDirectoryName, platformSessionLeasesDirectoryName, '<timestamp>.platform-session-lease.json').replace(/\\/g, '/'),
+      path.join(stateDirectoryName, platformSessionResultsDirectoryName, '<timestamp>.platform-session-result.json').replace(/\\/g, '/'),
+    ];
+  }
+
+  function validatePlatformSessionArtifact(root, artifact, fileName = '') {
+    const failures = [];
+    if (artifact.schema_version !== jsonSchemaVersion) failures.push('schema_version must be 1');
+    if (artifact.command !== 'subagents') failures.push('command must be subagents');
+    if (artifact.mode !== 'platform-session-create') failures.push('mode must be platform-session-create');
+    const session = artifact.platform_session || {};
+    const lease = artifact.platform_session_lease || {};
+    const result = artifact.platform_session_result || {};
+    const files = artifact.files || {};
+    if (!files.platform_session || !String(files.platform_session).endsWith('.platform-session.json')) failures.push('files.platform_session must be a platform session artifact');
+    if (!files.platform_session_lease || !String(files.platform_session_lease).endsWith('.platform-session-lease.json')) failures.push('files.platform_session_lease must be a platform session lease artifact');
+    if (!files.platform_session_result || !String(files.platform_session_result).endsWith('.platform-session-result.json')) failures.push('files.platform_session_result must be a platform session result artifact');
+    if (fileName) {
+      if (fileName.endsWith('.platform-session.json') && files.platform_session !== fileName) failures.push('Stage 43 platform session file identity mismatch');
+      else if (fileName.endsWith('.platform-session-lease.json') && files.platform_session_lease !== fileName) failures.push('Stage 43 platform session lease file identity mismatch');
+      else if (fileName.endsWith('.platform-session-result.json') && files.platform_session_result !== fileName) failures.push('Stage 43 platform session result file identity mismatch');
+      else if (!fileName.endsWith('.platform-session.json') && !fileName.endsWith('.platform-session-lease.json') && !fileName.endsWith('.platform-session-result.json')) failures.push('Stage 43 platform session artifact file extension is unsupported');
+    }
+    if (session.version !== 1 || lease.version !== 1 || result.version !== 1) failures.push('Stage 43 artifact versions must be 1');
+    if (session.stage !== 'Stage 43' || lease.stage !== 'Stage 43' || result.stage !== 'Stage 43') failures.push('Stage 43 artifact stages must be Stage 43');
+    if (session.writes !== true || lease.writes !== true || result.writes !== true) failures.push('Stage 43 artifacts must be confirmed writes');
+    if (session.session_status !== 'completed-result-captured') failures.push('platform_session.session_status must be completed-result-captured');
+    if (lease.lease_status !== 'acquired-and-released' || lease.active !== false) failures.push('platform_session_lease must be acquired-and-released and inactive');
+    if (result.result_status !== 'captured-review-required') failures.push('platform_session_result.result_status must be captured-review-required');
+    if (!Array.isArray(session.allowed_followup) || digestObject(session.allowed_followup) !== digestObject(['platform-session-result-ingest-only'])) failures.push('platform_session.allowed_followup must equal platform-session-result-ingest-only');
+    if (!Array.isArray(result.allowed_followup) || digestObject(result.allowed_followup) !== digestObject(['platform-session-result-review-only'])) failures.push('platform_session_result.allowed_followup must equal platform-session-result-review-only');
+    if (!Array.isArray(session.planned_writes) || digestObject(session.planned_writes) !== digestObject(expectedStage43PlannedWrites())) failures.push('platform_session.planned_writes must match Stage 43 write whitelist');
+    for (const key of ['session_create', 'platform_api', 'model_invocation', 'result_capture']) if (session[key] !== true) failures.push(`platform_session.${key} must be true`);
+    for (const key of ['external_network', 'business_source_write', 'source_merge', 'git', 'worktree']) if (session[key] !== false) failures.push(`platform_session.${key} must be false`);
+    for (const key of ['business_source_write', 'source_merge', 'git', 'worktree']) if (result[key] !== false) failures.push(`platform_session_result.${key} must be false`);
+    if (result.review_required !== true || result.review_completed !== false) failures.push('platform_session_result must require incomplete review');
+    const sessionDigestPayload = { ...session };
+    delete sessionDigestPayload.session_digest;
+    if (session.session_digest !== digestObject(sessionDigestPayload)) failures.push('platform_session digest mismatch');
+    const sessionDigest = digestObject(session);
+    if (lease.session_digest !== sessionDigest || result.session_digest !== sessionDigest) failures.push('Stage 43 session digest binding mismatch');
+    const leaseDigestPayload = { ...lease };
+    delete leaseDigestPayload.lease_digest;
+    if (lease.lease_digest !== digestObject(leaseDigestPayload)) failures.push('platform_session_lease digest mismatch');
+    const leaseDigest = digestObject(lease);
+    if (result.lease_digest !== leaseDigest) failures.push('platform_session_result lease digest mismatch');
+    const resultPayloadDigest = digestObject(result.result_payload || {});
+    if (result.result_payload_digest !== resultPayloadDigest) failures.push('platform_session_result payload digest mismatch');
+    const resultDigestPayload = { ...result };
+    delete resultDigestPayload.result_digest;
+    if (result.result_digest !== digestObject(resultDigestPayload)) failures.push('platform_session_result digest mismatch');
+    const operation = platformSessionAdapterOperation();
+    if (session.adapter_operation_digest !== operation.operation_digest) failures.push('platform_session adapter operation digest mismatch');
+    if (root && session.approval_file) {
+      try {
+        const approvalPath = platformSessionApprovalFilePath(root, session.approval_file);
+        if (fileDigest(approvalPath) !== session.approval_digest) failures.push('platform_session approval digest mismatch');
+        const approvalArtifact = readJsonArtifact(approvalPath, 'Platform session approval');
+        const verification = validatePlatformSessionApprovalArtifact(root, approvalArtifact, path.basename(approvalPath));
+        failures.push(...verification.failures.map((failure) => `platform session approval: ${failure}`));
+        if ((approvalArtifact.platform_session_approval?.approval_digest || '') !== session.approval_artifact_digest) failures.push('platform_session approval artifact digest mismatch');
+        if ((approvalArtifact.platform_session_approval?.dispatch_file || '') !== session.dispatch_file) failures.push('platform_session dispatch file mismatch');
+        if ((approvalArtifact.platform_session_approval?.capability_file || '') !== session.capability_file) failures.push('platform_session capability file mismatch');
+      } catch (error) {
+        failures.push(error.message);
+      }
+    }
+    const safety = artifact.safety || {};
+    if (safety.stage !== 'Stage 43') failures.push('safety.stage must be Stage 43');
+    for (const key of ['writes', 'platform_session_artifact', 'platform_session_lease_artifact', 'platform_session_result_artifact', 'session_create', 'platform_api', 'model_invocation', 'result_capture']) if (safety[key] !== true) failures.push(`safety.${key} must be true`);
+    for (const key of ['external_network', 'business_source_write', 'source_merge', 'git', 'worktree', backgroundProcessField, 'watcher', 'auto_execution']) if (safety[key] !== false) failures.push(`safety.${key} must be false`);
+    return { ok: failures.length === 0, failures };
+  }
+
+  function writePlatformSession(root, envelope) {
+    const sessionFile = platformSessionFilePath(root, envelope.files.platform_session);
+    const leaseFile = platformSessionLeaseFilePath(root, envelope.files.platform_session_lease);
+    const resultFile = platformSessionResultFilePath(root, envelope.files.platform_session_result);
+    const payload = { schema_version: jsonSchemaVersion, command: 'subagents', ...envelope, safety: { ...envelope.safety, platform_session_artifact: true, platform_session_lease_artifact: true, platform_session_result_artifact: true } };
+    const verification = validatePlatformSessionArtifact(root, payload, path.basename(sessionFile));
+    if (!verification.ok) throw new Error(`platform session verification failed: ${verification.failures.join('; ')}`);
+    stateArtifactWriter(path.dirname(sessionFile), path.basename(sessionFile), payload);
+    stateArtifactWriter(path.dirname(leaseFile), path.basename(leaseFile), payload);
+    stateArtifactWriter(path.dirname(resultFile), path.basename(resultFile), payload);
+    return { sessionFile, leaseFile, resultFile };
+  }
+
+  function platformSessionCancelEnvelope(root, sessionFile, { persist = false } = {}) {
+    ensureRoot(root);
+    const sessionPath = platformSessionFilePath(root, sessionFile);
+    const artifact = readJsonArtifact(sessionPath, 'Platform session');
+    const verification = validatePlatformSessionArtifact(root, artifact, path.basename(sessionPath));
+    if (!verification.ok) throw new Error(`platform session verification failed: ${verification.failures.join('; ')}`);
+    const cancelFile = path.basename(platformSessionCancellationSnapshotPath(root));
+    const cancelCore = {
+      version: 1,
+      stage: 'Stage 43',
+      created_at: new Date().toISOString(),
+      writes: Boolean(persist),
+      cancelled: false,
+      cancel_status: 'not-needed-session-already-terminal',
+      session_file: path.basename(sessionPath),
+      session_digest: fileDigest(sessionPath),
+      session_id: artifact.platform_session?.session_id || '',
+      source_mutation: false,
+      business_source_write: false,
+      source_merge: false,
+      git: false,
+      worktree: false,
+      allowed_followup: ['platform-session-result-ingest-only'],
+    };
+    const cancel = { ...cancelCore, cancel_digest: digestObject(cancelCore) };
+    return {
+      mode: 'platform-session-cancel',
+      ok: true,
+      state_present: fs.existsSync(workflowPath(root)),
+      platform_session_cancel: cancel,
+      session: { file: path.basename(sessionPath), digest: fileDigest(sessionPath), verification },
+      files: { platform_session_cancel: cancelFile },
+      safety: stage43PlatformSessionCancelSafety({ persist }),
+      quality: [],
+      action: persist
+        ? 'platform session cancel artifact was written locally. Session was already terminal; no platform API, source, git, or worktree write occurred.'
+        : 'platform session cancel was audited. Session was already terminal; no files were written and no platform API call occurred.',
+    };
+  }
+
+  function validatePlatformSessionCancelArtifact(root, artifact, fileName = '') {
+    const failures = [];
+    if (artifact.schema_version !== jsonSchemaVersion) failures.push('schema_version must be 1');
+    if (artifact.command !== 'subagents') failures.push('command must be subagents');
+    if (artifact.mode !== 'platform-session-cancel') failures.push('mode must be platform-session-cancel');
+    const cancel = artifact.platform_session_cancel || {};
+    const files = artifact.files || {};
+    if (!files.platform_session_cancel || !String(files.platform_session_cancel).endsWith('.platform-session-cancel.json')) failures.push('files.platform_session_cancel must be a platform session cancellation artifact');
+    if (fileName) {
+      if (!fileName.endsWith('.platform-session-cancel.json')) failures.push('Stage 43 platform session cancel artifact file extension is unsupported');
+      else if (files.platform_session_cancel !== fileName) failures.push('Stage 43 platform session cancel file identity mismatch');
+    }
+    if (cancel.version !== 1) failures.push('platform_session_cancel.version must be 1');
+    if (cancel.stage !== 'Stage 43') failures.push('platform_session_cancel.stage must be Stage 43');
+    if (cancel.writes !== true) failures.push('platform_session_cancel.writes must be true');
+    if (cancel.cancelled !== false) failures.push('platform_session_cancel.cancelled must be false');
+    if (cancel.cancel_status !== 'not-needed-session-already-terminal') failures.push('platform_session_cancel.cancel_status must be not-needed-session-already-terminal');
+    if (!cancel.session_file || !String(cancel.session_file).endsWith('.platform-session.json')) failures.push('platform_session_cancel.session_file must be a platform session artifact');
+    if (!Array.isArray(cancel.allowed_followup) || digestObject(cancel.allowed_followup) !== digestObject(['platform-session-result-ingest-only'])) failures.push('platform_session_cancel.allowed_followup must equal platform-session-result-ingest-only');
+    for (const key of ['source_mutation', 'business_source_write', 'source_merge', 'git', 'worktree']) if (cancel[key] !== false) failures.push(`platform_session_cancel.${key} must be false`);
+    const cancelDigestPayload = { ...cancel };
+    delete cancelDigestPayload.cancel_digest;
+    if (cancel.cancel_digest !== digestObject(cancelDigestPayload)) failures.push('platform_session_cancel digest mismatch');
+    if (root && cancel.session_file) {
+      try {
+        const sessionPath = platformSessionFilePath(root, cancel.session_file);
+        if (fileDigest(sessionPath) !== cancel.session_digest) failures.push('platform_session_cancel session digest mismatch');
+        const sessionArtifact = readJsonArtifact(sessionPath, 'Platform session');
+        const verification = validatePlatformSessionArtifact(root, sessionArtifact, path.basename(sessionPath));
+        failures.push(...verification.failures.map((failure) => `platform session: ${failure}`));
+        if ((sessionArtifact.platform_session?.session_id || '') !== cancel.session_id) failures.push('platform_session_cancel session_id mismatch');
+      } catch (error) {
+        failures.push(error.message);
+      }
+    }
+    const safety = artifact.safety || {};
+    if (safety.stage !== 'Stage 43') failures.push('safety.stage must be Stage 43');
+    for (const key of ['writes', 'platform_session_cancel_artifact', 'cancel_requested']) if (safety[key] !== true) failures.push(`safety.${key} must be true`);
+    for (const key of ['cancelled', 'session_create', 'platform_api', 'model_invocation', 'business_source_write', 'source_merge', 'git', 'worktree', backgroundProcessField, 'watcher']) if (safety[key] !== false) failures.push(`safety.${key} must be false`);
+    return { ok: failures.length === 0, failures };
+  }
+
+  function writePlatformSessionCancel(root, envelope) {
+    const file = platformSessionCancellationFilePath(root, envelope.files.platform_session_cancel);
+    const payload = { schema_version: jsonSchemaVersion, command: 'subagents', ...envelope, safety: { ...envelope.safety, platform_session_cancel_artifact: true } };
+    const verification = validatePlatformSessionCancelArtifact(root, payload, path.basename(file));
+    if (!verification.ok) throw new Error(`platform session cancel verification failed: ${verification.failures.join('; ')}`);
+    return stateArtifactWriter(path.dirname(file), path.basename(file), payload);
+  }
+
+  function platformSessionIntakeSnapshotPath(root) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    return path.join(platformSessionIntakeDirectory(root), `${timestamp}.platform-session-intake.json`);
+  }
+
+  function platformSessionReviewSnapshotPath(root) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    return path.join(platformSessionReviewsDirectory(root), `${timestamp}.platform-session-review.json`);
+  }
+
+  function listPlatformSessionIntakeFiles(root) {
+    return listStateFiles(root, platformSessionIntakeDirectory, '.platform-session-intake.json');
+  }
+
+  function listPlatformSessionReviewFiles(root) {
+    return listStateFiles(root, platformSessionReviewsDirectory, '.platform-session-review.json');
+  }
+
+  function stage44Safety({ writes = false, intake = false, review = false } = {}) {
+    return {
+      stage: 'Stage 44',
+      writes: Boolean(writes),
+      platform_session_intake_artifact: Boolean(intake),
+      platform_session_review_artifact: Boolean(review),
+      result_ingestion: true,
+      review_gate: true,
+      session_create: false,
+      platform_api: false,
+      model_invocation: false,
+      business_source_write: false,
+      source_merge: false,
+      source_mutation: false,
+      forbidden_file_write: false,
+      git: false,
+      worktree: false,
+      [backgroundProcessField]: false,
+      watcher: false,
+      auto_execution: false,
+    };
+  }
+
+  function platformSessionResultIntakeEnvelope(root, resultFile, { persist = false, artifactFile = '' } = {}) {
+    ensureRoot(root);
+    const resultPath = platformSessionResultFilePath(root, resultFile);
+    const sessionArtifact = readJsonArtifact(resultPath, 'Platform session result');
+    const sessionVerification = validatePlatformSessionArtifact(root, sessionArtifact, path.basename(resultPath));
+    if (!sessionVerification.ok) throw new Error(`platform session verification failed: ${sessionVerification.failures.join('; ')}`);
+    const session = sessionArtifact.platform_session || {};
+    const result = sessionArtifact.platform_session_result || {};
+    const payload = result.result_payload || {};
+    const patchText = String(payload.patch || '');
+    const filesTouched = Array.isArray(payload.files_touched) ? payload.files_touched : [];
+    const evidence = Array.isArray(payload.verification_evidence) ? payload.verification_evidence : [];
+    const scopeChecks = [
+      { id: 'session_result_verified', status: sessionVerification.ok ? 'passed' : 'blocked', evidence: [path.basename(resultPath)], blocked_reason: sessionVerification.ok ? '' : 'Stage 43 result verification failed' },
+      { id: 'structured_result', status: payload.kind === 'structured-result' ? 'passed' : 'blocked', evidence: [`kind=${payload.kind || ''}`], blocked_reason: payload.kind === 'structured-result' ? '' : 'session result is not structured' },
+      { id: 'patch_parseable', status: patchText === '' || patchText.startsWith('diff --git ') ? 'passed' : 'blocked', evidence: [patchText === '' ? 'empty patch accepted for Stage 44 review-only path' : 'git diff header present'], blocked_reason: patchText === '' || patchText.startsWith('diff --git ') ? '' : 'patch is not a bounded git diff' },
+      { id: 'scope_not_exceeded', status: filesTouched.every((file) => typeof file === 'string' && !path.isAbsolute(file) && !file.includes('..') && !file.includes('\\')) ? 'passed' : 'blocked', evidence: filesTouched, blocked_reason: filesTouched.every((file) => typeof file === 'string' && !path.isAbsolute(file) && !file.includes('..') && !file.includes('\\')) ? '' : 'files_touched contains unsafe path' },
+      { id: 'no_source_write_claim', status: result.business_source_write === false && result.source_merge === false && result.git === false && result.worktree === false ? 'passed' : 'blocked', evidence: ['business_source_write=false', 'source_merge=false', 'git=false', 'worktree=false'], blocked_reason: result.business_source_write === false && result.source_merge === false && result.git === false && result.worktree === false ? '' : 'session result claims source mutation' },
+      { id: 'verification_evidence', status: evidence.length > 0 ? 'passed' : 'blocked', evidence, blocked_reason: evidence.length > 0 ? '' : 'session result evidence missing' },
+    ];
+    const blockedReasons = scopeChecks.filter((check) => check.status !== 'passed').map((check) => `${check.id}: ${check.blocked_reason}`);
+    const intakeFile = artifactFile || path.basename(platformSessionIntakeSnapshotPath(root));
+    const core = {
+      version: 1,
+      stage: 'Stage 44',
+      created_at: new Date().toISOString(),
+      writes: Boolean(persist),
+      source_result_file: path.basename(resultPath),
+      source_result_digest: fileDigest(resultPath),
+      session_file: result.session_file || sessionArtifact.files?.platform_session || '',
+      session_digest: result.session_digest || '',
+      approval_file: result.approval_file || session.approval_file || '',
+      approval_digest: result.approval_digest || session.approval_digest || '',
+      prompt_digest: result.prompt_digest || session.prompt_digest || '',
+      transcript_digest: result.transcript_digest || session.transcript_digest || '',
+      result_payload_digest: result.result_payload_digest || '',
+      patch_digest: digestObject({ patch: patchText }),
+      files_touched: filesTouched,
+      intake_status: blockedReasons.length === 0 ? 'ingested-review-required' : 'blocked',
+      scope_checks: scopeChecks,
+      blocked_reasons: blockedReasons,
+      structured_result: payload.kind === 'structured-result',
+      patch_parseable: patchText === '' || patchText.startsWith('diff --git '),
+      forbidden_files_modified: false,
+      business_source_write: false,
+      source_merge: false,
+      git: false,
+      worktree: false,
+      review_required: true,
+      review_completed: false,
+      allowed_followup: ['source-change-candidate-only'],
+      planned_writes: persist ? [path.join(stateDirectoryName, platformSessionIntakeDirectoryName, '<timestamp>.platform-session-intake.json').replace(/\\/g, '/')] : [],
+    };
+    return {
+      mode: 'platform-session-result-ingestion',
+      ok: blockedReasons.length === 0,
+      state_present: fs.existsSync(workflowPath(root)),
+      platform_session_intake: { ...core, intake_digest: digestObject(core) },
+      source_result: { file: path.basename(resultPath), digest: fileDigest(resultPath), verification: sessionVerification },
+      files: { platform_session_intake: intakeFile },
+      safety: stage44Safety({ writes: persist, intake: persist }),
+      quality: blockedReasons,
+      action: persist
+        ? 'platform session result intake artifact was written locally. No source, git, worktree, or merge write occurred.'
+        : 'platform session result intake was previewed read-only. No files were written and no result was merged.',
+    };
+  }
+
+  function validatePlatformSessionIntakeArtifact(root, artifact, fileName = '') {
+    const failures = [];
+    if (artifact.schema_version !== jsonSchemaVersion) failures.push('schema_version must be 1');
+    if (artifact.command !== 'subagents') failures.push('command must be subagents');
+    if (artifact.mode !== 'platform-session-result-ingestion') failures.push('mode must be platform-session-result-ingestion');
+    const intake = artifact.platform_session_intake || {};
+    const files = artifact.files || {};
+    if (!files.platform_session_intake || !String(files.platform_session_intake).endsWith('.platform-session-intake.json')) failures.push('files.platform_session_intake must be a platform session intake artifact');
+    if (fileName) {
+      if (!fileName.endsWith('.platform-session-intake.json')) failures.push('Stage 44 platform session intake artifact file extension is unsupported');
+      else if (files.platform_session_intake !== fileName) failures.push('Stage 44 platform session intake file identity mismatch');
+    }
+    if (intake.version !== 1) failures.push('platform_session_intake.version must be 1');
+    if (intake.stage !== 'Stage 44') failures.push('platform_session_intake.stage must be Stage 44');
+    if (intake.writes !== true) failures.push('platform_session_intake.writes must be true');
+    if (intake.intake_status !== 'ingested-review-required') failures.push('platform_session_intake.intake_status must be ingested-review-required');
+    if (!Array.isArray(intake.allowed_followup) || digestObject(intake.allowed_followup) !== digestObject(['source-change-candidate-only'])) failures.push('platform_session_intake.allowed_followup must equal source-change-candidate-only');
+    for (const key of ['forbidden_files_modified', 'business_source_write', 'source_merge', 'git', 'worktree', 'review_completed']) if (intake[key] !== false) failures.push(`platform_session_intake.${key} must be false`);
+    if (intake.review_required !== true) failures.push('platform_session_intake.review_required must be true');
+    if (!Array.isArray(intake.scope_checks)) failures.push('platform_session_intake.scope_checks must be an array');
+    if (!Array.isArray(intake.files_touched)) failures.push('platform_session_intake.files_touched must be an array');
+    const expectedWrites = [path.join(stateDirectoryName, platformSessionIntakeDirectoryName, '<timestamp>.platform-session-intake.json').replace(/\\/g, '/')];
+    if (!Array.isArray(intake.planned_writes) || digestObject(intake.planned_writes) !== digestObject(expectedWrites)) failures.push('platform_session_intake.planned_writes must only contain platform session intake artifact');
+    const digestPayload = { ...intake };
+    delete digestPayload.intake_digest;
+    if (intake.intake_digest !== digestObject(digestPayload)) failures.push('platform_session_intake digest mismatch');
+    if (root && intake.source_result_file) {
+      try {
+        const sourcePath = platformSessionResultFilePath(root, intake.source_result_file);
+        if (fileDigest(sourcePath) !== intake.source_result_digest) failures.push('platform_session_intake source result digest mismatch');
+        const source = readJsonArtifact(sourcePath, 'Platform session result');
+        const verification = validatePlatformSessionArtifact(root, source, path.basename(sourcePath));
+        failures.push(...verification.failures.map((failure) => `platform session result: ${failure}`));
+        const result = source.platform_session_result || {};
+        if ((result.session_digest || '') !== intake.session_digest) failures.push('platform_session_intake session digest mismatch');
+        if ((result.prompt_digest || '') !== intake.prompt_digest) failures.push('platform_session_intake prompt digest mismatch');
+        if ((result.transcript_digest || '') !== intake.transcript_digest) failures.push('platform_session_intake transcript digest mismatch');
+        if ((result.result_payload_digest || '') !== intake.result_payload_digest) failures.push('platform_session_intake result payload digest mismatch');
+      } catch (error) {
+        failures.push(error.message);
+      }
+    }
+    const safety = artifact.safety || {};
+    if (safety.stage !== 'Stage 44') failures.push('safety.stage must be Stage 44');
+    for (const key of ['writes', 'platform_session_intake_artifact', 'result_ingestion', 'review_gate']) if (safety[key] !== true) failures.push(`safety.${key} must be true`);
+    for (const key of ['session_create', 'platform_api', 'model_invocation', 'business_source_write', 'source_merge', 'source_mutation', 'forbidden_file_write', 'git', 'worktree', backgroundProcessField, 'watcher', 'auto_execution']) if (safety[key] !== false) failures.push(`safety.${key} must be false`);
+    return { ok: failures.length === 0, failures };
+  }
+
+  function writePlatformSessionIntake(root, envelope) {
+    const file = platformSessionIntakeFilePath(root, envelope.files.platform_session_intake);
+    const payload = { schema_version: jsonSchemaVersion, command: 'subagents', ...envelope, safety: { ...envelope.safety, platform_session_intake_artifact: true } };
+    const verification = validatePlatformSessionIntakeArtifact(root, payload, path.basename(file));
+    if (!verification.ok) throw new Error(`platform session intake verification failed: ${verification.failures.join('; ')}`);
+    return stateArtifactWriter(path.dirname(file), path.basename(file), payload);
+  }
+
+  function platformSessionReviewEnvelope(root, intakeFile, { persist = false, artifactFile = '' } = {}) {
+    ensureRoot(root);
+    const intakePath = platformSessionIntakeFilePath(root, intakeFile);
+    const intakeArtifact = readJsonArtifact(intakePath, 'Platform session intake');
+    const intakeVerification = validatePlatformSessionIntakeArtifact(root, intakeArtifact, path.basename(intakePath));
+    if (!intakeVerification.ok) throw new Error(`platform session intake verification failed: ${intakeVerification.failures.join('; ')}`);
+    const intake = intakeArtifact.platform_session_intake || {};
+    const checks = [
+      { id: 'intake_verified', passed: intakeVerification.ok, evidence: [path.basename(intakePath)] },
+      { id: 'structured_patch_scope', passed: intake.structured_result === true && intake.patch_parseable === true, evidence: [`files=${intake.files_touched?.length || 0}`] },
+      { id: 'no_forbidden_source_claim', passed: intake.business_source_write === false && intake.source_merge === false && intake.git === false && intake.worktree === false, evidence: ['business_source_write=false', 'source_merge=false', 'git=false', 'worktree=false'] },
+      { id: 'review_still_required', passed: intake.review_required === true && intake.review_completed === false, evidence: ['review_required=true', 'review_completed=false'] },
+    ];
+    const blockedReasons = checks.filter((check) => !check.passed).map((check) => `${check.id}: failed`);
+    const reviewFile = artifactFile || path.basename(platformSessionReviewSnapshotPath(root));
+    const core = {
+      version: 1,
+      stage: 'Stage 44',
+      created_at: new Date().toISOString(),
+      writes: Boolean(persist),
+      intake_file: path.basename(intakePath),
+      intake_digest: fileDigest(intakePath),
+      source_result_file: intake.source_result_file || '',
+      source_result_digest: intake.source_result_digest || '',
+      session_file: intake.session_file || '',
+      session_digest: intake.session_digest || '',
+      approval_file: intake.approval_file || '',
+      approval_digest: intake.approval_digest || '',
+      patch_digest: intake.patch_digest || '',
+      files_touched: intake.files_touched || [],
+      review_status: blockedReasons.length === 0 ? 'review-gate-passed-source-candidate-required' : 'blocked',
+      checks,
+      blocked_reasons: blockedReasons,
+      business_source_write: false,
+      source_merge: false,
+      git: false,
+      worktree: false,
+      review_required: true,
+      review_completed: true,
+      allowed_followup: ['source-change-candidate-only'],
+      planned_writes: persist ? [path.join(stateDirectoryName, platformSessionReviewsDirectoryName, '<timestamp>.platform-session-review.json').replace(/\\/g, '/')] : [],
+    };
+    return {
+      mode: 'platform-session-review-gate',
+      ok: blockedReasons.length === 0,
+      state_present: fs.existsSync(workflowPath(root)),
+      platform_session_review: { ...core, review_digest: digestObject(core) },
+      platform_session_intake: { file: path.basename(intakePath), digest: fileDigest(intakePath), verification: intakeVerification },
+      files: { platform_session_review: reviewFile },
+      safety: stage44Safety({ writes: persist, review: persist }),
+      quality: blockedReasons,
+      action: persist
+        ? 'platform session review gate artifact was written locally. No source, git, worktree, or merge write occurred.'
+        : 'platform session review gate was previewed read-only. No files were written and no result was merged.',
+    };
+  }
+
+  function validatePlatformSessionReviewArtifact(root, artifact, fileName = '') {
+    const failures = [];
+    if (artifact.schema_version !== jsonSchemaVersion) failures.push('schema_version must be 1');
+    if (artifact.command !== 'subagents') failures.push('command must be subagents');
+    if (artifact.mode !== 'platform-session-review-gate') failures.push('mode must be platform-session-review-gate');
+    const review = artifact.platform_session_review || {};
+    const files = artifact.files || {};
+    if (!files.platform_session_review || !String(files.platform_session_review).endsWith('.platform-session-review.json')) failures.push('files.platform_session_review must be a platform session review artifact');
+    if (fileName) {
+      if (!fileName.endsWith('.platform-session-review.json')) failures.push('Stage 44 platform session review artifact file extension is unsupported');
+      else if (files.platform_session_review !== fileName) failures.push('Stage 44 platform session review file identity mismatch');
+    }
+    if (review.version !== 1) failures.push('platform_session_review.version must be 1');
+    if (review.stage !== 'Stage 44') failures.push('platform_session_review.stage must be Stage 44');
+    if (review.writes !== true) failures.push('platform_session_review.writes must be true');
+    if (review.review_status !== 'review-gate-passed-source-candidate-required') failures.push('platform_session_review.review_status must be review-gate-passed-source-candidate-required');
+    if (!Array.isArray(review.allowed_followup) || digestObject(review.allowed_followup) !== digestObject(['source-change-candidate-only'])) failures.push('platform_session_review.allowed_followup must equal source-change-candidate-only');
+    for (const key of ['business_source_write', 'source_merge', 'git', 'worktree']) if (review[key] !== false) failures.push(`platform_session_review.${key} must be false`);
+    if (review.review_required !== true || review.review_completed !== true) failures.push('platform_session_review review flags mismatch');
+    const expectedWrites = [path.join(stateDirectoryName, platformSessionReviewsDirectoryName, '<timestamp>.platform-session-review.json').replace(/\\/g, '/')];
+    if (!Array.isArray(review.planned_writes) || digestObject(review.planned_writes) !== digestObject(expectedWrites)) failures.push('platform_session_review.planned_writes must only contain platform session review artifact');
+    const digestPayload = { ...review };
+    delete digestPayload.review_digest;
+    if (review.review_digest !== digestObject(digestPayload)) failures.push('platform_session_review digest mismatch');
+    if (root && review.intake_file) {
+      try {
+        const intakePath = platformSessionIntakeFilePath(root, review.intake_file);
+        if (fileDigest(intakePath) !== review.intake_digest) failures.push('platform_session_review intake digest mismatch');
+        const intakeArtifact = readJsonArtifact(intakePath, 'Platform session intake');
+        const verification = validatePlatformSessionIntakeArtifact(root, intakeArtifact, path.basename(intakePath));
+        failures.push(...verification.failures.map((failure) => `platform session intake: ${failure}`));
+        if ((intakeArtifact.platform_session_intake?.session_digest || '') !== review.session_digest) failures.push('platform_session_review session digest mismatch');
+        if ((intakeArtifact.platform_session_intake?.patch_digest || '') !== review.patch_digest) failures.push('platform_session_review patch digest mismatch');
+      } catch (error) {
+        failures.push(error.message);
+      }
+    }
+    const safety = artifact.safety || {};
+    if (safety.stage !== 'Stage 44') failures.push('safety.stage must be Stage 44');
+    for (const key of ['writes', 'platform_session_review_artifact', 'result_ingestion', 'review_gate']) if (safety[key] !== true) failures.push(`safety.${key} must be true`);
+    for (const key of ['session_create', 'platform_api', 'model_invocation', 'business_source_write', 'source_merge', 'source_mutation', 'forbidden_file_write', 'git', 'worktree', backgroundProcessField, 'watcher', 'auto_execution']) if (safety[key] !== false) failures.push(`safety.${key} must be false`);
+    return { ok: failures.length === 0, failures };
+  }
+
+  function writePlatformSessionReview(root, envelope) {
+    const file = platformSessionReviewFilePath(root, envelope.files.platform_session_review);
+    const payload = { schema_version: jsonSchemaVersion, command: 'subagents', ...envelope, safety: { ...envelope.safety, platform_session_review_artifact: true } };
+    const verification = validatePlatformSessionReviewArtifact(root, payload, path.basename(file));
+    if (!verification.ok) throw new Error(`platform session review verification failed: ${verification.failures.join('; ')}`);
+    return stateArtifactWriter(path.dirname(file), path.basename(file), payload);
+  }
+
+  return {
+    platformSessionApprovalSnapshotPath,
+    listPlatformSessionApprovalFiles,
+    platformSessionApprovalEnvelope,
+    validatePlatformSessionApprovalArtifact,
+    writePlatformSessionApproval,
+    listPlatformSessionFiles,
+    listPlatformSessionLeaseFiles,
+    listPlatformSessionResultFiles,
+    listPlatformSessionCancellationFiles,
+    platformSessionEnvelope,
+    validatePlatformSessionArtifact,
+    writePlatformSession,
+    platformSessionCancelEnvelope,
+    validatePlatformSessionCancelArtifact,
+    writePlatformSessionCancel,
+    platformSessionIntakeSnapshotPath,
+    platformSessionReviewSnapshotPath,
+    listPlatformSessionIntakeFiles,
+    listPlatformSessionReviewFiles,
+    platformSessionResultIntakeEnvelope,
+    validatePlatformSessionIntakeArtifact,
+    writePlatformSessionIntake,
+    platformSessionReviewEnvelope,
+    validatePlatformSessionReviewArtifact,
+    writePlatformSessionReview,
+  };
+};