@atolis-hq/wake 0.4.47 → 0.4.49

package/dist/src/bootstrap/runner-registry.js

@@ -1,11 +1,29 @@
 import { createClaudeRunner, createCodexRunner, createCommandRunner, createCursorRunner, emptyFakeScenarios, FakeExecutionRunner, RunnerRegistry, } from '../execution/index.js';
 export function createRunnerRegistry(config, scenarios = emptyFakeScenarios, decorateRunner) {
-    const runners = Object.fromEntries(Object.entries(config.agentRunners ?? {}).map(([name, runner]) => [
-        name,
-        (decorateRunner ?? identity)(createConfiguredRunner(name, runner, scenarios), name),
-    ]));
+    const runners = Object.fromEntries(Object.entries(config.agentRunners ?? {}).map(([name, runner]) => {
+        const configured = createConfiguredRunner(name, runner, scenarios);
+        const decorated = (decorateRunner ?? identity)(configured, name);
+        return [name, preserveRunnerCapabilities(configured, decorated)];
+    }));
     return new RunnerRegistry(config.runnerPools, runners);
 }
+// Test and operational decorators commonly wrap only `start`; adapter capabilities
+// describe the underlying transport and must survive that wrapper.
+function preserveRunnerCapabilities(configured, decorated) {
+    const capabilities = {
+        ...(decorated.supportsSessionResume === undefined &&
+            configured.supportsSessionResume !== undefined
+            ? { supportsSessionResume: configured.supportsSessionResume }
+            : {}),
+        ...(decorated.supportsEphemeralMcp === undefined &&
+            configured.supportsEphemeralMcp !== undefined
+            ? { supportsEphemeralMcp: configured.supportsEphemeralMcp }
+            : {}),
+    };
+    if (Object.keys(capabilities).length === 0)
+        return decorated;
+    return Object.assign(Object.create(decorated), capabilities);
+}
 function identity(value) {
     return value;
 }

package/dist/src/bootstrap/surface-api-work-applications.js

@@ -4,7 +4,7 @@ import { conversationIdForWorkItem, ConversationOriginKind, } from '../conversat
 import { executionProjection, runsByWorkflowInstanceProjection, } from '../execution/index.js';
 import { ApprovalAuthorityKind, ConversationSurfaceCapability, GroupBudgetExtensionIneligibleError, isGroupBudgetExtensionEligible, OperatorRetryIneligibleError, orchestrationProjection, selectOperatorRetryTarget, workflowsByWorkItemProjection, } from '../orchestration/index.js';
 import { workCorrelationsProjection, } from '../resources/index.js';
-import { ApiCommandStatus, fromWorkItemKey, presentResource, presentRun, presentWorkflowInstance, presentWorkItem, } from '../surfaces/index.js';
+import { ApiCommandStatus, fromWorkItemKey, presentResource, presentRun, presentWorkflowInstance, presentWorkItem, toWorkItemKey, } from '../surfaces/index.js';
 import { workItemId, WorkStatus } from '../work/index.js';
 import { primaryExternalRef } from './external-ref.js';
 import { projectionMeta } from './surface-api-metadata.js';
@@ -29,6 +29,20 @@ export function createSurfaceWorkApplications(root, now) {
             });
         },
         detail: (key) => workDetail(root, key, now),
+        async artifact(key, revisionId) {
+            const id = decodeWorkItemId(key);
+            if (id === undefined)
+                return undefined;
+            const accepted = new Set((await root.orchestration.listForWorkItem(id)).flatMap((workflow) => workflow.acceptedOutcomes));
+            const artifact = await root.artifacts.readAcceptedRevision(id, revisionId, async (activationId) => accepted.has(activationId));
+            if (artifact === null)
+                return undefined;
+            return {
+                bytes: artifact.bytes,
+                mediaType: safeMediaType(artifact.revision.mediaType),
+                filename: artifact.revision.path.split('/').at(-1) ?? 'artifact',
+            };
+        },
         async transcript(key, groupId) {
             const id = decodeWorkItemId(key);
             if (id === undefined)
@@ -197,6 +211,7 @@ async function workDetail(root, key, now) {
             transcriptGroups: await transcriptGroups(root.transcriptStore, id, runs),
         },
         activities: presentPullRequest(pullRequest?.value),
+        artifacts: await presentArtifacts(root, id),
         conversation: presentConversation(conversation, root.config?.surfaces.api.conversationMessages.enabled === true),
     };
     const [projections, correlationFacts] = await Promise.all([
@@ -208,6 +223,29 @@ async function workDetail(root, key, now) {
         meta: await projectionMeta(root.journal, [...projections, ...correlationFacts, ...(pullRequest == null ? [] : [pullRequest])], now()),
     };
 }
+async function presentArtifacts(root, id) {
+    const partial = root;
+    if (partial.artifacts === undefined || partial.orchestration?.listAll === undefined)
+        return [];
+    const accepted = new Set((await partial.orchestration.listAll())
+        .filter((workflow) => workflow.workItemId === id)
+        .flatMap((workflow) => workflow.acceptedOutcomes));
+    return (await partial.artifacts.latestPublished(id, async (activationId) => accepted.has(activationId))).map((artifact) => ({
+        revisionId: artifact.revisionId,
+        producer: artifact.producer,
+        path: artifact.path,
+        occurredAt: artifact.occurredAt,
+        ...(artifact.mediaType === undefined ? {} : { mediaType: artifact.mediaType }),
+        ...(artifact.byteLength === undefined ? {} : { byteLength: artifact.byteLength }),
+        ...(artifact.digest === undefined ? {} : { digest: artifact.digest }),
+        href: `/api/v1/work-items/${encodeURIComponent(toWorkItemKey(id))}/artifacts/${encodeURIComponent(artifact.revisionId)}`,
+    }));
+}
+function safeMediaType(value) {
+    return value !== undefined && /^[^\r\n]+\/[^\r\n]+$/.test(value)
+        ? value
+        : 'application/octet-stream';
+}
 async function conversationForWorkItem(root, id) {
     // Narrow test/application seams may provide a partial composition root while
     // the production root always composes Conversations.

package/dist/src/bootstrap/surface-cli-applications.js

@@ -6,11 +6,14 @@ import { join } from 'node:path';
 import { createInterface } from 'node:readline/promises';
 import { promisify } from 'node:util';
 import { BuiltInActivityName, agentActivityDefinition } from '../activities/index.js';
+import { FileArtifactMcpSessionStore } from '../artifacts/index.js';
 import { IntakeHost, ResidentHost, TickHost, } from '../control-plane/index.js';
 import { ExecutionFailureCode, RunStatus, isActiveRunStatus, loadPromptTemplate, } from '../execution/index.js';
+import { UlidIdGenerator } from '../kernel/index.js';
 import { ResourceCorrelationRole, resourceId } from '../resources/index.js';
-import { DockerProcessError, createApiDispatcher, createLoggedDockerCli, createPackagedAssetSource, createPairingGrant, createProcessLogSink, createSandboxDockerPort, createSurfaceHttpServer, describeSandboxStartupFailure, drainProcessOutput, loadOrCreateCredentials, promoteSandboxImage, redeemPairingGrant, replaceAccessKey, runDoctor, runSandbox, runSandboxEntrypoint, runSandboxSetup, runSelfUpdateLatestLoop, runTargetSmoke, verifyResidentStart, waitForActiveRuns, waitForever, } from '../surfaces/index.js';
+import { DockerProcessError, createApiDispatcher, createLoggedDockerCli, createPackagedAssetSource, createPairingGrant, createProcessLogSink, createSandboxDockerPort, createSurfaceHttpServer, describeSandboxStartupFailure, drainProcessOutput, loadOrCreateCredentials, promoteSandboxImage, redeemPairingGrant, replaceAccessKey, runDoctor, runSandbox, runSandboxEntrypoint, runSandboxSetup, runSelfUpdateLatestLoop, runTargetSmoke, serveMcpOverStdio, verifyResidentStart, waitForActiveRuns, waitForever, } from '../surfaces/index.js';
 import { WorkStreamKind, workItemId } from '../work/index.js';
+import { createArtifactMcpServerForSession } from './artifact-mcp.js';
 import { loadConfig } from './config/load-config.js';
 import { createNpmUpdatePort } from './npm-update-port.js';
 import { runtimeProjectionDefinitions } from './projection-runtime.js';
@@ -24,6 +27,8 @@ import { UpdateMaintenancePhase } from './update-maintenance-lease.js';
 import { resolveWakeVersion, wakePackageVersion } from './version.js';
 const execFile = promisify(nodeExecFile);
 export function createSurfaceCliApplications(root, api, now) {
+    const artifactMcpSessions = new FileArtifactMcpSessionStore(root.paths.artifactsRoot, now);
+    const artifactMcpIds = new UlidIdGenerator();
     const runnerTick = new TickHost(createOneShotRunnerAdvance(root));
     const runnerResidentTick = new TickHost(createResidentRunnerAdvance(root));
     const intakeHost = new IntakeHost((signal) => root.intakePipeline.run(signal));
@@ -84,6 +89,12 @@ export function createSurfaceCliApplications(root, api, now) {
         },
         api: { start: (options) => startHttp(options, false) },
         ui: { start: (options) => startHttp(options, true) },
+        mcp: {
+            async serve(sessionPath, token) {
+                const server = await createArtifactMcpServerForSession(root, artifactMcpSessions, sessionPath, token, { now, nextId: () => artifactMcpIds.next('artifact') });
+                await serveMcpOverStdio(server);
+            },
+        },
         auth: {
             async token(accessKey) {
                 if (root.config.surfaces.web.auth.disabled)

package/dist/src/bootstrap/version.js

@@ -124,6 +124,6 @@ export function resolveWakeVersion(options = {}) {
         return `g${headHash.slice(0, 7)}`;
     return '0.1.0-dev';
 }
-export const wakeVersion = "v0.4.47";
+export const wakeVersion = "v0.4.49";
 /** The registry-installable version used by packaged sandbox images. */
 export const wakePackageVersion = packageVersion(defaultRepoRoot) ?? wakeVersion;

package/dist/src/execution/application/execution-activity.d.ts

@@ -4,6 +4,7 @@ import { type Clock, type IdGenerator } from '../../kernel/index.js';
 import type { ExecutionActivation, ExecutionAttemptContext } from '../contracts/commands.js';
 import type { ExecutionConfig } from '../contracts/config.js';
 import type { runId } from '../contracts/identifiers.js';
+import { type RunnerMcpServer } from '../contracts/runner.js';
 import type { WorkspaceProvider } from '../contracts/workspace.js';
 import type { RunnerRegistry } from '../infrastructure/runners/registry.js';
 import type { RunRepository } from './run-repository.js';
@@ -12,6 +13,11 @@ export interface ExecutionDependencies {
     readonly ids: IdGenerator;
     readonly workspaces?: WorkspaceProvider;
     readonly runners?: RunnerRegistry;
+    readonly mcp?: (input: {
+        readonly runId: string;
+        readonly activation: ExecutionActivation;
+        readonly context: ExecutionAttemptContext;
+    }) => Promise<ExecutionMcpConfiguration>;
     readonly transcriptRecorder?: ActivityExecutionContext['transcriptRecorder'];
     readonly logOperationalError?: ActivityExecutionContext['logOperationalError'];
     readonly reportRunnerQuota?: (input: {
@@ -19,6 +25,11 @@ export interface ExecutionDependencies {
         readonly message: string;
     }) => Promise<void>;
 }
+export interface ExecutionMcpConfiguration {
+    readonly servers: readonly RunnerMcpServer[];
+    readonly prompt?: string;
+    release(): Promise<void>;
+}
 export interface ExecutionRuntime {
     readonly activities: ActivityRegistry;
     readonly config: ExecutionConfig;

package/dist/src/execution/application/execution-activity.js

@@ -4,10 +4,15 @@ import { ExecutionCancellationReason } from '../contracts/vocabulary.js';
 import { parseAgentRunnerResponse } from '../infrastructure/agent-runner-adapter.js';
 import { createRunEvent } from './run-lifecycle.js';
 import { confirmCancellation, requestCancellation } from './run-liveness-service.js';
+// Execution context assembly intentionally keeps every run-bound capability visible at dispatch.
+// eslint-disable-next-line max-lines-per-function, complexity
 export async function executeActivity(runtime, currentRunId, request) {
     const { activation, context, occurredAt, runner } = request;
     const controller = activityController(runtime, currentRunId);
     runtime.active.set(currentRunId, controller);
+    const mcp = runner === undefined || runtime.dependencies.mcp === undefined
+        ? undefined
+        : await runtime.dependencies.mcp({ runId: currentRunId, activation, context });
     const executionContext = {
         signal: controller.signal,
         occurredAt,
@@ -20,6 +25,12 @@ export async function executeActivity(runtime, currentRunId, request) {
             : { reportRunnerStarted: request.reportRunnerStarted }),
         ...workspaceContext(request.workspace),
         ...(runner === undefined ? {} : { runner }),
+        ...(mcp === undefined
+            ? {}
+            : {
+                mcpServers: mcp.servers,
+                ...(mcp.prompt === undefined ? {} : { mcpPrompt: mcp.prompt }),
+            }),
         ...(runtime.dependencies.transcriptRecorder === undefined
             ? {}
             : { transcriptRecorder: runtime.dependencies.transcriptRecorder }),
@@ -41,16 +52,21 @@ export async function executeActivity(runtime, currentRunId, request) {
         reportRunnerResult: runnerResultReporter(runtime, currentRunId, context, activation, request),
         reportRunnerTimeout: runnerTimeoutReporter(runtime, currentRunId),
     };
-    return runtime.activities.execute({
-        activationId: activation.activationId,
-        activity: activation.activity,
-        workItemId: context.workItemId,
-        workflowInstanceId: context.workflowInstanceId,
-        orchestrationGroupId: context.orchestrationGroupId,
-        causationId: activation.activationId,
-        input: activation.input,
-        resources: context.resources,
-    }, executionContext);
+    try {
+        return await runtime.activities.execute({
+            activationId: activation.activationId,
+            activity: activation.activity,
+            workItemId: context.workItemId,
+            workflowInstanceId: context.workflowInstanceId,
+            orchestrationGroupId: context.orchestrationGroupId,
+            causationId: activation.activationId,
+            input: activation.input,
+            resources: context.resources,
+        }, executionContext);
+    }
+    finally {
+        await mcp?.release();
+    }
 }
 function activityController(runtime, currentRunId) {
     return runtime.active.get(currentRunId) ?? new AbortController();

package/dist/src/execution/application/execution-service.js

@@ -563,7 +563,7 @@ function resolveRunner(runtime, executionKind, activation, context) {
         throw new Error(`Unknown execution runner pool: ${runnerPool}`);
     if (executionKind !== ActivityExecutionKind.Agent)
         return { runner: undefined };
-    const resolved = runtime.dependencies.runners?.resolve(runnerPool, context.ineligibleRunners ?? new Set());
+    const resolved = runtime.dependencies.runners?.resolve(runnerPool, context.ineligibleRunners ?? new Set(), { ephemeralMcp: runtime.dependencies.mcp !== undefined });
     return describeResolvedRunner(runtime, runnerPool, resolved);
 }
 function describeResolvedRunner(runtime, pool, resolved) {

package/dist/src/execution/contracts/runner.d.ts

@@ -1,6 +1,13 @@
 import type { ExternalExecutionKind } from '../../activities/index.js';
 import type { FinishedRunStatus, WorkspaceMode } from './vocabulary.js';
 export declare const ProviderQuotaExceededFailureKind = "provider-quota-exceeded";
+/** A trusted MCP process configured only for this runner invocation. */
+export interface RunnerMcpServer {
+    readonly name: string;
+    readonly command: string;
+    readonly args?: readonly string[];
+    readonly env?: Readonly<Record<string, string>>;
+}
 export interface RunnerRequest {
     readonly runId: string;
     readonly prompt: string;
@@ -23,6 +30,7 @@ export interface RunnerRequest {
         readonly cacheRead?: number;
         readonly cacheWrite?: number;
     };
+    readonly mcpServers?: readonly RunnerMcpServer[];
 }
 export type AgentRunOutcome = 'DONE' | 'REJECTED' | 'BLOCKED' | 'FAILED' | 'NEEDS_CLARIFICATION';
 export interface AgentRunResponse {
@@ -74,5 +82,7 @@ export interface RunnerExecution {
 export interface Runner {
     /** Whether this adapter can continue an earlier session with its opaque session ID. */
     readonly supportsSessionResume?: boolean;
+    /** Whether this adapter can inject trusted MCP configuration per invocation. */
+    readonly supportsEphemeralMcp?: boolean;
     start(request: RunnerRequest, signal: AbortSignal): Promise<RunnerExecution>;
 }

package/dist/src/execution/infrastructure/runners/claude.d.ts

@@ -14,6 +14,7 @@ export declare function cliRunner(name: string, command: string, args: (request:
     readonly runnerTimeouts?: ProcessTimeouts;
     readonly defaultModel?: string;
     readonly supportsSessionResume?: boolean;
+    readonly supportsEphemeralMcp?: boolean;
     readonly parseSuccessfulOutput?: (stdout: string, request: RunnerRequest) => Partial<AgentRunnerResult>;
     readonly classifyFailure?: (input: {
         readonly stdout: string;

package/dist/src/execution/infrastructure/runners/claude.js

@@ -9,6 +9,7 @@ export function createClaudeRunner(options = {}) {
         parseSuccessfulOutput: parseClaudeOutput,
         classifyFailure: classifyClaudeFailure,
         supportsSessionResume: true,
+        supportsEphemeralMcp: true,
     });
 }
 export function parseClaudeOutput(stdout, _request) {
@@ -84,15 +85,35 @@ export function claudeCommandArgs(request, passthroughArgs = [], defaults = {})
         ...(request.allowedTools.length === 0
             ? []
             : ['--allowedTools', request.allowedTools.join(' ')]),
+        ...(request.mcpServers === undefined || request.mcpServers.length === 0
+            ? []
+            : ['--mcp-config', JSON.stringify(claudeMcpConfig(request)), '--strict-mcp-config']),
         ...passthroughArgs,
         '--',
         request.prompt,
     ];
 }
+function claudeMcpConfig(request) {
+    return {
+        mcpServers: Object.fromEntries((request.mcpServers ?? []).map((server) => [
+            server.name,
+            {
+                command: server.command,
+                ...(server.args === undefined ? {} : { args: server.args }),
+                ...(server.env === undefined ? {} : { env: server.env }),
+            },
+        ])),
+    };
+}
 export function cliRunner(name, command, args, options = {}) {
     return {
         supportsSessionResume: options.supportsSessionResume === true,
+        supportsEphemeralMcp: options.supportsEphemeralMcp === true,
         async start(request, signal) {
+            if (request.mcpServers !== undefined &&
+                request.mcpServers.length > 0 &&
+                !options.supportsEphemeralMcp)
+                throw new Error(`${name} runner does not support ephemeral MCP configuration`);
             const process = runProcess(command, args(request), request.workspacePath, signal, {
                 ...options.runnerTimeouts,
                 ...(request.onTimeout === undefined ? {} : { onTimeout: request.onTimeout }),

package/dist/src/execution/infrastructure/runners/codex.js

@@ -42,6 +42,7 @@ export function createCodexRunner(options = {}) {
         parseSuccessfulOutput: parseCodexOutput,
         classifyFailure: classifyCodexFailure,
         supportsSessionResume: true,
+        supportsEphemeralMcp: true,
     });
     return runner;
 }
@@ -59,11 +60,22 @@ export function codexCommandArgs(request, passthroughArgs = [], defaults = {}) {
         ...((request.effort ?? defaults.effort) === undefined
             ? []
             : ['-c', `model_reasoning_effort=${request.effort ?? defaults.effort}`]),
+        ...codexMcpConfigArgs(request),
         ...(request.resumeSessionId === undefined ? [] : ['resume', request.resumeSessionId]),
         ...passthroughArgs,
         `${request.prompt}\n\n${waitBackgroundInstruction}`,
     ];
 }
+function codexMcpConfigArgs(request) {
+    return (request.mcpServers ?? []).flatMap((server) => [
+        '-c',
+        `mcp_servers.${JSON.stringify(server.name)}={command=${JSON.stringify(server.command)},args=${JSON.stringify(server.args ?? [])}${server.env === undefined
+            ? ''
+            : `,env={${Object.entries(server.env)
+                .map(([key, value]) => `${JSON.stringify(key)}=${JSON.stringify(value)}`)
+                .join(',')}}`}}`,
+    ]);
+}
 // Work around Codex's missing background-command lifecycle contract (https://github.com/openai/codex/issues/32505, https://github.com/openai/codex/issues/34866).
 const waitBackgroundInstruction = `When a command you started is still running or lacks a terminal result, do not report a normal Wake outcome. Make your entire final response exactly WAIT_BACKGROUND. Wake will reject that stop attempt and ask you to continue. After that hook prompt, poll the still-running command and report a normal terminal status only after it has settled. Do not use WAIT_BACKGROUND for a human-input or implementation blocker.`;
 function codexSandboxMode(_workspaceMode) {

package/dist/src/execution/infrastructure/runners/fake.d.ts

@@ -3,6 +3,7 @@ import { type FakeScenarioResolver } from './fake-scenarios.js';
 export declare class FakeExecutionRunner implements Runner {
     readonly name: string;
     private readonly scenarios;
+    readonly supportsEphemeralMcp = true;
     constructor(name?: string, scenarios?: FakeScenarioResolver);
     start(request: RunnerRequest, signal: AbortSignal): Promise<RunnerExecution>;
 }

package/dist/src/execution/infrastructure/runners/fake.js

@@ -4,6 +4,7 @@ import { emptyFakeScenarios, } from './fake-scenarios.js';
 export class FakeExecutionRunner {
     name;
     scenarios;
+    supportsEphemeralMcp = true;
     constructor(name = 'fake', scenarios = emptyFakeScenarios) {
         this.name = name;
         this.scenarios = scenarios;

package/dist/src/execution/infrastructure/runners/registry.d.ts

@@ -7,7 +7,9 @@ export declare class RunnerRegistry {
     private readonly runnerPools;
     private readonly runners;
     constructor(runnerPools: Readonly<Record<string, readonly string[]>>, runners: Readonly<Record<string, Runner>>);
-    resolve(runnerPool: string, ineligible?: ReadonlySet<string>): {
+    resolve(runnerPool: string, ineligible?: ReadonlySet<string>, requirements?: {
+        readonly ephemeralMcp?: boolean;
+    }): {
         readonly name: string;
         readonly runner: Runner;
     };

package/dist/src/execution/infrastructure/runners/registry.js

@@ -13,21 +13,23 @@ export class RunnerRegistry {
         this.runnerPools = runnerPools;
         this.runners = runners;
     }
-    resolve(runnerPool, ineligible = new Set()) {
+    resolve(runnerPool, ineligible = new Set(), requirements = {}) {
         const candidates = this.runnerPools[runnerPool];
         if (candidates === undefined)
             throw new Error(`Execution runner pool ${runnerPool} has no runner`);
-        return selectEligibleCandidate(runnerPool, candidates, this.runners, ineligible);
+        return selectEligibleCandidate(runnerPool, candidates, this.runners, ineligible, requirements);
     }
 }
 // Falls sideways to the next candidate on quota ineligibility; never a different runner pool.
-function selectEligibleCandidate(runnerPool, candidates, runners, ineligible) {
+function selectEligibleCandidate(runnerPool, candidates, runners, ineligible, requirements) {
     for (const name of candidates) {
         if (ineligible.has(name))
             continue;
         const runner = runners[name];
         if (runner === undefined)
             throw new Error(`Runner ${name} is not registered`);
+        if (requirements.ephemeralMcp === true && runner.supportsEphemeralMcp !== true)
+            continue;
         return { name, runner };
     }
     throw new NoEligibleRunnerError(runnerPool);

package/dist/src/surfaces/api/contracts/board.d.ts

@@ -22,6 +22,8 @@ export interface BoardCardResponse {
     readonly condition: BoardCardCondition;
     readonly frozen?: boolean;
     readonly awaitingApproval?: boolean;
+    /** Whether the primary workflow needs a gate-budget extension to continue. */
+    readonly extendEligible?: boolean;
     readonly workflowName?: string;
     readonly stage?: string;
     /** Why the primary workflow is blocked, when it requires operator intervention. */

package/dist/src/surfaces/api/contracts/work.d.ts

@@ -35,6 +35,16 @@ export interface WorkDetailResponse {
     readonly activities: {
         readonly pullRequest?: PullRequestResponse;
     };
+    readonly artifacts: readonly {
+        readonly revisionId: string;
+        readonly producer: string;
+        readonly path: string;
+        readonly occurredAt: string;
+        readonly mediaType?: string;
+        readonly byteLength?: number;
+        readonly digest?: string;
+        readonly href: string;
+    }[];
     readonly conversation: {
         /** Whether this authenticated surface may create control-plane entries. */
         readonly canCreateEntries: boolean;

package/dist/src/surfaces/api/routes/applications.d.ts

@@ -56,6 +56,11 @@ export interface ApiApplications {
         list(query: CollectionQuery): Promise<ApiCollectionPage<WorkItemResponse>>;
         detail(key: string): Promise<ApiResourceResult<WorkDetailResponse> | undefined>;
         transcript?(key: string, groupId: string): Promise<ApiResourceResult<WorkItemTranscriptResponse> | undefined>;
+        artifact?(key: string, revisionId: string): Promise<{
+            readonly bytes: Uint8Array;
+            readonly mediaType: string;
+            readonly filename: string;
+        } | undefined>;
         freeze?(key: string, command: ApiCommandRequest): Promise<ApiCommandResult>;
         unfreeze?(key: string, command: ApiCommandRequest): Promise<ApiCommandResult>;
         delete?(key: string, command: ApiCommandRequest): Promise<ApiCommandResult>;

package/dist/src/surfaces/api/routes/read.js

@@ -108,9 +108,9 @@ async function collectionResult(applications, pathname, query) {
     }
 }
 async function readDetail(applications, pathname) {
-    const workTranscript = /^\/api\/v1\/work-items\/([^/]+)\/transcripts\/([^/]+)$/.exec(pathname);
-    if (workTranscript?.[1] !== undefined && workTranscript[2] !== undefined)
-        return readWorkTranscript(applications, workTranscript[1], workTranscript[2]);
+    const workSubresource = await readWorkSubresource(applications, pathname);
+    if (workSubresource !== undefined)
+        return workSubresource;
     const transcript = /^\/api\/v1\/runs\/([^/]+)\/transcript$/.exec(pathname)?.[1];
     if (transcript !== undefined)
         return readTranscript(applications, transcript);
@@ -120,6 +120,37 @@ async function readDetail(applications, pathname) {
     const run = /^\/api\/v1\/runs\/([^/]+)$/.exec(pathname)?.[1];
     return run === undefined ? undefined : readRun(applications, run);
 }
+async function readWorkSubresource(applications, pathname) {
+    const workTranscript = /^\/api\/v1\/work-items\/([^/]+)\/transcripts\/([^/]+)$/.exec(pathname);
+    if (workTranscript?.[1] !== undefined && workTranscript[2] !== undefined)
+        return readWorkTranscript(applications, workTranscript[1], workTranscript[2]);
+    const artifact = /^\/api\/v1\/work-items\/([^/]+)\/artifacts\/([^/]+)$/.exec(pathname);
+    if (artifact?.[1] !== undefined && artifact[2] !== undefined)
+        return readWorkArtifact(applications, artifact[1], artifact[2]);
+    return undefined;
+}
+async function readWorkArtifact(applications, keySegment, revisionSegment) {
+    const key = decodePathSegment(keySegment);
+    const revisionId = decodePathSegment(revisionSegment);
+    if (key instanceof ApiPathError)
+        return invalidPath(key.message);
+    if (revisionId instanceof ApiPathError)
+        return invalidPath(revisionId.message);
+    if (applications.work.artifact === undefined)
+        return unavailable('artifact');
+    const artifact = await applications.work.artifact(key, revisionId);
+    if (artifact === undefined)
+        return found(undefined);
+    return {
+        status: 200,
+        body: artifact.bytes,
+        contentType: artifact.mediaType,
+        headers: {
+            'content-disposition': `attachment; filename*=UTF-8''${encodeURIComponent(artifact.filename)}`,
+            'content-length': String(artifact.bytes.byteLength),
+        },
+    };
+}
 async function readWorkTranscript(applications, keySegment, groupSegment) {
     const key = decodePathSegment(keySegment);
     const groupId = decodePathSegment(groupSegment);

package/dist/src/surfaces/api/routes/work.d.ts

@@ -1 +1 @@
-export declare const workRoutes: readonly ["/api/v1/work-items", "/api/v1/work-items/:workItemKey", "/api/v1/work-items/:workItemKey/transcripts/:groupId", "/api/v1/work-items/:workItemKey/commands/freeze", "/api/v1/work-items/:workItemKey/commands/unfreeze", "/api/v1/work-items/:workItemKey/commands/delete", "/api/v1/work-items/:workItemKey/commands/retry", "/api/v1/work-items/:workItemKey/commands/extend", "/api/v1/work-items/:workItemKey/commands/message"];
+export declare const workRoutes: readonly ["/api/v1/work-items", "/api/v1/work-items/:workItemKey", "/api/v1/work-items/:workItemKey/transcripts/:groupId", "/api/v1/work-items/:workItemKey/artifacts/:revisionId", "/api/v1/work-items/:workItemKey/commands/freeze", "/api/v1/work-items/:workItemKey/commands/unfreeze", "/api/v1/work-items/:workItemKey/commands/delete", "/api/v1/work-items/:workItemKey/commands/retry", "/api/v1/work-items/:workItemKey/commands/extend", "/api/v1/work-items/:workItemKey/commands/message"];

package/dist/src/surfaces/api/routes/work.js

@@ -2,6 +2,7 @@ export const workRoutes = [
     '/api/v1/work-items',
     '/api/v1/work-items/:workItemKey',
     '/api/v1/work-items/:workItemKey/transcripts/:groupId',
+    '/api/v1/work-items/:workItemKey/artifacts/:revisionId',
     '/api/v1/work-items/:workItemKey/commands/freeze',
     '/api/v1/work-items/:workItemKey/commands/unfreeze',
     '/api/v1/work-items/:workItemKey/commands/delete',

package/dist/src/surfaces/cli/main.d.ts

@@ -15,6 +15,11 @@ export type WakeCommand = ({
 }) | ({
     readonly kind: 'api' | 'ui';
 } & HostOptions) | ({
+    readonly kind: 'mcp';
+} & {
+    readonly sessionPath: string;
+    readonly wakeRoot?: string;
+}) | ({
     readonly kind: 'ui-token';
     readonly accessKey?: string;
 } & Pick<HostOptions, 'wakeRoot'>) | {
@@ -84,6 +89,9 @@ export interface WakeCliApplications {
     readonly ui: {
         start(options?: HostOptions): Promise<void>;
     };
+    readonly mcp?: {
+        serve(sessionPath: string, token: string): Promise<void>;
+    };
     readonly auth?: {
         token(accessKey?: string): Promise<string>;
     };

package/dist/src/surfaces/cli/main.js

@@ -27,6 +27,8 @@ export function parseWakeCommand(arguments_) {
             return parseUiCommand(arguments_.slice(1));
         case 'api':
             return { kind: command, ...parseHostOptions(arguments_.slice(1)) };
+        case 'mcp':
+            return parseMcpCommand(arguments_.slice(1));
         case 'tick':
         case 'start':
         case 'stop':
@@ -44,6 +46,27 @@ export function parseWakeCommand(arguments_) {
             throw new Error(`Unknown wake command: ${command ?? ''}`);
     }
 }
+function parseMcpCommand(arguments_) {
+    if (arguments_[0] !== 'serve')
+        throw new Error(`Unknown mcp command: ${arguments_[0] ?? ''}`);
+    let sessionPath;
+    let wakeRoot;
+    for (let index = 1; index < arguments_.length; index += 2) {
+        const flag = arguments_[index];
+        const value = requiredArgument(arguments_[index + 1], `value for ${flag ?? 'option'}`);
+        if (flag === '--session' && sessionPath === undefined)
+            sessionPath = value;
+        else if (flag === '--wake-root' && wakeRoot === undefined)
+            wakeRoot = value;
+        else
+            throw new Error(`Unknown or duplicate mcp option: ${flag ?? ''}`);
+    }
+    return {
+        kind: 'mcp',
+        sessionPath: requiredArgument(sessionPath, 'mcp --session'),
+        ...(wakeRoot === undefined ? {} : { wakeRoot }),
+    };
+}
 function parseUiCommand(arguments_) {
     if (arguments_[0] !== 'token')
         return { kind: 'ui', ...parseHostOptions(arguments_) };
@@ -194,6 +217,9 @@ export async function runWakeCommand(command, applications, output, signal) {
         case 'ui-token':
             output.write(await formatUiTokenOutput(auth(applications).token(command.accessKey)));
             return;
+        case 'mcp':
+            await mcp(applications).serve(command.sessionPath, process.env.WAKE_MCP_TOKEN ?? '');
+            return;
         case 'audit':
             for (const record of await applications.audit.read(command.workItemId))
                 output.write(`${JSON.stringify(record)}\n`);
@@ -247,6 +273,11 @@ function auth(applications) {
         throw new Error('UI auth CLI application was not composed');
     return applications.auth;
 }
+function mcp(applications) {
+    if (applications.mcp === undefined)
+        throw new Error('MCP CLI application was not composed');
+    return applications.mcp;
+}
 function writeResult(output, value) {
     if (value !== undefined)
         output.write(`${JSON.stringify(value)}\n`);

package/dist/src/surfaces/cli/usage.js

@@ -14,6 +14,7 @@ export const usage = [
     '  wake ui token set <key>    Replace the UI login access key',
     '  wake audit                 Show autonomous decision audit history',
     '  wake correlate             Manually correlate a resource to a work item',
+    '  wake mcp serve             Run the private run-scoped Wake MCP transport',
     '  wake run resolve           Resolve an escalated ambiguous run',
     '  wake doctor                Diagnose config/GitHub/Docker/sandbox setup problems',
     '  wake maintenance clear     Clear an abandoned failed self-update maintenance lease',

package/dist/src/surfaces/index.d.ts

@@ -45,6 +45,7 @@ export * from './cli/infrastructure/process-log.js';
 export * from './cli/infrastructure/sandbox-startup-failure.js';
 export * from './cli/main.js';
 export * from './cli/usage.js';
+export * from './mcp/stdio.js';
 export * from './contracts/config.js';
 export * from './web-host/asset-source.js';
 export * from './web-host/packaged-assets.js';