sliccy 3.5.4 → 3.6.0

package/dist/node-server/_cloud_core/tests/list.test.js

@@ -0,0 +1,300 @@
+import { describe, it, expect } from 'vitest';
+import { listCones } from '../src/operations/list.js';
+import { MemRegistry, makeFakeSubstrate } from './fixtures/index.js';
+describe('listCones', () => {
+    it('returns registry entries enriched with live state', async () => {
+        const registry = new MemRegistry();
+        await registry.append({
+            sandboxId: 's-1',
+            substrate: 'e2b',
+            createdAt: '',
+            lastSeen: '',
+            joinUrl: 'https://w/join/s-1',
+            state: 'paused',
+        });
+        const substrate = makeFakeSubstrate({
+            listResult: [{ sandboxId: 's-1', state: 'running', metadata: { name: 'mine' } }],
+        });
+        const result = await listCones({ substrate, registry });
+        expect(result).toHaveLength(1);
+        expect(result[0]?.state).toBe('running');
+        // Registry state flipped:
+        expect(registry.entries[0]?.state).toBe('running');
+    });
+    it("marks registry entries missing from substrate as 'dead'", async () => {
+        const registry = new MemRegistry();
+        await registry.append({
+            sandboxId: 's-stale',
+            substrate: 'e2b',
+            createdAt: '',
+            lastSeen: '',
+            joinUrl: 'https://w/join/s-stale',
+            state: 'paused',
+        });
+        const substrate = makeFakeSubstrate({ listResult: [] });
+        const result = await listCones({ substrate, registry });
+        expect(result[0]?.state).toBe('dead');
+        expect(registry.entries[0]?.state).toBe('dead');
+    });
+    it('rebuilds orphans (substrate sandboxes not in registry) into the registry', async () => {
+        const registry = new MemRegistry();
+        const substrate = makeFakeSubstrate({
+            listResult: [{ sandboxId: 's-orphan', state: 'running', metadata: { name: 'orphan' } }],
+        });
+        const result = await listCones({ substrate, registry });
+        expect(result.some((c) => c.sandboxId === 's-orphan')).toBe(true);
+        expect(registry.entries.some((e) => e.sandboxId === 's-orphan')).toBe(true);
+        // Check that recovered entry has reasonable defaults:
+        const recovered = registry.entries.find((e) => e.sandboxId === 's-orphan');
+        expect(recovered?.name).toBe('orphan');
+        expect(recovered?.substrate).toBe('e2b');
+        expect(recovered?.state).toBe('running');
+    });
+    it('filters by opts.metadata when provided', async () => {
+        const registry = new MemRegistry();
+        const substrate = makeFakeSubstrate({
+            listResult: [
+                {
+                    sandboxId: 's-mine',
+                    state: 'running',
+                    metadata: { userId: 'u1', name: 'mine' },
+                },
+                {
+                    sandboxId: 's-theirs',
+                    state: 'running',
+                    metadata: { userId: 'u2', name: 'theirs' },
+                },
+            ],
+        });
+        const result = await listCones({ substrate, registry }, { metadata: { userId: 'u1' } });
+        expect(result.map((c) => c.sandboxId)).toEqual(['s-mine']);
+    });
+    it('does not overwrite dead state if already dead', async () => {
+        const registry = new MemRegistry();
+        await registry.append({
+            sandboxId: 's-already-dead',
+            substrate: 'e2b',
+            createdAt: '',
+            lastSeen: '',
+            joinUrl: 'https://w/join/s-already-dead',
+            state: 'dead',
+        });
+        const substrate = makeFakeSubstrate({ listResult: [] });
+        const result = await listCones({ substrate, registry });
+        expect(result[0]?.state).toBe('dead');
+        expect(registry.entries[0]?.state).toBe('dead');
+    });
+    it('does not update registry if state already matches', async () => {
+        const registry = new MemRegistry();
+        await registry.append({
+            sandboxId: 's-running',
+            substrate: 'e2b',
+            createdAt: '',
+            lastSeen: '',
+            joinUrl: 'https://w/join/s-running',
+            state: 'running',
+        });
+        const substrate = makeFakeSubstrate({
+            listResult: [{ sandboxId: 's-running', state: 'running', metadata: {} }],
+        });
+        const initialEntry = { ...registry.entries[0] };
+        await listCones({ substrate, registry });
+        // State should remain unchanged (not re-written):
+        expect(registry.entries[0]).toEqual(initialEntry);
+    });
+    it('recovers metadata fields from substrate during orphan recovery', async () => {
+        const registry = new MemRegistry();
+        const substrate = makeFakeSubstrate({
+            listResult: [
+                {
+                    sandboxId: 's-orphan-with-meta',
+                    state: 'running',
+                    metadata: {
+                        name: 'custom-name',
+                        createdAt: '2026-01-01T00:00:00Z',
+                        joinUrl: 'https://custom/join/url',
+                        trayId: 'tray-123',
+                        lastJoinUpdatedAt: '2026-01-02T00:00:00Z',
+                    },
+                },
+            ],
+        });
+        const result = await listCones({ substrate, registry });
+        const recovered = result.find((c) => c.sandboxId === 's-orphan-with-meta');
+        expect(recovered?.name).toBe('custom-name');
+        expect(recovered?.createdAt).toBe('2026-01-01T00:00:00Z');
+        expect(recovered?.joinUrl).toBe('https://custom/join/url');
+        expect(recovered?.trayId).toBe('tray-123');
+        expect(recovered?.lastJoinUpdatedAt).toBe('2026-01-02T00:00:00Z');
+    });
+    it('falls back to reading /tmp/slicc-join.json when metadata lacks joinUrl', async () => {
+        const registry = new MemRegistry();
+        const substrate = makeFakeSubstrate({
+            listResult: [
+                {
+                    sandboxId: 's-orphan-no-metadata',
+                    state: 'running',
+                    metadata: { name: 'orphan-fallback' },
+                },
+            ],
+            // The default handle will return joinUrl from /tmp/slicc-join.json
+            handle: {
+                sandboxId: 's-orphan-no-metadata',
+                substrate: 'e2b',
+                pause: async () => { },
+                kill: async () => { },
+                getInfo: async () => ({
+                    sandboxId: 's-orphan-no-metadata',
+                    state: 'running',
+                    metadata: {},
+                    createdAt: new Date().toISOString(),
+                }),
+                writeFile: async () => { },
+                readFile: async (path) => {
+                    if (path === '/tmp/slicc-join.json') {
+                        return JSON.stringify({
+                            joinUrl: 'https://recovered/join/url',
+                            trayId: 'tray-recovered',
+                            updatedAt: '2026-05-27T00:00:00Z',
+                        });
+                    }
+                    throw new Error(`ENOENT ${path}`);
+                },
+                run: async () => ({ stdout: '', stderr: '', exitCode: 0 }),
+            },
+        });
+        const result = await listCones({ substrate, registry });
+        const recovered = result.find((c) => c.sandboxId === 's-orphan-no-metadata');
+        expect(recovered?.joinUrl).toBe('https://recovered/join/url');
+        expect(recovered?.trayId).toBe('tray-recovered');
+        expect(recovered?.lastJoinUpdatedAt).toBe('2026-05-27T00:00:00Z');
+    });
+    it('does not call substrate.connect for paused orphans (no auto-resume)', async () => {
+        const registry = new MemRegistry();
+        // connectError proves connect was NOT called — if it were called, listCones
+        // would throw or swallow the error, but we want to prove the branch is skipped.
+        const substrate = makeFakeSubstrate({
+            listResult: [
+                {
+                    sandboxId: 's-paused-orphan',
+                    state: 'paused',
+                    metadata: { name: 'paused-orphan' },
+                },
+            ],
+            connectError: new Error('connect should not be called for paused orphans'),
+        });
+        const result = await listCones({ substrate, registry });
+        const recovered = result.find((c) => c.sandboxId === 's-paused-orphan');
+        // If connect had been called, the error would have been swallowed by the catch,
+        // but we still expect recovery to succeed with empty joinUrl.
+        expect(recovered?.joinUrl).toBe('');
+        expect(recovered?.state).toBe('paused');
+        // Verify the entry was added to registry
+        expect(registry.entries.some((e) => e.sandboxId === 's-paused-orphan')).toBe(true);
+    });
+    it('calls substrate.connect only for running orphans, not paused', async () => {
+        const registry = new MemRegistry();
+        const connects = [];
+        const fakeHandle = makeFakeSubstrate().connect('fake');
+        const substrate = {
+            id: 'e2b',
+            async create() {
+                throw new Error('create should not be called');
+            },
+            async connect(sandboxId) {
+                connects.push(sandboxId);
+                return fakeHandle;
+            },
+            async list() {
+                return [
+                    { sandboxId: 's-running', state: 'running', metadata: { name: 'running' } },
+                    { sandboxId: 's-paused', state: 'paused', metadata: { name: 'paused' } },
+                ];
+            },
+            async extendTimeout(_sandboxId, _ttlMs) {
+                // No-op for this test
+            },
+        };
+        await listCones({ substrate, registry });
+        // Only the running sandbox should trigger a connect call
+        expect(connects).toEqual(['s-running']);
+        // Both orphans should be recovered
+        expect(registry.entries).toHaveLength(2);
+        const paused = registry.entries.find((e) => e.sandboxId === 's-paused');
+        expect(paused?.joinUrl).toBe(''); // No joinUrl recovery for paused
+    });
+    it('extends timeout on running cones during reconciliation', async () => {
+        const registry = new MemRegistry();
+        const timeoutCalls = [];
+        const substrate = makeFakeSubstrate({
+            listResult: [
+                { sandboxId: 's-running', state: 'running', metadata: { userId: 'u1' } },
+                { sandboxId: 's-paused', state: 'paused', metadata: { userId: 'u1' } },
+            ],
+            timeoutCalls,
+        });
+        await listCones({ substrate, registry });
+        const extended = timeoutCalls.map((c) => c.sandboxId);
+        expect(extended).toContain('s-running');
+        expect(extended).not.toContain('s-paused');
+        expect(timeoutCalls[0]?.ttlMs).toBe(60 * 60 * 1000);
+    });
+    it('preserves reserved entries during reconciliation (not marked dead)', async () => {
+        const registry = new MemRegistry();
+        const now = new Date().toISOString();
+        await registry.append({
+            sandboxId: 'pending-abc',
+            substrate: 'e2b',
+            createdAt: now,
+            lastSeen: now,
+            joinUrl: '',
+            state: 'reserved',
+            reservedAt: now,
+        });
+        const substrate = makeFakeSubstrate({ listResult: [] }); // substrate knows nothing about it
+        const result = await listCones({ substrate, registry });
+        expect(result).toHaveLength(1);
+        expect(result[0]?.state).toBe('reserved');
+        expect(result[0]?.sandboxId).toBe('pending-abc');
+        // Should NOT have been removed from registry
+        expect(registry.entries).toHaveLength(1);
+    });
+    it('reclaims stale reserved entries (older than 10 min TTL)', async () => {
+        const registry = new MemRegistry();
+        const staleTime = new Date(Date.now() - 11 * 60 * 1000).toISOString(); // 11 min ago
+        await registry.append({
+            sandboxId: 'pending-stale',
+            substrate: 'e2b',
+            createdAt: staleTime,
+            lastSeen: staleTime,
+            joinUrl: '',
+            state: 'reserved',
+            reservedAt: staleTime,
+        });
+        const substrate = makeFakeSubstrate({ listResult: [] });
+        const result = await listCones({ substrate, registry });
+        // Stale reservation should be reclaimed (not in result)
+        expect(result).toHaveLength(0);
+        // Should have been removed from registry
+        expect(registry.entries).toHaveLength(0);
+    });
+    it('preserves fresh reserved entries (younger than 10 min TTL)', async () => {
+        const registry = new MemRegistry();
+        const freshTime = new Date(Date.now() - 5 * 60 * 1000).toISOString(); // 5 min ago
+        await registry.append({
+            sandboxId: 'pending-fresh',
+            substrate: 'e2b',
+            createdAt: freshTime,
+            lastSeen: freshTime,
+            joinUrl: '',
+            state: 'reserved',
+            reservedAt: freshTime,
+        });
+        const substrate = makeFakeSubstrate({ listResult: [] });
+        const result = await listCones({ substrate, registry });
+        // Fresh reservation should be preserved
+        expect(result).toHaveLength(1);
+        expect(result[0]?.state).toBe('reserved');
+        expect(registry.entries).toHaveLength(1);
+    });
+});

package/dist/node-server/_cloud_core/tests/pause.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=pause.test.d.ts.map

package/dist/node-server/_cloud_core/tests/pause.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pause.test.d.ts","sourceRoot":"","sources":["../../tests/pause.test.ts"],"names":[],"mappings":""}

package/dist/node-server/_cloud_core/tests/pause.test.js

@@ -0,0 +1,167 @@
+import { describe, it, expect } from 'vitest';
+import { pauseCone, CloudError } from '../src/index.js';
+import { MemRegistry, makeFakeSubstrate } from './fixtures/index.js';
+// Specialized handle for pause tests: tracks paused state separately and reflects in getInfo.
+function makePauseTestHandle(id, paused = { value: false }) {
+    return {
+        sandboxId: id,
+        substrate: 'e2b',
+        pause: async () => {
+            paused.value = true;
+        },
+        kill: async () => {
+            // noop
+        },
+        getInfo: async () => {
+            const state = paused.value ? 'paused' : 'running';
+            return {
+                sandboxId: id,
+                state,
+                metadata: {},
+                createdAt: new Date().toISOString(),
+            };
+        },
+        writeFile: async () => {
+            // noop
+        },
+        readFile: async () => '',
+        run: async () => ({
+            stdout: '',
+            stderr: '',
+            exitCode: 0,
+        }),
+    };
+}
+describe('pauseCone', () => {
+    it('pauses a running cone and updates registry state', async () => {
+        const registry = new MemRegistry();
+        await registry.append({
+            sandboxId: 's-1',
+            substrate: 'e2b',
+            createdAt: new Date().toISOString(),
+            lastSeen: new Date().toISOString(),
+            state: 'running',
+            joinUrl: 'https://example.com/join',
+        });
+        const pausedFlag = { value: false };
+        const substrate = makeFakeSubstrate({
+            handle: makePauseTestHandle('s-1', pausedFlag),
+        });
+        await pauseCone({ substrate, registry }, 's-1');
+        expect(pausedFlag.value).toBe(true);
+        const entry = await registry.findByNameOrId('s-1');
+        expect(entry).toBeDefined();
+        expect(entry?.state).toBe('paused');
+    });
+    it('throws NOT_FOUND when query does not match', async () => {
+        const registry = new MemRegistry();
+        const substrate = makeFakeSubstrate({
+            handle: makePauseTestHandle('s-x'),
+        });
+        await expect(pauseCone({ substrate, registry }, 'missing')).rejects.toThrow();
+        let thrownErr;
+        try {
+            await pauseCone({ substrate, registry }, 'missing');
+        }
+        catch (err) {
+            thrownErr = err;
+        }
+        expect(thrownErr).toBeInstanceOf(CloudError);
+        const cloudErr = thrownErr;
+        expect(cloudErr.code).toBe('NOT_FOUND');
+        expect(cloudErr.message).toContain('cloud session not found');
+    });
+    it('throws ALREADY_PAUSED when entry is already paused', async () => {
+        const registry = new MemRegistry();
+        await registry.append({
+            sandboxId: 's-2',
+            substrate: 'e2b',
+            createdAt: new Date().toISOString(),
+            lastSeen: new Date().toISOString(),
+            state: 'paused',
+            joinUrl: 'https://example.com/join',
+        });
+        const substrate = makeFakeSubstrate({
+            handle: makePauseTestHandle('s-2'),
+        });
+        let thrownErr;
+        try {
+            await pauseCone({ substrate, registry }, 's-2');
+        }
+        catch (err) {
+            thrownErr = err;
+        }
+        expect(thrownErr).toBeInstanceOf(CloudError);
+        const cloudErr = thrownErr;
+        expect(cloudErr.code).toBe('ALREADY_PAUSED');
+        expect(cloudErr.message).toContain('already paused');
+    });
+    it('preserves trayId and lastJoinUpdatedAt on pause', async () => {
+        const registry = new MemRegistry();
+        const originalTrayId = 'tray-123';
+        const originalLastJoinUpdatedAt = '2026-05-22T10:00:00Z';
+        await registry.append({
+            sandboxId: 's-3',
+            substrate: 'e2b',
+            createdAt: new Date().toISOString(),
+            lastSeen: new Date().toISOString(),
+            state: 'running',
+            joinUrl: 'https://example.com/join',
+            trayId: originalTrayId,
+            lastJoinUpdatedAt: originalLastJoinUpdatedAt,
+        });
+        const substrate = makeFakeSubstrate({
+            handle: makePauseTestHandle('s-3'),
+        });
+        await pauseCone({ substrate, registry }, 's-3');
+        const entry = await registry.findByNameOrId('s-3');
+        expect(entry?.trayId).toBe(originalTrayId);
+        expect(entry?.lastJoinUpdatedAt).toBe(originalLastJoinUpdatedAt);
+    });
+    it('finds entry by name', async () => {
+        const registry = new MemRegistry();
+        await registry.append({
+            sandboxId: 's-4',
+            name: 'my-session',
+            substrate: 'e2b',
+            createdAt: new Date().toISOString(),
+            lastSeen: new Date().toISOString(),
+            state: 'running',
+            joinUrl: 'https://example.com/join',
+        });
+        const pausedFlag = { value: false };
+        const substrate = makeFakeSubstrate({
+            handle: makePauseTestHandle('s-4', pausedFlag),
+        });
+        await pauseCone({ substrate, registry }, 'my-session');
+        expect(pausedFlag.value).toBe(true);
+        const entry = await registry.findByNameOrId('my-session');
+        expect(entry?.state).toBe('paused');
+    });
+    it('throws ALREADY_RUNNING when entry is reserved', async () => {
+        const registry = new MemRegistry();
+        await registry.append({
+            sandboxId: 's-reserved',
+            substrate: 'e2b',
+            createdAt: new Date().toISOString(),
+            lastSeen: new Date().toISOString(),
+            state: 'reserved',
+            joinUrl: '',
+            reservedAt: new Date().toISOString(),
+        });
+        const substrate = makeFakeSubstrate({
+            handle: makePauseTestHandle('s-reserved'),
+        });
+        let thrownErr;
+        try {
+            await pauseCone({ substrate, registry }, 's-reserved');
+        }
+        catch (err) {
+            thrownErr = err;
+        }
+        expect(thrownErr).toBeInstanceOf(CloudError);
+        const cloudErr = thrownErr;
+        expect(cloudErr.code).toBe('ALREADY_RUNNING');
+        expect(cloudErr.message).toContain('being started/resumed');
+    });
+});

package/dist/node-server/_cloud_core/tests/resume.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=resume.test.d.ts.map

package/dist/node-server/_cloud_core/tests/resume.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resume.test.d.ts","sourceRoot":"","sources":["../../tests/resume.test.ts"],"names":[],"mappings":""}

package/dist/node-server/_cloud_core/tests/resume.test.js

@@ -0,0 +1,203 @@
+import { describe, it, expect } from 'vitest';
+import { resumeCone } from '../src/operations/resume.js';
+import { MemRegistry, makeFakeSubstrate } from './fixtures/index.js';
+// Specialized handle for resume tests: configurable joinJson and kick behavior.
+function makeResumeTestHandle(overrides) {
+    const writes = overrides.writes ?? [];
+    return {
+        sandboxId: 'sbx-1',
+        substrate: 'e2b',
+        pause: async () => { },
+        kill: async () => { },
+        getInfo: async () => ({
+            sandboxId: 'sbx-1',
+            state: 'running',
+            metadata: {},
+            createdAt: '',
+        }),
+        writeFile: async (path, contents) => {
+            writes.push({ path, contents });
+        },
+        readFile: async (path) => {
+            if (path === '/tmp/slicc-join.json') {
+                return (overrides.joinJson ??
+                    JSON.stringify({
+                        joinUrl: 'https://w/join/new',
+                        trayId: 't-new',
+                        updatedAt: new Date().toISOString(),
+                        sliccVersion: 'test',
+                    }));
+            }
+            throw new Error(`ENOENT ${path}`);
+        },
+        run: async (_cmd) => ({
+            stdout: overrides.kickStatus ?? '200',
+            stderr: '',
+            exitCode: overrides.kickExitCode ?? 0,
+        }),
+    };
+}
+describe('resumeCone', () => {
+    it('resumes a paused cone and updates registry with refreshed joinUrl', async () => {
+        const registry = new MemRegistry();
+        await registry.append({
+            sandboxId: 'sbx-1',
+            substrate: 'e2b',
+            createdAt: '',
+            joinUrl: 'https://old/join',
+            lastSeen: '',
+            state: 'paused',
+            trayId: 't-old',
+            lastJoinUpdatedAt: '2026-05-01T00:00:00.000Z',
+        });
+        const substrate = makeFakeSubstrate({
+            handle: makeResumeTestHandle({}),
+        });
+        const result = await resumeCone({ substrate, registry }, {
+            query: 'sbx-1',
+            localSliccVersion: 'test',
+        });
+        expect(result.joinUrl).toBe('https://w/join/new');
+        expect(result.trayRebuilt).toBe(true); // t-old → t-new
+        expect(registry.entries[0]?.state).toBe('running');
+        expect(registry.entries[0]?.trayId).toBe('t-new');
+        expect(registry.entries[0]?.joinUrl).toBe('https://w/join/new');
+    });
+    it('throws NOT_FOUND when query does not match', async () => {
+        const registry = new MemRegistry();
+        const substrate = makeFakeSubstrate({
+            handle: makeResumeTestHandle({}),
+        });
+        await expect(resumeCone({ substrate, registry }, { query: 'missing', localSliccVersion: 'test' })).rejects.toMatchObject({ name: 'CloudError', code: 'NOT_FOUND' });
+    });
+    it('throws ALREADY_RUNNING when entry is already running', async () => {
+        const registry = new MemRegistry();
+        await registry.append({
+            sandboxId: 'sbx-1',
+            substrate: 'e2b',
+            createdAt: '',
+            joinUrl: 'https://w/join',
+            lastSeen: '',
+            state: 'running',
+        });
+        const substrate = makeFakeSubstrate({
+            handle: makeResumeTestHandle({}),
+        });
+        await expect(resumeCone({ substrate, registry }, { query: 'sbx-1', localSliccVersion: 'test' })).rejects.toMatchObject({ name: 'CloudError', code: 'ALREADY_RUNNING' });
+    });
+    it('writes refreshSecretsContents to /slicc/secrets.env when provided', async () => {
+        const registry = new MemRegistry();
+        await registry.append({
+            sandboxId: 'sbx-1',
+            substrate: 'e2b',
+            createdAt: '',
+            joinUrl: 'https://w/join',
+            lastSeen: '',
+            state: 'paused',
+        });
+        const writes = [];
+        const handle = makeResumeTestHandle({ writes });
+        const substrate = makeFakeSubstrate({ handle });
+        await resumeCone({ substrate, registry }, {
+            query: 'sbx-1',
+            localSliccVersion: 'test',
+            refreshSecretsContents: 'ADOBE_IMS_TOKEN=fresh',
+        });
+        expect(writes).toContainEqual({
+            path: '/slicc/secrets.env',
+            contents: 'ADOBE_IMS_TOKEN=fresh',
+        });
+    });
+    it('throws LEADER_NOT_READY when kick returns unexpected status', async () => {
+        const registry = new MemRegistry();
+        await registry.append({
+            sandboxId: 'sbx-1',
+            substrate: 'e2b',
+            createdAt: '',
+            joinUrl: 'https://w/join',
+            lastSeen: '',
+            state: 'paused',
+        });
+        const substrate = makeFakeSubstrate({
+            handle: makeResumeTestHandle({ kickStatus: '418' }),
+        });
+        await expect(resumeCone({ substrate, registry }, { query: 'sbx-1', localSliccVersion: 'test' })).rejects.toMatchObject({ name: 'CloudError', code: 'LEADER_NOT_READY' });
+    });
+    it('reports versionMismatch when running version differs from local', async () => {
+        const registry = new MemRegistry();
+        await registry.append({
+            sandboxId: 'sbx-1',
+            substrate: 'e2b',
+            createdAt: '',
+            joinUrl: 'https://w/join',
+            lastSeen: '',
+            state: 'paused',
+            lastJoinUpdatedAt: '2026-05-01T00:00:00.000Z',
+        });
+        const substrate = makeFakeSubstrate({
+            handle: makeResumeTestHandle({
+                joinJson: JSON.stringify({
+                    joinUrl: 'https://w/join/new',
+                    trayId: 't-new',
+                    updatedAt: new Date().toISOString(),
+                    sliccVersion: 'v1.2.3',
+                }),
+            }),
+        });
+        const result = await resumeCone({ substrate, registry }, {
+            query: 'sbx-1',
+            localSliccVersion: 'v1.0.0',
+        });
+        expect(result.versionMismatch).toEqual({ running: 'v1.2.3', local: 'v1.0.0' });
+    });
+    it('does not report trayRebuilt when no baseline trayId', async () => {
+        const registry = new MemRegistry();
+        await registry.append({
+            sandboxId: 'sbx-1',
+            substrate: 'e2b',
+            createdAt: '',
+            joinUrl: 'https://w/join',
+            lastSeen: '',
+            state: 'paused',
+            lastJoinUpdatedAt: '2026-05-01T00:00:00.000Z',
+            // No trayId in baseline
+        });
+        const substrate = makeFakeSubstrate({
+            handle: makeResumeTestHandle({}),
+        });
+        const result = await resumeCone({ substrate, registry }, {
+            query: 'sbx-1',
+            localSliccVersion: 'test',
+        });
+        expect(result.trayRebuilt).toBe(false);
+    });
+    it('rejects an older /tmp/slicc-join.json on resume (stale file)', async () => {
+        const registry = new MemRegistry();
+        const baselineUpdatedAt = '2026-05-01T12:00:00.000Z';
+        const olderUpdatedAt = '2026-05-01T11:00:00.000Z'; // 1 hour earlier
+        await registry.append({
+            sandboxId: 'sbx-1',
+            substrate: 'e2b',
+            createdAt: '',
+            joinUrl: 'https://w/join/old',
+            lastSeen: '',
+            state: 'paused',
+            lastJoinUpdatedAt: baselineUpdatedAt,
+        });
+        const substrate = makeFakeSubstrate({
+            handle: makeResumeTestHandle({
+                joinJson: JSON.stringify({
+                    joinUrl: 'https://w/join/stale',
+                    trayId: 't-stale',
+                    updatedAt: olderUpdatedAt,
+                }),
+            }),
+        });
+        await expect(resumeCone({ substrate, registry }, {
+            query: 'sbx-1',
+            localSliccVersion: 'test',
+            pollTimeoutMs: 200,
+            pollIntervalMs: 50,
+        })).rejects.toMatchObject({ name: 'CloudError', code: 'LEADER_NOT_READY' });
+    });
+});