opencode-swarm 7.179.1 → 7.180.1

package/dist/cli/{index-zbhvr9st.js → index-n5carmk0.js}

@@ -1,24 +1,22 @@
 // @bun
 import {
   validateSwarmPath
-} from "./index-s4bkey0q.js";
+} from "./index-gc6h1fmf.js";
 import {
   bunSpawn
 } from "./index-2s7dvzff.js";
-import {
-  atomicWriteSwarmFileSync
-} from "./index-ne9zamcs.js";
 import {
   canonicalRootKeyFresh
 } from "./index-1xnse449.js";
 import {
-  init_git_executable,
-  resolveGitExecutable
-} from "./index-zz7gzw57.js";
+  atomicWriteSwarmFileSync
+} from "./index-989v83pb.js";
 import {
   advisoryWarn,
-  init_warning_buffer
-} from "./index-4ddpvd5c.js";
+  init_git_executable,
+  init_warning_buffer,
+  resolveGitExecutable
+} from "./index-zxdawwc7.js";
 import {
   SWARM_WORKTREE_DIR_NAME,
   init_constants
@@ -244,7 +242,7 @@ var _internals2 = {
     symlinkSync: fs2.symlinkSync
   },
   writeScopeToDisk: async (directory, taskId, files) => {
-    const { writeScopeToDisk: realWrite } = await import("./scope-persistence-d0358pw7.js");
+    const { writeScopeToDisk: realWrite } = await import("./scope-persistence-xeg4khwk.js");
     return realWrite(directory, taskId, files);
   },
   writeLaneProfileToDisk: async (_worktreePath, _laneIndex, _envOverrides) => {

package/dist/cli/{index-h4nh6s8b.js → index-nhxykfyy.js}

@@ -5,7 +5,7 @@ import {
   batchDurabilityClass,
   classifyDbWriteError,
   getProjectDb
-} from "./index-nzekzzs2.js";
+} from "./index-bv4b8tpa.js";
 import {
   _internals,
   canonicalRootKeyFresh

package/dist/cli/{index-pskba939.js → index-rejpbgxp.js}

@@ -9,7 +9,7 @@ import {
   readEvaluationRun,
   saveEvaluationRun,
   saveTaskSetSnapshot
-} from "./index-g6nyk713.js";
+} from "./index-s0zgz4p1.js";
 import {
   canonicalHash,
   computeCandidateInputContentHash,

package/dist/cli/{index-9s1xzvnn.js → index-rp4akjrm.js}

@@ -21,7 +21,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.179.1",
+    version: "7.180.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",
@@ -327,7 +327,7 @@ function resolveExternalSkillsConfig(input) {
   };
   return merged;
 }
-var _internals, SEPARATORS, CANONICAL_ROLES_LONGEST_FIRST, CANONICAL_ROLES_SET, AgentReasoningConfigSchema, AgentThinkingConfigSchema, FALLBACK_MODELS_MAX = 3, AgentOverrideConfigSchema, SwarmConfigSchema, ModelPricingConfigSchema, PricingConfigSchema, HooksConfigSchema, ScoringWeightsSchema, DecisionDecaySchema, TokenRatiosSchema, ScoringConfigSchema, ContextBudgetConfigSchema, EvidenceConfigSchema, GateFeatureSchema, PlaceholderScanConfigSchema, QualityBudgetConfigSchema, GATE_SECTION_SCHEMAS, GateConfigSchema, GATE_CONFIG_KNOWN_SECTION_KEYS, GATE_CONFIG_READERS, PipelineConfigSchema, PhaseCompleteConfigSchema, SummaryConfigSchema, RetentionConfigSchema, ReviewPassesConfigSchema, AUTO_REVIEW_V8_BURN_IN_DECISION, AutoReviewFinalConfigSchema, AutoReviewConfigObjectSchema, AutoReviewConfigSchema, AdversarialDetectionConfigSchema, AdversarialTestingConfigSchemaBase, AdversarialTestingConfigSchema, IntegrationAnalysisConfigSchema, DocsConfigSchema, DesignDocsConfigSchema, GitConfigSchema, UIReviewConfigSchema, CompactionAdvisoryConfigSchema, LintConfigSchema, SecretscanConfigSchema, GuardrailsProfileSchema, DEFAULT_AGENT_PROFILES, DEFAULT_ARCHITECT_PROFILE, GuardrailsConfigSchema, WatchdogConfigSchema, SelfReviewConfigSchema, ToolFilterConfigSchema, PlanCursorConfigSchema, ContextMapConfigSchema, RepoGraphConfigSchema, INVALID_CHECKPOINT_PROTO_FIELD = "__swarm_invalid_checkpoint_proto__", FORBIDDEN_CHECKPOINT_CONFIG_KEYS, CheckpointConfigSchema, ApplyPatchConfigSchema, AutomationModeSchema, AutomationCapabilitiesSchema, AutomationConfigSchemaBase, AutomationConfigSchema, KnowledgeConfigSchema, LearningConfigSchema, ConsensusConfigSchema, OtlpExportConfigSchema, ObservabilityConfigSchema, MemoryConfigSchema, CuratorConfigSchema, ArchitecturalSupervisionConfigSchema, KnowledgeApplicationConfigSchema, SkillPropagationAudienceSchema, SkillPropagationConfigSchema, HarnessRelativePathSchema, HarnessEvolutionConfigSchema, DEFAULT_HARNESS_EVOLUTION_CONFIG, SkillImproverConfigSchema, SkillsConfigSchema, SkillOptConfigSchema, DEFAULT_SKILL_OPT_CONFIG, SpecWriterConfigSchema, SlopDetectorConfigSchema, IncrementalVerifyConfigSchema, CompactionConfigSchema, PrmConfigSchema, AgentAuthorityRuleSchema, AuthorityConfigSchema, GeneralCouncilMemberConfigSchema, GeneralCouncilConfigSchema, CouncilConfigSchema, PrMonitorConfigSchema, ParallelizationConfigSchema, WorktreeIsolationConfigSchema, LeanTurboConfigSchema, EpicConfigSchema, StandardTurboConfigSchema, LeanTurboStrategyConfigSchema, TurboConfigSchema, ExternalSkillCandidateSourceTypeSchema, ExternalSkillCandidateEvaluationVerdictSchema, DiscoverySourceSchema, ExternalSkillCandidateSchema, ExternalSkillsConfigSchema, DEFAULT_EXTERNAL_SKILLS_CONFIG, DEFAULT_SKILLS_CONFIG, DEFAULT_PR_REVIEW_RESILIENCE_CONFIG, PrReviewResilienceConfigSchema, ReviewRoutingConfigSchema, DEFAULT_REVIEW_ROUTING_CONFIG, LaneLivenessWatchdogConfigSchema, DispatchProtectionConfigSchema, DashboardConfigSchema, DEFAULT_PR_REVIEW_LEGACY_TRANSCRIPT_COMPATIBILITY = false, PluginConfigSchema;
+var _internals, SEPARATORS, CANONICAL_ROLES_LONGEST_FIRST, CANONICAL_ROLES_SET, AgentReasoningConfigSchema, AgentThinkingConfigSchema, FALLBACK_MODELS_MAX = 3, AgentOverrideConfigSchema, SwarmConfigSchema, ModelPricingConfigSchema, PricingConfigSchema, HooksConfigSchema, ScoringWeightsSchema, DecisionDecaySchema, TokenRatiosSchema, ScoringConfigSchema, ContextBudgetConfigSchema, EvidenceConfigSchema, GateFeatureSchema, PlaceholderScanConfigSchema, QualityBudgetConfigSchema, GATE_SECTION_SCHEMAS, GateConfigSchema, GATE_CONFIG_KNOWN_SECTION_KEYS, GATE_CONFIG_READERS, PipelineConfigSchema, PhaseCompleteConfigSchema, SummaryConfigSchema, RetentionConfigSchema, ReviewPassesConfigSchema, AUTO_REVIEW_V8_BURN_IN_DECISION, AutoReviewFinalConfigSchema, AutoReviewConfigObjectSchema, AutoReviewConfigSchema, AdversarialDetectionConfigSchema, AdversarialTestingConfigSchemaBase, AdversarialTestingConfigSchema, IntegrationAnalysisConfigSchema, DocsConfigSchema, DesignDocsConfigSchema, GitConfigSchema, UIReviewConfigSchema, CompactionAdvisoryConfigSchema, LintConfigSchema, SecretscanConfigSchema, GuardrailsProfileSchema, DEFAULT_AGENT_PROFILES, DEFAULT_ARCHITECT_PROFILE, GuardrailsConfigSchema, WatchdogConfigSchema, SelfReviewConfigSchema, ToolFilterConfigSchema, PlanCursorConfigSchema, ContextMapConfigSchema, RepoGraphConfigSchema, INVALID_CHECKPOINT_PROTO_FIELD = "__swarm_invalid_checkpoint_proto__", FORBIDDEN_CHECKPOINT_CONFIG_KEYS, CheckpointConfigSchema, ApplyPatchConfigSchema, AutomationModeSchema, AutomationCapabilitiesSchema, AutomationConfigSchemaBase, AutomationConfigSchema, KnowledgeConfigSchema, LearningConfigSchema, ConsensusConfigSchema, OtlpExportConfigSchema, ObservabilityConfigSchema, MemoryConfigSchema, CuratorConfigSchema, ArchitecturalSupervisionConfigSchema, KnowledgeApplicationConfigSchema, SkillPropagationAudienceSchema, SkillPropagationConfigSchema, HarnessRelativePathSchema, HarnessEvolutionConfigSchema, DEFAULT_HARNESS_EVOLUTION_CONFIG, SkillImproverConfigSchema, SkillsConfigSchema, SkillOptConfigSchema, DEFAULT_SKILL_OPT_CONFIG, SpecWriterConfigSchema, SlopDetectorConfigSchema, IncrementalVerifyConfigSchema, CompactionConfigSchema, PrmConfigSchema, AgentAuthorityRuleSchema, AuthorityConfigSchema, GeneralCouncilMemberConfigSchema, GeneralCouncilConfigSchema, CouncilConfigSchema, PrMonitorConfigSchema, PrFeedbackLoopConfigSchema, ParallelizationConfigSchema, WorktreeIsolationConfigSchema, LeanTurboConfigSchema, EpicConfigSchema, StandardTurboConfigSchema, LeanTurboStrategyConfigSchema, TurboConfigSchema, ExternalSkillCandidateSourceTypeSchema, ExternalSkillCandidateEvaluationVerdictSchema, DiscoverySourceSchema, ExternalSkillCandidateSchema, ExternalSkillsConfigSchema, DEFAULT_EXTERNAL_SKILLS_CONFIG, DEFAULT_SKILLS_CONFIG, DEFAULT_PR_REVIEW_RESILIENCE_CONFIG, PrReviewResilienceConfigSchema, ReviewRoutingConfigSchema, DEFAULT_REVIEW_ROUTING_CONFIG, LaneLivenessWatchdogConfigSchema, DispatchProtectionConfigSchema, DashboardConfigSchema, DEFAULT_PR_REVIEW_LEGACY_TRANSCRIPT_COMPATIBILITY = false, PluginConfigSchema;
 var init_schema = __esm(() => {
   init_zod();
   init_package();
@@ -1489,6 +1489,12 @@ var init_schema = __esm(() => {
     event_delivery: exports_external.enum(["advisory", "prompt"]).default("prompt"),
     auto_subscribe_on_pr_create: exports_external.boolean().default(true)
   }).strict();
+  PrFeedbackLoopConfigSchema = exports_external.object({
+    enabled: exports_external.boolean().default(false),
+    max_actions_per_pr: exports_external.number().int().min(1).max(10).default(3),
+    max_session_actions: exports_external.number().int().min(1).max(50).default(10),
+    publication: exports_external.enum(["none"]).default("none")
+  });
   ParallelizationConfigSchema = exports_external.object({
     enabled: exports_external.boolean().default(false),
     maxConcurrentTasks: exports_external.number().int().min(1).max(64).default(1),
@@ -1748,6 +1754,9 @@ var init_schema = __esm(() => {
     integration_analysis: IntegrationAnalysisConfigSchema.optional().describe("Integration analysis settings."),
     docs: DocsConfigSchema.optional().describe("Documentation synthesizer (docs agent) settings."),
     design_docs: DesignDocsConfigSchema.optional().describe("Structured design-doc generation (issue #1080, docs_design agent) \u2014 opt-in."),
+    speckit_checkoff: exports_external.object({
+      enabled: exports_external.boolean().default(false).describe("Check off mapped Spec-Kit tasks in the source tasks.md when Swarm completes a plan task (issue #2501). Off by default \u2014 write-back to user-owned files is opt-in.")
+    }).optional().describe("Spec-Kit tasks.md check-off round trip (issue #2501) \u2014 opt-in, never on by default."),
     git: GitConfigSchema.optional().describe("Git executable resolution override (issue #2236 hardening)."),
     ui_review: UIReviewConfigSchema.optional().describe("UI/UX review (designer agent) settings."),
     compaction_advisory: CompactionAdvisoryConfigSchema.optional().describe("Compaction advisory settings."),
@@ -1949,6 +1958,7 @@ var init_schema = __esm(() => {
         cleanup_timeout_ms: 2000
       }
     })).describe("Full-auto autonomous orchestration with critic oversight: permission policy, denial accounting, oversight cadence triggers (v2 preserves v1 fields so existing configs load unchanged)."),
+    pr_feedback_loop: PrFeedbackLoopConfigSchema.optional().describe("Autonomous PR babysitting settling loop (issue #2502) \u2014 triple opt-in with pr_monitor.enabled + pr_monitor.auto_pr_feedback; off by default; publication profile is none-only."),
     pr_monitor: PrMonitorConfigSchema.optional().describe("GitHub PR subscription and polling (FR-001) \u2014 disabled by default; opt-in for real-time PR status updates."),
     external_skills: ExternalSkillsConfigSchema.optional().describe("External skills: candidate model, discovery, and quarantine store (FR-001) \u2014 all subsystems opt-in."),
     skills: SkillsConfigSchema.optional().describe("Opt-in gate for the 7 skill_* management tools (FR-004). Default false: the tools are host-denied for every agent except skill_improver (genuinely unreachable, not merely unlisted \u2014 issue #2528)."),
@@ -1957,4 +1967,4 @@ var init_schema = __esm(() => {
   });
 });
 
-export { init_package, package_default, DEFAULT_MODEL_CONTEXT_TOKENS, init_context_window, _internals, isKnownCanonicalRole, getCanonicalAgentRole, resolveGeneratedAgentRole, stripKnownSwarmPrefix, AgentReasoningConfigSchema, AgentThinkingConfigSchema, FALLBACK_MODELS_MAX, AgentOverrideConfigSchema, SwarmConfigSchema, ModelPricingConfigSchema, PricingConfigSchema, HooksConfigSchema, ScoringWeightsSchema, DecisionDecaySchema, TokenRatiosSchema, ScoringConfigSchema, ContextBudgetConfigSchema, EvidenceConfigSchema, GateFeatureSchema, PlaceholderScanConfigSchema, QualityBudgetConfigSchema, GATE_SECTION_SCHEMAS, GateConfigSchema, GATE_CONFIG_KNOWN_SECTION_KEYS, GATE_CONFIG_READERS, PipelineConfigSchema, PhaseCompleteConfigSchema, SummaryConfigSchema, RetentionConfigSchema, ReviewPassesConfigSchema, AUTO_REVIEW_V8_BURN_IN_DECISION, AutoReviewConfigSchema, resolveAutoReviewConfig, AdversarialDetectionConfigSchema, AdversarialTestingConfigSchema, IntegrationAnalysisConfigSchema, DocsConfigSchema, DesignDocsConfigSchema, GitConfigSchema, UIReviewConfigSchema, CompactionAdvisoryConfigSchema, LintConfigSchema, SecretscanConfigSchema, GuardrailsProfileSchema, DEFAULT_AGENT_PROFILES, DEFAULT_ARCHITECT_PROFILE, GuardrailsConfigSchema, WatchdogConfigSchema, SelfReviewConfigSchema, resolveGuardrailsConfig, ToolFilterConfigSchema, PlanCursorConfigSchema, ContextMapConfigSchema, RepoGraphConfigSchema, CheckpointConfigSchema, ApplyPatchConfigSchema, AutomationModeSchema, AutomationCapabilitiesSchema, AutomationConfigSchema, KnowledgeConfigSchema, LearningConfigSchema, ConsensusConfigSchema, OtlpExportConfigSchema, ObservabilityConfigSchema, MemoryConfigSchema, CuratorConfigSchema, ArchitecturalSupervisionConfigSchema, KnowledgeApplicationConfigSchema, SkillPropagationConfigSchema, HarnessEvolutionConfigSchema, DEFAULT_HARNESS_EVOLUTION_CONFIG, SkillImproverConfigSchema, SkillsConfigSchema, SkillOptConfigSchema, DEFAULT_SKILL_OPT_CONFIG, SpecWriterConfigSchema, SlopDetectorConfigSchema, IncrementalVerifyConfigSchema, CompactionConfigSchema, PrmConfigSchema, AgentAuthorityRuleSchema, AuthorityConfigSchema, GeneralCouncilConfigSchema, CouncilConfigSchema, PrMonitorConfigSchema, ParallelizationConfigSchema, WorktreeIsolationConfigSchema, LeanTurboConfigSchema, EpicConfigSchema, StandardTurboConfigSchema, LeanTurboStrategyConfigSchema, TurboConfigSchema, ExternalSkillCandidateSourceTypeSchema, ExternalSkillCandidateEvaluationVerdictSchema, DiscoverySourceSchema, ExternalSkillCandidateSchema, ExternalSkillsConfigSchema, DEFAULT_EXTERNAL_SKILLS_CONFIG, DEFAULT_SKILLS_CONFIG, resolveExternalSkillsConfig, DEFAULT_PR_REVIEW_RESILIENCE_CONFIG, PrReviewResilienceConfigSchema, ReviewRoutingConfigSchema, DEFAULT_REVIEW_ROUTING_CONFIG, LaneLivenessWatchdogConfigSchema, DispatchProtectionConfigSchema, DashboardConfigSchema, DEFAULT_PR_REVIEW_LEGACY_TRANSCRIPT_COMPATIBILITY, PluginConfigSchema, init_schema };
+export { init_package, package_default, DEFAULT_MODEL_CONTEXT_TOKENS, init_context_window, _internals, isKnownCanonicalRole, getCanonicalAgentRole, resolveGeneratedAgentRole, stripKnownSwarmPrefix, AgentReasoningConfigSchema, AgentThinkingConfigSchema, FALLBACK_MODELS_MAX, AgentOverrideConfigSchema, SwarmConfigSchema, ModelPricingConfigSchema, PricingConfigSchema, HooksConfigSchema, ScoringWeightsSchema, DecisionDecaySchema, TokenRatiosSchema, ScoringConfigSchema, ContextBudgetConfigSchema, EvidenceConfigSchema, GateFeatureSchema, PlaceholderScanConfigSchema, QualityBudgetConfigSchema, GATE_SECTION_SCHEMAS, GateConfigSchema, GATE_CONFIG_KNOWN_SECTION_KEYS, GATE_CONFIG_READERS, PipelineConfigSchema, PhaseCompleteConfigSchema, SummaryConfigSchema, RetentionConfigSchema, ReviewPassesConfigSchema, AUTO_REVIEW_V8_BURN_IN_DECISION, AutoReviewConfigSchema, resolveAutoReviewConfig, AdversarialDetectionConfigSchema, AdversarialTestingConfigSchema, IntegrationAnalysisConfigSchema, DocsConfigSchema, DesignDocsConfigSchema, GitConfigSchema, UIReviewConfigSchema, CompactionAdvisoryConfigSchema, LintConfigSchema, SecretscanConfigSchema, GuardrailsProfileSchema, DEFAULT_AGENT_PROFILES, DEFAULT_ARCHITECT_PROFILE, GuardrailsConfigSchema, WatchdogConfigSchema, SelfReviewConfigSchema, resolveGuardrailsConfig, ToolFilterConfigSchema, PlanCursorConfigSchema, ContextMapConfigSchema, RepoGraphConfigSchema, CheckpointConfigSchema, ApplyPatchConfigSchema, AutomationModeSchema, AutomationCapabilitiesSchema, AutomationConfigSchema, KnowledgeConfigSchema, LearningConfigSchema, ConsensusConfigSchema, OtlpExportConfigSchema, ObservabilityConfigSchema, MemoryConfigSchema, CuratorConfigSchema, ArchitecturalSupervisionConfigSchema, KnowledgeApplicationConfigSchema, SkillPropagationConfigSchema, HarnessEvolutionConfigSchema, DEFAULT_HARNESS_EVOLUTION_CONFIG, SkillImproverConfigSchema, SkillsConfigSchema, SkillOptConfigSchema, DEFAULT_SKILL_OPT_CONFIG, SpecWriterConfigSchema, SlopDetectorConfigSchema, IncrementalVerifyConfigSchema, CompactionConfigSchema, PrmConfigSchema, AgentAuthorityRuleSchema, AuthorityConfigSchema, GeneralCouncilConfigSchema, CouncilConfigSchema, PrMonitorConfigSchema, PrFeedbackLoopConfigSchema, ParallelizationConfigSchema, WorktreeIsolationConfigSchema, LeanTurboConfigSchema, EpicConfigSchema, StandardTurboConfigSchema, LeanTurboStrategyConfigSchema, TurboConfigSchema, ExternalSkillCandidateSourceTypeSchema, ExternalSkillCandidateEvaluationVerdictSchema, DiscoverySourceSchema, ExternalSkillCandidateSchema, ExternalSkillsConfigSchema, DEFAULT_EXTERNAL_SKILLS_CONFIG, DEFAULT_SKILLS_CONFIG, resolveExternalSkillsConfig, DEFAULT_PR_REVIEW_RESILIENCE_CONFIG, PrReviewResilienceConfigSchema, ReviewRoutingConfigSchema, DEFAULT_REVIEW_ROUTING_CONFIG, LaneLivenessWatchdogConfigSchema, DispatchProtectionConfigSchema, DashboardConfigSchema, DEFAULT_PR_REVIEW_LEGACY_TRANSCRIPT_COMPATIBILITY, PluginConfigSchema, init_schema };

package/dist/cli/{index-g6nyk713.js → index-s0zgz4p1.js}

@@ -11,7 +11,7 @@ import {
   assertProjectRoot,
   atomicWriteFile,
   withEvidenceLock
-} from "./index-f2v90gfc.js";
+} from "./index-ea9fk6v0.js";
 import {
   exports_external,
   init_zod

package/dist/cli/{index-aqpwm350.js → index-tnhk72rs.js}

@@ -1,14 +1,14 @@
 // @bun
 import {
   observeStoreHealth
-} from "./index-yfpswnjt.js";
+} from "./index-516j9vsk.js";
 import {
   telemetry
-} from "./index-qt0793qm.js";
+} from "./index-6mwha20t.js";
 import {
   init_schema,
   stripKnownSwarmPrefix
-} from "./index-9s1xzvnn.js";
+} from "./index-rp4akjrm.js";
 import {
   init_constants
 } from "./index-w872yykk.js";

package/dist/cli/{index-sj29n50e.js → index-v0par978.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   validateSwarmPath
-} from "./index-s4bkey0q.js";
+} from "./index-gc6h1fmf.js";
 import {
   bunWrite
 } from "./index-2s7dvzff.js";
@@ -18,21 +18,21 @@ import {
   releaseCoordinationLease,
   transitionCoordinationState,
   withCoordinationTransaction
-} from "./index-a11ztzs5.js";
+} from "./index-vmthakz0.js";
 import {
   getProjectDb,
   projectDbExists
-} from "./index-nzekzzs2.js";
+} from "./index-bv4b8tpa.js";
 import {
   observeDelegationLedgerPressure
-} from "./index-yfpswnjt.js";
+} from "./index-516j9vsk.js";
 import {
   EvidenceLockTimeoutError,
   withEvidenceLock
-} from "./index-f2v90gfc.js";
+} from "./index-ea9fk6v0.js";
 import {
   telemetry
-} from "./index-qt0793qm.js";
+} from "./index-6mwha20t.js";
 import {
   canonicalRootKeyFresh,
   sameProjectRoot
@@ -4660,7 +4660,7 @@ async function reconcileLegacyCoderSettlements(directory, maxRecords, onReconcil
   const candidates = readDelegations(directory).filter((record) => record.normalizedAgent === "coder" && Boolean(record.legacyCoderSettlementTransfer) && Boolean(record.terminalResult)).slice(0, maxRecords);
   if (candidates.length === 0)
     return 0;
-  const { transferCoderSettlementToBackground } = await import("./coder-settlement-f1nmezzv.js");
+  const { transferCoderSettlementToBackground } = await import("./coder-settlement-b57917a3.js");
   let transferred = 0;
   for (const record of candidates) {
     try {

package/dist/cli/index-v7fx8q3z.js

@@ -0,0 +1,339 @@
+// @bun
+import {
+  tryAcquireLock
+} from "./index-ejhxgyvm.js";
+import {
+  atomicWriteFileAnyRoot,
+  atomicWriteSwarmFileSync
+} from "./index-989v83pb.js";
+import {
+  init_loader,
+  loadPluginConfig
+} from "./index-xj5z92qz.js";
+import {
+  init_logger,
+  log,
+  warn
+} from "./index-zgwm4ryv.js";
+
+// src/sdd/speckit-checkoff.ts
+init_loader();
+import { createHash } from "crypto";
+import * as fs from "fs";
+import * as path from "path";
+init_logger();
+var SPECKIT_CHECKOFF_LEDGER_REL = path.join(".swarm", "speckit-checkoff-ledger.json");
+var TASK_LINE_REGEX = /^\s*-\s+\[[ xX]\]\s+(T\d+)/;
+var FR_REF_REGEX = /(?:[A-Za-z0-9][A-Za-z0-9._-]*\/)?FR-\d{3}/g;
+var MAX_TASKS_FILE_BYTES = 512 * 1024;
+var FR_BARE_SUFFIX = /FR-\d{3}$/;
+function refsMatch(a, b) {
+  if (a === b)
+    return true;
+  const aBare = !a.includes("/");
+  const bBare = !b.includes("/");
+  if (aBare && !bBare && FR_BARE_SUFFIX.test(b) && b.endsWith(`/${a}`))
+    return true;
+  if (bBare && !aBare && FR_BARE_SUFFIX.test(a) && a.endsWith(`/${b}`))
+    return true;
+  return false;
+}
+function sha256(text) {
+  return createHash("sha256").update(text, "utf-8").digest("hex");
+}
+function readBounded(filePath) {
+  try {
+    const stat = fs.lstatSync(filePath);
+    if (!stat.isFile() || stat.size > MAX_TASKS_FILE_BYTES)
+      return null;
+    return fs.readFileSync(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function parseSpeckitTasksContent(content, namespaced, featureId) {
+  const tasks = [];
+  const taskLines = [];
+  for (const rawLine of content.replace(/\r\n/g, `
+`).split(`
+`)) {
+    const match = rawLine.match(TASK_LINE_REGEX);
+    if (!match)
+      continue;
+    const snapshot = rawLine.trim();
+    taskLines.push(snapshot.replace(/\[[xX]\]/g, "[ ]"));
+    const refs = [...snapshot.matchAll(FR_REF_REGEX)].map((m) => m[0]);
+    const frRefs = refs.map((ref) => namespaced && !ref.includes("/") ? `${featureId}/${ref}` : ref);
+    tasks.push({
+      taskId: match[1],
+      frRefs,
+      lineSnapshot: snapshot,
+      initiallyChecked: /\[x\]/i.test(snapshot)
+    });
+  }
+  return { tasks, taskLinesDigest: sha256(taskLines.join(`
+`)) };
+}
+function writeSpeckitCheckoffLedger(root, resolution) {
+  const features = [];
+  resolution.features.forEach((featureId, index) => {
+    const specRel = resolution.spec.sourcePaths[index] ?? `specs/${featureId}/spec.md`;
+    const tasksRelPath = `${path.dirname(specRel).split(path.sep).join("/")}/tasks.md`;
+    const content = readBounded(path.join(root, tasksRelPath));
+    if (content === null)
+      return;
+    const parsed = parseSpeckitTasksContent(content, resolution.namespaced, featureId);
+    if (parsed.tasks.length === 0)
+      return;
+    const requirementIds = resolution.featureRequirementIds[index] ?? [];
+    for (const task of parsed.tasks) {
+      const refs = new Set(task.frRefs);
+      for (const storyMatch of task.lineSnapshot.matchAll(/\[US(\d+)\]/gi)) {
+        const storyIndex = Number(storyMatch[1]) - 1;
+        const mapped = requirementIds[storyIndex];
+        if (mapped)
+          refs.add(mapped);
+      }
+      task.frRefs = [...refs];
+    }
+    features.push({
+      featureId,
+      tasksRelPath,
+      taskLinesDigest: parsed.taskLinesDigest,
+      tasks: parsed.tasks
+    });
+  });
+  const ledger = {
+    version: 1,
+    namespaced: resolution.namespaced,
+    projectedAt: new Date().toISOString(),
+    features
+  };
+  atomicWriteSwarmFileSync(path.join(root, SPECKIT_CHECKOFF_LEDGER_REL), `${JSON.stringify(ledger, null, 2)}
+`);
+}
+function readLedger(root) {
+  const raw = readBounded(path.join(root, SPECKIT_CHECKOFF_LEDGER_REL));
+  if (raw === null)
+    return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed?.version !== 1 || !Array.isArray(parsed.features))
+      return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function writeLedger(root, ledger) {
+  atomicWriteSwarmFileSync(path.join(root, SPECKIT_CHECKOFF_LEDGER_REL), `${JSON.stringify(ledger, null, 2)}
+`);
+}
+function normalizeCheckboxState(line) {
+  return line.replace(/\[[xX]\]/g, "[ ]");
+}
+function applyCheckoffEdit(taskEntry, _baselineContent, currentContent) {
+  const lines = currentContent.split(/(?=\r?\n)/);
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    const lineTrimmed = line.trim();
+    if (normalizeCheckboxState(lineTrimmed) !== normalizeCheckboxState(taskEntry.lineSnapshot)) {
+      const idMatch = line.match(TASK_LINE_REGEX);
+      if (idMatch && idMatch[1] === taskEntry.taskId) {
+        return {
+          applied: false,
+          content: currentContent,
+          reason: "task-line-changed"
+        };
+      }
+      continue;
+    }
+    if (/\[x\]/i.test(lineTrimmed)) {
+      return {
+        applied: false,
+        content: currentContent,
+        reason: "already-checked"
+      };
+    }
+    const boxIndex = line.indexOf("[ ]");
+    if (boxIndex === -1) {
+      return {
+        applied: false,
+        content: currentContent,
+        reason: "task-line-changed"
+      };
+    }
+    lines[i] = `${line.slice(0, boxIndex)}[x]${line.slice(boxIndex + 3)}`;
+    return { applied: true, content: lines.join(""), reason: "ok" };
+  }
+  return {
+    applied: false,
+    content: currentContent,
+    reason: "task-line-not-found"
+  };
+}
+function extractFrRefsFromText(text) {
+  return [...text.matchAll(FR_REF_REGEX)].map((m) => m[0]);
+}
+async function propagateSpeckitCheckoff(directory, completed, options) {
+  if (!options.enabled) {
+    return { ran: false, reason: "disabled", features: [] };
+  }
+  const root = path.resolve(directory);
+  const ledger = readLedger(root);
+  if (!ledger) {
+    return { ran: false, reason: "no-ledger", features: [] };
+  }
+  const completedRefs = [
+    ...completed.frRefs,
+    ...extractFrRefsFromText(`${completed.text ?? ""}`)
+  ];
+  const results = [];
+  let anyMatch = false;
+  let ledgerDirty = false;
+  const checkedAt = new Date().toISOString();
+  for (const feature of ledger.features) {
+    const result = {
+      featureId: feature.featureId,
+      tasksRelPath: feature.tasksRelPath,
+      checked: [],
+      reopenedSkipped: [],
+      stale: false,
+      refused: []
+    };
+    const matchedTasks = feature.tasks.filter((task) => task.frRefs.some((taskRef) => completedRefs.some((completedRef) => refsMatch(completedRef, taskRef))));
+    const hasSwarmChecked = feature.tasks.some((t) => t.swarmCheckedAt);
+    if (matchedTasks.length === 0 && !hasSwarmChecked) {
+      results.push(result);
+      continue;
+    }
+    if (matchedTasks.length > 0)
+      anyMatch = true;
+    const tasksAbs = path.join(root, feature.tasksRelPath);
+    let current = readBounded(tasksAbs);
+    if (current === null) {
+      result.stale = true;
+      result.refused.push(...matchedTasks.map((t) => t.taskId));
+      results.push(result);
+      continue;
+    }
+    const currentDigest = parseSpeckitTasksContent(current, ledger.namespaced, feature.featureId).taskLinesDigest;
+    if (currentDigest !== feature.taskLinesDigest) {
+      result.stale = true;
+      result.refused.push(...matchedTasks.map((t) => t.taskId));
+      results.push(result);
+      continue;
+    }
+    for (const task of feature.tasks) {
+      if (!task.swarmCheckedAt)
+        continue;
+      const line = current.replace(/\r\n/g, `
+`).split(`
+`).find((l) => normalizeCheckboxState(l.trim()) === normalizeCheckboxState(task.lineSnapshot));
+      if (line !== undefined && /\[ \]/.test(line)) {
+        result.reopenedSkipped.push(task.taskId);
+      }
+    }
+    let contentChanged = false;
+    for (const task of matchedTasks) {
+      if (task.swarmCheckedAt && result.reopenedSkipped.includes(task.taskId)) {
+        continue;
+      }
+      const outcome = applyCheckoffEdit(task, current, current);
+      if (outcome.applied) {
+        current = outcome.content;
+        contentChanged = true;
+        task.swarmCheckedAt = checkedAt;
+        ledgerDirty = true;
+        result.checked.push(task.taskId);
+      } else if (outcome.reason === "already-checked") {
+        if (!task.swarmCheckedAt) {
+          task.swarmCheckedAt = checkedAt;
+          ledgerDirty = true;
+        }
+      } else {
+        result.refused.push(task.taskId);
+      }
+    }
+    if (contentChanged && current !== null) {
+      const lock = await tryAcquireLock(root, feature.tasksRelPath, "speckit-checkoff", completed.taskId);
+      if (!lock.acquired) {
+        result.refused.push(...result.checked);
+        result.checked = [];
+        results.push(result);
+        continue;
+      }
+      try {
+        const latest = readBounded(tasksAbs);
+        if (latest === null || latest !== current) {
+          if (latest !== null) {
+            let reconciled = latest;
+            let ok = true;
+            for (const taskId of [...result.checked]) {
+              const task = feature.tasks.find((t) => t.taskId === taskId);
+              const outcome = applyCheckoffEdit(task, latest, reconciled);
+              if (outcome.applied) {
+                reconciled = outcome.content;
+              } else if (outcome.reason !== "already-checked") {
+                ok = false;
+                result.checked = result.checked.filter((id) => id !== taskId);
+                result.refused.push(taskId);
+              }
+            }
+            if (ok && result.checked.length > 0) {
+              await atomicWriteFileAnyRoot(tasksAbs, reconciled);
+              current = reconciled;
+            } else {
+              current = latest;
+            }
+          } else {
+            result.refused.push(...result.checked);
+            result.checked = [];
+          }
+        } else {
+          await atomicWriteFileAnyRoot(tasksAbs, current);
+        }
+      } finally {
+        if (lock.lock._release) {
+          await lock.lock._release().catch(() => {});
+        }
+      }
+    }
+    results.push(result);
+  }
+  if (ledgerDirty) {
+    try {
+      writeLedger(root, ledger);
+    } catch (err) {
+      warn(`[speckit-checkoff] ledger update failed after check-off: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  return {
+    ran: true,
+    features: results,
+    unmatched: !anyMatch || undefined
+  };
+}
+async function maybePropagateSpeckitCheckoff(directory, completed) {
+  try {
+    const config = loadPluginConfig(directory);
+    if (config?.speckit_checkoff?.enabled !== true)
+      return;
+    const result = await propagateSpeckitCheckoff(directory, completed, {
+      enabled: true
+    });
+    if (result.ran && result.features.some((f) => f.checked.length > 0)) {
+      log(`[speckit-checkoff] task ${completed.taskId} checked off: ${result.features.map((f) => `${f.featureId}:[${f.checked.join(", ")}]`).join(" ")}`);
+    }
+  } catch (err) {
+    warn(`[speckit-checkoff] propagation for ${completed.taskId} failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+var _internals = {
+  applyCheckoffEdit,
+  parseSpeckitTasksContent,
+  readBounded,
+  sha256
+};
+
+export { SPECKIT_CHECKOFF_LEDGER_REL, parseSpeckitTasksContent, writeSpeckitCheckoffLedger, applyCheckoffEdit, propagateSpeckitCheckoff, maybePropagateSpeckitCheckoff, _internals };

package/dist/cli/{index-a11ztzs5.js → index-vmthakz0.js}

@@ -4,7 +4,7 @@ import {
   getProjectDb,
   projectDbExists,
   withImmediateTransaction
-} from "./index-nzekzzs2.js";
+} from "./index-bv4b8tpa.js";
 
 // src/db/coordination-store.ts
 import { createHash } from "crypto";

package/dist/cli/{index-b567t0cr.js → index-wx3wz7ya.js}

@@ -2,32 +2,34 @@
 import {
   derivePlanId,
   derivePlanIdentityHash
-} from "./index-a11ztzs5.js";
+} from "./index-vmthakz0.js";
 import {
   getProjectDb,
   projectDbExists,
   withImmediateTransaction,
   withProjectDbReadOnly
-} from "./index-nzekzzs2.js";
+} from "./index-bv4b8tpa.js";
 import {
   assertProjectRoot,
   withEvidenceLock
-} from "./index-f2v90gfc.js";
+} from "./index-ea9fk6v0.js";
 import {
   emit
-} from "./index-qt0793qm.js";
+} from "./index-6mwha20t.js";
 import {
   ExecutionProfileSchema,
   PlanSchema,
   TaskStatusSchema,
-  init_loader,
-  loadPluginConfig,
   normalizeCurrentPhaseInPlace
-} from "./index-m1w40kfw.js";
+} from "./index-gx2vp8gx.js";
+import {
+  init_loader,
+  loadPluginConfig
+} from "./index-xj5z92qz.js";
 import {
   init_package,
   package_default
-} from "./index-9s1xzvnn.js";
+} from "./index-rp4akjrm.js";
 import {
   criticalWarn,
   init_logger,