@atolis-hq/wake 0.2.97 → 0.3.0

package/dist/src/execution/infrastructure/transcript-store.js

@@ -0,0 +1,223 @@
+import { createHash } from 'node:crypto';
+import { mkdir, readdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { TranscriptGroupKind, } from '../contracts/vocabulary.js';
+export class TranscriptStore {
+    transcriptsRoot;
+    fileSystem;
+    constructor(transcriptsRoot, fileSystem = { remove: rm }) {
+        this.transcriptsRoot = transcriptsRoot;
+        this.fileSystem = fileSystem;
+    }
+    async capturePrompt(capture) {
+        const timestamp = timestampForFile(capture.timestamp);
+        const directory = this.stagingDirectory(capture.workItemId, capture.runId);
+        await mkdir(directory, { recursive: true });
+        await writeFile(join(directory, messageFile(timestamp, capture.runId, 'prompt')), capture.text, 'utf8');
+    }
+    async captureResponse(capture) {
+        const timestamp = timestampForFile(capture.timestamp);
+        const group = capture.sessionId === undefined
+            ? runGroup(capture.runId)
+            : sessionGroup(capture.cli, capture.sessionId);
+        const destination = this.groupDirectory(capture.workItemId, group);
+        await this.moveStagedPrompt(capture.workItemId, capture.runId, destination);
+        await writeFile(join(destination, messageFile(timestamp, capture.runId, 'response')), capture.text, 'utf8');
+    }
+    async finalisePrompt(capture) {
+        const staging = this.stagingDirectory(capture.workItemId, capture.runId);
+        const promptFiles = (await filesOrEmpty(staging)).filter((file) => file.endsWith('.prompt.txt'));
+        if (promptFiles.length === 0)
+            return;
+        const destination = this.groupDirectory(capture.workItemId, runGroup(capture.runId));
+        await mkdir(destination, { recursive: true });
+        for (const promptFile of promptFiles) {
+            await rename(join(staging, promptFile), join(destination, promptFile));
+        }
+        await this.fileSystem.remove(staging, { recursive: true, force: true });
+    }
+    async listGroups(workItemId) {
+        const groups = [];
+        for (const name of await filesOrEmpty(this.workItemDirectory(workItemId))) {
+            const parsed = parseGroup(name);
+            if (parsed === undefined)
+                continue;
+            const messages = await this.readGroup(workItemId, name);
+            const latest = messages.at(-1);
+            if (latest === undefined)
+                continue;
+            groups.push({
+                ...parsed,
+                latestAt: latest.timestamp,
+                runIds: [...new Set(messages.map((message) => message.runId))],
+            });
+        }
+        return groups.sort((left, right) => {
+            if (left.kind !== right.kind)
+                return left.kind === TranscriptGroupKind.Session ? -1 : 1;
+            return left.id.localeCompare(right.id);
+        });
+    }
+    async readGroup(workItemId, groupId) {
+        assertSegment(groupId, 'Transcript group ID');
+        const messages = [];
+        const directory = this.groupDirectory(workItemId, groupId);
+        for (const file of await filesOrEmpty(directory)) {
+            const parsed = parseMessageFile(file);
+            if (parsed === undefined)
+                continue;
+            messages.push({ ...parsed, text: await readFile(join(directory, file), 'utf8') });
+        }
+        return messages.sort((left, right) => left.timestamp.localeCompare(right.timestamp));
+    }
+    async groupForRun(workItemId, runId) {
+        for (const group of await this.listGroups(workItemId)) {
+            if (group.runIds.includes(runId))
+                return group.id;
+        }
+        return undefined;
+    }
+    async markWorkItemCleaned(workItemId, retentionMs, cleanedAt) {
+        assertRetention(retentionMs);
+        const directory = this.workItemDirectory(workItemId);
+        if (retentionMs === 0) {
+            await this.fileSystem.remove(directory, { recursive: true, force: true });
+            return;
+        }
+        try {
+            await readFile(join(directory, '.cleaned-at'), 'utf8');
+            return;
+        }
+        catch (error) {
+            if (!isMissing(error))
+                throw error;
+        }
+        const timestamp = normaliseTimestamp(cleanedAt);
+        await mkdir(directory, { recursive: true });
+        await writeFile(join(directory, '.cleaned-at'), timestamp, 'utf8');
+    }
+    async sweepExpired(retentionMs, now, onError = () => { }) {
+        assertRetention(retentionMs);
+        const currentTime = Date.parse(normaliseTimestamp(now));
+        const expired = [];
+        for (const workItemId of await filesOrEmpty(this.transcriptsRoot)) {
+            const directory = this.workItemDirectory(workItemId);
+            const marker = join(directory, '.cleaned-at');
+            let cleanedAt;
+            try {
+                cleanedAt = await readFile(marker, 'utf8');
+            }
+            catch (error) {
+                if (isMissing(error))
+                    continue;
+                onError(workItemId, error);
+                continue;
+            }
+            try {
+                if (Date.parse(normaliseTimestamp(cleanedAt)) + retentionMs <= currentTime) {
+                    await this.fileSystem.remove(directory, { recursive: true, force: true });
+                    expired.push(workItemId);
+                }
+            }
+            catch (error) {
+                onError(workItemId, error);
+            }
+        }
+        return expired.sort();
+    }
+    workItemDirectory(workItemId) {
+        assertSegment(workItemId, 'Work item ID');
+        return join(this.transcriptsRoot, workItemId);
+    }
+    groupDirectory(workItemId, groupId) {
+        assertSegment(groupId, 'Transcript group ID');
+        return join(this.workItemDirectory(workItemId), groupId);
+    }
+    stagingDirectory(workItemId, runId) {
+        return join(this.workItemDirectory(workItemId), `.pending--${safe(runId)}`);
+    }
+    async moveStagedPrompt(workItemId, runId, destination) {
+        const staging = this.stagingDirectory(workItemId, runId);
+        await mkdir(destination, { recursive: true });
+        const promptFiles = await filesOrEmpty(staging);
+        for (const promptFile of promptFiles.filter((file) => file.endsWith('.prompt.txt'))) {
+            await rename(join(staging, promptFile), join(destination, promptFile));
+        }
+        await this.fileSystem.remove(staging, { recursive: true, force: true });
+    }
+}
+function runGroup(runId) {
+    return `run--${safe(runId)}`;
+}
+function sessionGroup(cli, sessionId) {
+    return `session--${safe(cli)}--${opaque(sessionId)}`;
+}
+function safe(value) {
+    return encodeURIComponent(value).replaceAll('-', '%2D').replaceAll('.', '%2E');
+}
+function opaque(value) {
+    return createHash('sha256').update(value).digest('base64url');
+}
+function messageFile(timestamp, runId, kind) {
+    return `${timestamp}.${encodeURIComponent(runId)}.${kind}.txt`;
+}
+function parseMessageFile(file) {
+    const match = /^(\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}\.\d{3}Z)\.(.+)\.(prompt|response)\.txt$/.exec(file);
+    if (match === null)
+        return undefined;
+    const [, fileTimestamp, encodedRunId, kind] = match;
+    if (fileTimestamp === undefined || encodedRunId === undefined || kind === undefined)
+        return undefined;
+    return {
+        timestamp: timestampFromFile(fileTimestamp),
+        runId: decodeURIComponent(encodedRunId),
+        kind: kind,
+    };
+}
+function parseGroup(id) {
+    const session = /^session--(.+)--(.+)$/.exec(id);
+    if (session?.[1] !== undefined && session[2] !== undefined) {
+        return { id, kind: TranscriptGroupKind.Session, cli: decodeURIComponent(session[1]) };
+    }
+    if (/^run--.+$/.test(id))
+        return { id, kind: TranscriptGroupKind.Run };
+    return undefined;
+}
+function timestampForFile(timestamp) {
+    return normaliseTimestamp(timestamp).replaceAll(':', '-');
+}
+function timestampFromFile(timestamp) {
+    return normaliseTimestamp(`${timestamp.slice(0, 13)}:${timestamp.slice(14, 16)}:${timestamp.slice(17)}`);
+}
+function normaliseTimestamp(timestamp) {
+    const parsed = new Date(timestamp);
+    if (Number.isNaN(parsed.getTime()))
+        throw new Error(`Invalid transcript timestamp: ${timestamp}`);
+    return parsed.toISOString();
+}
+function assertRetention(retentionMs) {
+    if (!Number.isInteger(retentionMs) || retentionMs < 0)
+        throw new Error('Transcript retention must be a non-negative integer');
+}
+function assertSegment(value, label) {
+    if (value.length === 0 ||
+        value === '.' ||
+        value === '..' ||
+        value.includes('/') ||
+        value.includes('\\')) {
+        throw new Error(`${label} must be a single filesystem segment`);
+    }
+}
+async function filesOrEmpty(directory) {
+    try {
+        return await readdir(directory);
+    }
+    catch (error) {
+        if (isMissing(error))
+            return [];
+        throw error;
+    }
+}
+function isMissing(error) {
+    return typeof error === 'object' && error !== null && 'code' in error && error.code === 'ENOENT';
+}

package/dist/src/execution/infrastructure/transcripts.js

@@ -0,0 +1,11 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+export async function writeTranscript(directory, runId, kind, text) {
+    await mkdir(directory, { recursive: true });
+    const path = join(directory, `${safe(runId)}.${kind}.txt`);
+    await writeFile(path, text, 'utf8');
+    return path;
+}
+function safe(value) {
+    return value.replace(/[^a-zA-Z0-9._-]/g, '-');
+}

package/dist/src/execution/infrastructure/workspace/fake-workspace.js

@@ -0,0 +1,19 @@
+export class FakeWorkspaceProvider {
+    path;
+    branch;
+    requests = [];
+    constructor(path = '/fake/workspace', branch = 'wake/fake-work') {
+        this.path = path;
+        this.branch = branch;
+    }
+    async acquire(request) {
+        this.requests.push(request);
+        return {
+            workspaceId: `workspace-${this.requests.length}`,
+            path: this.path,
+            ...(this.branch === undefined ? {} : { branch: this.branch }),
+            mode: request.mode,
+            release: async () => { },
+        };
+    }
+}

package/dist/src/execution/infrastructure/workspace/git-workspace.js

@@ -0,0 +1,241 @@
+import { execFile } from 'node:child_process';
+import { access, mkdir, readdir, readFile, realpath, rm, writeFile } from 'node:fs/promises';
+import { basename, dirname, isAbsolute, join, relative, resolve } from 'node:path';
+import { promisify } from 'node:util';
+import { RunStatus, WorkspaceMode } from '../../contracts/vocabulary.js';
+const exec = promisify(execFile);
+export class GitWorkspaceProvider {
+    root;
+    resolver;
+    git;
+    markerRoot;
+    recoveryFileSystem;
+    constructor(root, resolver, git = async (arguments_) => {
+        await exec('git', arguments_);
+    }, recoveryFileSystem = {
+        remove: async (path) => rm(path, { recursive: true, force: true, maxRetries: 5, retryDelay: 200 }),
+        canonicalize: realpath,
+    }) {
+        this.root = root;
+        this.resolver = resolver;
+        this.git = git;
+        this.markerRoot = join(this.root, '.wake-workspace-ownership');
+        this.recoveryFileSystem = recoveryFileSystem;
+    }
+    async acquire(request) {
+        const locator = await this.resolver.cloneLocator(request.repositoryResource.resourceId);
+        const name = `${request.workItemId}-${request.mode}-${slug(locator)}`;
+        const path = resolve(this.root, name);
+        const markerPath = join(this.markerRoot, `${name}.json`);
+        await mkdir(dirname(markerPath), { recursive: true });
+        await writeFile(markerPath, JSON.stringify({
+            runId: request.runId,
+            workItemId: request.workItemId,
+            repositoryResourceId: request.repositoryResource.resourceId,
+            mode: request.mode,
+            workspaceId: name,
+            path,
+        }), 'utf8');
+        const existingWorkspace = await exists(join(path, '.git'));
+        if (!existingWorkspace) {
+            await mkdir(dirname(path), { recursive: true });
+            await this.git(['clone', locator, path]);
+        }
+        const branch = request.mode === WorkspaceMode.Branch ? request.workItemId : undefined;
+        if (branch !== undefined)
+            await this.git(['-C', path, 'switch', ...(existingWorkspace ? [] : ['--create']), branch]);
+        return {
+            workspaceId: name,
+            path,
+            mode: request.mode,
+            ...(branch === undefined ? {} : { branch }),
+            release: async () => {
+                if (request.mode !== WorkspaceMode.ReadOnly)
+                    return;
+                await rm(path, { recursive: true, force: true, maxRetries: 5, retryDelay: 200 });
+                await rm(markerPath, { force: true });
+            },
+        };
+    }
+    async recover(runs, options = {}) {
+        const scope = await recoveryScope(this.root, this.markerRoot);
+        if (scope === null)
+            return emptyRecovery();
+        const markers = await recoveryMarkerNames(this.markerRoot);
+        let reclaimed = 0;
+        const reclaimedWorkItemIds = [];
+        const failures = [];
+        for (const filename of markers) {
+            if (await options.isPaused?.())
+                break;
+            const result = await recoverMarker({
+                filename,
+                markerRoot: this.markerRoot,
+                scope,
+                runs,
+                fileSystem: this.recoveryFileSystem,
+                options,
+            });
+            reclaimed += result.reclaimed;
+            reclaimedWorkItemIds.push(...(result.reclaimedWorkItemIds ?? []));
+            failures.push(...result.failures);
+        }
+        return { reclaimed, reclaimedWorkItemIds, failures };
+    }
+}
+async function recoveryScope(root, markerRoot) {
+    const canonicalRoot = await canonicalPath(root);
+    const canonicalMarkerRoot = await canonicalPath(markerRoot);
+    if (canonicalRoot === null ||
+        canonicalMarkerRoot === null ||
+        !isStrictDescendant(canonicalRoot, canonicalMarkerRoot)) {
+        return null;
+    }
+    return { root: canonicalRoot, markerRoot: canonicalMarkerRoot };
+}
+async function recoveryMarkerNames(markerRoot) {
+    try {
+        return await readdir(markerRoot);
+    }
+    catch {
+        return [];
+    }
+}
+async function recoverMarker(input) {
+    if (!input.filename.endsWith('.json'))
+        return emptyRecovery();
+    const markerPath = join(input.markerRoot, input.filename);
+    const marker = await readMarker(markerPath);
+    try {
+        return await reclaimOwnedMarker(input, markerPath, marker);
+    }
+    catch (error) {
+        return {
+            reclaimed: 0,
+            failures: [{ markerPath, path: marker?.path ?? markerPath, message: errorMessage(error) }],
+        };
+    }
+}
+async function reclaimOwnedMarker(input, markerPath, marker) {
+    if (marker === null ||
+        !(await isOwnedWorkspace(input.scope, markerPath, marker, input.fileSystem)))
+        return emptyRecovery();
+    if (input.runs.some((run) => (run.status === RunStatus.Started || run.status === RunStatus.Ambiguous) &&
+        (run.runId === marker.runId || run.workspace?.path === marker.path)))
+        return emptyRecovery();
+    if ((await input.options.retainWorkItem?.(marker.workItemId)) === true)
+        return emptyRecovery();
+    if (!(await canRemoveOwnedWorkspace(input.scope, marker.path)))
+        return emptyRecovery();
+    if ((await canonicalPath(marker.path)) !== null)
+        await input.fileSystem.remove(marker.path);
+    if ((await input.options.onWorkspaceReclaimed?.(marker.workItemId)) === false)
+        return emptyRecovery();
+    await rm(markerPath, { force: true });
+    return {
+        reclaimed: 1,
+        reclaimedWorkItemIds: [marker.workItemId],
+        failures: [],
+    };
+}
+function emptyRecovery() {
+    return { reclaimed: 0, reclaimedWorkItemIds: [], failures: [] };
+}
+async function canRemoveOwnedWorkspace(scope, path) {
+    const canonicalTarget = await canonicalPath(path);
+    return (canonicalTarget === null ||
+        (isStrictDescendant(scope.root, canonicalTarget) &&
+            !isDescendantOrSame(scope.markerRoot, canonicalTarget)));
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+async function readMarker(path) {
+    try {
+        const value = JSON.parse(await readFile(path, 'utf8'));
+        if (!isOwnershipMarker(value))
+            return null;
+        return value;
+    }
+    catch {
+        return null;
+    }
+}
+function isOwnershipMarker(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const marker = value;
+    return (typeof marker.runId === 'string' &&
+        typeof marker.workItemId === 'string' &&
+        typeof marker.repositoryResourceId === 'string' &&
+        (marker.mode === WorkspaceMode.ReadOnly || marker.mode === WorkspaceMode.Branch) &&
+        typeof marker.workspaceId === 'string' &&
+        typeof marker.path === 'string');
+}
+async function isOwnedWorkspace(scope, markerPath, marker, fileSystem) {
+    if (!isSafeWorkspaceId(marker.workspaceId))
+        return false;
+    if (basename(markerPath) !== `${marker.workspaceId}.json`)
+        return false;
+    if (!isAbsolute(marker.path))
+        return false;
+    const expectedPath = resolve(scope.root, marker.workspaceId);
+    if (resolve(marker.path) !== expectedPath)
+        return false;
+    if (!isStrictDescendant(scope.root, expectedPath))
+        return false;
+    if (isDescendantOrSame(scope.markerRoot, expectedPath))
+        return false;
+    const canonicalMarkerPath = await canonicalizeMarkerPath(fileSystem, markerPath);
+    if (canonicalMarkerPath === null)
+        return false;
+    return isStrictDescendant(scope.markerRoot, canonicalMarkerPath);
+}
+async function canonicalizeMarkerPath(fileSystem, path) {
+    try {
+        return await fileSystem.canonicalize(path);
+    }
+    catch (error) {
+        if (isNotFound(error))
+            return null;
+        throw error;
+    }
+}
+function isSafeWorkspaceId(value) {
+    return value !== '' && value !== '.' && value !== '..' && basename(value) === value;
+}
+function isStrictDescendant(root, target) {
+    const path = relative(root, target);
+    return path !== '' && !path.startsWith('..') && !isAbsolute(path);
+}
+function isDescendantOrSame(root, target) {
+    return root === target || isStrictDescendant(root, target);
+}
+async function canonicalPath(path) {
+    try {
+        return await realpath(path);
+    }
+    catch (error) {
+        if (isNotFound(error))
+            return null;
+        throw error;
+    }
+}
+function isNotFound(error) {
+    return typeof error === 'object' && error !== null && 'code' in error && error.code === 'ENOENT';
+}
+async function exists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function slug(value) {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '');
+}

package/dist/src/integrations/application/agent-run-publication-reactor.js

@@ -0,0 +1,111 @@
+import { BuiltInActivityName } from '../../activities/index.js';
+import { RunStatus } from '../../execution/index.js';
+import { createEventDraft, EventActorKind, EventSourceKind, } from '../../kernel/index.js';
+import { ApprovalAuthorityKind, isApprovalAwaitingSignalKind, OrchestrationEventType, OrchestrationStreamKind, WatchGateVerdictSignal, } from '../../orchestration/index.js';
+import { ResourceCorrelationRole, resourceStream } from '../../resources/index.js';
+import { DeliveryIntentEventType } from '../delivery/contracts/intents.js';
+import { projectTerminalAgentRunReport } from './terminal-agent-run-report.js';
+/** Projects terminal agent runs into one durable outbound intent per primary resource. */
+export class AgentRunPublicationReactor {
+    dependencies;
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+    }
+    async runOnce(limit = 100) {
+        const consumer = 'reactor:agent-run-publication';
+        const events = await this.dependencies.journal.readAll(await this.dependencies.checkpoints.load(consumer), limit);
+        for (const event of events) {
+            if (event.eventType === OrchestrationEventType.ActivityOutcomeAccepted)
+                await this.publishAcceptedOutcome(event.stream.id, event.payload.activationId, event.recordedAt, event.eventId, event.correlationId);
+            if (event.eventType === OrchestrationEventType.ActivityExecutionFailed)
+                await this.publish(event.payload.runId, event.recordedAt, event.eventId, event.correlationId);
+            await this.dependencies.checkpoints.save(consumer, event.globalPosition);
+        }
+        return events.length;
+    }
+    async publishAcceptedOutcome(workflowInstanceId, activationId, occurredAt, causationId, correlationId) {
+        const run = (await this.dependencies.runs.list(activationId)).find((candidate) => candidate.workflowInstanceId === workflowInstanceId &&
+            candidate.status === RunStatus.Succeeded &&
+            candidate.activity === BuiltInActivityName.Agent);
+        if (run === undefined)
+            return;
+        await this.publish(run.runId, occurredAt, causationId, correlationId);
+    }
+    async publish(id, occurredAt, causationId, correlationId) {
+        const run = (await this.dependencies.runs.load(id)).view;
+        if (run?.activity !== BuiltInActivityName.Agent || run.finishedAt === undefined)
+            return;
+        const allWorkflows = await this.dependencies.orchestration.listAll();
+        const workflow = allWorkflows.find((value) => value.workflowInstanceId === run.workflowInstanceId);
+        if (workflow === undefined)
+            return;
+        const primary = (await this.dependencies.resources.correlationsForWork(workflow.workItemId)).find((value) => value.role === ResourceCorrelationRole.Primary);
+        if (primary === undefined)
+            return;
+        const stage = await this.stageForActivation(workflow.workflowInstanceId, run.activationId);
+        const report = projectTerminalAgentRunReport(reportInput(run, stage, workflow, allWorkflows));
+        if (report === null)
+            return;
+        const stream = resourceStream(primary.resourceId);
+        const sequence = (await this.dependencies.journal.readStream(stream)).length;
+        try {
+            await this.dependencies.journal.append(stream, sequence, [
+                createEventDraft({
+                    eventId: `agent-run:${run.runId}`,
+                    eventType: DeliveryIntentEventType.AgentRunPublishRequested,
+                    occurredAt,
+                    correlationId: correlationId,
+                    causationId: causationId,
+                    actor: { kind: EventActorKind.Integration, id: 'agent-run-publication' },
+                    source: { kind: EventSourceKind.Internal, id: 'agent-run-publication' },
+                    stream,
+                    payload: {
+                        workflowInstanceId: run.workflowInstanceId,
+                        activationId: run.activationId,
+                        resourceId: primary.resourceId,
+                        report,
+                    },
+                }),
+            ]);
+        }
+        catch {
+            /* idempotency is the deterministic run event id */
+        }
+    }
+    async stageForActivation(workflowInstanceId, activationId) {
+        const events = await this.dependencies.journal.readStream({
+            kind: OrchestrationStreamKind.WorkflowInstance,
+            id: workflowInstanceId,
+        });
+        const request = events.findIndex((event) => event.eventType === OrchestrationEventType.ActivityRequested &&
+            event.payload.activationId === activationId);
+        for (let index = request - 1; index >= 0; index -= 1) {
+            const event = events[index];
+            if (event?.eventType === OrchestrationEventType.StageEntered)
+                return event.payload.stage;
+        }
+        return undefined;
+    }
+}
+function reportInput(run, stage, workflow, allWorkflows) {
+    const watchGateVerdict = watchGateVerdictFor(run, workflow, allWorkflows);
+    const isWaiting = workflow.waitingFor !== undefined &&
+        isApprovalAwaitingSignalKind(workflow.waitingFor.signalKind);
+    return {
+        run,
+        ...(stage === undefined ? {} : { stage }),
+        ...(isWaiting ? { awaitingApproval: true } : {}),
+        ...(watchGateVerdict === undefined ? {} : { watchGateVerdict }),
+    };
+}
+function watchGateVerdictFor(run, workflow, allWorkflows) {
+    if (run.agent?.outcome !== 'DONE' && run.agent?.outcome !== 'REJECTED')
+        return undefined;
+    if (workflow.parentWorkflowInstanceId === undefined || workflow.watchId === undefined)
+        return undefined;
+    const parent = allWorkflows.find((value) => value.workflowInstanceId === workflow.parentWorkflowInstanceId);
+    if (parent?.waitingFor?.signalKind !== WatchGateVerdictSignal)
+        return undefined;
+    const namesThisWatch = parent.waitingFor.from?.some((entry) => entry.kind === ApprovalAuthorityKind.Watch && entry.watch === workflow.watchId);
+    return namesThisWatch === true ? { runId: run.runId } : undefined;
+}