@lumenflow/cli 2.1.2 → 2.2.1

package/dist/wu-edit.js

@@ -84,6 +84,9 @@ export function validateDoneWUEdits(opts) {
     if (opts.codePaths && Array.isArray(opts.codePaths) && opts.codePaths.length > 0) {
         disallowedEdits.push('--code-paths');
     }
+    if (opts.risks && Array.isArray(opts.risks) && opts.risks.length > 0) {
+        disallowedEdits.push('--risks');
+    }
     if (opts.lane)
         disallowedEdits.push('--lane');
     if (opts.type)
@@ -157,13 +160,24 @@ const EDIT_OPTIONS = {
     acceptance: {
         name: 'acceptance',
         flags: '--acceptance <criterion>',
-        description: 'Acceptance criterion (repeatable, replaces existing; use --append to add)',
+        description: 'Acceptance criterion (repeatable, appends to existing; use --replace-acceptance to overwrite)',
         isRepeatable: true,
     },
     notes: {
         name: 'notes',
         flags: '--notes <text>',
-        description: 'New notes text (replaces existing)',
+        description: 'Notes text (appends to existing; use --replace-notes to overwrite)',
+    },
+    // WU-1144: Add explicit replace flags for notes and acceptance
+    replaceNotes: {
+        name: 'replaceNotes',
+        flags: '--replace-notes',
+        description: 'Replace existing notes instead of appending',
+    },
+    replaceAcceptance: {
+        name: 'replaceAcceptance',
+        flags: '--replace-acceptance',
+        description: 'Replace existing acceptance criteria instead of appending',
     },
     codePaths: {
         name: 'codePaths',
@@ -171,10 +185,16 @@ const EDIT_OPTIONS = {
         description: 'Code path (repeatable, replaces existing; use --append to add)',
         isRepeatable: true,
     },
+    risks: {
+        name: 'risks',
+        flags: '--risks <risk>',
+        description: 'Risk entry (repeatable, replaces existing; use --append to add)',
+        isRepeatable: true,
+    },
     append: {
         name: 'append',
         flags: '--append',
-        description: 'Append to existing array values instead of replacing (for --acceptance, --code-paths)',
+        description: 'Append to existing array values instead of replacing (for --code-paths, --test-paths-*, --blocked-by, --add-dep)',
     },
     // WU-1456: Add lane reassignment support
     lane: {
@@ -310,7 +330,11 @@ function parseArgs() {
             EDIT_OPTIONS.description,
             EDIT_OPTIONS.acceptance,
             EDIT_OPTIONS.notes,
+            // WU-1144: Add explicit replace flags for notes and acceptance
+            EDIT_OPTIONS.replaceNotes,
+            EDIT_OPTIONS.replaceAcceptance,
             EDIT_OPTIONS.codePaths,
+            EDIT_OPTIONS.risks,
             EDIT_OPTIONS.append,
             // WU-1390: Add test path flags
             WU_OPTIONS.testPathsManual,
@@ -581,6 +605,25 @@ function mergeArrayField(existing, newValues, shouldAppend) {
     const existingArray = Array.isArray(existing) ? existing : [];
     return [...existingArray, ...newValues];
 }
+/**
+ * WU-1144: Merge string field values with append-by-default behavior
+ *
+ * Notes and acceptance criteria should append by default (preserving original),
+ * with explicit --replace-notes and --replace-acceptance flags for overwrite.
+ *
+ * @param {string | undefined} existing - Current string value from WU
+ * @param {string} newValue - New value from CLI
+ * @param {boolean} shouldReplace - Whether to replace instead of append
+ * @returns {string} Merged string value
+ */
+export function mergeStringField(existing, newValue, shouldReplace) {
+    // If replace mode or no existing value, just use new value
+    if (shouldReplace || !existing || existing.trim() === '') {
+        return newValue;
+    }
+    // Append with double newline separator
+    return `${existing}\n\n${newValue}`;
+}
 /**
  * Load spec file and merge with original WU (preserving id and status)
  * @param {string} specPath - Path to spec file
@@ -610,7 +653,7 @@ function loadSpecFile(specPath, originalWU) {
  * Returns the updated WU object
  */
 // eslint-disable-next-line sonarjs/cognitive-complexity -- Pre-existing complexity, refactor tracked separately
-function applyEdits(wu, opts) {
+export function applyEdits(wu, opts) {
     // Full spec replacement from file
     if (opts.specFile) {
         return loadSpecFile(opts.specFile, wu);
@@ -620,12 +663,17 @@ function applyEdits(wu, opts) {
     if (opts.description) {
         updated.description = opts.description;
     }
-    // Handle repeatable --acceptance flags (WU-1388: replace by default, append with --append)
+    // WU-1144: Handle --acceptance with append-by-default behavior
+    // Appends to existing acceptance criteria unless --replace-acceptance is set
     if (opts.acceptance && opts.acceptance.length > 0) {
-        updated.acceptance = mergeArrayField(wu.acceptance, opts.acceptance, opts.append);
+        // Invert the logic: append by default, replace with --replace-acceptance
+        const shouldAppend = !opts.replaceAcceptance;
+        updated.acceptance = mergeArrayField(wu.acceptance, opts.acceptance, shouldAppend);
     }
+    // WU-1144: Handle --notes with append-by-default behavior
+    // Appends to existing notes unless --replace-notes is set
     if (opts.notes) {
-        updated.notes = opts.notes;
+        updated.notes = mergeStringField(wu.notes, opts.notes, opts.replaceNotes ?? false);
     }
     // WU-1456: Handle lane reassignment
     if (opts.lane) {
@@ -670,6 +718,21 @@ function applyEdits(wu, opts) {
                 .filter(Boolean);
         updated.code_paths = mergeArrayField(wu.code_paths, codePaths, opts.append);
     }
+    // WU-1073: Handle repeatable --risks flags (replace by default, append with --append)
+    // Split comma-separated values within each entry for consistency with other list fields
+    if (opts.risks && opts.risks.length > 0) {
+        const rawRisks = opts.risks;
+        const risks = Array.isArray(rawRisks)
+            ? rawRisks
+                .flatMap((risk) => risk.split(','))
+                .map((risk) => risk.trim())
+                .filter(Boolean)
+            : rawRisks
+                .split(',')
+                .map((risk) => risk.trim())
+                .filter(Boolean);
+        updated.risks = mergeArrayField(wu.risks, risks, opts.append);
+    }
     // WU-1390: Handle test path flags (DRY refactor)
     const testPathMappings = [
         { optKey: 'testPathsManual', field: 'manual' },
@@ -757,6 +820,7 @@ async function main() {
         (opts.acceptance && opts.acceptance.length > 0) ||
         opts.notes ||
         (opts.codePaths && opts.codePaths.length > 0) ||
+        (opts.risks && opts.risks.length > 0) ||
         // WU-1390: Add test path flags to hasEdits check
         (opts.testPathsManual && opts.testPathsManual.length > 0) ||
         (opts.testPathsUnit && opts.testPathsUnit.length > 0) ||
@@ -779,9 +843,12 @@ async function main() {
             'Provide one of:\n' +
             '  --spec-file <path>        Replace full spec from YAML file\n' +
             '  --description <text>      Update description field\n' +
-            '  --acceptance <text>       Replace acceptance criteria (repeatable; use --append to add)\n' +
-            '  --notes <text>            Update notes field\n' +
+            '  --acceptance <text>       Append acceptance criteria (repeatable; use --replace-acceptance to overwrite)\n' +
+            '  --notes <text>            Append to notes (use --replace-notes to overwrite)\n' +
+            '  --replace-notes           Replace existing notes instead of appending\n' +
+            '  --replace-acceptance      Replace existing acceptance instead of appending\n' +
             '  --code-paths <paths>      Replace code paths (repeatable; use --append to add)\n' +
+            '  --risks <risk>            Replace risks (repeatable; use --append to add)\n' +
             '  --lane <lane>             Update lane assignment (e.g., "Operations: Tooling")\n' +
             '  --type <type>             Update WU type (feature, bug, refactor, documentation)\n' +
             '  --priority <priority>     Update priority (P0, P1, P2, P3)\n' +

package/dist/wu-infer-lane.d.ts

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+/**
+ * WU Lane Inference CLI (WU-908)
+ *
+ * Suggests sub-lane for a WU based on code paths and description.
+ * Wrapper around lib/lane-inference.mjs for standalone CLI usage.
+ *
+ * Usage:
+ *   # Infer from existing WU
+ *   node tools/wu-infer-lane.mjs --id WU-123
+ *
+ *   # Infer from manual inputs
+ *   node tools/wu-infer-lane.mjs --paths "tools/**" "docs/**" --desc "Tooling improvements"
+ *
+ * Returns suggested lane and confidence score (0-100).
+ */
+export {};

package/dist/wu-preflight.d.ts

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+/**
+ * WU Preflight Validation
+ *
+ * WU-1803: Fast validation of code_paths and test paths before gates run.
+ * Completes in under 5 seconds vs 2+ minutes for full gates.
+ *
+ * This catches YAML mismatches early, preventing wasted time running full
+ * gates only to fail on code_paths validation at the end of wu:done.
+ *
+ * Usage:
+ *   pnpm wu:preflight --id WU-1803          # Validate from main checkout
+ *   pnpm wu:preflight --id WU-1803 --worktree worktrees/operations-gates-wu-1803
+ *
+ * Validates:
+ *   - code_paths files exist
+ *   - test file paths exist (unit, e2e, integration)
+ *   - WU YAML schema is valid
+ */
+/**
+ * Parse command-line arguments
+ * @param {string[]} argv - Process arguments
+ * @returns {object} Parsed arguments
+ */
+declare function parseArgs(argv: any): {
+    help: boolean;
+    error?: undefined;
+    id?: undefined;
+    worktree?: undefined;
+} | {
+    error: string;
+    help?: undefined;
+    id?: undefined;
+    worktree?: undefined;
+} | {
+    id: any;
+    worktree: any;
+    help: boolean;
+    error?: undefined;
+};
+/**
+ * Detect worktree path from WU YAML or calculate from lane
+ * @param {string} id - WU ID
+ * @returns {string|null} Worktree path or null if not found
+ */
+declare function detectWorktreePath(id: any): string;
+export { parseArgs, detectWorktreePath };

package/dist/wu-prune.d.ts

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+/**
+ * WU Prune Utility
+ *
+ * Maintains worktree hygiene by:
+ * - Running git worktree prune to clean stale metadata
+ * - Validating worktree ↔ WU ↔ lane mappings
+ * - Warning on orphaned worktrees (no matching WU YAML)
+ * - Warning on stale worktrees (WU status is done/blocked)
+ * - Warning on invalid branch naming conventions
+ *
+ * Usage:
+ *   pnpm wu:prune          # Dry-run mode (shows what would be done)
+ *   pnpm wu:prune --execute # Actually run cleanup
+ */
+export {};

package/dist/wu-recover.d.ts

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+/**
+ * WU Recovery Command
+ *
+ * WU-1090: Context-aware state machine for WU lifecycle commands
+ *
+ * Analyzes WU state inconsistencies and offers recovery actions:
+ * - resume: Reconcile state and continue working (preserves work)
+ * - reset: Discard worktree and reset WU to ready
+ * - nuke: Remove all artifacts completely (requires --force)
+ * - cleanup: Remove leftover worktree for done WUs
+ *
+ * Usage:
+ *   pnpm wu:recover --id WU-123             # Analyze issues
+ *   pnpm wu:recover --id WU-123 --action resume  # Apply fix
+ *   pnpm wu:recover --id WU-123 --action nuke --force  # Destructive
+ */
+import { type RecoveryAnalysis } from '@lumenflow/core/dist/recovery/recovery-analyzer.js';
+/**
+ * Check if action requires --force flag
+ */
+export declare function requiresForceFlag(action: string): boolean;
+/**
+ * Validate recovery action
+ */
+export declare function validateRecoveryAction(action: string): {
+    valid: boolean;
+    error?: string;
+};
+/**
+ * Format recovery analysis output
+ */
+export declare function formatRecoveryOutput(analysis: RecoveryAnalysis): string;
+/**
+ * Get exit code for recovery command
+ */
+export declare function getRecoveryExitCode(analysis: RecoveryAnalysis, actionFailed: boolean): number;

package/dist/wu-release.d.ts

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+/**
+ * WU Release Command (WU-1080)
+ *
+ * Releases an orphaned WU from in_progress back to ready state.
+ * Use when an agent is interrupted mid-WU and the WU needs to be reclaimed.
+ *
+ * Sequence (micro-worktree pattern):
+ * 1) Validate WU is in_progress
+ * 2) Create micro-worktree from main
+ * 3) Append release event to state store
+ * 4) Regenerate backlog.md and status.md
+ * 5) Commit in micro-worktree, push directly to origin/main
+ * 6) Optionally remove the work worktree
+ *
+ * Usage:
+ *   pnpm wu:release --id WU-1080 --reason "Agent interrupted"
+ */
+export {};

package/dist/wu-repair.d.ts

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+/**
+ * WU State Repair Tool (Unified - WU-1826, WU-2240)
+ *
+ * Layer 2 defense-in-depth: detect and repair WU state inconsistencies.
+ *
+ * This unified tool consolidates four repair modes:
+ * - Consistency mode (default): detect/repair state inconsistencies
+ * - Claim mode (--claim): repair missing claim metadata in worktrees
+ * - Admin mode (--admin): administrative fixes for done WUs
+ * - State mode (--repair-state): repair corrupted wu-events.jsonl (WU-2240)
+ *
+ * Usage:
+ *   # Consistency mode (default)
+ *   pnpm wu:repair --id WU-123           # Repair single WU
+ *   pnpm wu:repair --id WU-123 --check   # Audit only, no changes
+ *   pnpm wu:repair --all                 # Batch repair all WUs
+ *   pnpm wu:repair --all --check         # Audit all WUs
+ *
+ *   # Claim mode
+ *   pnpm wu:repair --claim --id WU-123           # Repair claim metadata
+ *   pnpm wu:repair --claim --id WU-123 --check   # Check only
+ *   pnpm wu:repair --claim --id WU-123 --worktree /path/to/worktree
+ *
+ *   # Admin mode
+ *   pnpm wu:repair --admin --id WU-123 --lane "Operations: Tooling"
+ *   pnpm wu:repair --admin --id WU-123 --status cancelled
+ *   pnpm wu:repair --admin --id WU-123 --notes "Administrative fix"
+ *   pnpm wu:repair --admin --id WU-123 --initiative INIT-001
+ *
+ *   # State mode (WU-2240)
+ *   pnpm wu:repair --repair-state                    # Repair default state file
+ *   pnpm wu:repair --repair-state --path /path/to/wu-events.jsonl  # Repair specific file
+ *
+ * Exit codes:
+ *   0: Success (no issues or all repaired)
+ *   1: Issues detected (--check mode)
+ *   2: Repair failed
+ *
+ * DEPRECATION NOTICE:
+ *   - pnpm wu:repair-claim is deprecated. Use: pnpm wu:repair --claim
+ *   - pnpm wu:admin-repair is deprecated. Use: pnpm wu:repair --admin
+ *
+ * @see {@link tools/lib/wu-repair-core.mjs} - Core repair logic
+ * @see {@link tools/lib/wu-consistency-checker.mjs} - Consistency detection/repair
+ * @see {@link tools/lib/wu-state-store.mjs} - State file repair (repairStateFile)
+ */
+/**
+ * Normalise WU ID to uppercase with WU- prefix
+ * @param {string} id - Raw WU ID
+ * @returns {string} Normalised WU ID
+ */
+declare function normaliseWUId(id: any): any;
+/**
+ * Validate WU ID format
+ * @param {string} id - WU ID to validate
+ * @returns {boolean} True if valid
+ */
+declare function isValidWUId(id: any): boolean;
+export { normaliseWUId, isValidWUId };

package/dist/wu-spawn-completion.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Generate the Completion Workflow section for sub-agents (WU-2682).
+ *
+ * Explicitly instructs sub-agents to run wu:done autonomously after gates pass.
+ * This prevents agents from asking permission instead of completing.
+ *
+ * @param {string} id - WU ID
+ * @returns {string} Completion Workflow section
+ */
+export declare function generateCompletionWorkflowSection(id: string): string;

package/dist/wu-spawn.d.ts

@@ -0,0 +1,192 @@
+#!/usr/bin/env node
+/**
+ * WU Spawn Helper
+ *
+ * Generates ready-to-use Task tool invocations for sub-agent WU execution.
+ * Includes context loading preamble, skills selection guidance, and constraints block.
+ *
+ * Usage:
+ *   pnpm wu:spawn --id WU-123
+ *   pnpm wu:spawn --id WU-123 --codex
+ *
+ * Output:
+ *   A complete Task tool invocation block with:
+ *   - Context loading preamble (.claude/CLAUDE.md, README, lumenflow, WU YAML)
+ *   - WU details and acceptance criteria
+ *   - Skills Selection section (sub-agent reads catalogue and selects at runtime)
+ *   - Mandatory agent advisory
+ *   - Constraints block at end (Lost in the Middle research)
+ *
+ * Skills Selection:
+ *   This command is AGENT-FACING. Unlike /wu-prompt (human-facing, skills selected
+ *   at generation time), wu:spawn instructs the sub-agent to read the skill catalogue
+ *   and select skills at execution time based on WU context.
+ *
+ * Codex Mode:
+ *   When --codex is used, outputs a Codex/GPT-friendly Markdown prompt (no antml/XML escaping).
+ *
+ * @see {@link docs/04-operations/_frameworks/lumenflow/agent/onboarding/agent-invocation-guide.md} - Context loading templates
+ */
+import { getConfig } from '@lumenflow/core/dist/lumenflow-config.js';
+import type { ClientConfig } from '@lumenflow/core/dist/lumenflow-config-schema.js';
+/**
+ * WU-1131: Truncation prevention constants
+ *
+ * These constants help detect when spawn output has been truncated during
+ * copy-paste operations or context loading. The warning banner alerts users
+ * to the truncation risk, and the end sentinel allows verification that
+ * the full output was received.
+ */
+export declare const TRUNCATION_WARNING_BANNER = "<!-- LUMENFLOW_TRUNCATION_WARNING -->\n<!--\n  \u26A0\uFE0F CRITICAL: DO NOT TRUNCATE THIS OUTPUT\n\n  This spawn prompt MUST be copied verbatim. Truncation causes:\n  - Missing constraints (agents ignore safety rules)\n  - Missing TDD directives (agents skip tests)\n  - Degraded agent performance\n\n  VERIFICATION: The output MUST end with: <!-- LUMENFLOW_SPAWN_END -->\n  If you don't see that sentinel at the end, the output was truncated.\n-->\n";
+export declare const SPAWN_END_SENTINEL = "<!-- LUMENFLOW_SPAWN_END -->";
+/**
+ * Generate effort scaling rules section (WU-1986)
+ *
+ * Based on Anthropic multi-agent research: helps agents decide when to
+ * spawn sub-agents vs handle inline.
+ *
+ * @returns {string} Effort scaling section
+ */
+export declare function generateEffortScalingRules(): string;
+/**
+ * Generate parallel tool call guidance (WU-1986)
+ *
+ * Based on Anthropic research: 3+ parallel tool calls significantly improve performance.
+ *
+ * @returns {string} Parallel tool call guidance
+ */
+export declare function generateParallelToolCallGuidance(): string;
+/**
+ * Generate iterative search heuristics (WU-1986)
+ *
+ * Based on Anthropic research: start broad, narrow focus.
+ *
+ * @returns {string} Search heuristics section
+ */
+export declare function generateIterativeSearchHeuristics(): string;
+/**
+ * Generate token budget awareness section (WU-1986)
+ *
+ * @param {string} id - WU ID
+ * @returns {string} Token budget section
+ */
+export declare function generateTokenBudgetAwareness(id: any): string;
+/**
+ * Generate structured completion format (WU-1986)
+ *
+ * @param {string} id - WU ID
+ * @returns {string} Completion format section
+ */
+export declare function generateCompletionFormat(_id: any): string;
+/**
+ * Generate agent coordination section (WU-1987)
+ *
+ * Provides guidance on mem:signal for parallel agent coordination,
+ * orchestrate:status for dashboard checks, and abandoned WU handling.
+ *
+ * @param {string} id - WU ID
+ * @returns {string} Agent coordination section
+ */
+export declare function generateAgentCoordinationSection(id: any): string;
+/**
+ * Generate quick fix commands section (WU-1987)
+ *
+ * Provides format/lint/typecheck commands for quick fixes before gates.
+ *
+ * @returns {string} Quick fix commands section
+ */
+export declare function generateQuickFixCommands(): string;
+/**
+ * Generate Lane Selection section (WU-2107)
+ *
+ * Provides guidance on lane selection when creating new WUs.
+ * Points agents to wu:infer-lane for automated lane suggestions.
+ *
+ * @returns {string} Lane Selection section
+ */
+export declare function generateLaneSelectionSection(): string;
+/**
+ * Generate Worktree Path Guidance section (WU-2362)
+ *
+ * Provides guidance for sub-agents on working within worktrees, including
+ * how to determine the worktree root and where to create stamps.
+ *
+ * Problem: CLAUDE_PROJECT_DIR is hook-only; sub-agents inherit parent cwd (main).
+ * Solution: Use git rev-parse --show-toplevel to determine actual worktree root.
+ *
+ * @param {string|undefined} worktreePath - Worktree path from WU YAML
+ * @returns {string} Worktree path guidance section
+ */
+export declare function generateWorktreePathGuidance(worktreePath: any): string;
+/**
+ * Generate the Action section based on WU claim status (WU-1745).
+ *
+ * If WU is already claimed (has claimed_at and worktree_path), tells agent
+ * to continue in the existing worktree.
+ *
+ * If WU is unclaimed (status: ready), tells agent to run wu:claim first.
+ *
+ * @param {object} doc - WU YAML document
+ * @param {string} id - WU ID
+ * @returns {string} Action section content
+ */
+export declare function generateActionSection(doc: any, id: any): string;
+/**
+ * Generate the Completion Workflow section for sub-agents (WU-2682).
+ *
+ * Explicitly instructs sub-agents to run wu:done autonomously after gates pass.
+ * This prevents agents from asking permission instead of completing.
+ *
+ * @param {string} id - WU ID
+ * @returns {string} Completion Workflow section
+ */
+export declare function generateCompletionWorkflowSection(id: string): string;
+interface ClientContext {
+    name: string;
+    config?: ClientConfig;
+}
+interface SpawnOptions {
+    thinking?: boolean;
+    noThinking?: boolean;
+    budget?: string;
+    client?: ClientContext;
+    config?: ReturnType<typeof getConfig>;
+}
+/**
+ * Generate the complete Task tool invocation
+ *
+ * @param {object} doc - WU YAML document
+ * @param {string} id - WU ID
+ * @param {SpawnStrategy} strategy - Client strategy
+ * @param {object} [options={}] - Thinking mode options
+ * @param {boolean} [options.thinking] - Whether extended thinking is enabled
+ * @param {boolean} [options.noThinking] - Whether thinking is explicitly disabled
+ * @param {string} [options.budget] - Token budget for thinking
+ * @returns {string} Complete Task tool invocation
+ */
+export declare function generateTaskInvocation(doc: any, id: any, strategy: any, options?: SpawnOptions): string;
+export declare function generateCodexPrompt(doc: any, id: any, strategy: any, options?: SpawnOptions): string;
+/**
+ * WU-1603: Check if a lane is currently occupied by another WU
+ *
+ * @param {string} lane - Lane name (e.g., "Operations: Tooling")
+ * @returns {import('@lumenflow/core/dist/lane-lock.js').LockMetadata|null} Lock metadata if occupied, null otherwise
+ */
+export declare function checkLaneOccupation(lane: any): import("@lumenflow/core/dist/lane-lock.js").LockMetadata;
+/**
+ * WU-1603: Generate a warning message when lane is occupied
+ *
+ * @param {import('@lumenflow/core/dist/lane-lock.js').LockMetadata} lockMetadata - Lock metadata
+ * @param {string} targetWuId - WU ID being spawned
+ * @param {Object} [options={}] - Options
+ * @param {boolean} [options.isStale] - Whether the lock is stale (>24h old)
+ * @returns {string} Warning message
+ */
+interface LaneOccupationOptions {
+    isStale?: boolean;
+}
+export declare function generateLaneOccupationWarning(lockMetadata: {
+    lane: string;
+    wuId: string;
+}, targetWuId: string, options?: LaneOccupationOptions): string;
+export {};