@fitlab-ai/agent-infra 0.9.3 → 0.9.5

package/dist/lib/internal/task-orchestration.js

@@ -1,7 +1,7 @@
 import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.js';
-import { activateMatchingOrchestrationDelegation, activateOrchestrationDelegation, advanceOrchestration, beginOrResumeOrchestration, completeCommitOrchestrationStage, pauseOrchestration, prepareOrchestrationDelegation, routeOrchestration, sealMatchingOrchestrationDelegation, sealOrchestrationDelegation, statusOrchestration } from '../task/orchestration.js';
+import { abortCommitIntent, activateMatchingOrchestrationDelegation, activateOrchestrationDelegation, advanceOrchestration, beginCommitIntent, beginOrResumeOrchestration, checkpointCommitIntent, completeCommitIntent, pauseOrchestration, prepareOrchestrationDelegation, recoverCommitIntent, routeOrchestration, sealMatchingOrchestrationDelegation, sealOrchestrationDelegation, startCommitAttempt, statusCommitIntent, statusOrchestration, terminateCommitAttempt } from '../task/orchestration.js';
 import { isAgentClientId } from '../agent-clients/types.js';
-const USAGE = 'Usage: agent-infra-internal task-orchestration <task-ref|auto> <begin-or-resume|route|prepare|hook-start|stage-completed|hook-stop|advance|pause|status> [options]\n';
+const USAGE = 'Usage: agent-infra-internal task-orchestration <task-ref|auto> <begin-or-resume|route|prepare|hook-start|hook-stop|advance|pause|status|commit-start|commit-begin|commit-checkpoint|commit-complete|commit-recover|commit-abort|commit-terminate|commit-status> [options]\n';
 function usageFailure(message) {
     process.stdout.write(`${JSON.stringify({
         status: 'failed', changed: false,
@@ -20,21 +20,36 @@ function taskOrchestration(args = []) {
         return;
     }
     const [taskRef, intent] = args;
-    if (!['begin-or-resume', 'route', 'prepare', 'hook-start', 'stage-completed', 'hook-stop', 'advance', 'pause', 'status'].includes(intent)) {
+    if (![
+        'begin-or-resume', 'route', 'prepare', 'hook-start', 'hook-stop', 'advance', 'pause', 'status',
+        'commit-start', 'commit-begin', 'commit-checkpoint', 'commit-complete', 'commit-recover', 'commit-abort', 'commit-terminate', 'commit-status'
+    ].includes(intent)) {
         usageFailure(`unknown intent '${intent}'`);
         return;
     }
     const values = {};
     const seen = new Set();
+    let orchestrated = false;
     for (let index = 2; index < args.length; index += 1) {
         const flag = args[index];
+        if (flag === '--orchestrated') {
+            if (seen.has(flag)) {
+                usageFailure(`duplicate option '${flag}'`);
+                return;
+            }
+            seen.add(flag);
+            orchestrated = true;
+            continue;
+        }
         if (![
             '--max-steps', '--executor-model', '--executor-reasoning-effort',
             '--reviewer-model', '--reviewer-reasoning-effort',
             '--client', '--requested-model', '--requested-reasoning-effort', '--parent-id', '--before-fingerprint',
             '--native-agent', '--child-id', '--spawn-mode', '--actual-model', '--actual-reasoning-effort',
             '--model-fallback-reason', '--reasoning-effort-fallback-reason',
-            '--exit-code', '--after-fingerprint', '--changed-paths', '--code', '--message', '--recoverable', '--agent'
+            '--exit-code', '--after-fingerprint', '--changed-paths', '--code', '--message', '--recoverable', '--agent',
+            '--baseline-head', '--token', '--kind', '--head', '--remote', '--ref', '--expected-head',
+            '--attempt', '--git-worktree-root'
         ].includes(flag)) {
             usageFailure(`unknown option '${flag}'`);
             return;
@@ -51,13 +66,153 @@ function taskOrchestration(args = []) {
         }
         values[flag] = value;
     }
+    const commitIntentFlags = {
+        'commit-start': ['--agent', '--git-worktree-root'],
+        'commit-begin': ['--agent', '--baseline-head', '--attempt', '--orchestrated', '--git-worktree-root'],
+        'commit-checkpoint': ['--token', '--kind', '--head', '--remote', '--ref', '--git-worktree-root'],
+        'commit-complete': ['--token', '--agent', '--git-worktree-root'],
+        'commit-recover': ['--agent', '--git-worktree-root'],
+        'commit-abort': ['--token', '--expected-head', '--git-worktree-root'],
+        'commit-terminate': ['--attempt', '--agent', '--code', '--git-worktree-root'],
+        'commit-status': ['--git-worktree-root']
+    };
+    if (intent in commitIntentFlags) {
+        const allowed = commitIntentFlags[intent];
+        const invalid = [...seen].find((flag) => !allowed.includes(flag));
+        if (invalid) {
+            usageFailure(`intent '${intent}' does not accept '${invalid}'`);
+            return;
+        }
+    }
+    else {
+        const commitOnly = [...seen].find((flag) => [
+            '--orchestrated', '--baseline-head', '--attempt', '--token', '--kind', '--head', '--remote', '--ref', '--expected-head'
+        ].includes(flag));
+        if (commitOnly) {
+            usageFailure(`intent '${intent}' does not accept '${commitOnly}'`);
+            return;
+        }
+    }
     const requireValues = (flags) => flags.find((flag) => values[flag] === undefined);
+    const coreOptions = values['--git-worktree-root'] === undefined
+        ? {}
+        : { gitWorktreeRoot: values['--git-worktree-root'] };
     if (values['--client'] !== undefined && !isAgentClientId(values['--client'])) {
         usageFailure(`unknown client '${values['--client']}'`);
         return;
     }
     let result;
-    if (intent === 'begin-or-resume') {
+    if (intent === 'commit-start') {
+        const missing = requireValues(['--agent']);
+        if (missing) {
+            usageFailure(`intent 'commit-start' requires '${missing}'`);
+            return;
+        }
+        const agent = normalizeAgentToken(values['--agent']);
+        if (!agent) {
+            usageFailure(`invalid --agent '${values['--agent']}': ${AGENT_USAGE_HINT}`);
+            return;
+        }
+        result = startCommitAttempt(taskRef, { agent }, coreOptions);
+    }
+    else if (intent === 'commit-begin') {
+        const missing = requireValues(['--agent', '--baseline-head', '--attempt']);
+        if (missing) {
+            usageFailure(`intent 'commit-begin' requires '${missing}'`);
+            return;
+        }
+        const agent = normalizeAgentToken(values['--agent']);
+        if (!agent) {
+            usageFailure(`invalid --agent '${values['--agent']}': ${AGENT_USAGE_HINT}`);
+            return;
+        }
+        result = beginCommitIntent(taskRef, {
+            agent, orchestrated, baselineHead: values['--baseline-head'], attempt: values['--attempt']
+        }, coreOptions);
+    }
+    else if (intent === 'commit-checkpoint') {
+        const missing = requireValues(['--token', '--kind', '--head']);
+        if (missing) {
+            usageFailure(`intent 'commit-checkpoint' requires '${missing}'`);
+            return;
+        }
+        if (!['committed', 'pushed'].includes(values['--kind'])) {
+            usageFailure('--kind must be committed or pushed');
+            return;
+        }
+        if (values['--kind'] === 'pushed') {
+            const pushedMissing = requireValues(['--remote', '--ref']);
+            if (pushedMissing) {
+                usageFailure(`pushed checkpoint requires '${pushedMissing}'`);
+                return;
+            }
+        }
+        else if (values['--remote'] !== undefined || values['--ref'] !== undefined) {
+            usageFailure('committed checkpoint does not accept --remote or --ref');
+            return;
+        }
+        result = checkpointCommitIntent(taskRef, {
+            token: values['--token'], kind: values['--kind'],
+            head: values['--head'], remote: values['--remote'], ref: values['--ref']
+        }, coreOptions);
+    }
+    else if (intent === 'commit-complete') {
+        const missing = requireValues(['--token', '--agent']);
+        if (missing) {
+            usageFailure(`intent 'commit-complete' requires '${missing}'`);
+            return;
+        }
+        const agent = normalizeAgentToken(values['--agent']);
+        if (!agent) {
+            usageFailure(`invalid --agent '${values['--agent']}': ${AGENT_USAGE_HINT}`);
+            return;
+        }
+        result = completeCommitIntent(taskRef, { token: values['--token'], agent }, coreOptions);
+    }
+    else if (intent === 'commit-recover') {
+        const missing = requireValues(['--agent']);
+        if (missing) {
+            usageFailure(`intent 'commit-recover' requires '${missing}'`);
+            return;
+        }
+        const agent = normalizeAgentToken(values['--agent']);
+        if (!agent) {
+            usageFailure(`invalid --agent '${values['--agent']}': ${AGENT_USAGE_HINT}`);
+            return;
+        }
+        result = recoverCommitIntent(taskRef, { agent }, coreOptions);
+    }
+    else if (intent === 'commit-abort') {
+        const missing = requireValues(['--token', '--expected-head']);
+        if (missing) {
+            usageFailure(`intent 'commit-abort' requires '${missing}'`);
+            return;
+        }
+        result = abortCommitIntent(taskRef, { token: values['--token'], expectedHead: values['--expected-head'] }, coreOptions);
+    }
+    else if (intent === 'commit-terminate') {
+        const missing = requireValues(['--attempt', '--agent', '--code']);
+        if (missing) {
+            usageFailure(`intent 'commit-terminate' requires '${missing}'`);
+            return;
+        }
+        const agent = normalizeAgentToken(values['--agent']);
+        if (!agent) {
+            usageFailure(`invalid --agent '${values['--agent']}': ${AGENT_USAGE_HINT}`);
+            return;
+        }
+        if (!/^[A-Z][A-Z0-9_]{2,63}$/.test(values['--code'])) {
+            usageFailure('--code must be a stable uppercase identifier');
+            return;
+        }
+        result = terminateCommitAttempt(taskRef, {
+            attempt: values['--attempt'], agent, code: values['--code']
+        }, coreOptions);
+    }
+    else if (intent === 'commit-status') {
+        result = statusCommitIntent(taskRef, coreOptions);
+    }
+    else if (intent === 'begin-or-resume') {
         const missing = requireValues(['--client']);
         if (missing) {
             usageFailure(`intent 'begin-or-resume' requires '${missing}'`);
@@ -78,6 +233,7 @@ function taskOrchestration(args = []) {
             return;
         }
         result = beginOrResumeOrchestration(taskRef, {
+            ...coreOptions,
             maxSteps,
             client: values['--client'],
             modelPolicy: hasAnyPolicy ? {
@@ -93,10 +249,10 @@ function taskOrchestration(args = []) {
         });
     }
     else if (intent === 'route') {
-        result = routeOrchestration(taskRef);
+        result = routeOrchestration(taskRef, coreOptions);
     }
     else if (intent === 'status') {
-        result = statusOrchestration(taskRef);
+        result = statusOrchestration(taskRef, coreOptions);
     }
     else if (intent === 'prepare') {
         const missing = requireValues(['--client']);
@@ -108,7 +264,7 @@ function taskOrchestration(args = []) {
             client: values['--client'],
             requestedModel: values['--requested-model'],
             requestedReasoningEffort: values['--requested-reasoning-effort']
-        });
+        }, coreOptions);
     }
     else if (intent === 'hook-start') {
         const missing = requireValues([
@@ -128,8 +284,8 @@ function taskOrchestration(args = []) {
             reasoningEffortFallbackReason: values['--reasoning-effort-fallback-reason']
         };
         result = taskRef === 'auto'
-            ? activateMatchingOrchestrationDelegation(values['--client'], event)
-            : activateOrchestrationDelegation(taskRef, event);
+            ? activateMatchingOrchestrationDelegation(values['--client'], event, coreOptions)
+            : activateOrchestrationDelegation(taskRef, event, coreOptions);
     }
     else if (intent === 'hook-stop') {
         if (taskRef === 'auto') {
@@ -140,7 +296,7 @@ function taskOrchestration(args = []) {
             }
             result = sealMatchingOrchestrationDelegation(values['--client'], {
                 nativeAgent: values['--native-agent'], childId: values['--child-id']
-            });
+            }, coreOptions);
         }
         else {
             const missing = requireValues(['--child-id', '--exit-code', '--after-fingerprint']);
@@ -157,24 +313,11 @@ function taskOrchestration(args = []) {
                 childId: values['--child-id'], exitCode,
                 afterFingerprint: values['--after-fingerprint'],
                 changedPaths: values['--changed-paths'] ? values['--changed-paths'].split(',').filter(Boolean) : []
-            });
-        }
-    }
-    else if (intent === 'stage-completed') {
-        const missing = requireValues(['--agent']);
-        if (missing) {
-            usageFailure(`intent 'stage-completed' requires '${missing}'`);
-            return;
-        }
-        const agent = normalizeAgentToken(values['--agent']);
-        if (!agent) {
-            usageFailure(`invalid --agent '${values['--agent']}': ${AGENT_USAGE_HINT}`);
-            return;
+            }, coreOptions);
         }
-        result = completeCommitOrchestrationStage(taskRef, agent);
     }
     else if (intent === 'advance') {
-        result = advanceOrchestration(taskRef);
+        result = advanceOrchestration(taskRef, coreOptions);
     }
     else {
         const missing = requireValues(['--code', '--message', '--recoverable']);
@@ -186,7 +329,7 @@ function taskOrchestration(args = []) {
             usageFailure('--recoverable must be true or false');
             return;
         }
-        result = pauseOrchestration(taskRef, values['--code'], values['--message'], values['--recoverable'] === 'true');
+        result = pauseOrchestration(taskRef, values['--code'], values['--message'], values['--recoverable'] === 'true', coreOptions);
     }
     process.stdout.write(`${JSON.stringify(result)}\n`);
     if (result.status === 'failed')

package/dist/lib/platform/github-client.js

@@ -2,6 +2,14 @@ import process from 'node:process';
 import spawn from 'cross-spawn';
 import semver from 'semver';
 const MINIMUM_GITHUB_CLI_VERSION = '2.16.0';
+const GITHUB_CLI_MAX_BUFFER = 64 * 1024 * 1024;
+const ERROR_DETAIL_LIMIT = 4096;
+function boundedFailureDetail(result) {
+    const diagnostic = `${result.stderr}\n${result.error?.message || ''}`.trim() || result.stdout.trim();
+    return diagnostic.length <= ERROR_DETAIL_LIMIT
+        ? diagnostic
+        : `${diagnostic.slice(0, ERROR_DETAIL_LIMIT)}… [truncated]`;
+}
 function defaultRunner(args, options) {
     const command = process.env.AGENT_INFRA_GH_BIN || 'gh';
     let prefix = [];
@@ -16,6 +24,7 @@ function defaultRunner(args, options) {
         encoding: 'utf8',
         env: process.env,
         input: options.input,
+        maxBuffer: GITHUB_CLI_MAX_BUFFER,
         shell: false
     });
     return {
@@ -37,7 +46,15 @@ function defaultSleep(delayMs) {
     Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, delayMs);
 }
 function classifyGitHubFailure(result) {
-    const detail = `${result.stderr}\n${result.stdout}\n${result.error?.message || ''}`.trim();
+    const errorCode = result.error && 'code' in result.error ? result.error.code : undefined;
+    if (errorCode === 'ENOBUFS') {
+        return {
+            code: 'PLATFORM_OUTPUT_TOO_LARGE',
+            message: 'GitHub CLI output exceeded the configured limit',
+            retryable: false
+        };
+    }
+    const detail = boundedFailureDetail(result);
     const lower = detail.toLowerCase();
     if (/\b401\b|bad credentials|authentication required|not logged into/.test(lower)) {
         return { code: 'AUTH_REQUIRED', message: detail || 'GitHub authentication is required', retryable: false };
@@ -54,7 +71,7 @@ function classifyGitHubFailure(result) {
     if (/\b422\b|validation failed/.test(lower)) {
         return { code: 'PLATFORM_REQUEST_INVALID', message: detail || 'GitHub rejected the request', retryable: false };
     }
-    if (result.error && 'code' in result.error && result.error.code === 'ENOENT') {
+    if (errorCode === 'ENOENT') {
         return { code: 'PLATFORM_DEPENDENCY_MISSING', message: detail || 'GitHub CLI is unavailable', retryable: false };
     }
     return { code: 'PLATFORM_REQUEST_FAILED', message: detail || 'GitHub request failed', retryable: false };

package/dist/lib/platform/pr-checks.js

@@ -85,7 +85,7 @@ registerPlatformCapabilities('github', {
     inspectRequiredChecks({ client, repository, number, cwd }) {
         const github = client || createGitHubClient();
         const inspected = github.json([
-            'pr', 'checks', String(number), '--repo', repository, '--required',
+            'pr', 'checks', String(number), '--repo', repository,
             '--json', 'name,state,bucket,link,workflow,startedAt,completedAt'
         ], { cwd });
         return inspected.ok

package/dist/lib/platform/pull-requests.js

@@ -11,6 +11,8 @@ import { inspectPlatformIssue } from './issues.js';
 import { planPullRequestMetadata } from './pull-request-metadata.js';
 import { platformResult } from './types.js';
 import { inspectCompletionArtifacts } from '../task/finalization-artifacts.js';
+import { inspectCreatePrCommitGate } from '../task/commit-finalization.js';
+import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.js';
 function result(status, taskId, issueNumber, prNumber, overrides = {}) {
     return {
         ...platformResult(status),
@@ -612,7 +614,7 @@ function resolveExternalPullRequest(taskRef, options) {
         error: null
     }), { mode: 'external', authorization: selected.source, candidates: selected.candidates, eligible: selected.eligible, selected: selected.selected });
 }
-function createPlatformPullRequest(taskRef, options) {
+function createPlatformPullRequestUnlocked(taskRef, options) {
     const base = resolvedContext(taskRef, options);
     if (!base.ok)
         return base.output;
@@ -622,6 +624,17 @@ function createPlatformPullRequest(taskRef, options) {
         });
     if (base.prNumber)
         return inspectPlatformPullRequest(taskRef, options);
+    const gate = inspectCreatePrCommitGate(base.resolved.taskDir, base.resolved.repoRoot, base.resolved.taskId);
+    if (!gate.allowed)
+        return result('blocked', base.resolved.taskId, base.issueNumber, null, {
+            platform: base.context.platform,
+            capabilities: base.context.capabilities,
+            error: {
+                code: gate.code,
+                message: `${gate.message}; action=${gate.action}`,
+                retryable: gate.action === 'rerun-commit' || gate.action === 'rerun-review-code'
+            }
+        });
     const located = locatePullRequest(base, options.head, options.base);
     if (!located.ok && located.error.code === 'PR_IDENTITY_AMBIGUOUS')
         return result('failed', base.resolved.taskId, base.issueNumber, null, {
@@ -689,6 +702,39 @@ function createPlatformPullRequest(taskRef, options) {
         operations: [{ name: created ? 'pr:create' : 'pr:reuse', status: created ? 'applied' : 'no-op', reasonCode: null }, { name: 'task:bind-pr', status: 'applied', reasonCode: null }], error: null
     });
 }
+function createPlatformPullRequest(taskRef, options) {
+    const base = resolvedContext(taskRef, options);
+    if (!base.ok)
+        return base.output;
+    if (!options.base || !options.head || !options.title.trim() || !options.body.trim()) {
+        return result('failed', base.resolved.taskId, base.issueNumber, base.prNumber, {
+            error: { code: 'PR_PAYLOAD_INVALID', message: 'base, head, title and body are required', retryable: false }
+        });
+    }
+    if (base.prNumber)
+        return inspectPlatformPullRequest(taskRef, options);
+    try {
+        return withTaskExecutionLock(base.resolved.repoRoot, base.resolved.taskId, 'platform-pr.create', () => createPlatformPullRequestUnlocked(taskRef, options));
+    }
+    catch (error) {
+        if (error instanceof TaskExecutionLockError) {
+            return result('blocked', base.resolved.taskId, base.issueNumber, null, {
+                platform: base.context.platform,
+                capabilities: base.context.capabilities,
+                error: { code: error.code, message: error.message, retryable: true }
+            });
+        }
+        return result('failed', base.resolved.taskId, base.issueNumber, null, {
+            platform: base.context.platform,
+            capabilities: base.context.capabilities,
+            error: {
+                code: 'PR_CREATE_FAILED',
+                message: error instanceof Error ? error.message : String(error),
+                retryable: false
+            }
+        });
+    }
+}
 function syncPlatformPullRequest(taskRef, options) {
     const base = resolvedContext(taskRef, options);
     if (!base.ok)

package/dist/lib/platform/releases.js

@@ -55,9 +55,17 @@ function reconcileReleaseMilestones(version, options = {}) {
     const major = Number(match[1]);
     const minor = Number(match[2]);
     const patch = Number(match[3]);
-    const ensure = [`${major}.${minor}.${patch + 1}`, `${major}.${minor}.x`];
-    if (patch === 0)
-        ensure.push(`${major}.${minor + 1}.0`, `${major}.${minor + 1}.x`);
+    const nextPatch = `${major}.${minor}.${patch + 1}`;
+    const currentLine = `${major}.${minor}.x`;
+    const ensure = [
+        { title: nextPatch, description: `Issues that we want to release in v${nextPatch}.` },
+        { title: currentLine, description: `Issues that we want to resolve in ${major}.${minor} line.` }
+    ];
+    if (patch === 0) {
+        const nextMinor = `${major}.${minor + 1}.0`;
+        const nextLine = `${major}.${minor + 1}.x`;
+        ensure.push({ title: nextMinor, description: `Issues that we want to release in v${nextMinor}.` }, { title: nextLine, description: `Issues that we want to resolve in ${major}.${minor + 1} line.` });
+    }
     const operations = [];
     const current = milestones.find((item) => item.title === version);
     if (current && current.state !== 'closed') {
@@ -66,11 +74,11 @@ function reconcileReleaseMilestones(version, options = {}) {
     }
     else
         operations.push({ name: 'close-milestone', title: version, status: 'no-op' });
-    for (const title of ensure) {
+    for (const { title, description } of ensure) {
         if (milestones.some((item) => item.title === title))
             operations.push({ name: 'ensure-milestone', title, status: 'no-op' });
         else {
-            const created = client.json(['api', '--method', 'POST', `repos/${context.platform.repository}/milestones`, '-f', `title=${title}`], { cwd: options.cwd });
+            const created = client.json(['api', '--method', 'POST', `repos/${context.platform.repository}/milestones`, '-f', `title=${title}`, '-f', `description=${description}`], { cwd: options.cwd });
             operations.push({ name: 'ensure-milestone', title, status: created.ok ? 'applied' : 'failed' });
         }
     }