mandrel 2.17.0 → 2.18.0

package/.agents/docs/agentrc-reference.json

@@ -128,6 +128,16 @@
     "docsFreshness": {
       "paths": ["README.md"]
     },
+    "tempRetention": {
+      "enabled": true,
+      "staleDays": 7,
+      "classes": {
+        "orchestrationLogs": true,
+        "validationEvidence": true,
+        "auditResults": true,
+        "planDirs": true
+      }
+    },
     "deliverRunner": {
       "concurrencyCap": 3
     },

package/.agents/docs/configuration.md

@@ -125,6 +125,14 @@ top-level keys are validation errors.
 | `lease.ttlMs` | No | `integer` | — | — |
 | `docsFreshness` | No | `object` | — | Nested configuration block. |
 | `docsFreshness.paths` | No | `array` | — | — |
+| `tempRetention` | No | `object` | — | Story #4794. Auto-purge of spent temp artifacts once their Story lands. Classification is an allowlist: only the declared classes below are ever deleted, so operator scratch files under tempRoot are reported with their size and left alone. signals.ndjson is never purged by any path. |
+| `tempRetention.enabled` | No | `boolean` | — | Master switch. Default true — reclaiming a landed Story's gate transcripts and validation evidence is the behaviour, and this knob turns it off. When false every purge path is a reported no-op. |
+| `tempRetention.staleDays` | No | `integer` | — | Age floor (days, default 7) for the families no Story id can be recovered from — roster-level audit reports and abandoned plan-<slug>/ dirs. Story-keyed artifacts do not wait for it: they are purged as soon as their merge is confirmed. |
+| `tempRetention.classes` | No | `object` | — | Per-class opt-out. Each defaults to true; set one false to keep that family while the rest are purged. |
+| `tempRetention.classes.orchestrationLogs` | No | `boolean` | — | <tempRoot>/orchestration/*.log — close gate transcripts and terse-result detail dumps. |
+| `tempRetention.classes.validationEvidence` | No | `boolean` | — | Per-Story validation-evidence.json, lifecycle.ndjson, and manifest.md under the standalone and per-run story trees. |
+| `tempRetention.classes.auditResults` | No | `boolean` | — | <tempRoot>/audits/ — audit lens reports. |
+| `tempRetention.classes.planDirs` | No | `boolean` | — | <tempRoot>/plan-<slug>/ — abandoned plan authoring dirs. Age-floored only; the current run is always excluded. |
 | `deliverRunner` | No | `object` | — | Nested configuration block. |
 | `deliverRunner.concurrencyCap` | No | `integer` | — | Maximum ready Stories dispatched by /deliver at once. Default 3. Moderate by design — keeps host-quota consumption predictable while allowing a small ready-set fan-out. Set 1 for strictly sequential delivery; raise further on hosts with adequate parallel-agent quota. See deliver.md for the sequencing model and throughput tradeoff. |
 | `worktreeIsolation` | No | `object` | — | Nested configuration block. |

package/.agents/schemas/agentrc.schema.json

@@ -441,6 +441,45 @@
       },
       "additionalProperties": false
     },
+    "tempRetention": {
+      "type": "object",
+      "description": "Story #4794. Auto-purge of spent temp artifacts once their Story lands. Classification is an allowlist: only the declared classes below are ever deleted, so operator scratch files under tempRoot are reported with their size and left alone. signals.ndjson is never purged by any path.",
+      "properties": {
+        "enabled": {
+          "type": "boolean",
+          "description": "Master switch. Default true — reclaiming a landed Story's gate transcripts and validation evidence is the behaviour, and this knob turns it off. When false every purge path is a reported no-op."
+        },
+        "staleDays": {
+          "type": "integer",
+          "minimum": 1,
+          "description": "Age floor (days, default 7) for the families no Story id can be recovered from — roster-level audit reports and abandoned plan-<slug>/ dirs. Story-keyed artifacts do not wait for it: they are purged as soon as their merge is confirmed."
+        },
+        "classes": {
+          "type": "object",
+          "description": "Per-class opt-out. Each defaults to true; set one false to keep that family while the rest are purged.",
+          "properties": {
+            "orchestrationLogs": {
+              "type": "boolean",
+              "description": "<tempRoot>/orchestration/*.log — close gate transcripts and terse-result detail dumps."
+            },
+            "validationEvidence": {
+              "type": "boolean",
+              "description": "Per-Story validation-evidence.json, lifecycle.ndjson, and manifest.md under the standalone and per-run story trees."
+            },
+            "auditResults": {
+              "type": "boolean",
+              "description": "<tempRoot>/audits/ — audit lens reports."
+            },
+            "planDirs": {
+              "type": "boolean",
+              "description": "<tempRoot>/plan-<slug>/ — abandoned plan authoring dirs. Age-floored only; the current run is always excluded."
+            }
+          },
+          "additionalProperties": false
+        }
+      },
+      "additionalProperties": false
+    },
     "docsFreshness": {
       "type": "object",
       "properties": {
@@ -1324,6 +1363,9 @@
         "docsFreshness": {
           "$ref": "#/$defs/docsFreshness"
         },
+        "tempRetention": {
+          "$ref": "#/$defs/tempRetention"
+        },
         "deliverRunner": {
           "$ref": "#/$defs/deliverRunner"
         },

package/.agents/schemas/story-deliver-terminal.schema.json

@@ -86,13 +86,18 @@
         "followUps",
         "statusResync",
         "refCleanup",
-        "baseFastForward"
+        "baseFastForward",
+        "tempPurge"
       ],
       "properties": {
         "followUps": { "type": "boolean" },
         "statusResync": { "type": "boolean" },
         "refCleanup": { "type": "boolean" },
         "baseFastForward": { "type": "boolean" },
+        "tempPurge": {
+          "type": "boolean",
+          "description": "Story #4794 — the merged Story's spent temp artifacts (gate transcripts, validation evidence) were purged under delivery.tempRetention. A disabled policy reports true: the operator turned the purge off, so doing nothing IS the correct outcome. Only a real failure — an unreadable temp root, an undeletable artifact — reports false, and like every tail step that degrades the report, never the land."
+        },
         "details": {
           "type": "object",
           "description": "Per-step diagnostic detail — the reason a false step reported false.",

package/.agents/scripts/boot-sweep.js

@@ -46,6 +46,25 @@ import { Logger } from './lib/Logger.js';
 import { createProvider } from './lib/provider-factory.js';
 import { buildProtectionCtx } from './lib/single-story-sweep/protection-ctx.js';
 import { sweepMergedBranches } from './lib/single-story-sweep.js';
+import { sweepTempRetention } from './lib/temp-retention.js';
+
+/**
+ * Recover the Story ids from the branch names a sweep reaped. Only the
+ * canonical `story-<id>` shape yields an id — an operator's ad-hoc branch that
+ * happened to match the include glob contributes nothing, so a purge can never
+ * be triggered by a name this framework did not create.
+ *
+ * @param {string[]|undefined} branches
+ * @returns {number[]}
+ */
+export function storyIdsFromBranches(branches) {
+  const ids = [];
+  for (const branch of Array.isArray(branches) ? branches : []) {
+    const match = /^story-(\d+)$/.exec(String(branch));
+    if (match) ids.push(Number(match[1]));
+  }
+  return ids;
+}
 
 const HELP = `Usage: node .agents/scripts/boot-sweep.js [options]
 
@@ -85,9 +104,11 @@ Options:
  *   injectedConfig?: object,
  *   injectedProvider?: object,
  *   injectedSweep?: Function,
+ *   purgeFn?: Function,
  *   logger?: { info?: Function, warn?: Function },
  * }} [args]
- * @returns {Promise<object>} the {@link sweepMergedBranches} envelope.
+ * @returns {Promise<object>} the {@link sweepMergedBranches} envelope, plus a
+ *   `tempPurge` result from the Story #4794 temp-retention catch-up.
  */
 export async function runBootSweep({
   cwd,
@@ -99,6 +120,7 @@ export async function runBootSweep({
   injectedConfig,
   injectedProvider,
   injectedSweep,
+  purgeFn = sweepTempRetention,
   logger = Logger,
 } = {}) {
   const root = path.resolve(cwd ?? PROJECT_ROOT);
@@ -125,7 +147,7 @@ export async function runBootSweep({
       config.delivery?.worktreeIsolation?.sweepLockMs ?? 60_000;
 
     const sweepFn = injectedSweep ?? sweepMergedBranches;
-    return await sweepFn({
+    const result = await sweepFn({
       cwd: root,
       baseBranch,
       include: includeGlobs,
@@ -140,6 +162,21 @@ export async function runBootSweep({
       lockPath,
       lockTimeoutMs,
     });
+
+    // Story #4794 — the temp-retention catch-up. Two eligibility signals, both
+    // already paid for: every branch this sweep reaped is a merge it CONFIRMED
+    // (merged PR + matching headRefOid), so those Stories' artifacts are spent;
+    // and the age floor collects everything else — the backlog from Stories
+    // merged before this existed, merged through the GitHub UI, or whose branch
+    // was already gone. Best-effort like the sweep itself: `runBootSweep`'s
+    // catch swallows any throw into the `ok: false` envelope, and exit stays 0.
+    const purge = await purgeFn({
+      config,
+      mergedStoryIds: storyIdsFromBranches(result?.reaped),
+      label: 'boot-sweep',
+      logger,
+    });
+    return { ...result, tempPurge: purge };
   } catch (err) {
     const msg = err?.message ?? String(err);
     logger.warn?.(`[boot-sweep] sweep threw (host continues): ${msg}`);

package/.agents/scripts/lib/config/temp-paths.js

@@ -274,6 +274,33 @@ export function tempRootFrom(config) {
     : 'temp';
 }
 
+/**
+ * Directory segment (under `tempRoot`) holding every orchestration run log —
+ * the close gate transcripts (`close-gates-<sid>.log`) and the terse-result
+ * detail dumps (`story-init-result-<sid>.log`, `sync-result-<branch>.log`, …).
+ *
+ * Story #4794: the four writers that land here each hand-rolled the temp path
+ * from a literal `temp` segment joined onto their own cwd, which ignores
+ * `project.paths.tempRoot` entirely. On a consumer that relocates its temp
+ * root, the writers wrote to `<cwd>/temp/` while every reader — including the
+ * retention purge — resolved the configured root, so the artifacts were
+ * invisible to the tooling meant to manage them. Routing all four through this
+ * helper also picks up main-checkout anchoring for free, so a close running
+ * from a Story worktree lands its logs in the same tree the host reads.
+ */
+export const ORCHESTRATION_DIRNAME = 'orchestration';
+
+/**
+ * `<tempRoot>/orchestration/` — resolved against the configured temp root and
+ * anchored to the main checkout, like every other helper in this module.
+ *
+ * @param {object} [config]
+ * @returns {string}
+ */
+export function orchestrationLogDir(config) {
+  return path.join(anchorTempRoot(tempRootFrom(config)), ORCHESTRATION_DIRNAME);
+}
+
 const runId = (id) => {
   if (!Number.isInteger(id) || id <= 0) {
     throw new Error(`[temp-paths] runId must be a positive integer; got ${id}`);

package/.agents/scripts/lib/config-settings-schema-delivery.js

@@ -352,12 +352,81 @@ const AUDIT_TO_STORIES_SCHEMA = {
   additionalProperties: false,
 };
 
+/**
+ * `delivery.tempRetention` — auto-purge of spent temp artifacts (Story #4794).
+ *
+ * `enabled` defaults to `true`: reclaiming a landed Story's gate transcripts
+ * and evidence is the behaviour, and the knob exists to turn it off. `classes`
+ * lets an operator keep one family while purging the rest; `staleDays` is the
+ * age floor for the families no Story id can be recovered from (audit reports,
+ * abandoned `plan-<slug>/` dirs).
+ */
+const TEMP_RETENTION_SCHEMA = {
+  type: 'object',
+  description:
+    'Story #4794. Auto-purge of spent temp artifacts once their Story lands. ' +
+    'Classification is an allowlist: only the declared classes below are ever ' +
+    'deleted, so operator scratch files under tempRoot are reported with their ' +
+    'size and left alone. signals.ndjson is never purged by any path.',
+  properties: {
+    enabled: {
+      type: 'boolean',
+      description:
+        "Master switch. Default true — reclaiming a landed Story's gate " +
+        'transcripts and validation evidence is the behaviour, and this knob ' +
+        'turns it off. When false every purge path is a reported no-op.',
+    },
+    staleDays: {
+      type: 'integer',
+      minimum: 1,
+      description:
+        'Age floor (days, default 7) for the families no Story id can be ' +
+        'recovered from — roster-level audit reports and abandoned ' +
+        'plan-<slug>/ dirs. Story-keyed artifacts do not wait for it: they are ' +
+        'purged as soon as their merge is confirmed.',
+    },
+    classes: {
+      type: 'object',
+      description:
+        'Per-class opt-out. Each defaults to true; set one false to keep that ' +
+        'family while the rest are purged.',
+      properties: {
+        orchestrationLogs: {
+          type: 'boolean',
+          description:
+            '<tempRoot>/orchestration/*.log — close gate transcripts and ' +
+            'terse-result detail dumps.',
+        },
+        validationEvidence: {
+          type: 'boolean',
+          description:
+            'Per-Story validation-evidence.json, lifecycle.ndjson, and ' +
+            'manifest.md under the standalone and per-run story trees.',
+        },
+        auditResults: {
+          type: 'boolean',
+          description: '<tempRoot>/audits/ — audit lens reports.',
+        },
+        planDirs: {
+          type: 'boolean',
+          description:
+            '<tempRoot>/plan-<slug>/ — abandoned plan authoring dirs. ' +
+            'Age-floored only; the current run is always excluded.',
+        },
+      },
+      additionalProperties: false,
+    },
+  },
+  additionalProperties: false,
+};
+
 export const DELIVERY_SCHEMA = {
   type: 'object',
   properties: {
     execution: EXECUTION_SCHEMA,
     lease: LEASE_SCHEMA,
     docsFreshness: DOCS_FRESHNESS_SCHEMA,
+    tempRetention: TEMP_RETENTION_SCHEMA,
     deliverRunner: DELIVER_RUNNER_SCHEMA,
     worktreeIsolation: WORKTREE_ISOLATION_SCHEMA,
     signals: SIGNALS_SCHEMA,

package/.agents/scripts/lib/observability/terse-result.js

@@ -1,6 +1,7 @@
 import nodeFs from 'node:fs';
 import path from 'node:path';
 
+import { orchestrationLogDir } from '../config/temp-paths.js';
 import { Logger } from '../Logger.js';
 
 /**
@@ -69,8 +70,10 @@ function detailBlock(label, result) {
  *   on; serialized compactly onto the single summary line.
  * @param {string|number} [args.scope] Disambiguating suffix for the log name
  *   (typically the Story id) so concurrent deliveries don't clobber one file.
- * @param {string} [args.logDir] Directory for the detail log. Defaults to
- *   `<cwd>/temp/orchestration`.
+ * @param {string} [args.logDir] Directory for the detail log. Defaults to the
+ *   configured `<tempRoot>/orchestration` (Story #4794 — was a hardcoded
+ *   `<cwd>/temp/orchestration`, which ignored `project.paths.tempRoot`).
+ * @param {object} [args.config] Resolved config bag, for the default `logDir`.
  * @param {typeof nodeFs} [args.fs] Filesystem seam (tests).
  * @param {{ info: (m: string) => void }} [args.log] Logger seam (tests).
  * @param {NodeJS.ProcessEnv} [args.env] Environment seam (tests).
@@ -82,6 +85,7 @@ export function emitTerseResult({
   summary = {},
   scope,
   logDir,
+  config,
   fs = nodeFs,
   log = Logger,
   env = process.env,
@@ -94,7 +98,7 @@ export function emitTerseResult({
     return { logPath: null, inline: true };
   }
 
-  const dir = logDir ?? path.join(process.cwd(), 'temp', 'orchestration');
+  const dir = logDir ?? orchestrationLogDir(config);
   const name = `${slugify(label)}${scope ? `-${scope}` : ''}.log`;
 
   try {

package/.agents/scripts/lib/orchestration/plan-persist/run-plan-persist.js

@@ -37,13 +37,12 @@
  * @module lib/orchestration/plan-persist/run-plan-persist
  */
 
-import { readdir, rm, stat } from 'node:fs/promises';
+import { rm } from 'node:fs/promises';
 import path from 'node:path';
-
-import { anchorTempRoot, tempRootFrom } from '../../config/temp-paths.js';
 import { getLimits, PROJECT_ROOT } from '../../config-resolver.js';
 import { gitSpawn } from '../../git-utils.js';
 import { Logger } from '../../Logger.js';
+import { sweepTempRetention } from '../../temp-retention.js';
 import {
   deriveStoryShape,
   LITE_ROUTE_LABEL,
@@ -374,13 +373,6 @@ function resolveEffectiveRoute({
   };
 }
 
-/**
- * Age after which an abandoned `temp/plan-*` directory is reaped. A plan run
- * that is still being authored is minutes-to-hours old; a week is far past
- * any live run and comfortably past an operator returning to a paused one.
- */
-const STALE_PLAN_DIR_MS = 7 * 24 * 60 * 60 * 1000;
-
 /**
  * Reap abandoned `plan-*` directories under the temp root (Story #4541).
  *
@@ -389,9 +381,16 @@ const STALE_PLAN_DIR_MS = 7 * 24 * 60 * 60 * 1000;
  * `--dry-run` left its directory behind forever. This sweeps the stragglers
  * on each persist.
  *
+ * Story #4794 folded the age-floored reap into the shared temp-retention
+ * engine — `planDirs` is one of its declared classes, so the plan path and
+ * the delivery path now converge on one classifier and one staleness floor
+ * (`delivery.tempRetention.staleDays`, still 7 days by default) instead of
+ * this module owning a private constant. Behaviour is unchanged: only
+ * `plan-*` directories are considered, the age test is the directory's own
+ * mtime, and the current run's `planDir` is excluded.
+ *
  * Best-effort throughout: this is hygiene, never a reason to fail a run that
- * has already created Stories. The current run's own `planDir` is always
- * excluded — its cleanup is the caller's decision.
+ * has already created Stories.
  *
  * @param {{ config?: object, keepDir?: string|null, now?: number }} args
  * @returns {Promise<{ reaped: string[] }>}
@@ -401,35 +400,14 @@ export async function reapStalePlanDirs({
   keepDir = null,
   now = Date.now(),
 } = {}) {
-  const reaped = [];
-  const tempRoot = anchorTempRoot(tempRootFrom(config));
-  let entries;
-  try {
-    entries = await readdir(tempRoot, { withFileTypes: true });
-  } catch {
-    return { reaped }; // No temp root yet — nothing to reap.
-  }
-  const keep = keepDir ? path.resolve(keepDir) : null;
-  for (const entry of entries) {
-    if (!entry.isDirectory() || !entry.name.startsWith('plan-')) continue;
-    const dir = path.resolve(tempRoot, entry.name);
-    if (keep !== null && dir === keep) continue;
-    try {
-      const { mtimeMs } = await stat(dir);
-      if (now - mtimeMs < STALE_PLAN_DIR_MS) continue;
-      await rm(dir, { recursive: true, force: true });
-      reaped.push(dir);
-    } catch {
-      // A racing writer or a permission error: leave it for the next run.
-    }
-  }
-  if (reaped.length > 0) {
-    Logger.info(
-      `[plan-persist] reaped ${reaped.length} abandoned plan director(ies) ` +
-        `older than 7d under ${tempRoot}.`,
-    );
-  }
-  return { reaped };
+  const result = await sweepTempRetention({
+    config,
+    only: ['planDirs'],
+    excludePaths: keepDir ? [keepDir] : [],
+    now,
+    label: 'plan-persist',
+  });
+  return { reaped: result.purged.map((entry) => entry.path) };
 }
 
 /**

package/.agents/scripts/lib/orchestration/single-story-close/gate-log.js

@@ -59,6 +59,7 @@
 import nodeFs from 'node:fs';
 import path from 'node:path';
 
+import { orchestrationLogDir } from '../../config/temp-paths.js';
 import { Logger, resolveLevel } from '../../Logger.js';
 
 /**
@@ -210,26 +211,29 @@ function createArtifactWriter(fs, logPath, handle) {
  *
  * @param {{
  *   storyId: number|null,
- *   cwd?: string,
  *   logDir?: string,
  *   fs?: typeof nodeFs,
  *   logger?: { info: (m: string) => void },
  *   level?: string,
- * }} [args] `logDir` defaults to `<cwd>/temp/orchestration`; `level` defaults
- *   to the live Logger level so `AGENT_LOG_LEVEL=verbose` restores streaming.
+ *   config?: object,
+ * }} [args] `logDir` defaults to the configured `<tempRoot>/orchestration`
+ *   (Story #4794 — was a hardcoded `<cwd>/temp/orchestration`, which ignored
+ *   `project.paths.tempRoot` and hid the artifact from the retention purge);
+ *   `level` defaults to the live Logger level so `AGENT_LOG_LEVEL=verbose`
+ *   restores streaming.
  * @returns {GateLogSink}
  */
 export function createGateLogSink({
   storyId = null,
-  cwd = process.cwd(),
   logDir,
   fs = nodeFs,
   logger = Logger,
   level,
+  config,
 } = {}) {
   const emit = (line) => logger.info?.(line);
   const verbose = (level ?? resolveLevel()) === 'verbose';
-  const dir = logDir ?? path.join(cwd, 'temp', 'orchestration');
+  const dir = logDir ?? orchestrationLogDir(config);
 
   let writer = null;
   let logPath = null;

package/.agents/scripts/lib/orchestration/single-story-close/phases/close-validation.js

@@ -143,7 +143,7 @@ export async function runCloseValidationPhase({
   );
   // Story #4736 — one sink for both `log` seams (gate construction and gate
   // execution), so nothing in the chain can route around the artifact.
-  const gateLog = createGateLogSink({ storyId, cwd });
+  const gateLog = createGateLogSink({ storyId, config });
   let validation;
   try {
     validation = await runCloseValidation({

package/.agents/scripts/lib/orchestration/single-story-close/phases/post-land.js

@@ -39,6 +39,7 @@ import {
   RUNTIME_FRICTION_CATEGORIES,
 } from '../../../observability/runtime-friction.js';
 import { acquireLockWithWait as defaultAcquireLockWithWait } from '../../../single-story-sweep/sweep-lock.js';
+import { purgeStoryTempArtifacts as defaultPurgeStoryTempArtifacts } from '../../../temp-retention.js';
 import {
   executeFastForward as defaultExecuteFastForward,
   planFastForward as defaultPlanFastForward,
@@ -224,6 +225,22 @@ async function stepBaseFastForward({
   };
 }
 
+/**
+ * Purge this Story's spent temp artifacts now that its merge is confirmed
+ * (Story #4794).
+ *
+ * The engine already emits its own one-line summary and returns a disabled
+ * policy as `skipped` with no errors, so this step needs no branching of its
+ * own: errors degrade it, everything else — including a deliberate
+ * config-disabled no-op — is a success. Reporting a disabled purge as a failed
+ * step would train readers to ignore the field.
+ */
+async function stepTempPurge({ storyId, config, purgeStoryTempArtifactsFn }) {
+  const result = await purgeStoryTempArtifactsFn({ storyId, config });
+  const errors = result?.errors ?? [];
+  return { ok: errors.length === 0, detail: errors.join('; ') || null };
+}
+
 /**
  * Run the whole post-land tail. Never throws.
  *
@@ -262,7 +279,8 @@ async function stepBaseFastForward({
  * @param {Function} [args.planFastForwardFn]       Test seam.
  * @param {Function} [args.executeFastForwardFn]    Test seam.
  * @param {Function} [args.acquireLockWithWaitFn]   Test seam.
- * @returns {Promise<{ followUps: boolean, statusResync: boolean, refCleanup: boolean, baseFastForward: boolean, details: Record<string, string|null> }>}
+ * @param {Function} [args.purgeStoryTempArtifactsFn] Test seam.
+ * @returns {Promise<{ followUps: boolean, statusResync: boolean, refCleanup: boolean, baseFastForward: boolean, tempPurge: boolean, details: Record<string, string|null> }>}
  */
 export async function runPostLandTail({
   storyId,
@@ -280,6 +298,7 @@ export async function runPostLandTail({
   planFastForwardFn = defaultPlanFastForward,
   executeFastForwardFn = defaultExecuteFastForward,
   acquireLockWithWaitFn = defaultAcquireLockWithWait,
+  purgeStoryTempArtifactsFn = defaultPurgeStoryTempArtifacts,
 }) {
   progress?.('POST-LAND', `🧾 Running land tail for Story #${storyId}...`);
 
@@ -373,16 +392,27 @@ export async function runPostLandTail({
     if (lock.acquired) lock.release();
   }
 
+  // Story #4794 — the merge is confirmed, so this Story's gate transcripts and
+  // validation evidence are spent. Runs LAST so a purge can never race a step
+  // that still reads them, and outside the checkout lock because it touches
+  // only the temp tree. Its `signals.ndjson` survives by construction.
+  const tempPurge = await step(
+    () => stepTempPurge({ storyId, config, purgeStoryTempArtifactsFn }),
+    { name: 'temp purge', progress },
+  );
+
   const tail = {
     followUps: followUps.ok,
     statusResync: statusResync.ok,
     refCleanup: refCleanup.ok,
     baseFastForward: baseFastForward.ok,
+    tempPurge: tempPurge.ok,
     details: {
       followUps: followUps.detail,
       statusResync: statusResync.detail,
       refCleanup: refCleanup.detail,
       baseFastForward: baseFastForward.detail,
+      tempPurge: tempPurge.detail,
     },
   };
   const degraded = Object.entries(tail)

package/.agents/scripts/lib/single-story-sweep.js

@@ -90,6 +90,7 @@ const STORY_BRANCH_INCLUDE = 'story-*';
  *   candidates: number,
  *   localDeleted: number,
  *   remoteDeleted: number,
+ *   reaped: string[],
  *   protected: Array<{ branch: string, reason: string, worktreePath?: string|null }>,
  *   contentMerged: Array<{ branch: string, worktreePath: string|null }>,
  *   failures: Array<{ branch: string|null, scope: string, stderr?: string }>,
@@ -147,6 +148,7 @@ export async function sweepMergedBranches({
         candidates: 0,
         localDeleted: 0,
         remoteDeleted: 0,
+        reaped: [],
         protected: [],
         contentMerged: [],
         failures: [],
@@ -296,6 +298,7 @@ async function runSweepUnderLock({
       candidates: 0,
       localDeleted: 0,
       remoteDeleted: 0,
+      reaped: [],
       protected: [],
       contentMerged,
       failures: [],
@@ -320,6 +323,7 @@ async function runSweepUnderLock({
       candidates: reapCandidates.length,
       localDeleted: 0,
       remoteDeleted: 0,
+      reaped: [],
       protected: protectedList,
       contentMerged,
       failures: [],
@@ -365,6 +369,7 @@ function executeReap({
       candidates: candidateCount,
       localDeleted: 0,
       remoteDeleted: 0,
+      reaped: [],
       protected: protectedList,
       contentMerged,
       failures: [{ branch: null, scope: 'execute', stderr: msg }],
@@ -398,6 +403,11 @@ function executeReap({
     candidates: candidateCount,
     localDeleted,
     remoteDeleted,
+    // Story #4794 — the branch names, not just the count. Each one is a merge
+    // this sweep CONFIRMED (merged PR + matching headRefOid), which is exactly
+    // the evidence the temp-retention catch-up needs to purge that Story's
+    // spent artifacts. Previously these existed only inside a log string.
+    reaped: reapable.map((c) => c.branch),
     protected: protectedList,
     contentMerged,
     failures: result.failures,
@@ -503,6 +513,7 @@ function zeroResult({ error }) {
     candidates: 0,
     localDeleted: 0,
     remoteDeleted: 0,
+    reaped: [],
     protected: [],
     contentMerged: [],
     failures: [],

package/.agents/scripts/lib/temp-retention.js

@@ -0,0 +1,559 @@
+/**
+ * temp-retention.js — allowlisted auto-purge of spent temp artifacts (Story #4794).
+ *
+ * The workspace temp tree grew without bound: every landed Story left its
+ * close-gate transcript (~1.4MB each), its terse-result detail dumps, and its
+ * validation-evidence envelope behind forever, because no code path had ever
+ * removed them. This module is the single engine that reclaims them.
+ *
+ * ## Allowlist, never a blocklist
+ *
+ * The safety property that matters is not "delete the right things" but
+ * "never delete the wrong thing". So classification is positive: an artifact
+ * is a purge candidate only when a declared class claims it. Everything else —
+ * an operator's scratch directory, a hand-parked file, a family a future
+ * Story adds without teaching this module about it — is **unrecognized**, is
+ * never touched, and is reported with its byte size so a human decides. A
+ * blocklist would have the opposite failure mode: anything the framework
+ * forgot to exclude gets deleted.
+ *
+ * ## Two eligibility signals, deliberately different in strength
+ *
+ * - **Story-keyed.** An artifact whose name carries a Story id is purged when
+ *   that Story's merge has been *confirmed* by the caller — the post-land tail
+ *   or a boot sweep that read live state. This is the primary path and the one
+ *   the operator asked for: spent the moment the work lands.
+ * - **Age-floored.** Artifacts no Story id can be recovered from (audit
+ *   reports, abandoned `plan-<slug>/` dirs) fall back to a `staleDays` floor.
+ *   Only the sweep opts into this; the per-Story purge never does, so a
+ *   post-land tail can never reap a sibling's in-flight artifact.
+ *
+ * ## Keep-class
+ *
+ * `signals.ndjson` is the artifact whose value *starts* when the run ends —
+ * `signals-view`, `acceptance-eval`, and the loop-health check all read it
+ * long after the Story merged. It is excluded twice over: it is not in the
+ * evidence basename allowlist, and {@link KEEP_BASENAMES} is re-checked at
+ * the deletion site. Defence in depth is warranted for the one file whose
+ * loss is silent and unrecoverable.
+ *
+ * ## Best-effort, never load-bearing
+ *
+ * Every entry point resolves rather than throws. This is hygiene: a purge
+ * that fails must never fail a land, a boot, or a persist that already did
+ * its real work. Failures are collected into `errors[]` and reported.
+ */
+
+import fsPromises from 'node:fs/promises';
+import path from 'node:path';
+
+import {
+  anchorTempRoot,
+  ORCHESTRATION_DIRNAME,
+  tempRootFrom,
+} from './config/temp-paths.js';
+import { Logger } from './Logger.js';
+
+/**
+ * Shipped defaults for `delivery.tempRetention`. `enabled` defaults to `true`:
+ * the operator asked for auto-purge to be the behaviour, with the knob there
+ * to turn it off rather than to turn it on.
+ */
+export const TEMP_RETENTION_DEFAULTS = Object.freeze({
+  enabled: true,
+  staleDays: 7,
+  classes: Object.freeze({
+    orchestrationLogs: true,
+    validationEvidence: true,
+    auditResults: true,
+    planDirs: true,
+  }),
+});
+
+/** Every declared purge class, in classification order. */
+export const PURGE_CLASS_NAMES = Object.freeze(
+  Object.keys(TEMP_RETENTION_DEFAULTS.classes),
+);
+
+/**
+ * Basenames no path may ever delete, re-checked at the deletion site even
+ * though classification already excludes them. See the module header.
+ */
+export const KEEP_BASENAMES = Object.freeze(['signals.ndjson']);
+
+/**
+ * The per-Story artifact basenames `validationEvidence` claims. An explicit
+ * allowlist rather than a "delete everything but signals" rule: a file this
+ * module has not been taught about is kept, not guessed at.
+ */
+const STORY_EVIDENCE_BASENAMES = Object.freeze([
+  'validation-evidence.json',
+  'lifecycle.ndjson',
+  'manifest.md',
+]);
+
+/**
+ * Top-level temp entries that belong to the framework but are never purge
+ * candidates: `qa/` holds resumable operator-owned session ledgers, `cache/`
+ * has its own invalidation, and `*.lock` files are live coordination state.
+ */
+const RESERVED_TOP_LEVEL = Object.freeze(['qa', 'cache']);
+
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+
+/** `story-4794` → `4794`. */
+const STORY_DIR_PATTERN = /^story-(\d+)$/;
+/** `close-gates-4794`, `sync-result-story-4794` → `4794`. */
+const TRAILING_ID_PATTERN = /-(\d+)$/;
+/** `audit-story-4794-audit-clean-code.md` → `4794`. */
+const AUDIT_STORY_PATTERN = /^audit-story-(\d+)-/;
+/** `run-1030` — a per-run temp tree holding `stories/story-<id>/` children. */
+const RUN_DIR_PATTERN = /^run-\d+$/;
+
+/**
+ * Resolve the effective retention policy, filling every field from
+ * {@link TEMP_RETENTION_DEFAULTS}. An unset block yields the defaults, so a
+ * consumer that never heard of this feature gets the purge.
+ *
+ * @param {object} [config] Resolved config bag.
+ * @returns {{ enabled: boolean, staleDays: number, classes: Record<string, boolean> }}
+ */
+export function resolveTempRetention(config) {
+  const raw = config?.delivery?.tempRetention ?? {};
+  const classes = {};
+  for (const name of PURGE_CLASS_NAMES) {
+    classes[name] =
+      raw.classes?.[name] ?? TEMP_RETENTION_DEFAULTS.classes[name];
+  }
+  return {
+    enabled: raw.enabled ?? TEMP_RETENTION_DEFAULTS.enabled,
+    staleDays: raw.staleDays ?? TEMP_RETENTION_DEFAULTS.staleDays,
+    classes,
+  };
+}
+
+/**
+ * `readdir` that yields `[]` for a directory that does not exist or cannot be
+ * read. Every scan below walks optional trees, so an absent one is the normal
+ * case, not an error.
+ *
+ * @param {typeof fsPromises} fsp
+ * @param {string} dir
+ * @returns {Promise<import('node:fs').Dirent[]>}
+ */
+async function safeReaddir(fsp, dir) {
+  try {
+    return await fsp.readdir(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Total bytes under a path — the file's own size, or the recursive sum for a
+ * directory. Reporting-only: a vanished child is skipped rather than fatal.
+ *
+ * @param {typeof fsPromises} fsp
+ * @param {string} target
+ * @returns {Promise<number>}
+ */
+async function sizeOf(fsp, target) {
+  let total = 0;
+  const stack = [target];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    let stats;
+    try {
+      stats = await fsp.stat(current);
+    } catch {
+      continue;
+    }
+    if (!stats.isDirectory()) {
+      total += stats.size;
+      continue;
+    }
+    for (const child of await safeReaddir(fsp, current)) {
+      stack.push(path.join(current, child.name));
+    }
+  }
+  return total;
+}
+
+/**
+ * Build one classified entry. `mtimeMs` is the entry's **own** mtime, not the
+ * newest mtime beneath it — that is the semantics the shipped stale-plan-dir
+ * reap has always used, and widening it here would silently change when an
+ * abandoned directory becomes eligible.
+ *
+ * @param {typeof fsPromises} fsp
+ * @param {string} target
+ * @param {string} className
+ * @param {number|null} storyId
+ * @param {boolean} keep
+ * @returns {Promise<object|null>}
+ */
+async function makeEntry(fsp, target, className, storyId, keep = false) {
+  let stats;
+  try {
+    stats = await fsp.stat(target);
+  } catch {
+    return null;
+  }
+  return {
+    path: target,
+    className,
+    storyId,
+    keep,
+    mtimeMs: stats.mtimeMs,
+    bytes: stats.isDirectory() ? await sizeOf(fsp, target) : stats.size,
+  };
+}
+
+/**
+ * Recover the Story id a run-log basename carries. Both writers that land in
+ * `orchestration/` end their name with the scope: `close-gates-4794.log` from
+ * the gate sink, `sync-result-story-4794.log` from the terse-result dump.
+ *
+ * @param {string} name
+ * @returns {number|null}
+ */
+function storyIdFromLogName(name) {
+  const match = TRAILING_ID_PATTERN.exec(name.replace(/\.log$/, ''));
+  return match ? Number(match[1]) : null;
+}
+
+/**
+ * `<tempRoot>/orchestration/*.log` — close gate transcripts and terse-result
+ * detail dumps. A log whose name carries no id (there are none today, but the
+ * class owns the directory) is age-floored rather than dropped from the class.
+ */
+async function scanOrchestrationLogs(tempRoot, fsp) {
+  const dir = path.join(tempRoot, ORCHESTRATION_DIRNAME);
+  const entries = [];
+  for (const dirent of await safeReaddir(fsp, dir)) {
+    if (!dirent.isFile() || !dirent.name.endsWith('.log')) continue;
+    const entry = await makeEntry(
+      fsp,
+      path.join(dir, dirent.name),
+      'orchestrationLogs',
+      storyIdFromLogName(dirent.name),
+    );
+    if (entry) entries.push(entry);
+  }
+  return entries;
+}
+
+/**
+ * Every directory that holds `story-<id>/` children: the standalone tree and
+ * each per-run tree.
+ */
+async function storyParentDirs(tempRoot, fsp) {
+  const parents = [path.join(tempRoot, 'standalone', 'stories')];
+  for (const dirent of await safeReaddir(fsp, tempRoot)) {
+    if (dirent.isDirectory() && RUN_DIR_PATTERN.test(dirent.name)) {
+      parents.push(path.join(tempRoot, dirent.name, 'stories'));
+    }
+  }
+  return parents;
+}
+
+/**
+ * `<…>/stories/story-<id>/*` — the per-Story delivery artifacts.
+ *
+ * Every file in the directory is emitted, but only the declared evidence
+ * basenames are purge candidates; `signals.ndjson` and anything unrecognized
+ * are emitted with `keep: true` so the envelope can show what survived.
+ */
+async function scanValidationEvidence(tempRoot, fsp) {
+  const entries = [];
+  for (const parent of await storyParentDirs(tempRoot, fsp)) {
+    for (const dirent of await safeReaddir(fsp, parent)) {
+      const match = STORY_DIR_PATTERN.exec(dirent.name);
+      if (!dirent.isDirectory() || !match) continue;
+      const storyDir = path.join(parent, dirent.name);
+      for (const file of await safeReaddir(fsp, storyDir)) {
+        if (!file.isFile()) continue;
+        const entry = await makeEntry(
+          fsp,
+          path.join(storyDir, file.name),
+          'validationEvidence',
+          Number(match[1]),
+          !STORY_EVIDENCE_BASENAMES.includes(file.name),
+        );
+        if (entry) entries.push(entry);
+      }
+    }
+  }
+  return entries;
+}
+
+/**
+ * `<tempRoot>/audits/*` — audit reports. `audit-story-<id>-<lens>.md` is
+ * Story-keyed; the roster-level reports and profiling output are age-floored.
+ */
+async function scanAuditResults(tempRoot, fsp) {
+  const dir = path.join(tempRoot, 'audits');
+  const entries = [];
+  for (const dirent of await safeReaddir(fsp, dir)) {
+    const match = AUDIT_STORY_PATTERN.exec(dirent.name);
+    const entry = await makeEntry(
+      fsp,
+      path.join(dir, dirent.name),
+      'auditResults',
+      match ? Number(match[1]) : null,
+    );
+    if (entry) entries.push(entry);
+  }
+  return entries;
+}
+
+/**
+ * `<tempRoot>/plan-<slug>/` — plan authoring dirs. Never Story-keyed: the
+ * directory predates the Stories it creates, so age is the only safe signal.
+ */
+async function scanPlanDirs(tempRoot, fsp) {
+  const entries = [];
+  for (const dirent of await safeReaddir(fsp, tempRoot)) {
+    if (!dirent.isDirectory() || !dirent.name.startsWith('plan-')) continue;
+    const entry = await makeEntry(
+      fsp,
+      path.join(tempRoot, dirent.name),
+      'planDirs',
+      null,
+    );
+    if (entry) entries.push(entry);
+  }
+  return entries;
+}
+
+/** Class name → scanner. Iteration order matches {@link PURGE_CLASS_NAMES}. */
+const SCANNERS = Object.freeze({
+  orchestrationLogs: scanOrchestrationLogs,
+  validationEvidence: scanValidationEvidence,
+  auditResults: scanAuditResults,
+  planDirs: scanPlanDirs,
+});
+
+/**
+ * Does a top-level temp entry belong to a declared class? Kept in lockstep
+ * with the scanners above: an entry no class walks must show up as
+ * unrecognized, never be silently ignored.
+ *
+ * @param {string} name
+ * @returns {boolean}
+ */
+function isClassOwnedTopLevel(name) {
+  return (
+    name === ORCHESTRATION_DIRNAME ||
+    name === 'standalone' ||
+    name === 'audits' ||
+    name.startsWith('plan-') ||
+    RUN_DIR_PATTERN.test(name)
+  );
+}
+
+/**
+ * Top-level entries that no class claims and that are not framework-reserved.
+ * Reported with byte sizes, never deleted — this is what makes a 49MB scratch
+ * directory visible to the operator instead of invisible to the tooling.
+ *
+ * @param {string} tempRoot
+ * @param {typeof fsPromises} fsp
+ * @returns {Promise<Array<{ path: string, bytes: number }>>}
+ */
+async function collectUnrecognized(tempRoot, fsp) {
+  const found = [];
+  for (const dirent of await safeReaddir(fsp, tempRoot)) {
+    const { name } = dirent;
+    if (isClassOwnedTopLevel(name)) continue;
+    if (RESERVED_TOP_LEVEL.includes(name) || name.endsWith('.lock')) continue;
+    const target = path.join(tempRoot, name);
+    found.push({ path: target, bytes: await sizeOf(fsp, target) });
+  }
+  return found;
+}
+
+/**
+ * Classify a whole temp tree without deleting anything. Exported so a caller
+ * (or a test) can see exactly what the purge would consider.
+ *
+ * @param {{ config?: object, tempRoot?: string, fsp?: typeof fsPromises }} [args]
+ * @returns {Promise<{ tempRoot: string, entries: object[], unrecognized: Array<{ path: string, bytes: number }> }>}
+ */
+export async function collectTempEntries({
+  config,
+  tempRoot,
+  fsp = fsPromises,
+} = {}) {
+  const root = tempRoot ?? anchorTempRoot(tempRootFrom(config));
+  const entries = [];
+  for (const className of PURGE_CLASS_NAMES) {
+    entries.push(...(await SCANNERS[className](root, fsp)));
+  }
+  return {
+    tempRoot: root,
+    entries,
+    unrecognized: await collectUnrecognized(root, fsp),
+  };
+}
+
+/**
+ * Is this entry eligible for deletion under the current policy and signals?
+ *
+ * @param {object} entry
+ * @param {object} ctx
+ * @returns {boolean}
+ */
+function isPurgeable(entry, ctx) {
+  if (entry.keep) return false;
+  if (KEEP_BASENAMES.includes(path.basename(entry.path))) return false;
+  if (!ctx.classes[entry.className]) return false;
+  if (ctx.only && !ctx.only.includes(entry.className)) return false;
+  if (ctx.excluded.has(path.resolve(entry.path))) return false;
+  if (entry.storyId !== null && ctx.storyIds.has(entry.storyId)) return true;
+  return ctx.sweepStale && ctx.now - entry.mtimeMs >= ctx.staleMs;
+}
+
+/**
+ * The purge core. Deliberately **module-private**: the two exported entry
+ * points below are the whole public surface, and each encodes a policy
+ * decision (Story-keyed vs. age-floored) that a caller reaching this directly
+ * could get wrong. Exporting it would also be a dead export — nothing outside
+ * this file has a reason to call it.
+ *
+ * @param {object} [args]
+ * @param {object} [args.config] Resolved config bag.
+ * @param {number[]} [args.storyIds] Stories whose merge the caller CONFIRMED.
+ * @param {boolean} [args.sweepStale] Opt into the age floor for un-keyed entries.
+ * @param {string[]|null} [args.only] Restrict to these class names.
+ * @param {string[]} [args.excludePaths] Absolute paths to leave alone.
+ * @param {number} [args.now] Clock seam.
+ * @param {string} [args.tempRoot] Temp root override (tests).
+ * @param {typeof fsPromises} [args.fsp] Filesystem seam.
+ * @param {{ info: Function }} [args.logger] Logger seam.
+ * @param {string} [args.label] Prefix for the single summary line.
+ * @returns {Promise<object>} Result envelope; never throws.
+ */
+async function purgeTempArtifacts({
+  config,
+  storyIds = [],
+  sweepStale = false,
+  only = null,
+  excludePaths = [],
+  now = Date.now(),
+  tempRoot,
+  fsp = fsPromises,
+  logger = Logger,
+  label = 'temp-retention',
+} = {}) {
+  const policy = resolveTempRetention(config);
+  const base = {
+    enabled: policy.enabled,
+    tempRoot: tempRoot ?? anchorTempRoot(tempRootFrom(config)),
+    purged: [],
+    kept: [],
+    unrecognized: [],
+    bytesReclaimed: 0,
+    errors: [],
+  };
+  if (!policy.enabled) return { ...base, skipped: 'disabled' };
+
+  let scan;
+  try {
+    scan = await collectTempEntries({ config, tempRoot: base.tempRoot, fsp });
+  } catch (err) {
+    return { ...base, skipped: null, errors: [String(err?.message ?? err)] };
+  }
+
+  const ctx = {
+    classes: policy.classes,
+    only,
+    storyIds: new Set(storyIds),
+    sweepStale,
+    staleMs: policy.staleDays * MS_PER_DAY,
+    now,
+    excluded: new Set(excludePaths.map((p) => path.resolve(p))),
+  };
+  const result = { ...base, skipped: null, unrecognized: scan.unrecognized };
+
+  for (const entry of scan.entries) {
+    if (!isPurgeable(entry, ctx)) {
+      if (entry.keep) result.kept.push(entry.path);
+      continue;
+    }
+    try {
+      await fsp.rm(entry.path, { recursive: true, force: true });
+      result.purged.push({ path: entry.path, bytes: entry.bytes });
+      result.bytesReclaimed += entry.bytes;
+    } catch (err) {
+      // A racing writer or a permission error: leave it for the next run.
+      result.errors.push(`${entry.path}: ${String(err?.message ?? err)}`);
+    }
+  }
+
+  if (result.purged.length > 0) {
+    logger?.info?.(
+      `[${label}] purged ${result.purged.length} spent temp artifact(s), ` +
+        `reclaimed ${formatBytes(result.bytesReclaimed)} under ${result.tempRoot}.`,
+    );
+  }
+  return result;
+}
+
+/**
+ * Human-readable byte count for the one summary line.
+ *
+ * @param {number} bytes
+ * @returns {string}
+ */
+export function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes}B`;
+  const units = ['KB', 'MB', 'GB'];
+  let value = bytes / 1024;
+  let unit = 0;
+  while (value >= 1024 && unit < units.length - 1) {
+    value /= 1024;
+    unit += 1;
+  }
+  return `${value.toFixed(1)}${units[unit]}`;
+}
+
+/**
+ * Purge one merged Story's spent artifacts. Called from the post-land tail,
+ * where "merged" is already confirmed — so this never applies the age floor
+ * and can never touch a sibling Story's in-flight artifacts.
+ *
+ * @param {{ storyId: number, config?: object, now?: number, tempRoot?: string,
+ *   fsp?: typeof fsPromises, logger?: object }} args
+ * @returns {Promise<object>} Result envelope; never throws.
+ */
+export async function purgeStoryTempArtifacts({ storyId, config, ...rest }) {
+  return purgeTempArtifacts({
+    config,
+    storyIds: Number.isInteger(storyId) ? [storyId] : [],
+    sweepStale: false,
+    ...rest,
+  });
+}
+
+/**
+ * Catch-up sweep: purge the artifacts of every Story the caller confirmed
+ * merged, plus every age-floored entry past `staleDays`. This is the path
+ * that reclaims a backlog — Stories merged in an earlier run, merged through
+ * the GitHub UI, or delivered before this feature existed.
+ *
+ * @param {{ config?: object, mergedStoryIds?: number[], now?: number,
+ *   tempRoot?: string, fsp?: typeof fsPromises, logger?: object,
+ *   only?: string[]|null, excludePaths?: string[], label?: string }} [args]
+ * @returns {Promise<object>} Result envelope; never throws.
+ */
+export async function sweepTempRetention({
+  mergedStoryIds = [],
+  ...rest
+} = {}) {
+  return purgeTempArtifacts({
+    storyIds: mergedStoryIds,
+    sweepStale: true,
+    ...rest,
+  });
+}

package/.agents/scripts/single-story-init.js

@@ -777,7 +777,7 @@ export async function runSingleStoryInit({
     label: 'STORY INIT RESULT',
     result,
     scope: storyId,
-    logDir: path.join(cwd, 'temp', 'orchestration'),
+    config,
     summary: {
       storyId,
       storyBranch,

package/.agents/scripts/sync-branch-from-base.js

@@ -31,6 +31,7 @@
 import path from 'node:path';
 import { parseArgs } from 'node:util';
 import { runAsCli } from './lib/cli-utils.js';
+import { resolveConfig } from './lib/config-resolver.js';
 import { syncBranchFromBase } from './lib/git/sync-from-base.js';
 import { gitSpawn, gitSync } from './lib/git-utils.js';
 import { Logger } from './lib/Logger.js';
@@ -95,11 +96,15 @@ export async function runSyncBranchFromBase(opts = {}) {
   });
 
   // Story #4685 — full detail to a temp log; emit a single summary line.
+  // Story #4794 — resolve the config so the log honours `project.paths.tempRoot`
+  // instead of the hardcoded `<cwd>/temp` this used to join. `resolveConfig`
+  // degrades to the framework defaults when no `.agentrc.json` is present, so
+  // a zero-config invocation needs no guard here.
   emitTerseResult({
     label: 'SYNC RESULT',
     result,
     scope: branch,
-    logDir: path.join(cwd, 'temp', 'orchestration'),
+    config: resolveConfig({ cwd }),
     summary: { branch, base, synced: result.synced, kind: result.kind },
   });
 

package/docs/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to this project will be documented in this file.
 
+## [2.18.0](https://github.com/dsj1984/mandrel/compare/mandrel-v2.17.0...mandrel-v2.18.0) (2026-07-26)
+
+
+### Added
+
+* **temp:** auto-purge merged Stories' spent temp artifacts behind an allowlist, keeping signals ([#4794](https://github.com/dsj1984/mandrel/issues/4794)) ([#4795](https://github.com/dsj1984/mandrel/issues/4795)) ([d69d985](https://github.com/dsj1984/mandrel/commit/d69d9858511658e0ec0336db0cf8aa65d725637b))
+
+
+### Chores
+
+* **release:** cut the 2.18.0 release missed by an unparseable squash subject ([#4796](https://github.com/dsj1984/mandrel/issues/4796)) ([8ccff57](https://github.com/dsj1984/mandrel/commit/8ccff574d44519595e04fc0f3597cb4dcd005436))
+
 ## [2.17.0](https://github.com/dsj1984/mandrel/compare/mandrel-v2.16.0...mandrel-v2.17.0) (2026-07-26)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mandrel",
-  "version": "2.17.0",
+  "version": "2.18.0",
   "description": "Claude Code-first opinionated workflow framework: instructions, skills, rules, and SDLC workflows that govern AI coding assistants.",
   "files": [
     ".agents/",