opencode-swarm 7.81.1 → 7.81.3

package/dist/commands/close.d.ts

@@ -1,4 +1,13 @@
+import { loadPluginConfigWithMeta } from '../config';
+import { type KnowledgeConfig, type PluginConfig } from '../config/schema';
+import { archiveEvidence } from '../evidence/manager';
 import { getGitRepositoryStatus, resetToMainAfterMerge, resetToRemoteBranch } from '../git/branch';
+import { createCuratorLLMDelegate } from '../hooks/curator-llm-factory';
+import { runCuratorPostMortem } from '../hooks/curator-postmortem';
+import { checkHivePromotions } from '../hooks/hive-promoter';
+import { curateAndStoreSwarm } from '../hooks/knowledge-curator';
+import { closePlanTerminalState } from '../plan/manager';
+import { resetSwarmStatePreservingSingletons } from '../state';
 interface PlanPhase {
     id: number;
     name: string;
@@ -17,9 +26,63 @@ interface CloseCommandOptions {
     sessionID?: string;
     skillReviewTimeoutMs?: number;
 }
+interface CurationCounts {
+    stored: number;
+    skipped: number;
+    rejected: number;
+    quarantined: number;
+}
 interface CloseKnowledgeEntry {
     created_at?: string;
 }
+export interface ArchiveStageContext {
+    directory: string;
+    swarmDir: string;
+    config: PluginConfig;
+    warnings: string[];
+}
+export interface CloseStageContext {
+    directory: string;
+    swarmDir: string;
+    planData: PlanData;
+    planExists: boolean;
+    planAlreadyDone: boolean;
+    config: KnowledgeConfig;
+    projectName: string;
+    warnings: string[];
+    closedPhases: number[];
+    closedTasks: string[];
+    sessionStart: string | undefined;
+    isForced: boolean;
+    runSkillReview: boolean;
+    options: CloseCommandOptions;
+    phases: PlanPhase[];
+    inProgressPhases: PlanPhase[];
+    curationSucceeded: boolean;
+    curationResult: CurationCounts | undefined;
+    allLessons: string[];
+    explicitLessons: string[];
+    retroLessons: string[];
+    knowledgeSkillHint: string;
+    skillReviewSummary: string;
+    postMortemSummary: string;
+    hivePromoted: number;
+    sessionKnowledgeCreated: number;
+    fallbackKnowledgeCreated: number;
+    originalStatuses: Map<string, string>;
+    guaranteeResult: {
+        closedPhaseIds: number[];
+        closedTaskIds: string[];
+    };
+    archiveResult: string;
+    archivedFileCount: number;
+    archivedActiveStateFiles: Set<string>;
+    archivedActiveStateDirs: Set<string>;
+    timestamp: string;
+    archiveDir: string;
+    archiveSuffix: string;
+    args: string[];
+}
 declare function countSessionKnowledgeEntries(entries: CloseKnowledgeEntry[], sessionStart: string | undefined, fallbackCount: number): number;
 declare function copyDirRecursive(src: string, dest: string): Promise<number>;
 /**
@@ -31,6 +94,58 @@ declare function guaranteeAllPlansComplete(planData: PlanData): {
     closedPhaseIds: number[];
     closedTaskIds: string[];
 };
+export interface GitAlignResult {
+    gitAlignResult: string;
+    prunedBranches: string[];
+}
+export interface CleanStageResult {
+    cleanedFiles: string[];
+    configBackupsRemoved: number;
+    swarmPlanFilesRemoved: number;
+    tmpFilesRemoved: number;
+}
+/**
+ * STAGE 1: FINALIZE
+ *
+ * Writes retrospectives for in-progress phases (or a session-level retro for
+ * plan-free closes), curates lessons, promotes to hive, runs skill review,
+ * persists terminal plan state, and runs post-mortem. All state mutations are
+ * written back to ctx so the caller can build the close summary.
+ */
+export declare function runFinalizeStage(ctx: CloseStageContext): Promise<void>;
+/**
+ * STAGE 2: ARCHIVE
+ *
+ * Creates a timestamped archive bundle under .swarm/archive/, copies flat-file
+ * artifacts and active-state directories, then runs the evidence retention
+ * policy. All state mutations (archive path, counts, success sets) are written
+ * back to ctx so the caller can build the close summary.
+ */
+export declare function runArchiveStage(ctx: CloseStageContext): Promise<void>;
+/**
+ * Runs the evidence-retention sub-logic of STAGE 2 (ARCHIVE).
+ * Reads max_age_days / max_bundles from config.evidence (FR-016) and
+ * calls archiveEvidence. Fail-open: pushes a warning on error but never throws.
+ */
+export declare function runArchiveEvidenceRetention(ctx: ArchiveStageContext): Promise<void>;
+/**
+ * STAGE 3: CLEAN
+ *
+ * Removes active-state files and directories that were successfully archived
+ * (archive-first guard), plus stale config-backup/ledger-sibling/SWARM_PLAN/.tmp
+ * artifacts. Resets context.md for the next session. All state mutations are
+ * written back to ctx so the caller can build the close summary.
+ */
+export declare function runCleanStage(ctx: CloseStageContext): Promise<CleanStageResult>;
+/**
+ * STAGE 4: ALIGN
+ *
+ * Performs safe git alignment to main (resetToMainAfterMerge / resetToRemoteBranch
+ * via _internals), handling post-merge scenarios and non-git directories.
+ * Returns { gitAlignResult, prunedBranches } so the orchestrator can build
+ * the close summary. All warnings are pushed into ctx.warnings.
+ */
+export declare function runAlignStage(ctx: CloseStageContext): Promise<GitAlignResult>;
 /**
  * Handles /swarm close command - performs full terminal session finalization:
  * 0. Guarantee: mark all incomplete phases/tasks as closed
@@ -42,7 +157,16 @@ declare function guaranteeAllPlansComplete(planData: PlanData): {
  * Must be idempotent - safe to run multiple times.
  */
 export declare function handleCloseCommand(directory: string, args: string[], options?: CloseCommandOptions): Promise<string>;
+/**
+ * Acquire the finalize lock for the close command (FR-012).
+ * Wraps tryAcquireLock with a directory-only API.
+ */
+declare function acquireFinalizeLock(directory: string): Promise<{
+    acquired: boolean;
+    release?: () => Promise<void>;
+}>;
 export declare const _internals: {
+    ACTIVE_STATE_DIRS_TO_CLEAN: string[];
     countSessionKnowledgeEntries: typeof countSessionKnowledgeEntries;
     CLOSE_SKILL_REVIEW_TIMEOUT_MS: number;
     guaranteeAllPlansComplete: typeof guaranteeAllPlansComplete;
@@ -50,5 +174,19 @@ export declare const _internals: {
     resetToMainAfterMerge: typeof resetToMainAfterMerge;
     resetToRemoteBranch: typeof resetToRemoteBranch;
     copyDirRecursive: typeof copyDirRecursive;
+    loadPluginConfigWithMeta: typeof loadPluginConfigWithMeta;
+    curateAndStoreSwarm: typeof curateAndStoreSwarm;
+    checkHivePromotions: typeof checkHivePromotions;
+    runCuratorPostMortem: typeof runCuratorPostMortem;
+    createCuratorLLMDelegate: typeof createCuratorLLMDelegate;
+    resetSwarmStatePreservingSingletons: typeof resetSwarmStatePreservingSingletons;
+    runFinalizeStage: typeof runFinalizeStage;
+    acquireFinalizeLock: typeof acquireFinalizeLock;
+    runArchiveStage: typeof runArchiveStage;
+    runArchiveEvidenceRetention: typeof runArchiveEvidenceRetention;
+    runCleanStage: typeof runCleanStage;
+    runAlignStage: typeof runAlignStage;
+    archiveEvidence: typeof archiveEvidence;
+    closePlanTerminalState: typeof closePlanTerminalState;
 };
 export {};

package/dist/commands/post-mortem.d.ts

@@ -1,3 +1,9 @@
+import { createCuratorLLMDelegate } from '../hooks/curator-llm-factory.js';
+import { runCuratorPostMortem } from '../hooks/curator-postmortem.js';
+export declare const _internals: {
+    createCuratorLLMDelegate: typeof createCuratorLLMDelegate;
+    runCuratorPostMortem: typeof runCuratorPostMortem;
+};
 export declare function handlePostMortemCommand(directory: string, args: string[], options?: {
     sessionID?: string;
 }): Promise<string>;

package/dist/commands/registry.d.ts

@@ -312,7 +312,7 @@ export declare const COMMAND_REGISTRY: {
     readonly finalize: {
         readonly handler: (ctx: CommandContext) => Promise<string>;
         readonly description: "Use /swarm finalize to finalize the swarm project and archive evidence";
-        readonly details: "Idempotent 4-stage terminal finalization: (1) finalize writes retrospectives for in-progress phases, (2) archive creates timestamped bundle of swarm artifacts and evidence, (3) clean removes active-state files for a clean slate, (4) align performs aggressive git reset --hard to the default remote branch, discarding uncommitted changes and untracked files; falls back to a cautious reset that preserves uncommitted changes when the aggressive path cannot proceed. WARNING: alignment discards local changes and untracked files. Resets agent sessions and delegation chains. Reads .swarm/close-lessons.md for explicit lessons and runs curation. Use --skill-review to run the quota-bounded skill_improver in proposal mode.";
+        readonly details: "Idempotent 4-stage terminal finalization: (1) finalize writes retrospectives for in-progress phases, (2) archive creates timestamped bundle of swarm artifacts and evidence, (3) clean removes active-state files for a clean slate, (4) align performs aggressive git reset --hard to the default remote branch, discarding uncommitted changes and gitignored build artifacts (user-created untracked files are preserved); falls back to a cautious reset that preserves uncommitted changes when the aggressive path cannot proceed. WARNING: alignment discards local changes and gitignored files. Resets agent sessions and delegation chains. Reads .swarm/close-lessons.md for explicit lessons and runs curation. Use --skill-review to run the quota-bounded skill_improver in proposal mode.";
         readonly args: "--prune-branches, --skill-review";
         readonly category: "core";
         readonly toolPolicy: "none";

package/dist/git/branch.d.ts

@@ -83,7 +83,7 @@ declare function detectDefaultRemoteBranch(cwd: string): string | null;
  */
 export declare function resetToRemoteBranch(cwd: string, options?: {
     pruneBranches?: boolean;
-}): ResetToRemoteBranchResult;
+}): Promise<ResetToRemoteBranchResult>;
 export interface ResetToMainAfterMergeResult {
     success: boolean;
     targetBranch: string;
@@ -101,7 +101,7 @@ export interface ResetToMainAfterMergeResult {
  */
 export declare function resetToMainAfterMerge(cwd: string, options?: {
     pruneBranches?: boolean;
-}): ResetToMainAfterMergeResult;
+}): Promise<ResetToMainAfterMergeResult>;
 /**
  * DI seam for testability. Contains all test-mocked exports.
  * Internal calls should use _internals.fn() instead of fn() directly.

package/dist/hooks/curator-postmortem.d.ts

@@ -33,13 +33,18 @@ interface KnowledgeEventSummary {
     status: string;
 }
 declare function collectKnowledgeSummary(directory: string): Promise<KnowledgeEventSummary[]>;
-declare function readJsonlFile(filePath: string): unknown[];
+declare function readJsonlFile(filePath: string, maxLines?: number): unknown[];
 declare function collectRetrospectives(directory: string): string[];
 declare function collectDriftReports(directory: string): string[];
 declare function collectPendingProposals(directory: string): Array<{
     source: string;
     content: string;
 }>;
+declare function isReportValid(reportPath: string): boolean;
+declare function acquirePostMortemLock(directory: string, planId: string): Promise<{
+    acquired: boolean;
+    release?: () => Promise<void>;
+}>;
 declare function buildDataOnlyReport(planId: string, planSummary: string, knowledgeSummary: KnowledgeEventSummary[], curatorDigest: string | null, proposals: Array<{
     source: string;
     content: string;
@@ -50,6 +55,7 @@ declare function assembleLLMInput(planId: string, planSummary: string, knowledge
 }>, unactionable: unknown[], retrospectives: string[], driftReports: string[]): string;
 export declare function runCuratorPostMortem(directory: string, options?: PostMortemOptions): Promise<PostMortemResult>;
 export declare const _internals: {
+    acquirePostMortemLock: typeof acquirePostMortemLock;
     collectKnowledgeSummary: typeof collectKnowledgeSummary;
     collectRetrospectives: typeof collectRetrospectives;
     collectDriftReports: typeof collectDriftReports;
@@ -57,5 +63,6 @@ export declare const _internals: {
     readJsonlFile: typeof readJsonlFile;
     buildDataOnlyReport: typeof buildDataOnlyReport;
     assembleLLMInput: typeof assembleLLMInput;
+    isReportValid: typeof isReportValid;
 };
 export {};

package/dist/hooks/knowledge-events.d.ts

@@ -186,8 +186,11 @@ export declare function recordHiveKnowledgeEvent(event: KnowledgeEventInput): Pr
  * Read all events from the log. Skips corrupted JSONL lines (logging a warning
  * for each) and returns an empty array when the file does not exist — mirrors
  * `readKnowledge` in knowledge-store.ts.
+ *
+ * Optional maxEvents cap: when provided as a positive finite number, stops
+ * after that many events are parsed, preventing unbounded memory growth.
  */
-export declare function readKnowledgeEvents(directory: string): Promise<KnowledgeEvent[]>;
+export declare function readKnowledgeEvents(directory: string, maxEvents?: number): Promise<KnowledgeEvent[]>;
 /**
  * Read all events from the shared, cross-project hive events log. Skips
  * corrupted JSONL lines and returns an empty array when the file does not exist.

package/dist/hooks/knowledge-store.d.ts

@@ -7,7 +7,8 @@ export declare function resolveSwarmRetractionsPath(directory: string): string;
 export declare function resolveHiveKnowledgePath(): string;
 export declare function resolveHiveRejectedPath(): string;
 export declare function resolveHiveEventsPath(): string;
-export declare function readKnowledge<T>(filePath: string): Promise<T[]>;
+declare function parseKnowledgeContent<T>(content: string, max: number): T[];
+export declare function readKnowledge<T>(filePath: string, maxEntries?: number): Promise<T[]>;
 export declare function normalizeEntry<T>(raw: T): T;
 export declare function readRejectedLessons(directory: string): Promise<RejectedLesson[]>;
 export interface KnowledgeRetractionRecord {
@@ -76,6 +77,7 @@ export declare const _internals: {
     resolveHiveRejectedPath: typeof resolveHiveRejectedPath;
     resolveHiveEventsPath: typeof resolveHiveEventsPath;
     readKnowledge: typeof readKnowledge;
+    parseKnowledgeContent: typeof parseKnowledgeContent;
     readRejectedLessons: typeof readRejectedLessons;
     appendKnowledge: typeof appendKnowledge;
     rewriteKnowledge: typeof rewriteKnowledge;