mandrel 1.67.0 → 1.69.0

package/.agents/scripts/lib/orchestration/epic-runner/progress-reporter/composition.js

@@ -240,42 +240,33 @@ export async function renderProgressBody({
 /**
  * Render and upsert the rolled-up `epic-run-progress` comment on the Epic.
  *
- * Called by `/deliver` Step 2b (`epic-execute-record-wave.js`) after
- * each wave completes. The caller folds `state.waves[]` from the
- * `epic-run-state` checkpoint into the per-wave rows and persists the
- * unified rollup as a fenced-JSON payload on the Epic ticket via
- * `upsertStructuredComment`. There is no separate per-wave structured
- * comment — `epic-run-progress` is the single operator-facing summary,
- * grouped by wave.
+ * Called by `/deliver`'s per-Story status recorder
+ * (`epic-execute-record-wave.js`) after each recorder beat. Story #4155
+ * (Epic #4151) — the Epic `/deliver` runtime cut over from the wave-batch
+ * scheduler to the continuous ready-set core, so the rollup is a **flat
+ * per-Story table** keyed by the checkpoint's `stories` status map, not a
+ * wave-grouped table. There is no `currentWave` / `totalWaves` / `waves[]`
+ * in the payload any more.
  *
- * The payload schema is pinned by `epic-execute.md` Step 2b / tech spec
- * #902:
+ * The payload schema:
  *
  *   {
  *     "kind": "epic-run-progress",
  *     "epicId": <number>,
- *     "currentWave": <number>,
- *     "totalWaves": <number>,
- *     "waves": [ { wave, concurrencyCap?, stories[] } ],
+ *     "stories": [ { id, title?, state, blockerCommentId? } ],
  *     "startedAt"?: "<iso8601>",
  *     "updatedAt": "<iso8601>"
  *   }
  *
  * The function does not re-derive Story state from labels — it trusts the
- * `waves` argument supplied by the caller, which itself is the projection
- * of the validated, verified per-Story rows recorded on the checkpoint.
+ * `stories` map supplied by the caller (the checkpoint's recorded per-Story
+ * statuses).
  *
  * @param {{
  *   provider: import('../../../ITicketingProvider.js').ITicketingProvider,
  *   epicId: number,
- *   waves: Array<{
- *     wave: number,
- *     concurrencyCap?: number,
- *     stories?: Array<{ id: number, title?: string, state?: string,
- *                       blockerCommentId?: string }>,
- *   }>,
- *   currentWave: number,
- *   totalWaves: number,
+ *   stories: Record<string, { status?: string, title?: string,
+ *                             blockerCommentId?: string }>,
  *   startedAt?: string,
  *   now?: () => Date,
  * }} args
@@ -285,9 +276,7 @@ export async function renderProgressBody({
 export async function upsertEpicRunProgress({
   provider,
   epicId,
-  waves,
-  currentWave,
-  totalWaves,
+  stories,
   startedAt,
   now = () => new Date(),
 } = {}) {
@@ -300,73 +289,44 @@ export async function upsertEpicRunProgress({
   if (!Number.isInteger(epicIdNum) || epicIdNum <= 0) {
     throw new TypeError('upsertEpicRunProgress requires a numeric epicId');
   }
-  const totalWavesNum = Number(totalWaves);
-  if (!Number.isInteger(totalWavesNum) || totalWavesNum < 0) {
-    throw new TypeError(
-      'upsertEpicRunProgress requires a non-negative integer totalWaves',
-    );
-  }
-  const currentWaveNum = Number(currentWave);
-  if (!Number.isInteger(currentWaveNum) || currentWaveNum < 0) {
-    throw new TypeError(
-      'upsertEpicRunProgress requires a non-negative integer currentWave',
-    );
-  }
-  const wavesArr = Array.isArray(waves) ? waves : [];
+  const statusMap = stories && typeof stories === 'object' ? stories : {};
 
   const updatedAt = now().toISOString();
-  const normalizedWaves = wavesArr.map((w) => {
-    const stories = Array.isArray(w?.stories) ? w.stories : [];
-    const out = {
-      wave: Number(w?.wave),
-      stories,
-    };
-    if (Number.isInteger(w?.concurrencyCap)) {
-      out.concurrencyCap = Number(w.concurrencyCap);
-    }
-    return out;
-  });
+  const rows = Object.entries(statusMap)
+    .map(([key, rec]) => {
+      const id = Number(key);
+      const state = String(rec?.status ?? 'pending');
+      const row = { id, title: String(rec?.title ?? ''), state };
+      if (rec?.blockerCommentId != null) {
+        row.blockerCommentId = String(rec.blockerCommentId);
+      }
+      return row;
+    })
+    .filter((r) => Number.isInteger(r.id) && r.id > 0)
+    .sort((a, b) => a.id - b.id);
 
   const payload = {
     kind: EPIC_RUN_PROGRESS_TYPE,
     epicId: epicIdNum,
-    currentWave: currentWaveNum,
-    totalWaves: totalWavesNum,
-    waves: normalizedWaves,
+    stories: rows,
     updatedAt,
   };
   if (typeof startedAt === 'string' && startedAt) {
     payload.startedAt = startedAt;
   }
 
-  const totalStories = normalizedWaves.reduce(
-    (acc, w) => acc + w.stories.length,
-    0,
-  );
-  const doneStories = normalizedWaves.reduce(
-    (acc, w) => acc + w.stories.filter((s) => s?.state === 'done').length,
-    0,
-  );
-  const header = `### 📊 Epic Progress — Wave ${Math.min(currentWaveNum + 1, Math.max(totalWavesNum, 1))}/${totalWavesNum || '?'} · ${doneStories}/${totalStories} stories done`;
+  const totalStories = rows.length;
+  const doneStories = rows.filter((s) => s.state === 'done').length;
+  const header = `### 📊 Epic Progress — ${doneStories}/${totalStories} stories done`;
 
-  const tableLines = ['| Wave | ID | State | Title |', '|---|---|---|---|'];
-  if (normalizedWaves.length === 0) {
-    tableLines.push('| — | — | _(no waves yet)_ | — |');
+  const tableLines = ['| ID | State | Title |', '|---|---|---|'];
+  if (rows.length === 0) {
+    tableLines.push('| — | _(no stories yet)_ | — |');
   } else {
-    for (const w of normalizedWaves) {
-      if (w.stories.length === 0) {
-        tableLines.push(`| ${w.wave + 1} | — | _(empty wave)_ | — |`);
-        continue;
-      }
-      for (const s of w.stories) {
-        const state = String(s?.state ?? 'unknown');
-        const emoji = STATE_EMOJI[state] ?? '';
-        const id = Number(s?.id ?? 0);
-        const title = escapePipes(truncate(String(s?.title ?? ''), 60));
-        tableLines.push(
-          `| ${w.wave + 1} | #${id} | ${emoji} ${state} | ${title} |`,
-        );
-      }
+    for (const s of rows) {
+      const emoji = STATE_EMOJI[s.state] ?? '';
+      const title = escapePipes(truncate(s.title, 60));
+      tableLines.push(`| #${s.id} | ${emoji} ${s.state} | ${title} |`);
     }
   }
 

package/.agents/scripts/lib/orchestration/epic-runner/progress-reporter/transport.js

@@ -38,10 +38,10 @@ export const EPIC_PROGRESS_EVENT = 'epic-progress';
 
 /**
  * Fire a curated `epic-progress` webhook event. Event-driven only — called
- * at wave boundaries and after blocker raise/clear transitions. Carries
- * the rollup payload `{ pct, done, total, currentWave, totalWaves, phase,
- * openBlockers }`, which Slack consumers and downstream subscribers use to
- * track epic progress without subscribing to per-story chatter.
+ * per recorder beat and after blocker raise/clear transitions. Carries the
+ * rollup payload `{ pct, done, total, phase, openBlockers }`, which Slack
+ * consumers and downstream subscribers use to track epic progress without
+ * subscribing to per-story chatter.
  *
  * The dispatch passes `skipComment: true` — the operator-facing GitHub
  * comment is owned by `ProgressReporter.fire()` and `upsertEpicRunProgress`,
@@ -50,13 +50,17 @@ export const EPIC_PROGRESS_EVENT = 'epic-progress';
  * Failures are swallowed by design: the runner must keep moving even if
  * the webhook URL is misconfigured or the network is flaky.
  *
+ * Story #4155 — the Epic `/deliver` runtime cut over to the continuous
+ * ready-set scheduler, which has **no wave index**. The wave segment was
+ * dropped from the message and the rollup payload entirely (rather than
+ * rendered as `Wave undefined/undefined`); the sole live caller
+ * (`wave-record-notifications.js`) never supplied wave coordinates.
+ *
  * @param {{
  *   notify: Function|null,
  *   epicId: number,
  *   done: number,
  *   total: number,
- *   currentWave: number,
- *   totalWaves: number,
  *   phase?: string,
  *   openBlockers?: Array<{ reason: string, storyId?: number }>,
  *   logger?: { warn?: Function },
@@ -68,8 +72,6 @@ export async function emitEpicProgress({
   epicId,
   done,
   total,
-  currentWave,
-  totalWaves,
   phase,
   openBlockers = [],
   logger,
@@ -85,7 +87,7 @@ export async function emitEpicProgress({
     blockerCount > 0
       ? ` · 🚧 ${blockerCount} blocker${blockerCount === 1 ? '' : 's'}`
       : '';
-  const message = `Epic #${epicIdNum} progress · Wave ${currentWave}/${totalWaves} · ${doneN}/${totalN} stories done (${pct}%)${blockerSuffix}`;
+  const message = `Epic #${epicIdNum} progress · ${doneN}/${totalN} stories done (${pct}%)${blockerSuffix}`;
 
   const payload = {
     severity: blockerCount > 0 ? 'high' : 'medium',
@@ -109,8 +111,6 @@ export async function emitEpicProgress({
       pct,
       done: doneN,
       total: totalN,
-      currentWave,
-      totalWaves,
       phase,
       openBlockers: openBlockers ?? [],
     },
@@ -121,11 +121,14 @@ export async function emitEpicProgress({
  * Fire a curated `epic-started` webhook event at /deliver kickoff.
  * The Slack consumer anchors the rest of the epic narrative to this fire.
  * Failures are swallowed.
+ *
+ * Story #4155 — the ready-set runtime has no wave count, so the wave
+ * segment was dropped from the message (rather than rendered as
+ * `undefined wave(s)`); the sole live caller never supplied one.
  */
 export async function emitEpicStarted({
   notify,
   epicId,
-  totalWaves,
   totalStories,
   title,
   logger,
@@ -133,7 +136,7 @@ export async function emitEpicStarted({
   if (typeof notify !== 'function') return null;
   const epicIdNum = Number(epicId);
   if (!Number.isInteger(epicIdNum) || epicIdNum <= 0) return null;
-  const message = `Epic #${epicIdNum} started · ${totalWaves} wave${totalWaves === 1 ? '' : 's'} · ${totalStories} stor${totalStories === 1 ? 'y' : 'ies'}${title ? ` — ${title}` : ''}`;
+  const message = `Epic #${epicIdNum} started · ${totalStories} stor${totalStories === 1 ? 'y' : 'ies'}${title ? ` — ${title}` : ''}`;
   try {
     await notify(
       epicIdNum,

package/.agents/scripts/lib/orchestration/epic-runner/sub-agent-return.js

@@ -241,26 +241,29 @@ export async function reconcileStoryFromGitHub({ provider, storyId } = {}) {
 
 /**
  * Render a single friction-comment body listing every malformed sub-agent
- * return for a given wave. Pure helper — no provider call. Exposed so tests
- * can pin the body shape.
+ * return for a recorder beat. Pure helper — no provider call. Exposed so
+ * tests can pin the body shape.
+ *
+ * Story #4155 — under the ready-set runtime there is no wave index; the
+ * recorder records the Stories it was handed, so the body is keyed by Epic
+ * only.
  *
  * @param {{
  *   epicId: number,
- *   wave: number,
  *   failures: Array<{ storyId: number, error: string, returnText: string }>,
  * }} args
  * @returns {string}
  */
-export function renderMalformedReturnsFriction({ epicId, wave, failures }) {
+export function renderMalformedReturnsFriction({ epicId, failures }) {
   const lines = [
-    `### 🚧 epic-execute friction — Epic #${epicId}, wave ${wave}`,
+    `### 🚧 epic-execute friction — Epic #${epicId}`,
     '',
     `**Reason:** \`malformed-subagent-return\``,
     '',
     `${failures.length} sub-agent return(s) did not match the /deliver return contract.`,
     'Each Story below was reconciled from GitHub (labels + `story-run-progress`)',
-    'and its wave-row downgraded to `failed` unless the live ticket already carried',
-    '`agent::done`.',
+    'and its recorded status downgraded to `failed` unless the live ticket',
+    'already carried `agent::done`.',
     '',
   ];
   for (const f of failures) {

package/.agents/scripts/lib/orchestration/lifecycle/listeners/automerge-predicate.js

@@ -21,7 +21,7 @@
  *     is a hard block evaluated BEFORE the structured-signal evaluator.
  *
  * Either trigger evaluates the same verdict: if `evaluateAutoMergePredicate`
- * reports `clean: true` (no manual interventions, no incomplete waves,
+ * reports `clean: true` (no manual interventions, every Story done,
  * no story blockers, no critical/high review findings, machine-readable
  * "clean sprint" retro trailer), emit `epic.merge.ready`. Otherwise emit
  * `epic.merge.blocked` with a non-empty reason.
@@ -172,38 +172,51 @@ function evaluateStateSignals(state, reasons) {
         .join('; ')}${interventionCount > 3 ? '; …' : ''}`,
     );
   }
-  const waves = Array.isArray(state?.waves) ? state.waves : [];
-  const waveStatuses = waves.map((w) => w.status ?? 'unknown');
-  const nonCompleteWaves = waveStatuses.filter((s) => s !== 'complete');
-  if (nonCompleteWaves.length > 0) {
+  // Story #4155 — the ready-set runtime records a flat per-Story status map
+  // on the checkpoint (`stories: { [id]: { status, blockerCommentId? } }`)
+  // instead of a per-wave `waves[]` history. The clean-run certification
+  // reads it directly: a run is clean only when every Story reached `done`
+  // and none carries a recorded blocker comment.
+  const stories =
+    state?.stories && typeof state.stories === 'object' ? state.stories : {};
+  const storyStatuses = Object.values(stories).map(
+    (s) => s?.status ?? 'pending',
+  );
+  const nonDoneStatuses = storyStatuses.filter((s) => s !== 'done');
+  if (nonDoneStatuses.length > 0) {
     reasons.push(
-      `${nonCompleteWaves.length} wave(s) not complete (statuses: ${nonCompleteWaves.join(', ')})`,
+      `${nonDoneStatuses.length} story(ies) not done (statuses: ${nonDoneStatuses.join(', ')})`,
     );
   }
-  const storyBlockers = countStoryBlockers(waves);
+  const storyBlockers = countStoryBlockers(stories);
   if (storyBlockers > 0) {
     reasons.push(
       `${storyBlockers} story-level blocker(s) recorded in run-state`,
     );
   }
-  return { interventionCount, waveStatuses, storyBlockers };
+  return { interventionCount, storyStatuses, storyBlockers };
 }
 
-function countStoryBlockers(waves) {
+/**
+ * Count blockers in the flat per-Story `stories` status map: each Story with
+ * a recorded `blockerCommentId` and each Story whose status is not `done`
+ * contributes one blocker (matching the prior per-wave count semantics).
+ *
+ * @param {Record<string, { status?: string, blockerCommentId?: string }>} stories
+ * @returns {number}
+ */
+function countStoryBlockers(stories) {
   let blockers = 0;
-  for (const w of waves) {
-    if (!Array.isArray(w.stories)) continue;
-    for (const s of w.stories) {
-      if (
-        s &&
-        typeof s.blockerCommentId === 'string' &&
-        s.blockerCommentId.length > 0
-      ) {
-        blockers += 1;
-      }
-      if (s?.status && s.status !== 'done') {
-        blockers += 1;
-      }
+  for (const s of Object.values(stories ?? {})) {
+    if (
+      s &&
+      typeof s.blockerCommentId === 'string' &&
+      s.blockerCommentId.length > 0
+    ) {
+      blockers += 1;
+    }
+    if (s?.status && s.status !== 'done') {
+      blockers += 1;
     }
   }
   return blockers;
@@ -271,7 +284,7 @@ function evaluateRetroSignals(retro, reasons) {
  *   reasons: string[],
  *   signals: {
  *     manualInterventions: number,
- *     waveStatuses: string[],
+ *     storyStatuses: string[],
  *     storyBlockers: number,
  *     severity: { critical: number|null, high: number|null, medium: number|null, suggestion: number|null },
  *     retroCompact: boolean,
@@ -292,7 +305,7 @@ export function deriveAutoMergeVerdict({ state, codeReview, retro }) {
     reasons,
     signals: {
       manualInterventions: stateSig.interventionCount,
-      waveStatuses: stateSig.waveStatuses,
+      storyStatuses: stateSig.storyStatuses,
       storyBlockers: stateSig.storyBlockers,
       severity: reviewSig.severity,
       retroCompact: retroSig.retroCompact,

package/.agents/scripts/lib/orchestration/lifecycle/listeners/watcher.js

@@ -358,10 +358,15 @@ export async function pollUntilTerminal({
  * @param {number} opts.maxPolls           Hard cap on total poll iterations.
  * @param {number} opts.maxUpdates         Cap on `gh pr update-branch` recovery calls.
  * @param {number} opts.pollIntervalMs     Delay between poll ticks.
- * @param {Function} opts.ghPrChecksFn
- * @param {Function} opts.ghPrViewFn
- * @param {Function} opts.ghPrUpdateBranchFn
- * @param {Function} opts.sleepFn
+ * @param {Function} [opts.ghPrChecksFn]   `gh pr checks` invoker. Defaults
+ *   to the real `gh pr checks` spawn so the CLI path (which injects no
+ *   port) works; tests override it with a stub. Story #4144.
+ * @param {Function} [opts.ghPrViewFn]     `gh pr view` invoker. Defaults
+ *   to the real spawn; tests override.
+ * @param {Function} [opts.ghPrUpdateBranchFn] `gh pr update-branch`
+ *   invoker. Defaults to the real spawn; tests override.
+ * @param {Function} [opts.sleepFn]        Poll-tick delay. Defaults to a
+ *   real `setTimeout`-backed sleep; tests override with a no-op.
  * @param {{ info?: Function, warn?: Function, debug?: Function }} opts.logger
  * @param {{status:number,stdout:string,stderr:string}} [opts.firstProbe]
  *   Optional already-issued `gh pr checks` result. When the caller (the
@@ -388,10 +393,10 @@ export async function watchPrToTerminal({
   maxPolls,
   maxUpdates,
   pollIntervalMs,
-  ghPrChecksFn,
-  ghPrViewFn,
-  ghPrUpdateBranchFn,
-  sleepFn,
+  ghPrChecksFn = ghPrChecks,
+  ghPrViewFn = ghPrView,
+  ghPrUpdateBranchFn = ghPrUpdateBranch,
+  sleepFn = defaultSleep,
   logger,
   firstProbe,
 }) {

package/.agents/scripts/lib/orchestration/manifest-builder.js

@@ -139,6 +139,12 @@ function buildStoryOnlyManifest(stories, epicId) {
       type: 'story',
       branchName: getStoryBranch(epicId, story.id),
       earliestWave,
+      // Carry the resolved cross-Story dependency edges on the entry so the
+      // presentation layer can derive grouping depth at render time via
+      // `assignLayers` (Story #4157) instead of trusting the persisted
+      // `earliestWave`. This is the same `explicitStoryDeps` set the wave
+      // computation consumed, already closed over the scheduled Story set.
+      dependsOn: explicitStoryDeps.get(story.id) ?? [],
       tasks: [],
     };
   });

package/.agents/scripts/lib/orchestration/planning-risk.js

@@ -37,6 +37,18 @@
  * @property {boolean} requiresReview
  * @property {AcceptanceDisposition} acceptanceDisposition
  * @property {GateDecision} gateDecision
+ * @property {string} [acceptanceWaivedReason] Present only when the
+ *   acceptance disposition was forced to `not-applicable` by a non-axis
+ *   signal (currently: no BDD runner detected). An operator-visible
+ *   rationale so the override is never silent (Story #4145).
+ */
+
+/**
+ * @typedef {Object} BddRunnerProbe
+ * @property {string|null} runner
+ * @property {boolean} fallback `true` when no supported BDD runner was
+ *   detected in the project (`verifyBddRunnerPendingTag`).
+ * @property {string} [reason]
  */
 
 const LEVEL_RANK = Object.freeze({ low: 0, medium: 1, high: 2 });
@@ -129,27 +141,54 @@ function resolveRequiresReview(overallLevel, axes) {
  * (`epic-plan-spec.js`), never here, so a malformed verdict fails closed
  * before this function runs.
  *
+ * **No-BDD-runner waiver (Story #4145).** The acceptance disposition the risk
+ * axes derive presumes a BDD runner exists to satisfy an authored AC table.
+ * When `opts.bddRunner.fallback === true` (no supported runner detected — e.g.
+ * a `node:test` repo with no `tests/features/**`), an authored AC table can
+ * never be reconciled by `@epic-<id>-ac-*` feature tags, so `/deliver`
+ * finalize would abort. In that case the disposition is **forced** to
+ * `not-applicable` regardless of the risk axes, and `acceptanceWaivedReason`
+ * records the override so it is operator-visible, not silent. The
+ * `requiresReview` / `gateDecision` outputs are unaffected — a high-risk
+ * Epic still routes to review; only the acceptance-spec requirement is
+ * waived. Repos that ship a BDD runner (`fallback !== true`) are unaffected.
+ *
  * @param {RiskVerdict} [verdict]
+ * @param {{ bddRunner?: BddRunnerProbe|null }} [opts]
  * @returns {PlanningRiskEnvelope}
  */
-export function deriveRiskEnvelope(verdict = {}) {
+export function deriveRiskEnvelope(verdict = {}, { bddRunner = null } = {}) {
   const axes = (Array.isArray(verdict.axes) ? verdict.axes : []).map(
     ({ axis, level, rationale }) => ({ axis, level, rationale }),
   );
 
   const overallLevel = resolveOverallLevel(axes);
-  const acceptanceDisposition = resolveAcceptanceDisposition(
-    axes,
-    overallLevel,
-  );
+  const axisDisposition = resolveAcceptanceDisposition(axes, overallLevel);
   const requiresReview = resolveRequiresReview(overallLevel, axes);
   const gateDecision = requiresReview ? 'review-required' : 'auto-proceed';
 
-  return {
+  const noBddRunner = bddRunner?.fallback === true;
+  // Force the waiver only when the axes would otherwise have required (or
+  // recommended) an AC table; if the disposition is already not-applicable
+  // there is nothing to override and no waiver rationale to surface.
+  const forceWaiver = noBddRunner && axisDisposition !== 'not-applicable';
+  const acceptanceDisposition = forceWaiver
+    ? 'not-applicable'
+    : axisDisposition;
+
+  /** @type {PlanningRiskEnvelope} */
+  const envelope = {
     axes,
     overallLevel,
     requiresReview,
     acceptanceDisposition,
     gateDecision,
   };
+  if (forceWaiver) {
+    envelope.acceptanceWaivedReason =
+      `no BDD runner detected (${bddRunner?.reason ?? 'no-bdd-runner-detected'}) — ` +
+      `an authored acceptance-spec AC table cannot be reconciled by feature tags, ` +
+      `so the acceptance disposition is waived to not-applicable (was ${axisDisposition}).`;
+  }
+  return envelope;
 }

package/.agents/scripts/lib/orchestration/ticket-validator-sizing.js

@@ -18,7 +18,7 @@
  *
  * Sizing model (Story #3760 — profile-matrix collapse; Story #3874 — one
  * uniform relaxed profile):
- *   - Flat knobs: `softFiles` (~8), `hardFiles` (~30), `maxAcceptance` (~14),
+ *   - Flat knobs: `softFiles` (~15), `hardFiles` (~30), `maxAcceptance` (~14),
  *     `softAcceptanceCount` (~10). No per-profile ceiling map, no parallel
  *     `testSurface` axis, no selector and no second profile.
  *   - The four-profile `sizingProfile` enum is replaced by a single optional
@@ -32,7 +32,11 @@
 
 export const DEFAULT_TASK_SIZING = Object.freeze({
   // Typical-Story warning thresholds (soft — emit advisory findings).
-  softFiles: 8,
+  // Story #4162 raised `softFiles` 8 → 15: a capability-sized Story routinely
+  // touches a dozen-plus files for one cohesive reason, so the advisory width
+  // nudge fired far too eagerly and biased the decomposer toward over-slicing.
+  // The hard `hardFiles` rejection (30) is unchanged.
+  softFiles: 15,
   softAcceptanceCount: 10,
   // Hard ceilings (rejection unless lifted).
   hardFiles: 30,