@atolis-hq/wake 0.4.48 → 0.4.50

package/dist/src/artifacts/infrastructure/file-artifact-store.js

@@ -0,0 +1,51 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+/**
+ * Private filesystem byte store. Its locations are opaque implementation
+ * details; durable artifact facts carry the location, digest, and length.
+ */
+export class FileArtifactStore {
+    root;
+    constructor(root) {
+        this.root = root;
+    }
+    async write(input) {
+        assertSegment(input.workItemId, 'Work item ID');
+        assertSegment(input.revisionId, 'Artifact revision ID');
+        const digest = createHash('sha256').update(input.bytes).digest('hex');
+        const location = join(input.workItemId, `${input.revisionId}.${digest}`);
+        const destination = this.absolute(location);
+        await mkdir(dirname(destination), { recursive: true });
+        const temporary = `${destination}.${randomUUID()}.pending`;
+        try {
+            await writeFile(temporary, input.bytes);
+            await rename(temporary, destination);
+        }
+        finally {
+            await rm(temporary, { force: true });
+        }
+        return {
+            location,
+            byteLength: input.bytes.byteLength,
+            digest,
+        };
+    }
+    async read(location) {
+        return readFile(this.absolute(location));
+    }
+    absolute(location) {
+        const segments = location.split('/');
+        for (const segment of segments)
+            assertSegment(segment, 'Artifact store location segment');
+        return join(this.root, ...segments);
+    }
+}
+function assertSegment(value, label) {
+    if (value.length === 0 ||
+        value === '.' ||
+        value === '..' ||
+        value.includes('/') ||
+        value.includes('\\'))
+        throw new Error(`${label} must be a single filesystem segment`);
+}

package/dist/src/artifacts/infrastructure/mcp-server.d.ts

@@ -0,0 +1,18 @@
+import type { CommandContext } from '@atolis-hq/eventing';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { WorkItemId } from '../../work/index.js';
+import type { ArtifactService } from '../application/artifact-service.js';
+/** A capability token is resolved into this server-side scope by Execution. */
+export interface ArtifactMcpSession {
+    readonly workItemId: WorkItemId;
+    readonly producer: string;
+    readonly runId: string;
+    readonly activationId: string;
+    readonly readableProducers: ReadonlySet<string>;
+    readonly nextRevisionId: () => string;
+    readonly commandContext: () => CommandContext;
+    readonly acceptedActivation: (activationId: string) => Promise<boolean>;
+    /** Revalidates the run-bound credential for every tool request. */
+    readonly assertActive: () => Promise<void>;
+}
+export declare function createArtifactMcpServer(artifacts: ArtifactService, session: ArtifactMcpSession): McpServer;

package/dist/src/artifacts/infrastructure/mcp-server.js

@@ -0,0 +1,135 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { artifactPath } from '../contracts/paths.js';
+// Tool registration remains adjacent so the advertised MCP surface is auditable in one place.
+// eslint-disable-next-line max-lines-per-function
+export function createArtifactMcpServer(artifacts, session) {
+    const server = new McpServer({ name: 'wake', version: '0.1.0' });
+    server.registerTool('wake.artifacts.read', {
+        description: 'Read a visible artifact revision as UTF-8 text or base64 bytes.',
+        inputSchema: {
+            revisionId: z.string().min(1),
+            encoding: z.enum(['utf8', 'base64']).default('utf8'),
+            offset: z.number().int().nonnegative().default(0),
+            length: z.number().int().positive().optional(),
+        },
+    }, async ({ revisionId, encoding, offset, length }) => {
+        await session.assertActive();
+        const artifact = await visibleArtifact(artifacts, session, revisionId);
+        if (artifact.location === undefined)
+            throw new Error('Artifact revision has no content');
+        const bytes = (await artifacts.read(artifact.location)).slice(offset, length === undefined ? undefined : offset + length);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: encoding === 'base64'
+                        ? Buffer.from(bytes).toString('base64')
+                        : new TextDecoder('utf-8', { fatal: true }).decode(bytes),
+                },
+            ],
+        };
+    });
+    server.registerTool('wake.artifacts.list', { description: 'List the current artifact manifest visible to this activation.' }, async () => {
+        await session.assertActive();
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify((await visibleArtifacts(artifacts, session)).map(({ location: _location, ...artifact }) => artifact)),
+                },
+            ],
+        };
+    });
+    server.registerTool('wake.artifacts.patch', {
+        description: 'Atomically replace one exact UTF-8 text fragment in an artifact owned by this producer.',
+        inputSchema: {
+            revisionId: z.string().min(1),
+            find: z.string().min(1),
+            replace: z.string(),
+        },
+    }, async ({ revisionId, find, replace }) => {
+        await session.assertActive();
+        const artifact = await visibleArtifact(artifacts, session, revisionId);
+        if (artifact.producer !== session.producer)
+            throw new Error('Only the owning producer may patch an artifact');
+        if (artifact.location === undefined)
+            throw new Error('Artifact revision has no content');
+        const source = new TextDecoder('utf-8', { fatal: true }).decode(await artifacts.read(artifact.location));
+        const first = source.indexOf(find);
+        if (first < 0 || source.indexOf(find, first + find.length) >= 0)
+            throw new Error('Patch target must occur exactly once');
+        const next = `${source.slice(0, first)}${replace}${source.slice(first + find.length)}`;
+        const nextRevisionId = session.nextRevisionId();
+        await artifacts.stageRevision({
+            revisionId: nextRevisionId,
+            path: artifactPath(artifact.path),
+            bytes: new TextEncoder().encode(next),
+            ...(artifact.mediaType === undefined ? {} : { mediaType: artifact.mediaType }),
+        }, writeScope(session), session.commandContext());
+        return { content: [{ type: 'text', text: JSON.stringify({ revisionId: nextRevisionId }) }] };
+    });
+    server.registerTool('wake.artifacts.write', {
+        description: 'Stage UTF-8 content at a path owned by this activation producer.',
+        inputSchema: {
+            path: z.string().min(1),
+            content: z.string(),
+            encoding: z.enum(['utf8', 'base64']).default('utf8'),
+            mediaType: z.string().min(1).optional(),
+        },
+    }, async ({ path, content, encoding, mediaType }) => {
+        await session.assertActive();
+        const revisionId = session.nextRevisionId();
+        await artifacts.stageRevision({
+            revisionId,
+            path: artifactPath(path),
+            bytes: decodeContent(content, encoding),
+            ...(mediaType === undefined ? {} : { mediaType }),
+        }, writeScope(session), session.commandContext());
+        return { content: [{ type: 'text', text: JSON.stringify({ revisionId }) }] };
+    });
+    server.registerTool('wake.artifacts.delete', {
+        description: 'Stage deletion of an artifact path owned by this activation producer.',
+        inputSchema: { path: z.string().min(1) },
+    }, async ({ path }) => {
+        await session.assertActive();
+        const revisionId = session.nextRevisionId();
+        await artifacts.stageTombstone({
+            revisionId,
+            path: artifactPath(path),
+        }, writeScope(session), session.commandContext());
+        return { content: [{ type: 'text', text: JSON.stringify({ revisionId }) }] };
+    });
+    return server;
+}
+async function visibleArtifact(artifacts, session, revisionId) {
+    const artifact = (await visibleArtifacts(artifacts, session)).find((candidate) => candidate.revisionId === revisionId && session.readableProducers.has(candidate.producer));
+    if (artifact === undefined)
+        throw new Error('Artifact revision is not visible to this activation');
+    return artifact;
+}
+function visibleArtifacts(artifacts, session) {
+    return artifacts.visibleTo({
+        workItemId: session.workItemId,
+        producer: session.producer,
+        runId: session.runId,
+        activationId: session.activationId,
+        readableProducers: session.readableProducers,
+    }, session.acceptedActivation);
+}
+function writeScope(session) {
+    return {
+        workItemId: session.workItemId,
+        producer: session.producer,
+        runId: session.runId,
+        activationId: session.activationId,
+    };
+}
+function decodeContent(content, encoding) {
+    if (encoding === 'utf8')
+        return new TextEncoder().encode(content);
+    const bytes = Buffer.from(content, 'base64');
+    if (bytes.toString('base64').replace(/=+$/, '') !== content.replace(/=+$/, ''))
+        throw new Error('Artifact base64 content is invalid');
+    return bytes;
+}

package/dist/src/artifacts/infrastructure/mcp-session-store.d.ts

@@ -0,0 +1,25 @@
+import type { WorkItemId } from '../../work/index.js';
+export interface ArtifactMcpSessionDescriptor {
+    readonly workItemId: WorkItemId;
+    readonly producer: string;
+    readonly runId: string;
+    readonly activationId: string;
+    readonly readableProducers: readonly string[];
+    readonly expiresAt: string;
+}
+/**
+ * Ephemeral run-scoped descriptors are intentionally outside a Git workspace.
+ * The unpredictable filename is the capability presented by the configured MCP
+ * child process; it does not contain artifacts themselves.
+ */
+export declare class FileArtifactMcpSessionStore {
+    private readonly root;
+    private readonly now;
+    constructor(root: string, now?: () => string);
+    issue(input: ArtifactMcpSessionDescriptor): Promise<{
+        readonly path: string;
+        readonly token: string;
+    }>;
+    read(path: string, token: string): Promise<ArtifactMcpSessionDescriptor>;
+    revoke(path: string): Promise<void>;
+}

package/dist/src/artifacts/infrastructure/mcp-session-store.js

@@ -0,0 +1,61 @@
+import { createHash, randomBytes, timingSafeEqual } from 'node:crypto';
+import { mkdir, readFile, unlink, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+/**
+ * Ephemeral run-scoped descriptors are intentionally outside a Git workspace.
+ * The unpredictable filename is the capability presented by the configured MCP
+ * child process; it does not contain artifacts themselves.
+ */
+export class FileArtifactMcpSessionStore {
+    root;
+    now;
+    constructor(root, now = () => new Date().toISOString()) {
+        this.root = root;
+        this.now = now;
+    }
+    async issue(input) {
+        const token = randomBytes(32).toString('base64url');
+        const id = createHash('sha256').update(token).digest('hex');
+        const directory = join(this.root, 'sessions');
+        await mkdir(directory, { recursive: true, mode: 0o700 });
+        const path = join(directory, `${id}.json`);
+        await writeFile(path, JSON.stringify({
+            ...input,
+            tokenHash: digest(token),
+        }), { encoding: 'utf8', mode: 0o600 });
+        return { path, token };
+    }
+    async read(path, token) {
+        const descriptor = JSON.parse(await readFile(path, 'utf8'));
+        if (typeof descriptor.tokenHash !== 'string' ||
+            !sameDigest(descriptor.tokenHash, digest(token)) ||
+            typeof descriptor.workItemId !== 'string' ||
+            typeof descriptor.producer !== 'string' ||
+            typeof descriptor.runId !== 'string' ||
+            typeof descriptor.activationId !== 'string' ||
+            !Array.isArray(descriptor.readableProducers) ||
+            typeof descriptor.expiresAt !== 'string' ||
+            !Number.isFinite(Date.parse(descriptor.expiresAt)) ||
+            Date.parse(descriptor.expiresAt) <= Date.parse(this.now()))
+            throw new Error('Invalid artifact MCP session');
+        const { tokenHash: _tokenHash, ...session } = descriptor;
+        return session;
+    }
+    async revoke(path) {
+        try {
+            await unlink(path);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+    }
+}
+function digest(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+function sameDigest(left, right) {
+    const leftBytes = Buffer.from(left, 'hex');
+    const rightBytes = Buffer.from(right, 'hex');
+    return leftBytes.byteLength === rightBytes.byteLength && timingSafeEqual(leftBytes, rightBytes);
+}

package/dist/src/bootstrap/artifact-mcp.d.ts

@@ -0,0 +1,23 @@
+import type { FileArtifactMcpSessionStore } from '../artifacts/index.js';
+import { type ArtifactService } from '../artifacts/index.js';
+import type { ExecutionDependencies } from '../execution/index.js';
+import { type OrchestrationService } from '../orchestration/index.js';
+/** Bootstrap binds Artifact's generic policy to verified Execution and Orchestration facts. */
+export declare function createArtifactMcpProvisioner(input: {
+    readonly artifacts: ArtifactService;
+    readonly orchestration: OrchestrationService;
+    readonly sessions: FileArtifactMcpSessionStore;
+    readonly wakeRoot: string;
+    readonly now: () => string;
+    readonly nextId: () => string;
+}): NonNullable<ExecutionDependencies['mcp']>;
+/** Creates the transport-neutral Wake MCP server for the run-bound CLI command. */
+export declare function createArtifactMcpServerForSession(root: ArtifactMcpRoot, sessions: FileArtifactMcpSessionStore, path: string, token: string, options: {
+    readonly now: () => string;
+    readonly nextId: () => string;
+}): Promise<import("@modelcontextprotocol/sdk/server/mcp").McpServer>;
+interface ArtifactMcpRoot {
+    readonly artifacts: ArtifactService;
+    readonly orchestration: OrchestrationService;
+}
+export {};

package/dist/src/bootstrap/artifact-mcp.js

@@ -0,0 +1,119 @@
+import { EventActorKind, correlationId } from '@atolis-hq/eventing';
+import { randomUUID } from 'node:crypto';
+import { createArtifactMcpServer, } from '../artifacts/index.js';
+import { TransitionTargetKind, } from '../orchestration/index.js';
+const sessionLifetimeMs = 2 * 60 * 60 * 1000;
+/** Bootstrap binds Artifact's generic policy to verified Execution and Orchestration facts. */
+export function createArtifactMcpProvisioner(input) {
+    return async ({ runId, activation, context }) => {
+        const workflow = await input.orchestration.get(context.workflowInstanceId);
+        const producer = producerFor(context.workflowInstanceId, activation.stage, activation.activity);
+        const readableProducers = new Set([
+            producer,
+            ...(workflow === null
+                ? []
+                : await upstreamProducers(input.orchestration, workflow, context.workflowInstanceId, activation.stage)),
+        ]);
+        const expiresAt = new Date(Date.parse(input.now()) + sessionLifetimeMs).toISOString();
+        const descriptor = {
+            workItemId: context.workItemId,
+            producer,
+            runId,
+            activationId: activation.activationId,
+            readableProducers: [...readableProducers],
+            expiresAt,
+        };
+        const issued = await input.sessions.issue(descriptor);
+        try {
+            const manifest = await input.artifacts.visibleTo({ ...descriptor, readableProducers }, acceptedActivation(input.orchestration, context.workItemId));
+            return {
+                servers: [
+                    {
+                        name: 'wake',
+                        command: 'wake',
+                        args: ['mcp', 'serve', '--session', issued.path, '--wake-root', input.wakeRoot],
+                        env: { WAKE_MCP_TOKEN: issued.token },
+                    },
+                ],
+                prompt: artifactPrompt(manifest),
+                release: () => input.sessions.revoke(issued.path),
+            };
+        }
+        catch (error) {
+            await input.sessions.revoke(issued.path);
+            throw error;
+        }
+    };
+}
+/** Creates the transport-neutral Wake MCP server for the run-bound CLI command. */
+export async function createArtifactMcpServerForSession(root, sessions, path, token, options) {
+    const descriptor = await sessions.read(path, token);
+    const accepted = acceptedActivation(root.orchestration, descriptor.workItemId);
+    return createArtifactMcpServer(root.artifacts, {
+        ...descriptor,
+        readableProducers: new Set(descriptor.readableProducers),
+        nextRevisionId: options.nextId,
+        commandContext: () => commandContext(options.now(), descriptor),
+        acceptedActivation: accepted,
+        assertActive: async () => {
+            await sessions.read(path, token);
+        },
+    });
+}
+function commandContext(occurredAt, descriptor) {
+    return {
+        commandId: `artifact-mcp:${descriptor.runId}:${randomUUID()}`,
+        correlationId: correlationId(`artifact:${descriptor.runId}`),
+        actor: { kind: EventActorKind.System, id: 'wake-mcp' },
+        occurredAt,
+    };
+}
+function acceptedActivation(orchestration, workItemId) {
+    let accepted;
+    return async (activationId) => {
+        accepted ??= orchestration
+            .listForWorkItem(workItemId)
+            .then((workflows) => new Set(workflows.flatMap((workflow) => workflow.acceptedOutcomes)));
+        return (await accepted).has(activationId);
+    };
+}
+async function upstreamProducers(orchestration, workflow, workflowInstanceId, stage) {
+    if (stage === undefined)
+        return [];
+    const definition = await orchestration.definitionFor(workflow);
+    return [...upstreamStages(definition, stage)].map((candidate) => producerFor(workflowInstanceId, candidate));
+}
+function upstreamStages(definition, stage) {
+    const predecessors = new Map();
+    for (const [source, configured] of Object.entries(definition.stages)) {
+        for (const route of Object.values(configured.on)) {
+            for (const target of [route.target, route.reentryTarget]) {
+                if (target.kind !== TransitionTargetKind.Stage)
+                    continue;
+                const entries = predecessors.get(target.stage) ?? new Set();
+                entries.add(source);
+                predecessors.set(target.stage, entries);
+            }
+        }
+    }
+    const found = new Set();
+    const pending = [...(predecessors.get(stage) ?? [])];
+    while (pending.length > 0) {
+        const candidate = pending.pop();
+        if (candidate === stage || found.has(candidate))
+            continue;
+        found.add(candidate);
+        pending.push(...(predecessors.get(candidate) ?? []));
+    }
+    return found;
+}
+function producerFor(workflowInstanceId, stage, activity) {
+    return `${workflowInstanceId}/${stage ?? `activation-${activity ?? ''}`}`;
+}
+function artifactPrompt(manifest) {
+    return [
+        'Wake artifacts are available through the trusted Wake MCP tools.',
+        'The manifest contains metadata only; read content explicitly when useful. Write output through Wake tools, not Git.',
+        JSON.stringify(manifest.map(({ location: _location, ...artifact }) => artifact)),
+    ].join('\n');
+}

package/dist/src/bootstrap/composition-root.d.ts

@@ -1,5 +1,6 @@
 import { type CheckpointStore, type EventJournal, type ProcessorRunSerialiser, type ProcessorStateStore, type ProjectionStore } from '@atolis-hq/eventing';
 import { createPullRequestService, type ActivityRegistry } from '../activities/index.js';
+import { createArtifactService } from '../artifacts/index.js';
 import { createControlPlaneService, createRunnerControlService, type ActivationScheduler, type ActivationSchedulerSubscriber, type IntakePipeline, type RunnerPipeline, type ScheduleCheckpointStore } from '../control-plane/index.js';
 import { createConversationService } from '../conversations/index.js';
 import { RecoveryService, TranscriptStore, createExecutionService, type FakeScenarioResolver, type Runner } from '../execution/index.js';
@@ -48,6 +49,7 @@ export interface CompositionRoot {
     readonly processorState: ProcessorStateStore;
     readonly activities: ActivityRegistry;
     readonly work: ReturnType<typeof createWorkService>;
+    readonly artifacts: ReturnType<typeof createArtifactService>;
     readonly conversations: ReturnType<typeof createConversationService>;
     readonly resources: ReturnType<typeof createResourceService>;
     readonly pullRequests: ReturnType<typeof createPullRequestService>;

package/dist/src/bootstrap/composition-root.js

@@ -1,4 +1,6 @@
+import { acquireFileLock } from '@atolis-hq/eventing-filesystem';
 import { createPullRequestService } from '../activities/index.js';
+import { FileArtifactMcpSessionStore, FileArtifactStore, createArtifactService, } from '../artifacts/index.js';
 import { DispatchPolicy, createActivationScheduler, createActivationSchedulerSubscriber, createControlPlaneService, createDurableRunnerIneligibility, createRunnerControlService, } from '../control-plane/index.js';
 import { createConversationService } from '../conversations/index.js';
 import { ExecutionCancellationReason, ExternalExecutionState, GitWorkspaceProvider, RecoveryService, TranscriptStore, createExecutionService, createRunnerMemoryProfileDecorator, } from '../execution/index.js';
@@ -9,6 +11,7 @@ import { createResourceLookup, createResourceService, resourceId, } from '../res
 import { createWorkService } from '../work/index.js';
 import { createFileActivationSchedulerSerialiser } from './activation-scheduler-serialiser.js';
 import { createBuiltInActivityRegistry } from './activity-registry.js';
+import { createArtifactMcpProvisioner } from './artifact-mcp.js';
 import { loadConfig } from './config/load-config.js';
 import { EventProcessorRuntime } from './event-processor-runtime.js';
 import { loadFakeScenarios } from './fake-scenarios.js';
@@ -37,6 +40,8 @@ export async function createCompositionRoot(wakeRoot, options = {}) {
     const { journal, projections, checkpoints, processorState, subscriptionRunSerialiser } = composePersistence(paths, clock, options);
     const processorRuntime = new EventProcessorRuntime(journal, checkpoints, subscriptionRunSerialiser, clock);
     const work = createWorkService(journal);
+    const artifacts = createArtifactService(journal, new FileArtifactStore(paths.artifactsRoot), config.artifacts);
+    const artifactMcpSessions = new FileArtifactMcpSessionStore(paths.artifactsRoot, () => clock.now().toISOString());
     const conversations = createConversationService(journal);
     const lookup = createResourceLookup({ journal, projections });
     const resources = createResourceService(journal, lookup);
@@ -59,6 +64,11 @@ export async function createCompositionRoot(wakeRoot, options = {}) {
                 throw new Error('Workspace resource ' + id + ' does not identify a GitHub repository');
             return 'https://github.com/' + match[1] + '.git';
         },
+    }, {
+        tryAcquire: (path) => acquireFileLock(path, {
+            staleAfterMs: 0,
+            staleRequiresDeadProcess: true,
+        }),
     }, undefined, undefined, config.execution.workspaceHooks?.prepare);
     const transcriptStore = config.transcripts.enabled
         ? (options.transcriptStore ?? new TranscriptStore(paths.transcriptsRoot))
@@ -79,6 +89,14 @@ export async function createCompositionRoot(wakeRoot, options = {}) {
         clock,
         ids,
         runners: createRunnerRegistry(config.execution, fakeScenarios, decorateRunner),
+        mcp: createArtifactMcpProvisioner({
+            artifacts,
+            orchestration,
+            sessions: artifactMcpSessions,
+            wakeRoot: paths.wakeRoot,
+            now: () => clock.now().toISOString(),
+            nextId: () => ids.next('artifact'),
+        }),
         reportRunnerQuota: createRunnerQuotaReporter(journal, clock, ids),
         ...(transcriptStore !== undefined
             ? {
@@ -174,6 +192,7 @@ export async function createCompositionRoot(wakeRoot, options = {}) {
         processorState,
         activities,
         work,
+        artifacts,
         conversations,
         resources,
         pullRequests,

package/dist/src/bootstrap/config/root-schema.d.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { type ActivitiesConfig } from '../../activities/index.js';
+import { type ArtifactsConfig } from '../../artifacts/index.js';
 import { type ControlPlaneConfig } from '../../control-plane/index.js';
 import { type ExecutionConfig } from '../../execution/index.js';
 import { type IntegrationsConfig } from '../../integrations/index.js';
@@ -262,6 +263,10 @@ export declare const rootConfigSchema: z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         retentionMs: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strict>>;
+    artifacts: z.ZodDefault<z.ZodObject<{
+        maxWriteBytes: z.ZodDefault<z.ZodNumber>;
+        maxWorkItemBytes: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>;
     execution: z.ZodObject<{
         agentRunners: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
             model: z.ZodOptional<z.ZodString>;
@@ -458,6 +463,7 @@ export interface ResolvedWakeModulesConfig {
     readonly activities: ActivitiesConfig;
     readonly orchestration: z.infer<typeof orchestrationConfigSchema>;
     readonly transcripts: z.infer<typeof transcriptsConfigSchema>;
+    readonly artifacts: ArtifactsConfig;
     readonly execution: ExecutionConfig;
     readonly controlPlane: ControlPlaneConfig;
     readonly integrations: IntegrationsConfig;

package/dist/src/bootstrap/config/root-schema.js

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { activitiesConfigSchema } from '../../activities/index.js';
+import { artifactsConfigSchema } from '../../artifacts/index.js';
 import { controlPlaneConfigSchema } from '../../control-plane/index.js';
 import { executionConfigSchema } from '../../execution/index.js';
 import { integrationsConfigSchema } from '../../integrations/index.js';
@@ -140,6 +141,10 @@ export const rootConfigSchema = z
     activities: activitiesConfigSchema.default({}),
     orchestration: orchestrationConfigSchema,
     transcripts: transcriptsConfigSchema,
+    artifacts: artifactsConfigSchema.default({
+        maxWriteBytes: 25 * 1024 * 1024,
+        maxWorkItemBytes: 250 * 1024 * 1024,
+    }),
     execution: executionConfigSchema,
     controlPlane: controlPlaneConfigSchema,
     integrations: integrationsConfigSchema,

package/dist/src/bootstrap/paths.d.ts

@@ -6,6 +6,7 @@ export interface WakePaths {
     readonly checkpointsRoot: string;
     readonly locksRoot: string;
     readonly transcriptsRoot: string;
+    readonly artifactsRoot: string;
     readonly containerHomeRoot: string;
     readonly workspacesRoot: string;
 }

package/dist/src/bootstrap/paths.js

@@ -9,6 +9,7 @@ export function resolveWakePaths(wakeRoot) {
         checkpointsRoot: join(dataRoot, 'checkpoints'),
         locksRoot: join(dataRoot, 'locks'),
         transcriptsRoot: join(dataRoot, 'transcripts'),
+        artifactsRoot: join(dataRoot, 'artifacts'),
         containerHomeRoot: join(dataRoot, 'container-home'),
         workspacesRoot: join(wakeRoot, 'workspaces'),
     };

package/dist/src/bootstrap/projection-runtime.js

@@ -1,6 +1,7 @@
 import { ProjectionRebuilder, createProjectionProcessor, } from '@atolis-hq/eventing';
 import { createInMemoryProcessorRunSerialiser } from '@atolis-hq/eventing/memory';
 import { activityProjectionDefinitions } from '../activities/index.js';
+import { artifactProjection } from '../artifacts/index.js';
 import { controlPlaneProjectionDefinitions } from '../control-plane/index.js';
 import { conversationProjection } from '../conversations/index.js';
 import { executionProjection, runsByWorkflowInstanceProjection } from '../execution/index.js';
@@ -11,6 +12,7 @@ import { workProjection } from '../work/index.js';
 import { analyticsProjection } from './analytics-projection.js';
 import { boardProjection } from './board-projection.js';
 export const runtimeProjectionDefinitions = [
+    artifactProjection,
     conversationProjection,
     workProjection,
     resourceProjection,

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;
 }