opencode-swarm 7.79.1 → 7.79.4

package/dist/index.js

@@ -69,7 +69,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.79.1",
+    version: "7.79.4",
     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",
@@ -90,7 +90,7 @@ var init_package = __esm(() => {
     license: "MIT",
     repository: {
       type: "git",
-      url: "https://github.com/zaxbysauce/opencode-swarm.git"
+      url: "https://github.com/ZaxbyHub/opencode-swarm.git"
     },
     publishConfig: {
       access: "public",
@@ -129,6 +129,7 @@ var init_package = __esm(() => {
       ".opencode/skills/critic-gate",
       ".opencode/skills/execute",
       ".opencode/skills/phase-wrap",
+      ".opencode/skills/loop",
       "tests/fixtures/memory-recall",
       "README.md",
       "LICENSE"
@@ -17210,7 +17211,8 @@ var init_bundled_skills = __esm(() => {
     "plan",
     "critic-gate",
     "execute",
-    "phase-wrap"
+    "phase-wrap",
+    "loop"
   ];
   syncedProjectSkillTargets = new Set;
 });
@@ -27658,8 +27660,16 @@ var init_tool_policy = __esm(() => {
   }).sort());
   SWARM_COMMAND_TOOL_ALLOWLIST = lazySet(() => VALID_COMMANDS.filter((cmd) => COMMAND_REGISTRY[cmd]?.toolPolicy === "agent"));
   HUMAN_ONLY_SWARM_COMMANDS = lazySet(() => VALID_COMMANDS.filter((cmd) => {
-    const policy = COMMAND_REGISTRY[cmd]?.toolPolicy;
-    return policy === "human-only" || policy === "restricted";
+    const entry = COMMAND_REGISTRY[cmd];
+    const policy = entry?.toolPolicy;
+    if (policy === "human-only" || policy === "restricted")
+      return true;
+    if (entry?.aliasOf) {
+      const target = COMMAND_REGISTRY[entry.aliasOf];
+      const targetPolicy = target?.toolPolicy;
+      return targetPolicy === "human-only" || targetPolicy === "restricted";
+    }
+    return false;
   }));
   NO_ARGS = lazySet(() => VALID_COMMANDS.filter((cmd) => COMMAND_REGISTRY[cmd]?.toolNoArgs === true));
   SUMMARY_ID_PATTERN = /^[A-Za-z][A-Za-z0-9_-]{0,63}$/;
@@ -78781,6 +78791,116 @@ var init_learning = __esm(() => {
   init_learning_metrics();
 });
 
+// src/commands/loop.ts
+function sanitizeObjective(raw) {
+  const collapsed = raw.replace(/\s+/g, " ").trim();
+  const stripped = collapsed.replace(/\[\s*MODE\s*:[^\]]*\]/gi, "");
+  const normalized = stripped.replace(/\s+/g, " ").trim();
+  if (normalized.length <= MAX_OBJECTIVE_LEN)
+    return normalized;
+  return `${normalized.slice(0, MAX_OBJECTIVE_LEN)}…`;
+}
+function isPositiveInteger(raw) {
+  return /^\d+$/.test(raw);
+}
+function parseArgs7(args2) {
+  const result = {
+    maxCycles: DEFAULT_MAX_CYCLES,
+    autonomy: DEFAULT_AUTONOMY,
+    depth: DEFAULT_DEPTH2,
+    resume: false,
+    rest: []
+  };
+  let i2 = 0;
+  while (i2 < args2.length) {
+    const token = args2[i2];
+    if (token === "--max-cycles") {
+      if (i2 + 1 >= args2.length) {
+        return { ...result, error: `Flag "${token}" requires a value` };
+      }
+      const value = args2[++i2];
+      if (!isPositiveInteger(value) || Number(value) < MIN_MAX_CYCLES || Number(value) > MAX_MAX_CYCLES) {
+        return {
+          ...result,
+          error: `Invalid --max-cycles value "${value}". Must be an integer between ${MIN_MAX_CYCLES} and ${MAX_MAX_CYCLES}.`
+        };
+      }
+      result.maxCycles = Number(value);
+    } else if (token === "--autonomy") {
+      if (i2 + 1 >= args2.length) {
+        return { ...result, error: `Flag "${token}" requires a value` };
+      }
+      const value = args2[++i2];
+      if (!AUTONOMY_LEVELS.has(value)) {
+        return {
+          ...result,
+          error: `Invalid autonomy "${value}". Must be one of: checkpoint, auto.`
+        };
+      }
+      result.autonomy = value;
+    } else if (token === "--depth") {
+      if (i2 + 1 >= args2.length) {
+        return { ...result, error: `Flag "${token}" requires a value` };
+      }
+      const value = args2[++i2];
+      if (!DEPTHS2.has(value)) {
+        return {
+          ...result,
+          error: `Invalid depth "${value}". Must be one of: standard, exhaustive.`
+        };
+      }
+      result.depth = value;
+    } else if (token === "--resume") {
+      result.resume = true;
+    } else if (token.startsWith("--")) {
+      return { ...result, error: `Unknown flag "${token}"` };
+    } else {
+      result.rest.push(token);
+    }
+    i2++;
+  }
+  return result;
+}
+async function handleLoopCommand(_directory, args2) {
+  const parsed = parseArgs7(args2);
+  if (parsed.error) {
+    return `Error: ${parsed.error}
+
+${USAGE7}`;
+  }
+  const objective = sanitizeObjective(parsed.rest.join(" "));
+  if (!objective && !parsed.resume) {
+    return USAGE7;
+  }
+  const header = `[MODE: LOOP max_cycles=${parsed.maxCycles} autonomy=${parsed.autonomy}` + ` depth=${parsed.depth} resume=${parsed.resume}]`;
+  if (!objective && parsed.resume) {
+    return `${header} Resume the existing compound-engineering loop from durable state in .swarm/loop/. Read the latest run state, report cycle progress, and continue from the current phase.`;
+  }
+  return `${header} ${objective}`;
+}
+var MAX_OBJECTIVE_LEN = 2000, DEPTHS2, AUTONOMY_LEVELS, DEFAULT_DEPTH2 = "standard", DEFAULT_AUTONOMY = "checkpoint", DEFAULT_MAX_CYCLES = 3, MIN_MAX_CYCLES = 1, MAX_MAX_CYCLES = 5, USAGE7 = `Usage: /swarm loop <objective> [--max-cycles 1..5] [--autonomy checkpoint|auto] [--depth standard|exhaustive] [--resume]
+
+Run a compound-engineering loop: brainstorm → plan → build → review → improve,
+iterating until the objective is met or a budget stop condition fires.
+
+Examples:
+  /swarm loop "add rate limiting to the public API"
+  /swarm loop "harden auth session handling" --depth exhaustive --max-cycles 2
+  /swarm loop "migrate config loader" --autonomy auto
+  /swarm loop --resume
+
+Flags:
+  --max-cycles <N>          outer improvement cycles, 1..5 (default: 3)
+  --autonomy <level>        checkpoint (pause at phase gates, default) or auto
+                            (run unattended; hard stop conditions still apply)
+  --depth <name>            standard (default) or exhaustive (wider exploration)
+  --resume                  resume the existing loop run from durable state in
+                            .swarm/loop/ instead of starting a new objective`;
+var init_loop = __esm(() => {
+  DEPTHS2 = new Set(["standard", "exhaustive"]);
+  AUTONOMY_LEVELS = new Set(["checkpoint", "auto"]);
+});
+
 // src/memory/config.ts
 function resolveMemoryConfig(input) {
   return {
@@ -83478,7 +83598,7 @@ var init_pr_monitor_status = __esm(() => {
 });
 
 // src/commands/pr-review.ts
-function parseArgs7(args2) {
+function parseArgs8(args2) {
   const out2 = { council: false, rest: [] };
   for (const token of args2) {
     if (token === "--council") {
@@ -83497,29 +83617,29 @@ function parseArgs7(args2) {
   return out2;
 }
 function handlePrReviewCommand(directory, args2) {
-  const parsed = parseArgs7(args2);
+  const parsed = parseArgs8(args2);
   if (parsed.unknownFlag) {
     return `Error: Unknown flag "${parsed.unknownFlag}"
 
-${USAGE7}`;
+${USAGE8}`;
   }
   const resolved = resolvePrCommandInput(parsed.rest, directory);
   if (resolved === null) {
-    return USAGE7;
+    return USAGE8;
   }
   if ("error" in resolved) {
     return `Error: ${resolved.error}
 
-${USAGE7}`;
+${USAGE8}`;
   }
   const councilFlag = parsed.council ? "council=true" : "council=false";
   const signal = `[MODE: PR_REVIEW pr="${resolved.prUrl}" ${councilFlag}]`;
   return resolved.instructions ? `${signal} ${resolved.instructions}` : signal;
 }
-var USAGE7;
+var USAGE8;
 var init_pr_review = __esm(() => {
   init_pr_ref();
-  USAGE7 = [
+  USAGE8 = [
     "Usage: /swarm pr-review <url|owner/repo#N|N> [--council] [instructions...]",
     "",
     "Run a full swarm PR review on a GitHub pull request.",
@@ -90854,7 +90974,7 @@ var init_rollback = __esm(() => {
 });
 
 // src/commands/sdd.ts
-function parseArgs8(args2) {
+function parseArgs9(args2) {
   const parsed = { json: false, dryRun: false };
   for (let i2 = 0;i2 < args2.length; i2++) {
     const token = args2[i2];
@@ -90885,11 +91005,11 @@ function formatList(items) {
 `) : "- none";
 }
 async function handleSddStatusCommand(directory, args2) {
-  const parsed = parseArgs8(args2);
+  const parsed = parseArgs9(args2);
   if (parsed.error)
     return `Error: ${parsed.error}
 
-${USAGE8}`;
+${USAGE9}`;
   const status = loadSddStatusSync(directory);
   if (parsed.json)
     return JSON.stringify(status, null, 2);
@@ -90923,11 +91043,11 @@ ${formatList([
 `);
 }
 async function handleSddValidateCommand(directory, args2) {
-  const parsed = parseArgs8(args2);
+  const parsed = parseArgs9(args2);
   if (parsed.error)
     return `Error: ${parsed.error}
 
-${USAGE8}`;
+${USAGE9}`;
   const status = loadSddStatusSync(directory);
   const projection = buildOpenSpecProjectionSync(directory, {
     changeId: parsed.changeId
@@ -90965,11 +91085,11 @@ ${formatList(result.warnings)}` : ""
 `);
 }
 async function handleSddProjectCommand(directory, args2) {
-  const parsed = parseArgs8(args2);
+  const parsed = parseArgs9(args2);
   if (parsed.error)
     return `Error: ${parsed.error}
 
-${USAGE8}`;
+${USAGE9}`;
   const result = writeProjectedSpecSync(directory, {
     changeId: parsed.changeId,
     dryRun: parsed.dryRun
@@ -90989,7 +91109,7 @@ ${USAGE8}`;
     return [
       "SDD projection failed: no valid OpenSpec-compatible projection could be built.",
       "",
-      USAGE8
+      USAGE9
     ].join(`
 `);
   }
@@ -91006,9 +91126,9 @@ ${formatList(result.projection.warnings)}` : ""
 `);
 }
 async function handleSddCommand(_directory, _args) {
-  return USAGE8;
+  return USAGE9;
 }
-var USAGE8 = `Usage:
+var USAGE9 = `Usage:
   /swarm sdd status [--json]
   /swarm sdd validate [--json] [--change <id>]
   /swarm sdd project [--dry-run] [--json] [--change <id>]
@@ -92693,6 +92813,7 @@ var init_registry = __esm(() => {
   init_issue();
   init_knowledge();
   init_learning();
+  init_loop();
   init_memory2();
   init_plan();
   init_post_mortem();
@@ -93052,6 +93173,24 @@ Subcommands:
       category: "utility",
       toolPolicy: "human-only"
     },
+    "sdd-status": {
+      handler: (ctx) => handleSddStatusCommand(ctx.directory, ctx.args),
+      description: "Show OpenSpec-compatible SDD status and effective spec source",
+      aliasOf: "sdd status",
+      deprecated: true
+    },
+    "sdd-validate": {
+      handler: (ctx) => handleSddValidateCommand(ctx.directory, ctx.args),
+      description: "Validate OpenSpec-compatible artifacts and effective spec projection",
+      aliasOf: "sdd validate",
+      deprecated: true
+    },
+    "sdd-project": {
+      handler: (ctx) => handleSddProjectCommand(ctx.directory, ctx.args),
+      description: "Materialize the OpenSpec-compatible effective spec into .swarm/spec.md",
+      aliasOf: "sdd project",
+      deprecated: true
+    },
     analyze: {
       handler: (ctx) => handleAnalyzeCommand(ctx.directory, ctx.args),
       description: "Analyze spec.md vs plan.md for requirement coverage gaps",
@@ -93081,6 +93220,14 @@ Subcommands:
       category: "agent",
       toolPolicy: "none"
     },
+    loop: {
+      handler: (ctx) => handleModeCommandWithBundledSkills(ctx, handleLoopCommand),
+      description: "Enter architect MODE: LOOP — compound-engineering loop: brainstorm → plan → build → review → improve, iterating until done [objective]",
+      args: "<objective> [--max-cycles 1..5] [--autonomy checkpoint|auto] [--depth standard|exhaustive] [--resume]",
+      details: "Triggers the architect to run the compound-engineering loop defined in .opencode/skills/loop/SKILL.md: BRAINSTORM (requirements) → PLAN (+ critic gate) → BUILD (execute) → REVIEW (independent reviewer + critic on the diff, report-only) → IMPROVE (phase-wrap retrospective + compounding learning capture), then evaluate stop conditions and loop for another improvement cycle if the objective is unmet and budget remains. Generator and reviewer/critic run in separate contexts; failing assertions must be fixed at the root cause, never weakened, mocked, or skipped. Defense-in-depth stop conditions: objective met, --max-cycles budget (default 3), no-progress/plateau, oscillation, unrecoverable error, or explicit user stop. --autonomy checkpoint (default) pauses at phase gates for user approval; --autonomy auto runs unattended with hard stops still enforced. --depth exhaustive widens exploration. --resume continues an existing loop run from durable .swarm/loop/ state. Distinct from full-auto (autonomous cross-phase oversight) and turbo (parallel lanes within a phase): loop is a user-initiated, gated, compounding workflow.",
+      category: "agent",
+      toolPolicy: "none"
+    },
     council: {
       handler: (ctx) => handleModeCommandWithBundledSkills(ctx, handleCouncilCommand),
       description: "Enter architect MODE: COUNCIL — multi-model deliberation [question] [--preset <name>] [--spec-review]",
@@ -93113,6 +93260,12 @@ Subcommands:
       category: "agent",
       toolPolicy: "human-only"
     },
+    "pr-subscribe": {
+      handler: (ctx) => handlePrSubscribeCommand(ctx.directory, ctx.args, ctx.sessionID),
+      description: "Subscribe the current session to PR state-change notifications",
+      aliasOf: "pr subscribe",
+      deprecated: true
+    },
     "pr unsubscribe": {
       handler: (ctx) => handlePrUnsubscribeCommand(ctx.directory, ctx.args, ctx.sessionID),
       description: "Unsubscribe the current session from PR state-change notifications",
@@ -93121,6 +93274,12 @@ Subcommands:
       category: "agent",
       toolPolicy: "human-only"
     },
+    "pr-unsubscribe": {
+      handler: (ctx) => handlePrUnsubscribeCommand(ctx.directory, ctx.args, ctx.sessionID),
+      description: "Unsubscribe the current session from PR state-change notifications",
+      aliasOf: "pr unsubscribe",
+      deprecated: true
+    },
     "pr status": {
       handler: (ctx) => handlePrMonitorStatusCommand(ctx.directory, ctx.args, ctx.sessionID),
       description: "Show PR monitor subscription status for the current session",
@@ -93130,6 +93289,12 @@ Subcommands:
       toolPolicy: "agent",
       toolNoArgs: true
     },
+    "pr-status": {
+      handler: (ctx) => handlePrMonitorStatusCommand(ctx.directory, ctx.args, ctx.sessionID),
+      description: "Show PR monitor subscription status for the current session",
+      aliasOf: "pr status",
+      deprecated: true
+    },
     "deep-dive": {
       handler: (ctx) => handleModeCommandWithBundledSkills(ctx, handleDeepDiveCommand),
       description: "Launch deep codebase audit with parallel explorer waves, dual reviewers, and critic challenge [scope]",
@@ -93428,6 +93593,30 @@ Subcommands:
       category: "utility",
       toolPolicy: "human-only"
     },
+    "memory-status": {
+      handler: (ctx) => handleMemoryStatusCommand(ctx.directory, ctx.args),
+      description: "Show Swarm memory provider, JSONL, and migration status",
+      aliasOf: "memory status",
+      deprecated: true
+    },
+    "memory-export": {
+      handler: (ctx) => handleMemoryExportCommand(ctx.directory, ctx.args),
+      description: "Export current Swarm memory to JSONL files",
+      aliasOf: "memory export",
+      deprecated: true
+    },
+    "memory-import": {
+      handler: (ctx) => handleMemoryImportCommand(ctx.directory, ctx.args),
+      description: "Import legacy JSONL memory into SQLite",
+      aliasOf: "memory import",
+      deprecated: true
+    },
+    "memory-migrate": {
+      handler: (ctx) => handleMemoryMigrateCommand(ctx.directory, ctx.args),
+      description: "Run the one-time legacy JSONL to SQLite migration",
+      aliasOf: "memory migrate",
+      deprecated: true
+    },
     checkpoint: {
       handler: (ctx) => handleCheckpointCommand(ctx.directory, ctx.args),
       description: "Manage project checkpoints [save|restore|delete|list] <label>",
@@ -93784,7 +93973,7 @@ function buildSlashCommandsList() {
       "acknowledge-spec-drift",
       "council"
     ],
-    "Execution Modes": ["turbo", "full-auto"],
+    "Execution Modes": ["turbo", "full-auto", "loop"],
     Observation: [
       "status",
       "history",
@@ -94575,7 +94764,7 @@ HARD CONSTRAINTS:
 
 <!-- BEHAVIORAL_GUIDANCE_START -->
 - Treat brainstorm output as discovery material until the loaded skill transitions to SPECIFY or PLAN.
-- When council.general.enabled is true, the brainstorm skill offers the user a General Council advisory input option before spec writing. This is NOT a QA gate — it's an early workflow option. The convene_general_council tool must be available when council.general.enabled is true.
+- When council.general.enabled is true, the brainstorm skill offers the user a General Council advisory input option before spec writing, and the plan skill offers it before save_plan. This is NOT a QA gate — it's an early workflow option. The convene_general_council tool must be available when council.general.enabled is true.
 <!-- BEHAVIORAL_GUIDANCE_END -->
 
 ### MODE: SPECIFY
@@ -94592,7 +94781,7 @@ HARD CONSTRAINTS:
 
 <!-- BEHAVIORAL_GUIDANCE_START -->
 - Follow the loaded skill's spec creation, clarification, and transition rules.
-- General Council advisory input is available via the /swarm council command at any time. It is NOT offered as a SPECIFY workflow step — it moved to BRAINSTORM Phase 1b as an early option before spec writing.
+- General Council advisory input is available via the /swarm council command at any time. It is NOT offered as a SPECIFY workflow step — it is offered in BRAINSTORM Phase 1b before spec writing and in MODE: PLAN before save_plan.
 <!-- BEHAVIORAL_GUIDANCE_END -->
 
 <!-- BEHAVIORAL_GUIDANCE_START -->
@@ -94685,6 +94874,22 @@ HARD CONSTRAINTS (apply regardless of skill load success):
 - Explorers generate candidate findings only — reviewers verify or reject
 - Critics challenge only HIGH/CRITICAL findings — do NOT waste cycles on lower severity
 
+### MODE: LOOP
+Activates when: architect receives \`[MODE: LOOP max_cycles=N autonomy=checkpoint|auto depth=standard|exhaustive resume=true|false] <objective>\` signal from the loop command handler.
+
+Purpose: Run the compound-engineering loop — BRAINSTORM → PLAN → BUILD → REVIEW → IMPROVE — iterating until the objective is met or a stop condition fires. Each cycle reuses the existing mode skills (brainstorm, plan, critic-gate, execute, phase-wrap) and then captures learnings so the next cycle is cheaper (compounding). This is a real implementation workflow: it DOES delegate to coder, DOES declare scope, and DOES mutate source code through the normal EXECUTE path. It is distinct from full-auto (autonomous cross-phase oversight) and turbo (parallel lanes within a phase): LOOP is a user-initiated, gated, compounding workflow.
+
+ACTION: Load skill file:.opencode/skills/loop/SKILL.md immediately and follow its protocol. Parse the header to get \`max_cycles\`, \`autonomy\`, \`depth\`, and \`resume\`.
+
+HARD CONSTRAINTS (apply regardless of skill load success):
+- Execute the loop phases IN ORDER as defined in the skill; do not skip a phase or collapse phases. A phase's entry gate must pass before it starts and its exit gate must pass (with positive evidence) before the next phase starts.
+- Keep generation and verification in SEPARATE contexts: the coder implements; an independent reviewer and a separate critic verify the actual diff. The same context must not both write and approve a change. The REVIEW phase is report-only — a distinct fix step applies changes.
+- NEVER weaken, mock, skip, or delete a failing test or assertion to make a gate pass. Fix the root cause or stop and report.
+- Honor defense-in-depth stop conditions and NEVER exceed \`max_cycles\`: stop when the objective is met, the cycle budget is exhausted, progress plateaus (a cycle yields no qualifying improvement), the same change oscillates, an unrecoverable error occurs, or the user says stop.
+- autonomy=checkpoint: pause at each phase gate and wait for explicit user approval before proceeding. autonomy=auto: proceed across gates without prompting, but still enforce every hard stop condition and the mandatory review/critic gates.
+- Before declaring the loop complete, run the IMPROVE/compound capture step: persist categorized learnings durably and ensure they are discoverable to the next loop. Do not declare completion without it.
+- Persist loop run state under \`.swarm/loop/\`; derive cycle/phase progress from git and the plan ledger, not from conversation memory, so the loop can resume after interruption.
+
 ### MODE: DEEP_RESEARCH
 Activates when: architect receives \`[MODE: DEEP_RESEARCH depth=X max_researchers=N rounds=N output=report|brief] <question>\` signal from the deep-research command handler.
 
@@ -94791,6 +94996,7 @@ Purpose: Create or ingest the implementation plan, apply QA gate selections afte
 ACTION: Load skill file:.opencode/skills/plan/SKILL.md immediately. Follow the protocol defined there.
 
 HARD CONSTRAINTS (apply regardless of skill load success):
+- Before drafting or saving a plan, offer the loaded skill's General Council advisory option when \`council.general.enabled\` is true and a search API key is configured. If the user accepts, use the council output as context before calling \`save_plan\` and before any critic pre-plan review.
 - Use the \`save_plan\` tool as the primary plan writer. Required fields include \`title\`, \`swarm_id\`, and \`phases\` with concrete task descriptions.
 - Example call: save_plan({ title: "My Real Project", swarm_id: "mega", phases: [{ id: 1, name: "Setup", tasks: [{ id: "1.1", description: "Install dependencies and configure TypeScript", size: "small" }] }] })
 
@@ -123946,7 +124152,7 @@ var convene_general_council = createSwarmTool({
   description: "Synthesize responses from a multi-model General Council. Accepts parallel member " + "responses (Round 1, optionally Round 2), detects disagreements, and returns " + "consensus points, persisting disagreements, and a structured synthesis. " + "Architect-only. Config-gated on council.general.enabled in the resolved config: global ~/.config/opencode/opencode-swarm.json, then project .opencode/opencode-swarm.json overrides.",
   args: {
     question: exports_external.string().min(1).max(8000).describe("The question put to the council, or the spec text to review."),
-    mode: exports_external.enum(["general", "spec_review"]).optional().describe('"general" for /swarm council; "spec_review" for SPECIFY-COUNCIL-REVIEW gate.'),
+    mode: exports_external.enum(["general", "spec_review"]).optional().describe('"general" for /swarm council or pre-save PLAN advisory; "spec_review" for manual /swarm council --spec-review.'),
     members: exports_external.array(exports_external.string()).optional().describe("Optional list of member IDs convened (for evidence/audit)."),
     round1Responses: exports_external.array(exports_external.object({
       memberId: exports_external.string().min(1),
@@ -147398,6 +147604,10 @@ async function initializeOpenCodeSwarm(ctx) {
           template: "/swarm brainstorm $ARGUMENTS",
           description: "Use /swarm brainstorm to enter the architect MODE: BRAINSTORM planning workflow"
         },
+        "swarm-loop": {
+          template: "/swarm loop $ARGUMENTS",
+          description: "Use /swarm loop <objective> to run a compound-engineering loop: brainstorm → plan → build → review → improve, iterating until done [--max-cycles 1..5] [--autonomy checkpoint|auto] [--depth standard|exhaustive] [--resume]"
+        },
         "swarm-council": {
           template: "/swarm council $ARGUMENTS",
           description: "Use /swarm council <question> to convene a multi-model General Council deliberation (generalist / skeptic / domain expert) [--preset <name>] [--spec-review]"

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-swarm",
-	"version": "7.79.1",
+	"version": "7.79.4",
 	"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",
@@ -21,7 +21,7 @@
 	"license": "MIT",
 	"repository": {
 		"type": "git",
-		"url": "https://github.com/zaxbysauce/opencode-swarm.git"
+		"url": "https://github.com/ZaxbyHub/opencode-swarm.git"
 	},
 	"publishConfig": {
 		"access": "public",
@@ -60,6 +60,7 @@
 		".opencode/skills/critic-gate",
 		".opencode/skills/execute",
 		".opencode/skills/phase-wrap",
+		".opencode/skills/loop",
 		"tests/fixtures/memory-recall",
 		"README.md",
 		"LICENSE"