opencode-swarm 7.108.0 → 7.109.1

package/dist/plan/ledger.d.ts

@@ -92,6 +92,29 @@ declare function getPlanJsonPath(directory: string): string;
  * @returns Hex-encoded SHA-256 hash
  */
 export declare function computePlanHash(plan: Plan): string;
+/**
+ * Compute a SHA-256 hash of the plan's STRUCTURE, excluding transient
+ * execution progress fields (`phase.status` and `task.status`).
+ *
+ * This mirrors {@link computePlanHash}'s normalization byte-for-byte EXCEPT it
+ * omits the two status fields from the hashed payload. It exists solely for the
+ * plan-critic execution gate (`assertPlanCriticApprovedForExecution`), which
+ * must recognize a plan as "the same plan the critic approved" even after the
+ * architect flips a task to `in_progress` before delegating its coder. Including
+ * status (as `computePlanHash` does) would make the gate fire on the very first
+ * conforming coder dispatch, because `update_task_status(taskId,'in_progress')`
+ * runs before it and mutates the status-inclusive hash.
+ *
+ * IMPORTANT: This is intentionally a SEPARATE function, not a refactor of
+ * `computePlanHash`. `computePlanHash` is load-bearing for ledger replay and
+ * staleness/integrity detection (its output is persisted on-disk as
+ * `plan_hash_after`), so its byte output must never change. Do NOT collapse
+ * these two into a shared normalizer.
+ *
+ * @param plan - The plan to hash
+ * @returns Hex-encoded SHA-256 hash of the status-excluded structure
+ */
+export declare function computePlanStructureHash(plan: Plan): string;
 /**
  * Read the current plan.json and compute its hash.
  *
@@ -206,12 +229,21 @@ export declare function takeSnapshotWithRetry(directory: string, plan: Plan, opt
  *   - approvalMetadata: optional free-form metadata embedded into the
  *     snapshot payload (e.g. phase number, verdict, summary) so that
  *     downstream readers can filter without decoding prompts.
+ *   - payloadHashOverride: when supplied, stored as the snapshot payload's
+ *     `payload_hash` INSTEAD of the default `computePlanHash(plan)`. Used by the
+ *     plan-critic gate to persist a status-excluded structural hash
+ *     (`computePlanStructureHash`) so the gate can match the plan across the
+ *     architect's pre-delegation `in_progress` status flip. Note this only
+ *     changes the embedded snapshot `payload_hash`; the ledger event's
+ *     hash-chain field `plan_hash_after` is unaffected (still governed by
+ *     `planHashAfter` / on-disk plan.json), preserving replay integrity.
  * @returns The LedgerEvent that was written
  */
 export declare function takeSnapshotEvent(directory: string, plan: Plan, options?: {
     planHashAfter?: string;
     source?: string;
     approvalMetadata?: Record<string, unknown>;
+    payloadHashOverride?: string;
 }): Promise<LedgerEvent>;
 /**
  * Options for replayFromLedger
@@ -320,8 +352,35 @@ export interface ApprovedSnapshotInfo {
  * @returns The most recent approved snapshot info, or null if none exists
  */
 export declare function loadLastApprovedPlan(directory: string, expectedPlanId?: string): Promise<ApprovedSnapshotInfo | null>;
+/**
+ * Find the most recent PLAN-CRITIC-approved snapshot in the ledger.
+ *
+ * Like {@link loadLastApprovedPlan}, but additionally requires the snapshot's
+ * embedded `approval.source === 'plan_critic_gate'`. This distinguishes the
+ * plan-critic execution-gate approval (recorded by
+ * `recordPlanCriticApprovalSnapshotIfApplicable` in the delegation gate) from
+ * the UNRELATED per-phase drift-verification snapshots that
+ * `src/tools/write-drift-evidence.ts` also writes with
+ * `source: 'critic_approved'` (but `approval: {phase, verdict, summary}` and no
+ * `plan_critic_gate` marker).
+ *
+ * Without this filter, a drift-verification snapshot landing AFTER a legitimate
+ * plan-critic approval would shadow it (being more recent), causing the gate to
+ * spuriously reject execution. This loader skips non-matching `critic_approved`
+ * snapshots and keeps scanning backward to find the plan-critic approval.
+ *
+ * SAFETY: `loadLastApprovedPlan`'s default behavior is intentionally left
+ * unchanged — other callers (`get-approved-plan`, restore/recovery paths) want
+ * ANY `critic_approved` snapshot as a restore point regardless of approval shape.
+ *
+ * @param directory - Working directory containing `.swarm/plan-ledger.jsonl`
+ * @param expectedPlanId - Optional plan identity filter (see loadLastApprovedPlan)
+ * @returns The most recent plan-critic-approved snapshot info, or null
+ */
+export declare function loadLastPlanCriticApprovedSnapshot(directory: string, expectedPlanId?: string): Promise<ApprovedSnapshotInfo | null>;
 export declare const _internals: {
     computePlanHash: typeof computePlanHash;
+    computePlanStructureHash: typeof computePlanStructureHash;
     computeCurrentPlanHash: typeof computeCurrentPlanHash;
     ledgerExists: typeof ledgerExists;
     getLatestLedgerSeq: typeof getLatestLedgerSeq;
@@ -336,6 +395,7 @@ export declare const _internals: {
     quarantineLedgerSuffix: typeof quarantineLedgerSuffix;
     replayWithIntegrity: typeof replayWithIntegrity;
     loadLastApprovedPlan: typeof loadLastApprovedPlan;
+    loadLastPlanCriticApprovedSnapshot: typeof loadLastPlanCriticApprovedSnapshot;
     getLedgerPath: typeof getLedgerPath;
     getPlanJsonPath: typeof getPlanJsonPath;
 };

package/dist/sdd/effective-spec.d.ts

@@ -203,6 +203,21 @@ export interface ReadEffectiveSpecOpts {
  * `.specify/` a non-competing source, matching both citations.
  */
 export declare function readEffectiveSpecSync(directory: string, opts?: ReadEffectiveSpecOpts): EffectiveSpec | null;
+/**
+ * Write an SDD projection to `.swarm/spec.md`.
+ *
+ * **Overwrite enforcement (FR-004, TOCTOU-safe):**
+ * When `overwrite` is `false` (default), the write uses `O_EXCL` exclusive
+ * creation (`fs.writeFileSync(target, data, { flag: 'wx' })`).  If the
+ * target already exists the kernel returns `EEXIST` and the function
+ * returns `written: false` with an `error` field — no archive, no replace.
+ * This closes the TOCTOU race at the write boundary: a native spec that
+ * appears between a pre-check and this call cannot be silently replaced.
+ *
+ * When `overwrite` is `true`, the existing archive-then-replace path runs.
+ *
+ * The `--dry-run` early-return remains untouched (before any write).
+ */
 export declare function writeProjectedSpecSync(directory: string, options?: {
     changeId?: string;
     dryRun?: boolean;
@@ -210,11 +225,17 @@ export declare function writeProjectedSpecSync(directory: string, options?: {
     source?: 'openspec' | 'speckit';
     /** Feature selector forwarded to buildSpeckitProjectionSync when source is speckit. */
     feature?: string;
+    /**
+     * When true, archive the existing spec and overwrite.
+     * When false (default), use O_EXCL (wx flag) — refuse if target exists.
+     */
+    overwrite?: boolean;
 }): {
     written: boolean;
     projection: EffectiveSpec | null;
     archivePath?: string;
     path: string;
+    error?: string;
 };
 /**
  * Validate Spec-Kit artifacts READ-ONLY (FR-007, task 2.3).

package/dist/tools/save-plan.d.ts

@@ -64,6 +64,12 @@ export interface SavePlanArgs {
      * from the existing plan's identity.
      */
     confirm_identity_change?: boolean;
+    /**
+     * When true, allows saving a plan even when required FR-### MUST/SHALL
+     * requirements from the effective spec are not explicitly mapped in task
+     * descriptions or acceptance criteria.
+     */
+    confirm_requirement_coverage_gaps?: boolean;
     /**
      * Architect-facing concurrency controls for this plan.
      * When execution_profile.locked is true the profile is immutable — subsequent
@@ -90,6 +96,7 @@ export interface SavePlanResult {
     errors?: string[];
     warnings?: string[];
     recovery_guidance?: string;
+    requirement_coverage?: RequirementCoverageResult;
     /** The resolved execution_profile that was persisted, if any. */
     execution_profile?: {
         parallelization_enabled: boolean;
@@ -99,6 +106,22 @@ export interface SavePlanResult {
         auto_proceed?: boolean;
     };
 }
+interface RequirementCoverageEntry {
+    id: string;
+    obligation: 'MUST' | 'SHOULD' | 'SHALL' | null;
+    text: string;
+    mapped_task_ids: string[];
+}
+interface RequirementCoverageResult {
+    status: 'passed' | 'failed' | 'override';
+    total_requirements: number;
+    covered_count: number;
+    missing_count: number;
+    blocking_missing_count: number;
+    covered: RequirementCoverageEntry[];
+    missing: RequirementCoverageEntry[];
+    blocking_missing: RequirementCoverageEntry[];
+}
 /**
  * Detect template placeholder content (e.g., [task], [Project], [description], [N]).
  * These patterns indicate the LLM reproduced template examples literally rather than
@@ -126,3 +149,4 @@ export declare function executeSavePlan(args: SavePlanArgs, fallbackDir?: string
  * Tool definition for save_plan
  */
 export declare const save_plan: ToolDefinition;
+export {};

package/dist/worktree/core.d.ts

@@ -180,23 +180,74 @@ export declare function makeWorktreeBranchName(sessionId: string, id: string, op
  * @param options   - Worktree purpose, branch naming, and path options.
  * @returns A worktree handle on success, or `{ error: string }` on failure.
  */
+/**
+ * Resolves the swarm-managed worktree base directory: `directory/worktreeDir`
+ * when an override is configured, otherwise the DD-6 default
+ * `<project-parent>/.swarm-worktrees`. Shared by `provisionWorktree` (path
+ * construction) and the destructive-command guard / removeWorktree force
+ * fallback (containment checks) so both sides agree on what counts as
+ * "swarm-managed".
+ *
+ * @param directory   - Project root (an absolute path to the git working tree).
+ * @param worktreeDir - Optional worktree-dir override (relative to `directory`
+ *                      or absolute). When absent, the DD-6 default base is used.
+ * @returns The absolute worktree base directory.
+ */
+export declare function resolveWorktreeBaseDir(directory: string, worktreeDir?: string): string;
+/**
+ * Checks whether `targetPath` is contained within the swarm-managed worktree
+ * base directory (default base, plus any `worktreeDirOverrides`), using
+ * `fs.realpathSync` on both sides to resolve symlinks/junctions before the
+ * containment comparison — this both establishes containment AND defeats a
+ * symlink/junction escape in one step. Fails closed (returns false) if the
+ * target cannot be resolved (e.g. does not exist, or a permission error).
+ * Case-insensitive comparison on Windows, matching `isInDeclaredScope` in
+ * `src/hooks/guardrails/helpers.ts`.
+ *
+ * @param targetPath           - Path to check (relative to `directory` or absolute).
+ * @param directory            - Project root, used to resolve relative targets
+ *                               and the default base.
+ * @param worktreeDirOverrides - Additional configured worktree-dir overrides
+ *                               whose resolved bases are also treated as trusted.
+ * @returns `true` when the resolved target is inside a trusted base, else `false`.
+ */
+export declare function isPathUnderSwarmWorktreeBase(targetPath: string, directory: string, worktreeDirOverrides?: string[]): boolean;
 export declare function provisionWorktree(directory: string, id: string, sessionId: string, options: WorktreeOptions): Promise<WorktreeProvisionResult>;
 /**
- * Removes a git worktree **without** `--force`.
+ * Removes a git worktree, **without** `--force` by default.
  *
  * On Windows (`process.platform === 'win32'`), retries up to 3 times with a
  * 2-second delay when the error contains `EBUSY` or `EPERM` (DD-10). After
  * exhausting retries the worktree is abandoned — the function returns an
  * error but does NOT throw.
  *
- * @param worktreePath - Absolute path to the worktree directory to remove.
- * @param projectRoot  - Absolute path to the project root (a git repository)
- *                       used as `cwd` for the `git worktree remove` command.
- *                       Required because the worktree's parent directory may
- *                       not itself be a git repository.
+ * When `options.force` is set, the removal is escalated (issue #1708): if the
+ * default non-forced removal gives up (either a non-retryable error such as the
+ * "contains modified or untracked files, use --force" message on the first
+ * attempt, or EBUSY/EPERM retries exhausted on Windows), a single
+ * `git worktree remove --force` is attempted — but ONLY when `worktreePath`
+ * resolves inside the swarm-managed worktree base directory
+ * (`isPathUnderSwarmWorktreeBase`). A path outside that trusted base is NEVER
+ * force-removed even if `force` is requested. When `force` is not set, behavior
+ * is unchanged (non-force only; returns an error, does not throw, on exhaustion).
+ *
+ * @param worktreePath        - Absolute path to the worktree directory to remove.
+ * @param projectRoot         - Absolute path to the project root (a git repository)
+ *                              used as `cwd` for the `git worktree remove` command.
+ *                              Required because the worktree's parent directory may
+ *                              not itself be a git repository.
+ * @param options             - Optional escalation controls.
+ * @param options.force       - When true, opt into the forced-fallback removal
+ *                              described above (scoped to the trusted base).
+ * @param options.worktreeDir - The configured worktree-dir override, if any, so
+ *                              the containment check trusts the same base
+ *                              `provisionWorktree` used.
  * @returns `{ success: true }` on success or `{ error: string }` on failure.
  */
-export declare function removeWorktree(worktreePath: string, projectRoot: string): Promise<RemoveSuccess | RemoveFailure>;
+export declare function removeWorktree(worktreePath: string, projectRoot: string, options?: {
+    force?: boolean;
+    worktreeDir?: string;
+}): Promise<RemoveSuccess | RemoveFailure>;
 /**
  * Checks whether a worktree is clean — no uncommitted changes AND no
  * untracked files.

package/dist/worktree/index.d.ts

@@ -1,5 +1,5 @@
 export type { AutoCommitSkip, AutoCommitSuccess, CleanCheckFailure, CleanCheckSuccess, CleanFailure, CleanSuccess, ProvisionFailure, ProvisionSuccess, RemoveFailure, RemoveSuccess, } from './core';
-export { _internals as coreInternals, assertCleanWorkingTree, autoCommitDirty, checkPathBudget, cleanUntrackedFiles, isCleanWorktree, makeWorktreeBranchName, provisionWorktree, removeWorktree, shortenWorktreePath, } from './core';
+export { _internals as coreInternals, assertCleanWorkingTree, autoCommitDirty, checkPathBudget, cleanUntrackedFiles, isCleanWorktree, isPathUnderSwarmWorktreeBase, makeWorktreeBranchName, provisionWorktree, removeWorktree, resolveWorktreeBaseDir, shortenWorktreePath, } from './core';
 export type { CleanupFailure, CleanupSuccess, ConflictHandlingError, ConflictInfo, DirtyMergeFailure, DirtyMergePartial, DirtyMergeSuccess, MergeConflict, MergeFailure, MergeSuccess, OrphanCleanupResult, StartupRecoveryResult, } from './merge';
 export { _internals as mergeInternals, attemptMergeBackFromDirty, cleanupOrphanedBranches, getMergeStrategy, handleMergeConflict, mergeLaneBranch, postMergeCleanup, startupOrphanRecovery, } from './merge';
 export * from './types';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-swarm",
-	"version": "7.108.0",
+	"version": "7.109.1",
 	"description": "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",