@on-par/factory-cli 0.9.25-next.9 → 0.9.25

package/dist/cli/index.js

@@ -12,7 +12,7 @@ import { startupSweeps, warnQueueDiagnostics } from './queue-startup.js';
 import { proposeTriageQueue } from './triage-open-prs.js';
 import { makeQueuePreflightOps, preflightQueuedIssue, } from './queue-preflight.js';
 import { acquirePortLease, aggregateCosts, appendKpiHistoryLine, applyRepoConfig, buildPhase, checkPhase, clearProxyState, computeHealthKpis, ConstitutionLoader, createDefaultWorkSourceRegistry, createLogger, createLaneProxy, defaultFindPortListeners, describeEffectiveConfig, detectPostMergeDefects, diagnoseModels, probeDeclaredHarnesses, estimateTrailingSpend, fetchDefectSources, fetchSubscriptionUsage, formatUsageReport, getConstitutionsDir, getFactoryPaths, GITHUB_ISSUE_SOURCE, hasUnresolvedPark, InvalidWorkRequestInputError, isCommandAvailable, isProxyRunning, kpiBranchPrefixes, kpisToHistoryRecord, laneBaseUrl, laneEnv, laneHostLabel, loadFactoryConfigForRepo, loadModelsConfig, loadRepoConfig, loadRoutesConfig, joinClassifierOutcomes, mergeClassifierOutcomes, parseClassifierOutcomes, summarizeClassifierOutcomes, formatClassifierReport, mergedPrRefs, ModelRegistry, ModelRouter, parkReasonFor, parseKpiHistory, parseQueue, planPhase, readEvents, readPortLeases, readQueue, readUsage, reapOrphanProcesses, reconstructKpiEvents, recordLeasePgid, releasePortLease, renderKpiReport, renderKpiTrend, resolveDefectWindowDays, parseSizeGateMode, parseMaxSlices, SIZE_GATE_MODES, resolveEffectiveModelPins, resolveEnvironmentProxy, resolveMergePolicy, resolveSkipCI, resolveTimeouts, resolveUsageCap, resolveWatchdogPolicy, runAutoIngest, shipPhase, formatCostTotal, validateQueue, watchUsage, writeLocalRunReport, workKeyFromIssue, writeProxyState, } from '@on-par/factory-core';
-import { acquirePidFile, createCheckResumeStore, DEFAULT_GARDEN_MAX_CLUSTERS, DEFAULT_GARDEN_SINCE, capGardenClusters, clusterGarden, dedupGardenClusters, filterGardenOnlyNew, filterGardenWindow, markGardenTrackingUnknown, parseGardenDuration, readHarvestEvents, renderGardenJson, renderGardenReport, laneWorktreePath, migrateRepoConfigToYaml, readRepoConfigFile, rewriteRepoConfigFile, REPO_CONFIG_YAML_HEADER, claudeConfigDirOverride, claudeKeychainService, cleanupWorktree, createDaemonLogSink, factoryBranchIssue, factoryBranchPrefixes, createFactorydServer, createRunRuntime, createShipExecutor, createGithubQueue, createLocalSmallDryRun, createOctokitFilingClient, createOctokitGreenPrClient, createOctokitQueueClient, daemonRuntimePaths, defaultRegistryPath, ensureDir, fetchHumanEventSourcesCached, FACTORY_RUNTIME_CONFIG_KEYS, findUnmergedGreenPrs, listStatelessLaneIssues, formatGcReport, gitFetch, listMicroVms, listOrphanContainers, logCost, logEvent, planQueueMigration, pollBlockedParks, readCosts, readGithubQueueSnapshot, reapCleanShipWorktree, reapLaneWorktree, reapOrphanContainers, reapOrphanMicroVm, releaseRuntimeFiles, releaseStaleClaims, resolveBranchPrefix, resolveEffectiveConfig, resolveExperimental, resolveLocalOnly, describeDraftPrPolicy, resolveDraftPrPolicy, resolvePrClassifierPolicy, resolveReviewFloorRules, runOvernightQueue, parseRemoteSlug, setupWorktree, shellEscape, listBuiltInCheckers, sweepWorktrees, watchChecks, withFileLock, withGitLock, writePortFile, buildTriagePrompt, parseTriageCandidates, laneSlug, formatStopMarker, readStopMarker, detectClaudePlan, findSlicePlanComment, } from '@on-par/factory-core/internal';
+import { acquirePidFile, createCheckResumeStore, DEFAULT_GARDEN_MAX_CLUSTERS, DEFAULT_GARDEN_SINCE, capGardenClusters, clusterGarden, dedupGardenClusters, filterGardenOnlyNew, filterGardenWindow, markGardenTrackingUnknown, parseGardenDuration, readHarvestEvents, renderGardenJson, renderGardenReport, laneWorktreePath, migrateRepoConfigToYaml, readRepoConfigFile, rewriteRepoConfigFile, REPO_CONFIG_YAML_HEADER, claudeConfigDirOverride, claudeKeychainService, cleanupWorktree, createDaemonLogSink, factoryBranchIssue, factoryBranchPrefixes, createFactorydServer, createRunRuntime, createShipExecutor, createGithubQueue, createLocalSmallDryRun, createOctokitFilingClient, createOctokitGreenPrClient, createOctokitQueueClient, daemonRuntimePaths, defaultRegistryPath, ensureDir, fetchHumanEventSourcesCached, FACTORY_RUNTIME_CONFIG_KEYS, findUnmergedGreenPrs, listStatelessLaneIssues, formatGcReport, gitFetch, listMicroVms, listOrphanContainers, logCost, logEvent, planQueueMigration, pollBlockedParks, readCosts, readGithubQueueSnapshot, reapCleanShipWorktree, reapLaneWorktree, reapOrphanContainers, reapOrphanMicroVm, releaseRuntimeFiles, releaseStaleClaims, resolveBranchPrefix, resolveEffectiveConfig, resolveExperimental, resolveLocalOnly, describeDraftPrPolicy, resolveDraftPrPolicy, resolvePrClassifierPolicy, resolveReviewFloorRules, runOvernightQueue, parseRemoteSlug, setupWorktree, shellEscape, listBuiltInCheckers, sweepWorktrees, watchChecks, withFileLock, withGitLock, writePortFile, buildTriagePrompt, parseTriageCandidates, laneSlug, formatStopMarker, readStopMarker, detectClaudePlan, findSlicePlanComment, listBlockedBy, aliasDeprecatedSizeGateMode, } from '@on-par/factory-core/internal';
 import { CliExitError } from './errors.js';
 import { baseBranchConflict, baseBranchOrExit } from './ship-options.js';
 import { runIssueStack } from './stack-run.js';
@@ -68,7 +68,6 @@ import { selectOctokit } from './github-stub.js';
 import { createFactoryOctokit } from './octokit.js';
 import { runDraftCommand } from './draft-command.js';
 import { checkErrorExit, checkReportExit, createDeepModelRunner, runIssueCheck } from './ready-check.js';
-import { childRunSucceeded, formatChildRunSummary, runChildrenInOrder } from './run-children.js';
 import { cmdRunBrief as cmdRunBriefWith } from './run-brief.js';
 import { readRunFlagOverrides, recordDraftPrFlag } from './run-flags.js';
 import { runStalenessGuard } from './staleness.js';
@@ -360,7 +359,6 @@ setShipRuntime(() => ({
     LaneParkError,
     LaneEnvironmentPauseError,
     IssueSkippedError,
-    IssueDecomposedError,
 }));
 export { LaneEnvironmentPauseError, shipIssue };
 export function hasGitHubToken(env = process.env, tryToken) {
@@ -666,7 +664,7 @@ function branchPrefixOrExit(raw, configPath) {
 function sizeGateOrExit(raw) {
     if (raw === undefined)
         return undefined;
-    const mode = parseSizeGateMode(raw);
+    const mode = parseSizeGateMode(aliasDeprecatedSizeGateMode(raw));
     if (mode === undefined) {
         throw new CliExitError(`factory: invalid --size-gate '${raw}' — expected one of: ${SIZE_GATE_MODES.join(', ')}`, 2);
     }
@@ -1109,7 +1107,9 @@ async function cmdClassifierBacktestEntry(opts) {
     const repoConfig = configLoaders.loadRepoConfig(repoRoot);
     const effective = resolveEffectiveConfig(repoConfig);
     const router = new coreOps.ModelRouter(applyRepoConfig(configLoaders.loadModelsConfig(), repoConfig), configLoaders.loadRoutesConfig(), false, undefined, effective.allowExperimental, effective.localOnly);
-    router.setCodexFullAccessTasks?.(configLoaders.loadFactoryConfigForRepo(paths.config).sandbox.codexFullAccessTasks);
+    const sandbox = configLoaders.loadFactoryConfigForRepo(paths.config).sandbox;
+    router.setCodexFullAccessTasks?.(sandbox.codexFullAccessTasks);
+    router.setCodexSandbox?.(sandbox.codexSandbox);
     applyRouterGuards(router);
     try {
         await cmdClassifierBacktest({ ...opts, branchPrefix }, {
@@ -1360,7 +1360,9 @@ async function cmdTui(opts = {}, runTuiImpl = runTui) {
     const routesConfig = configLoaders.loadRoutesConfig();
     const effective = resolveEffectiveConfig(repoConfig);
     const router = new coreOps.ModelRouter(modelsConfig, routesConfig, false, undefined, effective.allowExperimental, effective.localOnly);
-    router.setCodexFullAccessTasks?.(configLoaders.loadFactoryConfigForRepo(paths.config).sandbox.codexFullAccessTasks);
+    const sandbox = configLoaders.loadFactoryConfigForRepo(paths.config).sandbox;
+    router.setCodexFullAccessTasks?.(sandbox.codexFullAccessTasks);
+    router.setCodexSandbox?.(sandbox.codexSandbox);
     applyRouterGuards(router);
     const effectiveConfigLines = describeEffectiveConfig({
         router,
@@ -1602,6 +1604,8 @@ async function cmdShip(issueNum, opts) {
     }, { scope: { kind: 'issue', key: workKeyFromIssue(issueNum) } });
 }
 async function cmdRunIssue(issueNum, opts) {
+    if (opts.runChildren)
+        throw new CliExitError('--run-children was removed; oversized issues stack with --stack', 2);
     if (availableAgentClis(coreOps.isCommandAvailable).length === 0) {
         throw new CliExitError(`factory: ${missingAgentCliMessage()}`, 2);
     }
@@ -1610,22 +1614,24 @@ async function cmdRunIssue(issueNum, opts) {
     if (!existsSync(paths.root)) {
         throw new CliExitError(`factory: ${notInitializedMessage()}`, 2);
     }
-    const { runChildren, sizeGate: rawSizeGate, maxSlices: rawMaxSlices, stack, ...shipOpts } = opts;
+    const { runChildren: _removed, sizeGate: rawSizeGate, maxSlices: rawMaxSlices, stack, ...shipOpts } = opts;
     const branchPrefix = branchPrefixOrExit(opts.branchPrefix, paths.config);
-    if (stack && rawSizeGate !== undefined && rawSizeGate !== 'stack') {
+    const parsedSizeGate = sizeGateOrExit(rawSizeGate);
+    if (stack && parsedSizeGate !== undefined && parsedSizeGate !== 'stack') {
         throw new CliExitError('factory: --stack is --size-gate stack — drop one of them', 2);
     }
-    const sizeGate = stack ? 'stack' : sizeGateOrExit(rawSizeGate);
+    const sizeGate = stack ? 'stack' : parsedSizeGate;
+    const explicitStack = stack === true || rawSizeGate === 'stack';
     const maxSlices = maxSlicesOrExit(rawMaxSlices);
     const baseBranch = baseBranchOrExit(opts.baseBranch);
-    const conflict = baseBranchConflict({ baseBranch, sizeGate, runChildren });
+    const conflict = baseBranchConflict({ baseBranch, sizeGate });
     if (conflict)
         throw new CliExitError(conflict, 2);
     if (sizeGate === 'stack' && opts.pr === false) {
         throw new CliExitError('factory: --stack opens a PR per slice — drop --no-pr or drop --stack', 2);
     }
-    if (opts.pr === false && ((sizeGate !== undefined && sizeGate !== 'off') || runChildren)) {
-        throw new CliExitError('factory: --no-pr runs with the size gate off — drop --size-gate/--run-children or drop --no-pr', 2);
+    if (opts.pr === false && sizeGate !== undefined && sizeGate !== 'off') {
+        throw new CliExitError('factory: --no-pr runs with the size gate off — drop --size-gate or drop --no-pr', 2);
     }
     await withRepoRunLock(paths, 'factory run-issue', async () => {
         recordDraftPrFlag(paths.runFlags, opts.draftPr);
@@ -1657,96 +1663,43 @@ async function cmdRunIssue(issueNum, opts) {
         try {
             if (sizeGate === 'stack') {
                 await runIssueStack(issueNum, baseBranch, {
+                    repo: ghRepo,
+                    list: (issue) => listBlockedBy({ octokit: getOctokit(), repo: ghRepo }, issue),
+                    shipMember: async (issue, base, onOutcome) => {
+                        const memberWork = issue === issueNum
+                            ? work
+                            : await workSources.resolve(GITHUB_ISSUE_SOURCE, { repo: ghRepo, issue });
+                        await shipIssue(issue, {
+                            ...shipOpts,
+                            branchPrefix,
+                            sizeGate,
+                            explicitStack,
+                            maxSlices,
+                            baseBranch: base,
+                            parkOverBudget: true,
+                        }, { repoRoot, ghRepo, workRequest: memberWork, onOutcome });
+                    },
                     readSlicePlan: async () => {
                         const lookup = await findSlicePlanComment({ octokit: getOctokit(), repo: ghRepo, issue: issueNum });
                         return lookup.status === 'found' ? lookup.plan : undefined;
                     },
                     ship: async (base, onOutcome) => {
-                        await shipIssue(issueNum, { ...shipOpts, branchPrefix, sizeGate, maxSlices, baseBranch: base }, { repoRoot, ghRepo, workRequest: work, onOutcome });
+                        await shipIssue(issueNum, { ...shipOpts, branchPrefix, sizeGate, explicitStack, maxSlices, baseBranch: base }, { repoRoot, ghRepo, workRequest: work, onOutcome });
                     },
                 });
                 return;
             }
-            await shipIssue(issueNum, { ...shipOpts, branchPrefix, sizeGate, maxSlices }, { repoRoot, ghRepo, workRequest: work });
+            await shipIssue(issueNum, { ...shipOpts, branchPrefix, sizeGate, explicitStack, maxSlices }, { repoRoot, ghRepo, workRequest: work });
         }
         catch (err) {
             if (err instanceof CliExitError)
                 throw err;
             if (err instanceof IssueSkippedError)
                 return;
-            if (err instanceof IssueDecomposedError && runChildren) {
-                await runDecomposedChildren(issueNum, err.childIssues, { ...shipOpts, branchPrefix, sizeGate, maxSlices }, { repoRoot, ghRepo, workSources });
-                return;
-            }
-            if (err instanceof IssueDecomposedError && !runChildren) {
-                const children = err.childIssues.map((n) => `#${n}`).join(', ');
-                throw new CliExitError(`Run failed for issue #${issueNum}: the size gate decomposed it into ${children} — no child issue was run. ` +
-                    `Re-run with \`factory run-issue ${issueNum} --run-children\` to run them.`, 1);
-            }
             throw new CliExitError(`Run failed for issue #${issueNum}: ${err.message}`, 1);
         }
     }, { scope: { kind: 'issue', key: workKeyFromIssue(issueNum) } });
 }
-/** Runs each decomposed child through the one-shot pipeline in build order, inside the caller's
- *  run lock, then prints a per-child summary. Nested decompositions expand in place and closed
- *  children are skipped. A failed or escalated child is recorded and the next one still runs;
- *  `.factory/STOP` is checked before each child starts (read only, ADR-0111). Throws CliExitError(1)
- *  unless every child is ready or skipped (#1747, #1748, #1749). */
-async function runDecomposedChildren(parent, children, opts, env) {
-    const list = children.map((n) => `#${n}`).join(', ');
-    console.log(styleText('cyan', `run-children: #${parent} decomposed into ${list} — running them in build order`));
-    const paths = getFactoryPaths(env.repoRoot);
-    const results = await runChildrenInOrder(children, async (child) => {
-        let work;
-        try {
-            work = await env.workSources.resolve(GITHUB_ISSUE_SOURCE, {
-                repo: env.ghRepo,
-                issue: child,
-            });
-        }
-        catch (err) {
-            return { issue: child, status: 'failed', detail: `could not resolve issue #${child} (${errorDetail(err)})` };
-        }
-        console.log(styleText('cyan', `one-shot: resolved ${work.id} — running the pipeline (queue untouched)`));
-        let outcome;
-        try {
-            await withRepoRunLock(paths, 'factory run-issue', () => shipIssue(child, opts, {
-                repoRoot: env.repoRoot,
-                ghRepo: env.ghRepo,
-                workRequest: work,
-                onOutcome: (o) => {
-                    outcome = o;
-                },
-            }), { scope: { kind: 'issue', key: workKeyFromIssue(child) } });
-        }
-        catch (err) {
-            if (err instanceof IssueDecomposedError) {
-                const again = err.childIssues.map((n) => `#${n}`).join(', ');
-                console.log(styleText('cyan', `run-children: #${child} decomposed into ${again} — running them in its place`));
-                return { issue: child, status: 'decomposed', children: err.childIssues };
-            }
-            if (err instanceof IssueSkippedError) {
-                return { issue: child, status: 'skipped', detail: err.message };
-            }
-            return { issue: child, status: 'failed', detail: err instanceof Error ? err.message : String(err) };
-        }
-        const done = outcome;
-        return { issue: child, status: 'ready', prNumber: done && 'prNumber' in done ? done.prNumber : undefined };
-    }, [parent], (next) => {
-        if (!existsSync(paths.stop))
-            return false;
-        logEvent(paths.events, 'stopped', next, 'STOP file present');
-        console.log(styleText('yellow', `run-children: .factory/STOP present — not starting #${next} or any later child`));
-        return true;
-    });
-    const ok = childRunSucceeded(results);
-    for (const line of formatChildRunSummary(parent, results)) {
-        console.log(ok ? styleText('green', line) : styleText('yellow', line));
-    }
-    if (!ok) {
-        throw new CliExitError(`Run failed for issue #${parent}: not every decomposed child reached ready-for-review or was skipped as closed (failed or not-run children are listed above)`, 1);
-    }
-}
 async function cmdLocalSmallDryRun(issueNum, opts) {
     const repoRoot = await getRepoRoot();
     const ghRepo = await getGitHubRepo();
@@ -1997,7 +1950,9 @@ async function cmdTriage(opts) {
     const routesConfig = configLoaders.loadRoutesConfig();
     const effective = resolveEffectiveConfig(repoConfig);
     const router = new coreOps.ModelRouter(modelsConfig, routesConfig, false, undefined, effective.allowExperimental, effective.localOnly);
-    router.setCodexFullAccessTasks?.(configLoaders.loadFactoryConfigForRepo(paths.config).sandbox.codexFullAccessTasks);
+    const sandbox = configLoaders.loadFactoryConfigForRepo(paths.config).sandbox;
+    router.setCodexFullAccessTasks?.(sandbox.codexFullAccessTasks);
+    router.setCodexSandbox?.(sandbox.codexSandbox);
     applyRouterGuards(router);
     router.skipMissingHarnessClis(coreOps.isCommandAvailable);
     router.setCostSink((entry) => logCost(paths.costs, { ...entry, issue: '-' }));
@@ -2548,7 +2503,6 @@ export function laneQueueDeps(queue, lane) {
         releaseIssue: (issue, outcome) => queue.release(issue, outcome),
         heartbeat: (issue) => queue.heartbeat(issue),
         countRemaining: async () => (await queue.list(lane)).length,
-        queueChildren: (parent, children) => queue.enqueueAfter(lane, parent, children),
     };
 }
 export { preflightQueuedIssue };
@@ -2592,16 +2546,6 @@ export class IssueSkippedError extends Error {
         this.reason = reason;
     }
 }
-/** The target issue tripped the PLAN pre-flight size gate and was decomposed into real
- *  filed sub-issues; the queue was rewritten. Not a park — the lane continues with the
- *  children in place of the oversized issue. (#823) */
-export class IssueDecomposedError extends Error {
-    childIssues;
-    constructor(message, childIssues) {
-        super(message);
-        this.childIssues = childIssues;
-    }
-}
 export function issueFromFactoryBranch(branch, prefix) {
     return factoryBranchIssue(branch, prefix) ?? undefined;
 }