@atolis-hq/wake 0.2.93 → 0.2.95

package/dist/src/core/projection-updater.js

@@ -268,6 +268,10 @@ async function applyEvent(current, event, ctx, config) {
             config !== undefined &&
             isCustomCommandAction(payload.action, config);
         const shouldClearSession = isForwardProgression || isFailed;
+        const hasPendingChangesRequested = (typeof current.context.changesRequestedCount === 'number' &&
+            current.context.changesRequestedCount > 0) ||
+            current.context.changesRequestedFeedback !== undefined;
+        const resolvesChangesRequested = sentinel === doneRunnerSentinel && (!hasPendingChangesRequested || !approvalGated);
         const currentFailureCount = typeof current.context.failureCount === 'number' &&
             Number.isInteger(current.context.failureCount)
             ? current.context.failureCount
@@ -327,9 +331,11 @@ async function applyEvent(current, event, ctx, config) {
                         approvalGated,
                     }),
                 }),
-            // A fresh DONE cycle (gated or not) resolves whatever changes were
-            // previously requested — reset the loop counter and stored feedback.
-            ...(sentinel === doneRunnerSentinel
+            // An approval-gated DONE after changes-requested only resubmits work for
+            // review; the next reviewer verdict decides whether the request was
+            // actually resolved. Keep the retry counter through that gate so
+            // repeated rejections can hit the configured escalation cap.
+            ...(resolvesChangesRequested
                 ? { changesRequestedCount: 0, changesRequestedFeedback: undefined }
                 : {}),
         };

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,
@@ -920,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.

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,15 +691,19 @@ 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),
-        maxChangesRequestedRetries: z.number().int().positive().default(5),
+        maxChangesRequestedRetries: z.number().int().positive().default(3),
     })
-        .default({ maxFailureRetries: 5, maxChangesRequestedRetries: 5 }),
+        .default({ maxFailureRetries: 5, maxChangesRequestedRetries: 3 }),
     runners: z.record(z.string(), runnerEntrySchema).default({
         fake: { kind: 'fake', cli: 'Fake' },
         'claude-haiku': {
@@ -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 = "g5c69d41";
+export const wakeVersion = "g803f372";

package/package.json

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