@lumenflow/cli 4.24.0 → 5.0.1

package/dist/wu-spawn-prompt-builders.js

@@ -17,7 +17,9 @@ import { minimatch } from 'minimatch';
 import { loadInvariants, INVARIANT_TYPES } from '@lumenflow/core/invariants-runner';
 import { validateSpawnArgs, generateExecutionModeSection, generateThinkToolGuidance, } from '@lumenflow/core/wu-spawn-helpers';
 import { findProjectRoot, getConfig } from '@lumenflow/core/config';
-import { BRANCHES, CONFIG_FILES, DIRECTORIES, LUMENFLOW_PATHS, REMOTES, } from '@lumenflow/core/wu-constants';
+import { StreamWatchdogConfigSchema } from '@lumenflow/core/config-schema';
+import { CONFIG_FILES, DIRECTORIES, LUMENFLOW_PATHS } from '@lumenflow/core/wu-constants';
+import { resolveIntegrationTargetRef } from '@lumenflow/core/integration-target';
 import { generateClientSkillsGuidance, generateSkillsSelectionSection, } from '@lumenflow/core/wu-spawn-skills';
 // WU-1253: Template loader for extracted prompt templates
 // WU-1898: Import evaluateCondition to gate templates by frontmatter conditions
@@ -30,7 +32,7 @@ import { TRUNCATION_WARNING_BANNER, SPAWN_END_SENTINEL, generateTestGuidance, ge
 // WU-1900: Import work classifier for domain-aware prompt generation
 import { classifyWork, TEST_METHODOLOGY_HINTS, } from '@lumenflow/core/work-classifier';
 // WU-1288: Import resolvePolicy for methodology policy resolution
-import { resolvePolicy } from '@lumenflow/core/resolve-policy';
+import { resolvePolicy } from '@lumenflow/packs-software-delivery/policy/resolve-policy';
 // WU-1240: Import memory context integration for spawn prompts
 import { generateMemoryContextSection, checkMemoryLayerInitialized, getMemoryContextMaxSize, } from '@lumenflow/core/wu-spawn-context';
 import { generateCompletionWorkflowSection as generateSharedCompletionWorkflowSection } from './wu-spawn-completion.js';
@@ -48,7 +50,9 @@ export { resolvePolicy };
 const SPAWN_PROMPT_BUILDERS_DIR = path.dirname(fileURLToPath(import.meta.url));
 const DEFAULT_TEMPLATE_BASE_DIR = findProjectRoot(SPAWN_PROMPT_BUILDERS_DIR);
 const DEFAULT_WORKTREES_DIR_SEGMENT = DIRECTORIES.WORKTREES.replace(/\/+$/g, '');
-const PRIMARY_MAIN_REF = `${REMOTES.ORIGIN}/${BRANCHES.MAIN}`;
+function getPrimaryMainRef() {
+    return resolveIntegrationTargetRef();
+}
 const LANE_GUIDANCE_TEMPLATE_ID_PREFIX = 'lane-guidance-';
 const DESIGN_CONTEXT_TEMPLATE_ID_PREFIX = 'design-context-';
 const VERIFICATION_TEMPLATE_ID_PREFIX = 'verification-';
@@ -75,6 +79,7 @@ const TEMPLATE_IDS = {
 const PRE_EXISTING_SKIP_GATES_REASON = 'pre-existing on main';
 const PRE_EXISTING_SKIP_GATES_FIX_WU = 'WU-XXXX';
 const PROJECT_LEVEL_SKIP_GATES_GUIDANCE = 'Project-level instructions win when they conflict with default skip-gates guidance';
+const WATCHDOG_LIVENESS_SECTION_HEADING = '## Watchdog-Safe Liveness Contract';
 const VERIFICATION_TEMPLATE_IDS = new Set([
     'documentation-directive',
     'visual-directive',
@@ -199,29 +204,75 @@ function resolveAgentCoordinationSection(templates, id) {
         AGENT_COORDINATION_SECTION: fallback,
     });
 }
-function resolveActionSection(templates, doc, id, config) {
-    const fallback = generateActionSection(doc, id, config);
+function resolveWatchdogHeartbeatCadenceSeconds(config) {
+    return StreamWatchdogConfigSchema.parse(config?.agents?.stream_watchdog ?? {})
+        .heartbeat_cadence_seconds;
+}
+export function generateWatchdogLivenessContractSection(config) {
+    const heartbeatCadenceSeconds = resolveWatchdogHeartbeatCadenceSeconds(config);
+    return `${WATCHDOG_LIVENESS_SECTION_HEADING}
+
+Some orchestration harnesses apply a stdout-silence watchdog during long
+read/reasoning windows. While you are working silently:
+
+1. Emit a \`[status]\` stdout line every ${heartbeatCadenceSeconds}s.
+2. Keep the line short and progress-oriented (for example:
+   \`[status] reading prompt builders\`).
+3. Do not wait for a tool call or gate run to prove liveness.
+4. Keep doing the scoped work; these status lines are heartbeat signals, not
+   completion claims.
+
+Configured watchdog cadence: ${heartbeatCadenceSeconds}s. Even if the client
+already streams its own progress, keep this explicit stdout heartbeat so the
+saved brief artifact and the operator runbook stay aligned.`;
+}
+function resolveActionSection(templates, doc, id, roleContract, delegationId, config) {
+    const fallback = generateActionSection(doc, id, roleContract, delegationId, config);
     const isAlreadyClaimed = Boolean(doc.claimed_at && doc.worktree_path);
+    const actualRole = roleContract?.actual_role;
+    const roleHintBlock = actualRole || delegationId
+        ? `\n\n**Expected session identity after claim:**\n- lifecycle_role: ${actualRole?.lifecycle_role ?? 'executor'}\n- specialty_profile: ${actualRole?.specialty_profile ?? 'general'}${delegationId ? `\n- delegation_id: ${delegationId}` : ''}\n- Confirm these values on the active session record so mem:roster and addressed signals stay accurate.`
+        : '';
+    const appendRoleHint = (resolved) => roleHintBlock && !resolved.includes('Expected session identity after claim')
+        ? `${resolved}${roleHintBlock}`
+        : resolved;
     if (isAlreadyClaimed) {
-        return resolveTemplateSection(templates, TEMPLATE_IDS.actionClaimed, fallback);
+        return appendRoleHint(resolveTemplateSection(templates, TEMPLATE_IDS.actionClaimed, fallback));
     }
-    return resolveTemplateSection(templates, TEMPLATE_IDS.actionUnclaimed, fallback, {
+    return appendRoleHint(resolveTemplateSection(templates, TEMPLATE_IDS.actionUnclaimed, fallback, {
         WORKTREE_PATH_HINT: resolveClaimWorktreePathHint(doc.lane, id, config),
         WU_EVENTS_PATH: LUMENFLOW_PATHS.WU_EVENTS,
-    });
+    }));
 }
+/**
+ * WU-2666: Codex constraints resolution.
+ *
+ * Tokens mirror the 8 critical-rule numbering from generateConstraints() so
+ * template overrides remain semantically equivalent. The template MUST render
+ * all 8 rules (7 when TDD is omitted). See BRIEF_PARITY_CONTRACT for the
+ * CI-enforced parity patterns.
+ */
 function resolveCodexConstraintsSection(templates, id, includeTddCheckpoint) {
     const fallback = generateCodexConstraints(id, { includeTddCheckpoint });
+    const tddBlock = includeTddCheckpoint
+        ? `1. **TDD CHECKPOINT** (VERIFY BEFORE IMPLEMENTATION)
+   - Did you write tests BEFORE implementation?
+   - Is there at least one failing test for each acceptance criterion?
+   - Never skip the RED phase — failing tests prove the test works
+
+`
+        : '';
     return resolveTemplateSection(templates, TEMPLATE_IDS.codexConstraints, fallback, {
-        TDD_CHECKPOINT_BLOCK: includeTddCheckpoint
-            ? '1. **TDD checkpoint**: tests BEFORE implementation; never skip RED\n'
-            : '',
-        STOP_NUM: String(includeTddCheckpoint ? 2 : 1),
-        VERIFY_NUM: String(includeTddCheckpoint ? 3 : 2),
-        FABRICATE_NUM: String(includeTddCheckpoint ? 4 : 3),
-        GIT_NUM: String(includeTddCheckpoint ? 5 : 4),
-        SCOPE_NUM: String(includeTddCheckpoint ? 6 : 5),
-        SKIP_GATES_NUM: String(includeTddCheckpoint ? 7 : 6),
+        TDD_CHECKPOINT_BLOCK: tddBlock,
+        ANTI_LOOP_NUM: String(includeTddCheckpoint ? 2 : 1),
+        STOP_ASK_NUM: String(includeTddCheckpoint ? 3 : 2),
+        VERIFY_NUM: String(includeTddCheckpoint ? 4 : 3),
+        NEVER_FAB_NUM: String(includeTddCheckpoint ? 5 : 4),
+        GIT_NUM: String(includeTddCheckpoint ? 6 : 5),
+        MEM_NUM: String(includeTddCheckpoint ? 7 : 6),
+        SKIP_GATES_NUM: String(includeTddCheckpoint ? 8 : 7),
+        PRIMARY_MAIN_REF: getPrimaryMainRef(),
+        PRE_EXISTING_SKIP_GATES_COMMAND: formatPreExistingSkipGatesCommand(id),
         PROJECT_LEVEL_SKIP_GATES_GUIDANCE,
     });
 }
@@ -554,7 +605,7 @@ ${neverFabNum}. NEVER FABRICATE COMPLETION
 
 ${gitNum}. GIT WORKFLOW (CRITICAL - GitHub rules reject merge commits)
    - GitHub REJECTS merge commits on main
-   - ALWAYS use \`git rebase ${PRIMARY_MAIN_REF}\` before push
+   - ALWAYS use \`git rebase ${getPrimaryMainRef()}\` before push
    - Push to main via \`git push origin lane/...:main\` (fast-forward only)
    - NEVER use \`git merge\` on main branch
    - Let \`pnpm wu:done\` handle the merge workflow
@@ -573,25 +624,88 @@ ${skipGatesNum}. SKIP-GATES POLICY LAYERING (WU-1142)
    - This prevents getting stuck on infrastructure debt
 </constraints>`;
 }
+/**
+ * WU-2666: Codex/Markdown rendering of the same critical rules as
+ * {@link generateConstraints}. Semantic parity — not verbatim — is the
+ * guarantee: every critical rule that appears in the Claude (XML) constraints
+ * block MUST also appear in the Codex (Markdown) block with the same named
+ * rule headers. See BRIEF_PARITY_CONTRACT for the enforceable patterns.
+ *
+ * Prior to WU-2666, Codex's constraints block was 6 items and silently omitted
+ * ANTI-LOOP GUARD, STOP-AND-ASK TRIGGERS, and MEMORY LAYER COORDINATION — the
+ * exact load-bearing guardrails that INIT-057 Codex agents needed.
+ */
 export function generateCodexConstraints(id, options) {
     const includeTdd = options?.includeTddCheckpoint !== false;
-    const tddLine = includeTdd
-        ? '1. **TDD checkpoint**: tests BEFORE implementation; never skip RED'
+    const tddBlock = includeTdd
+        ? `1. **TDD CHECKPOINT** (VERIFY BEFORE IMPLEMENTATION)
+   - Did you write tests BEFORE implementation?
+   - Is there at least one failing test for each acceptance criterion?
+   - Never skip the RED phase — failing tests prove the test works
+
+`
         : '';
-    const stopNum = includeTdd ? 2 : 1;
-    const verifyNum = includeTdd ? 3 : 2;
-    const fabricateNum = includeTdd ? 4 : 3;
-    const gitNum = includeTdd ? 5 : 4;
-    const scopeNum = includeTdd ? 6 : 5;
-    const skipGatesNum = includeTdd ? 7 : 6;
+    // WU-2666: Renumber in lockstep with generateConstraints(). Same rules,
+    // same order, same headings — only the rendering shell differs.
+    const antiLoopNum = includeTdd ? 2 : 1;
+    const stopAskNum = includeTdd ? 3 : 2;
+    const verifyNum = includeTdd ? 4 : 3;
+    const neverFabNum = includeTdd ? 5 : 4;
+    const gitNum = includeTdd ? 6 : 5;
+    const memNum = includeTdd ? 7 : 6;
+    const skipGatesNum = includeTdd ? 8 : 7;
     return `## Constraints (Critical)
 
-${tddLine}${tddLine ? '\n' : ''}${stopNum}. **Stop on errors**: if UnsafeAny command fails, report BLOCKED (never DONE) with the error
-${verifyNum}. **Verify before success**: run \`pnpm gates\` in the worktree, then run \`pnpm wu:verify --id ${id}\` (from the shared checkout)
-${fabricateNum}. **No fabrication**: if blockers remain or verification fails, report INCOMPLETE
-${gitNum}. **Git workflow**: avoid merge commits; let \`pnpm wu:done\` handle completion
-${scopeNum}. **Scope discipline**: stay within \`code_paths\`; capture out-of-scope issues via \`pnpm mem:create\`
-${skipGatesNum}. **Skip-gates for pre-existing**: if gates fail due to pre-existing issue on main, the default audited path is \`--skip-gates --reason "pre-existing" --fix-wu WU-XXX\`. If AGENTS.md or project-level instructions are stricter, follow those instead. ${PROJECT_LEVEL_SKIP_GATES_GUIDANCE}`;
+CRITICAL RULES - ENFORCE BEFORE EVERY ACTION:
+
+${tddBlock}${antiLoopNum}. **ANTI-LOOP GUARD** (LumenFlow §7.3)
+
+- Max 3 attempts per unique error before escalating
+- If same error repeats 3x, STOP and report with full context
+- Retry with different approach, not same command
+
+${stopAskNum}. **STOP-AND-ASK TRIGGERS** (LumenFlow §7.2 - narrow scope)
+
+- Policy changes, auth/permissions modifications
+- PII/safety issues, cloud spend, secrets, backups
+- Same error repeats 3x
+- For ordinary errors: fix and retry autonomously (up to 3 attempts)
+
+${verifyNum}. **VERIFY COMPLETION** before reporting success
+
+- Run \`pnpm gates\` in the worktree, then \`pnpm wu:verify --id ${id}\` (from the shared checkout)
+- Exit 0 = passed, Exit 1 = INCOMPLETE
+- Never report "done" if verification fails
+
+${neverFabNum}. **NEVER FABRICATE COMPLETION**
+
+- If blockers remain, report INCOMPLETE
+- If verification fails, summarize failures
+- Honesty over false completion
+
+${gitNum}. **GIT WORKFLOW** (CRITICAL - GitHub rules reject merge commits)
+
+- GitHub REJECTS merge commits on main
+- ALWAYS use \`git rebase ${getPrimaryMainRef()}\` before push
+- Push to main via \`git push origin lane/...:main\` (fast-forward only)
+- NEVER use \`git merge\` on main branch
+- Let \`pnpm wu:done\` handle the merge workflow
+
+${memNum}. **MEMORY LAYER COORDINATION** (INIT-007)
+
+- Use \`pnpm mem:checkpoint --wu ${id}\` to save progress before risky operations
+- Check \`pnpm mem:inbox --wu ${id}\` periodically for parallel signals from other agents
+- Checkpoint triggers (WU-1943): checkpoint after each acceptance criterion completed, checkpoint before gates, checkpoint every 30 tool calls
+
+${skipGatesNum}. **SKIP-GATES POLICY LAYERING** (WU-1142)
+
+- If gates fail, rerun \`pnpm wu:prep --id ${id}\` from the worktree; it checks main safely and prints skip-gates guidance when appropriate
+- If \`wu:prep\` reports the failure is pre-existing on main, the default audited path is: \`${formatPreExistingSkipGatesCommand(id)}\`
+- If AGENTS.md, the WU prompt, or project-level policy says to stop on gate failures, stop and surface the failure instead of using skip-gates autonomously
+- ${PROJECT_LEVEL_SKIP_GATES_GUIDANCE}
+- Stay within \`code_paths\`; capture out-of-scope issues via \`pnpm mem:create\`
+- Do NOT use \`git stash\` or mutate local main just to prove a pre-existing failure
+- This prevents getting stuck on infrastructure debt`;
 }
 // ─── Section Generators ───
 /**
@@ -831,13 +945,48 @@ export function generateWorktreePathGuidance(worktreePath) {
     if (!worktreePath) {
         return '';
     }
-    return `## Worktree Path Guidance (WU-2362)
+    return `## Worktree Path Guidance (WU-2362, WU-2655)
 
 **Your worktree:** \`${worktreePath}\`
 
+### First Action: cd to your declared worktree
+
+**Before ANY Read/Write/Edit tool call, run:**
+
+\`\`\`bash
+cd ${worktreePath}
+pwd  # MUST print a path ending in "${worktreePath}"
+\`\`\`
+
+### Absolute Paths Required for Write/Edit (WU-2655)
+
+Parallel-agent cwd-inheritance trap: when an orchestrator running in
+worktree-A spawns you for worktree-B, your process may inherit the
+orchestrator's cwd. Relative paths then resolve against the wrong
+worktree and your writes leak into worktree-A. This exact failure was
+reported by the WU-2638 agent during INIT-057 Wave 0.
+
+**Rules:**
+
+1. Use ABSOLUTE paths for every Write/Edit tool call, rooted at the
+   declared worktree.
+2. Compute the root via \`git rev-parse --show-toplevel\` AFTER your
+   \`cd\`, then prepend it to every path.
+3. If you invoke \`pnpm file:write\` or \`pnpm file:edit\` (vendor-agnostic
+   CLI), pass \`--worktree-root "$(git rev-parse --show-toplevel)"\` so
+   the CLI rejects any path that escapes the declared worktree.
+
+\`\`\`bash
+# Machine-enforced guard (vendor-agnostic) — use when available:
+WORKTREE_ROOT=$(git rev-parse --show-toplevel)
+pnpm file:write --worktree-root "$WORKTREE_ROOT" \\
+  --path "$WORKTREE_ROOT/src/feature.ts" --content "..."
+\`\`\`
+
 ### Finding the Worktree Root
 
-Sub-agents may inherit the parent's cwd (main checkout). To find the actual worktree root:
+Sub-agents may inherit the parent's cwd (main checkout or a sibling
+worktree). To find the actual worktree root:
 
 \`\`\`bash
 # Get the worktree root (not main checkout)
@@ -866,7 +1015,8 @@ touch "$WORKTREE_ROOT/.lumenflow/agent-runs/code-reviewer.stamp"
 
 - Stamps on main get overwritten by worktree merge
 - \`wu:done\` validates stamps exist in the worktree branch
-- Parallel WUs in other lanes won't see your stamps if on main`;
+- Parallel WUs in other lanes won't see your stamps if on main
+- Relative-path writes in parallel-spawned agents leak across worktrees (WU-2655)`;
 }
 /**
  * Generate the Bug Discovery section (WU-1592, WU-2284)
@@ -1020,12 +1170,16 @@ ${sections.join('\n\n')}`;
  * @param {string} id - WU ID
  * @returns {string} Action section content
  */
-export function generateActionSection(doc, id, config) {
+export function generateActionSection(doc, id, roleContract, delegationId, config) {
     const isAlreadyClaimed = doc.claimed_at && doc.worktree_path;
+    const actualRole = roleContract?.actual_role;
+    const roleHintBlock = actualRole || delegationId
+        ? `\n\n**Expected session identity after claim:**\n- lifecycle_role: ${actualRole?.lifecycle_role ?? 'executor'}\n- specialty_profile: ${actualRole?.specialty_profile ?? 'general'}${delegationId ? `\n- delegation_id: ${delegationId}` : ''}\n- Confirm these values on the active session record so mem:roster and addressed signals stay accurate.`
+        : '';
     if (isAlreadyClaimed) {
         return `This WU is already claimed. Continue implementation in worktree following all standards above.
 
-cd ${doc.worktree_path}`;
+cd ${doc.worktree_path}${roleHintBlock}`;
     }
     const claimWorktreePathHint = resolveClaimWorktreePathHint(doc.lane, id, config);
     return `**FIRST: Claim this WU before starting work:**
@@ -1040,7 +1194,7 @@ Then implement following all standards above.
 **CRITICAL:** Never use \`git worktree add\` directly. Always use \`pnpm wu:claim\` to ensure:
 - Event tracking in ${LUMENFLOW_PATHS.WU_EVENTS}
 - Lane lock acquisition (WIP=1 enforcement)
-- Session tracking for context recovery`;
+- Session tracking for context recovery${roleHintBlock}`;
 }
 /**
  * Generate the Completion Workflow section for sub-agents (WU-2682).
@@ -1255,6 +1409,7 @@ export function generateTaskInvocation(doc, id, strategy, options = {}) {
     // WU-2362: Worktree path guidance for sub-agents
     const worktreePathHint = resolveWorktreePathHint(doc, id, config);
     const worktreeGuidance = resolveTemplateSection(templates, TEMPLATE_IDS.worktreePathGuidance, generateWorktreePathGuidance(doc.worktree_path));
+    const watchdogLivenessContract = generateWatchdogLivenessContractSection(config);
     // WU-1134: Worktree block recovery guidance
     // WU-1253: Try template for worktree-recovery
     const worktreeBlockRecovery = templates.get('worktree-recovery') ||
@@ -1311,6 +1466,10 @@ ${mandatorySection}${invariantsPriorArt ? `---\n\n${invariantsPriorArt}\n\n` : '
 ${thinkingBlock}${skillsSection}
 ${memoryContextSection ? `---\n\n${memoryContextSection}\n\n` : ''}---
 
+${watchdogLivenessContract}
+
+---
+
 ${mandatoryStandards}
 
 ---
@@ -1369,7 +1528,7 @@ ${laneSelection}
 
 ${laneGuidance}${laneGuidance ? '\n\n---\n\n' : ''}## Action
 
-${resolveActionSection(templates, doc, id, config)}
+${resolveActionSection(templates, doc, id, options.roleContract, options.delegationId, config)}
 
 ---
 
@@ -1445,7 +1604,7 @@ export function generateCodexPrompt(doc, id, strategy, options = {}) {
     const templates = tryLoadTemplates(clientName, templateContext, templateBaseDir);
     const mandatorySection = resolveMandatoryAgentSection(templates, mandatoryAgents, id);
     const implementationContext = resolveImplementationContextSection(templates, implementationContextFallback);
-    const action = resolveActionSection(templates, doc, id, config);
+    const action = resolveActionSection(templates, doc, id, options.roleContract, options.delegationId, config);
     const constraints = resolveCodexConstraintsSection(templates, id, shouldIncludeTddCheckpoint);
     const testGuidanceFallback = [
         generateRequiredVerificationSection(doc),
@@ -1472,6 +1631,7 @@ export function generateCodexPrompt(doc, id, strategy, options = {}) {
     const designContextSection = resolveDesignContextSection(templates, classification);
     // WU-2368: DB-risk verification guidance when code_paths touch database files
     const dbRiskGuidance = resolveTemplateSection(templates, TEMPLATE_IDS.dbRiskVerification, generateDbRiskVerificationGuidance(codePaths));
+    const watchdogLivenessContract = generateWatchdogLivenessContractSection(config);
     const executionModeSection = generateExecutionModeSection(options);
     const thinkToolGuidance = generateThinkToolGuidance(options);
     const thinkingSections = [executionModeSection, thinkToolGuidance]
@@ -1538,6 +1698,10 @@ ${readBeforeWrite}
 ${designContextSection ? `---\n\n${designContextSection}\n\n` : ''}${skillsSection}
 ${memoryContextSection ? `---\n\n${memoryContextSection}\n\n` : ''}---
 
+${watchdogLivenessContract}
+
+---
+
 ## Action
 
 ${action}
@@ -1572,4 +1736,96 @@ ${constraints}
 ${SPAWN_END_SENTINEL}
 `;
 }
+/**
+ * WU-2666: Parity contract — load-bearing methodology sections that every
+ * supported --client brief MUST include. Adding a new client or generator
+ * without these sections is a CI failure.
+ *
+ * Section IDs match the mission-critical list in WU-2666's description:
+ * TDD RED-first, worktree discipline, constraints block, skill directives,
+ * memory/coordination, bug discovery, completion workflow.
+ */
+export const BRIEF_PARITY_CONTRACT = [
+    {
+        id: 'tdd-red-first',
+        description: 'TDD checkpoint with RED-first rule (feature/enhancement WUs)',
+        patterns: ['TDD CHECKPOINT', 'RED phase', 'tests BEFORE implementation'],
+    },
+    {
+        id: 'worktree-discipline',
+        description: 'Git/worktree discipline: rebase before push, never merge on main',
+        patterns: ['GIT WORKFLOW', 'git rebase', 'fast-forward', 'NEVER use `git merge`'],
+    },
+    {
+        id: 'constraints-block',
+        description: 'Constraints block declaring critical rules enforced before every action',
+        patterns: [
+            'CRITICAL RULES - ENFORCE BEFORE EVERY ACTION',
+            'ANTI-LOOP GUARD',
+            'STOP-AND-ASK',
+            'VERIFY COMPLETION',
+            'NEVER FABRICATE',
+            'SKIP-GATES',
+        ],
+    },
+    {
+        id: 'skills-directive',
+        description: 'Skills selection directive telling the agent to load relevant skills (universal — client-specific activation syntax like /skill is not required here)',
+        patterns: ['## Skills Selection', 'wu-lifecycle', 'worktree-discipline'],
+    },
+    {
+        id: 'memory-coordination',
+        description: 'Memory layer coordination: checkpoint + inbox for parallel-agent signals',
+        patterns: ['MEMORY LAYER COORDINATION', 'mem:checkpoint', 'mem:inbox'],
+    },
+    {
+        id: 'watchdog-liveness',
+        description: 'Watchdog-safe liveness contract: explicit stdout heartbeat during silent work',
+        patterns: [
+            'Watchdog-Safe Liveness Contract',
+            '`[status]` stdout line every',
+            'stdout-silence watchdog',
+        ],
+    },
+    {
+        id: 'bug-discovery',
+        description: 'Mid-WU bug capture via mem:create; no raw wu:create for discovered issues',
+        patterns: ['## Bug Discovery', 'pnpm mem:create', 'wu:create'],
+    },
+    {
+        id: 'completion-workflow',
+        description: 'Autonomous completion workflow invoking wu:done after gates pass',
+        patterns: ['## Completion Workflow', 'pnpm wu:done', 'pnpm gates'],
+    },
+];
+/**
+ * WU-2666: Canonical supported brief clients. New client variants MUST be
+ * added here so the parity contract test covers them — otherwise a client
+ * could ship without guardrails. The five names match resolveClientName().
+ */
+export const SUPPORTED_BRIEF_CLIENTS = [
+    'claude-code',
+    'codex-cli',
+    'cursor',
+    'gemini-cli',
+    'windsurf',
+];
+export function renderBriefForClient(args) {
+    const { client, doc, id, strategy, config, roleContract, delegationId } = args;
+    const clientContext = { name: client };
+    if (client === 'codex-cli') {
+        return generateCodexPrompt(doc, id, strategy, {
+            client: clientContext,
+            config,
+            roleContract,
+            delegationId,
+        });
+    }
+    return generateTaskInvocation(doc, id, strategy, {
+        client: clientContext,
+        config,
+        roleContract,
+        delegationId,
+    });
+}
 //# sourceMappingURL=wu-spawn-prompt-builders.js.map