@atolis-hq/wake 0.4.48 → 0.4.50

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.48";
+export const wakeVersion = "v0.4.50";
 /** 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/application/execution-validation.js

@@ -7,12 +7,26 @@ export async function acquireWorkspace(runId, mode, workItemId, resources, provi
     if (provider === undefined)
         throw new Error('Workspace provider is required');
     const repositoryResource = resources.find((resource) => resource.kind === BuiltInResourceKind.Repository) ??
-        resources.find((resource) => resource.kind === BuiltInResourceKind.Issue ||
-            resource.kind === BuiltInResourceKind.PullRequest);
+        resources.find((resource) => resource.kind === BuiltInResourceKind.PullRequest) ??
+        resources.find((resource) => resource.kind === BuiltInResourceKind.Issue);
     if (repositoryResource === undefined)
         throw new Error('Repository Resource is required');
     signal.throwIfAborted();
-    return provider.acquire({ runId, signal, mode, workItemId, repositoryResource });
+    const revision = repositoryResource.revision;
+    const checkoutRevision = repositoryResource.kind === BuiltInResourceKind.Repository ||
+        (repositoryResource.kind === BuiltInResourceKind.PullRequest &&
+            revision !== undefined &&
+            /^(?:[a-f0-9]{40}|[a-f0-9]{64})$/i.test(revision))
+        ? revision
+        : undefined;
+    return provider.acquire({
+        runId,
+        signal,
+        mode,
+        workItemId,
+        repositoryResource,
+        ...(checkoutRevision === undefined ? {} : { checkoutRevision }),
+    });
 }
 export function validateResourceRequirements(requirements, resources) {
     for (const requirement of requirements) {

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/contracts/workspace.d.ts

@@ -9,6 +9,8 @@ export interface WorkspaceRequest {
     readonly mode: typeof WorkspaceMode.ReadOnly | typeof WorkspaceMode.Branch;
     readonly workItemId: WorkItemId;
     readonly repositoryResource: ResourceView;
+    /** Git checkout target, independent of the resource observation revision. */
+    readonly checkoutRevision?: string;
 }
 export interface WorkspaceLease {
     readonly workspaceId: string;
@@ -16,7 +18,7 @@ export interface WorkspaceLease {
     /** Branch actually checked out for this lease, when the provider can attest it. */
     readonly branch?: string | undefined;
     readonly mode: WorkspaceRequest['mode'];
-    /** Ends this Run's use of the workspace; branch-workspace disposal is WorkItem-scoped recovery. */
+    /** Ends this Run's use of the workspace; workspace disposal is WorkItem-scoped recovery. */
     release(): Promise<void>;
 }
 export interface WorkspaceProvider {
@@ -46,3 +48,11 @@ export interface WorkspaceRecoveryFailure {
     readonly path: string;
     readonly message: string;
 }
+/** Process-owned exclusion shared by acquisition and recovery. */
+export interface WorkspaceLockProvider {
+    tryAcquire(path: string): Promise<WorkspaceLock>;
+}
+export interface WorkspaceLock {
+    readonly acquired: boolean;
+    release(): Promise<void>;
+}

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/execution/infrastructure/workspace/git-workspace.d.ts

@@ -1,11 +1,10 @@
-import type { WorkItemId } from '../../../work/index.js';
 import type { RunView } from '../../contracts/views.js';
-import type { WorkspaceProvider, WorkspaceRecovery, WorkspaceRecoveryOptions, WorkspaceRecoveryResult, WorkspaceRequest } from '../../contracts/workspace.js';
+import type { WorkspaceLockProvider, WorkspaceProvider, WorkspaceRecovery, WorkspaceRecoveryOptions, WorkspaceRecoveryResult, WorkspaceRequest } from '../../contracts/workspace.js';
 import { type WorkspacePrepareHook } from './prepare-workspace.js';
 export interface RepositoryCloneResolver {
     cloneLocator(resourceId: string, signal: AbortSignal): Promise<string>;
 }
-export type GitRunner = (arguments_: readonly string[], signal: AbortSignal) => Promise<void>;
+export type GitRunner = (arguments_: readonly string[], signal: AbortSignal) => Promise<string | void>;
 export interface WorkspaceRecoveryFileSystem {
     remove(path: string): Promise<void>;
     canonicalize(path: string): Promise<string>;
@@ -13,17 +12,23 @@ export interface WorkspaceRecoveryFileSystem {
 export declare class GitWorkspaceProvider implements WorkspaceProvider, WorkspaceRecovery {
     private readonly root;
     private readonly resolver;
+    private readonly locks;
     private readonly git;
     private readonly prepareHook?;
     private readonly markerRoot;
     private readonly recoveryFileSystem;
-    constructor(root: string, resolver: RepositoryCloneResolver, git?: GitRunner, recoveryFileSystem?: WorkspaceRecoveryFileSystem, prepareHook?: WorkspacePrepareHook);
+    private readonly pendingReleases;
+    constructor(root: string, resolver: RepositoryCloneResolver, locks: WorkspaceLockProvider, git?: GitRunner, recoveryFileSystem?: WorkspaceRecoveryFileSystem, prepareHook?: WorkspacePrepareHook);
     acquire(request: WorkspaceRequest): Promise<{
         release: () => Promise<void>;
-        branch?: WorkItemId;
+        branch?: string;
         workspaceId: string;
         path: string;
         mode: "read-only" | "branch";
     }>;
+    private releaseWorkspaceLock;
+    private prepareCheckout;
+    private reuseCheckout;
+    private validateLegacyCheckout;
     recover(runs: readonly RunView[], options?: WorkspaceRecoveryOptions): Promise<WorkspaceRecoveryResult>;
 }