@lumenflow/core 1.3.4 → 1.3.6

package/dist/wu-recovery.js

@@ -25,7 +25,7 @@ import { moveWUToDoneBacklog } from './wu-backlog-updater.js';
 import { getGitForCwd } from './git-adapter.js';
 import { createError, ErrorCodes } from './error-handler.js';
 import { rollbackFiles } from './rollback-utils.js';
-import { LOG_PREFIX, EMOJI, WU_STATUS, getProjectRoot } from './wu-constants.js';
+import { LOG_PREFIX, EMOJI, WU_STATUS, getProjectRoot, LUMENFLOW_PATHS, } from './wu-constants.js';
 import { RETRY_PRESETS } from './retry-strategy.js';
 /**
  * WU-1335: Maximum number of recovery attempts before escalating to manual intervention
@@ -33,24 +33,24 @@ import { RETRY_PRESETS } from './retry-strategy.js';
  */
 export const MAX_RECOVERY_ATTEMPTS = RETRY_PRESETS.recovery.maxAttempts;
 /**
- * WU-1335: Recovery marker subdirectory within .beacon
+ * WU-1335: Recovery marker subdirectory within .lumenflow
  */
 const RECOVERY_MARKER_DIR = 'recovery';
 /**
  * WU-1335: Get the path to the recovery marker file for a WU
  *
  * @param {string} id - WU ID
- * @param {string} [baseDir=process.cwd()] - Base directory for .beacon
+ * @param {string} [baseDir=process.cwd()] - Base directory for .lumenflow
  * @returns {string} Path to recovery marker file
  */
 export function getRecoveryMarkerPath(id, baseDir = process.cwd()) {
-    return join(baseDir, '.beacon', RECOVERY_MARKER_DIR, `${id}.recovery`);
+    return join(baseDir, LUMENFLOW_PATHS.BASE, RECOVERY_MARKER_DIR, `${id}.recovery`);
 }
 /**
  * WU-1335: Get the current recovery attempt count for a WU
  *
  * @param {string} id - WU ID
- * @param {string} [baseDir=process.cwd()] - Base directory for .beacon
+ * @param {string} [baseDir=process.cwd()] - Base directory for .lumenflow
  * @returns {number} Current attempt count (0 if no marker exists)
  */
 export function getRecoveryAttemptCount(id, baseDir = process.cwd()) {
@@ -71,12 +71,12 @@ export function getRecoveryAttemptCount(id, baseDir = process.cwd()) {
  * WU-1335: Increment recovery attempt count for a WU
  *
  * @param {string} id - WU ID
- * @param {string} [baseDir=process.cwd()] - Base directory for .beacon
+ * @param {string} [baseDir=process.cwd()] - Base directory for .lumenflow
  * @returns {number} New attempt count
  */
 export function incrementRecoveryAttempt(id, baseDir = process.cwd()) {
     const markerPath = getRecoveryMarkerPath(id, baseDir);
-    const markerDir = join(baseDir, '.beacon', RECOVERY_MARKER_DIR);
+    const markerDir = join(baseDir, LUMENFLOW_PATHS.BASE, RECOVERY_MARKER_DIR);
     // Ensure directory exists
     if (!existsSync(markerDir)) {
         mkdirSync(markerDir, { recursive: true });
@@ -95,7 +95,7 @@ export function incrementRecoveryAttempt(id, baseDir = process.cwd()) {
  * WU-1335: Clear recovery attempts for a WU (called on successful recovery)
  *
  * @param {string} id - WU ID
- * @param {string} [baseDir=process.cwd()] - Base directory for .beacon
+ * @param {string} [baseDir=process.cwd()] - Base directory for .lumenflow
  */
 export function clearRecoveryAttempts(id, baseDir = process.cwd()) {
     const markerPath = getRecoveryMarkerPath(id, baseDir);

package/dist/wu-repair-core.js

@@ -21,7 +21,7 @@ import { readWU, writeWU, parseYAML, stringifyYAML } from './wu-yaml.js';
 import { WU_PATHS } from './wu-paths.js';
 import { WUStateStore, WU_EVENTS_FILE_NAME } from './wu-state-store.js';
 import { getGitForCwd, createGitForPath } from './git-adapter.js';
-import { EXIT_CODES, LOG_PREFIX, EMOJI, WU_STATUS } from './wu-constants.js';
+import { EXIT_CODES, LOG_PREFIX, EMOJI, WU_STATUS, LUMENFLOW_PATHS, } from './wu-constants.js';
 import { die } from './error-handler.js';
 import { ensureOnMain, ensureMainUpToDate, validateWUIDFormat } from './wu-helpers.js';
 import { withMicroWorktree } from './micro-worktree.js';
@@ -103,7 +103,7 @@ export async function checkClaimMetadata(id, worktreePath) {
         errors.push(`WU YAML not found at: ${wuPath}`);
     }
     // Check state store
-    const stateDir = path.join(worktreePath, '.beacon', 'state');
+    const stateDir = path.join(worktreePath, LUMENFLOW_PATHS.STATE_DIR);
     const eventsPath = path.join(stateDir, WU_EVENTS_FILE_NAME);
     if (existsSync(eventsPath)) {
         try {
@@ -174,7 +174,7 @@ export async function repairClaimMetadata(id, worktreePath, checkResult) {
     // Repair 2: Add claim event to state store if missing
     if (!checkResult.stateStoreHasClaim) {
         try {
-            const stateDir = path.join(worktreePath, '.beacon', 'state');
+            const stateDir = path.join(worktreePath, LUMENFLOW_PATHS.STATE_DIR);
             const eventsPath = path.join(stateDir, WU_EVENTS_FILE_NAME);
             // Ensure directory exists
             mkdirSync(stateDir, { recursive: true });
@@ -201,7 +201,7 @@ export async function repairClaimMetadata(id, worktreePath, checkResult) {
             const gitWorktree = createGitForPath(worktreePath);
             // Stage repaired files
             const filesToStage = [wuPath];
-            const stateDir = path.join(worktreePath, '.beacon', 'state');
+            const stateDir = path.join(worktreePath, LUMENFLOW_PATHS.STATE_DIR);
             const eventsPath = path.join(stateDir, WU_EVENTS_FILE_NAME);
             if (existsSync(eventsPath)) {
                 filesToStage.push(eventsPath);

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

@@ -79,7 +79,7 @@ export declare function getHelpText(): string;
  * @param {string} options.parentWuId - Parent WU ID (orchestrator)
  * @param {string} options.targetWuId - Target WU ID (spawned work)
  * @param {string} options.lane - Lane for the spawned work
- * @param {string} [options.baseDir] - Base directory for registry (defaults to .beacon/state)
+ * @param {string} [options.baseDir] - Base directory for registry (defaults to LUMENFLOW_PATHS.STATE_DIR)
  * @returns {Promise<{success: boolean, spawnId: string|null, error?: string}>}
  *
  * @example

package/dist/wu-spawn-helpers.js

@@ -12,6 +12,7 @@
  */
 import { Command } from 'commander';
 import { SpawnRegistryStore } from './spawn-registry-store.js';
+import { LUMENFLOW_PATHS } from './wu-constants.js';
 /**
  * Option definitions for thinking mode configuration.
  *
@@ -210,7 +211,7 @@ const LOG_PREFIX = '[wu:spawn]';
  * @param {string} options.parentWuId - Parent WU ID (orchestrator)
  * @param {string} options.targetWuId - Target WU ID (spawned work)
  * @param {string} options.lane - Lane for the spawned work
- * @param {string} [options.baseDir] - Base directory for registry (defaults to .beacon/state)
+ * @param {string} [options.baseDir] - Base directory for registry (defaults to LUMENFLOW_PATHS.STATE_DIR)
  * @returns {Promise<{success: boolean, spawnId: string|null, error?: string}>}
  *
  * @example
@@ -225,7 +226,7 @@ const LOG_PREFIX = '[wu:spawn]';
  * }
  */
 export async function recordSpawnToRegistry(options) {
-    const { parentWuId, targetWuId, lane, baseDir = '.beacon/state' } = options;
+    const { parentWuId, targetWuId, lane, baseDir = LUMENFLOW_PATHS.STATE_DIR } = options;
     try {
         const store = new SpawnRegistryStore(baseDir);
         await store.load();

package/dist/wu-spawn.js

@@ -34,7 +34,7 @@ import { createWUParser, WU_OPTIONS } from './arg-parser.js';
 import { WU_PATHS } from './wu-paths.js';
 import { parseYAML } from './wu-yaml.js';
 import { die } from './error-handler.js';
-import { WU_STATUS, PATTERNS, EMOJI } from './wu-constants.js';
+import { WU_STATUS, PATTERNS, EMOJI, LUMENFLOW_PATHS } from './wu-constants.js';
 // WU-1603: Check lane lock status before spawning
 import { checkLaneLock } from './lane-lock.js';
 import { minimatch } from 'minimatch';
@@ -650,7 +650,7 @@ git rev-parse --show-toplevel
 
 ### Stamp Creation
 
-When creating \`.beacon/\` stamps or other artifacts:
+When creating \`.lumenflow/\` stamps or other artifacts:
 
 1. **ALWAYS** create stamps in the **worktree**, not main
 2. Use \`git rev-parse --show-toplevel\` to get the correct base path
@@ -659,11 +659,11 @@ When creating \`.beacon/\` stamps or other artifacts:
 \`\`\`bash
 # CORRECT: Create stamp in worktree
 WORKTREE_ROOT=$(git rev-parse --show-toplevel)
-mkdir -p "$WORKTREE_ROOT/.beacon/agent-runs"
-touch "$WORKTREE_ROOT/.beacon/agent-runs/beacon-guardian.stamp"
+mkdir -p "$WORKTREE_ROOT/.lumenflow/agent-runs"
+touch "$WORKTREE_ROOT/.lumenflow/agent-runs/beacon-guardian.stamp"
 
 # WRONG: Hardcoded path to main
-# touch /path/to/main/.beacon/agent-runs/beacon-guardian.stamp
+# touch /path/to/main/.lumenflow/agent-runs/beacon-guardian.stamp
 \`\`\`
 
 ### Why This Matters
@@ -789,7 +789,7 @@ cd worktrees/${laneSlug}-${id.toLowerCase()}
 Then implement following all standards above.
 
 **CRITICAL:** Never use \`git worktree add\` directly. Always use \`pnpm wu:claim\` to ensure:
-- Event tracking in .beacon/state/wu-events.jsonl
+- Event tracking in ${LUMENFLOW_PATHS.WU_EVENTS}
 - Lane lock acquisition (WIP=1 enforcement)
 - Session tracking for context recovery`;
 }
@@ -1229,7 +1229,7 @@ async function main() {
                 parentWuId: args.parentWu,
                 targetWuId: id,
                 lane: doc.lane || 'Unknown',
-                baseDir: '.beacon/state',
+                baseDir: LUMENFLOW_PATHS.STATE_DIR,
             });
             const registryMessage = formatSpawnRecordedMessage(registryResult.spawnId, registryResult.error);
             console.log(`\n${registryMessage}`);

package/dist/wu-state-schema.d.ts

@@ -17,8 +17,9 @@ import { z } from 'zod';
  * - complete: WU completed (transitions to done)
  * - checkpoint: Progress checkpoint (WU-1748: cross-agent visibility)
  * - spawn: WU spawned from parent (WU-1947: parent-child relationships)
+ * - release: WU released (WU-1080: transitions from in_progress to ready for orphan recovery)
  */
-export declare const WU_EVENT_TYPES: readonly ["create", "claim", "block", "unblock", "complete", "checkpoint", "spawn"];
+export declare const WU_EVENT_TYPES: readonly ["create", "claim", "block", "unblock", "complete", "checkpoint", "spawn", "release"];
 /** Type for WU event types */
 export type WUEventType = (typeof WU_EVENT_TYPES)[number];
 /**
@@ -103,6 +104,17 @@ export declare const SpawnEventSchema: z.ZodObject<{
     parentWuId: z.ZodString;
     spawnId: z.ZodString;
 }, z.core.$strip>;
+/**
+ * Release event schema (WU-1080: orphan recovery)
+ * Releases an in_progress WU back to ready state when agent is interrupted.
+ * Allows another agent to reclaim the orphaned WU.
+ */
+export declare const ReleaseEventSchema: z.ZodObject<{
+    wuId: z.ZodString;
+    timestamp: z.ZodString;
+    type: z.ZodLiteral<"release">;
+    reason: z.ZodString;
+}, z.core.$strip>;
 /**
  * Union schema for all event types
  */
@@ -145,6 +157,11 @@ export declare const WUEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"spawn">;
     parentWuId: z.ZodString;
     spawnId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    wuId: z.ZodString;
+    timestamp: z.ZodString;
+    type: z.ZodLiteral<"release">;
+    reason: z.ZodString;
 }, z.core.$strip>], "type">;
 /**
  * TypeScript types inferred from schemas
@@ -156,6 +173,7 @@ export type UnblockEvent = z.infer<typeof UnblockEventSchema>;
 export type CompleteEvent = z.infer<typeof CompleteEventSchema>;
 export type CheckpointEvent = z.infer<typeof CheckpointEventSchema>;
 export type SpawnEvent = z.infer<typeof SpawnEventSchema>;
+export type ReleaseEvent = z.infer<typeof ReleaseEventSchema>;
 export type WUEvent = z.infer<typeof WUEventSchema>;
 /**
  * Validates WU event data against schema
@@ -210,4 +228,9 @@ export declare function validateWUEvent(data: any): z.ZodSafeParseResult<{
     type: "spawn";
     parentWuId: string;
     spawnId: string;
+} | {
+    wuId: string;
+    timestamp: string;
+    type: "release";
+    reason: string;
 }>;

package/dist/wu-state-schema.js

@@ -17,6 +17,7 @@ import { z } from 'zod';
  * - complete: WU completed (transitions to done)
  * - checkpoint: Progress checkpoint (WU-1748: cross-agent visibility)
  * - spawn: WU spawned from parent (WU-1947: parent-child relationships)
+ * - release: WU released (WU-1080: transitions from in_progress to ready for orphan recovery)
  */
 export const WU_EVENT_TYPES = [
     'create',
@@ -26,6 +27,7 @@ export const WU_EVENT_TYPES = [
     'complete',
     'checkpoint',
     'spawn',
+    'release',
 ];
 /**
  * WU status values (matches LumenFlow state machine)
@@ -125,6 +127,16 @@ export const SpawnEventSchema = BaseEventSchema.extend({
     /** Unique spawn identifier */
     spawnId: z.string().min(1, { message: 'Spawn ID is required' }),
 });
+/**
+ * Release event schema (WU-1080: orphan recovery)
+ * Releases an in_progress WU back to ready state when agent is interrupted.
+ * Allows another agent to reclaim the orphaned WU.
+ */
+export const ReleaseEventSchema = BaseEventSchema.extend({
+    type: z.literal('release'),
+    /** Reason for releasing the WU */
+    reason: z.string().min(1, { message: ERROR_MESSAGES.REASON_REQUIRED }),
+});
 /**
  * Union schema for all event types
  */
@@ -136,6 +148,7 @@ export const WUEventSchema = z.discriminatedUnion('type', [
     CompleteEventSchema,
     CheckpointEventSchema,
     SpawnEventSchema,
+    ReleaseEventSchema,
 ]);
 /**
  * Validates WU event data against schema

package/dist/wu-state-store.d.ts

@@ -2,7 +2,7 @@
  * WU State Store (WU-1570, WU-2240)
  *
  * Event-sourced state store for WU lifecycle following INIT-007 pattern.
- * Stores events in .beacon/state/wu-events.jsonl (append-only, git-friendly).
+ * Stores events in .lumenflow/state/wu-events.jsonl (append-only, git-friendly).
  *
  * Features:
  * - Event sourcing with replay for current state
@@ -217,6 +217,27 @@ export declare class WUStateStore {
      * await store.spawn('WU-200', 'WU-100', 'spawn-abc123');
      */
     spawn(childWuId: string, parentWuId: string, spawnId: string): Promise<void>;
+    /**
+     * Releases an in_progress WU back to ready state (WU-1080: orphan recovery).
+     *
+     * Use this when an agent is interrupted mid-WU and the WU needs to be
+     * made available for reclaiming by another agent.
+     *
+     * @throws Error If WU is not in_progress
+     *
+     * @example
+     * await store.release('WU-1080', 'Agent interrupted mid-WU');
+     */
+    release(wuId: string, reason: string): Promise<void>;
+    /**
+     * Create a release event without writing to disk.
+     *
+     * Used by transactional flows where event log writes are staged and committed atomically.
+     * WU-1080: Orphan recovery support.
+     *
+     * @throws Error If WU is not in_progress or event fails validation
+     */
+    createReleaseEvent(wuId: string, reason: string, timestamp?: string): WUEvent;
 }
 /**
  * Check if a lock is stale (expired or dead process)
@@ -255,7 +276,7 @@ export declare function releaseLock(lockPath: string): void;
  * - Returns detailed repair statistics
  *
  * @example
- * const stateFilePath = path.join(process.cwd(), '.beacon', 'state', 'wu-events.jsonl');
+ * const stateFilePath = path.join(process.cwd(), '.lumenflow', 'state', 'wu-events.jsonl');
  * const result = await repairStateFile(stateFilePath);
  * if (result.success) {
  *   console.log(`Repaired: kept ${result.linesKept}, removed ${result.linesRemoved}`);

package/dist/wu-state-store.js

@@ -2,7 +2,7 @@
  * WU State Store (WU-1570, WU-2240)
  *
  * Event-sourced state store for WU lifecycle following INIT-007 pattern.
- * Stores events in .beacon/state/wu-events.jsonl (append-only, git-friendly).
+ * Stores events in .lumenflow/state/wu-events.jsonl (append-only, git-friendly).
  *
  * Features:
  * - Event sourcing with replay for current state
@@ -171,6 +171,11 @@ export class WUStateStore {
                 this.byParent.set(parentWuId, new Set());
             }
             this.byParent.get(parentWuId).add(wuId);
+            return;
+        }
+        // WU-1080: Handle release event - transitions from in_progress to ready
+        if (type === 'release') {
+            this._transitionToStatus(wuId, 'ready');
         }
     }
     /**
@@ -446,6 +451,55 @@ export class WUStateStore {
         await this._appendEvent(event);
         this._applyEvent(event);
     }
+    /**
+     * Releases an in_progress WU back to ready state (WU-1080: orphan recovery).
+     *
+     * Use this when an agent is interrupted mid-WU and the WU needs to be
+     * made available for reclaiming by another agent.
+     *
+     * @throws Error If WU is not in_progress
+     *
+     * @example
+     * await store.release('WU-1080', 'Agent interrupted mid-WU');
+     */
+    async release(wuId, reason) {
+        // Check state machine: can only release if in_progress
+        const currentState = this.wuState.get(wuId);
+        if (!currentState || currentState.status !== 'in_progress') {
+            throw new Error(`WU ${wuId} is not in_progress`);
+        }
+        const event = {
+            type: 'release',
+            wuId,
+            reason,
+            timestamp: new Date().toISOString(),
+        };
+        await this._appendEvent(event);
+        this._applyEvent(event);
+    }
+    /**
+     * Create a release event without writing to disk.
+     *
+     * Used by transactional flows where event log writes are staged and committed atomically.
+     * WU-1080: Orphan recovery support.
+     *
+     * @throws Error If WU is not in_progress or event fails validation
+     */
+    createReleaseEvent(wuId, reason, timestamp = new Date().toISOString()) {
+        const currentState = this.wuState.get(wuId);
+        if (!currentState || currentState.status !== 'in_progress') {
+            throw new Error(`WU ${wuId} is not in_progress`);
+        }
+        const event = { type: 'release', wuId, reason, timestamp };
+        const validation = validateWUEvent(event);
+        if (!validation.success) {
+            const issues = validation.error.issues
+                .map((issue) => `${issue.path.join('.')}: ${issue.message}`)
+                .join(', ');
+            throw new Error(`Validation error: ${issues}`);
+        }
+        return validation.data;
+    }
 }
 /**
  * Check if a process with given PID is running
@@ -592,7 +646,7 @@ export function releaseLock(lockPath) {
  * - Returns detailed repair statistics
  *
  * @example
- * const stateFilePath = path.join(process.cwd(), '.beacon', 'state', 'wu-events.jsonl');
+ * const stateFilePath = path.join(process.cwd(), '.lumenflow', 'state', 'wu-events.jsonl');
  * const result = await repairStateFile(stateFilePath);
  * if (result.success) {
  *   console.log(`Repaired: kept ${result.linesKept}, removed ${result.linesRemoved}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumenflow/core",
-  "version": "1.3.4",
+  "version": "1.3.6",
   "description": "Core WU lifecycle tools for LumenFlow workflow framework",
   "keywords": [
     "lumenflow",
@@ -91,8 +91,8 @@
     "vitest": "^4.0.17"
   },
   "peerDependencies": {
-    "@lumenflow/memory": "1.3.4",
-    "@lumenflow/initiatives": "1.3.4"
+    "@lumenflow/memory": "1.3.6",
+    "@lumenflow/initiatives": "1.3.6"
   },
   "peerDependenciesMeta": {
     "@lumenflow/memory": {

package/dist/spec-branch-helpers.d.ts

@@ -1,118 +0,0 @@
-/**
- * Spec Branch Helpers
- *
- * WU-1062: External plan storage and no-main-write mode
- *
- * Provides helpers for working with spec branches (spec/wu-XXXX).
- * wu:create writes to spec branches by default; wu:claim merges them to main.
- *
- * @module
- */
-import type { GitAdapter } from './git-adapter.js';
-/**
- * Spec branch prefix
- */
-export declare const SPEC_BRANCH_PREFIX = "spec/";
-/**
- * WU source location constants
- */
-export declare const WU_SOURCE: {
-    /** WU exists on main branch only */
-    readonly MAIN: "main";
-    /** WU exists on spec branch only */
-    readonly SPEC_BRANCH: "spec_branch";
-    /** WU exists on both main and spec branch */
-    readonly BOTH: "both";
-    /** WU not found anywhere */
-    readonly NOT_FOUND: "not_found";
-};
-export type WUSourceType = (typeof WU_SOURCE)[keyof typeof WU_SOURCE];
-/**
- * Get the spec branch name for a WU
- *
- * @param {string} wuId - Work Unit ID (e.g., 'WU-1062')
- * @returns {string} Spec branch name (e.g., 'spec/wu-1062')
- *
- * @example
- * getSpecBranchName('WU-1062') // 'spec/wu-1062'
- */
-export declare function getSpecBranchName(wuId: string): string;
-/**
- * Get the origin-qualified spec branch name
- *
- * @param {string} wuId - Work Unit ID
- * @returns {string} Origin-qualified branch name (e.g., 'origin/spec/wu-1062')
- */
-export declare function getOriginSpecBranch(wuId: string): string;
-/**
- * Check if a spec branch exists on origin
- *
- * @param {string} wuId - Work Unit ID
- * @param {SimpleGit} git - Git adapter instance
- * @returns {Promise<boolean>} True if spec branch exists
- *
- * @example
- * const exists = await specBranchExists('WU-1062', git);
- */
-export declare function specBranchExists(wuId: string, git: GitAdapter): Promise<boolean>;
-/**
- * Check if a WU exists on main branch
- *
- * @param {string} wuId - Work Unit ID
- * @param {SimpleGit} git - Git adapter instance
- * @returns {Promise<boolean>} True if WU YAML exists on main
- */
-export declare function isWUOnMain(wuId: string, git: GitAdapter): Promise<boolean>;
-/**
- * Merge spec branch to main branch (fast-forward only)
- *
- * This is used by wu:claim when a WU exists only on a spec branch.
- * The spec branch is merged to main before creating the worktree.
- *
- * @param {string} wuId - Work Unit ID
- * @param {SimpleGit} git - Git adapter instance
- * @throws {Error} If merge fails (e.g., due to conflicts)
- *
- * @example
- * await mergeSpecBranchToMain('WU-1062', git);
- */
-export declare function mergeSpecBranchToMain(wuId: string, git: GitAdapter): Promise<void>;
-/**
- * Delete spec branch after merge
- *
- * @param {string} wuId - Work Unit ID
- * @param {SimpleGit} git - Git adapter instance
- */
-export declare function deleteSpecBranch(wuId: string, git: GitAdapter): Promise<void>;
-/**
- * Determine the source of a WU (main, spec branch, both, or not found)
- *
- * Used by wu:claim to decide whether to merge spec branch before creating worktree.
- *
- * @param {string} wuId - Work Unit ID
- * @param {SimpleGit} git - Git adapter instance
- * @returns {Promise<WUSourceType>} Source location constant
- *
- * @example
- * const source = await getWUSource('WU-1062', git);
- * if (source === WU_SOURCE.SPEC_BRANCH) {
- *   await mergeSpecBranchToMain('WU-1062', git);
- * }
- */
-export declare function getWUSource(wuId: string, git: GitAdapter): Promise<WUSourceType>;
-/**
- * Create a spec branch from current HEAD
- *
- * Used by wu:create in default mode (no --direct flag).
- *
- * @param {string} wuId - Work Unit ID
- * @param {SimpleGit} git - Git adapter instance
- */
-export declare function createSpecBranch(wuId: string, git: GitAdapter): Promise<void>;
-/**
- * Push spec branch to origin
- *
- * @param {string} wuId - Work Unit ID
- * @param {SimpleGit} git - Git adapter instance
- */
-export declare function pushSpecBranch(wuId: string, git: GitAdapter): Promise<void>;