mandrel 2.60.0 → 2.62.0

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

@@ -1,25 +1,8 @@
 /**
- * phases/base-sync.js — pre-push base-sync phase for `single-story-close`.
- *
- * Story #2580: sync the Story branch from `origin/<baseBranch>` before
- * push so the PR opens with the latest base commits already integrated.
- * Defends against the parallel-`/single-story-deliver` race where one
- * Story's auto-merge bumps `main` while sibling Stories are mid-flight —
- * without the sync, the lagging PRs open "behind base" and stall against
- * the `up-to-date branch` protection rule.
- *
- * The sync runs INSIDE the worktree (where the Story branch is checked
- * out); falls back to the main checkout when the worktree is absent.
- * On a merge conflict the Story is transitioned to `agent::blocked` via
- * `handleSyncFailure` and the caller throws — the operator resolves in
- * the worktree and re-runs.
- *
- * Story #5267: a sync that lands tracked content also spends the worker's
- * pre-push credit, because that credit is keyed on the tree. The phase says
- * so out loud — see `buildStampInvalidatedWarning` — instead of leaving
- * close's second full suite looking like a bug. Story #5278 splits the claim
- * in two: gate evidence is spent by any tracked path, the capture stamp only
- * by one under `crap.targetDirs`.
+ * phases/base-sync.js — sync the Story branch from `origin/<baseBranch>`
+ * before push, so a PR does not open behind a base a sibling's merge just
+ * moved. Runs in the worktree (else the main checkout); a failure blocks the
+ * Story and throws.
  */
 
 import { getQuality } from '../../../config/quality.js';
@@ -35,11 +18,7 @@ import {
 } from '../../ticketing.js';
 
 /**
- * Orchestrate the pre-push base-sync step: run `syncBranchFromBase`
- * inside the worktree (or main checkout when no worktree exists). On
- * failure, post a friction comment, flip the Story to `agent::blocked`,
- * and throw so the caller fails non-zero. The `--skip-sync` flag is
- * handled by the caller; this function assumes the sync is desired.
+ * `--skip-sync` is the caller's concern.
  *
  * @param {{
  *   cwd: string,
@@ -109,10 +88,7 @@ export async function runBaseSyncPhase({
 }
 
 /**
- * The CRAP scoring scope, or `[]` when it cannot be resolved. A `[]` makes
- * the warning below fall back to naming the capture stamp unconditionally —
- * the pre-#5278 wording — because an unresolvable scope is no evidence that
- * the stamp survived.
+ * The CRAP scoring scope, or `[]` when unresolvable.
  *
  * @param {typeof resolveConfig} resolveConfigImpl
  * @param {string} cwd
@@ -126,37 +102,13 @@ function resolveCrapTargetDirs(resolveConfigImpl, cwd) {
   }
 }
 
-/**
- * How many changed paths the warning names before it stops listing.
- * Enough to recognise the change set; short enough that the warning still
- * reads as a warning rather than as a diff.
- */
 const WARNED_PATH_LIMIT = 12;
 
 /**
- * The loud "your credit is spent" warning, or `[]` when the sync changed
- * nothing (Story #5267, narrowed by #5278).
- *
- * The worker banks two kinds of credit before the push: gate evidence keyed
- * on the tree (lint, typecheck) and one full-suite capture stamp keyed on the
- * content of `crap.targetDirs`. This sync runs after that, and the two are
- * spent on different conditions — which is why #5267's single blanket
- * sentence was wrong half the time:
- *
- *   - **Gate evidence** is spent by any tracked path at all, because the tree
- *     hash it is keyed on moves with the first byte.
- *   - **The capture stamp** is spent only when a merged path lands under
- *     `crap.targetDirs`. A sync that brings in docs, workflows or CI config
- *     leaves it perfectly valid, and announcing it as spent taught operators
- *     to expect a second full suite that close was never going to run.
- *
- * Quiet by construction on the outcome that cannot spend either: a
- * `noop-already-current` sync never touched the tree. A content-changing
- * fast-forward DOES warn — it moves the tree exactly as a merge commit does,
- * and staying quiet there would be a lie of omission.
- *
- * Pure. Module-private: the phase is the seam tests drive it through
- * (`injectedSync` + a `progress` spy), so it needs no export of its own.
+ * Warn that the sync spent pre-push credit, or `[]` when it changed nothing.
+ * Gate evidence is keyed on the tree, so any tracked path spends it; the
+ * full-suite capture stamp is spent only by a path under `crap.targetDirs`.
+ * A content-changing fast-forward warns just as a merge does.
  *
  * @param {{ baseBranch: string, result: { kind?: string, changedPaths?: string[] }, targetDirs?: string[] }} args
  * @returns {string[]} Progress lines, in order. Empty when nothing changed.
@@ -167,8 +119,7 @@ function buildStampInvalidatedWarning({ baseBranch, result, targetDirs }) {
     : [];
   if (changed.length === 0) return [];
   const dirs = Array.isArray(targetDirs) ? targetDirs : [];
-  // An unresolvable scope (`[]`) cannot prove the stamp survived, so it fails
-  // closed to the unconditional wording.
+  // An unresolvable scope cannot prove the stamp survived: fail closed.
   const scored =
     dirs.length === 0 ? changed : filterFilesUnderTargets(changed, dirs);
   const shown = changed.slice(0, WARNED_PATH_LIMIT);
@@ -191,8 +142,7 @@ function buildStampInvalidatedWarning({ baseBranch, result, targetDirs }) {
 }
 
 /**
- * Post a `friction` structured comment summarising a base-sync failure
- * and transition the Story to `agent::blocked`. Exported for testing.
+ * Post a `friction` comment and block the Story; both best-effort.
  *
  * @param {{
  *   provider: object,
@@ -224,10 +174,8 @@ export async function handleSyncFailure({
     result,
   });
 
-  // Post the structured comment first so the operator's recovery
-  // surface lands even if the label flip fails. Both are best-effort:
-  // we never want a notification-side failure to mask the real reason
-  // close threw.
+  // Comment first so the recovery surface lands even if the flip fails; a
+  // notification failure must never mask why close threw.
   try {
     await upsertStructuredComment(provider, storyId, 'friction', body);
     progress('SYNC', `📝 Posted friction comment on #${storyId}.`);
@@ -237,9 +185,7 @@ export async function handleSyncFailure({
     );
   }
 
-  // Story #4539 — the canonical mutator, not a direct label write: a bare
-  // `provider.updateTicket` skips the Projects v2 column sync (Story
-  // #2548) and strands the board on the Story's prior status.
+  // The canonical mutator: a bare label write skips the Projects v2 sync.
   try {
     await transitionTicketState(provider, storyId, STATE_LABELS.BLOCKED, {});
     progress('SYNC', `🚧 Flipped Story #${storyId} → ${AGENT_LABELS.BLOCKED}.`);
@@ -251,17 +197,9 @@ export async function handleSyncFailure({
 }
 
 /**
- * Build the markdown body posted on a base-sync failure. Pure; exported
- * for tests so the operator-recoverable surface stays reviewable.
- *
- * Story #4891 — `baseConfirmed` gates the merge-the-base recovery block, and
- * defaults to `false` so it fails closed. Telling the operator to run
- * `git merge origin/<baseBranch>` is actively harmful when `<baseBranch>` is
- * not the base the Story was seeded from: it permanently contaminates the
- * branch and its PR diff with an unrelated base. Close confirms the base
- * against the run's init receipt before that advice is emitted; when
- * it could not (receipt absent, unreadable, or unpinned), the operator is
- * told to establish the real base first instead.
+ * `baseConfirmed` (default false, fail-closed) gates the merge-the-base
+ * advice: merging a base the Story was not seeded from contaminates the
+ * branch and PR diff, so an unconfirmed base gets "establish it first".
  *
  * @param {{ storyId: number, storyBranch: string, baseBranch: string, baseConfirmed?: boolean, syncCwd: string, result: { kind: string, conflictFiles?: string[], stderr?: string } }} args
  * @returns {string}

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

@@ -1,69 +1,23 @@
 /**
- * phases/close-validation.js — run the canonical close-validation gate
- * chain for a standalone Story.
+ * phases/close-validation.js — the close-validation gate chain for a Story.
  *
- * The standalone path uses the same `runCloseValidation` chain as
- * Epic-attached Stories so the experience matches — only the baseline
- * ref changes (`main`, not `epic/<id>`).
- *
- * Standalone evidence keyspace (Story #4250). Standalone Stories have no
- * parent Epic, so they cannot scope a `validation-evidence.json` under a
- * `temp/run-<id>/` tree. Rather than feed a null `epicId` into the
- * Epic-keyed path (which structurally disabled the evidence cache and
- * forced every re-run — base-sync conflict, review remediation, baseline
- * absorb — to re-execute ALL gates including the coverage suite), the
- * standalone close now passes `standalone: true`. `runCloseValidation`
- * then anchors the cache on the Story id alone at
- * `temp/standalone/stories/story-<id>/validation-evidence.json`, so a
- * second close at unchanged HEAD short-circuits the already-passed gates.
- *
- * Pre-gate self-heal (Stories #4250, #5224). Two best-effort steps run on the
- * Story branch before the check-only gates score it — the scoped format
- * autofix and the upward maintainability write-back — so whatever they commit
- * is part of what the gates see and part of the branch's own PR. Both live in
- * [`pre-gate-steps.js`](pre-gate-steps.js); neither can fail a close, because
- * an authoritative gate for each runs immediately below.
- *
- * Bounded gate output (Story #4736). Every gate line goes to the run's
- * `gate-log.js` sink — an artifact under the gitignored temp tree — instead
- * of straight to the agent's stdout, where a passing `npm test` alone once
- * pushed a successful close past the host's inline tool-result ceiling. A
- * clean run reports one digest line naming the artifact; a failing gate
- * replays its captured tail inline, because that is exactly when the caller
- * needs the evidence in front of them. `AGENT_LOG_LEVEL=verbose` restores
- * live streaming.
- *
- * Projection advisories (Story #4776). `baseBranch`, `storyBranch` and the
- * resolved `config` are forwarded to `runCloseValidation` so its projection
- * phase can run. They surface, after the gates pass, which committed
- * baseline rows the post-merge tree would breach and the exact
- * `*:update` + `baseline-refresh:` remedy — advisory only, so the close
- * verdict is unchanged.
- *
- * `runCloseValidation`, `buildDefaultGates` and the pre-gate steps (whole, or
- * their two individual collaborators) are accepted as injected dependencies so
- * the parent CLI's cache-busted bindings win in tests that mock the upstream
- * module URLs.
+ * Gate output goes to an artifact sink (inline output once overflowed the
+ * host's tool-result ceiling): a pass reports one digest line, a failure
+ * replays its tail inline. Full-suite lock-wait lines are also teed to
+ * `progress()` so a long wait doesn't read as a hang, and an expired wait
+ * defers to `pending` rather than failing.
  */
 
 import { buildDefaultGates as defaultBuildDefaultGates } from '../../../close-validation/gates.js';
 import { runCloseValidation as defaultRunCloseValidation } from '../../../close-validation/runner.js';
+import { LOCK_WAIT_EXPIRED_EXIT_CODE } from '../../../full-suite-lock.js';
+import { parseLockWaitOutcome } from '../../../full-suite-queue.js';
 import { createGateLogSink as defaultCreateGateLogSink } from '../gate-log.js';
 import { runPreGateSteps as defaultRunPreGateSteps } from './pre-gate-steps.js';
 
 /**
- * Run the close-validation gate chain. Throws on first gate failure.
- *
- * Order: pre-gate self-heal steps → close-validation gates. The steps scope
- * to the `baseBranch...storyBranch` diff, commit inside the Story worktree,
- * and are best-effort — a missing `storyBranch` (resume/legacy callers) skips
- * them with a log line rather than failing.
- *
- * Gates are built from the canonical resolved config (`buildDefaultGates`
- * reads `project.commands` and `delivery.quality.gates.crap.enabled`); the
- * `baseBranch` is forwarded as the gate `baseBranch` so the format gate's
- * changed-file scope anchors on it. `standalone: true` routes the evidence
- * cache to the storyId-anchored keyspace.
+ * Pre-gate self-heal steps, then the gates (throws on first failure). The
+ * steps commit in the worktree before scoring, so the gates see their output.
  *
  * @param {{
  *   cwd: string,
@@ -81,10 +35,12 @@ import { runPreGateSteps as defaultRunPreGateSteps } from './pre-gate-steps.js';
  *   runContextBudgetWriteback?: Function,
  *   createGateLogSink?: typeof defaultCreateGateLogSink,
  * }} args
- * @returns {Promise<{ gates: Record<string, 'passed'|'skipped'> }>} Per-gate
- *   outcomes keyed by gate name — the terminal envelope reports the split
- *   baselines entries from this (Story #5172). A failure throws instead, with
- *   `err.closeGate` naming the gate that died.
+ * @returns {Promise<{
+ *   gates: Record<string, 'passed'|'skipped'>|null,
+ *   lockWait: { waitedSeconds: number, expired: boolean }|null,
+ *   pending: boolean,
+ * }>} `pending` (with `gates: null`) when a lock wait expired; any other
+ *   failure throws with `err.closeGate` naming the gate.
  */
 export async function runCloseValidationPhase({
   cwd,
@@ -119,15 +75,15 @@ export async function runCloseValidationPhase({
     'VALIDATE',
     `Running close-validation gates against baseline ${baseBranch}${worktreePath ? ` in ${worktreePath}` : ''}...`,
   );
-  // Story #4736 — one sink for both `log` seams (gate construction and gate
-  // execution), so nothing in the chain can route around the artifact.
+  // One sink for both `log` seams so nothing routes around the artifact.
   const gateLog = createGateLogSink({ storyId, config });
+  const lockWaits = trackLockWaits({ sink: gateLog.log, progress });
   const gateList = buildDefaultGates({
     config,
     baseBranch,
     cwd: worktreePath || cwd,
     log: gateLog.log,
-    storyId, // Story #5313 — a credited bare `npm test` registers `test`.
+    storyId,
     evidenceCwd: cwd,
   });
   let validation;
@@ -136,57 +92,107 @@ export async function runCloseValidationPhase({
       cwd,
       worktreePath,
       gates: gateList,
-      log: gateLog.log,
+      log: lockWaits.log,
       storyId,
-      // Story #4250 — standalone storyId-anchored evidence keyspace. No
-      // epicId; the standalone flag routes the cache to
-      // temp/standalone/stories/story-<id>/validation-evidence.json.
+      // Anchors the evidence cache on the Story id, so a re-close at an
+      // unchanged HEAD skips already-passed gates.
       standalone: true,
-      // Story #4776 — the branch pair and resolved config the advisory
-      // projections need. Without them the runner skips the projection
-      // phase entirely, which is the correct behaviour for resume/legacy
-      // callers that have no story branch to diff.
+      // Needed for the advisory baseline projections; absent, they're skipped.
       baseBranch,
       storyBranch,
       config,
+      deferOnLockExpiry: true,
     });
   } finally {
-    // Story #4766 — gate lines are buffered to an async stream so the drain
-    // never blocks a gate child's pipe. Settle the artifact before anything
-    // reads it, replays from it, or reports its path — including on the throw
-    // path, where the artifact is the only surviving record.
+    // The sink is async-buffered; settle it before anything reads it, on
+    // the throw path too.
     await gateLog.flush();
   }
+  const lockWait = lockWaits.summary();
   if (!validation.ok) {
-    const [first] = validation.failed;
-    const { gate, status, cwd: gateCwd } = first;
-    // The evidence is the point on this path: replay the captured tail inline
-    // rather than making the caller open a file to learn why close stopped.
-    gateLog.replay();
-    const err = new Error(
-      `[single-story-close] Gate failed: ${gate.name} (exit ${status})${gateCwd ? ` in ${gateCwd}` : ''}.` +
-        (gate.hint ? ` ${gate.hint}` : ''),
-    );
-    // Story #5172 — the phase tracker tags `closePhase`; this tags WHICH gate
-    // inside the phase died, so the failed terminal can name the split
-    // baselines entry rather than reporting a generic validation failure.
-    err.closeGate = gate.name;
-    throw err;
+    return settleFailedValidation({ validation, lockWait, gateLog, progress });
   }
   progress('VALIDATE', `✅ All gates passed. ${gateLog.digest()}`);
-  return { gates: gateOutcomes(gateList, validation) };
+  return {
+    gates: gateOutcomes(gateList, validation),
+    lockWait,
+    pending: false,
+  };
+}
+
+/**
+ * Deferred on an expired lock wait → `pending`; otherwise throws.
+ *
+ * @param {{
+ *   validation: { failed: Array<{ gate: { name: string, hint?: string }, status: number, cwd?: string }> },
+ *   lockWait: { waitedSeconds: number, expired: boolean }|null,
+ *   gateLog: { replay: () => void },
+ *   progress: (tag: string, msg: string) => void,
+ * }} args
+ * @returns {{ gates: null, lockWait: object, pending: true }}
+ */
+function settleFailedValidation({ validation, lockWait, gateLog, progress }) {
+  const [first] = validation.failed;
+  const { gate, status, cwd: gateCwd } = first;
+  if (isDeferredLockWait(first, lockWait)) {
+    progress(
+      'VALIDATE',
+      `⏸ ${gate.name} deferred: the full-suite lock wait expired after ${lockWait.waitedSeconds}s. Nothing was spawned; close will report pending.`,
+    );
+    return { gates: null, lockWait, pending: true };
+  }
+  gateLog.replay();
+  const err = new Error(
+    `[single-story-close] Gate failed: ${gate.name} (exit ${status})${gateCwd ? ` in ${gateCwd}` : ''}.` +
+      (gate.hint ? ` ${gate.hint}` : ''),
+  );
+  err.closeGate = gate.name;
+  throw err;
 }
 
 /**
- * Per-gate outcomes for a validation run that passed (Story #5172).
+ * Parsed from the gate log because it is the one place that sees waits both
+ * in-process and in gate children.
  *
- * Every registered gate passed unless the runner reported it skipped — an
- * evidence short-circuit at unchanged HEAD, or a changed-file scope that
- * matched nothing. `skipped` is the honest verdict for both: the gate did not
- * run in THIS invocation, and the terminal schema's own contract is that a
- * skipped gate is reported as skipped rather than quietly counted as a pass.
+ * @param {{ sink: (m: string) => void, progress: (tag: string, msg: string) => void }} args
+ * @returns {{ log: (m: string) => void, summary: () => { waitedSeconds: number, expired: boolean }|null }}
+ */
+function trackLockWaits({ sink, progress }) {
+  let tally = null;
+  return {
+    log(line) {
+      sink(line);
+      if (!String(line).includes('[full-suite-lock]')) return;
+      progress('LOCK', line);
+      const outcome = parseLockWaitOutcome(line);
+      if (!outcome) return;
+      tally = {
+        waitedSeconds: (tally?.waitedSeconds ?? 0) + outcome.waitedSeconds,
+        expired: Boolean(tally?.expired) || outcome.expired,
+      };
+    },
+    summary: () => tally,
+  };
+}
+
+/**
+ * Needs both the exit code and a recorded expiry — either alone is ambiguous.
+ *
+ * @param {{ status: number }|undefined} failure
+ * @param {{ expired: boolean }|null} lockWait
+ * @returns {boolean}
+ */
+function isDeferredLockWait(failure, lockWait) {
+  return (
+    failure?.status === LOCK_WAIT_EXPIRED_EXIT_CODE &&
+    lockWait?.expired === true
+  );
+}
+
+/**
+ * A gate that did not run this invocation reports `skipped`, never `passed`.
  *
- * @param {Array<{ name: string }>} gateList The gates this run registered.
+ * @param {Array<{ name: string }>} gateList
  * @param {{ skipped?: Array<{ gate: { name: string } }> }} validation
  * @returns {Record<string, 'passed'|'skipped'>}
  */

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

@@ -1,38 +1,11 @@
 /**
- * phases/code-review.js — Story-scope code review phase for
- * `single-story-close`.
+ * phases/code-review.js — Story-scope code review: findings post to the PR,
+ * with a cross-reference on the Story issue. Critical findings return
+ * `halted: true` so the caller never arms auto-merge.
  *
- * Runs the Story-scope code review against `main`, posts the structured
- * findings comment to the PR (not the Story issue), and adds a one-line
- * cross-reference comment on the Story issue linking back to the PR
- * review comment. The render header still labels the comment "Story #N"
- * even though the post target is the PR — the PR is the comment surface,
- * the Story is the ticket the findings *describe*.
- *
- * Cross-reference URL shape: GitHub serves issue comments at
- * `<prUrl>#issuecomment-<commentId>` — the same URL pattern for PR
- * conversation comments and issue comments, because PRs are issues at
- * the API level.
- *
- * Re-exports `parsePrNumber` (delegates to `lib/github-url.js`) so
- * existing call sites need not change. Story #3649.
- *
- * Critical findings cause `runStoryScopeReview` to return `halted: true`;
- * the caller raises that to a thrown error so auto-merge is not enabled.
- *
- * Delegates the `runCodeReview` invocation to `runStoryReviewCore`
- * (exported from `story-close/phases/review-core.js`) so the close path
- * shares a single invocation pattern (Story #3653). Review depth needs no
- * input here: it is derived from this Story's own diff inside `runCodeReview`
- * (Story #4542).
- *
- * Story #5325 — this phase boundary is where the base ref is resolved, once.
- * The resolved ref threads into `runStoryReviewCore`, which hands it to both
- * the change-set enumeration (and through it the provider review) and the
- * local lens pass, so one resolution corrects both arms. It resolves to
- * `origin/<baseBranch>` — the ref base-sync merged from — rather than the bare
- * branch name git would resolve to the local `refs/heads/<baseBranch>`, whose
- * drift would otherwise be scored as this Story's own change.
+ * The base ref is resolved once, here, to `origin/<baseBranch>` (what
+ * base-sync merged from) — the local branch's drift would otherwise be
+ * scored as this Story's change.
  */
 
 import { parsePrNumberFromUrl } from '../../../github-url.js';
@@ -49,23 +22,12 @@ import {
 } from './review-outcome.js';
 
 /**
- * Extract the numeric PR ID from a `gh pr create` URL. The CLI returns a
- * URL like `https://github.com/<owner>/<repo>/pull/<n>`; we want `<n>`.
- * Returns `null` when the URL doesn't match. Exported for testing.
- *
- * Delegates to `parsePrNumberFromUrl` in `lib/github-url.js`.
- * Re-exported under the original name so existing call sites and tests
- * do not need to change. Story #3649.
- *
  * @param {string|null|undefined} prUrl
  * @returns {number|null}
  */
 export const parsePrNumber = parsePrNumberFromUrl;
 
 /**
- * Build the cross-reference comment body posted on the Story issue when
- * the PR-side review comment lands. Pure; exported for testing.
- *
  * @param {{
  *   prUrl: string,
  *   prNumber: number,
@@ -109,9 +71,6 @@ async function invokeStoryReviewCore({
     progressTag: 'REVIEW',
     runCodeReviewFn,
     gitSpawnFn,
-    // Forward the seams only when the caller injects them; otherwise
-    // `runStoryReviewCore` uses its defaults. `undefined` deep-merges to
-    // the default via the destructuring default there.
     ...(runLocalLensReviewFn ? { runLocalLensReviewFn } : {}),
     ...(appendFindingsYieldFn ? { appendFindingsYieldFn } : {}),
   });
@@ -160,21 +119,8 @@ async function postStoryReviewCrossRef({
 }
 
 /**
- * Run the Story-scope code review against `main`, post the structured
- * findings comment to the PR, and add a one-line cross-reference comment
- * on the Story issue linking back to the PR review comment.
- *
- * Failure modes:
- *   - When `prNumber` is null (couldn't parse), the review is skipped
- *     and the function returns `{ halted: false, skipped: true }`.
- *   - When `origin/<baseBranch>` cannot be resolved, the review is skipped,
- *     a `base-ref-resolution` degradation is recorded on the returned
- *     envelope, and no findings are raised (Story #5325).
- *   - When the runner throws, the close fails non-zero (the throw
- *     propagates) — a Story-scope review failure is not silently
- *     ignored.
- *
- * Exported for testing.
+ * Skips on an unparseable PR number or an unresolvable base (recording a
+ * degradation); a runner throw propagates and fails the close.
  *
  * @param {{
  *   cwd: string,
@@ -224,8 +170,6 @@ export async function runStoryScopeReview({
     return { halted: false, skipped: true };
   }
 
-  // One resolution per close, at the phase boundary: `baseRef` threads from
-  // here into the change set, the provider review and the local lens pass.
   const base = resolveSharedBaseRef({ baseBranch, cwd, gitSpawnFn });
   if (!base.resolved) {
     return unresolvedBaseReviewOutcome({