openclaw-swarm-layer 0.1.0

package/dist/src/cli/swarm-review.js

@@ -0,0 +1,34 @@
+import { resolveSwarmPaths } from "../lib/paths.js";
+import { journalCompletionSummary, journalReviewEntry } from "../reporting/obsidian-journal.js";
+import { writeWorkflowReport } from "../reporting/reporter.js";
+import { applyReviewDecision } from "../review/review-gate.js";
+import { resolveStateStore } from "./context.js";
+export async function runSwarmReview(options, context) {
+    const decision = options.approve ? "approve" : options.reject ? "reject" : null;
+    if (!decision) {
+        throw new Error("Either --approve or --reject is required");
+    }
+    const stateStore = resolveStateStore(context);
+    const reportConfig = context?.config ?? stateStore.config;
+    const workflow = await stateStore.loadWorkflow(options.project);
+    const result = applyReviewDecision(workflow, options.task, decision, options.note);
+    await stateStore.saveWorkflow(options.project, result.workflow);
+    const report = await writeWorkflowReport(options.project, result.workflow, reportConfig);
+    // Obsidian journal: review log
+    const paths = resolveSwarmPaths(options.project, reportConfig);
+    await journalReviewEntry(paths, stateStore.config.obsidianJournal, options.task, decision, options.note);
+    // Obsidian journal: completion summary (when all tasks done)
+    const allDone = result.workflow.tasks.every((t) => t.status === "done" || t.status === "dead_letter");
+    if (allDone && result.workflow.tasks.length > 0) {
+        const runs = await stateStore.loadRuns(options.project);
+        await journalCompletionSummary(paths, stateStore.config.obsidianJournal, result.workflow, runs);
+    }
+    return {
+        ok: true,
+        taskId: options.task,
+        decision,
+        status: result.task.status,
+        localReportPath: report.localReportPath,
+        obsidianReportPath: report.obsidianReportPath,
+    };
+}

package/dist/src/cli/swarm-run.d.ts

@@ -0,0 +1,7 @@
+import { type SwarmCliContext } from "./context.js";
+export declare function runSwarmRun(options: {
+    project: string;
+    task?: string;
+    dryRun?: boolean;
+    runner?: "manual" | "acp" | "subagent";
+}, context?: SwarmCliContext): Promise<unknown>;

package/dist/src/cli/swarm-run.js

@@ -0,0 +1,39 @@
+import { resolveSwarmPaths } from "../lib/paths.js";
+import { journalRunEntry } from "../reporting/obsidian-journal.js";
+import { writeWorkflowReport } from "../reporting/reporter.js";
+import { createOrchestrator } from "../services/orchestrator.js";
+import { SessionStore } from "../session/session-store.js";
+import { resolveSessionAdapter, resolveStateStore, resolveSubagentAdapter } from "./context.js";
+export async function runSwarmRun(options, context) {
+    const stateStore = resolveStateStore(context);
+    const sessionStore = context?.sessionStore ?? new SessionStore(stateStore.config);
+    const sessionAdapter = resolveSessionAdapter(context);
+    const subagentAdapter = resolveSubagentAdapter(context);
+    const reportConfig = context?.config ?? stateStore.config;
+    const orchestrator = createOrchestrator({ stateStore, sessionStore, sessionAdapter, subagentAdapter });
+    const result = await orchestrator.runOnce({
+        projectRoot: options.project,
+        taskId: options.task,
+        dryRun: options.dryRun,
+        runnerOverride: options.runner,
+    });
+    if (!options.dryRun) {
+        const workflow = await stateStore.loadWorkflow(options.project);
+        const report = await writeWorkflowReport(options.project, workflow, reportConfig);
+        // Obsidian journal: run log
+        if (result.runIds?.[0]) {
+            const runs = await stateStore.loadRuns(options.project);
+            const runRecord = runs.find((r) => r.runId === result.runIds?.[0]);
+            if (runRecord) {
+                const paths = resolveSwarmPaths(options.project, reportConfig);
+                await journalRunEntry(paths, stateStore.config.obsidianJournal, runRecord);
+            }
+        }
+        return {
+            ...result,
+            localReportPath: report.localReportPath,
+            obsidianReportPath: report.obsidianReportPath,
+        };
+    }
+    return result;
+}

package/dist/src/cli/swarm-session-cancel.d.ts

@@ -0,0 +1,6 @@
+import { type SwarmCliContext } from "./context.js";
+export declare function runSwarmSessionCancel(options: {
+    project: string;
+    run: string;
+    reason?: string;
+}, context?: SwarmCliContext): Promise<unknown>;

package/dist/src/cli/swarm-session-cancel.js

@@ -0,0 +1,64 @@
+import { applyAcpRunStatusToWorkflow } from "../review/review-gate.js";
+import { writeWorkflowReport } from "../reporting/reporter.js";
+import { buildSessionRecordFromRun } from "../session/session-lifecycle.js";
+import { resolveSessionAdapter, resolveSessionStore, resolveStateStore, resolveSubagentAdapter } from "./context.js";
+function resolveCancelledAt(result) {
+    const normalized = result;
+    return normalized.cancelledAt ?? normalized.killedAt;
+}
+export async function runSwarmSessionCancel(options, context) {
+    const stateStore = resolveStateStore(context);
+    const sessionStore = resolveSessionStore(context);
+    const sessionAdapter = resolveSessionAdapter(context);
+    const reportConfig = context?.config ?? stateStore.config;
+    const runRecord = await stateStore.loadRun(options.project, options.run);
+    if (!runRecord) {
+        throw new Error(`Run record not found: ${options.run}`);
+    }
+    if (!runRecord.sessionRef?.sessionKey) {
+        throw new Error(`Run record has no session key: ${options.run}`);
+    }
+    const cancelled = runRecord.runner.type === "subagent"
+        ? await resolveSubagentAdapter(context).killSubagentRun(runRecord.sessionRef.sessionKey, options.reason)
+        : await sessionAdapter.cancelAcpSession(runRecord.sessionRef.sessionKey, options.reason);
+    const nextRun = {
+        ...runRecord,
+        status: "cancelled",
+        endedAt: resolveCancelledAt(cancelled) ?? new Date().toISOString(),
+        resultSummary: cancelled.message ?? runRecord.resultSummary,
+        events: [
+            ...(runRecord.events ?? []),
+            {
+                at: resolveCancelledAt(cancelled) ?? new Date().toISOString(),
+                type: "cancelled",
+                detail: { reason: options.reason, message: cancelled.message },
+            },
+        ],
+    };
+    await stateStore.writeRun(options.project, nextRun);
+    const workflow = await stateStore.loadWorkflow(options.project);
+    const nextWorkflow = applyAcpRunStatusToWorkflow(workflow, { taskId: nextRun.taskId, runStatus: "cancelled" });
+    await stateStore.saveWorkflow(options.project, nextWorkflow);
+    const task = nextWorkflow.tasks.find((entry) => entry.taskId === nextRun.taskId);
+    const nextSession = buildSessionRecordFromRun(nextWorkflow, nextRun, task);
+    if (nextSession) {
+        const existing = await sessionStore.loadSession(options.project, nextSession.sessionId);
+        await sessionStore.writeSession(options.project, existing
+            ? {
+                ...existing,
+                ...nextSession,
+                createdAt: existing.createdAt,
+            }
+            : nextSession);
+    }
+    const report = await writeWorkflowReport(options.project, nextWorkflow, reportConfig);
+    return {
+        ok: true,
+        runId: nextRun.runId,
+        status: nextRun.status,
+        sessionRef: nextRun.sessionRef,
+        resultSummary: nextRun.resultSummary,
+        localReportPath: report.localReportPath,
+        obsidianReportPath: report.obsidianReportPath,
+    };
+}

package/dist/src/cli/swarm-session-cleanup.d.ts

@@ -0,0 +1,16 @@
+import { type SwarmCliContext } from "./context.js";
+export type CleanupResult = {
+    ok: boolean;
+    orphanedCount: number;
+    closedSessionIds: string[];
+    message: string;
+};
+/**
+ * Detect orphaned sessions and close them.
+ * A session is considered orphaned if it is in "active" state but its
+ * updatedAt is older than the staleness threshold (default 1 hour).
+ */
+export declare function runSwarmSessionCleanup(options: {
+    project: string;
+    staleMinutes?: number;
+}, context?: SwarmCliContext): Promise<CleanupResult>;

package/dist/src/cli/swarm-session-cleanup.js

@@ -0,0 +1,34 @@
+import { SessionStore } from "../session/session-store.js";
+import { resolveStateStore } from "./context.js";
+/**
+ * Detect orphaned sessions and close them.
+ * A session is considered orphaned if it is in "active" state but its
+ * updatedAt is older than the staleness threshold (default 1 hour).
+ */
+export async function runSwarmSessionCleanup(options, context) {
+    const stateStore = resolveStateStore(context);
+    const sessionStore = context?.sessionStore ?? new SessionStore(stateStore.config);
+    const staleMinutes = options.staleMinutes ?? 60;
+    const cutoff = new Date(Date.now() - staleMinutes * 60_000).toISOString();
+    const sessions = await sessionStore.listSessions(options.project);
+    const orphanCandidates = sessions.filter((session) => session.state === "active" && session.updatedAt < cutoff);
+    const closedIds = [];
+    for (const session of orphanCandidates) {
+        const updated = {
+            ...session,
+            state: "orphaned",
+            updatedAt: new Date().toISOString(),
+            summary: `Orphaned: stale for >${staleMinutes}m (was active since ${session.updatedAt})`,
+        };
+        await sessionStore.writeSession(options.project, updated);
+        closedIds.push(session.sessionId);
+    }
+    return {
+        ok: true,
+        orphanedCount: closedIds.length,
+        closedSessionIds: closedIds,
+        message: closedIds.length > 0
+            ? `Marked ${closedIds.length} stale session(s) as orphaned`
+            : "No orphaned sessions found",
+    };
+}

package/dist/src/cli/swarm-session-close.d.ts

@@ -0,0 +1,6 @@
+import { type SwarmCliContext } from "./context.js";
+export declare function runSwarmSessionClose(options: {
+    project: string;
+    run: string;
+    reason?: string;
+}, context?: SwarmCliContext): Promise<unknown>;

package/dist/src/cli/swarm-session-close.js

@@ -0,0 +1,53 @@
+import { writeWorkflowReport } from "../reporting/reporter.js";
+import { buildSessionRecordFromRun } from "../session/session-lifecycle.js";
+import { resolveSessionAdapter, resolveSessionStore, resolveStateStore } from "./context.js";
+export async function runSwarmSessionClose(options, context) {
+    const stateStore = resolveStateStore(context);
+    const sessionStore = resolveSessionStore(context);
+    const sessionAdapter = resolveSessionAdapter(context);
+    const reportConfig = context?.config ?? stateStore.config;
+    const runRecord = await stateStore.loadRun(options.project, options.run);
+    if (!runRecord) {
+        throw new Error(`Run record not found: ${options.run}`);
+    }
+    if (runRecord.runner.type !== "acp" || !runRecord.sessionRef?.sessionKey) {
+        throw new Error(`Run record is not an ACP closable session: ${options.run}`);
+    }
+    const closed = await sessionAdapter.closeAcpSession(runRecord.sessionRef.sessionKey, options.reason);
+    const nextRun = {
+        ...runRecord,
+        resultSummary: closed.message ?? runRecord.resultSummary,
+        events: [
+            ...(runRecord.events ?? []),
+            {
+                at: closed.closedAt ?? new Date().toISOString(),
+                type: "closed",
+                detail: { reason: options.reason, message: closed.message },
+            },
+        ],
+    };
+    await stateStore.writeRun(options.project, nextRun);
+    const workflow = await stateStore.loadWorkflow(options.project);
+    const task = workflow.tasks.find((entry) => entry.taskId === nextRun.taskId);
+    const nextSession = buildSessionRecordFromRun(workflow, nextRun, task);
+    if (nextSession) {
+        const existing = await sessionStore.loadSession(options.project, nextSession.sessionId);
+        await sessionStore.writeSession(options.project, existing
+            ? {
+                ...existing,
+                ...nextSession,
+                createdAt: existing.createdAt,
+            }
+            : nextSession);
+    }
+    const report = await writeWorkflowReport(options.project, workflow, reportConfig);
+    return {
+        ok: true,
+        runId: nextRun.runId,
+        status: nextRun.status,
+        sessionRef: nextRun.sessionRef,
+        resultSummary: nextRun.resultSummary,
+        localReportPath: report.localReportPath,
+        obsidianReportPath: report.obsidianReportPath,
+    };
+}

package/dist/src/cli/swarm-session-followup.d.ts

@@ -0,0 +1,7 @@
+import { type SwarmCliContext } from "./context.js";
+export declare function runSwarmSessionFollowup(options: {
+    project: string;
+    session: string;
+    task: string;
+    runner?: "acp" | "subagent";
+}, context?: SwarmCliContext): Promise<unknown>;

package/dist/src/cli/swarm-session-followup.js

@@ -0,0 +1,63 @@
+import { writeWorkflowReport } from "../reporting/reporter.js";
+import { createOrchestrator } from "../services/orchestrator.js";
+import { SessionStore } from "../session/session-store.js";
+import { resolveSessionAdapter, resolveStateStore, resolveSubagentAdapter } from "./context.js";
+export async function runSwarmSessionFollowup(options, context) {
+    const stateStore = resolveStateStore(context);
+    const sessionStore = context?.sessionStore ?? new SessionStore(stateStore.config);
+    const sessionAdapter = resolveSessionAdapter(context);
+    const subagentAdapter = resolveSubagentAdapter(context);
+    const session = await sessionStore.loadSession(options.project, options.session);
+    if (!session) {
+        return { ok: false, error: `Session not found: ${options.session}` };
+    }
+    if (session.state !== "active" && session.state !== "idle") {
+        return { ok: false, error: `Session ${options.session} is in ${session.state} state, cannot follow up` };
+    }
+    // Load workflow and find next runnable task, or inject a synthetic one
+    const workflow = await stateStore.loadWorkflow(options.project);
+    const runnerType = options.runner ?? session.runner;
+    // Create a synthetic follow-up task injected into the workflow
+    const followupTaskId = `followup-${Date.now()}`;
+    const followupTask = {
+        taskId: followupTaskId,
+        specId: workflow.activeSpecId ?? "followup",
+        title: `Follow-up: ${options.task}`,
+        description: options.task,
+        kind: "coding",
+        deps: [],
+        status: "ready",
+        workspace: { mode: "shared" },
+        runner: { type: runnerType, threadRequested: Boolean(session.threadId) },
+        review: { required: true },
+        session: {
+            policy: "require_existing",
+            bindingKey: session.scope.bindingKey,
+            preferredSessionId: session.sessionId,
+        },
+    };
+    // Add task to workflow
+    const updatedWorkflow = {
+        ...workflow,
+        tasks: [...workflow.tasks, followupTask],
+    };
+    await stateStore.saveWorkflow(options.project, updatedWorkflow);
+    // Dispatch through orchestrator
+    const orchestrator = createOrchestrator({ stateStore, sessionStore, sessionAdapter, subagentAdapter });
+    const result = await orchestrator.runOnce({
+        projectRoot: options.project,
+        taskId: followupTaskId,
+        runnerOverride: runnerType,
+    });
+    if (!result.ok) {
+        return result;
+    }
+    const finalWorkflow = await stateStore.loadWorkflow(options.project);
+    const report = await writeWorkflowReport(options.project, finalWorkflow, stateStore.config);
+    return {
+        ...result,
+        followupTaskId,
+        sessionId: options.session,
+        localReportPath: report.localReportPath,
+    };
+}

package/dist/src/cli/swarm-session-inspect.d.ts

@@ -0,0 +1,5 @@
+import { type SwarmCliContext } from "./context.js";
+export declare function runSwarmSessionInspect(options: {
+    project: string;
+    session: string;
+}, context?: SwarmCliContext): Promise<unknown>;

package/dist/src/cli/swarm-session-inspect.js

@@ -0,0 +1,12 @@
+import { resolveSessionStore } from "./context.js";
+export async function runSwarmSessionInspect(options, context) {
+    const sessionStore = resolveSessionStore(context);
+    const session = await sessionStore.loadSession(options.project, options.session);
+    if (!session) {
+        throw new Error(`Session record not found: ${options.session}`);
+    }
+    return {
+        ok: true,
+        session,
+    };
+}

package/dist/src/cli/swarm-session-list.d.ts

@@ -0,0 +1,4 @@
+import { type SwarmCliContext } from "./context.js";
+export declare function runSwarmSessionList(options: {
+    project: string;
+}, context?: SwarmCliContext): Promise<unknown>;

package/dist/src/cli/swarm-session-list.js

@@ -0,0 +1,19 @@
+import { resolveSessionStore } from "./context.js";
+export async function runSwarmSessionList(options, context) {
+    const sessionStore = resolveSessionStore(context);
+    const sessions = await sessionStore.listSessions(options.project);
+    return {
+        ok: true,
+        sessions: sessions
+            .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt))
+            .map((session) => ({
+            sessionId: session.sessionId,
+            runner: session.runner,
+            mode: session.mode,
+            state: session.state,
+            summary: session.summary,
+            lastRunId: session.lastRunId,
+            updatedAt: session.updatedAt,
+        })),
+    };
+}

package/dist/src/cli/swarm-session-status.d.ts

@@ -0,0 +1,5 @@
+import { type SwarmCliContext } from "./context.js";
+export declare function runSwarmSessionStatus(options: {
+    project: string;
+    run: string;
+}, context?: SwarmCliContext): Promise<unknown>;

package/dist/src/cli/swarm-session-status.js

@@ -0,0 +1,85 @@
+import { applyAcpRunStatusToWorkflow } from "../review/review-gate.js";
+import { writeWorkflowReport } from "../reporting/reporter.js";
+import { buildSessionRecordFromRun } from "../session/session-lifecycle.js";
+import { resolveSessionAdapter, resolveSessionStore, resolveStateStore, resolveSubagentAdapter } from "./context.js";
+import { syncAcpRunRecord, syncSubagentRunRecord } from "../runtime/session-sync.js";
+function canUseLocalClosedRunFallback(error, runRecord) {
+    const message = error instanceof Error ? error.message : String(error);
+    const hasClosedEvent = (runRecord.events ?? []).some((event) => event.type === "closed");
+    return hasClosedEvent && /metadata is missing|Unable to resolve session target/i.test(message);
+}
+export async function runSwarmSessionStatus(options, context) {
+    const stateStore = resolveStateStore(context);
+    const sessionStore = resolveSessionStore(context);
+    const sessionAdapter = resolveSessionAdapter(context);
+    const reportConfig = context?.config ?? stateStore.config;
+    const runRecord = await stateStore.loadRun(options.project, options.run);
+    if (!runRecord) {
+        throw new Error(`Run record not found: ${options.run}`);
+    }
+    if (!runRecord.sessionRef?.sessionKey) {
+        throw new Error(`Run record has no session key: ${options.run}`);
+    }
+    let synced;
+    try {
+        if (runRecord.runner.type === "acp") {
+            const remoteStatus = await sessionAdapter.getAcpSessionStatus(runRecord.sessionRef.sessionKey);
+            synced = syncAcpRunRecord(runRecord, remoteStatus);
+        }
+        else if (runRecord.runner.type === "subagent") {
+            const remoteStatus = await resolveSubagentAdapter(context).getSubagentRunStatus(runRecord.sessionRef.sessionKey);
+            synced = syncSubagentRunRecord(runRecord, remoteStatus);
+        }
+        else {
+            throw new Error(`Run record is not a session-backed runner: ${options.run}`);
+        }
+    }
+    catch (error) {
+        if (!canUseLocalClosedRunFallback(error, runRecord)) {
+            throw error;
+        }
+        synced = {
+            runRecord: {
+                ...runRecord,
+                resultSummary: runRecord.resultSummary ?? "session metadata missing after close; using local ledger",
+            },
+            remoteStatus: {
+                sessionKey: runRecord.sessionRef.sessionKey,
+                state: runRecord.status === "cancelled" ? "cancelled" : "completed",
+                checkedAt: new Date().toISOString(),
+                message: "session metadata missing after close; using local ledger",
+            },
+        };
+    }
+    await stateStore.writeRun(options.project, synced.runRecord);
+    const workflow = await stateStore.loadWorkflow(options.project);
+    const nextWorkflow = applyAcpRunStatusToWorkflow(workflow, {
+        taskId: synced.runRecord.taskId,
+        runStatus: synced.runRecord.status,
+        summary: synced.runRecord.resultSummary,
+        at: synced.remoteStatus.checkedAt,
+    });
+    await stateStore.saveWorkflow(options.project, nextWorkflow);
+    const task = nextWorkflow.tasks.find((entry) => entry.taskId === synced.runRecord.taskId);
+    const nextSession = buildSessionRecordFromRun(nextWorkflow, synced.runRecord, task);
+    if (nextSession) {
+        const existing = await sessionStore.loadSession(options.project, nextSession.sessionId);
+        await sessionStore.writeSession(options.project, existing
+            ? {
+                ...existing,
+                ...nextSession,
+                createdAt: existing.createdAt,
+            }
+            : nextSession);
+    }
+    const report = await writeWorkflowReport(options.project, nextWorkflow, reportConfig);
+    return {
+        ok: true,
+        runId: synced.runRecord.runId,
+        status: synced.runRecord.status,
+        sessionRef: synced.runRecord.sessionRef,
+        resultSummary: synced.runRecord.resultSummary,
+        localReportPath: report.localReportPath,
+        obsidianReportPath: report.obsidianReportPath,
+    };
+}

package/dist/src/cli/swarm-session-steer.d.ts

@@ -0,0 +1,6 @@
+import { type SwarmCliContext } from "./context.js";
+export declare function runSwarmSessionSteer(options: {
+    project: string;
+    session: string;
+    message: string;
+}, context?: SwarmCliContext): Promise<unknown>;

package/dist/src/cli/swarm-session-steer.js

@@ -0,0 +1,40 @@
+import { SessionStore } from "../session/session-store.js";
+import { resolveSessionAdapter, resolveStateStore } from "./context.js";
+export async function runSwarmSessionSteer(options, context) {
+    const stateStore = resolveStateStore(context);
+    const sessionStore = context?.sessionStore ?? new SessionStore(stateStore.config);
+    const sessionAdapter = resolveSessionAdapter(context);
+    const session = await sessionStore.loadSession(options.project, options.session);
+    if (!session) {
+        return { ok: false, error: `Session not found: ${options.session}` };
+    }
+    if (session.state !== "active") {
+        return { ok: false, error: `Session ${options.session} is in ${session.state} state, must be active to steer` };
+    }
+    if (!session.providerRef.sessionKey) {
+        return { ok: false, error: `Session ${options.session} has no provider session key` };
+    }
+    // Use the session adapter to send a follow-up message via spawn with the existing session
+    // This leverages the same spawn mechanism with existingSessionKey
+    const result = await sessionAdapter.spawnAcpSession({
+        task: options.message,
+        runtime: "acp",
+        agentId: "codex",
+        mode: "session",
+        thread: true,
+        existingSessionKey: session.providerRef.sessionKey,
+        threadId: session.threadId,
+    });
+    // Update session record
+    await sessionStore.writeSession(options.project, {
+        ...session,
+        updatedAt: new Date().toISOString(),
+        summary: `Steered: ${options.message.slice(0, 80)}`,
+    });
+    return {
+        ok: true,
+        sessionId: options.session,
+        sessionKey: result.sessionKey,
+        message: `Steering message sent to session ${options.session}`,
+    };
+}

package/dist/src/cli/swarm-status.d.ts

@@ -0,0 +1,81 @@
+import { type SwarmCliContext } from "./context.js";
+export type SwarmStatusResult = {
+    ok: true;
+    workflow: {
+        lifecycle: string;
+        activeSpecId?: string;
+        totalTasks: number;
+        readyTasks: number;
+        runningTasks: number;
+        blockedTasks: number;
+        reviewQueueSize: number;
+        lastAction?: {
+            at: string;
+            type: string;
+            message?: string;
+        };
+    };
+    reviewQueue: Array<{
+        taskId: string;
+        title?: string;
+        status?: string;
+        latestRunId?: string;
+        latestRunStatus?: string;
+        latestRunSummary?: string;
+        recommendedAction?: string;
+    }>;
+    attention: Array<{
+        kind: string;
+        taskId: string;
+        title?: string;
+        message: string;
+        latestRunId?: string;
+        latestRunStatus?: string;
+        latestRunSummary?: string;
+        recommendedAction: string;
+    }>;
+    recentRuns: Array<{
+        runId: string;
+        taskId: string;
+        runner: string;
+        status: string;
+        resultSummary?: string;
+    }>;
+    highlights: Array<{
+        kind: string;
+        runId: string;
+        taskId: string;
+        runner: string;
+        summary?: string;
+        recommendedAction: string;
+    }>;
+    recommendedActions: string[];
+    sessions: {
+        total: number;
+        active: number;
+        idle: number;
+        closed: number;
+        failed: number;
+        orphaned: number;
+    };
+    recentSessions: Array<{
+        sessionId: string;
+        runner: string;
+        mode: string;
+        state: string;
+        summary?: string;
+        lastRunId?: string;
+    }>;
+    reusableSessionCandidates: Array<{
+        taskId: string;
+        title?: string;
+        policy: string;
+        eligible: boolean;
+        bindingKey?: string;
+        selectedSessionId?: string;
+        reason: string;
+    }>;
+};
+export declare function runSwarmStatus(options: {
+    project: string;
+}, context?: SwarmCliContext): Promise<SwarmStatusResult>;