swarm-orchestrator 7.0.0-alpha.0

package/dist/src/orchestrator/wave-scheduler-loop.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runWaveLoop = runWaveLoop;
+const async_meta_analysis_1 = require("./async-meta-analysis");
+const defaults_1 = require("../defaults");
+const logger_1 = require("../logger");
+const work_stealing_queue_1 = require("../scheduling/work-stealing-queue");
+const fatal_run_error_1 = require("./fatal-run-error");
+const logger = (0, logger_1.getLogger)('orchestrator');
+/**
+ * Run the greedy as-soon-as-ready scheduler loop. The custom fleet-wave executor was
+ * removed for v7. Native `/fleet` pass-through remains available per step through
+ * `useInnerFleet`.
+ *
+ * @param host - Orchestrator surface.
+ * @param _plan - Initial plan, retained for API compatibility. The loop reads `context.plan`.
+ * @param agents - Available agent map.
+ * @param context - Mutable execution context.
+ * @param options - Scheduler options.
+ */
+async function runWaveLoop(host, _plan, agents, context, options) {
+    const completed = new Set();
+    const scheduler = new work_stealing_queue_1.WorkStealingQueue(context.plan, {
+        maxWorkers: context.executionQueue?.getStats().maxConcurrency ?? 1,
+    });
+    const runningPromises = new Map();
+    let dispatchCounter = 0;
+    if (options?.lean && context.knowledgeBase) {
+        for (const step of context.plan.steps) {
+            const matches = context.knowledgeBase.findSimilarTasks(step.task);
+            if (matches.length > 0) {
+                const ref = matches[0];
+                const commitRef = ref.evidence[0] || 'unknown';
+                step.task += `\nReference: similar task completed in session ${ref.id}, commit ${commitRef}.`;
+                context.leanSavedRequests = (context.leanSavedRequests || 0) + 1;
+                logger.info(`  [lean] Step ${step.stepNumber}: found similar pattern "${ref.insight.slice(0, 50)}"`);
+            }
+        }
+    }
+    const pendingMerge = [];
+    const onStepComplete = async (stepNumber) => {
+        scheduler.markCompleted(stepNumber);
+        completed.add(stepNumber);
+        context.adaptiveConcurrency?.recordSuccess();
+        const result = context.results.find((entry) => entry.stepNumber === stepNumber);
+        if (result && result.branchName && result.status === 'completed') {
+            pendingMerge.push(result);
+        }
+        if (scheduler.stats().running === 0 || pendingMerge.length >= 3) {
+            if (pendingMerge.length > 0) {
+                context.contextBroker.forceReleaseStaleLocks();
+                await host.mergeWaveBranches(pendingMerge, context, options);
+                pendingMerge.length = 0;
+            }
+        }
+        if (context.metaAnalyzer && context.knowledgeBase) {
+            setImmediate(() => {
+                (0, async_meta_analysis_1.runAsyncMetaAnalysis)(context, context.plan, context.runDir, Array.from(completed));
+            });
+        }
+        options?.onProgress?.(context, `step-done:${stepNumber}`);
+    };
+    // Set when any in-flight step throws FatalRunError. Causes the loop to
+    // stop dispatching new work and exit as soon as running steps drain.
+    // Re-thrown by runWaveLoop after the drain so swarm-orchestrator's
+    // top-level handler can record the abort and skip the post-run pipeline.
+    let fatalRunError;
+    const onStepFailed = (stepNumber, errorMsg, err) => {
+        scheduler.markFailed(stepNumber);
+        if (err && (0, fatal_run_error_1.isFatalRunError)(err) && !fatalRunError) {
+            fatalRunError = err;
+        }
+        const isRateLimit = /rate limit|quota|429|throttle/i.test(errorMsg);
+        context.adaptiveConcurrency?.recordFailure(isRateLimit ? 'rate_limit' : 'error');
+        const newLimit = context.adaptiveConcurrency?.getCurrentLimit() || 3;
+        context.executionQueue?.setMaxConcurrency(newLimit);
+        scheduler.setMaxWorkers(newLimit);
+        options?.onProgress?.(context, `step-failed:${stepNumber}`);
+    };
+    while (scheduler.hasPendingWork()) {
+        if (host.pauseController.isPauseRequested()) {
+            logger.info('\n⏸️  Pause requested. Waiting for resume...');
+            await host.pauseController.waitForResume();
+            logger.info('\n▶️  Resuming execution...');
+        }
+        if (fatalRunError) {
+            // A fatal account-level error was raised by an in-flight step. Drain
+            // anything still running, then exit — dispatching further steps would
+            // hit the same wall and waste the per-instance budget.
+            break;
+        }
+        scheduler.syncPlan(context.plan);
+        const ready = scheduler.nextDispatches();
+        if (ready.length === 0 && scheduler.isBlocked()) {
+            const blocked = scheduler.blockedSteps();
+            logger.error(`\n❌ ${blocked.length} step(s) blocked by failed dependencies: ${blocked.join(', ')}`);
+            // Mark each blocked step as failed AND emit step-completed via the
+            // broker so any later replan step that depends on this number
+            // resolves its waitForDependencies immediately instead of timing out
+            // after DEFAULT_DEPENDENCY_WAIT_MS (10 min). Without this, every
+            // failed top-level step costs ~10 minutes per replan attempt.
+            const ts = new Date().toISOString();
+            for (const stepNumber of blocked) {
+                scheduler.markFailed(stepNumber);
+                const result = context.results.find((r) => r.stepNumber === stepNumber);
+                if (result && result.status === 'pending') {
+                    result.status = 'failed';
+                    result.error = 'blocked by failed dependencies';
+                    result.endTime = ts;
+                }
+                const stepDef = context.plan.steps.find((s) => s.stepNumber === stepNumber);
+                context.contextBroker.addStepContext({
+                    stepNumber,
+                    agentName: stepDef?.agentName ?? result?.agentName ?? 'unknown',
+                    timestamp: ts,
+                    data: {
+                        filesChanged: [],
+                        outputsSummary: 'step blocked by failed dependencies',
+                        branchName: result?.branchName ?? '',
+                        commitShas: [],
+                        verificationPassed: false,
+                    },
+                });
+            }
+            break;
+        }
+        if (ready.length > 0) {
+            dispatchCounter++;
+            context.metricsCollector?.startWave(dispatchCounter);
+            options?.onProgress?.(context, `wave-start:${dispatchCounter}`);
+            const stats = scheduler.stats();
+            const stepsLabel = ready.length === 1 ? `step ${ready[0]}` : `steps ${ready.join(', ')}`;
+            const modeLabel = stats.parallelEnabled ? 'parallel' : 'sequential';
+            // Wave header is presenter-owned. Suppress the line for single-step,
+            // single-wave runs where it adds noise without information.
+            logger.debug(`wave ${dispatchCounter}: ${stepsLabel} (${modeLabel})`);
+            const totalWaves = context.totalWaves ?? 0;
+            if (totalWaves > 1 || ready.length > 1) {
+                const presenter = require('../presenter');
+                const p = presenter.getPresenter();
+                p.print(`  ${p.dim(`wave ${dispatchCounter}`)}  ${stepsLabel} ${p.dim(p.glyph('sep'))} ${modeLabel}`);
+            }
+            for (const stepNumber of ready) {
+                const step = context.plan.steps.find((candidate) => candidate.stepNumber === stepNumber);
+                if (!step) {
+                    throw new Error(`Step ${stepNumber} disappeared from the active plan; rerun planning before scheduling`);
+                }
+                const agent = host.resolveAgent(agents, step.agentName);
+                if (!agent) {
+                    throw new Error(`Agent ${step.agentName} not found for step ${stepNumber}`);
+                }
+                scheduler.markRunning(stepNumber);
+                const promise = context.executionQueue
+                    .enqueue(`step-${stepNumber}`, () => host.executeStepInSwarm(step, agent, context, options), {
+                    priority: 100 - stepNumber,
+                    maxRetries: options?.maxRetries ?? 3,
+                    metadata: {
+                        stepNumber: step.stepNumber,
+                        agentName: agent.name,
+                        wave: dispatchCounter,
+                    },
+                })
+                    .then(() => onStepComplete(stepNumber), (err) => onStepFailed(stepNumber, err.message, err))
+                    .finally(() => {
+                    runningPromises.delete(stepNumber);
+                });
+                runningPromises.set(stepNumber, promise);
+            }
+            context.queueStats = context.executionQueue.getStats();
+            options?.onProgress?.(context, `wave-done:${dispatchCounter}`);
+            if (runningPromises.size > 0) {
+                await Promise.race(runningPromises.values());
+            }
+        }
+        else {
+            await new Promise((resolve) => {
+                const handler = () => {
+                    context.contextBroker.removeListener('step-completed', handler);
+                    resolve();
+                };
+                context.contextBroker.once('step-completed', handler);
+                setTimeout(() => {
+                    context.contextBroker.removeListener('step-completed', handler);
+                    resolve();
+                }, defaults_1.DEFAULT_HEARTBEAT_INTERVAL_MS);
+            });
+        }
+    }
+    if (runningPromises.size > 0) {
+        await Promise.allSettled(runningPromises.values());
+    }
+    context.totalWaves = dispatchCounter;
+    if (pendingMerge.length > 0) {
+        context.contextBroker.forceReleaseStaleLocks();
+        await host.mergeWaveBranches(pendingMerge, context, options);
+        pendingMerge.length = 0;
+    }
+    if (fatalRunError) {
+        // Re-throw after the in-flight drain and the merge of any successful
+        // pre-fatal work, so swarm-orchestrator's top-level handler sees a
+        // FatalRunError rather than a generic step failure.
+        throw fatalRunError;
+    }
+}

package/dist/src/owasp-mapper.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OwaspMapper = void 0;
+const riskAssessors = [
+    // ASI-01: Agent Goal Hijack
+    (_results, meta) => ({
+        asiId: 'ASI-01',
+        riskName: 'Agent Goal Hijack',
+        status: meta.strictIsolation ? 'mitigated' : 'partial',
+        evidence: meta.strictIsolation
+            ? ['Strict isolation enabled', 'Bounded worker and reviewer roles with refusal rules']
+            : ['Worker and reviewer roles bounded by prompts; strict isolation not enabled'],
+        rationale: meta.strictIsolation
+            ? 'Strict isolation and bounded role prompts reduce goal-hijack blast radius.'
+            : 'Role prompts bound agent scope, but strict isolation was not enabled for this run.'
+    }),
+    // ASI-02: Tool Misuse
+    (_results, meta) => ({
+        asiId: 'ASI-02',
+        riskName: 'Tool Misuse',
+        status: meta.strictIsolation ? 'mitigated' : 'partial',
+        evidence: meta.strictIsolation
+            ? ['Strict isolation enabled', 'Adapter interface restricts CLI flags', 'Cross-step context sharing blocked']
+            : ['Adapter interface restricts CLI flags', 'Strict isolation not enabled; cross-step context may be shared'],
+        rationale: meta.strictIsolation
+            ? 'Strict isolation limits each agent to its own step context. Adapter interface restricts available CLI flags.'
+            : 'Adapter interface restricts CLI flags, but strict isolation was not enabled. Agents may share cross-step context.'
+    }),
+    // ASI-03: Privilege Escalation (always mitigated; structural)
+    () => ({
+        asiId: 'ASI-03',
+        riskName: 'Privilege Escalation',
+        status: 'mitigated',
+        evidence: ['Each agent runs in its own git worktree and branch', 'No shared filesystem state between agents'],
+        rationale: 'Branch isolation is structural. Each agent operates in a dedicated worktree with no shared filesystem state.'
+    }),
+    // ASI-04: Data Leakage (not applicable)
+    () => ({
+        asiId: 'ASI-04',
+        riskName: 'Data Leakage',
+        status: 'not_applicable',
+        evidence: [],
+        rationale: 'Agents are stateless subprocesses on local branches with no external data access.'
+    }),
+    // ASI-05: Uncontrolled Code Execution
+    (_results, meta) => {
+        const allPassedClean = meta.repairedSteps === 0 && meta.failedSteps === 0 && meta.totalSteps > 0;
+        return {
+            asiId: 'ASI-05',
+            riskName: 'Uncontrolled Code Execution',
+            status: allPassedClean ? 'mitigated' : 'partial',
+            evidence: allPassedClean
+                ? [
+                    `All ${meta.passedSteps} steps passed verification (build, test, git diff)`,
+                    'No unverified merges occurred'
+                ]
+                : [
+                    `${meta.repairedSteps} step(s) required repair before passing`,
+                    `${meta.failedSteps} step(s) failed verification`,
+                    'Outcome verification gates blocked unverified merges'
+                ],
+            rationale: allPassedClean
+                ? 'All steps passed outcome verification gates (build, test, git diff) on first attempt. No unverified code was merged.'
+                : 'Outcome verification gates are in place, but some steps required repair or failed. Verification prevented uncontrolled merges.'
+        };
+    },
+    // ASI-06: Knowledge Poisoning (not applicable)
+    () => ({
+        asiId: 'ASI-06',
+        riskName: 'Knowledge Poisoning',
+        status: 'not_applicable',
+        evidence: [],
+        rationale: 'No persistent memory or RAG pipeline in agent sessions. Agents are stateless subprocesses.'
+    }),
+    // ASI-07: Insecure Communication (not applicable)
+    () => ({
+        asiId: 'ASI-07',
+        riskName: 'Insecure Communication',
+        status: 'not_applicable',
+        evidence: [],
+        rationale: 'No inter-agent networking. Agents are isolated subprocesses with no direct communication channels.'
+    }),
+    // ASI-08: Cascading Failures
+    (_results, meta) => ({
+        asiId: 'ASI-08',
+        riskName: 'Cascading Failures',
+        status: meta.retriesExhausted === 0 ? 'mitigated' : 'partial',
+        evidence: meta.retriesExhausted === 0
+            ? [
+                'Greedy scheduler with adaptive concurrency',
+                'Failure classification in RepairAgent',
+                'No steps exhausted retry limits'
+            ]
+            : [
+                'Greedy scheduler with adaptive concurrency',
+                `${meta.retriesExhausted} step(s) exhausted retry limits`,
+                'Max retry limits prevented unbounded cascading'
+            ],
+        rationale: meta.retriesExhausted === 0
+            ? 'Adaptive concurrency and failure classification contained all failures within retry limits.'
+            : `${meta.retriesExhausted} step(s) exhausted retries. Max retry limits prevented unbounded cascading, but failures did propagate.`
+    }),
+    // ASI-09: Supply Chain (not applicable)
+    () => ({
+        asiId: 'ASI-09',
+        riskName: 'Supply Chain',
+        status: 'not_applicable',
+        evidence: [],
+        rationale: 'Agents are first-party CLI tools invoked as subprocesses. No third-party plugins or agent marketplace in use.'
+    }),
+    // ASI-10: Rogue Agents
+    (_results, meta) => {
+        const fullyVerified = meta.failedSteps === 0;
+        return {
+            asiId: 'ASI-10',
+            riskName: 'Rogue Agents',
+            status: fullyVerified ? 'mitigated' : 'partial',
+            evidence: fullyVerified
+                ? [
+                    'Transcript analysis as secondary verification signal',
+                    'All steps passed outcome-based verification',
+                    'Max retry limits enforced'
+                ]
+                : [
+                    'Transcript analysis as secondary signal only',
+                    `${meta.failedSteps} step(s) failed verification`,
+                    'Outcome checks gated merges'
+                ],
+            rationale: fullyVerified
+                ? 'Outcome verification and transcript analysis completed successfully for all steps.'
+                : 'Outcome checks served as the primary gate against rogue behavior.'
+        };
+    }
+];
+class OwaspMapper {
+    map(verificationResults, executionMeta) {
+        const risks = riskAssessors.map(assess => assess(verificationResults, executionMeta));
+        const notApplicableRisks = risks.filter(r => r.status === 'not_applicable').length;
+        const mitigatedRisks = risks.filter(r => r.status === 'mitigated').length;
+        const partialRisks = risks.filter(r => r.status === 'partial').length;
+        return {
+            generatedAt: new Date().toISOString(),
+            executionId: executionMeta.executionId,
+            toolVersion: executionMeta.toolVersion,
+            applicableRisks: 10 - notApplicableRisks,
+            mitigatedRisks,
+            partialRisks,
+            notApplicableRisks,
+            risks
+        };
+    }
+}
+exports.OwaspMapper = OwaspMapper;

package/dist/src/owasp-report-renderer.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OwaspReportRenderer = void 0;
+const STATUS_LABELS = {
+    mitigated: 'MITIGATED',
+    partial: 'PARTIAL',
+    not_applicable: 'NOT APPLICABLE'
+};
+class OwaspReportRenderer {
+    static toMarkdown(report) {
+        const lines = [
+            '# OWASP ASI Compliance Report',
+            '',
+            `Run: ${report.executionId} | Tool: swarm-orchestrator v${report.toolVersion} | Date: ${report.generatedAt}`,
+            '',
+            '## Summary',
+            '',
+            `Applicable risks: ${report.applicableRisks}/10`,
+            `Mitigated: ${report.mitigatedRisks} | Partial: ${report.partialRisks} | Not applicable: ${report.notApplicableRisks}`,
+            '',
+            '## Risk Assessment',
+            ''
+        ];
+        for (const risk of report.risks) {
+            lines.push(`### ${risk.asiId}: ${risk.riskName}`);
+            lines.push(`Status: ${STATUS_LABELS[risk.status]}`);
+            if (risk.evidence.length > 0) {
+                lines.push(`Evidence: ${risk.evidence.join(', ')}`);
+            }
+            lines.push(`Rationale: ${risk.rationale}`);
+            lines.push('');
+        }
+        return lines.join('\n');
+    }
+    static toJson(report) {
+        return JSON.stringify(report, null, 2);
+    }
+}
+exports.OwaspReportRenderer = OwaspReportRenderer;

package/dist/src/plan-files.js

@@ -0,0 +1,142 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.savePlanFile = savePlanFile;
+exports.loadPlanFile = loadPlanFile;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function getPlanDir() {
+    return path.join(process.cwd(), 'plans');
+}
+function ensurePlanDirectory() {
+    const planDir = getPlanDir();
+    if (!fs.existsSync(planDir)) {
+        fs.mkdirSync(planDir, { recursive: true });
+    }
+    return planDir;
+}
+function generatePlanFilename(plan) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const goalSlug = plan.goal
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '')
+        .substring(0, 50);
+    return `plan-${timestamp}-${goalSlug}.json`;
+}
+function resolvePlanPath(planRef) {
+    if (path.isAbsolute(planRef)) {
+        return planRef;
+    }
+    const looksLikePath = planRef.includes(path.sep) || planRef.startsWith('./') || planRef.startsWith('../');
+    if (looksLikePath) {
+        return path.resolve(process.cwd(), planRef);
+    }
+    // Bare filename: prefer the file in cwd if it exists, otherwise fall back
+    // to the workspace plans/ directory. This matches the help text examples
+    // (`swarm swarm plan.json`) without breaking the historical `plans/<name>`
+    // shortcut.
+    const cwdCandidate = path.resolve(process.cwd(), planRef);
+    if (fs.existsSync(cwdCandidate)) {
+        return cwdCandidate;
+    }
+    return path.join(getPlanDir(), planRef);
+}
+/**
+ * Writes an execution plan JSON file under the current workspace plans directory.
+ *
+ * @param plan - Plan to persist.
+ * @param filename - Optional filename. When omitted, a timestamped filename is generated.
+ * @returns Absolute path to the written plan file.
+ */
+function savePlanFile(plan, filename) {
+    const planDir = ensurePlanDirectory();
+    const planFilename = filename || generatePlanFilename(plan);
+    const planPath = path.join(planDir, planFilename);
+    fs.writeFileSync(planPath, JSON.stringify(plan, null, 2), 'utf8');
+    return planPath;
+}
+function isExecutionPlanShape(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const candidate = value;
+    return typeof candidate.goal === 'string' && Array.isArray(candidate.steps);
+}
+/**
+ * Loads an execution plan from an absolute path, relative path, or plans directory filename.
+ *
+ * Accepts two on-disk shapes:
+ *   - Bare ExecutionPlan: `{ goal, createdAt, steps, metadata? }` (the format
+ *     `savePlanFile` writes under `plans/`).
+ *   - Structured-output envelope: `{ goal, planFile, plan: ExecutionPlan }` (the
+ *     format `swarm plan --output json` and `swarm plan import --output json`
+ *     emit). The envelope is unwrapped to the inner plan.
+ *
+ * @param planRef - Plan filename or path.
+ * @returns Parsed execution plan.
+ * @throws Error when the file is missing, not parseable as JSON, or matches
+ *   neither the bare nor the envelope shape.
+ */
+function loadPlanFile(planRef) {
+    const planPath = resolvePlanPath(planRef);
+    if (!fs.existsSync(planPath)) {
+        const isBareName = !path.isAbsolute(planRef) &&
+            !planRef.includes(path.sep) &&
+            !planRef.startsWith('./') &&
+            !planRef.startsWith('../');
+        const hint = isBareName
+            ? ` (looked in cwd and ${getPlanDir()}); pass an explicit path like ./${planRef} or plans/${planRef} if the file lives elsewhere`
+            : '';
+        throw new Error(`Plan file not found: ${planPath}${hint}`);
+    }
+    const raw = fs.readFileSync(planPath, 'utf8');
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (err) {
+        throw new Error(`Plan file is not valid JSON: ${planPath}; check the file for syntax errors or stray prose mixed into the JSON output`, { cause: err });
+    }
+    if (isExecutionPlanShape(parsed)) {
+        return parsed;
+    }
+    if (parsed && typeof parsed === 'object' && 'plan' in parsed) {
+        const inner = parsed.plan;
+        if (isExecutionPlanShape(inner)) {
+            return inner;
+        }
+    }
+    throw new Error(`Plan file at ${planPath} does not match the expected schema; expected either a plan object with "goal" and "steps" fields, or a structured-output envelope with a "plan" field containing the same. Regenerate via \`swarm plan\` or \`swarm bootstrap\`.`);
+}