@atolis-hq/wake 0.2.40 → 0.2.41

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

@@ -0,0 +1,36 @@
+import { AUTONOMOUS_DECISION_AUDIT_EVENT } from '../domain/schema.js';
+function formatValue(value) {
+    if (value === undefined)
+        return 'n/a';
+    if (typeof value === 'string')
+        return value;
+    return JSON.stringify(value);
+}
+function auditEventsForWorkItem(events, workItemKey) {
+    return events
+        .filter((event) => event.workItemKey === workItemKey &&
+        event.sourceEventType === AUTONOMOUS_DECISION_AUDIT_EVENT)
+        .sort((left, right) => left.ingestedAt.localeCompare(right.ingestedAt));
+}
+export async function runAuditCommand(input) {
+    const log = input.log ?? console.log;
+    const [workItemKey] = input.args;
+    if (workItemKey === undefined) {
+        throw new Error('Usage: wake audit <workItemKey>');
+    }
+    const events = auditEventsForWorkItem(await input.stateStore.listEventEnvelopes(), workItemKey);
+    if (events.length === 0) {
+        log(`No autonomous audit events found for ${workItemKey}.`);
+        return;
+    }
+    log(`Autonomous audit history for ${workItemKey}`);
+    for (const event of events) {
+        const payload = event.payload;
+        log('');
+        log(`${formatValue(payload.timestamp)}  ${formatValue(payload.decisionType)}`);
+        log(`  runId: ${formatValue(payload.runId)}`);
+        log(`  workflowRevision: ${formatValue(payload.workflowRevision)}`);
+        log(`  inputsConsidered: ${formatValue(payload.inputsConsidered)}`);
+        log(`  outcome: ${formatValue(payload.outcome)}`);
+    }
+}

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

@@ -0,0 +1,82 @@
+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,
+        },
+    });
+}

package/dist/src/core/tick-runner.js

@@ -17,6 +17,7 @@ import { createOutbox } from './outbox.js';
 import { createEventResolver } from './event-resolver.js';
 import { createStaleRunReconciler } from './stale-run-reconciler.js';
 import { createWorkspaceCleanup } from './workspace-cleanup.js';
+import { createAutonomousDecisionAuditEvent, workflowRevision as computeWorkflowRevision, } from './audit-events.js';
 import { createRunLease, isRunLeaseExpired, renewRunLease, runLeaseRenewalIntervalMs, } from './run-lease.js';
 import { currentProcessIdentity, processIdentityMatches } from '../lib/process-identity.js';
 import { readJsonFile, writeJsonFile } from '../lib/json-file.js';
@@ -172,6 +173,9 @@ export function createTickRunner(deps) {
     function eventStampNow() {
         return deps.clock.now().toISOString();
     }
+    async function appendAuditEvent(input) {
+        await deps.stateStore.appendEventEnvelope(createAutonomousDecisionAuditEvent(input));
+    }
     // The watchlist is every resource currently correlated to an open work
     // item, deduplicated by exact resourceUri. It is derived once per tick from
     // the pre-poll projection snapshot (see runTick's ordering note) and handed
@@ -309,6 +313,38 @@ export function createTickRunner(deps) {
             await retryUnconfirmedDeliveries();
             const watchlistProjections = await deps.stateStore.listIssueStates();
             const inboundEvents = await ingestInboundEvents(await deps.workSource.pollEvents({ watch: deriveWatchlist(watchlistProjections) }));
+            for (const event of inboundEvents) {
+                const trigger = event.payload.trigger;
+                const workflowName = typeof event.payload.workflow === 'string' ? event.payload.workflow : undefined;
+                const workflow = workflowName === undefined ? undefined : deps.config.workflows[workflowName];
+                if (trigger?.kind !== 'schedule' || workflowName === undefined || workflow === undefined) {
+                    continue;
+                }
+                const timestamp = eventStampNow();
+                await appendAuditEvent({
+                    eventId: `${event.eventId}-audit-trigger-fired`,
+                    decisionType: 'trigger.fired',
+                    workItemKey: event.workItemKey,
+                    runId: event.eventId,
+                    workflowRevision: await computeWorkflowRevision({
+                        config: deps.config,
+                        workflowName,
+                        workflow,
+                    }),
+                    inputsConsidered: {
+                        workflow: workflowName,
+                        schedule: workflow.trigger?.schedule,
+                        trigger,
+                        sourceEventId: event.eventId,
+                    },
+                    outcome: {
+                        fired: true,
+                        sourceEventType: event.sourceEventType,
+                    },
+                    timestamp,
+                    sourceRefs: event.sourceRefs,
+                });
+            }
             const projections = await deps.stateStore.listIssueStates();
             await cleanupClosedIssueWorkspaces(projections);
             if (inboundEvents.length > 0) {
@@ -661,6 +697,35 @@ export function createTickRunner(deps) {
                             },
                         });
                         await deps.stateStore.appendEventEnvelope(approvalCompletedEvent);
+                        if (automaticApproval) {
+                            await appendAuditEvent({
+                                eventId: `${approvalId}-audit-auto-resolution`,
+                                decisionType: 'approval.auto-resolved',
+                                workItemKey: candidate.workItemKey,
+                                runId: approvalId,
+                                workflowRevision: await computeWorkflowRevision({
+                                    config: deps.config,
+                                    workflowName,
+                                    workflow,
+                                    action: approvalResolution.pendingAction,
+                                }),
+                                inputsConsidered: {
+                                    labels: candidate.issue.labels,
+                                    pendingAction: approvalResolution.pendingAction,
+                                    pendingApprovalAllowAutoApproval: candidate.context.pendingApprovalAllowAutoApproval === true,
+                                },
+                                outcome: {
+                                    approved: true,
+                                    nextStage,
+                                    reason: approvalResolution.reason,
+                                },
+                                timestamp: approvedAt,
+                                sourceRefs: {
+                                    repo: candidate.issue.repo,
+                                    issueNumber: candidate.issue.number,
+                                },
+                            });
+                        }
                         await projectionUpdater.rebuildFromEvents([approvalCompletedEvent]);
                         await deliverOutboundEvent(createLabelsEvent({
                             projection: candidate,
@@ -791,6 +856,38 @@ export function createTickRunner(deps) {
                 },
             });
             await deps.stateStore.appendEventEnvelope(claimedEvent);
+            if (watcherRun && watcherDispatch !== null && watcherTriggerForRun !== undefined) {
+                await appendAuditEvent({
+                    eventId: `${runId}-audit-watcher-dispatched`,
+                    decisionType: 'watcher.dispatched',
+                    workItemKey: candidate.workItemKey,
+                    runId,
+                    workflowRevision: await computeWorkflowRevision({
+                        config: deps.config,
+                        workflowName,
+                        workflow: deps.config.workflows[workflowName] ?? workflow,
+                        action,
+                    }),
+                    inputsConsidered: {
+                        parentWorkflowName: watcherDispatch.parentWorkflowName,
+                        parentStage: watcherDispatch.parentStage,
+                        watcherIndex: watcherDispatch.watcherIndex,
+                        watcherStatus: watcherStatus(candidate),
+                        trigger: watcherTriggerForRun,
+                    },
+                    outcome: {
+                        dispatched: true,
+                        targetWorkflowName: workflowName,
+                        action,
+                        claimedStage,
+                    },
+                    timestamp: claimedAt,
+                    sourceRefs: {
+                        repo: candidate.issue.repo,
+                        issueNumber: candidate.issue.number,
+                    },
+                });
+            }
             await transitionRunLifecycle('CLAIMED');
             await projectionUpdater.rebuildFromEvents([claimedEvent]);
             if (watcherStateKeyForRun !== undefined && watcherTriggerForRun !== undefined) {
@@ -907,6 +1004,44 @@ export function createTickRunner(deps) {
                         runnerResult,
                         occurredAt: finishedAt,
                     });
+                    await appendAuditEvent({
+                        eventId: `${runId}-audit-review-verdict`,
+                        decisionType: 'review.verdict',
+                        workItemKey: candidate.workItemKey,
+                        runId,
+                        workflowRevision: await computeWorkflowRevision({
+                            config: deps.config,
+                            workflowName,
+                            workflow: deps.config.workflows[workflowName] ?? workflow,
+                            action,
+                        }),
+                        inputsConsidered: {
+                            sourceRevision,
+                            watcherTrigger: watcherTriggerForRun,
+                            verifiedTargetResourceUri: prReviewTargetResourceUri,
+                            rawSentinel,
+                        },
+                        outcome: {
+                            sentinel,
+                            verdict: prReviewTargetResourceUri === null
+                                ? 'uncertain'
+                                : sentinel === 'DONE'
+                                    ? 'approved'
+                                    : sentinel === 'FAILED'
+                                        ? 'changes-requested'
+                                        : 'uncertain',
+                            reasoning: parsedRunnerResult.body,
+                            runner: {
+                                model: runnerResult.model,
+                                cli: runnerResult.cli,
+                            },
+                        },
+                        timestamp: finishedAt,
+                        sourceRefs: {
+                            repo: candidate.issue.repo,
+                            issueNumber: candidate.issue.number,
+                        },
+                    });
                 }
                 else if (workspaceMode === 'branch') {
                     await registerReportedArtifacts({

package/dist/src/domain/schema.js

@@ -210,6 +210,7 @@ export const WORK_ITEM_CREATED_EVENT = 'wake.workitem.created';
 export const CORRELATION_REGISTERED_EVENT = 'wake.correlation.registered';
 export const CORRELATION_RETRACTED_EVENT = 'wake.correlation.retracted';
 export const CORRELATION_PRIMARY_CONFLICT_EVENT = 'wake.correlation.primary-conflict';
+export const AUTONOMOUS_DECISION_AUDIT_EVENT = 'wake.audit.autonomous-decision';
 /**
  * Shared key for events whose resource failed mint qualification (spec D1').
  * Never a real work item: `readIssueState(UNRESOLVED_WORK_ITEM_KEY)` always

package/dist/src/main.js

@@ -19,6 +19,7 @@ import { createGitHubArtifactVerifier } from './adapters/github/github-artifact-
 import { createGitHubClient } from './adapters/github/github-client.js';
 import { createGitHubIssuesWorkSource } from './adapters/github/github-issues-work-source.js';
 import { createGitHubPullRequestActivitySource } from './adapters/github/github-pull-request-activity-source.js';
+import { runAuditCommand } from './cli/audit-command.js';
 import { runCorrelateCommand } from './cli/correlate-command.js';
 import { runDoctorCommand } from './cli/doctor-command.js';
 import { runInitCommand } from './cli/init-command.js';
@@ -701,6 +702,15 @@ async function runCorrelate(args) {
         readFlag: readFlagBeforeCommandTerminator,
     });
 }
+async function runAudit(args) {
+    const wakeRoot = resolve(readFlagBeforeCommandTerminator('--wake-root', args) ?? process.cwd());
+    const stateStore = createStateStore({ wakeRoot });
+    await stateStore.ensureWakeRoot();
+    await runAuditCommand({
+        args,
+        stateStore,
+    });
+}
 async function runSmoke(args) {
     const runtime = await buildRuntime(args);
     const explicitKind = args[0] === 'claude' || args[0] === 'codex' || args[0] === 'cursor' ? args[0] : undefined;
@@ -783,6 +793,7 @@ export function printUsage(stream) {
         '  wake stop                  Stop the sandbox container gracefully',
         '  wake smoke                 Smoke-test the configured runner',
         '  wake ui                    Run the control-plane UI server',
+        '  wake audit                 Show autonomous decision audit history',
         '  wake correlate             Manually correlate a resource to a work item',
         '  wake doctor                Diagnose config/GitHub/Docker/sandbox setup problems',
         '  wake --version             Print the installed Wake version',
@@ -792,14 +803,22 @@ export function printUsage(stream) {
         '  1. wake init ./wake-home',
         '  2. cd wake-home && wake start',
         '',
-        'Runtime commands (tick/start/ui/smoke/correlate/validate-state) auto-delegate into the sandbox',
+        'Runtime commands (tick/start/ui/smoke/audit/correlate/validate-state) auto-delegate into the sandbox',
         'when docker/Dockerfile exists at --wake-root (i.e. after `wake sandbox build`),',
         'defaulting --wake-root to the current directory. Pass --no-sandbox to run',
         'directly on the host instead.',
         '',
     ].join('\n'));
 }
-const runtimeCommands = new Set(['tick', 'start', 'ui', 'smoke', 'correlate', 'validate-state']);
+const runtimeCommands = new Set([
+    'tick',
+    'start',
+    'ui',
+    'smoke',
+    'audit',
+    'correlate',
+    'validate-state',
+]);
 export async function dispatchMainCommand(input) {
     const command = input.args[0] ?? 'help';
     if (command === '--version' || command === '-v') {
@@ -855,6 +874,12 @@ export async function dispatchMainCommand(input) {
         else if (command === 'ui') {
             await input.runUi(hostArgs);
         }
+        else if (command === 'audit') {
+            if (input.runAudit === undefined) {
+                throw new CliUsageError('audit command is not available in this runtime');
+            }
+            await input.runAudit(hostArgs);
+        }
         else if (command === 'smoke') {
             await input.runSmoke(hostArgs);
         }
@@ -991,6 +1016,7 @@ async function main() {
         runStart,
         runSmoke,
         runUi,
+        runAudit,
         runCorrelate,
         runValidateState,
         execIntoSandbox: async (commandArgs) => {

package/dist/src/version.js

@@ -124,4 +124,4 @@ export function resolveWakeVersion(options = {}) {
     }
     return '0.1.0-dev';
 }
-export const wakeVersion = "g8ab2018";
+export const wakeVersion = "gecbffd3";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atolis-hq/wake",
-  "version": "0.2.40",
+  "version": "0.2.41",
   "description": "Local autonomous agent control plane for software development",
   "license": "Apache-2.0",
   "repository": {