@atolis-hq/wake 0.2.92 → 0.2.94

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

@@ -194,7 +194,7 @@ export function createTickRunner(deps) {
         isRunningRecordActive,
         deliverOutboundEvent,
     });
-    const { cleanupClosedIssueWorkspaces } = createWorkspaceCleanup({
+    const { cleanupClosedIssueWorkspaces, sweepExpiredTranscriptDirs } = createWorkspaceCleanup({
         clock: deps.clock,
         config: deps.config,
         stateStore: deps.stateStore,
@@ -374,14 +374,12 @@ export function createTickRunner(deps) {
         const targetResourceUri = input.approvalResolution.targetResourceUri;
         const commentId = input.approvalResolution.triggeringCommentId.replace(/[^a-z0-9]+/gi, '-');
         const reviewBody = reviewerMessageFromApprovalComment(input.approvalResolution.triggeringCommentBody ?? '');
-        // Never enumerate specific rejection reasons (self-approval, merge-method
-        // restrictions, branch protection, ...) by string-matching the merge
-        // actor's error — there are too many, and Wake shouldn't need to know
-        // its provider's vocabulary. Any failure here is permanent enough not to
-        // retry blindly forever, so it becomes a policy block with the actor's
-        // own message attached. approve and autoMerge are independent: one
-        // failing doesn't stop the other from being attempted.
-        const blockedReasons = [];
+        // approve and autoMerge are independent: one failing doesn't stop the
+        // other from being attempted. If autoMerge succeeds, a failed approval is
+        // not a policy block on its own; GitHub can reject self-approval while
+        // still accepting auto-merge for repos that do not require review.
+        const approvalBlockedReasons = [];
+        const autoMergeBlockedReasons = [];
         const approvedEventId = `pr-merge-approved-${commentId}`;
         if (input.mergePolicy.approve &&
             (await deps.stateStore.readEventEnvelope(approvedEventId)) === null) {
@@ -408,10 +406,11 @@ export function createTickRunner(deps) {
                 }));
             }
             catch (error) {
-                blockedReasons.push(`Merge policy blocked the approval step: ${describeMergeActorError(error)}`);
+                approvalBlockedReasons.push(`Merge policy blocked the approval step: ${describeMergeActorError(error)}`);
             }
         }
         const autoMergeEventId = `pr-auto-merge-enabled-${commentId}`;
+        let autoMergeSucceeded = false;
         if (input.mergePolicy.autoMerge &&
             (await deps.stateStore.readEventEnvelope(autoMergeEventId)) === null) {
             try {
@@ -435,14 +434,52 @@ export function createTickRunner(deps) {
                         idempotencyKey: `${input.approvalResolution.triggeringCommentId}:pr-auto-merge`,
                     },
                 }));
+                autoMergeSucceeded = true;
             }
             catch (error) {
-                blockedReasons.push(`Merge policy blocked the auto-merge step: ${describeMergeActorError(error)}`);
+                autoMergeBlockedReasons.push(`Merge policy blocked the auto-merge step: ${describeMergeActorError(error)}`);
             }
         }
+        else if (input.mergePolicy.autoMerge) {
+            autoMergeSucceeded = true;
+        }
+        const blockedReasons = autoMergeSucceeded && input.mergePolicy.autoMerge
+            ? autoMergeBlockedReasons
+            : [...approvalBlockedReasons, ...autoMergeBlockedReasons];
         if (blockedReasons.length > 0) {
             return { blocked: true, reason: blockedReasons.join(' ') };
         }
+        // Approval failed but auto-merge covered it (e.g. GitHub rejecting
+        // self-approval on the bot's own PR) - not a policy block, but the
+        // failure should still leave a visible trail instead of vanishing
+        // silently, since it may also be a real permissions/config problem.
+        if (approvalBlockedReasons.length > 0) {
+            const occurredAt = eventStampNow();
+            await deliverOutboundEvent(createEventEnvelope({
+                eventId: `pr-merge-approval-note-${commentId}`,
+                workItemKey: input.projection.workItemKey,
+                streamScope: 'work-item',
+                direction: 'outbound',
+                sourceSystem: 'wake',
+                sourceEventType: PUBLISH_INTENT_REQUESTED_EVENT,
+                sourceRefs: {
+                    repo: input.projection.issue.repo,
+                    issueNumber: input.projection.issue.number,
+                    resourceUri: targetResourceUri,
+                },
+                occurredAt,
+                ingestedAt: occurredAt,
+                trigger: 'context-only',
+                payload: {
+                    kind: 'status-update',
+                    origin: input.projection.origin ?? 'github',
+                    body: `Approval step did not block the merge, but did not succeed on its own: ${approvalBlockedReasons.join(' ')}`,
+                    idempotencyKey: `${commentId}:pr-merge-approval-note`,
+                    deliveryState: 'PENDING',
+                },
+                derivedHints: { stage: input.projection.wake.stage },
+            }));
+        }
         return { blocked: false };
     }
     // The one deterministic approval transition: /approved, wake:auto, and a
@@ -883,6 +920,7 @@ export function createTickRunner(deps) {
             }
             const projections = await deps.stateStore.listIssueStates();
             await cleanupClosedIssueWorkspaces(projections);
+            await sweepExpiredTranscriptDirs();
             // Runs every tick, not only when this tick happened to poll a fresh
             // inbound event — a stale label on a parked item (nothing else ever
             // re-checks it once there's no next action) otherwise never self-heals.
@@ -2054,7 +2092,7 @@ export function createTickRunner(deps) {
                             },
                             payload: {
                                 ...publishIntent.payload,
-                                kind: sentinel === 'DONE' ? 'approval-request' : 'status-update',
+                                kind: 'status-update',
                                 body: sentinel === 'DONE'
                                     ? `${parsedRunnerResult.body}\n\n${prReviewApprovalMarker}`
                                     : `${parsedRunnerResult.body}\n\n<!-- wake:pr-review-changes-requested -->`,

package/dist/src/core/workspace-cleanup.js

@@ -1,8 +1,9 @@
-import { rm } from 'node:fs/promises';
+import { readdir, readFile, rm, stat, writeFile } from 'node:fs/promises';
 import { isAbsolute, join, relative } from 'node:path';
 import { WORKSPACE_CLEANED_EVENT, WORKSPACE_CLEANUP_FAILED_EVENT } from '../domain/event-types.js';
 import { createEventEnvelope } from '../lib/event-log.js';
-// Cleans up per-issue workspaces (and, unless retained, transcripts) once the
+const TRANSCRIPT_CLEANED_AT_MARKER = '.cleaned-at';
+// Cleans up per-issue workspaces and applies transcript retention once the
 // originating issue is closed. A cleanup failure is recorded as an event and
 // skipped rather than aborting the sweep.
 export function createWorkspaceCleanup(deps) {
@@ -14,6 +15,49 @@ export function createWorkspaceCleanup(deps) {
         const rel = relative(workspacesRoot, workspacePath);
         return !rel.startsWith('..') && !isAbsolute(rel) && rel.length > 0;
     }
+    async function markTranscriptDirectoryCleaned(workItemKey, cleanedAt) {
+        const transcriptDir = deps.stateStore.paths.transcriptWorkDir(workItemKey);
+        const transcriptDirStat = await stat(transcriptDir).catch(() => undefined);
+        if (transcriptDirStat === undefined || !transcriptDirStat.isDirectory()) {
+            return;
+        }
+        await writeFile(join(transcriptDir, TRANSCRIPT_CLEANED_AT_MARKER), `${cleanedAt}\n`, 'utf8');
+    }
+    async function applyTranscriptCleanupRetention(workItemKey, cleanedAt) {
+        if (deps.config.transcripts.retentionMs === 0) {
+            await rm(deps.stateStore.paths.transcriptWorkDir(workItemKey), {
+                recursive: true,
+                force: true,
+            });
+            return;
+        }
+        await markTranscriptDirectoryCleaned(workItemKey, cleanedAt);
+    }
+    async function sweepExpiredTranscriptDirs() {
+        const retentionMs = deps.config.transcripts.retentionMs;
+        const transcriptDirs = await readdir(deps.stateStore.paths.transcriptsRoot, {
+            withFileTypes: true,
+        }).catch(() => []);
+        const nowMs = deps.clock.now().getTime();
+        for (const entry of transcriptDirs) {
+            if (!entry.isDirectory()) {
+                continue;
+            }
+            const transcriptDir = join(deps.stateStore.paths.transcriptsRoot, entry.name);
+            const markerPath = join(transcriptDir, TRANSCRIPT_CLEANED_AT_MARKER);
+            const marker = await readFile(markerPath, 'utf8').catch(() => undefined);
+            if (marker === undefined) {
+                continue;
+            }
+            const cleanedAtMs = Date.parse(marker.trim());
+            if (!Number.isFinite(cleanedAtMs)) {
+                continue;
+            }
+            if (nowMs - cleanedAtMs >= retentionMs) {
+                await rm(transcriptDir, { recursive: true, force: true });
+            }
+        }
+    }
     async function cleanupClosedIssueWorkspaces(projections) {
         for (const projection of projections) {
             const { workspacePath } = projection.wake;
@@ -22,12 +66,7 @@ export function createWorkspaceCleanup(deps) {
                 isPerIssueWorkspacePath(workspacePath)) {
                 try {
                     await deps.workspaceManager.cleanupWorkspace({ workspacePath });
-                    if (!deps.config.transcripts.retainAfterWorkspaceCleanup) {
-                        await rm(deps.stateStore.paths.transcriptWorkDir(projection.workItemKey), {
-                            recursive: true,
-                            force: true,
-                        });
-                    }
+                    await applyTranscriptCleanupRetention(projection.workItemKey, eventStampNow());
                 }
                 catch (error) {
                     const failedAt = eventStampNow();
@@ -74,5 +113,5 @@ export function createWorkspaceCleanup(deps) {
             }
         }
     }
-    return { cleanupClosedIssueWorkspaces };
+    return { cleanupClosedIssueWorkspaces, sweepExpiredTranscriptDirs };
 }

package/dist/src/domain/schema.js

@@ -691,9 +691,13 @@ const wakeConfigBaseSchema = z.object({
     transcripts: z
         .object({
         enabled: z.boolean().default(false),
-        retainAfterWorkspaceCleanup: z.boolean().default(false),
+        retentionMs: z
+            .number()
+            .int()
+            .nonnegative()
+            .default(3 * 24 * 60 * 60 * 1000),
     })
-        .default({ enabled: false, retainAfterWorkspaceCleanup: false }),
+        .default({ enabled: false, retentionMs: 3 * 24 * 60 * 60 * 1000 }),
     retry: z
         .object({
         maxFailureRetries: z.number().int().positive().default(5),
@@ -1090,8 +1094,16 @@ function attachDerivedPromptContext(config) {
     return config;
 }
 export function parseWakeConfig(input) {
+    if (isRecord(input) &&
+        isRecord(input.transcripts) &&
+        'retainAfterWorkspaceCleanup' in input.transcripts) {
+        throw new Error('transcripts.retainAfterWorkspaceCleanup is no longer supported; use transcripts.retentionMs instead. Set transcripts.retentionMs to 0 to delete transcripts immediately on workspace cleanup.');
+    }
     return structuredClone(attachDerivedPromptContext(wakeConfigSchema.parse(input)));
 }
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
 export function parseSourceStateRecord(input) {
     return sourceStateRecordSchema.parse(input);
 }

package/dist/src/version.js

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

package/package.json

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