@atolis-hq/wake 0.4.48 → 0.4.50

package/README.md

@@ -109,6 +109,9 @@ For more detail, see [docs/vision.md](docs/vision.md) and
   `workspaces/` at the top level for
   what you edit or browse day-to-day, with durable/internal state (events,
   projections, runs, logs, sandbox auth) nested under a hidden `.wake/`.
+- **Durable handoffs.** Agent stages can publish work-item artifacts outside
+  Git workspaces. Wake passes only a scoped manifest to later agents, which
+  fetch content on demand through a run-bound MCP capability.
 - **Sandbox-oriented execution.** Wake can run from a persistent Docker sandbox
   with durable auth state and mounted Wake home data.
 - **Runner agnostic.** Claude Code, Codex, Cursor, and fake runners sit behind

package/dist/src/activities/agent/agent-activity.js

@@ -12,6 +12,8 @@ export function createAgentActivity(templates, contextReader) {
                 resumeStartedAt: context.resumeStartedAt,
                 usageBaseline: context.usageBaseline,
                 workspace: context.workspace,
+                mcpServers: context.mcpServers,
+                mcpPrompt: context.mcpPrompt,
                 reportRunnerTimeout: context.reportRunnerTimeout,
             });
             await capturePrompt(context, invocation.workItemId, request);
@@ -77,7 +79,7 @@ async function recordTranscript(context, write) {
 async function agentRequest(invocation, templates, contextReader, context) {
     const input = invocation.input;
     const template = await resolveTemplate(input.template, invocation.workItemId, templates, contextReader, context.resumeSessionId !== undefined, context.resumeStartedAt);
-    return requestFrom(input, context.runId ?? invocation.activationId, template, context.runnerContext, context.resumeSessionId, context.usageBaseline, context.workspace, context.reportRunnerTimeout);
+    return requestFrom(input, context.runId ?? invocation.activationId, template, context.runnerContext, context.resumeSessionId, context.usageBaseline, context.workspace, context.mcpServers, context.mcpPrompt, context.reportRunnerTimeout);
 }
 async function resolveTemplate(name, workItemId, templates, contextReader, isResume, observedSince) {
     if (name === undefined)
@@ -133,10 +135,10 @@ function escapeUntrustedJson(json) {
 }
 // The runner request maps each independently optional execution concern.
 // eslint-disable-next-line max-params, complexity
-function requestFrom(input, runId, template, runnerContext, resumeSessionId, usageBaseline, workspace, reportRunnerTimeout) {
+function requestFrom(input, runId, template, runnerContext, resumeSessionId, usageBaseline, workspace, mcpServers, mcpPrompt, reportRunnerTimeout) {
     return {
         runId,
-        prompt: input.prompt ?? template.prompt,
+        prompt: appendMcpPrompt(input.prompt ?? template.prompt, mcpPrompt),
         ...modelField(input.model ?? template?.model ?? runnerContext?.model),
         ...effortField(runnerContext?.effort),
         allowedTools: input.allowedTools ?? template?.allowedTools ?? [],
@@ -145,9 +147,13 @@ function requestFrom(input, runId, template, runnerContext, resumeSessionId, usa
         ...(resumeSessionId === undefined ? {} : { resumeSessionId }),
         ...(usageBaseline === undefined ? {} : { usageBaseline }),
         ...workspaceFields(workspace),
+        ...(mcpServers === undefined ? {} : { mcpServers }),
         ...(reportRunnerTimeout === undefined ? {} : { onTimeout: reportRunnerTimeout }),
     };
 }
+function appendMcpPrompt(prompt, mcpPrompt) {
+    return mcpPrompt === undefined ? prompt : `${prompt}\n\n${mcpPrompt}`;
+}
 function workspaceFields(workspace) {
     return workspace === undefined
         ? {}

package/dist/src/activities/contracts/activity.d.ts

@@ -54,6 +54,12 @@ export interface AgentRunnerPort {
             readonly cacheRead?: number;
             readonly cacheWrite?: number;
         };
+        readonly mcpServers?: readonly {
+            readonly name: string;
+            readonly command: string;
+            readonly args?: readonly string[];
+            readonly env?: Readonly<Record<string, string>>;
+        }[];
         readonly context?: {
             readonly runnerName: string;
             readonly action: string;
@@ -107,6 +113,14 @@ export interface ActivityExecutionContext {
         readonly mode: ActivityWorkspaceMode;
     };
     readonly runner?: AgentRunnerPort;
+    readonly mcpServers?: readonly {
+        readonly name: string;
+        readonly command: string;
+        readonly args?: readonly string[];
+        readonly env?: Readonly<Record<string, string>>;
+    }[];
+    /** Wake-owned capability inventory appended after the operator prompt. */
+    readonly mcpPrompt?: string;
     readonly runnerContext?: {
         readonly runnerName: string;
         /** CLI identity configured for the resolved runner. */

package/dist/src/artifacts/application/artifact-projection.d.ts

@@ -0,0 +1,3 @@
+import type { ProjectionDefinition } from '@atolis-hq/eventing';
+import type { ArtifactWorkItemView } from '../contracts/views.js';
+export declare const artifactProjection: ProjectionDefinition<ArtifactWorkItemView | null>;

package/dist/src/artifacts/application/artifact-projection.js

@@ -0,0 +1,15 @@
+import { selectArtifactEvent } from '../contracts/events.js';
+import { ArtifactStreamKind } from '../contracts/streams.js';
+import { applyArtifactEvent } from '../domain/artifact-work-item.js';
+export const artifactProjection = {
+    name: ArtifactStreamKind.WorkItem,
+    select(event) {
+        const owned = selectArtifactEvent(event);
+        return owned === null ? null : { key: owned.stream.id };
+    },
+    initial: () => null,
+    project(previous, event) {
+        const owned = selectArtifactEvent(event);
+        return owned === null ? previous : applyArtifactEvent(previous, owned);
+    },
+};

package/dist/src/artifacts/application/artifact-repository.d.ts

@@ -0,0 +1,13 @@
+import type { EventJournal } from '@atolis-hq/eventing';
+import { type ArtifactEvent, type ArtifactEventData } from '../contracts/events.js';
+import type { ArtifactWorkItemId } from '../contracts/identifiers.js';
+import type { ArtifactWorkItemView } from '../contracts/views.js';
+export declare class ArtifactRepository {
+    private readonly journal;
+    constructor(journal: EventJournal);
+    load(id: ArtifactWorkItemId): Promise<{
+        sequence: number;
+        view: ArtifactWorkItemView | null;
+    }>;
+    append(id: ArtifactWorkItemId, sequence: number, drafts: readonly ArtifactEventData[]): Promise<ArtifactEvent[]>;
+}

package/dist/src/artifacts/application/artifact-repository.js

@@ -0,0 +1,19 @@
+import { decodeArtifactEvent, selectArtifactEvent, } from '../contracts/events.js';
+import { artifactWorkItemStream } from '../contracts/streams.js';
+import { foldArtifactWorkItem } from '../domain/artifact-work-item.js';
+export class ArtifactRepository {
+    journal;
+    constructor(journal) {
+        this.journal = journal;
+    }
+    async load(id) {
+        const events = await this.journal.readStream(artifactWorkItemStream(id));
+        return {
+            sequence: events.length,
+            view: foldArtifactWorkItem(events.map(selectArtifactEvent).filter((event) => event !== null)),
+        };
+    }
+    async append(id, sequence, drafts) {
+        return (await this.journal.appendToStream(artifactWorkItemStream(id), sequence, drafts)).map(decodeArtifactEvent);
+    }
+}

package/dist/src/artifacts/application/artifact-service.d.ts

@@ -0,0 +1,40 @@
+import { type CommandContext } from '@atolis-hq/eventing';
+import type { WorkItemId } from '../../work/index.js';
+import type { ArtifactsConfig } from '../contracts/config.js';
+import { type ArtifactPath } from '../contracts/paths.js';
+import type { ArtifactWorkItemView } from '../contracts/views.js';
+import type { FileArtifactStore } from '../infrastructure/file-artifact-store.js';
+import { ArtifactRepository } from './artifact-repository.js';
+export interface ArtifactService {
+    stageRevision(command: StageArtifactRevision, scope: ArtifactWriteScope, context: CommandContext): Promise<ArtifactWorkItemView>;
+    stageTombstone(command: StageArtifactTombstone, scope: ArtifactWriteScope, context: CommandContext): Promise<ArtifactWorkItemView>;
+    get(workItemId: string): Promise<ArtifactWorkItemView | null>;
+    latestPublished(workItemId: string, acceptedActivation: (activationId: string) => Promise<boolean>): Promise<ReadonlyArray<ArtifactWorkItemView['revisions'][number]>>;
+    readAcceptedRevision(workItemId: string, revisionId: string, acceptedActivation: (activationId: string) => Promise<boolean>): Promise<{
+        readonly revision: ArtifactWorkItemView['revisions'][number];
+        readonly bytes: Uint8Array;
+    } | null>;
+    visibleTo(scope: ArtifactReadScope, acceptedActivation: (activationId: string) => Promise<boolean>): Promise<ReadonlyArray<ArtifactWorkItemView['revisions'][number]>>;
+    read(location: string): Promise<Uint8Array>;
+}
+export interface StageArtifactRevision {
+    readonly revisionId: string;
+    readonly path: ArtifactPath | string;
+    readonly bytes: Uint8Array;
+    readonly mediaType?: string;
+}
+export interface StageArtifactTombstone {
+    readonly revisionId: string;
+    readonly path: ArtifactPath | string;
+}
+/** Trusted execution context, never supplied by an MCP tool request. */
+export interface ArtifactWriteScope {
+    readonly workItemId: WorkItemId;
+    readonly producer: string;
+    readonly runId: string;
+    readonly activationId: string;
+}
+export interface ArtifactReadScope extends ArtifactWriteScope {
+    readonly readableProducers: ReadonlySet<string>;
+}
+export declare function createArtifactService(journal: ConstructorParameters<typeof ArtifactRepository>[0], store: FileArtifactStore, config: ArtifactsConfig): ArtifactService;

package/dist/src/artifacts/application/artifact-service.js

@@ -0,0 +1,128 @@
+import { EventSourceKind } from '@atolis-hq/eventing';
+import { createArtifactEventData } from '../contracts/event-factory.js';
+import { ArtifactEventType } from '../contracts/events.js';
+import { artifactWorkItemIdForWorkItem } from '../contracts/identifiers.js';
+import { artifactPath } from '../contracts/paths.js';
+import { ArtifactRepository } from './artifact-repository.js';
+// The public service keeps the tightly coupled idempotent staging operations adjacent.
+// eslint-disable-next-line max-lines-per-function
+export function createArtifactService(journal, store, config) {
+    const repository = new ArtifactRepository(journal);
+    return {
+        async stageRevision(command, scope, context) {
+            const id = artifactWorkItemIdForWorkItem(scope.workItemId);
+            const loaded = await repository.load(id);
+            if (loaded.view?.revisions.some((revision) => revision.revisionId === command.revisionId))
+                return loaded.view;
+            if (command.bytes.byteLength > config.maxWriteBytes)
+                throw new Error(`Artifact write exceeds ${config.maxWriteBytes} byte limit`);
+            const retained = loaded.view?.revisions.reduce((total, revision) => total + (revision.byteLength ?? 0), 0) ??
+                0;
+            if (retained + command.bytes.byteLength > config.maxWorkItemBytes)
+                throw new Error(`Artifact work item exceeds ${config.maxWorkItemBytes} byte limit`);
+            const path = artifactPath(String(command.path));
+            const stored = await store.write({
+                workItemId: scope.workItemId,
+                revisionId: command.revisionId,
+                path,
+                bytes: command.bytes,
+            });
+            const [event] = await repository.append(id, loaded.sequence, [
+                createArtifactEventData({
+                    eventId: `${context.commandId}:${ArtifactEventType.RevisionStaged}:${command.revisionId}`,
+                    eventType: ArtifactEventType.RevisionStaged,
+                    occurredAt: context.occurredAt,
+                    correlationId: context.correlationId,
+                    causationId: context.commandId,
+                    actor: context.actor,
+                    source: { kind: EventSourceKind.Internal, id: 'artifact-service' },
+                    payload: {
+                        workItemId: scope.workItemId,
+                        revisionId: command.revisionId,
+                        producer: scope.producer,
+                        path,
+                        runId: scope.runId,
+                        activationId: scope.activationId,
+                        ...stored,
+                        ...(command.mediaType === undefined ? {} : { mediaType: command.mediaType }),
+                    },
+                }),
+            ]);
+            const view = event === undefined ? null : (await repository.load(id)).view;
+            if (view === null)
+                throw new Error(`Artifact work item ${scope.workItemId} was not created`);
+            return view;
+        },
+        async stageTombstone(command, scope, context) {
+            const id = artifactWorkItemIdForWorkItem(scope.workItemId);
+            const loaded = await repository.load(id);
+            if (loaded.view?.revisions.some((revision) => revision.revisionId === command.revisionId))
+                return loaded.view;
+            const [event] = await repository.append(id, loaded.sequence, [
+                createArtifactEventData({
+                    eventId: `${context.commandId}:${ArtifactEventType.TombstoneStaged}:${command.revisionId}`,
+                    eventType: ArtifactEventType.TombstoneStaged,
+                    occurredAt: context.occurredAt,
+                    correlationId: context.correlationId,
+                    causationId: context.commandId,
+                    actor: context.actor,
+                    source: { kind: EventSourceKind.Internal, id: 'artifact-service' },
+                    payload: {
+                        workItemId: scope.workItemId,
+                        revisionId: command.revisionId,
+                        producer: scope.producer,
+                        path: artifactPath(String(command.path)),
+                        runId: scope.runId,
+                        activationId: scope.activationId,
+                    },
+                }),
+            ]);
+            const view = event === undefined ? null : (await repository.load(id)).view;
+            if (view === null)
+                throw new Error(`Artifact work item ${scope.workItemId} was not created`);
+            return view;
+        },
+        async get(workItemId) {
+            return (await repository.load(artifactWorkItemIdForWorkItem(workItemId))).view;
+        },
+        async latestPublished(workItemId, acceptedActivation) {
+            const view = await repository.load(artifactWorkItemIdForWorkItem(workItemId));
+            const visible = [];
+            const latest = new Map();
+            for (const revision of view.view?.revisions ?? []) {
+                if (!(await acceptedActivation(revision.activationId)))
+                    continue;
+                latest.set(`${revision.producer}\u0000${revision.path}`, revision);
+            }
+            for (const revision of latest.values())
+                if (!revision.deleted)
+                    visible.push(revision);
+            return visible;
+        },
+        async visibleTo(scope, acceptedActivation) {
+            const view = await repository.load(artifactWorkItemIdForWorkItem(scope.workItemId));
+            const latest = new Map();
+            for (const revision of view.view?.revisions ?? []) {
+                const published = scope.readableProducers.has(revision.producer) &&
+                    (await acceptedActivation(revision.activationId));
+                const ownStaged = revision.producer === scope.producer &&
+                    revision.runId === scope.runId &&
+                    revision.activationId === scope.activationId;
+                if (published || ownStaged)
+                    latest.set(`${revision.producer}\u0000${revision.path}`, revision);
+            }
+            return [...latest.values()].filter((revision) => !revision.deleted);
+        },
+        async readAcceptedRevision(workItemId, revisionId, acceptedActivation) {
+            const view = await repository.load(artifactWorkItemIdForWorkItem(workItemId));
+            const revision = (view.view?.revisions ?? []).find((candidate) => candidate.revisionId === revisionId);
+            if (revision === undefined ||
+                revision.deleted ||
+                revision.location === undefined ||
+                !(await acceptedActivation(revision.activationId)))
+                return null;
+            return { revision, bytes: await store.read(revision.location) };
+        },
+        read: (location) => store.read(location),
+    };
+}

package/dist/src/artifacts/contracts/config.d.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+export declare const artifactsConfigSchema: z.ZodObject<{
+    maxWriteBytes: z.ZodDefault<z.ZodNumber>;
+    maxWorkItemBytes: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+export type ArtifactsConfig = z.infer<typeof artifactsConfigSchema>;

package/dist/src/artifacts/contracts/config.js

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+export const artifactsConfigSchema = z
+    .object({
+    maxWriteBytes: z
+        .number()
+        .int()
+        .positive()
+        .default(25 * 1024 * 1024),
+    maxWorkItemBytes: z
+        .number()
+        .int()
+        .positive()
+        .default(250 * 1024 * 1024),
+})
+    .strict()
+    .refine((value) => value.maxWorkItemBytes >= value.maxWriteBytes, {
+    message: 'artifacts.maxWorkItemBytes must be at least artifacts.maxWriteBytes',
+    path: ['maxWorkItemBytes'],
+});

package/dist/src/artifacts/contracts/event-factory.d.ts

@@ -0,0 +1,6 @@
+import { type EventDataInput } from '@atolis-hq/eventing';
+import { type ArtifactEventData, type ArtifactEventPayloads } from './events.js';
+export type ArtifactEventDataInput = {
+    [Type in keyof ArtifactEventPayloads]: EventDataInput<Type, ArtifactEventPayloads[Type]>;
+}[keyof ArtifactEventPayloads];
+export declare function createArtifactEventData(input: ArtifactEventDataInput): ArtifactEventData;

package/dist/src/artifacts/contracts/event-factory.js

@@ -0,0 +1,10 @@
+import { createEventData } from '@atolis-hq/eventing';
+import { ArtifactEventType } from './events.js';
+export function createArtifactEventData(input) {
+    switch (input.eventType) {
+        case ArtifactEventType.RevisionStaged:
+            return createEventData(input);
+        case ArtifactEventType.TombstoneStaged:
+            return createEventData(input);
+    }
+}

package/dist/src/artifacts/contracts/events.d.ts

@@ -0,0 +1,33 @@
+import { type EventDataUnion, type EventEnvelope, type EventUnion } from '@atolis-hq/eventing';
+import { type WorkItemId } from '../../work/index.js';
+import { type ArtifactWorkItemStreamRef } from './streams.js';
+export declare const ArtifactEventType: {
+    readonly RevisionStaged: "artifact.revision-staged";
+    readonly TombstoneStaged: "artifact.tombstone-staged";
+};
+export interface ArtifactEventPayloads {
+    readonly [ArtifactEventType.RevisionStaged]: {
+        readonly workItemId: WorkItemId;
+        readonly revisionId: string;
+        readonly producer: string;
+        readonly path: string;
+        readonly runId: string;
+        readonly activationId: string;
+        readonly location: string;
+        readonly digest: string;
+        readonly byteLength: number;
+        readonly mediaType?: string | undefined;
+    };
+    readonly [ArtifactEventType.TombstoneStaged]: {
+        readonly workItemId: WorkItemId;
+        readonly revisionId: string;
+        readonly producer: string;
+        readonly path: string;
+        readonly runId: string;
+        readonly activationId: string;
+    };
+}
+export type ArtifactEvent = EventUnion<ArtifactEventPayloads, ArtifactWorkItemStreamRef>;
+export type ArtifactEventData = EventDataUnion<ArtifactEventPayloads>;
+export declare function decodeArtifactEvent(event: EventEnvelope): ArtifactEvent;
+export declare function selectArtifactEvent(event: EventEnvelope): ArtifactEvent | null;

package/dist/src/artifacts/contracts/events.js

@@ -0,0 +1,59 @@
+import { eventDataSchema, eventEnvelopeSchema, } from '@atolis-hq/eventing';
+import { z } from 'zod';
+import { brandedStringSchema } from '../../kernel/index.js';
+import { workItemId } from '../../work/index.js';
+import { artifactWorkItemId, artifactWorkItemIdForWorkItem } from './identifiers.js';
+import { artifactPath } from './paths.js';
+import { ArtifactStreamKind } from './streams.js';
+export const ArtifactEventType = {
+    RevisionStaged: 'artifact.revision-staged',
+    TombstoneStaged: 'artifact.tombstone-staged',
+};
+const stream = z
+    .object({
+    kind: z.literal(ArtifactStreamKind.WorkItem),
+    id: brandedStringSchema(artifactWorkItemId),
+})
+    .strict();
+const staged = z
+    .object({
+    workItemId: brandedStringSchema(workItemId),
+    revisionId: z.string().min(1),
+    producer: z.string().min(1),
+    path: z.string().transform(artifactPath),
+    runId: z.string().min(1),
+    activationId: z.string().min(1),
+})
+    .strict();
+const schema = z.union([
+    eventEnvelopeSchema.extend({
+        event: eventDataSchema.extend({
+            eventType: z.literal(ArtifactEventType.RevisionStaged),
+            payload: staged.extend({
+                location: z.string().min(1),
+                digest: z.string().regex(/^[a-f0-9]{64}$/),
+                byteLength: z.number().int().nonnegative(),
+                mediaType: z.string().min(1).optional(),
+            }),
+        }),
+        stream,
+    }),
+    eventEnvelopeSchema.extend({
+        event: eventDataSchema.extend({
+            eventType: z.literal(ArtifactEventType.TombstoneStaged),
+            payload: staged,
+        }),
+        stream,
+    }),
+]);
+export function decodeArtifactEvent(event) {
+    const result = schema.safeParse(event);
+    if (!result.success)
+        throw new Error(`Invalid Artifact event ${event.event.eventId}: ${result.error.message}`);
+    if (result.data.stream.id !== artifactWorkItemIdForWorkItem(result.data.event.payload.workItemId))
+        throw new Error(`Artifact event ${event.event.eventId} belongs to another work item stream`);
+    return result.data;
+}
+export function selectArtifactEvent(event) {
+    return event.event.eventType.startsWith('artifact.') ? decodeArtifactEvent(event) : null;
+}

package/dist/src/artifacts/contracts/identifiers.d.ts

@@ -0,0 +1,5 @@
+import type { Brand } from '../../kernel/index.js';
+import type { WorkItemId } from '../../work/index.js';
+export type ArtifactWorkItemId = Brand<string, 'ArtifactWorkItemId'>;
+export declare function artifactWorkItemId(value: string): ArtifactWorkItemId;
+export declare function artifactWorkItemIdForWorkItem(workItemId: WorkItemId): ArtifactWorkItemId;

package/dist/src/artifacts/contracts/identifiers.js

@@ -0,0 +1,8 @@
+export function artifactWorkItemId(value) {
+    if (!/^artifact-work-[0-9a-hjkmnp-tv-z]{26}$/.test(value))
+        throw new Error('Invalid ArtifactWorkItemId');
+    return value;
+}
+export function artifactWorkItemIdForWorkItem(workItemId) {
+    return artifactWorkItemId(`artifact-work-${String(workItemId).slice('work-'.length)}`);
+}

package/dist/src/artifacts/contracts/paths.d.ts

@@ -0,0 +1,5 @@
+export type ArtifactPath = string & {
+    readonly __artifactPath: unique symbol;
+};
+/** A logical path, never a path that can escape an artifact owner namespace. */
+export declare function artifactPath(value: string): ArtifactPath;

package/dist/src/artifacts/contracts/paths.js

@@ -0,0 +1,9 @@
+/** A logical path, never a path that can escape an artifact owner namespace. */
+export function artifactPath(value) {
+    if (value.length === 0 ||
+        value.startsWith('/') ||
+        value.includes('\\') ||
+        value.split('/').some((segment) => segment.length === 0 || segment === '.' || segment === '..'))
+        throw new Error('Artifact path must be a normalized relative path');
+    return value;
+}

package/dist/src/artifacts/contracts/streams.d.ts

@@ -0,0 +1,7 @@
+import type { EntityRef } from '../../kernel/index.js';
+import type { ArtifactWorkItemId } from './identifiers.js';
+export declare const ArtifactStreamKind: {
+    readonly WorkItem: "artifact-work-item";
+};
+export type ArtifactWorkItemStreamRef = EntityRef<typeof ArtifactStreamKind.WorkItem, ArtifactWorkItemId>;
+export declare function artifactWorkItemStream(id: ArtifactWorkItemId): ArtifactWorkItemStreamRef;

package/dist/src/artifacts/contracts/streams.js

@@ -0,0 +1,4 @@
+export const ArtifactStreamKind = { WorkItem: 'artifact-work-item' };
+export function artifactWorkItemStream(id) {
+    return { kind: ArtifactStreamKind.WorkItem, id };
+}

package/dist/src/artifacts/contracts/views.d.ts

@@ -0,0 +1,20 @@
+import type { WorkItemId } from '../../work/index.js';
+import type { ArtifactWorkItemId } from './identifiers.js';
+export interface ArtifactRevisionView {
+    readonly revisionId: string;
+    readonly producer: string;
+    readonly path: string;
+    readonly runId: string;
+    readonly activationId: string;
+    readonly occurredAt: string;
+    readonly deleted: boolean;
+    readonly location?: string;
+    readonly digest?: string;
+    readonly byteLength?: number;
+    readonly mediaType?: string;
+}
+export interface ArtifactWorkItemView {
+    readonly artifactWorkItemId: ArtifactWorkItemId;
+    readonly workItemId: WorkItemId;
+    readonly revisions: readonly ArtifactRevisionView[];
+}

package/dist/src/artifacts/contracts/views.js

@@ -0,0 +1 @@
+export {};

package/dist/src/artifacts/domain/artifact-work-item.d.ts

@@ -0,0 +1,4 @@
+import { type ArtifactEvent } from '../contracts/events.js';
+import type { ArtifactWorkItemView } from '../contracts/views.js';
+export declare function foldArtifactWorkItem(events: readonly ArtifactEvent[]): ArtifactWorkItemView | null;
+export declare function applyArtifactEvent(view: ArtifactWorkItemView | null, event: ArtifactEvent): ArtifactWorkItemView;

package/dist/src/artifacts/domain/artifact-work-item.js

@@ -0,0 +1,42 @@
+import { ArtifactEventType, } from '../contracts/events.js';
+export function foldArtifactWorkItem(events) {
+    let view = null;
+    for (const event of events)
+        view = applyArtifactEvent(view, event);
+    return view;
+}
+export function applyArtifactEvent(view, event) {
+    const payload = event.event.payload;
+    const current = view ?? {
+        artifactWorkItemId: event.stream.id,
+        workItemId: payload.workItemId,
+        revisions: [],
+    };
+    if (current.revisions.some((revision) => revision.revisionId === payload.revisionId))
+        return current;
+    const common = {
+        revisionId: payload.revisionId,
+        producer: payload.producer,
+        path: payload.path,
+        runId: payload.runId,
+        activationId: payload.activationId,
+        occurredAt: event.event.occurredAt,
+    };
+    if (event.event.eventType === ArtifactEventType.TombstoneStaged)
+        return { ...current, revisions: [...current.revisions, { ...common, deleted: true }] };
+    const revision = payload;
+    return {
+        ...current,
+        revisions: [
+            ...current.revisions,
+            {
+                ...common,
+                deleted: false,
+                location: revision.location,
+                digest: revision.digest,
+                byteLength: revision.byteLength,
+                ...(revision.mediaType === undefined ? {} : { mediaType: revision.mediaType }),
+            },
+        ],
+    };
+}

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

@@ -0,0 +1,14 @@
+export * from './application/artifact-projection.js';
+export * from './application/artifact-repository.js';
+export * from './application/artifact-service.js';
+export * from './contracts/config.js';
+export * from './contracts/event-factory.js';
+export * from './contracts/events.js';
+export * from './contracts/identifiers.js';
+export * from './contracts/paths.js';
+export * from './contracts/streams.js';
+export * from './contracts/views.js';
+export * from './domain/artifact-work-item.js';
+export * from './infrastructure/file-artifact-store.js';
+export * from './infrastructure/mcp-server.js';
+export * from './infrastructure/mcp-session-store.js';

package/dist/src/artifacts/index.js

@@ -0,0 +1,14 @@
+export * from './application/artifact-projection.js';
+export * from './application/artifact-repository.js';
+export * from './application/artifact-service.js';
+export * from './contracts/config.js';
+export * from './contracts/event-factory.js';
+export * from './contracts/events.js';
+export * from './contracts/identifiers.js';
+export * from './contracts/paths.js';
+export * from './contracts/streams.js';
+export * from './contracts/views.js';
+export * from './domain/artifact-work-item.js';
+export * from './infrastructure/file-artifact-store.js';
+export * from './infrastructure/mcp-server.js';
+export * from './infrastructure/mcp-session-store.js';

package/dist/src/artifacts/infrastructure/file-artifact-store.d.ts

@@ -0,0 +1,22 @@
+import type { ArtifactPath } from '../contracts/paths.js';
+export interface StoredArtifactBytes {
+    readonly location: string;
+    readonly byteLength: number;
+    readonly digest: string;
+}
+/**
+ * Private filesystem byte store. Its locations are opaque implementation
+ * details; durable artifact facts carry the location, digest, and length.
+ */
+export declare class FileArtifactStore {
+    private readonly root;
+    constructor(root: string);
+    write(input: {
+        readonly workItemId: string;
+        readonly revisionId: string;
+        readonly path: ArtifactPath;
+        readonly bytes: Uint8Array;
+    }): Promise<StoredArtifactBytes>;
+    read(location: string): Promise<Uint8Array>;
+    private absolute;
+}