@lumenflow/cli 5.3.1 → 5.4.0

package/packs/software-delivery/src/policy/resolve-policy.ts

@@ -66,10 +66,69 @@ export const ArchitectureMethodologySchema = z.enum(['hexagonal', 'layered', 'no
  */
 export const CoverageModeSchema = z.enum(['block', 'warn', 'off']);
 
+/**
+ * WU-2905: Default test-file glob patterns for the tdd_diff_evidence gate.
+ *
+ * These globs identify files that count as "test evidence" in a branch diff
+ * for the default TS/JS toolchain. Mirrors the regex set in
+ * `@lumenflow/core/file-classifiers.ts:TEST_FILE_PATTERNS` (the legacy regex
+ * form historically used by the gate consumer in wu:prep). When a workspace
+ * overrides `tdd_diff_evidence.test_file_patterns`, the gate uses the
+ * override exclusively (no merge) so non-TS/JS toolchains (.NET, Python,
+ * Go, ...) get a clean opt-in without inheriting TS/JS bias.
+ */
+export const DEFAULT_TDD_DIFF_TEST_FILE_PATTERNS: readonly string[] = Object.freeze([
+  '**/*.test.ts',
+  '**/*.test.tsx',
+  '**/*.test.js',
+  '**/*.test.jsx',
+  '**/*.test.mjs',
+  '**/*.spec.ts',
+  '**/*.spec.tsx',
+  '**/*.spec.js',
+  '**/*.spec.jsx',
+  '**/*.spec.mjs',
+  '**/__tests__/**',
+  '**/*.test-utils.*',
+  '**/*.mock.*',
+]);
+
+/**
+ * WU-2905: Default code file extensions for the tdd_diff_evidence gate.
+ *
+ * Determines which changed files count as production code that requires
+ * accompanying test evidence. Mirrors the historic constant in
+ * `methodology/incremental-test.ts:CODE_FILE_EXTENSIONS`.
+ */
+export const DEFAULT_TDD_DIFF_CODE_FILE_EXTENSIONS: readonly string[] = Object.freeze([
+  '.ts',
+  '.tsx',
+  '.js',
+  '.jsx',
+  '.cjs',
+  '.mts',
+  '.cts',
+]);
+
 export const TddDiffEvidenceConfigSchema = z.object({
   mode: CoverageModeSchema.optional(),
   applies_to_types: z.array(z.enum(WU_TYPE_VALUES)).min(1).optional(),
   exempt_paths: z.array(z.string().min(1)).optional(),
+  /**
+   * WU-2905: Optional glob patterns identifying test files for the
+   * tdd_diff_evidence gate. When omitted, defaults to TS/JS patterns
+   * (DEFAULT_TDD_DIFF_TEST_FILE_PATTERNS). When set, REPLACES the defaults so
+   * non-TS/JS consumers can supply only their language's test patterns
+   * (e.g. ['**\/*Tests.cs', '**\/Test*.cs'] for C# xUnit/NUnit/MSTest).
+   */
+  test_file_patterns: z.array(z.string().min(1)).min(1).optional(),
+  /**
+   * WU-2905: Optional file extensions identifying production code files for
+   * the tdd_diff_evidence gate. When omitted, defaults to TS/JS extensions
+   * (DEFAULT_TDD_DIFF_CODE_FILE_EXTENSIONS). When set, REPLACES the defaults
+   * (e.g. ['.cs'] for C#, ['.py'] for Python, ['.go'] for Go).
+   */
+  code_file_extensions: z.array(z.string().min(1)).min(1).optional(),
 });
 
 export type TddDiffEvidenceConfig = z.infer<typeof TddDiffEvidenceConfigSchema>;
@@ -275,6 +334,18 @@ export interface TddDiffEvidencePolicy {
   mode: CoverageMode;
   applies_to_types: WUType[];
   exempt_paths: string[];
+  /**
+   * WU-2905: Resolved glob patterns identifying test files. Always
+   * populated — falls back to DEFAULT_TDD_DIFF_TEST_FILE_PATTERNS when the
+   * workspace does not override.
+   */
+  test_file_patterns: string[];
+  /**
+   * WU-2905: Resolved file extensions identifying production code files.
+   * Always populated — falls back to DEFAULT_TDD_DIFF_CODE_FILE_EXTENSIONS
+   * when the workspace does not override.
+   */
+  code_file_extensions: string[];
 }
 
 /**
@@ -342,6 +413,14 @@ function cloneExemptPaths(value: readonly string[] | undefined): string[] {
   return [...(value ?? DEFAULT_TDD_DIFF_EXEMPT_PATHS)];
 }
 
+function cloneTestFilePatterns(value: readonly string[] | undefined): string[] {
+  return [...(value ?? DEFAULT_TDD_DIFF_TEST_FILE_PATTERNS)];
+}
+
+function cloneCodeFileExtensions(value: readonly string[] | undefined): string[] {
+  return [...(value ?? DEFAULT_TDD_DIFF_CODE_FILE_EXTENSIONS)];
+}
+
 function resolveTddDiffEvidencePolicy(
   testing: TestingMethodology,
   config: TddDiffEvidenceConfig | undefined,
@@ -350,6 +429,8 @@ function resolveTddDiffEvidencePolicy(
     mode: config?.mode ?? resolveDefaultTddDiffEvidenceMode(testing),
     applies_to_types: cloneWuTypes(config?.applies_to_types),
     exempt_paths: cloneExemptPaths(config?.exempt_paths),
+    test_file_patterns: cloneTestFilePatterns(config?.test_file_patterns),
+    code_file_extensions: cloneCodeFileExtensions(config?.code_file_extensions),
   };
 }
 
@@ -506,6 +587,8 @@ export function getDefaultPolicy(): ResolvedPolicy {
       mode: COVERAGE_MODE.BLOCK,
       applies_to_types: [...DEFAULT_TDD_DIFF_APPLIES_TO_TYPES],
       exempt_paths: [...DEFAULT_TDD_DIFF_EXEMPT_PATHS],
+      test_file_patterns: [...DEFAULT_TDD_DIFF_TEST_FILE_PATTERNS],
+      code_file_extensions: [...DEFAULT_TDD_DIFF_CODE_FILE_EXTENSIONS],
     },
     tdd_ordering: {
       mode: COVERAGE_MODE.BLOCK,

package/packs/software-delivery/tool-impl/memory-tools.ts

@@ -16,6 +16,7 @@ const MEMORY_TOOLS = {
   MEM_EXPORT: 'mem:export',
   MEM_INBOX: 'mem:inbox',
   MEM_SIGNAL: 'mem:signal',
+  MEM_CONVERGED: 'mem:converged',
   MEM_SUMMARIZE: 'mem:summarize',
   MEM_TRIAGE: 'mem:triage',
   MEM_RECOVER: 'mem:recover',
@@ -35,6 +36,7 @@ const MEMORY_TOOL_ERROR_CODES: Record<MemoryToolName, string> = {
   'mem:export': 'MEM_EXPORT_ERROR',
   'mem:inbox': 'MEM_INBOX_ERROR',
   'mem:signal': 'MEM_SIGNAL_ERROR',
+  'mem:converged': 'MEM_CONVERGED_ERROR',
   'mem:summarize': 'MEM_SUMMARIZE_ERROR',
   'mem:triage': 'MEM_TRIAGE_ERROR',
   'mem:recover': 'MEM_RECOVER_ERROR',
@@ -55,6 +57,7 @@ const MEMORY_TOOL_COMMANDS: Record<
   'mem:export': RUNTIME_CLI_COMMANDS.MEM_EXPORT,
   'mem:inbox': RUNTIME_CLI_COMMANDS.MEM_INBOX,
   'mem:signal': RUNTIME_CLI_COMMANDS.MEM_SIGNAL,
+  'mem:converged': RUNTIME_CLI_COMMANDS.MEM_CONVERGED,
   'mem:summarize': RUNTIME_CLI_COMMANDS.MEM_SUMMARIZE,
   'mem:triage': RUNTIME_CLI_COMMANDS.MEM_TRIAGE,
   'mem:recover': RUNTIME_CLI_COMMANDS.MEM_RECOVER,
@@ -338,6 +341,18 @@ export async function memInboxTool(input: unknown): Promise<ToolOutput> {
   if (lane) {
     args.push('--lane', lane);
   }
+  const reader = toStringValue(parsed.for);
+  if (reader) {
+    args.push('--for', reader);
+  }
+  const thread = toStringValue(parsed.thread);
+  if (thread) {
+    args.push('--thread', thread);
+  }
+  const intent = toStringValue(parsed.intent);
+  if (intent) {
+    args.push('--intent', intent);
+  }
 
   return executeMemoryTool(MEMORY_TOOLS.MEM_INBOX, args);
 }
@@ -354,7 +369,47 @@ export async function memSignalTool(input: unknown): Promise<ToolOutput> {
     return createMissingParameterOutput(MISSING_PARAMETER_MESSAGES.WU_REQUIRED);
   }
 
-  return executeMemoryTool(MEMORY_TOOLS.MEM_SIGNAL, [message, '--wu', wu]);
+  const args = [message, '--wu', wu];
+  const to = toStringValue(parsed.to);
+  if (to) {
+    args.push('--to', to);
+  }
+  const thread = toStringValue(parsed.thread);
+  if (thread) {
+    args.push('--thread', thread);
+  }
+  const replyTo = toStringValue(parsed.reply_to);
+  if (replyTo) {
+    args.push('--reply-to', replyTo);
+  }
+  const intent = toStringValue(parsed.intent);
+  if (intent) {
+    args.push('--intent', intent);
+  }
+  const interrupt = toStringValue(parsed.interrupt);
+  if (interrupt) {
+    args.push('--interrupt', interrupt);
+  }
+  if (parsed.requires_ack === true) {
+    args.push('--requires-ack');
+  }
+
+  return executeMemoryTool(MEMORY_TOOLS.MEM_SIGNAL, args);
+}
+
+export async function memConvergedTool(input: unknown): Promise<ToolOutput> {
+  const parsed = toRecord(input);
+  const thread = toStringValue(parsed.thread);
+  if (!thread) {
+    return createMissingParameterOutput('thread is required');
+  }
+
+  const args = ['--thread', thread];
+  if (parsed.quiet === true) {
+    args.push('--quiet');
+  }
+
+  return executeMemoryTool(MEMORY_TOOLS.MEM_CONVERGED, args);
 }
 
 export async function memSummarizeTool(input: unknown): Promise<ToolOutput> {

package/packs/software-delivery/tool-impl/runtime-cli-adapter.ts

@@ -47,6 +47,7 @@ export const RUNTIME_CLI_COMMANDS = {
   MEM_DELETE: 'mem-delete',
   MEM_EXPORT: 'mem-export',
   MEM_INBOX: 'mem-inbox',
+  MEM_CONVERGED: 'mem-converged',
   MEM_INIT: 'mem-init',
   MEM_READY: 'mem-ready',
   MEM_RECOVER: 'mem-recover',

package/templates/core/AGENTS.md.template

@@ -70,7 +70,7 @@ cd <project-root> && pnpm wu:done --id WU-XXXX
 Step 2 above is not optional:
 
 - `wu:brief` records checkpoint evidence; `wu:done` **blocks** without it for feature/bug WUs.
-- `wu:brief` also auto-loads shared memory and coordination signals into the generated prompt (WU-1240, WU-2607) — read the `## Memory Context` section in the brief output before coding. Manual `mem:context`/`mem:inbox` calls are still available as ad-hoc lookups mid-WU.
+- `wu:brief` also auto-loads shared memory and an Inbox Snapshot into the generated prompt (WU-1240, WU-2607) — read the `## Memory Context` section in the brief output before coding. Manual `mem:context`/`mem:inbox` calls are still available as ad-hoc lookups mid-WU.
 - Load relevant skills (`design-first`, `tdd-workflow`, `frontend-design`, `worktree-discipline`, `lumenflow-gates`) via your vendor's skill primitive. Claude Code, Codex, Cursor, and Windsurf all support `SKILL.md`-based skills (with minor invocation differences); Aider uses `CONVENTIONS.md`; Cline uses `.clinerules`. See [LUMENFLOW.md "Skills & Agents"](LUMENFLOW.md#skills--agents) for the invocation table, and your per-vendor rules file for specifics.
 
 ### During the WU
@@ -83,6 +83,16 @@ pnpm mem:signal '<short status>' --wu WU-XXXX
 pnpm mem:checkpoint --wu WU-XXXX --note '<progress>' --next-steps '<what is next>'
 ```
 
+### Inbox Signals Are Decision Points
+
+At `wu:brief`, after every `mem:checkpoint`, and before `wu:prep`, inspect unread coordination
+signals for your WU/session. A signal is not noise: read it, decide whether it changes or blocks the
+WU, and reply, acknowledge, or dismiss it before continuing.
+
+This convention applies to Claude Code, Codex, Cursor, Gemini CLI, and Windsurf briefs. Aider and
+Cline do not use `wu:brief` client variants, but they must follow the same polling rule through this
+onboarding guidance and their generated rules surfaces.
+
 **Classification rule:** if the fact would help _another_ agent vendor working this repo, it belongs in shared memory (`mem:create`), not your vendor's personal memory folder. Examples of shared: bug discoveries, architecture decisions, CI/gates gotchas, initiative direction, cross-WU scope flags. Examples of vendor-personal: behavioural feedback, user preferences, tool-invocation mechanics.
 
 **Shell-quoting footgun:** always **single-quote** the `--title` value. Bash expands `$var`, `$0`, backticks, and `!hist` inside double-quoted strings, silently corrupting prose containing prices (`$49`), positional refs, or exclamation marks. See [Memory section in LUMENFLOW.md](LUMENFLOW.md#memory-shared-vs-vendor-personal) for the full mem:\* contract.
@@ -204,6 +214,14 @@ LumenFlow enforces safety at the repository level via git wrappers and hooks. Fo
 
 This file provides universal guidance for all AI agents. LumenFlow skills live in `.lumenflow/skills/` as `SKILL.md` files and are projected to each vendor via `pnpm lumenflow:integrate --client <x>`.
 
+Agent plugins are a discovery and invocation on-ramp, not a replacement for repo-level LumenFlow
+integration. If a plugin is installed alongside standalone projections, use the surface-specific
+name: standalone skills keep local names such as `design-first`, Claude plugin skills use names such
+as `/lumenflow:design-first`, and Codex plugin use should select the installed `lumenflow` plugin or
+bundled skill through Codex's `@` plugin selection surface. Plugin installation must not delete
+`.claude/skills/` or `.agents/skills/`, and governed repo enforcement still requires
+`npx lumenflow init`, `pnpm lumenflow:integrate`, or `pnpm lumenflow:integrate --sync`.
+
 | Vendor       | Skill / rules surface                               | Invocation                                                             |
 | ------------ | --------------------------------------------------- | ---------------------------------------------------------------------- |
 | Claude Code  | `.claude/skills/` + `.claude/CLAUDE.md`             | `Skill` tool call, or `/skill <name>` in interactive CLI               |

package/templates/core/LUMENFLOW.md.template

@@ -727,6 +727,15 @@ If you're an AI agent, read the onboarding docs:
 
 Skills are reusable workflow/knowledge bundles that agents load on demand. The `SKILL.md` format pioneered by Claude Code has converged into a de-facto standard adopted by OpenAI Codex (Dec 2025), Cursor (v2.4), and Windsurf Cascade (Jan 2026). LumenFlow stores vendor-neutral skill sources in `.lumenflow/skills/` and projects them to each vendor surface via `pnpm lumenflow:integrate --client <x>`.
 
+Agent plugins are a distribution on-ramp, not a replacement for these repo-level
+projections or for the Software Delivery Pack runtime. Standalone projected
+skills keep local names such as `design-first`, while plugin-installed Claude
+skills use plugin-qualified names such as `/lumenflow:design-first`. If both
+surfaces exist, prompts and handoff text must say which one they mean.
+Installing a plugin gives the agent methodology and entrypoint guidance;
+repo-level enforcement still requires `npx lumenflow init`,
+`pnpm lumenflow:integrate`, or `pnpm lumenflow:integrate --sync`.
+
 ### Core skills (vendor-neutral)
 
 | Skill                 | Load before...                               |
@@ -752,6 +761,14 @@ A skill name written in prose does nothing — it must be **loaded** through the
 | Aider        | `CONVENTIONS.md`          | `/read CONVENTIONS.md` or `aider --read CONVENTIONS.md`  |
 | Cline        | `.clinerules`             | Auto-loaded                                              |
 
+For plugin-distributed skills, prefer the vendor's plugin-qualified invocation
+surface instead of rewriting all canonical skill names. Claude Code plugin
+skills are namespaced as `/lumenflow:<skill>`. Codex plugin use should name the
+installed `lumenflow` plugin or one of its bundled skills through Codex's `@`
+plugin selection surface. Standalone projections remain valid until a future
+explicit cleanup command such as `--plugin-only` exists and is run
+intentionally.
+
 For vendor-specific setup details and per-vendor quirks, see:
 
 - Claude Code: [.claude/CLAUDE.md](.claude/CLAUDE.md)

package/templates/core/ai/onboarding/agent-safety-card.md.template

@@ -40,12 +40,28 @@ Quick reference for AI agents working in LumenFlow projects.
 | Read WU spec first                   | Understand scope                  |
 | cd to worktree after claim           | Isolation                         |
 | Write tests before code              | TDD                               |
+| Treat unread inbox signals as decisions | Prevent missed redirects       |
 | Run wu:prep in the claimed workspace | Quality and lifecycle correctness |
 | Run wu:done from main                | Complete WU                       |
 | Stay within code_paths               | Scope discipline                  |
 
 ---
 
+## Coordination Signals
+
+`wu:brief` includes an Inbox Snapshot when memory is available. Also check `mem:inbox`
+after checkpoints and before `wu:prep`.
+
+An unread signal is a decision point:
+
+1. Read it.
+2. Decide whether it changes, blocks, or does not affect the WU.
+3. Reply, acknowledge, or dismiss it before continuing.
+
+Do not leave directed signals for `wu:done`; by then the coordination window has already passed.
+
+---
+
 ## Universal Safety Mechanisms
 
 ### Git Safety Wrapper

package/templates/core/ai/onboarding/vendor-support.md.template

@@ -31,15 +31,15 @@ lumenflow init
 
 For popular AI coding assistants, LumenFlow provides **optional enhanced integrations** with deeper features like auto-detection, skills, and vendor-specific configurations.
 
-| Assistant   | Config File                    | Auto-detected | Enhanced Features               |
-| ----------- | ------------------------------ | ------------- | ------------------------------- |
-| Claude Code | `CLAUDE.md`, `.claude/`        | Yes           | Skills, agents, hooks, settings |
-| Cursor      | `.cursor/rules/lumenflow.md`   | Yes           | Rules integration               |
-| Windsurf    | `.windsurf/rules/lumenflow.md` | Yes           | Rules integration               |
-| Cline       | `.clinerules`                  | No            | Rules file                      |
-| Codex       | `AGENTS.md` (native)           | No            | Uses universal files directly   |
-| Aider       | `.aider.conf.yml`              | No            | Config file                     |
-| Antigravity | `AGENTS.md` (native)           | Unknown       | Research phase                  |
+| Assistant   | Config File                    | Auto-detected | Enhanced Features                                                |
+| ----------- | ------------------------------ | ------------- | ---------------------------------------------------------------- |
+| Claude Code | `CLAUDE.md`, `.claude/`        | Yes           | Skills, agents, hooks, settings, A2A `signal:received` delivery |
+| Cursor      | `.cursor/rules/lumenflow.md`   | Yes           | Rules integration; A2A push deferred to `mem:watch`              |
+| Windsurf    | `.windsurf/rules/lumenflow.md` | Yes           | Rules integration; A2A push deferred to `mem:watch`              |
+| Cline       | `.clinerules`                  | No            | Rules file; poll `mem:inbox` for A2A signals                     |
+| Codex       | `AGENTS.md` (native)           | No            | Universal files directly; A2A push deferred to `mem:watch`       |
+| Aider       | `.aider.conf.yml`              | No            | Config file; poll `mem:inbox` for A2A signals                    |
+| Antigravity | `AGENTS.md` (native)           | Unknown       | Research phase                                                   |
 
 ---