@atolis-hq/wake 0.2.96 → 0.3.0

package/dist/src/adapters/cursor/cursor-runner.js

@@ -1,418 +0,0 @@
-import { parseRunnerResult } from '../../domain/schema.js';
-import { buildStagePrompt } from '../runner/stage-prompt.js';
-import { runAgentCliCommand } from '../runner/cli-command.js';
-import { emitRuntimeEvent, runnerRuntimeEvent } from '../runner/runtime-events.js';
-import { writeRunnerTranscript } from '../runner/transcripts.js';
-import { createAgentExecution } from '../../core/live-execution.js';
-const CURSOR_CLI_NAME = 'Cursor';
-export function buildCursorAgentArgs(input) {
-    const fullPrompt = buildCursorPromptText(input);
-    return [
-        'agent',
-        '-p',
-        '--output-format',
-        'json',
-        '--model',
-        input.model,
-        '--trust',
-        ...(input.mode !== undefined ? ['--mode', input.mode] : []),
-        ...(input.force === true ? ['--force'] : []),
-        ...(input.resumeSessionId !== undefined ? [`--resume=${input.resumeSessionId}`] : []),
-        fullPrompt,
-    ];
-}
-export function buildCursorPromptText(input) {
-    return input.harnessPrompt === undefined
-        ? input.prompt
-        : `${input.harnessPrompt}\n\n${input.prompt}`;
-}
-export function buildCursorResumeArgs(input) {
-    return ['agent', '--resume=' + input.sessionId];
-}
-function compactLogValue(value) {
-    return value.replace(/\s+/g, ' ').trim();
-}
-export function formatCursorRunLogLine(input) {
-    const parts = [
-        '[cursor-run]',
-        `phase=${input.phase}`,
-        `runId=${input.runId}`,
-        `cli=Cursor`,
-        ...(input.model === undefined ? [] : [`model=${input.model}`]),
-        `repo=${input.repo}`,
-        `issueNumber=${input.issueNumber}`,
-        `action=${input.action}`,
-        `recentEventIds=${input.recentEventIds.length > 0 ? input.recentEventIds.join(',') : '(none)'}`,
-        ...(input.workspacePath === undefined
-            ? []
-            : [`workspacePath=${compactLogValue(input.workspacePath)}`]),
-        ...(input.sessionId === undefined ? [] : [`sessionId=${input.sessionId}`]),
-        ...(input.exitCode === undefined ? [] : [`exitCode=${input.exitCode}`]),
-    ];
-    return parts.join(' ');
-}
-// Verified against a live `cursor-agent agent -p --output-format json` call
-// (run through the wake-sandbox container, since the host `cursor` binary
-// here is the desktop app, not the CLI). Cursor's usage keys are camelCase
-// and different names from both Claude's and Codex's snake_case fields, e.g.:
-// {"usage":{"inputTokens":5945,"outputTokens":32,"cacheReadTokens":6020,"cacheWriteTokens":0}}
-// No cost field was present in that response, so costUsd stays unset for Cursor.
-function extractCursorTokenUsage(parsed) {
-    const usage = parsed.usage;
-    if (usage === undefined) {
-        return undefined;
-    }
-    const inputTokens = typeof usage.inputTokens === 'number' ? usage.inputTokens : undefined;
-    const outputTokens = typeof usage.outputTokens === 'number' ? usage.outputTokens : undefined;
-    if (inputTokens === undefined || outputTokens === undefined) {
-        return undefined;
-    }
-    const cacheReadInputTokens = typeof usage.cacheReadTokens === 'number' ? usage.cacheReadTokens : undefined;
-    const cacheCreationInputTokens = typeof usage.cacheWriteTokens === 'number' ? usage.cacheWriteTokens : undefined;
-    return {
-        inputTokens,
-        outputTokens,
-        ...(cacheCreationInputTokens === undefined ? {} : { cacheCreationInputTokens }),
-        ...(cacheReadInputTokens === undefined ? {} : { cacheReadInputTokens }),
-    };
-}
-export function extractCursorAgentResult(stdout) {
-    const trimmed = stdout.trim();
-    if (trimmed.length === 0) {
-        throw new Error('Cursor agent produced no output.');
-    }
-    const parsed = JSON.parse(trimmed);
-    const result = typeof parsed.result === 'string' ? parsed.result : undefined;
-    if (result === undefined) {
-        throw new Error('Cursor agent JSON output did not include a result field.');
-    }
-    const sessionId = typeof parsed.session_id === 'string' ? parsed.session_id : undefined;
-    const isError = typeof parsed.is_error === 'boolean' ? parsed.is_error : undefined;
-    const tokenUsage = extractCursorTokenUsage(parsed);
-    return {
-        result,
-        ...(sessionId !== undefined ? { sessionId } : {}),
-        ...(isError !== undefined ? { isError } : {}),
-        ...(tokenUsage !== undefined ? { tokenUsage } : {}),
-    };
-}
-export function classifyCursorCliFailure(input) {
-    if (input.timedOut) {
-        return 'infra';
-    }
-    // Cursor JSON output signals a handled task-level error
-    if (input.isError === true) {
-        return 'task';
-    }
-    const text = `${input.stderr}\n${input.stdout}`.toLowerCase();
-    if (text.includes('rate limit') ||
-        text.includes('usage limit') ||
-        text.includes('quota') ||
-        text.includes('billing') ||
-        text.includes('unauthorized') ||
-        text.includes('authentication') ||
-        text.includes('api key') ||
-        text.includes('too many requests')) {
-        return 'quota';
-    }
-    return 'infra';
-}
-// Cursor uses --mode ask for read-only stages, which already enforces
-// the constraint at the CLI boundary. The capability note explains to the agent
-// what tools are available in ask mode versus the default agent mode.
-export function buildCursorToolCapabilityNote(input) {
-    if (input.workspaceMode !== 'read-only') {
-        return undefined;
-    }
-    const note = 'You are running in read-only ask mode. You can read and explore the repository but cannot modify files. ' +
-        'Use your available file-reading and search tools to understand the codebase.';
-    return input.mode === 'resume' ? `Reminder: this is still a planning-only stage. ${note}` : note;
-}
-function resolveCursorMode(input) {
-    return input.workspaceMode === 'read-only' ? 'ask' : undefined;
-}
-function resolveModel(input) {
-    return input.settings.model;
-}
-function readSandboxLogBreadcrumb() {
-    const containerName = process.env.WAKE_SANDBOX_CONTAINER_NAME;
-    if (containerName === undefined || containerName.length === 0) {
-        return null;
-    }
-    return {
-        text: `Sandbox logs: docker logs --tail 200 ${containerName}`,
-        metadata: {
-            sandboxContainerName: containerName,
-        },
-    };
-}
-export function createCursorRunner(options) {
-    const runner = {
-        async start(input) {
-            return createAgentExecution(input, (liveInput) => runner.run(liveInput));
-        },
-        async run(input) {
-            const priorSessionId = input.projection.wake.sessionId;
-            const priorSessionCli = input.projection.wake.sessionCli;
-            const isResume = priorSessionId !== undefined && priorSessionCli === CURSOR_CLI_NAME;
-            const cursorMode = resolveCursorMode({
-                ...(input.workspaceMode === undefined ? {} : { workspaceMode: input.workspaceMode }),
-            });
-            const toolCapabilityNote = buildCursorToolCapabilityNote({
-                ...(input.workspaceMode === undefined ? {} : { workspaceMode: input.workspaceMode }),
-                mode: isResume ? 'resume' : 'start',
-            });
-            const stagePrompt = await buildStagePrompt({
-                action: input.action,
-                projection: input.projection,
-                mode: isResume ? 'resume' : 'start',
-                config: input.config,
-                ...(input.workspaceMode === undefined ? {} : { workspaceMode: input.workspaceMode }),
-                ...(input.mergeConflictDetected === true ? { mergeConflictDetected: true } : {}),
-                ...(input.upstreamChanges === undefined ? {} : { upstreamChanges: input.upstreamChanges }),
-                ...(input.preExistingUncommittedChanges === true
-                    ? { preExistingUncommittedChanges: true }
-                    : {}),
-                ...(toolCapabilityNote !== undefined || input.promptContextOverrides !== undefined
-                    ? {
-                        contextOverrides: {
-                            ...input.promptContextOverrides,
-                            ...(toolCapabilityNote === undefined ? {} : { toolCapabilityNote }),
-                        },
-                    }
-                    : {}),
-            });
-            const model = resolveModel({ action: input.action, settings: options.settings });
-            const cwd = input.workspacePath ?? options.cwd;
-            const promptText = buildCursorPromptText({
-                prompt: stagePrompt.prompt,
-                harnessPrompt: stagePrompt.harnessPrompt,
-            });
-            const promptTranscriptPath = await writeRunnerTranscript({
-                config: input.config,
-                projection: input.projection,
-                runId: input.runId,
-                action: input.action,
-                cli: CURSOR_CLI_NAME,
-                kind: 'prompt',
-                text: promptText,
-            });
-            console.log(formatCursorRunLogLine({
-                phase: 'start',
-                runId: input.runId,
-                action: input.action,
-                issueNumber: input.projection.issue.number,
-                repo: input.projection.issue.repo,
-                recentEventIds: input.recentEvents.map((event) => event.eventId),
-                model,
-                ...(input.workspacePath === undefined ? {} : { workspacePath: input.workspacePath }),
-                ...(isResume ? { sessionId: priorSessionId } : {}),
-            }));
-            const result = await runAgentCliCommand({
-                command: options.command,
-                args: buildCursorAgentArgs({
-                    model,
-                    prompt: promptText,
-                    ...(cursorMode !== undefined ? { mode: cursorMode } : {}),
-                    force: cursorMode === undefined,
-                    ...(isResume ? { resumeSessionId: priorSessionId } : {}),
-                }),
-                cwd,
-                timeoutMs: options.settings.timeoutMs,
-                ...(input.cancellationSignal === undefined
-                    ? {}
-                    : { cancellationSignal: input.cancellationSignal }),
-                onProcessStart: async (identity) => {
-                    await input.onProcessStart?.(identity);
-                    await emitRuntimeEvent(input.onRuntimeEvent, runnerRuntimeEvent({
-                        type: 'agent.process.started',
-                        runId: input.runId,
-                        projection: input.projection,
-                        routing: input.routing,
-                        cli: CURSOR_CLI_NAME,
-                        model,
-                        payload: { pid: identity.pid, processStartedAt: identity.processStartedAt },
-                    }));
-                },
-            });
-            const responseTranscriptPath = await writeRunnerTranscript({
-                config: input.config,
-                projection: input.projection,
-                runId: input.runId,
-                action: input.action,
-                cli: CURSOR_CLI_NAME,
-                kind: 'response',
-                text: result.stdout,
-            });
-            if (result.exitCode !== 0 || result.timedOut || result.stdout.trim().length === 0) {
-                const sandboxLog = readSandboxLogBreadcrumb();
-                const failureClass = classifyCursorCliFailure({
-                    stdout: result.stdout,
-                    stderr: result.stderr,
-                    timedOut: result.timedOut,
-                });
-                console.error(formatCursorRunLogLine({
-                    phase: 'failure',
-                    runId: input.runId,
-                    action: input.action,
-                    issueNumber: input.projection.issue.number,
-                    repo: input.projection.issue.repo,
-                    recentEventIds: input.recentEvents.map((event) => event.eventId),
-                    model,
-                    ...(input.workspacePath === undefined ? {} : { workspacePath: input.workspacePath }),
-                    exitCode: result.exitCode,
-                }));
-                await emitRuntimeEvent(input.onRuntimeEvent, runnerRuntimeEvent({
-                    type: 'agent.process.exited',
-                    runId: input.runId,
-                    projection: input.projection,
-                    routing: input.routing,
-                    cli: CURSOR_CLI_NAME,
-                    model,
-                    payload: { exitCode: result.exitCode, timedOut: result.timedOut },
-                }));
-                return {
-                    result: [
-                        result.timedOut
-                            ? `Cursor runner timed out after ${options.settings.timeoutMs}ms and was killed`
-                            : result.stdout.trim().length === 0
-                                ? 'Cursor runner produced no output'
-                                : 'Cursor runner failed',
-                        result.stderr,
-                        sandboxLog?.text,
-                        'FAILED',
-                    ]
-                        .filter((part) => part !== undefined && part.length > 0)
-                        .join('\n'),
-                    model,
-                    cli: CURSOR_CLI_NAME,
-                    failureClass,
-                    metadata: {
-                        stdout: result.stdout,
-                        stderr: result.stderr,
-                        exitCode: result.exitCode,
-                        failureClass,
-                        ...(promptTranscriptPath === undefined ? {} : { promptTranscriptPath }),
-                        ...(responseTranscriptPath === undefined ? {} : { responseTranscriptPath }),
-                        ...(sandboxLog?.metadata ?? {}),
-                    },
-                };
-            }
-            let parsed;
-            try {
-                parsed = extractCursorAgentResult(result.stdout);
-            }
-            catch (err) {
-                const sandboxLog = readSandboxLogBreadcrumb();
-                return {
-                    result: [`Cursor runner output could not be parsed: ${String(err)}`, 'FAILED']
-                        .filter((part) => part.length > 0)
-                        .join('\n'),
-                    model,
-                    cli: CURSOR_CLI_NAME,
-                    failureClass: 'infra',
-                    metadata: {
-                        stdout: result.stdout,
-                        stderr: result.stderr,
-                        parseError: String(err),
-                        ...(promptTranscriptPath === undefined ? {} : { promptTranscriptPath }),
-                        ...(responseTranscriptPath === undefined ? {} : { responseTranscriptPath }),
-                        ...(sandboxLog?.metadata ?? {}),
-                    },
-                };
-            }
-            const sandboxLog = readSandboxLogBreadcrumb();
-            await emitRuntimeEvent(input.onRuntimeEvent, runnerRuntimeEvent({
-                type: 'agent.progress',
-                runId: input.runId,
-                projection: input.projection,
-                routing: input.routing,
-                cli: CURSOR_CLI_NAME,
-                model,
-                ...(parsed.sessionId === undefined ? {} : { sessionId: parsed.sessionId }),
-                payload: { message: 'Cursor agent result received', raw: parsed },
-            }));
-            if (parsed.tokenUsage !== undefined) {
-                await emitRuntimeEvent(input.onRuntimeEvent, runnerRuntimeEvent({
-                    type: 'agent.usage.updated',
-                    runId: input.runId,
-                    projection: input.projection,
-                    routing: input.routing,
-                    cli: CURSOR_CLI_NAME,
-                    model,
-                    ...(parsed.sessionId === undefined ? {} : { sessionId: parsed.sessionId }),
-                    payload: { tokenUsage: parsed.tokenUsage },
-                }));
-            }
-            console.log(formatCursorRunLogLine({
-                phase: 'success',
-                runId: input.runId,
-                action: input.action,
-                issueNumber: input.projection.issue.number,
-                repo: input.projection.issue.repo,
-                recentEventIds: input.recentEvents.map((event) => event.eventId),
-                model,
-                ...(input.workspacePath === undefined ? {} : { workspacePath: input.workspacePath }),
-                ...(parsed.sessionId === undefined ? {} : { sessionId: parsed.sessionId }),
-            }));
-            await emitRuntimeEvent(input.onRuntimeEvent, runnerRuntimeEvent({
-                type: 'agent.process.exited',
-                runId: input.runId,
-                projection: input.projection,
-                routing: input.routing,
-                cli: CURSOR_CLI_NAME,
-                model,
-                ...(parsed.sessionId === undefined ? {} : { sessionId: parsed.sessionId }),
-                payload: { exitCode: result.exitCode, timedOut: result.timedOut },
-            }));
-            return {
-                result: parsed.result,
-                model,
-                cli: CURSOR_CLI_NAME,
-                ...(parseRunnerResult(parsed.result).status === 'FAILED'
-                    ? { failureClass: 'task' }
-                    : {}),
-                ...(parsed.sessionId === undefined ? {} : { session_id: parsed.sessionId }),
-                ...(parsed.tokenUsage === undefined ? {} : { tokenUsage: parsed.tokenUsage }),
-                metadata: {
-                    stdout: result.stdout,
-                    stderr: result.stderr,
-                    raw: parsed,
-                    skipApproval: stagePrompt.skipApproval,
-                    allowAutoApproval: stagePrompt.allowAutoApproval,
-                    ...(promptTranscriptPath === undefined ? {} : { promptTranscriptPath }),
-                    ...(responseTranscriptPath === undefined ? {} : { responseTranscriptPath }),
-                    ...(sandboxLog?.metadata ?? {}),
-                },
-            };
-        },
-        async smoke() {
-            const result = await runAgentCliCommand({
-                command: options.command,
-                args: buildCursorAgentArgs({
-                    model: options.settings.smokeModel,
-                    prompt: options.settings.smokePrompt,
-                    force: true,
-                }),
-                cwd: options.cwd,
-            });
-            let parsed;
-            if (result.exitCode === 0 && result.stdout.trim().length > 0) {
-                try {
-                    parsed = extractCursorAgentResult(result.stdout);
-                }
-                catch {
-                    parsed = undefined;
-                }
-            }
-            return {
-                text: parsed?.result ?? '',
-                ...(parsed?.sessionId === undefined ? {} : { sessionId: parsed.sessionId }),
-                stdout: result.stdout,
-                stderr: result.stderr,
-                exitCode: result.exitCode,
-            };
-        },
-    };
-    return runner;
-}

package/dist/src/adapters/docker/docker-cli.js

@@ -1,150 +0,0 @@
-import { createInterface } from 'node:readline';
-import { scrubSecrets } from '../../cli/sandbox-exec-logging.js';
-function buildStopArgs(containerName, timeoutSeconds) {
-    return [
-        'stop',
-        ...(timeoutSeconds !== undefined ? ['--time', String(timeoutSeconds)] : []),
-        containerName,
-    ];
-}
-const DOCKER_LOG_MAX_SIZE = '10m';
-const DOCKER_LOG_MAX_FILE = '3';
-function buildRunArgs(input) {
-    return [
-        'run',
-        '-d',
-        '--log-opt',
-        `max-size=${DOCKER_LOG_MAX_SIZE}`,
-        '--log-opt',
-        `max-file=${DOCKER_LOG_MAX_FILE}`,
-        '--name',
-        input.containerName,
-        '-v',
-        `${input.wakeRoot}:${input.containerMountPath}`,
-        '-v',
-        `${input.containerHomeRoot}:${input.containerHomeMountPath}`,
-        ...(input.extraMounts ?? []).flatMap((mount) => [
-            '-v',
-            `${mount.source}:${mount.target}${mount.readOnly === true ? ':ro' : ''}`,
-        ]),
-        // Auto-started by wake sandbox-entrypoint; the UI binds 0.0.0.0 inside the
-        // container so this published port can reach it (127.0.0.1 inside the
-        // container would not be reachable via docker's port-forwarding NAT).
-        ...(input.ui?.enabled === true
-            ? [
-                '-p',
-                `127.0.0.1:${input.ui.port}:${input.ui.port}`,
-                '-e',
-                'WAKE_UI_ENABLED=true',
-                '-e',
-                `WAKE_UI_PORT=${input.ui.port}`,
-                ...(input.ui.token !== undefined ? ['-e', `WAKE_UI_TOKEN=${input.ui.token}`] : []),
-                ...(input.ui.tunnel?.enabled === true
-                    ? [
-                        '-e',
-                        'WAKE_UI_TUNNEL_ENABLED=true',
-                        '-e',
-                        input.ui.tunnel.authToken !== undefined
-                            ? `NGROK_AUTHTOKEN=${input.ui.tunnel.authToken}`
-                            : 'NGROK_AUTHTOKEN',
-                    ]
-                    : []),
-            ]
-            : []),
-        ...(input.start?.enabled === true ? ['-e', 'WAKE_START_ENABLED=true'] : []),
-        input.image,
-    ];
-}
-export function createDockerCli(deps) {
-    return {
-        async inspectContainerImage(containerName) {
-            return (await deps.inspectContainerImage?.(containerName)) ?? null;
-        },
-        async build(input) {
-            const buildArgFlags = Object.entries(input.buildArgs ?? {}).flatMap(([key, value]) => [
-                '--build-arg',
-                `${key}=${value}`,
-            ]);
-            await deps.run([
-                'build',
-                '-t',
-                input.image,
-                '-f',
-                input.dockerfile,
-                ...buildArgFlags,
-                input.contextDir,
-            ]);
-        },
-        async up(input) {
-            const imageExists = await deps.inspectImage(input.image);
-            if (!imageExists) {
-                throw new Error('Sandbox image not found. Run `wake sandbox build` first.');
-            }
-            const containerState = await deps.inspectContainer(input.containerName);
-            if (containerState === 'running') {
-                return;
-            }
-            if (containerState === 'stopped') {
-                await deps.run(['start', input.containerName]);
-                return;
-            }
-            await deps.run(buildRunArgs(input));
-        },
-        async update(input) {
-            const imageExists = await deps.inspectImage(input.image);
-            if (!imageExists) {
-                throw new Error('Sandbox image not found. Run `wake sandbox build` first.');
-            }
-            const containerState = await deps.inspectContainer(input.containerName);
-            if (containerState === 'running' || containerState === 'stopped') {
-                if (containerState === 'running') {
-                    await deps.run(buildStopArgs(input.containerName, input.stopTimeoutSeconds));
-                }
-                await deps.run(['rm', input.containerName]);
-            }
-            await deps.run(buildRunArgs(input));
-        },
-        async down(containerName, options) {
-            await deps.run(buildStopArgs(containerName, options?.timeoutSeconds));
-        },
-        async exec(containerName, command, options) {
-            const interactive = options?.interactive ?? false;
-            await deps.run(command.length > 0
-                ? ['exec', interactive ? '-it' : '-i', containerName, ...command]
-                : ['exec', '-it', containerName, 'bash']);
-        },
-        /**
-         * Runs `docker exec -i <containerName> <command>` with piped (not
-         * inherited) stdio, line-buffers stdout/stderr, scrubs secrets from each
-         * line, and forwards it to the caller's handlers in real time. Used by
-         * `sandbox exec` so live output is observed and redacted on the host
-         * instead of being wrapped by a mounted in-container script.
-         */
-        async execCaptured(containerName, command, handlers) {
-            if (deps.spawnExec === undefined) {
-                throw new Error('docker cli adapter was not configured with spawnExec');
-            }
-            const args = ['exec', '-i', containerName, ...command];
-            const child = deps.spawnExec(args);
-            const stdoutReader = createInterface({ input: child.stdout });
-            stdoutReader.on('line', (line) => handlers.onStdout(scrubSecrets(line)));
-            const stderrReader = createInterface({ input: child.stderr });
-            stderrReader.on('line', (line) => handlers.onStderr(scrubSecrets(line)));
-            await new Promise((resolveExec, reject) => {
-                child.on('error', reject);
-                child.on('close', (exitCode) => {
-                    stdoutReader.close();
-                    stderrReader.close();
-                    if (exitCode === 0) {
-                        resolveExec();
-                        return;
-                    }
-                    reject(new Error(`docker ${args.join(' ')} failed with exit code ${exitCode ?? 1}`));
-                });
-            });
-        },
-        async logs(containerName, tailLines) {
-            await deps.run(['logs', '--tail', String(tailLines), containerName]);
-        },
-    };
-}

package/dist/src/adapters/fake/fake-artifact-verifier.js

@@ -1,14 +0,0 @@
-/**
- * Permanent test harness. `verifies` is the allowlist of URLs this fake
- * treats as legitimate, mapped to the resourceUri they resolve to — anything
- * not listed fails verification, exercising the "malformed claim" path.
- */
-export function createFakeArtifactVerifier(options) {
-    const byUrl = new Map(options.verifies.map((entry) => [entry.url, entry.resourceUri]));
-    return {
-        async verify(artifact) {
-            const resourceUri = byUrl.get(artifact.url);
-            return resourceUri === undefined ? null : { resourceUri };
-        },
-    };
-}

package/dist/src/adapters/fake/fake-github-pull-request-activity-source.js

@@ -1,77 +0,0 @@
-import { createEventEnvelope, createUnkeyedEventEnvelope } from '../../lib/event-log.js';
-/** Permanent test harness — zero-token equivalent of the real GitHub PR activity source. */
-export function createFakeGitHubPullRequestActivitySource(options) {
-    const now = options.now ?? (() => new Date());
-    return {
-        async pollEvents(input) {
-            const nowIso = now().toISOString();
-            const watched = new Set((input?.watch ?? []).map((ref) => ref.resourceUri));
-            const events = [];
-            for (const pr of options.prs) {
-                const resourceUri = `github:pr:${pr.repo}#${pr.number}`;
-                if (!watched.has(resourceUri)) {
-                    events.push(createUnkeyedEventEnvelope({
-                        eventId: `fake-pr-seen-${pr.repo}-${pr.number}`,
-                        streamScope: 'global-intake',
-                        direction: 'inbound',
-                        sourceSystem: 'fake-github-pr',
-                        sourceEventType: 'pr.seen',
-                        sourceRefs: { repo: pr.repo, resourceUri },
-                        occurredAt: nowIso,
-                        ingestedAt: nowIso,
-                        trigger: 'context-only',
-                        payload: { pr: { number: pr.number, author: pr.author, headRef: pr.headRef } },
-                    }));
-                    continue;
-                }
-                for (const comment of pr.comments) {
-                    events.push(createUnkeyedEventEnvelope({
-                        eventId: `fake-pr-comment-${pr.repo}-${pr.number}-${comment.id}`,
-                        streamScope: 'work-item',
-                        direction: 'inbound',
-                        sourceSystem: 'fake-github-pr',
-                        sourceEventType: 'pr.comment.created',
-                        sourceRefs: { repo: pr.repo, commentId: comment.id, resourceUri },
-                        occurredAt: nowIso,
-                        ingestedAt: nowIso,
-                        trigger: 'context-only',
-                        payload: {
-                            comment: {
-                                id: comment.id,
-                                body: comment.body,
-                                author: { login: comment.author },
-                                createdAt: nowIso,
-                                updatedAt: nowIso,
-                                resourceUri,
-                            },
-                        },
-                        derivedHints: { botAuthoredComment: false },
-                    }));
-                }
-            }
-            return events;
-        },
-        async deliverIntent(input) {
-            const publishedAt = now().toISOString();
-            return [
-                createEventEnvelope({
-                    eventId: `${input.event.eventId}-published`,
-                    workItemKey: input.event.workItemKey,
-                    streamScope: 'work-item',
-                    direction: 'outbound',
-                    sourceSystem: 'fake-github-pr',
-                    sourceEventType: 'pr.comment.reply.published',
-                    sourceRefs: { ...input.event.sourceRefs, sink: 'fake-github-pr' },
-                    occurredAt: publishedAt,
-                    ingestedAt: publishedAt,
-                    trigger: 'context-only',
-                    payload: {
-                        intentEventId: input.event.eventId,
-                        kind: input.event.payload.kind,
-                        body: input.event.payload.body,
-                    },
-                }),
-            ];
-        },
-    };
-}

package/dist/src/adapters/fake/fake-resource-index.js

@@ -1,21 +0,0 @@
-/**
- * In-memory ResourceIndex test fake. Permanent test harness (per repo
- * convention: fakes are passed on purpose, never a default that materializes
- * when a caller forgets to wire one in), not a fallback baked into core/.
- * Production always uses the disk-backed `createResourceIndex` from
- * `src/adapters/fs/resource-index.ts`.
- */
-export function createFakeResourceIndex() {
-    const entries = new Map();
-    return {
-        async resolve(resourceUri) {
-            return entries.get(resourceUri);
-        },
-        async register(resourceUri, workItemKey) {
-            entries.set(resourceUri, workItemKey);
-        },
-        async retract(resourceUri) {
-            entries.delete(resourceUri);
-        },
-    };
-}