opencode-swarm 7.79.1 → 7.79.4

package/dist/cli/index.js

@@ -52,7 +52,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",
@@ -73,7 +73,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",
@@ -112,6 +112,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"
@@ -318,7 +319,8 @@ var init_bundled_skills = __esm(() => {
     "plan",
     "critic-gate",
     "execute",
-    "phase-wrap"
+    "phase-wrap",
+    "loop"
   ];
   syncedProjectSkillTargets = new Set;
 });
@@ -23512,8 +23514,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}$/;
@@ -54770,6 +54780,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)}\u2026`;
+}
+function isPositiveInteger(raw) {
+  return /^\d+$/.test(raw);
+}
+function parseArgs7(args) {
+  const result = {
+    maxCycles: DEFAULT_MAX_CYCLES,
+    autonomy: DEFAULT_AUTONOMY,
+    depth: DEFAULT_DEPTH2,
+    resume: false,
+    rest: []
+  };
+  let i = 0;
+  while (i < args.length) {
+    const token = args[i];
+    if (token === "--max-cycles") {
+      if (i + 1 >= args.length) {
+        return { ...result, error: `Flag "${token}" requires a value` };
+      }
+      const value = args[++i];
+      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 (i + 1 >= args.length) {
+        return { ...result, error: `Flag "${token}" requires a value` };
+      }
+      const value = args[++i];
+      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 (i + 1 >= args.length) {
+        return { ...result, error: `Flag "${token}" requires a value` };
+      }
+      const value = args[++i];
+      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);
+    }
+    i++;
+  }
+  return result;
+}
+async function handleLoopCommand(_directory, args) {
+  const parsed = parseArgs7(args);
+  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 \u2192 plan \u2192 build \u2192 review \u2192 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 {
@@ -58629,7 +58749,7 @@ var init_pr_monitor_status = __esm(() => {
 });
 
 // src/commands/pr-review.ts
-function parseArgs7(args) {
+function parseArgs8(args) {
   const out = { council: false, rest: [] };
   for (const token of args) {
     if (token === "--council") {
@@ -58648,29 +58768,29 @@ function parseArgs7(args) {
   return out;
 }
 function handlePrReviewCommand(directory, args) {
-  const parsed = parseArgs7(args);
+  const parsed = parseArgs8(args);
   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.",
@@ -65850,7 +65970,7 @@ var init_rollback = __esm(() => {
 });
 
 // src/commands/sdd.ts
-function parseArgs8(args) {
+function parseArgs9(args) {
   const parsed = { json: false, dryRun: false };
   for (let i = 0;i < args.length; i++) {
     const token = args[i];
@@ -65881,11 +66001,11 @@ function formatList(items) {
 `) : "- none";
 }
 async function handleSddStatusCommand(directory, args) {
-  const parsed = parseArgs8(args);
+  const parsed = parseArgs9(args);
   if (parsed.error)
     return `Error: ${parsed.error}
 
-${USAGE8}`;
+${USAGE9}`;
   const status = loadSddStatusSync(directory);
   if (parsed.json)
     return JSON.stringify(status, null, 2);
@@ -65919,11 +66039,11 @@ ${formatList([
 `);
 }
 async function handleSddValidateCommand(directory, args) {
-  const parsed = parseArgs8(args);
+  const parsed = parseArgs9(args);
   if (parsed.error)
     return `Error: ${parsed.error}
 
-${USAGE8}`;
+${USAGE9}`;
   const status = loadSddStatusSync(directory);
   const projection = buildOpenSpecProjectionSync(directory, {
     changeId: parsed.changeId
@@ -65961,11 +66081,11 @@ ${formatList(result.warnings)}` : ""
 `);
 }
 async function handleSddProjectCommand(directory, args) {
-  const parsed = parseArgs8(args);
+  const parsed = parseArgs9(args);
   if (parsed.error)
     return `Error: ${parsed.error}
 
-${USAGE8}`;
+${USAGE9}`;
   const result = writeProjectedSpecSync(directory, {
     changeId: parsed.changeId,
     dryRun: parsed.dryRun
@@ -65985,7 +66105,7 @@ ${USAGE8}`;
     return [
       "SDD projection failed: no valid OpenSpec-compatible projection could be built.",
       "",
-      USAGE8
+      USAGE9
     ].join(`
 `);
   }
@@ -66002,9 +66122,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>]
@@ -67474,6 +67594,7 @@ var init_registry = __esm(() => {
   init_issue();
   init_knowledge();
   init_learning();
+  init_loop();
   init_memory2();
   init_plan();
   init_post_mortem();
@@ -67833,6 +67954,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",
@@ -67862,6 +68001,14 @@ Subcommands:
       category: "agent",
       toolPolicy: "none"
     },
+    loop: {
+      handler: (ctx) => handleModeCommandWithBundledSkills(ctx, handleLoopCommand),
+      description: "Enter architect MODE: LOOP \u2014 compound-engineering loop: brainstorm \u2192 plan \u2192 build \u2192 review \u2192 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) \u2192 PLAN (+ critic gate) \u2192 BUILD (execute) \u2192 REVIEW (independent reviewer + critic on the diff, report-only) \u2192 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 \u2014 multi-model deliberation [question] [--preset <name>] [--spec-review]",
@@ -67894,6 +68041,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",
@@ -67902,6 +68055,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",
@@ -67911,6 +68070,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]",
@@ -68209,6 +68374,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>",

package/dist/commands/loop.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Handle /swarm loop command.
+ *
+ * Sanitizes the objective input, parses flags, and emits a [MODE: LOOP ...]
+ * signal. The architect picks up the signal and loads
+ * `.opencode/skills/loop/SKILL.md`, which runs the compound-engineering loop:
+ * brainstorm → plan → build → review → improve, iterating under
+ * defense-in-depth stop conditions until the objective is met or a budget is
+ * exhausted.
+ *
+ * The objective is sanitized to prevent prompt injection of rival MODE:
+ * headers or newline-based control sequences (mirrors the brainstorm /
+ * deep-dive handlers).
+ */
+export declare function handleLoopCommand(_directory: string, args: string[]): Promise<string>;

package/dist/commands/registry.d.ts

@@ -381,6 +381,24 @@ export declare const COMMAND_REGISTRY: {
         readonly category: "utility";
         readonly toolPolicy: "human-only";
     };
+    readonly 'sdd-status': {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Show OpenSpec-compatible SDD status and effective spec source";
+        readonly aliasOf: "sdd status";
+        readonly deprecated: true;
+    };
+    readonly 'sdd-validate': {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Validate OpenSpec-compatible artifacts and effective spec projection";
+        readonly aliasOf: "sdd validate";
+        readonly deprecated: true;
+    };
+    readonly 'sdd-project': {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Materialize the OpenSpec-compatible effective spec into .swarm/spec.md";
+        readonly aliasOf: "sdd project";
+        readonly deprecated: true;
+    };
     readonly analyze: {
         readonly handler: (ctx: CommandContext) => Promise<string>;
         readonly description: "Analyze spec.md vs plan.md for requirement coverage gaps";
@@ -410,6 +428,14 @@ export declare const COMMAND_REGISTRY: {
         readonly category: "agent";
         readonly toolPolicy: "none";
     };
+    readonly loop: {
+        readonly handler: (ctx: CommandContext) => CommandResult;
+        readonly description: "Enter architect MODE: LOOP — compound-engineering loop: brainstorm → plan → build → review → improve, iterating until done [objective]";
+        readonly args: "<objective> [--max-cycles 1..5] [--autonomy checkpoint|auto] [--depth standard|exhaustive] [--resume]";
+        readonly 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.";
+        readonly category: "agent";
+        readonly toolPolicy: "none";
+    };
     readonly council: {
         readonly handler: (ctx: CommandContext) => CommandResult;
         readonly description: "Enter architect MODE: COUNCIL — multi-model deliberation [question] [--preset <name>] [--spec-review]";
@@ -442,6 +468,12 @@ export declare const COMMAND_REGISTRY: {
         readonly category: "agent";
         readonly toolPolicy: "human-only";
     };
+    readonly 'pr-subscribe': {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Subscribe the current session to PR state-change notifications";
+        readonly aliasOf: "pr subscribe";
+        readonly deprecated: true;
+    };
     readonly 'pr unsubscribe': {
         readonly handler: (ctx: CommandContext) => Promise<string>;
         readonly description: "Unsubscribe the current session from PR state-change notifications";
@@ -450,6 +482,12 @@ export declare const COMMAND_REGISTRY: {
         readonly category: "agent";
         readonly toolPolicy: "human-only";
     };
+    readonly 'pr-unsubscribe': {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Unsubscribe the current session from PR state-change notifications";
+        readonly aliasOf: "pr unsubscribe";
+        readonly deprecated: true;
+    };
     readonly 'pr status': {
         readonly handler: (ctx: CommandContext) => Promise<string>;
         readonly description: "Show PR monitor subscription status for the current session";
@@ -459,6 +497,12 @@ export declare const COMMAND_REGISTRY: {
         readonly toolPolicy: "agent";
         readonly toolNoArgs: true;
     };
+    readonly 'pr-status': {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Show PR monitor subscription status for the current session";
+        readonly aliasOf: "pr status";
+        readonly deprecated: true;
+    };
     readonly 'deep-dive': {
         readonly handler: (ctx: CommandContext) => CommandResult;
         readonly description: "Launch deep codebase audit with parallel explorer waves, dual reviewers, and critic challenge [scope]";
@@ -742,6 +786,30 @@ export declare const COMMAND_REGISTRY: {
         readonly category: "utility";
         readonly toolPolicy: "human-only";
     };
+    readonly 'memory-status': {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Show Swarm memory provider, JSONL, and migration status";
+        readonly aliasOf: "memory status";
+        readonly deprecated: true;
+    };
+    readonly 'memory-export': {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Export current Swarm memory to JSONL files";
+        readonly aliasOf: "memory export";
+        readonly deprecated: true;
+    };
+    readonly 'memory-import': {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Import legacy JSONL memory into SQLite";
+        readonly aliasOf: "memory import";
+        readonly deprecated: true;
+    };
+    readonly 'memory-migrate': {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Run the one-time legacy JSONL to SQLite migration";
+        readonly aliasOf: "memory migrate";
+        readonly deprecated: true;
+    };
     readonly checkpoint: {
         readonly handler: (ctx: CommandContext) => Promise<string>;
         readonly description: "Manage project checkpoints [save|restore|delete|list] <label>";

package/dist/config/bundled-skills.d.ts

@@ -1,4 +1,4 @@
-export declare const BUNDLED_PROJECT_SKILLS: readonly ["brainstorm", "specify", "clarify-spec", "resume", "clarify", "discover", "consult", "pre-phase-briefing", "council", "deep-dive", "deep-research", "codebase-review-swarm", "design-docs", "swarm-pr-review", "swarm-pr-feedback", "issue-ingest", "plan", "critic-gate", "execute", "phase-wrap"];
+export declare const BUNDLED_PROJECT_SKILLS: readonly ["brainstorm", "specify", "clarify-spec", "resume", "clarify", "discover", "consult", "pre-phase-briefing", "council", "deep-dive", "deep-research", "codebase-review-swarm", "design-docs", "swarm-pr-review", "swarm-pr-feedback", "issue-ingest", "plan", "critic-gate", "execute", "phase-wrap", "loop"];
 interface CopyState {
     files: number;
     bytes: number;