@renseiai/agentfactory 0.8.13 → 0.8.14

package/dist/src/orchestrator/session-backstop.js

@@ -0,0 +1,394 @@
+/**
+ * Session Backstop
+ *
+ * Deterministic post-session recovery that runs after every agent session.
+ * Validates the session's outputs against the work type's completion contract,
+ * then takes backstop actions for any recoverable gaps.
+ *
+ * This is provider-agnostic — it operates on the worktree and GitHub API,
+ * not on the agent session. Every provider gets the same backstop.
+ *
+ * Architecture:
+ * 1. Collect session outputs (git state, PR detection, work result markers)
+ * 2. Validate against the completion contract
+ * 3. Run backstop actions for recoverable fields (push, create PR)
+ * 4. Return structured result for the orchestrator to act on
+ */
+import { execSync } from 'node:child_process';
+import { getCompletionContract, validateCompletion, formatMissingFields, } from './completion-contracts.js';
+/**
+ * Collect structured outputs from the completed session.
+ * Inspects git state, agent process data, and tracked flags.
+ */
+export function collectSessionOutputs(ctx) {
+    const { agent } = ctx;
+    const outputs = {
+        prUrl: agent.pullRequestUrl ?? undefined,
+        workResult: agent.workResult ?? 'unknown',
+        commentPosted: ctx.commentPosted,
+        issueUpdated: ctx.issueUpdated,
+        subIssuesCreated: ctx.subIssuesCreated,
+    };
+    // Inspect git state for code-producing work types
+    if (agent.worktreePath) {
+        try {
+            outputs.commitsPresent = hasCommitsAheadOfMain(agent.worktreePath);
+            outputs.branchPushed = isBranchPushed(agent.worktreePath);
+        }
+        catch {
+            // Git inspection failed — leave as undefined (unknown)
+        }
+    }
+    // If PR URL exists, check merged status
+    if (outputs.prUrl) {
+        try {
+            outputs.prMerged = isPrMerged(outputs.prUrl, agent.worktreePath);
+        }
+        catch {
+            // GitHub check failed — leave as undefined
+        }
+    }
+    return outputs;
+}
+/**
+ * Run the post-session backstop for an agent.
+ *
+ * 1. Collects session outputs
+ * 2. Validates against completion contract
+ * 3. Runs backstop actions for recoverable gaps
+ * 4. Returns structured result
+ *
+ * This function is safe to call for any work type — it returns a no-op
+ * result for work types without contracts.
+ */
+export function runBackstop(ctx, options) {
+    const workType = ctx.agent.workType ?? 'development';
+    const contract = getCompletionContract(workType);
+    // No contract for this work type — nothing to validate
+    if (!contract) {
+        return {
+            contract: null,
+            outputs: collectSessionOutputs(ctx),
+            validation: null,
+            backstop: { actions: [], fullyRecovered: true, remainingGaps: [] },
+            diagnosticMessage: null,
+        };
+    }
+    // Collect and validate
+    const outputs = collectSessionOutputs(ctx);
+    const validation = validateCompletion(contract, outputs);
+    // Already satisfied — no backstop needed
+    if (validation.satisfied) {
+        return {
+            contract,
+            outputs,
+            validation,
+            backstop: { actions: [], fullyRecovered: true, remainingGaps: [] },
+            diagnosticMessage: null,
+        };
+    }
+    // Run backstop actions for recoverable fields
+    const actions = [];
+    for (const fieldType of validation.backstopRecoverable) {
+        switch (fieldType) {
+            case 'branch_pushed': {
+                if (options?.dryRun) {
+                    actions.push({ field: 'branch_pushed', action: 'would push branch', success: false, detail: 'dry-run' });
+                    break;
+                }
+                const pushResult = backstopPushBranch(ctx.agent.worktreePath);
+                actions.push(pushResult);
+                if (pushResult.success) {
+                    outputs.branchPushed = true;
+                }
+                break;
+            }
+            case 'pr_url': {
+                // Can only create PR if branch is pushed (either already or by backstop above)
+                if (!outputs.branchPushed) {
+                    actions.push({
+                        field: 'pr_url',
+                        action: 'skipped PR creation — branch not pushed',
+                        success: false,
+                        detail: 'Branch must be pushed before PR can be created',
+                    });
+                    break;
+                }
+                if (options?.dryRun) {
+                    actions.push({ field: 'pr_url', action: 'would create PR', success: false, detail: 'dry-run' });
+                    break;
+                }
+                const prResult = backstopCreatePR(ctx.agent, options);
+                actions.push(prResult);
+                if (prResult.success && prResult.detail) {
+                    outputs.prUrl = prResult.detail;
+                    ctx.agent.pullRequestUrl = prResult.detail;
+                }
+                break;
+            }
+        }
+    }
+    // Re-validate after backstop
+    const postBackstopValidation = validateCompletion(contract, outputs);
+    const remainingGaps = postBackstopValidation.missingFields;
+    const fullyRecovered = postBackstopValidation.satisfied;
+    const backstopResult = {
+        actions,
+        fullyRecovered,
+        remainingGaps,
+    };
+    // Build diagnostic message for unrecoverable gaps
+    const diagnosticMessage = fullyRecovered
+        ? null
+        : formatMissingFields(contract, postBackstopValidation);
+    return {
+        contract,
+        outputs,
+        validation,
+        backstop: backstopResult,
+        diagnosticMessage,
+    };
+}
+// ---------------------------------------------------------------------------
+// Git inspection helpers
+// ---------------------------------------------------------------------------
+function hasCommitsAheadOfMain(worktreePath) {
+    try {
+        const currentBranch = execSync('git branch --show-current', {
+            cwd: worktreePath,
+            encoding: 'utf-8',
+            timeout: 10000,
+        }).trim();
+        if (currentBranch === 'main' || currentBranch === 'master' || !currentBranch) {
+            return false;
+        }
+        const aheadOutput = execSync('git rev-list --count main..HEAD', {
+            cwd: worktreePath,
+            encoding: 'utf-8',
+            timeout: 10000,
+        }).trim();
+        return parseInt(aheadOutput, 10) > 0;
+    }
+    catch {
+        return false;
+    }
+}
+function isBranchPushed(worktreePath) {
+    try {
+        const currentBranch = execSync('git branch --show-current', {
+            cwd: worktreePath,
+            encoding: 'utf-8',
+            timeout: 10000,
+        }).trim();
+        if (!currentBranch || currentBranch === 'main' || currentBranch === 'master') {
+            return true; // main is always "pushed"
+        }
+        const remoteRef = execSync(`git ls-remote --heads origin ${currentBranch}`, {
+            cwd: worktreePath,
+            encoding: 'utf-8',
+            timeout: 15000,
+        }).trim();
+        if (remoteRef.length === 0) {
+            return false; // remote branch doesn't exist
+        }
+        // Check if local is ahead of remote (unpushed commits)
+        try {
+            execSync('git rev-parse --abbrev-ref @{u}', {
+                cwd: worktreePath,
+                encoding: 'utf-8',
+                timeout: 10000,
+            });
+            const unpushed = execSync('git rev-list --count @{u}..HEAD', {
+                cwd: worktreePath,
+                encoding: 'utf-8',
+                timeout: 10000,
+            }).trim();
+            return parseInt(unpushed, 10) === 0;
+        }
+        catch {
+            // No tracking branch but remote exists — close enough
+            return true;
+        }
+    }
+    catch {
+        return false;
+    }
+}
+function isPrMerged(prUrl, worktreePath) {
+    try {
+        const prMatch = prUrl.match(/\/([^/]+)\/([^/]+)\/pull\/(\d+)/);
+        if (!prMatch)
+            return false;
+        const [, owner, repo, prNum] = prMatch;
+        const json = execSync(`gh pr view ${prNum} --repo ${owner}/${repo} --json state --jq '.state'`, {
+            cwd: worktreePath ?? process.cwd(),
+            encoding: 'utf-8',
+            timeout: 15000,
+        }).trim();
+        return json === 'MERGED';
+    }
+    catch {
+        return false;
+    }
+}
+// ---------------------------------------------------------------------------
+// Backstop actions
+// ---------------------------------------------------------------------------
+function backstopPushBranch(worktreePath) {
+    try {
+        const currentBranch = execSync('git branch --show-current', {
+            cwd: worktreePath,
+            encoding: 'utf-8',
+            timeout: 10000,
+        }).trim();
+        if (!currentBranch || currentBranch === 'main' || currentBranch === 'master') {
+            return {
+                field: 'branch_pushed',
+                action: 'skipped — on main/master branch',
+                success: false,
+                detail: 'Cannot push from main branch',
+            };
+        }
+        execSync(`git push -u origin ${currentBranch}`, {
+            cwd: worktreePath,
+            encoding: 'utf-8',
+            timeout: 60000,
+        });
+        return {
+            field: 'branch_pushed',
+            action: 'auto-pushed branch to remote',
+            success: true,
+            detail: currentBranch,
+        };
+    }
+    catch (error) {
+        return {
+            field: 'branch_pushed',
+            action: 'failed to push branch',
+            success: false,
+            detail: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+function backstopCreatePR(agent, options) {
+    const worktreePath = agent.worktreePath;
+    if (!worktreePath) {
+        return {
+            field: 'pr_url',
+            action: 'skipped — no worktree path',
+            success: false,
+        };
+    }
+    try {
+        const currentBranch = execSync('git branch --show-current', {
+            cwd: worktreePath,
+            encoding: 'utf-8',
+            timeout: 10000,
+        }).trim();
+        // Check if PR already exists for this branch (might have been missed during output parsing)
+        try {
+            const existingPr = execSync(`gh pr list --head "${currentBranch}" --json url --limit 1`, {
+                cwd: worktreePath,
+                encoding: 'utf-8',
+                timeout: 15000,
+            }).trim();
+            const prs = JSON.parse(existingPr);
+            if (prs.length > 0 && prs[0].url) {
+                return {
+                    field: 'pr_url',
+                    action: 'found existing PR (missed during session)',
+                    success: true,
+                    detail: prs[0].url,
+                };
+            }
+        }
+        catch {
+            // PR check failed — proceed with creation
+        }
+        // Build PR title and body
+        const identifier = agent.identifier;
+        const title = options?.prTitleTemplate
+            ? options.prTitleTemplate.replace('{identifier}', identifier)
+            : `feat: ${identifier} (auto-recovered by backstop)`;
+        const body = options?.prBodyTemplate
+            ? options.prBodyTemplate.replace('{identifier}', identifier)
+            : [
+                `## Summary`,
+                ``,
+                `Auto-created by the session backstop for ${identifier}.`,
+                `The agent completed work but did not create a PR.`,
+                ``,
+                `> This PR was created automatically by the orchestrator backstop to prevent work loss.`,
+                `> Please review carefully before merging.`,
+            ].join('\n');
+        const prOutput = execSync(`gh pr create --title "${title.replace(/"/g, '\\"')}" --body "${body.replace(/"/g, '\\"')}"`, {
+            cwd: worktreePath,
+            encoding: 'utf-8',
+            timeout: 30000,
+        }).trim();
+        // gh pr create outputs the PR URL
+        const prUrlMatch = prOutput.match(/https:\/\/github\.com\/[^\s]+\/pull\/\d+/);
+        const prUrl = prUrlMatch ? prUrlMatch[0] : prOutput;
+        return {
+            field: 'pr_url',
+            action: 'auto-created PR via backstop',
+            success: true,
+            detail: prUrl,
+        };
+    }
+    catch (error) {
+        return {
+            field: 'pr_url',
+            action: 'failed to create PR',
+            success: false,
+            detail: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+// ---------------------------------------------------------------------------
+// Diagnostic formatting
+// ---------------------------------------------------------------------------
+/**
+ * Format a backstop result into a diagnostic comment for the issue tracker.
+ */
+export function formatBackstopComment(result) {
+    // Nothing to report if contract was satisfied or no contract exists
+    if (!result.contract || result.backstop.fullyRecovered) {
+        // If backstop took actions to recover, report those
+        if (result.backstop.actions.length > 0) {
+            const lines = [
+                `**Session backstop recovered missing outputs for ${result.contract?.workType ?? 'unknown'} work.**`,
+                '',
+                'Actions taken:',
+                ...result.backstop.actions.map(a => `- ${a.field}: ${a.action}${a.success ? ' ✓' : ' ✗'}${a.detail ? ` (${a.detail})` : ''}`),
+            ];
+            return lines.join('\n');
+        }
+        return null;
+    }
+    // Contract not satisfied — build diagnostic
+    const lines = [
+        `⚠️ **Session completion check failed for ${result.contract.workType} work.**`,
+        '',
+    ];
+    if (result.backstop.actions.length > 0) {
+        lines.push('**Backstop actions attempted:**');
+        for (const action of result.backstop.actions) {
+            lines.push(`- ${action.field}: ${action.action}${action.success ? ' ✓' : ' ✗'}`);
+            if (action.detail && !action.success) {
+                lines.push(`  > ${action.detail}`);
+            }
+        }
+        lines.push('');
+    }
+    if (result.backstop.remainingGaps.length > 0) {
+        lines.push('**Still missing (requires manual action or re-trigger):**');
+        for (const gap of result.backstop.remainingGaps) {
+            const field = result.contract.required.find(f => f.type === gap);
+            lines.push(`- ${field?.label ?? gap}`);
+        }
+        lines.push('');
+        lines.push('**Issue status was NOT updated automatically** to prevent incomplete work from advancing.');
+    }
+    return lines.join('\n');
+}

package/dist/src/orchestrator/session-backstop.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=session-backstop.test.d.ts.map

package/dist/src/orchestrator/session-backstop.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-backstop.test.d.ts","sourceRoot":"","sources":["../../../src/orchestrator/session-backstop.test.ts"],"names":[],"mappings":""}

package/dist/src/orchestrator/session-backstop.test.js

@@ -0,0 +1,245 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { collectSessionOutputs, runBackstop, formatBackstopComment } from './session-backstop.js';
+// Mock execSync to avoid actual git/gh commands
+vi.mock('node:child_process', () => ({
+    execSync: vi.fn(),
+}));
+import { execSync } from 'node:child_process';
+const mockExecSync = vi.mocked(execSync);
+function createMockAgent(overrides) {
+    return {
+        issueId: 'issue-123',
+        identifier: 'SUP-123',
+        status: 'completed',
+        startedAt: new Date(),
+        completedAt: new Date(),
+        pid: 1234,
+        lastActivityAt: new Date(),
+        ...overrides,
+    };
+}
+function createSessionContext(overrides) {
+    return {
+        agent: createMockAgent(),
+        commentPosted: false,
+        issueUpdated: false,
+        subIssuesCreated: false,
+        ...overrides,
+    };
+}
+beforeEach(() => {
+    mockExecSync.mockReset();
+});
+describe('collectSessionOutputs', () => {
+    it('collects basic outputs from agent process', () => {
+        const ctx = createSessionContext({
+            agent: createMockAgent({
+                pullRequestUrl: 'https://github.com/org/repo/pull/42',
+                workResult: 'passed',
+            }),
+            commentPosted: true,
+            issueUpdated: true,
+        });
+        const outputs = collectSessionOutputs(ctx);
+        expect(outputs.prUrl).toBe('https://github.com/org/repo/pull/42');
+        expect(outputs.workResult).toBe('passed');
+        expect(outputs.commentPosted).toBe(true);
+        expect(outputs.issueUpdated).toBe(true);
+    });
+    it('inspects git state for worktree-based agents', () => {
+        // Mock git commands for commit and branch checks
+        mockExecSync
+            .mockReturnValueOnce('feat/sup-123\n') // git branch --show-current
+            .mockReturnValueOnce('3\n') // git rev-list --count main..HEAD
+            .mockReturnValueOnce('feat/sup-123\n') // git branch --show-current (isBranchPushed)
+            .mockReturnValueOnce('abc123 refs/heads/feat/sup-123\n') // git ls-remote
+            .mockReturnValueOnce('origin/feat/sup-123\n') // git rev-parse @{u}
+            .mockReturnValueOnce('0\n'); // git rev-list --count @{u}..HEAD
+        const ctx = createSessionContext({
+            agent: createMockAgent({ worktreePath: '/tmp/worktree' }),
+        });
+        const outputs = collectSessionOutputs(ctx);
+        expect(outputs.commitsPresent).toBe(true);
+        expect(outputs.branchPushed).toBe(true);
+    });
+    it('defaults to unknown work result when not set', () => {
+        const ctx = createSessionContext();
+        const outputs = collectSessionOutputs(ctx);
+        expect(outputs.workResult).toBe('unknown');
+    });
+});
+describe('runBackstop', () => {
+    it('returns no-op for work types without contracts', () => {
+        // Use a work type cast that has no contract
+        const ctx = createSessionContext({
+            agent: createMockAgent({ workType: 'unknown-type' }),
+        });
+        const result = runBackstop(ctx);
+        expect(result.contract).toBeNull();
+        expect(result.backstop.fullyRecovered).toBe(true);
+        expect(result.backstop.actions).toHaveLength(0);
+    });
+    it('returns satisfied for development with all outputs present', () => {
+        // Mock git: commits ahead of main, branch pushed
+        mockExecSync
+            .mockReturnValueOnce('feat/sup-123\n') // branch
+            .mockReturnValueOnce('2\n') // rev-list count
+            .mockReturnValueOnce('feat/sup-123\n') // branch (isBranchPushed)
+            .mockReturnValueOnce('abc refs/heads/feat/sup-123\n') // ls-remote
+            .mockReturnValueOnce('origin/feat/sup-123\n') // @{u}
+            .mockReturnValueOnce('0\n'); // unpushed count
+        const ctx = createSessionContext({
+            agent: createMockAgent({
+                workType: 'development',
+                worktreePath: '/tmp/worktree',
+                pullRequestUrl: 'https://github.com/org/repo/pull/42',
+            }),
+        });
+        const result = runBackstop(ctx);
+        expect(result.validation.satisfied).toBe(true);
+        expect(result.backstop.actions).toHaveLength(0);
+    });
+    it('auto-pushes branch when commits exist but branch not pushed', () => {
+        // collectSessionOutputs calls:
+        //   hasCommitsAheadOfMain: git branch, git rev-list
+        //   isBranchPushed: git branch, git ls-remote (empty = not pushed)
+        // backstopPushBranch calls:
+        //   git branch, git push
+        // backstopCreatePR calls:
+        //   git branch, gh pr list, gh pr create
+        // (re-validation uses mutated outputs object, no git calls)
+        mockExecSync
+            // --- collectSessionOutputs ---
+            .mockReturnValueOnce('feat/sup-123\n') // hasCommits: git branch
+            .mockReturnValueOnce('2\n') // hasCommits: git rev-list
+            .mockReturnValueOnce('feat/sup-123\n') // isBranchPushed: git branch
+            .mockReturnValueOnce('') // isBranchPushed: ls-remote (empty = not pushed)
+            // --- backstopPushBranch ---
+            .mockReturnValueOnce('feat/sup-123\n') // git branch
+            .mockReturnValueOnce('') // git push -u origin
+            // --- backstopCreatePR ---
+            .mockReturnValueOnce('feat/sup-123\n') // git branch
+            .mockReturnValueOnce('[]') // gh pr list (empty)
+            .mockReturnValueOnce('https://github.com/org/repo/pull/99\n'); // gh pr create
+        const ctx = createSessionContext({
+            agent: createMockAgent({
+                workType: 'development',
+                worktreePath: '/tmp/worktree',
+                // No PR URL — agent didn't create one
+            }),
+        });
+        const result = runBackstop(ctx);
+        const pushAction = result.backstop.actions.find(a => a.field === 'branch_pushed');
+        expect(pushAction).toBeDefined();
+        expect(pushAction.success).toBe(true);
+        expect(pushAction.action).toContain('auto-pushed');
+    });
+    it('skips backstop actions in dry-run mode', () => {
+        // Mock git: commits present, branch not pushed
+        mockExecSync
+            .mockReturnValueOnce('feat/sup-123\n') // branch
+            .mockReturnValueOnce('2\n') // count
+            .mockReturnValueOnce('feat/sup-123\n') // branch (isBranchPushed)
+            .mockReturnValueOnce('\n'); // ls-remote empty
+        const ctx = createSessionContext({
+            agent: createMockAgent({
+                workType: 'development',
+                worktreePath: '/tmp/worktree',
+                pullRequestUrl: 'https://github.com/org/repo/pull/42',
+            }),
+        });
+        const result = runBackstop(ctx, { dryRun: true });
+        const pushAction = result.backstop.actions.find(a => a.field === 'branch_pushed');
+        expect(pushAction).toBeDefined();
+        expect(pushAction.success).toBe(false);
+        expect(pushAction.detail).toBe('dry-run');
+    });
+    it('reports satisfied for QA with pass result and comment', () => {
+        const ctx = createSessionContext({
+            agent: createMockAgent({ workType: 'qa', workResult: 'passed' }),
+            commentPosted: true,
+        });
+        const result = runBackstop(ctx);
+        expect(result.validation.satisfied).toBe(true);
+    });
+    it('reports unsatisfied for QA with unknown work result', () => {
+        const ctx = createSessionContext({
+            agent: createMockAgent({ workType: 'qa' }),
+            commentPosted: true,
+        });
+        const result = runBackstop(ctx);
+        expect(result.validation.satisfied).toBe(false);
+        expect(result.backstop.remainingGaps).toContain('work_result');
+    });
+    it('reports satisfied for refinement with comment posted', () => {
+        const ctx = createSessionContext({
+            agent: createMockAgent({ workType: 'refinement' }),
+            commentPosted: true,
+        });
+        const result = runBackstop(ctx);
+        expect(result.validation.satisfied).toBe(true);
+    });
+    it('reports unsatisfied for refinement without comment', () => {
+        const ctx = createSessionContext({
+            agent: createMockAgent({ workType: 'refinement' }),
+            commentPosted: false,
+        });
+        const result = runBackstop(ctx);
+        expect(result.validation.satisfied).toBe(false);
+        expect(result.backstop.remainingGaps).toContain('comment_posted');
+    });
+    it('reports satisfied for backlog-creation with sub-issues', () => {
+        const ctx = createSessionContext({
+            agent: createMockAgent({ workType: 'backlog-creation' }),
+            subIssuesCreated: true,
+        });
+        const result = runBackstop(ctx);
+        expect(result.validation.satisfied).toBe(true);
+    });
+});
+describe('formatBackstopComment', () => {
+    it('returns null when contract satisfied with no actions', () => {
+        const ctx = createSessionContext({
+            agent: createMockAgent({ workType: 'qa', workResult: 'passed' }),
+            commentPosted: true,
+        });
+        const result = runBackstop(ctx);
+        const comment = formatBackstopComment(result);
+        expect(comment).toBeNull();
+    });
+    it('returns recovery summary when backstop took actions', () => {
+        // Mock: commits present, branch not pushed, push succeeds
+        mockExecSync
+            .mockReturnValueOnce('feat/sup-123\n')
+            .mockReturnValueOnce('2\n')
+            .mockReturnValueOnce('feat/sup-123\n')
+            .mockReturnValueOnce('\n') // not pushed
+            .mockReturnValueOnce('feat/sup-123\n') // backstop push branch
+            .mockReturnValueOnce('') // push succeeds
+            // Now PR creation attempt
+            .mockReturnValueOnce('feat/sup-123\n') // branch for PR
+            .mockReturnValueOnce('[]\n') // no existing PR
+            .mockReturnValueOnce('https://github.com/org/repo/pull/99\n'); // gh pr create
+        const ctx = createSessionContext({
+            agent: createMockAgent({
+                workType: 'development',
+                worktreePath: '/tmp/worktree',
+            }),
+        });
+        const result = runBackstop(ctx);
+        const comment = formatBackstopComment(result);
+        expect(comment).toBeDefined();
+        expect(comment).toContain('backstop');
+    });
+    it('includes remaining gaps when not fully recovered', () => {
+        const ctx = createSessionContext({
+            agent: createMockAgent({ workType: 'qa' }),
+            commentPosted: false,
+        });
+        const result = runBackstop(ctx);
+        const comment = formatBackstopComment(result);
+        expect(comment).toBeDefined();
+        expect(comment).toContain('Still missing');
+        expect(comment).toContain('NOT updated automatically');
+    });
+});

package/dist/src/orchestrator/worktree-checks.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=worktree-checks.test.d.ts.map

package/dist/src/orchestrator/worktree-checks.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worktree-checks.test.d.ts","sourceRoot":"","sources":["../../../src/orchestrator/worktree-checks.test.ts"],"names":[],"mappings":""}