specrails-desktop 2.31.2 → 2.32.0

package/server/dist/loop-executors.js

@@ -182,7 +182,9 @@ function createLoopExecutors(opts = {}) {
                 buildOpts,
                 cwd,
                 env: (0, runtime_1.buildProviderEnv)(adapter, buildOpts, stepEnv),
-                timeoutMs: aiStepTimeoutMs ?? AI_STEP_TIMEOUT_MS,
+                // 0 ⇒ watchdog disabled (factory loops run untimed; the loop's
+                // maxIterations / cost cap remain the runaway guards).
+                timeoutMs: (aiStepTimeoutMs ?? AI_STEP_TIMEOUT_MS) > 0 ? (aiStepTimeoutMs ?? AI_STEP_TIMEOUT_MS) : undefined,
                 onSpawn,
                 // Two complementary streams, mirroring QueueManager's contract:
                 //  • RAW JSONL via onStdoutLine → engine emits parsed `event`s that drive
@@ -319,7 +321,8 @@ function createLoopExecutors(opts = {}) {
             return {
                 adapter,
                 spec: { binary: adapter.binary, args, cwd, env: (0, runtime_1.buildProviderEnv)(adapter, buildOpts, stepEnv) },
-                // The loop's ai-step timeout bounds the WHOLE step, interactive included.
+                // The loop's ai-step timeout bounds the WHOLE step, interactive
+                // included. 0 ⇒ unbounded (the engine skips arming the step timer).
                 stepTimeoutMs: aiStepTimeoutMs ?? AI_STEP_TIMEOUT_MS,
             };
         },

package/server/dist/loop-factory.js

@@ -8,12 +8,14 @@ exports.factoryLoopForMode = factoryLoopForMode;
 const loop_templates_1 = require("./loop-templates");
 const GREEN_GOAL = 'Stop only when the latest verification step reports {{const:VERIFICATION_PASS}} and the history proves the spec is implemented with all required tests/build checks passing.';
 // Factory loops run the WHOLE architect→developer→reviewer pipeline inside a
-// single AI step (`/specrails:implement` etc.), so they need far more headroom
-// than the engine defaults (loop 30 min / step 15 min): a real implement can run
-// for a long time. 360 min loop deadline, 60 min per AI step.
+// single AI step (`/specrails:implement` etc.), so no fixed wall-clock budget is
+// honest — a legit implement outran the old 60-min step cap and got killed
+// mid-run. Built-in loops therefore run UNTIMED (0 = no timeout, both the run
+// deadline and the per-step watchdog); maxIterations and the optional cost cap
+// remain the runaway guards.
 const FACTORY_MAX_ITERATIONS = 12;
-const FACTORY_LOOP_TIMEOUT_MIN = 360;
-const FACTORY_AI_STEP_TIMEOUT_MIN = 60;
+const FACTORY_LOOP_TIMEOUT_MIN = 0;
+const FACTORY_AI_STEP_TIMEOUT_MIN = 0;
 const SDD_QUICK_OPENSPEC_FACTORY = {
     id: 'factory:sdd-quick-openspec',
     name: 'SDD Quick (OpenSpec)',

package/server/dist/loop-graph.js

@@ -27,7 +27,7 @@ function emptyLoopGraph() {
  *  - at least one `end` node (the explicit exit),
  *  - every edge references existing nodes (no dangling edges),
  *  - every node is reachable from `start` (no orphan / disconnected nodes),
- *  - a sane config (maxIterations ≥ 1, timeoutMinutes ≥ 1).
+ *  - a sane config (maxIterations ≥ 1, timeoutMinutes ≥ 0 — 0 = no timeout).
  *
  * Returns all errors found (not just the first) so the builder can highlight
  * every problem at once.
@@ -60,10 +60,11 @@ function validateLoopGraph(graph) {
         !Number.isInteger(cfg.maxIterations) ||
         cfg.maxIterations < 1 ||
         typeof cfg.timeoutMinutes !== 'number' ||
-        cfg.timeoutMinutes < 1) {
+        !Number.isFinite(cfg.timeoutMinutes) ||
+        cfg.timeoutMinutes < 0) {
         errors.push({
             code: 'INVALID_CONFIG',
-            message: 'maxIterations and timeoutMinutes must both be ≥ 1.',
+            message: 'maxIterations must be ≥ 1 and timeoutMinutes ≥ 0 (0 = no timeout).',
         });
     }
     // ── Dangling edges ────────────────────────────────────────────────────────────

package/server/dist/loop-run-manager.js

@@ -502,9 +502,13 @@ class LoopRunManager {
         const neverAfterDispose = () => new Promise(() => { });
         const runId = req.runId ?? (0, ids_1.newId)();
         const maxIterations = req.graph.config.maxIterations;
-        const timeoutMs = req.graph.config.timeoutMinutes * 60_000;
-        const deadline = this.now() + timeoutMs;
-        // Per-step AI timeout (ms) — undefined falls back to the executor default.
+        // 0 ⇒ no whole-run deadline (built-in pipeline loops opt out of the wall
+        // clock; maxIterations / maxCostUsd remain the runaway guards).
+        const deadline = req.graph.config.timeoutMinutes > 0
+            ? this.now() + req.graph.config.timeoutMinutes * 60_000
+            : Infinity;
+        // Per-step AI timeout (ms) — undefined falls back to the executor default,
+        // 0 disables the per-step watchdog entirely.
         const aiStepTimeoutMs = req.graph.config.aiStepTimeoutMinutes != null
             ? req.graph.config.aiStepTimeoutMinutes * 60_000
             : undefined;

package/server/dist/loop-templates.js

@@ -170,9 +170,10 @@ function opsxLifecycleGraph() {
             { id: 'e-stop', source: 'decide', target: 'archive', branch: 'stop' },
             { id: 'e-archive', source: 'archive', target: 'done' },
         ],
-        // Conservative bounds so a never-satisfied verify can't spin: at most 3 full
-        // lifecycle passes; per-step cap raised (apply can implement a whole change).
-        config: { maxIterations: 3, timeoutMinutes: 180, aiStepTimeoutMinutes: 45 },
+        // At most 3 full lifecycle passes guard a never-satisfied verify. Like the
+        // other built-in loops the run is UNTIMED (0 = no timeout) — apply can
+        // implement a whole change and must never be killed mid-flight.
+        config: { maxIterations: 3, timeoutMinutes: 0, aiStepTimeoutMinutes: 0 },
     };
 }
 exports.LOOP_TEMPLATES = [

package/server/dist/profiles-router.js

@@ -282,7 +282,30 @@ function createProfilesRouter() {
                 throw err;
             }
             broadcast({ type: 'profile.changed', projectId: project.id, name: 'default' });
-            res.status(201).json({ profile });
+            // Companion `fast` profile (claude only, best-effort): same chain, but
+            // the flanking pipeline stages (architect plan / reviewer gate) run on
+            // haiku while the developer keeps its migrated model — a one-click way
+            // to cut implement wall-clock when the spec doesn't need heavyweight
+            // design/review. Skipped silently when 'fast' already exists.
+            let fastProfile = null;
+            if (isClaude && (0, providers_1.isModelAvailableForAdapter)(adapter, 'haiku')) {
+                const candidate = {
+                    ...profile,
+                    name: 'fast',
+                    description: 'Speed-first: haiku architect/reviewer, your developer model unchanged. Pick per rail when the spec is routine.',
+                    agents: profile.agents.map((a) => (a.id === 'sr-architect' || a.id === 'sr-reviewer' ? { ...a, model: 'haiku' } : a)),
+                };
+                try {
+                    (0, profile_manager_1.createProfile)(specRoot(project), candidate, provider);
+                    fastProfile = candidate;
+                    broadcast({ type: 'profile.changed', projectId: project.id, name: 'fast' });
+                }
+                catch (err) {
+                    if (!(err instanceof profile_manager_1.ProfileConflictError))
+                        throw err;
+                }
+            }
+            res.status(201).json({ profile, ...(fastProfile ? { fastProfile } : {}) });
         }
         catch (err) {
             handleError(res, err);

package/server/dist/rail-isolated-launch.js

@@ -78,6 +78,7 @@ const agent_chat_registry_1 = require("./agent-chat-registry");
 const rail_merge_orchestrator_1 = require("./rail-merge-orchestrator");
 const loop_executors_1 = require("./loop-executors");
 const worktree_overlay_1 = require("./worktree-overlay");
+const worktree_node_modules_1 = require("./worktree-node-modules");
 const workspace_resolution_1 = require("./workspace-resolution");
 const feature_flags_1 = require("./feature-flags");
 const file_provenance_1 = require("./file-provenance");
@@ -690,6 +691,20 @@ async function launchIsolatedRail(input, io = {}) {
                             // and future edits — the spawn proceeds regardless.
                             notifyOverlayDegraded(unit.ticketId, [err instanceof Error ? err.message : String(err)]);
                         }
+                        // Warm-dependency reuse: link the base checkout's node_modules trees
+                        // into the fresh worktree (best-effort; a failure just leaves the run
+                        // on the legacy cold start). Linked paths join the overlay exclusion
+                        // list so they inherit the commit-time guarantees.
+                        try {
+                            const nm = (io.linkNodeModules ?? worktree_node_modules_1.linkNodeModulesIntoWorktree)(baseRepo, handle.worktreePath);
+                            if (nm.linked.length > 0)
+                                overlayExcludes = overlayExcludes.concat(nm.linked);
+                            if (nm.warnings.length > 0)
+                                notifyOverlayDegraded(unit.ticketId, nm.warnings);
+                        }
+                        catch (err) {
+                            notifyOverlayDegraded(unit.ticketId, [err instanceof Error ? err.message : String(err)]);
+                        }
                         // Code-Explorer provenance: freeze the worktree's pre-run state (HEAD sha
                         // + the overlay's untracked set) so the settle diff attributes exactly
                         // the run's own writes. Best-effort — a snapshot failure only loses

package/server/dist/spawn-lifecycle.js

@@ -66,7 +66,7 @@ function runAiCliInvocation(hooks) {
             return;
         }
         hooks.onSpawn?.(child);
-        if (hooks.timeoutMs != null) {
+        if (hooks.timeoutMs != null && hooks.timeoutMs > 0) {
             timer = setTimeout(() => {
                 hooks.onTimeout?.();
                 // treeKill the whole subtree (a bare child.kill leaves grandchildren),

package/server/dist/worktree-node-modules.js

@@ -0,0 +1,158 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWorktreeNodeModulesEnabled = isWorktreeNodeModulesEnabled;
+exports.linkNodeModulesIntoWorktree = linkNodeModulesIntoWorktree;
+/**
+ * Warm-dependency reuse for isolated rail worktrees.
+ *
+ * `git worktree add` materializes only TRACKED files, so a fresh worktree has
+ * no `node_modules` — every isolated run used to pay a cold `npm install`
+ * (root + nested packages) plus cold build caches before doing any real work.
+ * This module links the base checkout's existing install into the worktree so
+ * the run starts warm.
+ *
+ * Mechanics:
+ *  - DISCOVER: every directory that holds a `package.json` in the base repo at
+ *    depth ≤ `MAX_DEPTH` (root plus shallow sub-packages like `client/`),
+ *    skipping dot-dirs and anything inside a `node_modules` tree.
+ *  - LINK: for each discovered package dir whose base checkout actually has a
+ *    `node_modules`, create the same relative path in the worktree as a
+ *    SYMLINK (junction on Windows). No copy fallback on purpose — copying a
+ *    multi-GB dependency tree would be slower than the `npm install` it
+ *    replaces; a failed link simply degrades to the legacy cold start.
+ *  - NEVER overwrite: an existing entry at the destination (a real dir, a
+ *    prior link, anything) is left untouched, so resume passes are idempotent
+ *    and an agent-made install is never clobbered.
+ *
+ * The returned `linked` paths are appended to the launch's overlay-exclusion
+ * list, so a linked `node_modules` inherits the same commit-time guarantees as
+ * overlay scaffolding (excluded pathspecs + index audit) even if the repo's
+ * `.gitignore` were ever missing the entry.
+ *
+ * Honest caveat (documented, accepted): the link SHARES the dependency tree
+ * with the base checkout. Reads (tests, builds) are safe under concurrency; an
+ * in-worktree `npm install` would write through to the shared tree — the same
+ * mutation it would make in the user's checkout after merge.
+ *
+ * Kill switch: `SPECRAILS_WORKTREE_NODE_MODULES=false` restores the byte-
+ * identical cold-worktree behaviour.
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/** Package-dir discovery depth: 0 = repo root, 1 = `client/`-style children. */
+const MAX_DEPTH = 2;
+function isWorktreeNodeModulesEnabled() {
+    return (process.env.SPECRAILS_WORKTREE_NODE_MODULES ?? '').toLowerCase() !== 'false';
+}
+function isDir(p) {
+    try {
+        return fs.statSync(p).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function exists(p) {
+    try {
+        fs.lstatSync(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function errMsg(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+/** Relative POSIX paths of package dirs (containing package.json) at depth ≤ MAX_DEPTH. */
+function discoverPackageDirs(baseRepo) {
+    const found = [];
+    const walk = (rel, depth) => {
+        const abs = rel === '' ? baseRepo : path.join(baseRepo, rel);
+        if (exists(path.join(abs, 'package.json')))
+            found.push(rel);
+        if (depth >= MAX_DEPTH)
+            return;
+        let names;
+        try {
+            names = fs.readdirSync(abs);
+        }
+        catch {
+            return;
+        }
+        for (const name of names) {
+            // Dot-dirs (.git, .specrails, provider dirs) and dependency trees never
+            // hold linkable first-party packages.
+            if (name.startsWith('.') || name === 'node_modules')
+                continue;
+            const childAbs = path.join(abs, name);
+            if (!isDir(childAbs))
+                continue;
+            walk(rel === '' ? name : `${rel}/${name}`, depth + 1);
+        }
+    };
+    walk('', 0);
+    return found;
+}
+/**
+ * Link the base checkout's installed `node_modules` trees into a fresh
+ * worktree. Best-effort and side-effect-transparent: never throws, never
+ * overwrites, returns what it created so the caller can exclude those paths
+ * from commits.
+ */
+function linkNodeModulesIntoWorktree(baseRepo, worktreePath) {
+    const result = { linked: [], warnings: [] };
+    if (!isWorktreeNodeModulesEnabled())
+        return result;
+    for (const pkgRel of discoverPackageDirs(baseRepo)) {
+        const rel = pkgRel === '' ? 'node_modules' : `${pkgRel}/node_modules`;
+        const src = path.join(baseRepo, ...rel.split('/'));
+        if (!isDir(src))
+            continue;
+        const dest = path.join(worktreePath, ...rel.split('/'));
+        if (exists(dest))
+            continue;
+        try {
+            fs.mkdirSync(path.dirname(dest), { recursive: true });
+            fs.symlinkSync(src, dest, process.platform === 'win32' ? 'junction' : undefined);
+            result.linked.push(rel);
+        }
+        catch (err) {
+            result.warnings.push(`failed to link ${rel}: ${errMsg(err)}`);
+        }
+    }
+    return result;
+}

package/client/dist/assets/loops-BzfXWEwO.js

@@ -1 +0,0 @@
-import{r as e}from"./rolldown-runtime-CNC7AqOf.js";var t=e({actions:()=>u,builder:()=>h,builtInBadge:()=>_,card:()=>d,catalog:()=>y,categories:()=>s,confirmDelete:()=>f,default:()=>b,empty:()=>l,errors:()=>m,gallery:()=>o,newLoop:()=>i,newLoopName:()=>p,preview:()=>g,run:()=>v,sections:()=>a,status:()=>c,subtitle:()=>r,title:()=>n}),n=`Loops`,r=`Reusable automation loops — shared across all your projects.`,i=`New loop`,a={drafts:`Drafts`,published:`Published`,templates:`Templates`,builtIn:`Built-in`},o={search:`Search templates…`,noResults:`No templates match your filters.`,clearFilter:`Clear filters`,resultCount_one:`{{count}} template`,resultCount_other:`{{count}} templates`,needsSpec:`Needs spec`,standalone:`Standalone`,needsSpecHint:`Runs on a rail with a dragged spec`,standaloneHint:`Runs standalone — just pick a project`},s={API:`API`,Automation:`Automation`,CI:`CI`,Database:`Database`,Debugging:`Debugging`,DevOps:`DevOps`,Docs:`Docs`,Git:`Git`,Maintenance:`Maintenance`,Performance:`Performance`,Planning:`Planning`,Quality:`Quality`,Review:`Review`,Security:`Security`,Testing:`Testing`},c={draft:`Draft`,published:`Published`,running:`Running`},l={title:`No loops yet`,body:`Create one from scratch or start from a template.`},u={edit:`Edit`,delete:`Delete`,publish:`Publish`,unpublish:`Unpublish`,duplicate:`Duplicate`,use:`Use template`,preview:`Preview`,fork:`Fork to edit`,run:`Run`,export:`Export`,import:`Import`,select:`Select {{name}}`},d={nodes_one:`{{count}} node`,nodes_other:`{{count}} nodes`,usedIn:`In use · {{project}}`},f=`Delete this loop? It will disappear from every rail picker.`,p=`New loop`,m={load:`Failed to load loops`,save:`Failed to save loop`,publishInvalid:`This loop can't be published yet — fix the highlighted issues.`},h={back:`Back to Loops`,save:`Save`,saved:`Loop saved`,publish:`Publish`,published:`Loop published`,addNode:`Add node`,deleteNode:`Delete node`,config:{maxIterations:`Max iterations`,timeout:`Timeout (min)`,maxIterationsHint:`Hard cap on Loop Decider iterations — the loop stops when it's reached even if the goal isn't met. Prevents runaway loops.`,timeoutHint:`Wall-clock limit for the whole run, in minutes. If exceeded, the run is stopped and marked failed — a safety net alongside max iterations.`,maxCost:`Max cost ($)`,maxCostHint:`Optional USD budget for the whole run. Checked BETWEEN steps (a step’s cost is only known once it finishes), so the loop stops before the next step once the total crosses it — may overshoot by one step. For non-Claude providers the cost is an estimate. Empty = no cap.`},nodes:{start:`Start`,"ai-step":`AI Step`,shell:`Shell`,decider:`Loop Decider`,condition:`Condition`,end:`End`},inspector:{selectNode:`Select a node to edit it.`,prompt:`Prompt`,provider:`Provider`,model:`Model`,effort:`Reasoning effort`,command:`Command`,goal:`Goal / stop criteria`,join:`Join`,outcome:`Outcome`,startNote:`The entry point of the loop. Connect it to the first step.`,promptHint:`Click or drag a token to insert it into the prompt.`,tokensSpec:`Spec fields`,tokensJira:`Jira`,tokensCommands:`Commands`,label:`Name`},branch:{continue:`↻ Continue`,stop:`✓ Stop`},edgesHelp:{label:`How steps connect`,body:`Arrows set the run ORDER, not data — boxes have no input ports and edges carry no parameters. Each AI Step automatically resumes its session (full prior context) plus a short summary of previous steps; nothing is wired by hand. The Loop Decider has two outputs: ↻ Continue (goal not met → loop back) and ✓ Stop (goal met → exit).`},arrange:{label:`Arrange`,vertical:`Vertical`,horizontal:`Horizontal`,grid:`Grid`,reset:`Reset`},constants:{label:`Constants`,manage:`Manage constants`,title:`Loop constants`,empty:`No custom constants yet.`,name:`NAME`,value:`value`,add:`Add`,builtinBadge:`Built-in`},paste:{done_one:`Pasted {{count}} step`,done_other:`Pasted {{count}} steps`},problems:{count_one:`{{count}} problem`,count_other:`{{count}} problems`,NO_START:`Add a Start node.`,MULTIPLE_START:`Only one Start node is allowed.`,NO_END:`Add at least one End node.`,ORPHAN:`This step isn't reachable from Start.`,DECIDER_BRANCHES:`Loop Decider needs a Continue and a Stop branch.`,EMPTY_PROMPT:`AI Step has an empty prompt.`,EMPTY_COMMAND:`Shell step has an empty command.`,EMPTY_GOAL:`Loop Decider has no goal.`,DEAD_END:`This step has no outgoing connection.`},preview:{label:`Preview`,title:`Dry-run preview`,sampleNote:`Spec values use sample data; commands and constants resolve exactly as they will at run time.`,empty:`No steps to preview.`,error:`Preview failed`}},g={steps:`Steps`,limits:`{{iterations}} iterations max · {{timeout}} min timeout`,openInBuilder:`Open in builder`,builtin:`Built-in`},_=`Built-in`,v={title:`Run {{name}}`,subtitle:`Launch this loop on a project (no ticket needed).`,project:`Project`,provider:`Provider`,model:`Model`,effort:`Reasoning effort`,execute:`Execute`,noProjects:`No projects available.`,launched:`Running {{name}}`},y=JSON.parse(`{"ship-and-green":{"name":"Ship & Green","description":"Fully autonomous: implement the spec, verify, and refine (fix) on failure — looping verify → fix → verify until everything is green. No human intervention."},"verify-pass":{"name":"Verify Pass","description":"Autonomous verify-and-fix: detect and run the project's build/lint/tests, then refine on failure — verify → fix → verify until green."},"ci-watch":{"name":"CI Watch","description":"Poll CI checks on the open PR (the agent uses the repo's CI tooling) until every check is green."},"lint-and-fix":{"name":"Lint & Fix","description":"The agent detects and runs the project's linter and fixes every issue, iterating until the codebase is clean."},"type-safe":{"name":"Type Safe","description":"The agent detects and runs the project's type checker and resolves every error, iterating until it passes cleanly."},"coverage-climb":{"name":"Coverage Climb","description":"The agent runs the project's coverage tooling and adds focused tests until the thresholds pass."},"build-fix":{"name":"Build Fix","description":"The agent detects and runs the project's production build and fixes compile/bundle errors until it is green."},"deploy-check":{"name":"Deploy Check","description":"The agent polls the deployment/health status (using the project's deploy tooling) until the service reports healthy."},"factory_implement":{"name":"Implement","description":"Fully autonomous: implement the spec, verify, and refine (fix) on failure — looping until all tests pass."},"factory_batch":{"name":"Batch Implement","description":"Batch-implement all the rail's tickets at once, then verify + refine on failure until green."},"factory_freestyle":{"name":"Freestyle","description":"Hands the spec straight to the model with full freedom — no pipeline, it works like a regular coding agent, then verify + refine until green. Claude only."},"autoloop-tdd":{"name":"Autoloop TDD","description":"A strict red-green-refactor cycle for {{spec.title}}: pin down each behavior with a failing test first, write only enough code to turn it green, then tidy up — repeating until the spec is fully covered."},"e2e-until-green":{"name":"E2E Until Green","description":"Run the end-to-end suite for {{spec.title}}, diagnose each failing user-flow, fix the underlying UI or integration defect, and keep cycling until every E2E spec passes."},"flaky-test-triage":{"name":"Flaky Test Triage","description":"Re-run the failing tests around {{spec.title}} several times to separate genuine regressions from intermittent flakes, then repair the real breaks and stabilize or document the flaky ones."},"independent-verifier-pass":{"name":"Independent Verifier Pass","description":"An adversarial verification of {{spec.title}}: re-run build, lint, and tests from scratch, trust only the raw command output (not any prior 'it works' claim), and surface or fix every gap."},"post-edit-test-guard":{"name":"Post-Edit Test Guard","description":"After each batch of edits for {{spec.title}}, immediately run the narrowest set of tests touching the changed files — catching regressions the moment they appear instead of at the end."},"post-merge-regression-guard":{"name":"Post-Merge Regression Guard","description":"Right after a merge or rebase brings other people's work into {{spec.title}}, run the fast smoke suite to catch integration breakage immediately — before any new feature work starts on top of it."},"pre-commit-guard":{"name":"Pre-Commit Guard","description":"A safety gate for {{spec.title}} that intercepts every commit: run the test suite first and refuse to commit while it is red, so broken code never enters history."},"visual-regression-until-match":{"name":"Visual Regression Until Match","description":"Capture visual snapshots of the changed UI, hunt down every unintended pixel diff, and self-correct until the visual suite is green with only deliberate design changes approved."},"format-until-clean":{"name":"Format Until Clean","description":"Apply the project formatter, mop up the handful of style problems it cannot auto-fix, and keep going until a fresh format run leaves the working tree untouched."},"lint-typecheck-fix":{"name":"Lint and Typecheck Fix","description":"Run the linter and the type checker, resolve each reported problem with the smallest possible edit, and loop until both gates come back completely clean."},"a11y-audit-until-clean":{"name":"A11y Audit Until Clean","description":"Run the automated accessibility checks over the changed screens, fix the violations one category at a time, and repeat until the audit comes back with zero issues."},"de-sloppify-pass":{"name":"De-Sloppify Pass","description":"After the feature lands, sweep the diff for leftover slop — debug output, dead branches, sloppy names, bloated functions — clean it up, and prove the cleanup did not break anything."},"fix-ci-until-green":{"name":"Fix CI Until Green","description":"Pull the most recent red CI run on this branch, reproduce the breakage on your machine, patch the real cause, push, and keep cycling until every check reports success."},"pr-babysitter":{"name":"PR Babysitter","description":"On a recurring interval, sweep the open pull requests you are watching and keep each one mergeable: revive red CI, rebase the ones that have fallen behind the base branch, and ping the stale ones — escalating anything a human has to decide."},"pr-watch-loop":{"name":"PR Watch Loop","description":"Poll the pull requests on your watch list at a steady cadence, summarize each one's CI and review health, and either knock out trivial blockers or surface what needs an owner."},"pr-self-review":{"name":"PR Self-Review","description":"Critique your own working diff the way a demanding senior reviewer would, resolve what you find, and re-review until a clean pass turns up nothing critical — before the PR ever leaves your hands."},"spec-first-ship":{"name":"Spec-First Ship","description":"Drive a written requirements checklist to completion one item at a time — each pass implements a single unchecked requirement, proves it, and ticks it off — so the spec is the contract for done."},"dependency-audit-weekly":{"name":"Weekly Dependency Audit","description":"Each week, take stock of which packages have fallen behind, sort them into safe-to-bump versus risky, and hand back a clear upgrade plan you can act on."},"dependency-upgrade-one-by-one":{"name":"Upgrade Dependencies One at a Time","description":"Bump exactly one outdated package per pass, repair whatever the bump breaks, prove the project still works, and commit — far safer than upgrading everything at once."},"knip-until-clean":{"name":"Prune Dead Code Until Clean","description":"Hunt down unreferenced exports, orphaned files, and dependencies nobody imports, remove them safely, and keep going until the dead-code scanner has nothing left to report."},"docs-sync-after-edits":{"name":"Sync Docs to Code Changes","description":"After a round of code edits, track down every doc the changes touched — README, API reference, inline comments — and bring them back in line with how the code actually behaves now."},"security-audit-weekly":{"name":"Weekly Security Audit","description":"Run a weekly vulnerability scan over the dependency tree, triage what turns up by severity and real-world exposure, and hand back a prioritized remediation plan."},"npm-audit-fix-loop":{"name":"Patch Vulnerabilities One at a Time","description":"Clear high and critical dependency advisories deliberately — one fix per pass, each verified against the test suite — instead of a blind force-fix that can quietly break the build."},"api-contract-until-match":{"name":"API Contract Until Match","description":"Drive the implementation until its responses honor the published API contract, closing any gap between what the schema promises and what the handlers actually return."},"openapi-sync-until-valid":{"name":"OpenAPI Sync Until Valid","description":"Keep the OpenAPI document well-formed and faithful to the real route handlers, repairing spec errors and code-vs-doc drift on each pass until the linter is satisfied."},"migration-until-applied":{"name":"Migration Until Applied","description":"Bring the database schema forward cleanly: run the pending migrations, repair any schema or SQL faults they surface, and confirm migration history stays consistent."},"bundle-size-budget":{"name":"Bundle Size Budget","description":"Land the feature without inflating the client bundle past its budget — measure each pass and trim, code-split, or lazy-load until the size gate is green."},"changelog-sync-after-ship":{"name":"Changelog Sync After Ship","description":"After shipping, make sure the changelog tells the user-facing story: review what landed, write Keep-a-Changelog entries, and confirm nothing visible was missed."},"guardrails-learning-loop":{"name":"Guardrails Learning Loop","description":"Keep iterating on the gates until they go green, but every time a check fails the same way twice, write down a guardrail note first so the loop never burns iterations re-attempting an approach that already failed."},"ralph-story-executor":{"name":"Backlog Story Executor","description":"Work a backlog of user stories one at a time with a fresh context each pass: pick the next unfinished story, build only it, prove the project gates stay green, commit, and mark it done before moving on."},"investigation-script-loop":{"name":"Investigation Script Loop","description":"Pin down a bug's true cause empirically: write a tiny disposable script that exercises the suspect behaviour, run it, read the real output, and refine the probe until the output itself proves the root cause."},"reflexion-debug-loop":{"name":"Reflection Debug Loop","description":"Turn a failing test green without thrashing: each time an attempt fails, record a short reflection to disk and consult it before the next try, so the loop never repeats a fix that has already been ruled out."},"merge-conflict-resolver":{"name":"Merge Conflict Resolver","description":"Bring the branch up to date with its target by rebasing, then resolve every conflict file by file while preserving both sides' intent, and prove the result still passes before declaring the branch current."},"staging-smoke-test":{"name":"Staging Smoke Test","description":"After a staging deploy, walk a fixed smoke checklist — auth, the core user paths, and key integrations — fixing the smallest issue each time something breaks and re-running until the whole checklist comes back clean."},"deploy-verification-loop":{"name":"Deploy Verification Loop","description":"After a deploy goes out, poll the health and smoke endpoints on an interval, investigating and fixing or escalating any non-healthy response, and keep checking until every configured endpoint reports success."},"factory_openspec":{"name":"OpenSpec Lifecycle","description":"Ticket-to-archive OpenSpec lifecycle: generate artifacts (opsx:ff) → implement (opsx:apply) → verify (opsx:verify); on FAIL loop back and amend the same change, on PASS archive it unattended."}}`),b={title:n,subtitle:r,newLoop:i,sections:a,gallery:o,categories:s,status:c,empty:l,actions:u,card:d,confirmDelete:f,newLoopName:p,errors:m,builder:h,preview:g,builtInBadge:_,run:v,catalog:y,import:{done_one:`Imported {{count}} loop`,done_other:`Imported {{count}} loops`,skipped_one:`Skipped {{count}} duplicate: {{names}}`,skipped_other:`Skipped {{count}} duplicates: {{names}}`,invalid:`That file isn't a valid loops export.`}};export{t};

package/client/dist/assets/loops-CPpgMapU.js

@@ -1 +0,0 @@
-var e=`Loops`,t=`Loops de automação reutilizáveis — partilhados entre todos os seus projetos.`,n=`Novo loop`,r={drafts:`Rascunhos`,published:`Publicados`,templates:`Modelos`,builtIn:`Integrados`},i={search:`Buscar modelos…`,noResults:`Nenhum modelo corresponde aos seus filtros.`,clearFilter:`Limpar filtros`,resultCount_one:`{{count}} modelo`,resultCount_other:`{{count}} modelos`,needsSpec:`Requer spec`,standalone:`Autônoma`,needsSpecHint:`Roda em um rail com uma spec arrastada`,standaloneHint:`Roda sozinha — basta escolher um projeto`},a={API:`API`,Automation:`Automação`,CI:`CI`,Database:`Banco de dados`,Debugging:`Depuração`,DevOps:`DevOps`,Docs:`Docs`,Git:`Git`,Maintenance:`Manutenção`,Performance:`Desempenho`,Planning:`Planejamento`,Quality:`Qualidade`,Review:`Revisão`,Security:`Segurança`,Testing:`Testes`},o={draft:`Rascunho`,published:`Publicado`,running:`Em execução`},s={title:`Ainda não há loops`,body:`Crie um do zero ou comece a partir de um modelo.`},c={edit:`Editar`,delete:`Eliminar`,publish:`Publicar`,unpublish:`Despublicar`,duplicate:`Duplicar`,use:`Usar modelo`,preview:`Pré-visualização`,fork:`Bifurcar para editar`,run:`Executar`,export:`Exportar`,import:`Importar`,select:`Selecionar {{name}}`},l={nodes_one:`{{count}} nó`,nodes_other:`{{count}} nós`,usedIn:`Em uso · {{project}}`},u=`Eliminar este loop? Desaparecerá de todos os seletores de rail.`,d=`Novo loop`,f={load:`Falha ao carregar os loops`,save:`Falha ao guardar o loop`,publishInvalid:`Este loop ainda não pode ser publicado — corrija os problemas assinalados.`},p={back:`Voltar aos Loops`,save:`Guardar`,saved:`Loop guardado`,publish:`Publicar`,published:`Loop publicado`,addNode:`Adicionar nó`,deleteNode:`Eliminar nó`,config:{maxIterations:`Iterações máximas`,timeout:`Tempo limite (min)`,maxIterationsHint:`Limite de iterações do Loop Decider — o loop para ao atingi-lo mesmo que o objetivo não seja cumprido. Evita loops infinitos.`,timeoutHint:`Limite de tempo real de toda a execução, em minutos. Se excedido, a execução é interrompida e marcada como falha — uma rede de segurança junto com as iterações máximas.`,maxCost:`Custo máx ($)`,maxCostHint:`Orçamento opcional em USD para toda a execução. Verificado ENTRE passos (o custo de um passo só é conhecido ao terminá-lo), o loop para antes do próximo passo quando o total freestylepassa — pode passar um passo. Em provedores não-Claude o custo é estimado. Vazio = sem limite.`},nodes:{start:`Início`,"ai-step":`Passo de IA`,shell:`Shell`,decider:`Decisor do Loop`,condition:`Condição`,end:`Fim`},inspector:{selectNode:`Selecione um nó para o editar.`,prompt:`Prompt`,provider:`Fornecedor`,model:`Modelo`,effort:`Esforço de raciocínio`,command:`Comando`,goal:`Objetivo / critérios de paragem`,join:`Junção`,outcome:`Resultado`,startNote:`O ponto de entrada do loop. Ligue-o ao primeiro passo.`,promptHint:`Clique ou arraste um token para inseri-lo no prompt.`,tokensSpec:`Campos da spec`,tokensJira:`Jira`,tokensCommands:`Comandos`,label:`Nome`},branch:{continue:`↻ Continuar`,stop:`✓ Parar`},edgesHelp:{label:`Como as etapas se conectam`,body:`As setas definem a ORDEM de execução, não os dados — as caixas não têm portas de entrada e as conexões não carregam parâmetros. Cada AI Step retoma automaticamente sua sessão (todo o contexto anterior) mais um breve resumo das etapas anteriores; nada é ligado manualmente. O Loop Decider tem duas saídas: ↻ Continuar (objetivo não atingido → volta ao loop) e ✓ Parar (objetivo atingido → sai).`},arrange:{label:`Organizar`,vertical:`Vertical`,horizontal:`Horizontal`,grid:`Grade`,reset:`Redefinir`},constants:{label:`Constantes`,manage:`Gerenciar constantes`,title:`Constantes do loop`,empty:`Ainda não há constantes personalizadas.`,name:`NOME`,value:`valor`,add:`Adicionar`,builtinBadge:`Integradas`},paste:{done_one:`{{count}} passo colado`,done_other:`{{count}} passos colados`},problems:{count_one:`{{count}} problema`,count_other:`{{count}} problemas`,NO_START:`Adicione um nó de Início.`,MULTIPLE_START:`Só é permitido um nó de Início.`,NO_END:`Adicione pelo menos um nó de Fim.`,ORPHAN:`Este passo não é acessível a partir do Início.`,DECIDER_BRANCHES:`O Loop Decider precisa de uma ramificação Continuar e uma Parar.`,EMPTY_PROMPT:`O AI Step está com o prompt vazio.`,EMPTY_COMMAND:`O passo Shell está com o comando vazio.`,EMPTY_GOAL:`O Loop Decider não tem objetivo.`,DEAD_END:`Este passo não tem conexão de saída.`},preview:{label:`Pré-visualizar`,title:`Pré-visualização (dry-run)`,sampleNote:`Os valores do spec são exemplos; comandos e constantes são resolvidos como em execução.`,empty:`Nenhum passo para pré-visualizar.`,error:`Falha na pré-visualização`}},m={steps:`Passos`,limits:`máx. {{iterations}} iterações · {{timeout}} min de timeout`,openInBuilder:`Abrir no builder`,builtin:`Integrado`},h=`Integrado`,g={title:`Executar {{name}}`,subtitle:`Inicia este loop num projeto (sem ticket).`,project:`Projeto`,provider:`Provedor`,model:`Modelo`,effort:`Esforço de raciocínio`,execute:`Executar`,noProjects:`Sem projetos disponíveis.`,launched:`Executando {{name}}`},_=JSON.parse(`{"ship-and-green":{"name":"Ship & Green","description":"Totalmente autônomo: implementa a spec, verifica e refina (corrige) em caso de falha — repetindo verificar → corrigir → verificar até tudo ficar verde. Sem intervenção humana."},"verify-pass":{"name":"Verificação","description":"Verificação e correção autônomas: detecta e executa o build/lint/testes do projeto e, em caso de falha, refina — verificar → corrigir → verificar até ficar verde."},"ci-watch":{"name":"Monitorar CI","description":"Consulta as verificações de CI no PR aberto (o agente usa as ferramentas de CI do repositório) até que todas fiquem verdes."},"lint-and-fix":{"name":"Lint & Corrigir","description":"O agente detecta e executa o lint do projeto e corrige cada problema, iterando até o código ficar limpo."},"type-safe":{"name":"Tipos Seguros","description":"O agente detecta e executa o verificador de tipos do projeto e resolve cada erro, iterando até passar sem problemas."},"coverage-climb":{"name":"Subir Cobertura","description":"O agente executa a ferramenta de cobertura do projeto e adiciona testes focados até atingir os limites exigidos."},"build-fix":{"name":"Corrigir Build","description":"O agente detecta e executa o build de produção do projeto e corrige erros de compilação/empacotamento até ficar verde."},"deploy-check":{"name":"Checar Deploy","description":"O agente consulta o status de deploy/saúde (usando as ferramentas de deploy do projeto) até o serviço reportar que está saudável."},"factory_implement":{"name":"Implementar","description":"Totalmente autônomo: implementa a spec, verifica e refina (corrige) em caso de falha — repetindo até todos os testes passarem."},"factory_batch":{"name":"Implementar em Lote","description":"Implementa de uma vez todos os tickets do trilho e, em seguida, verifica + refina em caso de falha até ficar verde."},"factory_freestyle":{"name":"Freestyle","description":"Entrega a spec diretamente ao modelo com total liberdade — sem pipeline, ele trabalha como um agente de código normal, depois verifica + refina até ficar verde. Somente Claude."},"autoloop-tdd":{"name":"Autoloop TDD","description":"Um ciclo rigoroso de red-green-refactor para {{spec.title}}: defina cada comportamento primeiro com um teste que falha, escreva só o código necessário para deixá-lo verde e então organize — repetindo até cobrir totalmente a spec."},"e2e-until-green":{"name":"E2E até passar","description":"Rode a suíte end-to-end de {{spec.title}}, diagnostique cada fluxo de usuário que falha, corrija o defeito de UI ou integração por trás dele e siga iterando até todas as specs E2E passarem."},"flaky-test-triage":{"name":"Triagem de testes instáveis","description":"Reexecute várias vezes os testes que falham em torno de {{spec.title}} para separar regressões reais de instabilidades intermitentes, depois conserte as quebras reais e estabilize ou documente as instáveis."},"independent-verifier-pass":{"name":"Verificação independente","description":"Uma verificação adversarial de {{spec.title}}: rode build, lint e testes do zero, confie só na saída crua dos comandos (não em qualquer alegação prévia de 'funciona') e exponha ou corrija cada falha."},"post-edit-test-guard":{"name":"Teste pós-edição","description":"Após cada lote de edições em {{spec.title}}, rode imediatamente o menor conjunto de testes que toca os arquivos alterados — pegando regressões no instante em que surgem, em vez de só no final."},"post-merge-regression-guard":{"name":"Guarda pós-merge","description":"Logo após um merge ou rebase trazer o trabalho de outras pessoas para {{spec.title}}, rode o smoke test rápido para pegar quebras de integração na hora — antes de começar qualquer nova feature em cima disso."},"pre-commit-guard":{"name":"Guarda pré-commit","description":"Um portão de segurança para {{spec.title}} que intercepta cada commit: roda a suíte de testes primeiro e se recusa a commitar enquanto ela estiver vermelha, para que código quebrado nunca entre no histórico."},"visual-regression-until-match":{"name":"Regressão visual até bater","description":"Capture snapshots visuais da UI alterada, cace cada diferença de pixel não intencional e se autocorrija até a suíte visual ficar verde, com apenas as mudanças de design deliberadas aprovadas."},"format-until-clean":{"name":"Formatar até limpar","description":"Aplique o formatador do projeto, resolva os poucos problemas de estilo que ele não corrige sozinho e siga até uma nova formatação não alterar mais nada na árvore de trabalho."},"lint-typecheck-fix":{"name":"Corrigir lint e tipos","description":"Rode o lint e o verificador de tipos, resolva cada problema reportado com a menor edição possível e itere até ambos os portões voltarem completamente limpos."},"a11y-audit-until-clean":{"name":"Auditoria de a11y","description":"Rode as verificações automáticas de acessibilidade nas telas alteradas, corrija as violações uma categoria por vez e repita até a auditoria voltar sem nenhum problema."},"de-sloppify-pass":{"name":"Passada de limpeza","description":"Depois que a feature entra, varra o diff atrás de sobras desleixadas — saída de debug, ramos mortos, nomes ruins, funções inchadas — limpe tudo e comprove que a limpeza não quebrou nada."},"fix-ci-until-green":{"name":"Corrigir CI até passar","description":"Pegue a execução de CI mais recente que ficou vermelha nesta branch, reproduza a quebra na sua máquina, corrija a causa real, faça push e siga iterando até todas as checagens reportarem sucesso."},"pr-babysitter":{"name":"Babá de PRs","description":"Em intervalos recorrentes, varra os pull requests que você acompanha e mantenha cada um mergeável: reviva CI vermelho, faça rebase dos que ficaram atrás da branch base e cutuque os parados — escalando tudo o que precisa da decisão de um humano."},"pr-watch-loop":{"name":"Acompanhar PRs","description":"Consulte os pull requests da sua lista de acompanhamento em cadência constante, resuma a saúde de CI e revisão de cada um e resolva os bloqueios triviais ou destaque o que precisa de um responsável."},"pr-self-review":{"name":"Auto-revisão de PR","description":"Critique o seu próprio diff como faria um revisor sênior exigente, resolva o que encontrar e revise de novo até uma passada limpa não apontar nada crítico — antes mesmo do PR sair das suas mãos."},"spec-first-ship":{"name":"Spec primeiro","description":"Leve um checklist escrito de requisitos até o fim, um item por vez — cada passada implementa um único requisito não marcado, comprova e o risca — para que a spec seja o contrato do 'pronto'."},"dependency-audit-weekly":{"name":"Auditoria semanal de deps","description":"A cada semana, faça um balanço de quais pacotes ficaram para trás, separe-os entre seguros de atualizar e arriscados e devolva um plano de upgrade claro e acionável."},"dependency-upgrade-one-by-one":{"name":"Atualizar deps uma a uma","description":"Atualize exatamente um pacote desatualizado por passada, conserte o que a atualização quebrar, comprove que o projeto ainda funciona e commite — bem mais seguro do que atualizar tudo de uma vez."},"knip-until-clean":{"name":"Podar código morto","description":"Cace exports sem referência, arquivos órfãos e dependências que ninguém importa, remova-os com segurança e siga até o scanner de código morto não ter mais nada a reportar."},"docs-sync-after-edits":{"name":"Sincronizar docs com o código","description":"Após uma rodada de edições, rastreie cada doc que as mudanças tocaram — README, referência de API, comentários inline — e alinhe-os de novo com o real comportamento atual do código."},"security-audit-weekly":{"name":"Auditoria semanal de segurança","description":"Rode um scan semanal de vulnerabilidades sobre a árvore de dependências, faça a triagem do que aparecer por severidade e exposição real e devolva um plano de remediação priorizado."},"npm-audit-fix-loop":{"name":"Corrigir vulnerabilidades uma a uma","description":"Resolva os alertas altos e críticos de dependências de forma deliberada — uma correção por passada, cada uma verificada contra a suíte de testes — em vez de um force-fix cego que pode quebrar o build em silêncio."},"api-contract-until-match":{"name":"Contrato de API até bater","description":"Conduza a implementação até suas respostas honrarem o contrato de API publicado, fechando qualquer lacuna entre o que o schema promete e o que os handlers de fato retornam."},"openapi-sync-until-valid":{"name":"Sincronizar OpenAPI","description":"Mantenha o documento OpenAPI bem-formado e fiel aos handlers de rota reais, corrigindo erros da spec e o descompasso código-vs-doc a cada passada até o lint ficar satisfeito."},"migration-until-applied":{"name":"Migração até aplicar","description":"Leve o schema do banco adiante de forma limpa: rode as migrações pendentes, corrija qualquer falha de schema ou SQL que elas revelem e confirme que o histórico de migração permanece consistente."},"bundle-size-budget":{"name":"Orçamento de bundle","description":"Entregue a feature sem inflar o bundle do cliente além do orçamento — meça a cada passada e enxugue, faça code-split ou carregamento lazy até o portão de tamanho ficar verde."},"changelog-sync-after-ship":{"name":"Sincronizar changelog","description":"Após entregar, garanta que o changelog conte a história voltada ao usuário: revise o que entrou, escreva as entradas no padrão Keep-a-Changelog e confirme que nada visível ficou de fora."},"guardrails-learning-loop":{"name":"Loop de guardrails","description":"Siga iterando nos portões até ficarem verdes, mas toda vez que uma checagem falhar do mesmo jeito duas vezes, anote primeiro uma nota de guardrail para que o loop nunca gaste iterações tentando de novo uma abordagem que já falhou."},"ralph-story-executor":{"name":"Executor de histórias","description":"Trabalhe um backlog de histórias de usuário uma por vez, com contexto novo a cada passada: pegue a próxima história pendente, construa só ela, comprove que os portões do projeto seguem verdes, commite e marque como pronta antes de seguir."},"investigation-script-loop":{"name":"Script de investigação","description":"Identifique empiricamente a verdadeira causa de um bug: escreva um script descartável minúsculo que exercita o comportamento suspeito, rode-o, leia a saída real e refine a sonda até a própria saída provar a causa raiz."},"reflexion-debug-loop":{"name":"Debug com reflexão","description":"Deixe um teste que falha verde sem ficar patinando: cada vez que uma tentativa falha, registre uma reflexão curta em disco e consulte-a antes da próxima tentativa, para que o loop nunca repita uma correção já descartada."},"merge-conflict-resolver":{"name":"Resolver conflitos de merge","description":"Atualize a branch em relação ao alvo via rebase, depois resolva cada arquivo em conflito um a um preservando a intenção dos dois lados e comprove que o resultado ainda passa antes de declarar a branch em dia."},"staging-smoke-test":{"name":"Smoke test em staging","description":"Após um deploy em staging, percorra um checklist fixo de smoke — auth, os fluxos centrais de usuário e as integrações-chave — corrigindo o menor problema sempre que algo quebra e reexecutando até o checklist inteiro voltar limpo."},"deploy-verification-loop":{"name":"Verificação de deploy","description":"Depois que um deploy sai, consulte os endpoints de saúde e smoke em intervalos, investigando e corrigindo ou escalando qualquer resposta não saudável, e siga checando até todos os endpoints configurados reportarem sucesso."},"factory_openspec":{"name":"OpenSpec Lifecycle","description":"Ciclo OpenSpec do ticket ao arquivo: gera artefatos (opsx:ff) → implementa (opsx:apply) → verifica (opsx:verify); em FAIL volta e emenda o mesmo change, em PASS arquiva sem intervenção."}}`),v={title:e,subtitle:t,newLoop:n,sections:r,gallery:i,categories:a,status:o,empty:s,actions:c,card:l,confirmDelete:u,newLoopName:d,errors:f,builder:p,preview:m,builtInBadge:h,run:g,catalog:_,import:{done_one:`{{count}} loop importado`,done_other:`{{count}} loops importados`,skipped_one:`{{count}} duplicado ignorado: {{names}}`,skipped_other:`{{count}} duplicados ignorados: {{names}}`,invalid:`Esse arquivo não é uma exportação de loops válida.`}};export{c as actions,p as builder,h as builtInBadge,l as card,_ as catalog,a as categories,u as confirmDelete,v as default,s as empty,f as errors,i as gallery,n as newLoop,d as newLoopName,m as preview,g as run,r as sections,o as status,t as subtitle,e as title};

package/client/dist/assets/loops-CWWbKuVL.js

@@ -1 +0,0 @@
-var e=`Loops`,t=`Bucles de automatización reutilizables — compartidos entre todos tus proyectos.`,n=`Nuevo loop`,r={drafts:`Borradores`,published:`Publicados`,templates:`Plantillas`,builtIn:`Integrados`},i={search:`Buscar plantillas…`,noResults:`Ninguna plantilla coincide con los filtros.`,clearFilter:`Limpiar filtros`,resultCount_one:`{{count}} plantilla`,resultCount_other:`{{count}} plantillas`,needsSpec:`Requiere spec`,standalone:`Autónoma`,needsSpecHint:`Se ejecuta en un rail con una spec arrastrada`,standaloneHint:`Se ejecuta sola — solo elige un proyecto`},a={API:`API`,Automation:`Automatización`,CI:`CI`,Database:`Base de datos`,Debugging:`Depuración`,DevOps:`DevOps`,Docs:`Docs`,Git:`Git`,Maintenance:`Mantenimiento`,Performance:`Rendimiento`,Planning:`Planificación`,Quality:`Calidad`,Review:`Revisión`,Security:`Seguridad`,Testing:`Pruebas`},o={draft:`Borrador`,published:`Publicado`,running:`En ejecución`},s={title:`Aún no hay loops`,body:`Crea uno desde cero o empieza a partir de una plantilla.`},c={edit:`Editar`,delete:`Eliminar`,publish:`Publicar`,unpublish:`Despublicar`,duplicate:`Duplicar`,use:`Usar plantilla`,preview:`Vista previa`,fork:`Bifurcar para editar`,run:`Ejecutar`,export:`Exportar`,import:`Importar`,select:`Seleccionar {{name}}`},l={nodes_one:`{{count}} nodo`,nodes_other:`{{count}} nodos`,usedIn:`En uso · {{project}}`},u=`¿Eliminar este loop? Desaparecerá de todos los selectores de rieles.`,d=`Nuevo loop`,f={load:`No se pudieron cargar los loops`,save:`No se pudo guardar el loop`,publishInvalid:`Este loop aún no se puede publicar — corrige los problemas resaltados.`},p={back:`Volver a los loops`,save:`Guardar`,saved:`Loop guardado`,publish:`Publicar`,published:`Loop publicado`,addNode:`Añadir nodo`,deleteNode:`Eliminar nodo`,config:{maxIterations:`Iteraciones máximas`,timeout:`Tiempo límite (min)`,maxIterationsHint:`Tope de iteraciones del Loop Decider — el loop se detiene al alcanzarlo aunque no se cumpla el objetivo. Evita bucles infinitos.`,timeoutHint:`Límite de tiempo real de toda la ejecución, en minutos. Si se supera, la ejecución se detiene y se marca como fallida — una red de seguridad junto a las iteraciones máximas.`,maxCost:`Coste máx ($)`,maxCostHint:`Presupuesto opcional en USD para toda la ejecución. Se comprueba ENTRE pasos (el coste de un paso solo se sabe al terminarlo), así que el loop para antes del siguiente paso cuando el total lo supera — puede pasarse un paso. En proveedores no-Claude el coste es estimado. Vacío = sin tope.`},nodes:{start:`Inicio`,"ai-step":`Paso de IA`,shell:`Shell`,decider:`Decisor del loop`,condition:`Condición`,end:`Fin`},inspector:{selectNode:`Selecciona un nodo para editarlo.`,prompt:`Prompt`,provider:`Proveedor`,model:`Modelo`,effort:`Esfuerzo de razonamiento`,command:`Comando`,goal:`Objetivo / criterio de parada`,join:`Unión`,outcome:`Resultado`,startNote:`El punto de entrada del loop. Conéctalo al primer paso.`,promptHint:`Haz clic o arrastra un token para insertarlo en el prompt.`,tokensSpec:`Campos del spec`,tokensJira:`Jira`,tokensCommands:`Comandos`,label:`Nombre`},branch:{continue:`↻ Continuar`,stop:`✓ Detener`},edgesHelp:{label:`Cómo se conectan los pasos`,body:`Las flechas marcan el ORDEN de ejecución, no los datos: las cajas no tienen puertos de entrada y las conexiones no transportan parámetros. Cada AI Step reanuda automáticamente su sesión (con todo el contexto previo) más un resumen breve de los pasos anteriores; nada se conecta a mano. El Loop Decider tiene dos salidas: ↻ Continuar (objetivo no cumplido → volver al bucle) y ✓ Detener (objetivo cumplido → salir).`},arrange:{label:`Ordenar`,vertical:`Vertical`,horizontal:`Horizontal`,grid:`Cuadrícula`,reset:`Restablecer`},constants:{label:`Constantes`,manage:`Gestionar constantes`,title:`Constantes del loop`,empty:`Aún no hay constantes personalizadas.`,name:`NOMBRE`,value:`valor`,add:`Añadir`,builtinBadge:`Integradas`},paste:{done_one:`{{count}} paso pegado`,done_other:`{{count}} pasos pegados`},problems:{count_one:`{{count}} problema`,count_other:`{{count}} problemas`,NO_START:`Añade un nodo de Inicio.`,MULTIPLE_START:`Solo se permite un nodo de Inicio.`,NO_END:`Añade al menos un nodo de Fin.`,ORPHAN:`Este paso no es alcanzable desde Inicio.`,DECIDER_BRANCHES:`El Decisor necesita una rama Continuar y otra Detener.`,EMPTY_PROMPT:`El Paso de IA tiene el prompt vacío.`,EMPTY_COMMAND:`El paso Shell tiene el comando vacío.`,EMPTY_GOAL:`El Decisor no tiene objetivo.`,DEAD_END:`Este paso no tiene conexión de salida.`},preview:{label:`Previsualizar`,title:`Previsualización (dry-run)`,sampleNote:`Los valores del spec son de ejemplo; comandos y constantes se resuelven tal cual en ejecución.`,empty:`No hay pasos que previsualizar.`,error:`Falló la previsualización`}},m={steps:`Pasos`,limits:`máx. {{iterations}} iteraciones · {{timeout}} min de timeout`,openInBuilder:`Abrir en el builder`,builtin:`Integrado`},h=`Integrado`,g={title:`Ejecutar {{name}}`,subtitle:`Lanza este loop en un proyecto (sin ticket).`,project:`Proyecto`,provider:`Proveedor`,model:`Modelo`,effort:`Esfuerzo de razonamiento`,execute:`Ejecutar`,noProjects:`No hay proyectos disponibles.`,launched:`Ejecutando {{name}}`},_=JSON.parse(`{"ship-and-green":{"name":"Ship & Green","description":"Totalmente autónomo: implementa la spec, verifica y refina (corrige) cuando falla, encadenando verificar → corregir → verificar hasta que todo esté en verde. Sin intervención humana."},"verify-pass":{"name":"Verificación","description":"Verifica y corrige de forma autónoma: detecta y ejecuta el build, el lint y los tests del proyecto y luego refina cuando falla, encadenando verificar → corregir → verificar hasta que esté en verde."},"ci-watch":{"name":"Vigilar CI","description":"Consulta los checks de CI del PR abierto (el agente usa las herramientas de CI del repositorio) hasta que todos los checks estén en verde."},"lint-and-fix":{"name":"Lint y corregir","description":"El agente detecta y ejecuta el linter del proyecto y corrige cada incidencia, iterando hasta que el código esté limpio."},"type-safe":{"name":"Tipado seguro","description":"El agente detecta y ejecuta el comprobador de tipos del proyecto y resuelve cada error, iterando hasta que pase sin problemas."},"coverage-climb":{"name":"Subir cobertura","description":"El agente ejecuta las herramientas de cobertura del proyecto y añade tests específicos hasta superar los umbrales."},"build-fix":{"name":"Arreglar build","description":"El agente detecta y ejecuta el build de producción del proyecto y corrige los errores de compilación o de empaquetado hasta que esté en verde."},"deploy-check":{"name":"Comprobar deploy","description":"El agente consulta el estado del deploy y de salud (usando las herramientas de deploy del proyecto) hasta que el servicio se reporte saludable."},"factory_implement":{"name":"Implementar","description":"Totalmente autónomo: implementa la spec, verifica y refina (corrige) cuando falla, encadenando hasta que pasen todos los tests."},"factory_batch":{"name":"Implementar en lote","description":"Implementa de golpe todos los tickets del raíl y luego verifica y refina cuando falla hasta que esté en verde."},"factory_freestyle":{"name":"Freestyle","description":"Entrega la spec directamente al modelo con total libertad — sin pipeline, trabaja como un agente de código normal, y después verifica + refina hasta quedar en verde. Solo Claude."},"autoloop-tdd":{"name":"Autoloop TDD","description":"Un ciclo estricto de rojo-verde-refactor para {{spec.title}}: fija cada comportamiento con una prueba que falle primero, escribe solo el código justo para ponerla en verde y luego limpia, repitiendo hasta cubrir toda la spec."},"e2e-until-green":{"name":"E2E hasta verde","description":"Ejecuta la suite end-to-end de {{spec.title}}, diagnostica cada flujo de usuario que falla, corrige el defecto de UI o integración subyacente y sigue iterando hasta que todas las pruebas E2E pasen."},"flaky-test-triage":{"name":"Triaje de tests flaky","description":"Reejecuta varias veces las pruebas que fallan en torno a {{spec.title}} para distinguir regresiones reales de fallos intermitentes, luego repara las roturas reales y estabiliza o documenta las flaky."},"independent-verifier-pass":{"name":"Verificación independiente","description":"Una verificación adversarial de {{spec.title}}: reejecuta build, lint y tests desde cero, confía solo en la salida real de los comandos (no en un 'funciona' anterior) y saca a la luz o corrige cada hueco."},"post-edit-test-guard":{"name":"Guardia de tests tras editar","description":"Tras cada tanda de ediciones en {{spec.title}}, ejecuta de inmediato el conjunto más reducido de pruebas que tocan los archivos cambiados, detectando regresiones en cuanto aparecen en lugar de al final."},"post-merge-regression-guard":{"name":"Guardia tras el merge","description":"Justo después de que un merge o rebase incorpore el trabajo de otros a {{spec.title}}, ejecuta el smoke test rápido para detectar roturas de integración de inmediato, antes de empezar nada nuevo encima."},"pre-commit-guard":{"name":"Guardia pre-commit","description":"Una barrera de seguridad para {{spec.title}} que intercepta cada commit: primero ejecuta la suite de pruebas y rechaza el commit mientras esté en rojo, para que el código roto nunca entre en el historial."},"visual-regression-until-match":{"name":"Regresión visual hasta cuadrar","description":"Captura instantáneas visuales de la UI modificada, persigue cada diferencia de píxeles no intencionada y autocorrige hasta que la suite visual esté en verde, con solo los cambios de diseño deliberados aprobados."},"format-until-clean":{"name":"Formatear hasta limpio","description":"Aplica el formateador del proyecto, arregla los pocos problemas de estilo que no puede corregir solo y sigue hasta que una nueva pasada de formato deje el árbol de trabajo sin tocar."},"lint-typecheck-fix":{"name":"Arreglar lint y tipos","description":"Ejecuta el lint y el comprobador de tipos, resuelve cada problema con la edición más pequeña posible e itera hasta que ambas barreras queden completamente limpias."},"a11y-audit-until-clean":{"name":"Auditoría A11y hasta limpio","description":"Pasa las comprobaciones automáticas de accesibilidad por las pantallas modificadas, corrige las infracciones categoría a categoría y repite hasta que la auditoría no devuelva ningún problema."},"de-sloppify-pass":{"name":"Pasada de pulido","description":"Tras aterrizar la funcionalidad, peina el diff en busca de descuidos: trazas de depuración, ramas muertas, nombres flojos, funciones infladas; límpialos y demuestra que la limpieza no rompió nada."},"fix-ci-until-green":{"name":"Arreglar CI hasta verde","description":"Recupera la ejecución de CI más reciente en rojo de esta rama, reproduce la rotura en tu máquina, corrige la causa real, haz push y sigue iterando hasta que todas las comprobaciones pasen."},"pr-babysitter":{"name":"Niñera de PRs","description":"A intervalos regulares, repasa las pull requests que vigilas y mantenlas mergeables: reanima la CI en rojo, haz rebase de las que se han quedado atrás respecto a la rama base y avisa de las estancadas, escalando lo que deba decidir una persona."},"pr-watch-loop":{"name":"Vigilancia de PRs","description":"Sondea con cadencia constante las pull requests de tu lista de seguimiento, resume el estado de CI y de revisión de cada una, y o bien despacha los bloqueos triviales o señala lo que necesita un responsable."},"pr-self-review":{"name":"Autorrevisión de PR","description":"Critica tu propio diff como lo haría un revisor sénior exigente, resuelve lo que encuentres y revísalo de nuevo hasta que una pasada limpia no saque nada crítico, antes de que la PR salga de tus manos."},"spec-first-ship":{"name":"Entrega guiada por spec","description":"Lleva una checklist de requisitos hasta el final de uno en uno: cada pasada implementa un requisito sin marcar, lo demuestra y lo tacha, de modo que la spec es el contrato de lo que está hecho."},"dependency-audit-weekly":{"name":"Auditoría semanal de dependencias","description":"Cada semana revisa qué paquetes se han quedado atrás, clasifícalos entre seguros de actualizar y arriesgados, y devuelve un plan de actualización claro y accionable."},"dependency-upgrade-one-by-one":{"name":"Actualizar dependencias de una en una","description":"Actualiza exactamente un paquete obsoleto por pasada, repara lo que la subida rompa, demuestra que el proyecto sigue funcionando y haz commit; mucho más seguro que actualizar todo de golpe."},"knip-until-clean":{"name":"Podar código muerto hasta limpio","description":"Rastrea exports sin referenciar, archivos huérfanos y dependencias que nadie importa, elimínalos con seguridad y sigue hasta que el escáner de código muerto no tenga nada que reportar."},"docs-sync-after-edits":{"name":"Sincronizar docs con el código","description":"Tras una ronda de ediciones, localiza cada documento que los cambios tocaron (README, referencia de la API, comentarios en línea) y ponlos de nuevo en consonancia con cómo se comporta ahora el código."},"security-audit-weekly":{"name":"Auditoría semanal de seguridad","description":"Ejecuta un escaneo semanal de vulnerabilidades sobre el árbol de dependencias, triaja lo que aparezca por severidad y exposición real, y devuelve un plan de remediación priorizado."},"npm-audit-fix-loop":{"name":"Parchear vulnerabilidades de una en una","description":"Resuelve los avisos altos y críticos de dependencias con cuidado (una corrección por pasada, cada una verificada contra la suite de pruebas) en lugar de un force-fix a ciegas que puede romper el build en silencio."},"api-contract-until-match":{"name":"Contrato de API hasta cuadrar","description":"Lleva la implementación hasta que sus respuestas respeten el contrato de la API publicada, cerrando cualquier brecha entre lo que promete el esquema y lo que devuelven realmente los handlers."},"openapi-sync-until-valid":{"name":"Sincronizar OpenAPI hasta válido","description":"Mantén el documento OpenAPI bien formado y fiel a los handlers de ruta reales, reparando errores de la spec y la deriva entre código y documento en cada pasada hasta que el lint quede satisfecho."},"migration-until-applied":{"name":"Migración hasta aplicada","description":"Avanza el esquema de la base de datos sin sobresaltos: ejecuta las migraciones pendientes, repara los fallos de esquema o SQL que afloren y confirma que el historial de migraciones se mantiene coherente."},"bundle-size-budget":{"name":"Presupuesto de tamaño del bundle","description":"Aterriza la funcionalidad sin inflar el bundle del cliente por encima de su presupuesto: mide en cada pasada y recorta, divide el código o aplica carga diferida hasta que la barrera de tamaño esté en verde."},"changelog-sync-after-ship":{"name":"Sincronizar changelog tras entregar","description":"Tras entregar, asegúrate de que el changelog cuente la historia de cara al usuario: revisa lo que aterrizó, escribe entradas estilo Keep a Changelog y confirma que no se quedó nada visible fuera."},"guardrails-learning-loop":{"name":"Bucle de aprendizaje con guardarraíles","description":"Sigue iterando sobre las barreras hasta que pasen, pero cada vez que una comprobación falle igual dos veces, anota primero una nota de guardarraíl para que el bucle no malgaste iteraciones reintentando un enfoque que ya falló."},"ralph-story-executor":{"name":"Ejecutor de historias del backlog","description":"Trabaja un backlog de historias de usuario de una en una con contexto nuevo en cada pasada: elige la siguiente historia sin terminar, construye solo esa, demuestra que las barreras del proyecto siguen en verde, haz commit y márcala como hecha antes de seguir."},"investigation-script-loop":{"name":"Bucle de script de investigación","description":"Localiza empíricamente la causa real de un bug: escribe un script desechable diminuto que ejercite el comportamiento sospechoso, ejecútalo, lee la salida real y refina la sonda hasta que la propia salida demuestre la causa raíz."},"reflexion-debug-loop":{"name":"Bucle de depuración con reflexión","description":"Pon en verde una prueba que falla sin dar vueltas: cada vez que un intento falle, anota una breve reflexión en disco y consúltala antes del siguiente intento, para que el bucle no repita una solución ya descartada."},"merge-conflict-resolver":{"name":"Resolutor de conflictos de merge","description":"Pon la rama al día con su destino mediante rebase, luego resuelve cada conflicto archivo a archivo preservando la intención de ambos lados, y demuestra que el resultado sigue pasando antes de declarar la rama al día."},"staging-smoke-test":{"name":"Smoke test en staging","description":"Tras un despliegue en staging, recorre una checklist fija de smoke (auth, los flujos de usuario centrales y las integraciones clave), corrigiendo el problema más pequeño cada vez que algo se rompa y reejecutando hasta que toda la checklist quede limpia."},"deploy-verification-loop":{"name":"Bucle de verificación del despliegue","description":"Tras salir un despliegue, sondea a intervalos los endpoints de salud y de smoke, investiga y corrige o escala cualquier respuesta no saludable, y sigue comprobando hasta que todos los endpoints configurados reporten éxito."},"factory_openspec":{"name":"OpenSpec Lifecycle","description":"Ciclo OpenSpec de ticket a archivo: genera artefactos (opsx:ff) → implementa (opsx:apply) → verifica (opsx:verify); con FAIL vuelve atrás y enmienda el mismo change, con PASS lo archiva sin intervención."}}`),v={title:e,subtitle:t,newLoop:n,sections:r,gallery:i,categories:a,status:o,empty:s,actions:c,card:l,confirmDelete:u,newLoopName:d,errors:f,builder:p,preview:m,builtInBadge:h,run:g,catalog:_,import:{done_one:`{{count}} loop importado`,done_other:`{{count}} loops importados`,skipped_one:`Omitido {{count}} duplicado: {{names}}`,skipped_other:`Omitidos {{count}} duplicados: {{names}}`,invalid:`Ese archivo no es una exportación de loops válida.`}};export{c as actions,p as builder,h as builtInBadge,l as card,_ as catalog,a as categories,u as confirmDelete,v as default,s as empty,f as errors,i as gallery,n as newLoop,d as newLoopName,m as preview,g as run,r as sections,o as status,t as subtitle,e as title};

package/client/dist/assets/loops-Crc9It8o.js

@@ -1 +0,0 @@
-var e=`Loops`,t=`再利用可能な自動化ループ — すべてのプロジェクトで共有されます。`,n=`新しいループ`,r={drafts:`下書き`,published:`公開済み`,templates:`テンプレート`,builtIn:`組み込み`},i={search:`テンプレートを検索…`,noResults:`フィルターに一致するテンプレートがありません。`,clearFilter:`フィルターをクリア`,resultCount_one:`{{count}} 件のテンプレート`,resultCount_other:`{{count}} 件のテンプレート`,needsSpec:`スペックが必要`,standalone:`単独実行`,needsSpecHint:`スペックをドラッグした rail で実行`,standaloneHint:`単独で実行 — プロジェクトを選ぶだけ`},a={API:`API`,Automation:`自動化`,CI:`CI`,Database:`データベース`,Debugging:`デバッグ`,DevOps:`DevOps`,Docs:`ドキュメント`,Git:`Git`,Maintenance:`メンテナンス`,Performance:`パフォーマンス`,Planning:`計画`,Quality:`品質`,Review:`レビュー`,Security:`セキュリティ`,Testing:`テスト`},o={draft:`下書き`,published:`公開済み`,running:`実行中`},s={title:`ループはまだありません`,body:`ゼロから作成するか、テンプレートから始めましょう。`},c={edit:`編集`,delete:`削除`,publish:`公開`,unpublish:`公開を取り消す`,duplicate:`複製`,use:`テンプレートを使用`,preview:`プレビュー`,fork:`フォークして編集`,run:`実行`,export:`エクスポート`,import:`インポート`,select:`{{name}} を選択`},l={nodes_one:`{{count}} 個のノード`,nodes_other:`{{count}} 個のノード`,usedIn:`使用中 · {{project}}`},u=`このループを削除しますか？すべてのレールのピッカーから表示されなくなります。`,d=`新しいループ`,f={load:`ループの読み込みに失敗しました`,save:`ループの保存に失敗しました`,publishInvalid:`このループはまだ公開できません — ハイライトされた問題を修正してください。`},p={back:`ループに戻る`,save:`保存`,saved:`ループを保存しました`,publish:`公開`,published:`ループを公開しました`,addNode:`ノードを追加`,deleteNode:`ノードを削除`,config:{maxIterations:`最大反復回数`,timeout:`タイムアウト（分）`,maxIterationsHint:`Loop Decider の反復回数の上限 — 目標が未達でも到達したらループを停止。暴走ループを防ぎます。`,timeoutHint:`実行全体の実時間の上限（分）。超過すると実行は停止し失敗として記録されます — 最大反復回数と並ぶ安全策です。`,maxCost:`最大コスト ($)`,maxCostHint:`実行全体の任意の USD 予算。ステップ間で確認（各ステップの費用はそのステップ終了時にのみ判明）するため、合計が超えると次のステップ前にループを停止します（1ステップ分超過する可能性あり）。Claude 以外のプロバイダーでは費用は推定値です。空欄 = 上限なし。`},nodes:{start:`開始`,"ai-step":`AI ステップ`,shell:`シェル`,decider:`ループ判定`,condition:`条件`,end:`終了`},inspector:{selectNode:`編集するノードを選択してください。`,prompt:`プロンプト`,provider:`プロバイダー`,model:`モデル`,effort:`推論の労力`,command:`コマンド`,goal:`目標 / 停止条件`,join:`結合`,outcome:`結果`,startNote:`ループのエントリーポイント。最初のステップに接続してください。`,promptHint:`トークンをクリックまたはドラッグしてプロンプトに挿入します。`,tokensSpec:`Spec フィールド`,tokensJira:`Jira`,tokensCommands:`コマンド`,label:`名前`},branch:{continue:`↻ 続行`,stop:`✓ 終了`},edgesHelp:{label:`ステップの接続方法`,body:`矢印は実行の順序を設定するもので、データの流れではありません — ボックスには入力ポートがなく、エッジはパラメータを運びません。各 AI Step は自動的にそのセッションを再開し (これまでの完全なコンテキスト)、加えて前のステップの短い要約を引き継ぎます。手作業での配線は一切ありません。Loop Decider には 2 つの出力があります: ↻ Continue (目標未達 → ループバック) と ✓ Stop (目標達成 → 終了)。`},arrange:{label:`整列`,vertical:`垂直`,horizontal:`水平`,grid:`グリッド`,reset:`リセット`},constants:{label:`定数`,manage:`定数を管理`,title:`ループ定数`,empty:`カスタム定数はまだありません。`,name:`名前`,value:`値`,add:`追加`,builtinBadge:`組み込み`},paste:{done_one:`{{count}} 個のステップを貼り付けました`,done_other:`{{count}} 個のステップを貼り付けました`},problems:{count_one:`{{count}} 件の問題`,count_other:`{{count}} 件の問題`,NO_START:`開始ノードを追加してください。`,MULTIPLE_START:`開始ノードは1つだけ許可されます。`,NO_END:`終了ノードを少なくとも1つ追加してください。`,ORPHAN:`このステップは開始から到達できません。`,DECIDER_BRANCHES:`Loop Decider には継続と停止の分岐が必要です。`,EMPTY_PROMPT:`AI ステップのプロンプトが空です。`,EMPTY_COMMAND:`Shell ステップのコマンドが空です。`,EMPTY_GOAL:`Loop Decider に目標がありません。`,DEAD_END:`このステップには出力接続がありません。`},preview:{label:`プレビュー`,title:`ドライラン プレビュー`,sampleNote:`Spec の値はサンプルです。コマンドと定数は実行時と同じように解決されます。`,empty:`プレビューするステップがありません。`,error:`プレビューに失敗しました`}},m={steps:`ステップ`,limits:`最大 {{iterations}} 回 · {{timeout}} 分タイムアウト`,openInBuilder:`ビルダーで開く`,builtin:`ビルトイン`},h=`組み込み`,g={title:`{{name}} を実行`,subtitle:`このループをプロジェクトで実行します（チケット不要）。`,project:`プロジェクト`,provider:`プロバイダー`,model:`モデル`,effort:`推論の強度`,execute:`実行`,noProjects:`利用可能なプロジェクトがありません。`,launched:`{{name}} を実行中`},_=JSON.parse(`{"ship-and-green":{"name":"Ship & Green","description":"完全自律: spec を実装し、検証し、失敗時には修正 (refine) する — すべてがグリーンになるまで 検証 → 修正 → 検証 をループします。人手による介入は不要です。"},"verify-pass":{"name":"Verify Pass","description":"自律的な検証と修正: プロジェクトの build / lint / テストを検出して実行し、失敗時には修正 — グリーンになるまで 検証 → 修正 → 検証 を繰り返します。"},"ci-watch":{"name":"CI Watch","description":"オープンな PR の CI チェックをポーリングし (エージェントがリポジトリの CI ツールを使用)、すべてのチェックがグリーンになるまで続けます。"},"lint-and-fix":{"name":"Lint & Fix","description":"エージェントがプロジェクトの linter を検出して実行し、すべての問題を修正します。コードベースがクリーンになるまで反復します。"},"type-safe":{"name":"Type Safe","description":"エージェントがプロジェクトの型チェッカーを検出して実行し、すべてのエラーを解消します。問題なくパスするまで反復します。"},"coverage-climb":{"name":"Coverage Climb","description":"エージェントがプロジェクトのカバレッジツールを実行し、しきい値をパスするまで的を絞ったテストを追加します。"},"build-fix":{"name":"Build Fix","description":"エージェントがプロジェクトの本番 build を検出して実行し、グリーンになるまでコンパイル / バンドルのエラーを修正します。"},"deploy-check":{"name":"Deploy Check","description":"エージェントがデプロイ / ヘルスステータスをポーリングし (プロジェクトの deploy ツールを使用)、サービスが正常を報告するまで続けます。"},"factory_implement":{"name":"実装","description":"完全自律: spec を実装し、検証し、失敗時には修正 (refine) する — すべてのテストがパスするまでループします。"},"factory_batch":{"name":"一括実装","description":"レールのすべてのチケットを一度に一括実装し、失敗時にはグリーンになるまで 検証 + 修正 を行います。"},"factory_freestyle":{"name":"Freestyle","description":"スペックをそのままモデルに渡して完全な自由を与えます — パイプラインなしで通常のコーディングエージェントのように動作し、その後グリーンになるまで検証+改善します。Claude 専用。"},"autoloop-tdd":{"name":"TDD 自動ループ","description":"{{spec.title}} に対する厳格なレッド・グリーン・リファクタのサイクル。まず失敗するテストで各挙動を固定し、グリーンにする最小限のコードだけを書き、整理する。仕様を完全にカバーするまで繰り返します。"},"e2e-until-green":{"name":"グリーンまで E2E","description":"{{spec.title}} の E2E スイートを実行し、失敗したユーザーフローを一つずつ診断して、根本にある UI や連携の不具合を修正。すべての E2E が通るまでサイクルを回します。"},"flaky-test-triage":{"name":"Flaky テスト切り分け","description":"{{spec.title}} まわりの失敗テストを何度か再実行し、本物のリグレッションと不安定な flake を切り分け。実際の破損を直し、flaky なものは安定化または記録します。"},"independent-verifier-pass":{"name":"独立検証パス","description":"{{spec.title}} を敵対的に検証。ビルド・lint・テストをゼロから再実行し、過去の「動いた」という主張ではなく生のコマンド出力だけを信じて、あらゆる抜けを洗い出し修正します。"},"post-edit-test-guard":{"name":"編集後テストガード","description":"{{spec.title}} の編集をひとまとまり加えるたびに、変更ファイルに関わる最小限のテストを即座に実行。リグレッションを最後ではなく発生した瞬間に捕まえます。"},"post-merge-regression-guard":{"name":"マージ後リグレッション防止","description":"マージやリベースで他人の作業が {{spec.title}} に入った直後に高速な smoke test を実行し、連携の破損を即座に検出。新たな機能開発を上に積み始める前に手当てします。"},"pre-commit-guard":{"name":"コミット前ガード","description":"{{spec.title}} のすべてのコミットを差し止める安全ゲート。先にテストスイートを実行し、レッドの間はコミットを拒否するので、壊れたコードが履歴に入りません。"},"visual-regression-until-match":{"name":"一致までビジュアル回帰","description":"変更した UI のビジュアルスナップショットを取得し、意図しないピクセル差分をすべて追跡。承認された意図的なデザイン変更だけが残り、ビジュアルスイートがグリーンになるまで自己修正します。"},"format-until-clean":{"name":"クリーンまで整形","description":"プロジェクトのフォーマッタを適用し、自動修正できない少数のスタイル問題を片付け、再度フォーマットを実行しても作業ツリーが変化しなくなるまで続けます。"},"lint-typecheck-fix":{"name":"lint・型チェック修正","description":"linter と型チェッカーを実行し、報告された各問題を最小限の編集で解消。両方のゲートが完全にクリーンになるまでループします。"},"a11y-audit-until-clean":{"name":"クリーンまで A11y 監査","description":"変更した画面に自動アクセシビリティチェックを実行し、違反をカテゴリごとに一つずつ修正。監査の指摘がゼロになるまで繰り返します。"},"de-sloppify-pass":{"name":"雑さ除去パス","description":"機能が入った後、差分に残った雑なもの — デバッグ出力、不要な分岐、いい加減な命名、肥大した関数 — を一掃して整理し、その整理が何も壊していないことを証明します。"},"fix-ci-until-green":{"name":"グリーンまで CI 修正","description":"このブランチで直近にレッドになった CI を取得し、手元で破損を再現。本当の原因を直してプッシュし、すべてのチェックが成功するまでサイクルを回します。"},"pr-babysitter":{"name":"PR 見守り","description":"一定間隔で、見ている PR を巡回し、各 PR をマージ可能に保ちます。レッドの CI を立て直し、ベースブランチから遅れたものはリベースし、停滞したものには催促を — 人の判断が要るものはエスカレーションします。"},"pr-watch-loop":{"name":"PR 監視ループ","description":"ウォッチリストの PR を一定間隔でポーリングし、各 PR の CI とレビュー状況を要約。些細な阻害要因はその場で片付け、担当者が必要なものは表に出します。"},"pr-self-review":{"name":"PR セルフレビュー","description":"自分の作業差分を、厳しいシニアレビュアーになったつもりで批評し、見つけた点を解消。重大な指摘が出なくなるまで再レビューします — PR を手放す前に。"},"spec-first-ship":{"name":"仕様ファースト出荷","description":"要件チェックリストを一項目ずつ完了へ導きます。各パスで未チェックの要件を一つ実装して証明し、チェックを付ける — 仕様が「完了」の契約になります。"},"dependency-audit-weekly":{"name":"週次 依存監査","description":"毎週、遅れているパッケージを棚卸しし、安全に上げられるものと危ういものに仕分けて、すぐ実行できる明確なアップグレード計画を返します。"},"dependency-upgrade-one-by-one":{"name":"依存を一つずつ更新","description":"パスごとに古いパッケージを正確に一つだけ上げ、それで壊れた箇所を直し、プロジェクトがまだ動くことを証明してコミット — まとめて上げるより遥かに安全です。"},"knip-until-clean":{"name":"クリーンまでデッドコード除去","description":"参照されないエクスポート、孤立したファイル、誰も import しない依存を洗い出して安全に削除。デッドコードスキャナの報告が無くなるまで続けます。"},"docs-sync-after-edits":{"name":"ドキュメントをコードに同期","description":"コード編集を一通り終えたら、変更が触れたドキュメント — README、API リファレンス、インラインコメント — をすべて探し出し、実際の挙動に合わせて更新します。"},"security-audit-weekly":{"name":"週次 セキュリティ監査","description":"依存ツリーに対し毎週、脆弱性スキャンを実行し、出てきたものを深刻度と実際の露出度でトリアージして、優先順位付きの是正計画を返します。"},"npm-audit-fix-loop":{"name":"脆弱性を一つずつ修正","description":"依存の high・critical の勧告を慎重に解消します。パスごとに一つ修正し、それぞれをテストスイートで検証 — ビルドを静かに壊しかねない一括強制修正は避けます。"},"api-contract-until-match":{"name":"一致まで API 契約","description":"実装のレスポンスが公開された API 契約を満たすまで作業を進め、スキーマが約束する内容とハンドラが実際に返す内容との乖離を埋めます。"},"openapi-sync-until-valid":{"name":"妥当になるまで OpenAPI 同期","description":"OpenAPI ドキュメントを整形式かつ実際のルートハンドラに忠実に保ちます。仕様エラーやコードとドキュメントのずれをパスごとに直し、linter が満足するまで続けます。"},"migration-until-applied":{"name":"適用までマイグレーション","description":"データベーススキーマをきれいに前へ進めます。保留中のマイグレーションを実行し、浮かび上がったスキーマや SQL の不具合を直し、マイグレーション履歴の整合を確認します。"},"bundle-size-budget":{"name":"バンドルサイズ予算","description":"クライアントバンドルを予算超過させずに機能を投入します。パスごとに計測し、サイズゲートがグリーンになるまで削減・コード分割・遅延読み込みを行います。"},"changelog-sync-after-ship":{"name":"出荷後 Changelog 同期","description":"出荷後、changelog がユーザー向けの物語を語れているか確認します。入った変更を見直し、Keep a Changelog 形式のエントリを書き、目に見える変更が漏れていないか確かめます。"},"guardrails-learning-loop":{"name":"ガードレール学習ループ","description":"ゲートがグリーンになるまで反復しますが、同じ失敗が二度起きるたびに先にガードレールメモを書き残し、既に失敗した手を試し直してイテレーションを無駄にしないようにします。"},"ralph-story-executor":{"name":"バックログ実行","description":"ユーザーストーリーのバックログを毎回まっさらな文脈で一つずつ処理します。次の未完ストーリーを選び、それだけを作り、プロジェクトのゲートがグリーンに保たれることを証明し、コミットして完了とし、次へ進みます。"},"investigation-script-loop":{"name":"調査スクリプトループ","description":"バグの真の原因を実証的に突き止めます。疑わしい挙動を再現する使い捨ての小さなスクリプトを書いて実行し、生の出力を読み、その出力自体が根本原因を示すまでプローブを磨きます。"},"reflexion-debug-loop":{"name":"省察デバッグループ","description":"失敗するテストを空回りせずグリーンにします。試行が失敗するたびに短い省察をディスクに記録し、次の試みの前に参照することで、既に除外した修正をループが繰り返さないようにします。"},"merge-conflict-resolver":{"name":"マージ競合の解決","description":"リベースでブランチをターゲットに追従させ、両者の意図を保ちながら競合をファイルごとに解消。結果がなお通ることを証明してから、ブランチが最新になったと宣言します。"},"staging-smoke-test":{"name":"ステージング smoke test","description":"ステージングへのデプロイ後、固定の smoke チェックリスト — 認証、主要なユーザー導線、重要な連携 — をたどり、壊れるたびに最小の問題を直して再実行。チェックリスト全体がクリーンになるまで繰り返します。"},"deploy-verification-loop":{"name":"デプロイ検証ループ","description":"デプロイ後、health と smoke のエンドポイントを一定間隔でポーリングし、不健全な応答を調査して修正またはエスカレーション。設定したすべてのエンドポイントが成功を報告するまでチェックを続けます。"},"factory_openspec":{"name":"OpenSpec Lifecycle","description":"チケットからアーカイブまでの OpenSpec ライフサイクル: アーティファクト生成 (opsx:ff) → 実装 (opsx:apply) → 検証 (opsx:verify)。FAIL なら同じ change を修正しに戻り、PASS なら無人でアーカイブします。"}}`),v={title:e,subtitle:t,newLoop:n,sections:r,gallery:i,categories:a,status:o,empty:s,actions:c,card:l,confirmDelete:u,newLoopName:d,errors:f,builder:p,preview:m,builtInBadge:h,run:g,catalog:_,import:{done_one:`{{count}} 個のループをインポートしました`,done_other:`{{count}} 個のループをインポートしました`,skipped_one:`{{count}} 件の重複をスキップ：{{names}}`,skipped_other:`{{count}} 件の重複をスキップ：{{names}}`,invalid:`そのファイルは有効なループのエクスポートではありません。`}};export{c as actions,p as builder,h as builtInBadge,l as card,_ as catalog,a as categories,u as confirmDelete,v as default,s as empty,f as errors,i as gallery,n as newLoop,d as newLoopName,m as preview,g as run,r as sections,o as status,t as subtitle,e as title};

package/client/dist/assets/loops-DH2hZcbK.js

@@ -1 +0,0 @@
-var e=`Loops`,t=`Boucles d'automatisation réutilisables — partagées entre tous vos projets.`,n=`Nouvelle boucle`,r={drafts:`Brouillons`,published:`Publiées`,templates:`Modèles`,builtIn:`Intégrés`},i={search:`Rechercher des modèles…`,noResults:`Aucun modèle ne correspond à vos filtres.`,clearFilter:`Effacer les filtres`,resultCount_one:`{{count}} modèle`,resultCount_other:`{{count}} modèles`,needsSpec:`Spec requise`,standalone:`Autonome`,needsSpecHint:`S'exécute sur un rail avec une spec glissée`,standaloneHint:`S'exécute seule — il suffit de choisir un projet`},a={API:`API`,Automation:`Automatisation`,CI:`CI`,Database:`Base de données`,Debugging:`Débogage`,DevOps:`DevOps`,Docs:`Docs`,Git:`Git`,Maintenance:`Maintenance`,Performance:`Performance`,Planning:`Planification`,Quality:`Qualité`,Review:`Revue`,Security:`Sécurité`,Testing:`Tests`},o={draft:`Brouillon`,published:`Publiée`,running:`En cours`},s={title:`Aucune boucle pour l'instant`,body:`Créez-en une de zéro ou partez d'un modèle.`},c={edit:`Modifier`,delete:`Supprimer`,publish:`Publier`,unpublish:`Dépublier`,duplicate:`Dupliquer`,use:`Utiliser le modèle`,preview:`Aperçu`,fork:`Dupliquer pour éditer`,run:`Exécuter`,export:`Exporter`,import:`Importer`,select:`Sélectionner {{name}}`},l={nodes_one:`{{count}} nœud`,nodes_other:`{{count}} nœuds`,usedIn:`En cours d'utilisation · {{project}}`},u=`Supprimer cette boucle ? Elle disparaîtra de tous les sélecteurs de rail.`,d=`Nouvelle boucle`,f={load:`Échec du chargement des boucles`,save:`Échec de l'enregistrement de la boucle`,publishInvalid:`Cette boucle ne peut pas encore être publiée — corrigez les problèmes signalés.`},p={back:`Retour aux boucles`,save:`Enregistrer`,saved:`Boucle enregistrée`,publish:`Publier`,published:`Boucle publiée`,addNode:`Ajouter un nœud`,deleteNode:`Supprimer le nœud`,config:{maxIterations:`Itérations max`,timeout:`Délai (min)`,maxIterationsHint:`Plafond d'itérations du Loop Decider — la boucle s'arrête une fois atteint, même si l'objectif n'est pas rempli. Évite les boucles infinies.`,timeoutHint:`Limite de temps réel pour toute l'exécution, en minutes. Si dépassée, l'exécution est arrêtée et marquée échouée — un filet de sécurité avec le nombre max d'itérations.`,maxCost:`Coût max ($)`,maxCostHint:`Budget USD optionnel pour toute l’exécution. Vérifié ENTRE les étapes (le coût d’une étape n’est connu qu’à sa fin), la boucle s’arrête avant l’étape suivante une fois le total dépassé — peut dépasser d’une étape. Pour les fournisseurs non-Claude, le coût est estimé. Vide = aucune limite.`},nodes:{start:`Début`,"ai-step":`Étape IA`,shell:`Shell`,decider:`Décideur de boucle`,condition:`Condition`,end:`Fin`},inspector:{selectNode:`Sélectionnez un nœud pour le modifier.`,prompt:`Invite`,provider:`Fournisseur`,model:`Modèle`,effort:`Effort de raisonnement`,command:`Commande`,goal:`Objectif / critères d'arrêt`,join:`Jointure`,outcome:`Résultat`,startNote:`Le point d'entrée de la boucle. Connectez-le à la première étape.`,promptHint:`Cliquez ou glissez un jeton pour l'insérer dans le prompt.`,tokensSpec:`Champs du spec`,tokensJira:`Jira`,tokensCommands:`Commandes`,label:`Nom`},branch:{continue:`↻ Continuer`,stop:`✓ Arrêter`},edgesHelp:{label:`Comment les étapes se connectent`,body:`Les flèches définissent l'ORDRE d'exécution, pas les données — les boîtes n'ont pas de ports d'entrée et les arêtes ne transportent aucun paramètre. Chaque AI Step reprend automatiquement sa session (tout le contexte précédent) plus un bref résumé des étapes antérieures ; rien n'est câblé à la main. Le Loop Decider a deux sorties : ↻ Continuer (objectif non atteint → retour en boucle) et ✓ Arrêter (objectif atteint → sortie).`},arrange:{label:`Disposer`,vertical:`Vertical`,horizontal:`Horizontal`,grid:`Grille`,reset:`Réinitialiser`},constants:{label:`Constantes`,manage:`Gérer les constantes`,title:`Constantes du loop`,empty:`Aucune constante personnalisée.`,name:`NOM`,value:`valeur`,add:`Ajouter`,builtinBadge:`Intégrées`},paste:{done_one:`{{count}} étape collée`,done_other:`{{count}} étapes collées`},problems:{count_one:`{{count}} problème`,count_other:`{{count}} problèmes`,NO_START:`Ajoutez un nœud de départ.`,MULTIPLE_START:`Un seul nœud de départ est autorisé.`,NO_END:`Ajoutez au moins un nœud de fin.`,ORPHAN:`Cette étape n'est pas accessible depuis le départ.`,DECIDER_BRANCHES:`Le Loop Decider a besoin d'une branche Continuer et d'une branche Arrêter.`,EMPTY_PROMPT:`L'AI Step a un prompt vide.`,EMPTY_COMMAND:`L'étape Shell a une commande vide.`,EMPTY_GOAL:`Le Loop Decider n'a pas d'objectif.`,DEAD_END:`Cette étape n'a aucune connexion sortante.`},preview:{label:`Aperçu`,title:`Aperçu (dry-run)`,sampleNote:`Les valeurs du spec sont des exemples ; commandes et constantes sont résolues telles qu'à l'exécution.`,empty:`Aucune étape à prévisualiser.`,error:`Échec de l'aperçu`}},m={steps:`Étapes`,limits:`{{iterations}} itérations max · {{timeout}} min de délai`,openInBuilder:`Ouvrir dans le builder`,builtin:`Intégré`},h=`Intégré`,g={title:`Exécuter {{name}}`,subtitle:`Lance ce loop sur un projet (sans ticket).`,project:`Projet`,provider:`Fournisseur`,model:`Modèle`,effort:`Effort de raisonnement`,execute:`Exécuter`,noProjects:`Aucun projet disponible.`,launched:`Exécution de {{name}}`},_=JSON.parse(`{"ship-and-green":{"name":"Ship & Green","description":"Totalement autonome : implémente le spec, vérifie, puis corrige en cas d'échec — en bouclant vérifier → corriger → vérifier jusqu'à ce que tout soit au vert. Aucune intervention humaine."},"verify-pass":{"name":"Passe de vérification","description":"Vérification et correction autonomes : détecte et lance le build/lint/tests du projet, puis corrige en cas d'échec — vérifier → corriger → vérifier jusqu'au vert."},"ci-watch":{"name":"Surveillance CI","description":"Interroge les contrôles CI sur la PR ouverte (l'agent utilise l'outillage CI du dépôt) jusqu'à ce que chaque contrôle soit au vert."},"lint-and-fix":{"name":"Lint & correction","description":"L'agent détecte et lance le linter du projet et corrige chaque problème, en itérant jusqu'à ce que le code soit propre."},"type-safe":{"name":"Types sûrs","description":"L'agent détecte et lance le vérificateur de types du projet et résout chaque erreur, en itérant jusqu'à ce qu'il passe sans accroc."},"coverage-climb":{"name":"Montée de couverture","description":"L'agent lance l'outillage de couverture du projet et ajoute des tests ciblés jusqu'à ce que les seuils soient atteints."},"build-fix":{"name":"Correction de build","description":"L'agent détecte et lance le build de production du projet et corrige les erreurs de compilation/bundle jusqu'à ce qu'il soit au vert."},"deploy-check":{"name":"Contrôle de deploy","description":"L'agent interroge l'état de deploy/santé (à l'aide de l'outillage de deploy du projet) jusqu'à ce que le service se déclare en bonne santé."},"factory_implement":{"name":"Implémenter","description":"Totalement autonome : implémente le spec, vérifie, puis corrige en cas d'échec — en bouclant jusqu'à ce que tous les tests passent."},"factory_batch":{"name":"Implémentation par lots","description":"Implémente d'un coup tous les tickets du rail, puis vérifie et corrige en cas d'échec jusqu'au vert."},"factory_freestyle":{"name":"Freestyle","description":"Confie la spec directement au modèle en toute liberté — sans pipeline, il travaille comme un agent de code classique, puis vérifie + affine jusqu'au vert. Claude uniquement."},"autoloop-tdd":{"name":"Autoloop TDD","description":"Un cycle red-green-refactor strict pour {{spec.title}} : chaque comportement est d'abord verrouillé par un test qui échoue, puis on écrit juste ce qu'il faut de code pour le faire passer au vert, avant de nettoyer — en répétant jusqu'à couvrir entièrement la spec."},"e2e-until-green":{"name":"E2E jusqu'au vert","description":"Lance la suite E2E pour {{spec.title}}, diagnostique chaque parcours utilisateur en échec, corrige le défaut d'UI ou d'intégration sous-jacent, et continue le cycle jusqu'à ce que toutes les specs E2E passent."},"flaky-test-triage":{"name":"Tri des tests instables","description":"Relance plusieurs fois les tests en échec autour de {{spec.title}} pour distinguer les vraies régressions des instabilités passagères, puis répare les vraies casses et stabilise ou documente les tests instables."},"independent-verifier-pass":{"name":"Vérification indépendante","description":"Une vérification adversariale de {{spec.title}} : relance build, lint et tests à zéro, ne fais confiance qu'à la sortie brute des commandes (jamais à un « ça marche » antérieur), et fais remonter ou corrige chaque écart."},"post-edit-test-guard":{"name":"Garde-fou post-édition","description":"Après chaque lot de modifications pour {{spec.title}}, lance aussitôt l'ensemble de tests le plus ciblé touchant les fichiers modifiés — pour attraper les régressions dès leur apparition plutôt qu'à la fin."},"post-merge-regression-guard":{"name":"Garde anti-régression post-merge","description":"Juste après qu'un merge ou un rebase fait entrer le travail des autres dans {{spec.title}}, lance le smoke test rapide pour repérer immédiatement toute casse d'intégration — avant de bâtir de nouvelles fonctionnalités par-dessus."},"pre-commit-guard":{"name":"Garde pré-commit","description":"Un verrou de sécurité pour {{spec.title}} qui intercepte chaque commit : la suite de tests passe d'abord, et le commit est refusé tant qu'elle est au rouge, pour que du code cassé n'entre jamais dans l'historique."},"visual-regression-until-match":{"name":"Régression visuelle jusqu'à correspondance","description":"Capture des instantanés visuels de l'UI modifiée, traque chaque écart de pixels involontaire, et corrige jusqu'à ce que la suite visuelle soit au vert avec uniquement les changements de design approuvés."},"format-until-clean":{"name":"Formater jusqu'au propre","description":"Applique le formateur du projet, règle les quelques problèmes de style qu'il ne peut pas corriger automatiquement, et continue jusqu'à ce qu'un nouveau passage ne touche plus rien dans l'arbre de travail."},"lint-typecheck-fix":{"name":"Corriger lint et typage","description":"Lance le lint et le vérificateur de types, résous chaque problème signalé avec la modification la plus minime possible, et boucle jusqu'à ce que les deux contrôles reviennent parfaitement propres."},"a11y-audit-until-clean":{"name":"Audit a11y jusqu'au propre","description":"Lance les contrôles d'accessibilité automatisés sur les écrans modifiés, corrige les violations catégorie par catégorie, et répète jusqu'à ce que l'audit ne remonte plus aucun problème."},"de-sloppify-pass":{"name":"Passe de nettoyage","description":"Une fois la fonctionnalité livrée, balaie le diff pour traquer les restes négligés — sorties de debug, branches mortes, noms bâclés, fonctions surchargées — nettoie-les, et prouve que le nettoyage n'a rien cassé."},"fix-ci-until-green":{"name":"Réparer la CI jusqu'au vert","description":"Récupère le dernier run CI rouge de cette branche, reproduis la casse en local, corrige la vraie cause, pousse, et continue le cycle jusqu'à ce que tous les contrôles soient au vert."},"pr-babysitter":{"name":"Nounou de PR","description":"À intervalle régulier, passe en revue les pull requests que tu surveilles et garde chacune fusionnable : relance la CI rouge, rebase celles en retard sur la branche de base, et relance celles qui stagnent — en escaladant tout ce qui demande une décision humaine."},"pr-watch-loop":{"name":"Boucle de veille PR","description":"Interroge à cadence régulière les pull requests de ta liste de veille, résume l'état de la CI et de la revue de chacune, puis règle les blocages triviaux ou fais remonter ce qui requiert un responsable."},"pr-self-review":{"name":"Auto-revue de PR","description":"Critique ton propre diff comme le ferait un reviewer senior exigeant, corrige ce que tu trouves, et re-révise jusqu'à ce qu'un passage propre ne remonte plus rien de critique — avant même que la PR ne quitte tes mains."},"spec-first-ship":{"name":"Livrer par la spec","description":"Mène une checklist d'exigences écrite jusqu'au bout, point par point — chaque passe implémente une seule exigence non cochée, la prouve et la coche — pour que la spec soit le contrat du « terminé »."},"dependency-audit-weekly":{"name":"Audit hebdo des dépendances","description":"Chaque semaine, fais le point sur les paquets en retard, trie-les entre mises à jour sûres et risquées, et restitue un plan de montée de version clair et actionnable."},"dependency-upgrade-one-by-one":{"name":"Mettre à jour une dépendance à la fois","description":"Monte exactement un paquet obsolète par passe, répare ce que la montée casse, prouve que le projet fonctionne toujours, et committe — bien plus sûr que de tout mettre à jour d'un coup."},"knip-until-clean":{"name":"Élaguer le code mort jusqu'au propre","description":"Traque les exports non référencés, les fichiers orphelins et les dépendances que personne n'importe, supprime-les en toute sécurité, et continue jusqu'à ce que le scanner de code mort n'ait plus rien à signaler."},"docs-sync-after-edits":{"name":"Synchroniser la doc au code","description":"Après une série de modifications de code, retrouve chaque doc concernée — README, référence API, commentaires inline — et remets-la en phase avec le comportement réel du code."},"security-audit-weekly":{"name":"Audit de sécurité hebdo","description":"Lance chaque semaine un scan de vulnérabilités sur l'arbre des dépendances, trie les résultats par gravité et exposition réelle, et restitue un plan de remédiation priorisé."},"npm-audit-fix-loop":{"name":"Corriger les vulnérabilités une à une","description":"Traite les alertes de dépendances critiques et élevées de manière maîtrisée — une correction par passe, chacune vérifiée contre la suite de tests — plutôt qu'un force-fix aveugle qui peut casser le build en silence."},"api-contract-until-match":{"name":"Contrat API jusqu'à correspondance","description":"Fais évoluer l'implémentation jusqu'à ce que ses réponses respectent le contrat API publié, en comblant tout écart entre ce que le schéma promet et ce que les handlers renvoient réellement."},"openapi-sync-until-valid":{"name":"Synchroniser OpenAPI jusqu'à validité","description":"Maintiens le document OpenAPI bien formé et fidèle aux vrais handlers de routes, en corrigeant les erreurs de spec et les écarts code/doc à chaque passe jusqu'à ce que le lint soit satisfait."},"migration-until-applied":{"name":"Migration jusqu'à application","description":"Fais avancer proprement le schéma de la base : exécute les migrations en attente, répare les défauts de schéma ou de SQL qu'elles révèlent, et confirme que l'historique de migration reste cohérent."},"bundle-size-budget":{"name":"Budget de taille du bundle","description":"Livre la fonctionnalité sans faire dépasser au bundle client son budget — mesure à chaque passe puis élague, découpe le code ou charge à la demande jusqu'à ce que le seuil de taille soit au vert."},"changelog-sync-after-ship":{"name":"Synchroniser le changelog après livraison","description":"Après une livraison, assure-toi que le changelog raconte l'histoire côté utilisateur : passe en revue ce qui a été livré, rédige des entrées au format Keep a Changelog, et confirme que rien de visible n'a été oublié."},"guardrails-learning-loop":{"name":"Boucle d'apprentissage des garde-fous","description":"Itère sur les contrôles jusqu'à les faire passer au vert, mais chaque fois qu'un contrôle échoue deux fois de la même manière, note d'abord un garde-fou pour que la boucle ne gaspille jamais d'itérations à retenter une approche déjà vouée à l'échec."},"ralph-story-executor":{"name":"Exécuteur de stories du backlog","description":"Traite un backlog de user stories une à une avec un contexte neuf à chaque passe : prends la prochaine story inachevée, construis-la seule, prouve que les contrôles du projet restent au vert, committe, et marque-la terminée avant de passer à la suivante."},"investigation-script-loop":{"name":"Boucle de script d'investigation","description":"Cerne empiriquement la vraie cause d'un bug : écris un petit script jetable qui exerce le comportement suspect, lance-le, lis la sortie réelle, et affine la sonde jusqu'à ce que la sortie elle-même prouve la cause racine."},"reflexion-debug-loop":{"name":"Boucle de debug réflexive","description":"Fais passer un test en échec au vert sans tourner en rond : à chaque tentative ratée, note une courte réflexion sur disque et consulte-la avant l'essai suivant, pour que la boucle ne répète jamais une correction déjà écartée."},"merge-conflict-resolver":{"name":"Résolveur de conflits de merge","description":"Mets la branche à jour avec sa cible par un rebase, puis résous chaque fichier en conflit un par un en préservant l'intention des deux côtés, et prouve que le résultat passe toujours avant de déclarer la branche à jour."},"staging-smoke-test":{"name":"Smoke test de staging","description":"Après un déploiement en staging, déroule une checklist de smoke test fixe — auth, parcours utilisateur principaux, intégrations clés — en corrigeant le plus petit problème à chaque casse et en relançant jusqu'à ce que toute la checklist revienne propre."},"deploy-verification-loop":{"name":"Boucle de vérification de déploiement","description":"Une fois le déploiement sorti, interroge les endpoints de santé et de smoke test à intervalle régulier, en investiguant et corrigeant ou escaladant toute réponse non saine, et continue de vérifier jusqu'à ce que chaque endpoint configuré reporte un succès."},"factory_openspec":{"name":"OpenSpec Lifecycle","description":"Cycle OpenSpec du ticket à l'archive : générer les artefacts (opsx:ff) → implémenter (opsx:apply) → vérifier (opsx:verify) ; en cas de FAIL, reboucle et amende le même change ; en cas de PASS, archive sans intervention."}}`),v={title:e,subtitle:t,newLoop:n,sections:r,gallery:i,categories:a,status:o,empty:s,actions:c,card:l,confirmDelete:u,newLoopName:d,errors:f,builder:p,preview:m,builtInBadge:h,run:g,catalog:_,import:{done_one:`{{count}} loop importé`,done_other:`{{count}} loops importés`,skipped_one:`{{count}} doublon ignoré : {{names}}`,skipped_other:`{{count}} doublons ignorés : {{names}}`,invalid:`Ce fichier n'est pas un export de loops valide.`}};export{c as actions,p as builder,h as builtInBadge,l as card,_ as catalog,a as categories,u as confirmDelete,v as default,s as empty,f as errors,i as gallery,n as newLoop,d as newLoopName,m as preview,g as run,r as sections,o as status,t as subtitle,e as title};