@playcraft/cli 0.1.70 → 0.1.72

package/dist/workspace-runtime/workspaces/remix-references.js

@@ -1,7 +1,7 @@
 import { execFile } from 'node:child_process';
 import { createHash, randomUUID } from 'node:crypto';
 import { constants } from 'node:fs';
-import { chmod, lstat, mkdir, mkdtemp, open, readdir, realpath, rename, rm, writeFile } from 'node:fs/promises';
+import { chmod, lstat, mkdir, mkdtemp, open, readdir, realpath, rename, rm, writeFile, } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 import { promisify } from 'node:util';
 import { WORKSPACE_REMIX_REFERENCE_MAX_BYTES, WORKSPACE_REMIX_REFERENCE_MAX_FILES, WORKSPACE_REMIX_REFERENCES_DIRECTORY, WORKSPACE_REMIX_REFERENCES_MANIFEST, remixReferenceContentHashInput, workspaceDirectoryNameSchema, workspaceRemixReferenceExportSchema, workspaceRemixReferenceSchema, } from '@playcraft/common/cloud-workspace/runtime';
@@ -12,24 +12,51 @@ const ATTRIBUTES = '.gitattributes';
 const SNAPSHOT_ATTRIBUTES = '* -filter -text -ident -working-tree-encoding -eol\n';
 const INERT_DIRECTORY = '_source_metadata';
 const MANIFEST_MAX_BYTES = 16 * 1024 * 1024;
-const EXCLUDED = new Set(['.git', 'node_modules', '.next', '.cache', '.tmp', '.turbo', '.pnpm-store', '.ssh', '.aws']);
-const INERT = new Set(['.agents', '.claude', '.codex', '.cursor', '.playcraft', '.gitignore', '.gitattributes',
-    '.gitmodules', 'agents.md', 'claude.md', 'gemini.md', '.cursorrules', '.mcp.json']);
+const EXCLUDED = new Set([
+    '.git',
+    'node_modules',
+    '.next',
+    '.cache',
+    '.tmp',
+    '.turbo',
+    '.pnpm-store',
+    '.ssh',
+    '.aws',
+]);
+const INERT = new Set([
+    '.agents',
+    '.claude',
+    '.codex',
+    '.cursor',
+    '.playcraft',
+    '.gitignore',
+    '.gitattributes',
+    '.gitmodules',
+    'agents.md',
+    'claude.md',
+    'gemini.md',
+    '.cursorrules',
+    '.mcp.json',
+]);
 const locks = new Map();
 const hash = (value) => createHash('sha256').update(value).digest('hex');
 export class RemixReferenceError extends Error {
-    constructor(code) { super(code); this.name = 'RemixReferenceError'; }
+    constructor(code) {
+        super(code);
+        this.name = 'RemixReferenceError';
+    }
 }
 async function safeDirectory(root, relative = '', create = false) {
     let current = root;
     for (const segment of relative.split('/').filter(Boolean)) {
         current = join(current, segment);
-        // shared
-        if (create)
+        if (create) {
+            // shared
             await mkdir(current, { mode: 0o755 }).catch((error) => {
                 if (error.code !== 'EEXIST')
                     throw error;
             });
+        }
         const info = await lstat(current);
         if (!info.isDirectory() || info.isSymbolicLink())
             throw new RemixReferenceError('remix_reference_path_conflict');
@@ -52,7 +79,10 @@ async function readFileSafely(root, path, limit) {
             length += bytesRead;
         }
         const after = await handle.stat();
-        if (length !== before.size || after.size !== before.size || after.mtimeMs !== before.mtimeMs || after.ctimeMs !== before.ctimeMs)
+        if (length !== before.size ||
+            after.size !== before.size ||
+            after.mtimeMs !== before.mtimeMs ||
+            after.ctimeMs !== before.ctimeMs)
             throw new RemixReferenceError('remix_reference_changed');
         return data.subarray(0, length);
     }
@@ -62,20 +92,28 @@ async function readFileSafely(root, path, limit) {
 }
 function identity(snapshot) {
     const { source, contentHash } = snapshot;
-    return hash(JSON.stringify([source.environment, source.projectUuid, source.branchName, source.commit, contentHash]));
+    const sourceIdentity = 'builtinTemplate' in source ? ['builtinTemplate', source.builtinTemplate] : source.projectUuid;
+    return hash(JSON.stringify([
+        source.environment,
+        sourceIdentity,
+        source.branchName,
+        source.commit,
+        contentHash,
+    ]));
 }
 function referencePath(referenceId, commit) {
     return `${WORKSPACE_REMIX_REFERENCES_DIRECTORY}/${referenceId.slice(0, 20)}-${commit.slice(0, 12)}`;
 }
 /** Project instructions and Git filters remain readable source material without becoming active configuration. */
 function materializedPath(sourcePath) {
-    const parts = sourcePath.split('/').map(part => part.toLowerCase());
-    if (parts.some(part => EXCLUDED.has(part)) || isCredentialFile(sourcePath) ||
-        parts.some(part => ['.npmrc', '.yarnrc', '.netrc', '.git-credentials'].includes(part)))
+    const parts = sourcePath.split('/').map((part) => part.toLowerCase());
+    if (parts.some((part) => EXCLUDED.has(part)) ||
+        isCredentialFile(sourcePath) ||
+        parts.some((part) => ['.npmrc', '.yarnrc', '.netrc', '.git-credentials'].includes(part)))
         return undefined;
     if (parts[0] === INERT_DIRECTORY || parts[0] === RECEIPT)
         throw new RemixReferenceError('remix_reference_path_conflict');
-    if (parts.some(part => INERT.has(part)))
+    if (parts.some((part) => INERT.has(part)))
         return `${INERT_DIRECTORY}/${hash(sourcePath)}.txt`;
     return sourcePath;
 }
@@ -85,7 +123,7 @@ async function readManifest(root) {
         if (value?.version !== 1 || !Array.isArray(value.items) || value.items.length > 100)
             throw new RemixReferenceError('remix_reference_manifest_invalid');
         const items = value.items.map((item) => workspaceRemixReferenceSchema.parse(item));
-        if (new Set(items.map(item => item.referenceId)).size !== items.length)
+        if (new Set(items.map((item) => item.referenceId)).size !== items.length)
             throw new RemixReferenceError('remix_reference_manifest_invalid');
         return items;
     }
@@ -98,8 +136,10 @@ async function readManifest(root) {
     }
 }
 function validateRecord(record, directoryName) {
-    if (record.directoryName !== directoryName || record.referenceId !== identity(record) ||
-        record.path !== referencePath(record.referenceId, record.source.commit) || record.name !== record.source.name)
+    if (record.directoryName !== directoryName ||
+        record.referenceId !== identity(record) ||
+        record.path !== referencePath(record.referenceId, record.source.commit) ||
+        record.name !== record.source.name)
         throw new RemixReferenceError('remix_reference_manifest_invalid');
     const paths = new Set();
     for (const file of record.files) {
@@ -107,10 +147,14 @@ function validateRecord(record, directoryName) {
             throw new RemixReferenceError('remix_reference_manifest_invalid');
         paths.add(file.path.toLowerCase());
     }
-    if ((record.omittedFiles ?? []).some(file => materializedPath(file.path) !== undefined))
+    if ((record.omittedFiles ?? []).some((file) => materializedPath(file.path) !== undefined))
         throw new RemixReferenceError('remix_reference_manifest_invalid');
-    const originalFiles = [...record.files.map(file => ({ ...file, path: file.sourcePath })), ...(record.omittedFiles ?? [])];
-    if (originalFiles.length > WORKSPACE_REMIX_REFERENCE_MAX_FILES || new Set(originalFiles.map(file => file.path.toLowerCase())).size !== originalFiles.length ||
+    const originalFiles = [
+        ...record.files.map((file) => ({ ...file, path: file.sourcePath })),
+        ...(record.omittedFiles ?? []),
+    ];
+    if (originalFiles.length > WORKSPACE_REMIX_REFERENCE_MAX_FILES ||
+        new Set(originalFiles.map((file) => file.path.toLowerCase())).size !== originalFiles.length ||
         hash(remixReferenceContentHashInput(originalFiles)) !== record.contentHash ||
         originalFiles.reduce((sum, file) => sum + file.size, 0) > WORKSPACE_REMIX_REFERENCE_MAX_BYTES)
         throw new RemixReferenceError('remix_reference_manifest_invalid');
@@ -120,8 +164,10 @@ async function verifyReferenceMetadata(root, record, directoryName, alternateDir
     const target = await safeDirectory(root, record.path);
     const receipt = JSON.parse((await readFileSafely(target, RECEIPT, MANIFEST_MAX_BYTES)).toString('utf8'));
     const parsedReceipt = workspaceRemixReferenceSchema.parse(receipt);
-    if (JSON.stringify(parsedReceipt) !== JSON.stringify(record)
-        && (!alternateDirectory || JSON.stringify(parsedReceipt) !== JSON.stringify({ ...record, directoryName: alternateDirectory })))
+    if (JSON.stringify(parsedReceipt) !== JSON.stringify(record) &&
+        (!alternateDirectory ||
+            JSON.stringify(parsedReceipt) !==
+                JSON.stringify({ ...record, directoryName: alternateDirectory })))
         throw new RemixReferenceError('remix_reference_changed');
     return target;
 }
@@ -129,7 +175,7 @@ async function verifyReference(root, record, directoryName, alternateDirectory)
     const target = await verifyReferenceMetadata(root, record, directoryName, alternateDirectory);
     if ((await readFileSafely(target, ATTRIBUTES, 256)).toString('utf8') !== SNAPSHOT_ATTRIBUTES)
         throw new RemixReferenceError('remix_reference_changed');
-    const expected = new Set([RECEIPT, ATTRIBUTES, ...record.files.map(file => file.path)]);
+    const expected = new Set([RECEIPT, ATTRIBUTES, ...record.files.map((file) => file.path)]);
     const walk = async (directory, prefix = '') => {
         for (const entry of await readdir(directory, { withFileTypes: true })) {
             const path = prefix ? `${prefix}/${entry.name}` : entry.name;
@@ -165,7 +211,9 @@ export async function batchReferenceMetadata(root) {
             await verifyReferenceMetadata(root, record, record.directoryName);
             verified.push(record);
         }
-        catch { /* An unrelated invalid reference cannot block source capture. */ }
+        catch {
+            /* An unrelated invalid reference cannot block source capture. */
+        }
     }
     return verified;
 }
@@ -180,8 +228,8 @@ export async function batchReferenceEnvExamples(root) {
         return examples;
     }
     for (const record of items) {
-        const files = record.files.filter(file => /^\.env\.(?:example|sample|template)$/i.test(file.path.split('/').pop() ?? '')
-            && !isCredentialFile(file.sourcePath));
+        const files = record.files.filter((file) => /^\.env\.(?:example|sample|template)$/i.test(file.path.split('/').pop() ?? '') &&
+            !isCredentialFile(file.sourcePath));
         if (!files.length)
             continue;
         try {
@@ -189,7 +237,9 @@ export async function batchReferenceEnvExamples(root) {
             for (const file of files)
                 examples.add(`${record.path}/${file.path}`);
         }
-        catch { /* An unselected damaged reference must not stop freezing the project. */ }
+        catch {
+            /* An unselected damaged reference must not stop freezing the project. */
+        }
     }
     return examples;
 }
@@ -208,13 +258,16 @@ export async function rebindBatchRemixReferences(root, sourceDirectory, memberDi
         throw error;
     }
     for (const reference of selected) {
-        const record = items.find(item => item.referenceId === reference.referenceId);
-        if (reference.directoryName !== sourceDirectory || !record || record.contentHash !== reference.snapshotHash)
+        const record = items.find((item) => item.referenceId === reference.referenceId);
+        if (reference.directoryName !== sourceDirectory ||
+            !record ||
+            record.contentHash !== reference.snapshotHash)
             throw new RemixReferenceError('context_remix_reference_changed');
     }
     if (selected.length) {
         const manifest = JSON.parse((await readFileSafely(rootReal, WORKSPACE_REMIX_REFERENCES_MANIFEST, MANIFEST_MAX_BYTES)).toString('utf8'));
-        if (Array.isArray(manifest.batchPolicyWithheldReferenceIds) && selected.some(reference => manifest.batchPolicyWithheldReferenceIds.includes(reference.referenceId)))
+        if (Array.isArray(manifest.batchPolicyWithheldReferenceIds) &&
+            selected.some((reference) => manifest.batchPolicyWithheldReferenceIds.includes(reference.referenceId)))
             throw new RemixReferenceError('batch_reference_files_withheld');
     }
     // Selected references must be complete. Other records need only valid metadata to be rebound;
@@ -222,7 +275,7 @@ export async function rebindBatchRemixReferences(root, sourceDirectory, memberDi
     const rebound = [];
     const writable = [];
     for (const record of items) {
-        const isSelected = selected.some(reference => reference.referenceId === record.referenceId);
+        const isSelected = selected.some((reference) => reference.referenceId === record.referenceId);
         try {
             if (record.directoryName !== sourceDirectory && record.directoryName !== memberDirectory)
                 throw new RemixReferenceError('remix_reference_manifest_invalid');
@@ -274,7 +327,7 @@ export async function resolveWorkspaceRemixReference(root, directoryName, refere
     workspaceDirectoryNameSchema.parse(directoryName);
     try {
         const rootReal = await realpath(root);
-        const item = (await readManifest(rootReal)).find(item => item.referenceId === referenceId);
+        const item = (await readManifest(rootReal)).find((item) => item.referenceId === referenceId);
         if (!item)
             throw new RemixReferenceError('context_remix_reference_unavailable');
         if (item.contentHash !== snapshotHash)
@@ -289,15 +342,38 @@ export async function resolveWorkspaceRemixReference(root, directoryName, refere
     }
 }
 async function trackReference(root, record) {
-    const environment = { PATH: process.env.PATH, HOME: root, GIT_CONFIG_NOSYSTEM: '1', GIT_CONFIG_GLOBAL: '/dev/null', GIT_TERMINAL_PROMPT: '0' };
+    const environment = {
+        PATH: process.env.PATH,
+        HOME: root,
+        GIT_CONFIG_NOSYSTEM: '1',
+        GIT_CONFIG_GLOBAL: '/dev/null',
+        GIT_TERMINAL_PROMPT: '0',
+    };
     const gitOptions = ['-c', 'core.hooksPath=/dev/null', '-c', 'core.fsmonitor=false', '-C', root];
-    const paths = [WORKSPACE_REMIX_REFERENCES_MANIFEST, `${record.path}/${RECEIPT}`, `${record.path}/${ATTRIBUTES}`,
-        ...record.files.map(file => `${record.path}/${file.path}`)];
+    const paths = [
+        WORKSPACE_REMIX_REFERENCES_MANIFEST,
+        `${record.path}/${RECEIPT}`,
+        `${record.path}/${ATTRIBUTES}`,
+        ...record.files.map((file) => `${record.path}/${file.path}`),
+    ];
     // Reject higher-priority repository attributes before Git can execute a conversion filter.
     const attributes = await new Promise((resolve, reject) => {
-        const child = execFile('git', [...gitOptions, 'check-attr', '-z', '--stdin', 'filter', 'text', 'ident', 'working-tree-encoding', 'eol'], {
-            timeout: 60_000, maxBuffer: 40 * 1024 * 1024, env: environment, encoding: 'utf8',
-        }, (error, stdout) => error ? reject(error) : resolve(stdout));
+        const child = execFile('git', [
+            ...gitOptions,
+            'check-attr',
+            '-z',
+            '--stdin',
+            'filter',
+            'text',
+            'ident',
+            'working-tree-encoding',
+            'eol',
+        ], {
+            timeout: 60_000,
+            maxBuffer: 40 * 1024 * 1024,
+            env: environment,
+            encoding: 'utf8',
+        }, (error, stdout) => (error ? reject(error) : resolve(stdout)));
         child.stdin?.end(`${paths.join('\0')}\0`);
     });
     const fields = attributes.split('\0');
@@ -305,15 +381,24 @@ async function trackReference(root, record) {
         throw new RemixReferenceError('remix_reference_git_attributes');
     for (let index = 0; index < fields.length - 1; index += 3) {
         const [path, attribute, value] = fields.slice(index, index + 3);
-        if (path === WORKSPACE_REMIX_REFERENCES_MANIFEST && (attribute === 'text' || attribute === 'eol'))
+        if (path === WORKSPACE_REMIX_REFERENCES_MANIFEST &&
+            (attribute === 'text' || attribute === 'eol'))
             continue;
         if (value !== 'unset' && value !== 'unspecified')
             throw new RemixReferenceError('remix_reference_git_attributes');
     }
     // A source file may have been tracked despite its old ignore rules. Track this approved snapshot explicitly.
-    await exec('git', [...gitOptions,
-        '--literal-pathspecs', 'add', '--force', '--', record.path, WORKSPACE_REMIX_REFERENCES_MANIFEST], {
-        timeout: 60_000, maxBuffer: 1024 * 1024,
+    await exec('git', [
+        ...gitOptions,
+        '--literal-pathspecs',
+        'add',
+        '--force',
+        '--',
+        record.path,
+        WORKSPACE_REMIX_REFERENCES_MANIFEST,
+    ], {
+        timeout: 60_000,
+        maxBuffer: 1024 * 1024,
         env: environment,
     });
 }
@@ -325,15 +410,20 @@ async function importReference(root, directoryName, input, assertCurrent) {
     const snapshot = parsed.data;
     if (snapshot.contentHash !== hash(remixReferenceContentHashInput(snapshot.files)))
         throw new RemixReferenceError('remix_reference_changed');
-    const plannedFiles = snapshot.files.map(file => {
+    const plannedFiles = snapshot.files.map((file) => {
         const bytes = Buffer.from(file.content, 'base64');
-        if (bytes.toString('base64') !== file.content || bytes.length !== file.size || hash(bytes) !== file.sha256)
+        if (bytes.toString('base64') !== file.content ||
+            bytes.length !== file.size ||
+            hash(bytes) !== file.sha256)
             throw new RemixReferenceError('remix_reference_changed');
-        if (bytes.subarray(0, 128).toString('utf8').startsWith('version https://git-lfs.github.com/spec/v1'))
+        if (bytes
+            .subarray(0, 128)
+            .toString('utf8')
+            .startsWith('version https://git-lfs.github.com/spec/v1'))
             throw new RemixReferenceError('remix_reference_external_resource');
         return { ...file, bytes, targetPath: materializedPath(file.path) };
     });
-    const files = plannedFiles.filter(file => file.targetPath !== undefined);
+    const files = plannedFiles.filter((file) => file.targetPath !== undefined);
     if (!files.length)
         throw new RemixReferenceError('remix_reference_empty');
     const rootReal = await realpath(root);
@@ -341,7 +431,7 @@ async function importReference(root, directoryName, input, assertCurrent) {
     const path = referencePath(referenceId, snapshot.source.commit);
     const items = await readManifest(rootReal);
     await safeDirectory(rootReal, '.playcraft', true);
-    let record = items.find(item => item.referenceId === referenceId);
+    let record = items.find((item) => item.referenceId === referenceId);
     if (record) {
         await verifyReference(rootReal, record, directoryName);
         assertCurrent();
@@ -352,8 +442,11 @@ async function importReference(root, directoryName, input, assertCurrent) {
         throw new RemixReferenceError('remix_reference_limit');
     await safeDirectory(rootReal, WORKSPACE_REMIX_REFERENCES_DIRECTORY, true);
     const target = join(rootReal, path);
-    const existing = await lstat(target).catch((error) => { if (error.code === 'ENOENT')
-        return undefined; throw error; });
+    const existing = await lstat(target).catch((error) => {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    });
     if (existing) {
         // A complete published directory is its recovery receipt when the process died before writing the manifest.
         if (!existing.isDirectory() || existing.isSymbolicLink())
@@ -364,10 +457,24 @@ async function importReference(root, directoryName, input, assertCurrent) {
         await verifyReference(rootReal, record, directoryName);
     }
     else {
-        record = workspaceRemixReferenceSchema.parse({ referenceId, directoryName, path, name: snapshot.source.name,
-            source: snapshot.source, contentHash: snapshot.contentHash, importedAt: new Date().toISOString(),
-            files: files.map(file => ({ path: file.targetPath, sourcePath: file.path, sha256: file.sha256, size: file.size })),
-            omittedFiles: plannedFiles.filter(file => file.targetPath === undefined).map(file => ({ path: file.path, sha256: file.sha256, size: file.size })) });
+        record = workspaceRemixReferenceSchema.parse({
+            referenceId,
+            directoryName,
+            path,
+            name: snapshot.source.name,
+            source: snapshot.source,
+            contentHash: snapshot.contentHash,
+            importedAt: new Date().toISOString(),
+            files: files.map((file) => ({
+                path: file.targetPath,
+                sourcePath: file.path,
+                sha256: file.sha256,
+                size: file.size,
+            })),
+            omittedFiles: plannedFiles
+                .filter((file) => file.targetPath === undefined)
+                .map((file) => ({ path: file.path, sha256: file.sha256, size: file.size })),
+        });
         const stage = await mkdtemp(join(dirname(rootReal), '.remix-reference-'));
         try {
             for (const file of files) {
@@ -411,7 +518,9 @@ async function importReference(root, directoryName, input, assertCurrent) {
 }
 export async function importWorkspaceRemixReference(root, directoryName, snapshot, assertCurrent = () => { }) {
     const previous = locks.get(root) ?? Promise.resolve();
-    const current = previous.catch(() => undefined).then(() => importReference(root, directoryName, snapshot, assertCurrent));
+    const current = previous
+        .catch(() => undefined)
+        .then(() => importReference(root, directoryName, snapshot, assertCurrent));
     locks.set(root, current);
     try {
         return await current;

package/dist/workspace-runtime/workspaces/skill-activation-recovery.js

@@ -0,0 +1,54 @@
+import { join } from 'node:path';
+import { lstat } from 'node:fs/promises';
+import { skillActivationBindingHash, transitionOperation } from '@playcraft/common/cloud-workspace/runtime';
+import { recoverPreparedSkillActivationTransactions } from '../../project-skills/remote-activation.js';
+import { workspaceRoot } from './registry.js';
+import { listSkillActivationRequests, reconcileSkillActivationRequestReceipts } from './skill-activation-requests.js';
+/** Runs before native startup: restore owned pairs and settle only provably unsent continuations. */
+export async function recoverInterruptedSkillActivations(state) {
+    if (state.config.workspaceMode !== 'multi' || !await lstat(join(state.config.stateDir, 'skill-activation-requests'))
+        .catch((error) => { if (error.code === 'ENOENT')
+        return undefined; throw error; }))
+        return;
+    const transactionDirectory = join(state.config.stateDir, 'skill-activation-requests/transactions');
+    const requests = await listSkillActivationRequests(state);
+    const unsentContinuations = (request) => {
+        const source = state.journal.getOperationById(request.sourceOperationId);
+        if (!source || source.kind !== 'session.turn' || source.sessionId !== request.sourceSessionId
+            || source.environment !== state.config.environment || source.userId !== state.config.userId
+            || source.workspaceId !== request.workspaceId || (source.directoryName ?? 'basic') !== request.directoryName
+            || source.generation !== request.generation || source.runtimeEpoch !== request.runtimeEpoch
+            || source.nativeThreadId !== request.sourceThreadId || source.nativeTurnId !== request.sourceTurnId)
+            return [];
+        return state.journal.listOperations().filter(({ operation }) => operation.kind === 'session.turn' && operation.clientRequestId === request.requestId
+            && operation.environment === state.config.environment && operation.userId === state.config.userId
+            && operation.sessionId === request.sourceSessionId && operation.workspaceId === request.workspaceId
+            && (operation.directoryName ?? 'basic') === request.directoryName && operation.generation === request.generation
+            && operation.runtimeEpoch === request.runtimeEpoch && operation.status === 'dispatched'
+            && !operation.nativeRequestId && !operation.nativeTurnId);
+    };
+    for (const workspaceId of new Set(requests.map(request => request.workspaceId))) {
+        const binding = state.journal.getWorkspace(workspaceId);
+        if (binding) {
+            for (const directoryName of new Set(['basic', ...(binding.directories ?? []).map(directory => directory.directoryName)])) {
+                const root = await workspaceRoot(state, binding.workspaceId, directoryName).catch(error => {
+                    if (error instanceof Error && error.message === 'workspace_not_prepared')
+                        return undefined;
+                    throw error;
+                });
+                if (root)
+                    await recoverPreparedSkillActivationTransactions(root, { transactionDirectory,
+                        orphanTransactionIds: requests.filter(request => request.workspaceId === workspaceId && request.directoryName === directoryName
+                            && request.registrationHash === skillActivationBindingHash(binding, directoryName) && unsentContinuations(request).length > 0)
+                            .map(request => request.requestId) });
+            }
+        }
+    }
+    for (const request of requests) {
+        for (const { scopeKey, operation } of unsentContinuations(request)) {
+            // Reservation is persisted before native send. Without it this interrupted preparation never sent a turn.
+            await state.journal.putOperation(scopeKey, transitionOperation(operation, 'failed', { error: 'skill_activation_interrupted' }));
+        }
+    }
+    await reconcileSkillActivationRequestReceipts(state);
+}