@atolis-hq/wake 0.2.97 → 0.3.0

package/dist/src/cli/self-update-command.js

@@ -1,198 +0,0 @@
-import { waitForActiveRuns } from './stop-command.js';
-import { resolveWakeVersion } from '../version.js';
-const HEALTHCHECK_WAKE_ROOT = '/tmp/wake-self-update-healthcheck';
-const START_PROCESS_CHECK_ATTEMPTS = 15;
-const START_PROCESS_CHECK_INTERVAL_MS = 1000;
-const START_PROCESS_CHECK = [
-    'sh',
-    '-lc',
-    [
-        'pid="$(cat /wake/.wake/logs/start.pid)"',
-        'test -n "$pid"',
-        'kill -0 "$pid"',
-        'tr "\\0" " " < "/proc/$pid/cmdline" | grep -F "node /app/dist/src/main.js start --wake-root /wake" >/dev/null',
-    ].join(' && '),
-];
-function tagFromImage(imageRepository, image) {
-    if (image === null) {
-        return null;
-    }
-    const prefix = `${imageRepository}:`;
-    return image.startsWith(prefix) ? image.slice(prefix.length) : null;
-}
-function readFlag(name, args) {
-    const index = args.indexOf(name);
-    return index === -1 ? undefined : args[index + 1];
-}
-function hasFlag(name, args) {
-    return args.includes(name);
-}
-function readNumberFlag(name, args) {
-    const raw = readFlag(name, args);
-    const parsed = raw === undefined ? Number.NaN : Number(raw);
-    return Number.isFinite(parsed) ? parsed : undefined;
-}
-const DEFAULT_LOOP_INTERVAL_MS = 5 * 60 * 1000;
-async function verifyResidentStart(input) {
-    if (input.start?.enabled !== true) {
-        input.logger.error(`[self-update] wake start auto-start is disabled; resident loop will not be running after ${input.context}`);
-        return;
-    }
-    let lastError;
-    for (let attempt = 1; attempt <= START_PROCESS_CHECK_ATTEMPTS; attempt += 1) {
-        try {
-            await input.docker.exec(input.containerName, START_PROCESS_CHECK);
-            input.logger.info(`[self-update] verified wake start is running after ${input.context}`);
-            return;
-        }
-        catch (error) {
-            lastError = error;
-            if (attempt === START_PROCESS_CHECK_ATTEMPTS) {
-                break;
-            }
-            await input.sleep(START_PROCESS_CHECK_INTERVAL_MS);
-        }
-    }
-    throw lastError instanceof Error ? lastError : new Error(String(lastError));
-}
-export async function runSelfUpdateCommand(input) {
-    const force = hasFlag('--force', input.args);
-    const explicitTag = readFlag('--tag', input.args);
-    const ledger = await input.readLedger();
-    const tag = explicitTag ?? (await input.git.latestTag());
-    if (!force && tag === ledger.lastAppliedTag) {
-        input.logger.info(`[self-update] already on ${tag}; nothing to do`);
-        return;
-    }
-    if (!force && ledger.badTags.some((bad) => bad.tag === tag)) {
-        input.logger.info(`[self-update] ${tag} is recorded as a bad tag; skipping (use --force to retry)`);
-        return;
-    }
-    if (!(await input.git.isWorkingTreeClean())) {
-        throw new Error(`[self-update] repo working tree has local changes; refusing to update to ${tag}`);
-    }
-    await waitForActiveRuns({
-        listRunRecords: input.stateStore.listRunRecords,
-        ...(input.recoverActiveRuns === undefined
-            ? {}
-            : { recoverActiveRuns: input.recoverActiveRuns }),
-        sleep: input.sleep,
-        logger: input.logger,
-    });
-    const newImage = `${input.imageRepository}:${tag}`;
-    const previousImage = (await input.docker.inspectContainerImage?.(input.containerName)) ?? null;
-    const previousImageTag = tagFromImage(input.imageRepository, previousImage);
-    const rollbackImage = previousImage ??
-        (ledger.lastKnownGoodTag !== null
-            ? `${input.imageRepository}:${ledger.lastKnownGoodTag}`
-            : null);
-    const rollbackTag = previousImageTag ?? ledger.lastKnownGoodTag;
-    const updateInput = {
-        containerName: input.containerName,
-        wakeRoot: input.wakeRoot,
-        containerHomeRoot: input.containerHomeRoot,
-        containerMountPath: input.containerMountPath,
-        containerHomeMountPath: input.containerHomeMountPath,
-        ui: input.ui,
-        start: input.start,
-    };
-    try {
-        await input.git.checkoutTag(tag);
-        const buildVersion = input.resolveBuildVersion?.(input.repoRoot) ??
-            resolveWakeVersion({ repoRoot: input.repoRoot });
-        await input.docker.build({
-            image: newImage,
-            dockerfile: input.dockerfilePath,
-            contextDir: input.repoRoot,
-            buildArgs: { WAKE_BUILD_TAG: buildVersion },
-        });
-        await input.docker.update({ ...updateInput, image: newImage });
-        input.logger.info('[self-update] recreated container; entrypoint will keep wake start running');
-        await verifyResidentStart({
-            docker: input.docker,
-            containerName: input.containerName,
-            start: input.start,
-            logger: input.logger,
-            sleep: input.sleep,
-            context: 'rollout',
-        });
-        await input.docker.exec(input.containerName, [
-            'node',
-            '/app/dist/src/main.js',
-            'tick',
-            '--wake-root',
-            HEALTHCHECK_WAKE_ROOT,
-        ]);
-    }
-    catch (error) {
-        const reason = error instanceof Error ? error.message : String(error);
-        input.logger.error(`[self-update] rollout of ${tag} failed: ${reason}`);
-        if (rollbackImage !== null) {
-            if (rollbackTag !== null) {
-                await input.git.checkoutTag(rollbackTag);
-            }
-            await input.docker.update({ ...updateInput, image: rollbackImage });
-            input.logger.info('[self-update] recreated rollback container; entrypoint will keep wake start running');
-            await verifyResidentStart({
-                docker: input.docker,
-                containerName: input.containerName,
-                start: input.start,
-                logger: input.logger,
-                sleep: input.sleep,
-                context: 'rollback',
-            });
-            input.logger.info(`[self-update] rolled back to ${rollbackTag ?? rollbackImage}`);
-        }
-        else {
-            input.logger.error('[self-update] no previous known-good tag to roll back to');
-        }
-        await input.writeLedger({
-            lastAppliedTag: rollbackTag,
-            lastKnownGoodTag: rollbackTag,
-            badTags: [...ledger.badTags, { tag, reason, recordedAt: new Date().toISOString() }],
-        });
-        try {
-            await input.issueReporter.createIssue({
-                title: `Self-update to ${tag} failed and was rolled back`,
-                body: [
-                    `Automated update to \`${tag}\` failed during rollout and was rolled back to \`${rollbackTag ?? rollbackImage ?? 'unknown'}\`.`,
-                    '',
-                    '```',
-                    reason,
-                    '```',
-                ].join('\n'),
-            });
-        }
-        catch (issueError) {
-            // Rollback already succeeded above; a failure to file the notification
-            // issue must not be reported as an overall self-update failure.
-            input.logger.error(`[self-update] rolled back successfully, but failed to file a GitHub issue: ${issueError instanceof Error ? issueError.message : String(issueError)}`);
-        }
-        return;
-    }
-    await input.writeLedger({
-        lastAppliedTag: tag,
-        lastKnownGoodTag: tag,
-        badTags: ledger.badTags,
-    });
-    input.logger.info(`[self-update] ${tag} is live and healthy`);
-}
-// Runs runSelfUpdateCommand forever, polling for a new tag every
-// --loop-interval-ms (default 5 minutes). One failed iteration (e.g. a
-// transient git/docker error) is logged and does not stop the loop — the
-// next iteration retries. Exits only if `sleep` itself rejects (e.g. the
-// process is being torn down), matching the resident-loop shape in
-// core/control-plane.ts.
-export async function runSelfUpdateLoop(input) {
-    const loopIntervalMs = readNumberFlag('--loop-interval-ms', input.args) ?? DEFAULT_LOOP_INTERVAL_MS;
-    for (;;) {
-        try {
-            await runSelfUpdateCommand(input);
-        }
-        catch (error) {
-            input.logger.error(`[self-update] loop iteration failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        input.logger.info(`[self-update] next check in ${loopIntervalMs}ms`);
-        await input.sleep(loopIntervalMs);
-    }
-}

package/dist/src/cli/startup-preflight.js

@@ -1,134 +0,0 @@
-import { execFile as nodeExecFile } from 'node:child_process';
-import { access } from 'node:fs/promises';
-import { promisify } from 'node:util';
-import { loadPromptTemplate } from '../adapters/runner/prompt-templates.js';
-const execFile = promisify(nodeExecFile);
-// Some CLIs (observed with Cursor's `agent --version`) take 5-6s to exit
-// when stdout isn't a TTY, likely due to a background update/telemetry
-// check — keep this comfortably above that or the probe kills a CLI that
-// is actually fine.
-const runnerVersionProbeTimeoutMs = 20_000;
-function activeRunnerNames(config, runnerOverride) {
-    const names = new Set();
-    if (runnerOverride !== undefined) {
-        names.add(runnerOverride);
-        return names;
-    }
-    for (const candidates of Object.values(config.tiers)) {
-        for (const candidate of candidates) {
-            names.add(candidate);
-        }
-    }
-    for (const workflow of Object.values(config.workflows)) {
-        for (const route of Object.values(workflow.stages)) {
-            if (route.runner !== undefined) {
-                names.add(route.runner);
-            }
-        }
-    }
-    return names;
-}
-function formatPreflightFailures(failures) {
-    return new Error([
-        'Wake startup preflight failed:',
-        ...failures.map((failure) => `- ${failure}`),
-        '',
-        'Fix the configuration or environment, then run `wake start` again.',
-    ].join('\n'));
-}
-async function defaultLoadPrompt(action, mode, promptsRoot) {
-    await loadPromptTemplate(action, mode, {
-        ...(promptsRoot === undefined ? {} : { promptsRoot }),
-    });
-}
-export function buildRunnerCommandProbeArgs(kind) {
-    return kind === 'cursor' ? ['agent', '--version'] : ['--version'];
-}
-async function defaultCheckRunnerCommand(runnerName, entry) {
-    try {
-        await execFile(entry.command, buildRunnerCommandProbeArgs(entry.kind), {
-            env: process.env,
-            timeout: runnerVersionProbeTimeoutMs,
-            windowsHide: true,
-            maxBuffer: 1024 * 1024,
-        });
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`runner "${runnerName}" (${entry.kind}) command "${entry.command}" is not invocable: ${message}`, { cause: error });
-    }
-}
-async function assertPromptsRootAccessible(promptsRoot) {
-    if (promptsRoot === undefined) {
-        return;
-    }
-    await access(promptsRoot);
-}
-export async function collectStartupPreflightFailures(config, deps = {}) {
-    const failures = [];
-    const loadPrompt = deps.loadPrompt ?? defaultLoadPrompt;
-    const checkRunnerCommand = deps.checkRunnerCommand ?? defaultCheckRunnerCommand;
-    try {
-        await assertPromptsRootAccessible(config.paths.promptsRoot);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        failures.push(`promptsRoot "${config.paths.promptsRoot}" is not readable: ${message}`);
-    }
-    const actions = new Set(Object.values(config.workflows).flatMap((workflow) => Object.entries(workflow.stages).map(([stageName, stage]) => stage.action ?? stageName)));
-    for (const action of actions) {
-        for (const mode of ['start', 'resume']) {
-            try {
-                await loadPrompt(action, mode, config.paths.promptsRoot);
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                const root = config.paths.promptsRoot ?? '(bundled prompts)';
-                failures.push(`prompt template ${action}.md or ${action}.${mode}.md under ${root} is not readable: ${message}`);
-            }
-        }
-    }
-    const activeRunners = activeRunnerNames(config, deps.runnerOverride);
-    let usesRealRunner = false;
-    for (const runnerName of activeRunners) {
-        const entry = config.runners[runnerName];
-        if (entry === undefined) {
-            failures.push(`routing references unknown runner "${runnerName}"`);
-            continue;
-        }
-        if (entry.kind === 'fake') {
-            continue;
-        }
-        usesRealRunner = true;
-        try {
-            await checkRunnerCommand(runnerName, entry);
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            failures.push(message);
-        }
-    }
-    if (usesRealRunner && config.sources.github.enabled && config.sources.github.repos.length > 0) {
-        if (deps.workspaceManager === undefined) {
-            failures.push('canonical clone health could not be checked: no workspace manager was provided');
-        }
-        else {
-            for (const repo of config.sources.github.repos) {
-                try {
-                    await deps.workspaceManager.prepareReadOnlyClone({ repo });
-                }
-                catch (error) {
-                    const message = error instanceof Error ? error.message : String(error);
-                    failures.push(`canonical clone for ${repo} is not healthy or clone-able: ${message}`);
-                }
-            }
-        }
-    }
-    return failures;
-}
-export async function runStartupPreflight(config, deps = {}) {
-    const failures = await collectStartupPreflightFailures(config, deps);
-    if (failures.length > 0) {
-        throw formatPreflightFailures(failures);
-    }
-}

package/dist/src/cli/stop-command.js

@@ -1,46 +0,0 @@
-const DEFAULT_POLL_INTERVAL_MS = 5_000;
-const STOP_GRACE_PERIOD_SECONDS = 60;
-export async function waitForActiveRuns(input) {
-    const pollIntervalMs = input.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
-    const startedAt = Date.now();
-    for (;;) {
-        await input.recoverActiveRuns?.();
-        const records = await input.listRunRecords();
-        const activeRuns = records.filter((record) => record.status === 'running');
-        if (activeRuns.length === 0) {
-            return;
-        }
-        if (input.timeoutMs !== undefined && Date.now() - startedAt >= input.timeoutMs) {
-            throw new Error(`Timed out after ${input.timeoutMs}ms waiting for active runs to finish: ${activeRuns
-                .map((record) => record.runId)
-                .join(', ')}`);
-        }
-        input.logger.info(`[wake stop] waiting for ${activeRuns.length} active run(s) to finish: ${activeRuns
-            .map((record) => record.runId)
-            .join(', ')}`);
-        await input.sleep(pollIntervalMs);
-    }
-}
-function readNumberFlag(name, args) {
-    const index = args.indexOf(name);
-    if (index === -1) {
-        return undefined;
-    }
-    const raw = args[index + 1];
-    const parsed = raw === undefined ? Number.NaN : Number(raw);
-    return Number.isFinite(parsed) ? parsed : undefined;
-}
-export async function runStopCommand(input) {
-    await waitForActiveRuns({
-        listRunRecords: input.stateStore.listRunRecords,
-        ...(input.recoverActiveRuns === undefined
-            ? {}
-            : { recoverActiveRuns: input.recoverActiveRuns }),
-        sleep: input.sleep,
-        pollIntervalMs: readNumberFlag('--poll-interval-ms', input.args),
-        timeoutMs: readNumberFlag('--timeout-ms', input.args),
-        logger: input.logger,
-    });
-    input.logger.info(`[wake stop] no active runs; stopping ${input.containerName}`);
-    await input.docker.down(input.containerName, { timeoutSeconds: STOP_GRACE_PERIOD_SECONDS });
-}

package/dist/src/cli/ui-command.js

@@ -1,27 +0,0 @@
-import { createUiServer } from '../adapters/http/ui-server.js';
-export async function runUiCommand(input) {
-    const log = input.log ?? console.log;
-    const portFlag = input.readFlag('--port', input.args);
-    const port = portFlag !== undefined ? Number(portFlag) : input.config.ui.port;
-    if (!Number.isInteger(port) || port <= 0) {
-        throw new Error(`Invalid --port: ${portFlag}`);
-    }
-    const host = input.readFlag('--host', input.args) ?? '127.0.0.1';
-    const token = input.readFlag('--token', input.args) ?? input.config.ui.token ?? process.env.WAKE_UI_TOKEN;
-    const server = createUiServer({
-        stateStore: input.stateStore,
-        resourceIndex: input.resourceIndex,
-        config: input.config,
-        ...(token === undefined ? {} : { token }),
-    });
-    await new Promise((resolveListen, reject) => {
-        server.once('error', reject);
-        server.listen(port, host, () => resolveListen());
-    });
-    log(`Wake UI listening on http://${host}:${port}`);
-    return {
-        close: () => new Promise((resolveClose) => {
-            server.close(() => resolveClose());
-        }),
-    };
-}

package/dist/src/config/defaults.js

@@ -1,10 +0,0 @@
-import { resolve } from 'node:path';
-import { defaultAgentIdentity, defaultSmokePrompt, parseWakeConfig } from '../domain/schema.js';
-export { defaultAgentIdentity, defaultSmokePrompt };
-export function createDefaultWakeConfig(wakeRoot = resolve(process.cwd(), '.wake')) {
-    return parseWakeConfig({
-        paths: {
-            wakeRoot,
-        },
-    });
-}

package/dist/src/config/discover-config-files.js

@@ -1,11 +0,0 @@
-import { readdir } from 'node:fs/promises';
-import { join } from 'node:path';
-const configFileNamePattern = /^config(\..+)?\.yaml$/;
-export async function discoverConfigFiles(wakeRoot) {
-    const entries = await readdir(wakeRoot, { withFileTypes: true }).catch(() => []);
-    return entries
-        .filter((entry) => entry.isFile() && configFileNamePattern.test(entry.name))
-        .map((entry) => entry.name)
-        .sort()
-        .map((name) => join(wakeRoot, name));
-}

package/dist/src/config/load-config.js

@@ -1,69 +0,0 @@
-import { resolve, join } from 'node:path';
-import { access } from 'node:fs/promises';
-import { existsSync } from 'node:fs';
-import { readJsonFile } from '../lib/json-file.js';
-import { readYamlFile } from '../lib/yaml-file.js';
-import { deepMergeRaw } from '../lib/deep-merge.js';
-import { parseWakeConfig } from '../domain/schema.js';
-import { discoverConfigFiles } from './discover-config-files.js';
-async function readLegacyConfigIfPresent(wakeRoot) {
-    const legacyConfigFile = join(wakeRoot, 'config.json');
-    try {
-        await access(legacyConfigFile);
-    }
-    catch {
-        return {};
-    }
-    return readJsonFile(legacyConfigFile);
-}
-export async function loadWakeConfig(options) {
-    const wakeRoot = options?.wakeRoot ?? resolve(process.cwd(), '.wake');
-    const configFiles = await discoverConfigFiles(wakeRoot);
-    let raw;
-    if (configFiles.length > 0) {
-        raw = {};
-        for (const configFile of configFiles) {
-            let parsed;
-            try {
-                // yaml.parse returns null for empty/comment-only files rather than
-                // {}, so coalesce before merging.
-                parsed = (await readYamlFile(configFile)) ?? {};
-            }
-            catch (error) {
-                throw new Error(`Failed to parse ${configFile}: ${error.message}`, {
-                    cause: error,
-                });
-            }
-            raw = deepMergeRaw(raw, parsed);
-        }
-    }
-    else {
-        // Pre-split Wake homes only have a single config.json — Wake reads it
-        // directly rather than requiring a migration step. It stays untouched
-        // on disk; nothing here writes it back out (see docs/configuration.md).
-        raw = await readLegacyConfigIfPresent(wakeRoot);
-    }
-    // wakeRoot is always the live invocation's --wake-root/cwd, never a value
-    // to accept from a (possibly stale, possibly container-context) config
-    // file — spread rawPaths first so wakeRoot always wins. promptsRoot stays
-    // file-overridable for a genuine custom location, but when the file is
-    // silent on it we default to the live wakeRoot's own prompts/ dir (the
-    // usual colocated layout `wake init` scaffolds) rather than leaving it to
-    // fall back to bundled prompts — this keeps a scaffolded home's prompt
-    // customizations in effect across host/container re-reads of the same
-    // config file, where an absolute promptsRoot baked in at init time would
-    // not resolve the same way.
-    const rawPaths = raw.paths ?? {};
-    const wakeRootPromptsDir = join(wakeRoot, 'prompts');
-    const promptsRootDefault = rawPaths.promptsRoot === undefined && existsSync(wakeRootPromptsDir)
-        ? { promptsRoot: wakeRootPromptsDir }
-        : {};
-    return parseWakeConfig({
-        ...raw,
-        paths: {
-            ...rawPaths,
-            ...promptsRootDefault,
-            wakeRoot,
-        },
-    });
-}

package/dist/src/config/split-config.js

@@ -1,14 +0,0 @@
-import { wakeInfraConfigSchema, wakeWorkflowConfigSchema } from '../domain/schema.js';
-const infraKeys = Object.keys(wakeInfraConfigSchema.shape);
-const workflowKeys = Object.keys(wakeWorkflowConfigSchema.shape);
-export function splitWakeConfig(config) {
-    const infra = {};
-    for (const key of infraKeys) {
-        infra[key] = config[key];
-    }
-    const workflow = {};
-    for (const key of workflowKeys) {
-        workflow[key] = config[key];
-    }
-    return { infra, workflow };
-}

package/dist/src/core/active-run-recovery.js

@@ -1,44 +0,0 @@
-import { maxConfiguredRunnerTimeoutMs } from '../domain/runner-routing.js';
-import { isRunLeaseExpired } from './run-lease.js';
-import { processIdentityMatches } from '../lib/process-identity.js';
-import { createOutbox } from './outbox.js';
-import { createProjectionUpdater } from './projection-updater.js';
-import { createStaleRunReconciler } from './stale-run-reconciler.js';
-export function createActiveRunRecovery(deps) {
-    const projectionUpdater = createProjectionUpdater({
-        stateStore: deps.stateStore,
-        resourceIndex: deps.resourceIndex,
-        config: deps.config,
-    });
-    const { deliverOutboundEvent } = createOutbox({
-        clock: deps.clock,
-        stateStore: deps.stateStore,
-        projectionUpdater,
-    });
-    async function isRunningRecordActive(record, now) {
-        if (record.lease !== undefined && !isRunLeaseExpired(record, now)) {
-            return true;
-        }
-        return (processIdentityMatches({
-            pid: record.agentPid,
-            processStartedAt: record.agentProcessStartedAt,
-        }) ||
-            processIdentityMatches({
-                pid: record.workerPid,
-                processStartedAt: record.workerProcessStartedAt,
-            }));
-    }
-    const { reconcileStaleRunningRecords } = createStaleRunReconciler({
-        config: deps.config,
-        stateStore: deps.stateStore,
-        projectionUpdater,
-        runnerTimeoutMs: () => maxConfiguredRunnerTimeoutMs(deps.config),
-        isRunningRecordActive,
-        deliverOutboundEvent,
-    });
-    return {
-        recoverActiveRuns() {
-            return reconcileStaleRunningRecords(deps.clock.now());
-        },
-    };
-}

package/dist/src/core/approval-intents.js

@@ -1,16 +0,0 @@
-export const autoApprovalLabel = 'wake:auto';
-const autoApprovalCommands = new Set(['yolo', 'autoapprove']);
-export function resolveAutoApprovalIntent(body) {
-    for (const line of (body ?? '').split(/\r?\n/)) {
-        const match = /^\/([A-Za-z0-9_.-]+)\b/.exec(line.trim());
-        const command = match?.[1]?.toLowerCase();
-        if (command !== undefined && autoApprovalCommands.has(command)) {
-            return {
-                kind: 'auto-approval-opt-in',
-                label: autoApprovalLabel,
-                command,
-            };
-        }
-    }
-    return null;
-}

package/dist/src/core/audit-events.js

@@ -1,82 +0,0 @@
-import { createHash } from 'node:crypto';
-import { readFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { AUTONOMOUS_DECISION_AUDIT_EVENT } from '../domain/schema.js';
-import { createEventEnvelope } from '../lib/event-log.js';
-function stableJson(value) {
-    if (value === null || typeof value !== 'object') {
-        return JSON.stringify(value);
-    }
-    if (Array.isArray(value)) {
-        return `[${value.map((entry) => stableJson(entry)).join(',')}]`;
-    }
-    const record = value;
-    return `{${Object.keys(record)
-        .sort()
-        .map((key) => `${JSON.stringify(key)}:${stableJson(record[key])}`)
-        .join(',')}}`;
-}
-async function promptRevisionInput(input) {
-    if (input.action === undefined) {
-        return {};
-    }
-    const promptsRoot = input.config.paths.promptsRoot;
-    if (promptsRoot === undefined) {
-        return { prompt: { action: input.action, status: 'not-configured' } };
-    }
-    for (const suffix of ['.md', '.start.md', '.resume.md']) {
-        const path = join(promptsRoot, `${input.action}${suffix}`);
-        try {
-            return {
-                prompt: {
-                    action: input.action,
-                    path,
-                    sha256: createHash('sha256')
-                        .update(await readFile(path, 'utf8'))
-                        .digest('hex'),
-                },
-            };
-        }
-        catch {
-            // Try the next supported prompt template name.
-        }
-    }
-    return { prompt: { action: input.action, status: 'missing' } };
-}
-export async function workflowRevision(input) {
-    const revisionInput = {
-        workflowName: input.workflowName,
-        workflow: input.workflow,
-        ...(await promptRevisionInput({
-            config: input.config,
-            ...(input.action === undefined ? {} : { action: input.action }),
-        })),
-    };
-    return `sha256:${createHash('sha256').update(stableJson(revisionInput)).digest('hex')}`;
-}
-export function createAutonomousDecisionAuditEvent(input) {
-    return createEventEnvelope({
-        eventId: input.eventId,
-        workItemKey: input.workItemKey,
-        streamScope: 'work-item',
-        direction: 'internal',
-        sourceSystem: 'wake',
-        sourceEventType: AUTONOMOUS_DECISION_AUDIT_EVENT,
-        sourceRefs: {
-            ...(input.sourceRefs ?? {}),
-            runId: input.runId,
-        },
-        occurredAt: input.timestamp,
-        ingestedAt: input.timestamp,
-        trigger: 'context-only',
-        payload: {
-            decisionType: input.decisionType,
-            workItemId: input.workItemKey,
-            runId: input.runId,
-            workflowRevision: input.workflowRevision,
-            inputsConsidered: input.inputsConsidered,
-            outcome: input.outcome,
-            timestamp: input.timestamp,
-        },
-    });
-}