specrails-desktop 2.58.0 → 2.59.0

package/server/dist/modules/loops/runtime/loop-graph.js

@@ -1,14 +1,4 @@
 "use strict";
-/**
- * Loop graph model + validation — the pure core shared by the canvas builder
- * (`loop-builder-canvas`) and the publish gate (`loops-store.publishLoop`).
- *
- * A loop is a directed graph of typed nodes connected by edges. Cycles are
- * allowed (a loop routes back to an earlier node); the run is bounded by the
- * graph's `config.maxIterations` + `timeoutMinutes`. This module has NO I/O and
- * NO provider knowledge — it only describes and validates the shape, so it is
- * trivially unit-testable and reused verbatim by both the store and the engine.
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CORE_NODE_KINDS = void 0;
 exports.isDefinitionReviewerPath = isDefinitionReviewerPath;
@@ -24,8 +14,8 @@ exports.successors = successors;
 exports.loopNeedsTicket = loopNeedsTicket;
 exports.interpolateSpec = interpolateSpec;
 exports.CORE_NODE_KINDS = ['prompt', 'role-turn', 'decider', 'condition', 'assign', 'verify', 'shell',
-    'openspec-validate', 'openspec-archive', 'approval', 'question', 'gate', 'map', 'join',
-    'component', 'implementation', 'end'];
+    'artifact-contract', 'openspec-validate', 'openspec-archive', 'approval', 'question', 'gate', 'map', 'join',
+    'component', 'implementation', 'implementation-step', 'end'];
 function isDefinitionReviewerPath(graph, value) {
     if (typeof value !== 'string' || !value || value.length > 2048)
         return false;
@@ -38,7 +28,7 @@ function isDefinitionReviewerPath(graph, value) {
         if (!node || node.type !== 'core')
             return false;
         if (index === segments.length - 1)
-            return node.data?.kind === 'role-turn';
+            return node.data?.kind === 'role-turn' || node.data?.kind === 'implementation-step' && node.data.params?.phase === 'reviewer';
         const ref = node.data?.kind === 'component' ? node.data.params?.ref : node.data?.kind === 'map' ? node.data.params?.body : undefined;
         body = typeof ref === 'string' ? graph.components?.[ref] : undefined;
     }
@@ -176,6 +166,7 @@ function validateLoopGraph(graph, catalog) {
         (cfg.maxCostUsd !== undefined && !Number.isFinite(cfg.maxCostUsd)) ||
         (cfg.maxTransitions !== undefined && (!Number.isInteger(cfg.maxTransitions) || cfg.maxTransitions < 1 || cfg.maxTransitions > 10000)) ||
         (cfg.maxTokens !== undefined && (!Number.isInteger(cfg.maxTokens) || cfg.maxTokens < 1)) ||
+        (cfg.ticketScope !== undefined && !['all', 'per-ticket'].includes(cfg.ticketScope)) ||
         (cfg.reviewerStepId !== undefined && !isDefinitionReviewerPath(graph, cfg.reviewerStepId))) {
         errors.push({
             code: 'INVALID_CONFIG',
@@ -300,7 +291,7 @@ function loopNeedsTicket(graph) {
     if (!graph)
         return false;
     for (const node of graph.nodes) {
-        if (node.type === 'core' && node.data?.kind === 'implementation')
+        if (node.type === 'core' && ['implementation', 'implementation-step'].includes(node.data?.kind ?? ''))
             return true;
         const text = [node.data?.prompt, node.data?.command, node.data?.goal,
             node.type === 'core' ? JSON.stringify(node.data?.params) : undefined]

package/server/dist/modules/loops/runtime/loop-implement-recipe.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configurableImplementGraph = configurableImplementGraph;
+const loop_agents_1 = require("./loop-agents");
+const objectSchema = (properties, required = Object.keys(properties)) => ({ type: 'object', properties, required, additionalProperties: false });
+const string = { type: 'string' };
+const strings = { type: 'array', items: string, maxItems: 100 };
+const score = { type: 'number', minimum: 0, maximum: 100 };
+const aspects = { type_correctness: 60, pattern_adherence: 60, test_coverage: 60, security: 75, architectural_alignment: 60 };
+/** The recipe, roles, schemas and decisions are Desktop data, never Core phases. */
+function configurableImplementGraph() {
+    const agents = (0, loop_agents_1.defaultLoopAgents)();
+    agents.roles = {
+        plan: { ...agents.agents.architect, access: 'read', artifacts: 'all', openspecSkill: 'openspec-ff-change', prompt: agents.rolePrompts?.architect },
+        build: { ...agents.agents.developer, access: 'write', artifacts: 'tasks-checkboxes', openspecSkill: 'openspec-apply-change', prompt: agents.rolePrompts?.developer },
+        assess: { ...agents.agents.reviewer, access: 'read', artifacts: 'none', openspecSkill: 'openspec-verify-change', prompt: agents.rolePrompts?.reviewer },
+        correct: { ...agents.fixer, access: 'write', artifacts: 'tasks-checkboxes', openspecSkill: 'openspec-apply-change', prompt: agents.rolePrompts?.fixer },
+    };
+    const nodes = [{ id: 'start', type: 'start', position: { x: 0, y: 0 } }], edges = [];
+    const node = (id, label, kind, params, outcomes) => {
+        nodes.push({ id, type: 'core', position: { x: 0, y: nodes.length * 140 }, data: { kind, label, params } });
+        for (const [outcome, target] of Object.entries(outcomes))
+            edges.push({ id: `e-${id}-${outcome}`, source: id, target, label: outcome });
+    };
+    const turn = (id, label, roleId, prompt, schema, next) => node(id, label, 'role-turn', { roleId, prompt, structuredOutput: schema, sessionContinuity: 'none' }, { next, invalid: 'failed', failed: 'failed' });
+    const change = '{{run.changeId}}';
+    turn('architect', 'Architect', 'plan', `Plan the frozen ticket requirements for OpenSpec change ${change}. Use the bound official fast-forward skill. Author complete proposal, design, delta specs and actionable tasks. Propose existing repository verification commands for repositories with no configured checks. Return confidence, question (empty when none), and verification [{repositoryId,command,args,cwd?}]. When revisiting low confidence, investigate the missing repository evidence before asking again. Context and human answers: {{history.text}}`, objectSchema({ confidence: { enum: ['high', 'medium', 'low'] }, question: string, verification: { type: 'array', maxItems: 20, items: objectSchema({ repositoryId: string, command: string, args: strings, cwd: string }, ['repositoryId', 'command', 'args']) } }), 'confidence');
+    node('confidence', 'Planning confidence', 'condition', { expr: '$outputs.architect.structured.confidence != "low"' }, { true: 'validate', false: 'investigate' });
+    node('investigate', 'Investigate low confidence once', 'condition', { expr: '!exists($vars.planInvestigated) || $vars.planInvestigated == false' }, { true: 'mark-investigated', false: 'clarify' });
+    node('mark-investigated', 'Mark confidence investigation', 'assign', { set: { planInvestigated: true } }, { next: 'architect', failed: 'failed' });
+    node('clarify', 'Clarify plan', 'question', { text: '{{outputs.architect.structured.question}}' }, { next: 'reset-confidence' });
+    node('reset-confidence', 'Reset confidence after answer', 'assign', { set: { planInvestigated: false } }, { next: 'architect', failed: 'failed' });
+    node('validate', 'Validate OpenSpec', 'openspec-validate', { change }, { pass: 'freeze', fail: 'architect', failed: 'failed' });
+    node('freeze', 'Freeze approved artifacts', 'artifact-contract', { change, contractId: 'plan', action: 'freeze' }, { pass: 'developer', fail: 'architect', failed: 'failed' });
+    const implementation = objectSchema({ summary: string, incomplete: strings });
+    turn('developer', 'Developer', 'build', `Implement every approved task for change ${change} using the bound official apply skill. Preserve proposal, design and specs; only tick tasks you completed. Report summary and incomplete task descriptions. Prior execution evidence and human answers: {{history.text}}`, implementation, 'tasks');
+    node('tasks', 'Check artifacts and completed tasks', 'artifact-contract', { change, contractId: 'plan', action: 'check', requireCompletedTasks: true }, { pass: 'verify', fail: 'developer', failed: 'failed' });
+    node('verify', 'Verify candidate', 'verify', { commands: 'configured', additionalCommandsFrom: 'architect' }, { pass: 'reviewer', fail: 'fixer', failed: 'failed' });
+    turn('reviewer', 'Reviewer', 'assess', `Review change ${change} read-only against all approved artifacts and frozen ticket acceptance criteria. Inspect real code and the host verification evidence: {{outputs.verify}}. Return approved, summary, issues, score (0-100), and aspects. Prior execution: {{history.text}}`, objectSchema({ approved: { type: 'boolean' }, summary: string, issues: strings, score, aspects: objectSchema(Object.fromEntries(Object.keys(aspects).map(aspect => [aspect, score]))) }), 'review-policy');
+    node('review-policy', 'Review acceptance policy', 'condition', { expr: ['$outputs.reviewer.structured.approved == true', '$outputs.reviewer.structured.issues.length == 0', '$outputs.reviewer.structured.score >= 70', ...Object.entries(aspects).map(([aspect, threshold]) => `$outputs.reviewer.structured.aspects.${aspect} >= ${threshold}`)].join(' && ') }, { true: 'approve', false: 'fixer' });
+    turn('fixer', 'Fixer', 'correct', `Correct only failures in change ${change}, using the bound apply skill and preserving approved artifacts. Report summary and incomplete tasks. Host verification: {{outputs.verify}}.  Prior execution: {{history.text}}`, implementation, 'tasks');
+    node('approve', 'Approve archive', 'approval', { reason: `Approve archiving the reviewed and verified candidate for change ${change}.`, bindCandidate: true, enabled: agents.approvalBeforeArchive === true }, { next: 'approval-policy' });
+    node('approval-policy', 'Approval decision', 'condition', { expr: '$outputs.approve.response.approved == true' }, { true: 'archive', false: 'failed' });
+    node('archive', 'Archive OpenSpec', 'openspec-archive', { change, allowArchived: true, requiresVerified: true, reviewedCandidate: '{{outputs.reviewer.candidateHash}}', approvedCandidate: '{{outputs.approve.candidateHash}}' }, { next: 'verify-archive', failed: 'verify' });
+    node('verify-archive', 'Verify archived candidate', 'verify', { commands: 'configured', additionalCommandsFrom: 'architect' }, { pass: 'done', fail: 'failed', failed: 'failed' });
+    nodes.push({ id: 'done', type: 'end', position: { x: 0, y: nodes.length * 140 }, data: { outcome: 'success', requiresVerified: true } }, { id: 'failed', type: 'end', position: { x: 360, y: nodes.length * 140 }, data: { outcome: 'failure' } });
+    edges.unshift({ id: 'e-start', source: 'start', target: 'architect' });
+    return { nodes, edges, config: { maxIterations: 12, maxTransitions: 200, timeoutMinutes: 0, aiStepTimeoutMinutes: 0, change: 'new', journal: 'ledger-only', ticketScope: 'all', agents, reviewerStepId: 'reviewer' } };
+}

package/server/dist/modules/loops/runtime/loop-run-manager.js

@@ -498,7 +498,7 @@ class LoopRunManager {
         if ((0, loop_graph_1.isDefinitionGraph)(graph)) {
             if (!this.executors.runDefinition)
                 throw new Error('engine_unsupported: Core workflow execution is unavailable');
-            await this.executors.assertDefinitionSupport?.();
+            await this.executors.assertDefinitionSupport?.(graph);
         }
         else
             await this.executors.assertLegacyEngineSupport?.();
@@ -1422,7 +1422,7 @@ class LoopRunManager {
                             const effectiveTimeoutMs = Number.isFinite(remainingMs)
                                 ? Math.max(1, Math.min(aiStepTimeoutMs === 0 ? Infinity : (aiStepTimeoutMs ?? 15 * 60_000), remainingMs))
                                 : aiStepTimeoutMs;
-                            const coreRun = { runId, implementation: requiresCoreCompletion, spec: req.spec, goal: req.spec ? undefined : JSON.stringify({ loop: req.loopName, graph: req.graph }), repositoryId: req.repositoryId, verificationStep: node.data?.requireVerificationPass === true || /\{\{\s*cmd:(?:verify|revision-verify|opsx:verify)\s*\}\}/.test(rawTemplate) };
+                            const coreRun = { runId, implementation: requiresCoreCompletion, spec: req.spec, goal: req.spec ? undefined : JSON.stringify({ loop: req.loopName, graph: req.graph }), repositoryId: req.repositoryId, workspacePaths: req.workspacePaths, verificationStep: node.data?.requireVerificationPass === true || /\{\{\s*cmd:(?:verify|revision-verify|opsx:verify)\s*\}\}/.test(rawTemplate) };
                             const interactivePlan = this.executors.planInteractiveAiStep?.({
                                 coreRun,
                                 provider: nodeProvider,
@@ -1552,7 +1552,7 @@ class LoopRunManager {
                             && requiresCoreCompletion
                             && this.executors.validateCoreCompletion) {
                             const completion = this.executors.validateCoreCompletion({
-                                coreRun: { runId, spec: req.spec, goal: req.spec ? undefined : JSON.stringify({ loop: req.loopName, graph: req.graph }), repositoryId: req.repositoryId },
+                                coreRun: { runId, spec: req.spec, goal: req.spec ? undefined : JSON.stringify({ loop: req.loopName, graph: req.graph }), repositoryId: req.repositoryId, workspacePaths: req.workspacePaths },
                                 provider: nodeProvider, model: nodeModel, effort: nodeEffort, profileName: req.profileName,
                                 cwd: req.cwd, repoDir: req.repoDir, executionManifest: req.executionManifest,
                             });

package/server/dist/modules/loops/runtime/loop-templates.js

@@ -8,6 +8,8 @@ exports.coreStarterGraph = coreStarterGraph;
 exports.supportsCoreTemplates = supportsCoreTemplates;
 exports.loopTemplatesForCapabilities = loopTemplatesForCapabilities;
 exports.getLoopTemplate = getLoopTemplate;
+const loop_core_factory_1 = require("./loop-core-factory");
+const loop_agents_1 = require("./loop-agents");
 /** Closed taxonomy a template's `category` must belong to. Single source of truth
  *  for the gallery's category chips (the client derives its chip list from the
  *  categories actually present in the served catalog). */
@@ -303,7 +305,8 @@ exports.LEGACY_LOOP_TEMPLATES = exports.LOOP_TEMPLATES;
 // - every mutating starter runs the real `verify` piece over the project's
 //   configured checks and ends with `requiresVerified: true` — a passing sentinel
 //   alone never reaches a success end;
-// - ship-and-green = native `implementation` → verify → decider → prompt(fix) loop;
+// - ship-and-green expands implementation operations when supported, then
+//   verify → decider → prompt(fix); old Core retains the compatibility wrapper;
 // - prompts, goals and iteration caps come from STARTER_TEXT (legacy parity).
 /** Fix step shared by every mutating Core starter. Reuses the tuned `{{cmd:fix}}`
  *  contract and covers the verify→fix edge, where no Decider verdict precedes it. */
@@ -324,7 +327,7 @@ function watcherVerdict(goal) {
 const CORE_GOAL_EVIDENCE = 'The configured host verification already passed on the current candidate before this decision. Judge only from concrete evidence in the history (commands run, their output, files changed); green baseline checks, setup or planning alone do not prove the goal.';
 const SHIP_AND_GREEN_GOAL = 'Stop only when the history proves the spec is implemented: every acceptance criterion maps to real code and behavioral evidence across every selected ticket and repository, and the configured host verification passed on the current candidate. Setup, planning, a launched subagent or green baseline checks alone are insufficient; continue when work is missing or incomplete.';
 /** Wall-clock cap for starters (legacy default). ship-and-green is untimed like the
- *  Implement factory: the native implementation piece runs the whole pipeline. */
+ *  Implement factory: implementation operations retain their own execution limits. */
 const STARTER_TIMEOUT_MIN = 30;
 const CORE_STARTER_SHAPES = {
     'ship-and-green': 'ship',
@@ -338,8 +341,10 @@ const CORE_STARTER_SHAPES = {
 };
 /** Core definition graph for one of the eight starters. Deterministic: same id ⇒
  *  structurally identical graph (positions included). */
-function coreStarterGraph(id) {
+function coreStarterGraph(id, independent = false, configurable = false) {
     const shape = CORE_STARTER_SHAPES[id];
+    if (shape === 'ship' && configurable)
+        return (0, loop_core_factory_1.coreFactoryGraph)('implement', true, true);
     const { prompt, goal, maxIterations } = STARTER_TEXT[id];
     const nodes = [{ id: 'start', type: 'start', position: { x: COL_X, y: 0 } }];
     const edges = [];
@@ -381,10 +386,29 @@ function coreStarterGraph(id) {
     }
     edges.unshift({ id: 'e-start', source: 'start', target: entry });
     nodes.push({ id: 'done', type: 'end', position: { x: COL_X, y: ROW_GAP * nodes.length }, data: successEnd }, { id: 'failed', type: 'end', position: { x: COL_RIGHT_X, y: ROW_GAP * nodes.length }, data: { outcome: 'failure' } });
+    if (independent) {
+        config.agents = (0, loop_agents_1.defaultLoopAgents)(shape === 'ship' ? 'implementation' : 'free');
+        if (shape === 'ship') {
+            const operations = (0, loop_core_factory_1.coreFactoryGraph)('implement', true);
+            const path = (id) => id === 'done' ? 'verify' : id === 'failed' ? 'failed' : `implementation-${id}`;
+            nodes.splice(nodes.findIndex(node => node.id === 'implement'), 1);
+            const remove = new Set(edges.filter(edge => edge.source === 'implement').map(edge => edge.id));
+            for (let i = edges.length - 1; i >= 0; i--)
+                if (remove.has(edges[i].id))
+                    edges.splice(i, 1);
+            for (const edge of edges)
+                if (edge.target === 'implement')
+                    edge.target = path('architect');
+            for (const node of operations.nodes.filter(node => node.type === 'core'))
+                nodes.push({ ...node, id: path(node.id) });
+            for (const edge of operations.edges.filter(edge => edge.source !== 'start'))
+                edges.push({ ...edge, id: 'implementation-' + edge.id, source: path(edge.source), target: path(edge.target) });
+        }
+    }
     return { nodes, edges, config };
 }
 const CORE_STARTER_DESCRIPTIONS = {
-    'ship-and-green': 'Fully autonomous: run Core\'s native implementation pipeline for the spec, then verify with the project\'s configured checks and refine (fix) on failure — verify → decide → fix until green. Success requires a verified candidate; no human intervention.',
+    'ship-and-green': 'Fully autonomous: run the loop\'s implementation steps for the spec, then verify with the project\'s configured checks and refine (fix) on failure — verify → decide → fix until green. Success requires a verified candidate; no human intervention.',
     'verify-pass': 'Autonomous verify-and-fix: run the project\'s configured build/lint/tests through Core\'s verify piece, then refine on failure — verify → fix → verify until green.',
     'ci-watch': 'Poll CI checks on the open PR (the agent uses the repo\'s CI tooling) until every check is green. Read-only: the watcher never edits the repository.',
     'lint-and-fix': 'The agent detects and runs the project\'s linter and fixes every issue, iterating until the codebase is clean. Every pass is confirmed by the project\'s configured verification before the loop can succeed.',
@@ -414,7 +438,7 @@ function loopTemplatesForCapabilities(capabilities) {
             ...template,
             description: CORE_STARTER_DESCRIPTIONS[template.id],
             ...(readOnly ? { readOnly: true } : {}),
-            graph: coreStarterGraph(template.id),
+            graph: coreStarterGraph(template.id, capabilities?.implementationSteps === 1, capabilities?.workflowAgentSteps === 1),
         };
     });
 }

package/server/dist/modules/loops/runtime/loops-router.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerLoopsRoutes = registerLoopsRoutes;
+const loop_agents_1 = require("./loop-agents");
+const agent_runtime_settings_1 = require("../../agent-runtime/runtime/agent-runtime-settings");
 const ids_1 = require("../../../ids");
 const feature_flags_1 = require("../../../feature-flags");
 const loops_store_1 = require("./loops-store");
@@ -57,6 +59,12 @@ function registerLoopsRoutes(router, deps) {
         }
         return true;
     }
+    router.get('/loop-agent-defaults', async (_req, res) => {
+        if (!guard(res))
+            return;
+        const runtime = await (0, agent_runtime_loader_1.loadCoreAgentRuntime)().catch(() => null);
+        res.json({ agents: (0, loop_agents_1.defaultLoopAgents)(), guardrails: { supported: runtime?.api?.capabilities?.configurableGuardrails === 1, catalog: runtime?.api?.guardrails ?? [] } });
+    });
     // ── Templates ──────────────────────────────────────────────────────────────
     router.get('/loop-templates', async (_req, res) => {
         if (!guard(res))
@@ -410,6 +418,15 @@ function registerLoopsRoutes(router, deps) {
                     res.status(409).json({ error: 'engine_unsupported', message: 'Update Core to publish executable workflows.' });
                     return;
                 }
+                if (current.graph.config.agents) {
+                    try {
+                        (0, agent_runtime_settings_1.validateLoopRuntimeSettings)(current.graph.config.agents);
+                    }
+                    catch (error) {
+                        res.status(422).json({ error: 'invalid_loop_agents', message: error instanceof Error ? error.message : 'Invalid loop agent settings' });
+                        return;
+                    }
+                }
                 let draft;
                 try {
                     draft = (0, loop_definition_1.compileLoopToDefinition)(current.graph, { id: current.id, title: current.name, constants: (0, loop_constants_1.loadConstantMap)(db), provider: 'claude', spec: { id: 1, title: 'Sample spec', description: 'Publication preview' } });

package/server/dist/modules/missions/runtime/agent-context-resolver.js

@@ -149,7 +149,7 @@ function formatProjectOverview(ref, index, deps) {
         lines.push('resolution: unresolved project');
         return lines.join('\n');
     }
-    lines.push(`project.id: ${project.id}`, `project.name: ${safe(project.name, 180)}`, `project.slug: ${safe(project.slug, 120)}`, `project.path: ${project.path}`, `project.provider: ${safe(project.provider, 80)}`, `project.providers: ${(project.providers ?? [project.provider]).join(', ')}`, `project.runtime: ${context ? 'available' : 'unavailable; do not interpret this as a deleted project'}`, `project.repositories: ${JSON.stringify((0, project_repositories_1.getProjectRepositories)(project).map(repository => ({ id: repository.id, name: repository.name, path: repository.path, isPrimary: repository.isPrimary, kind: repository.kind, available: repository.available })))}`, 'repository.scope: One shared project backlog. Files and Git operations require repositoryId when more than one member exists; find/search can discover across members. Reading context does not grant implementation write access. Historical specs without repositoryIds target only the primary.');
+    lines.push(`project.id: ${project.id}`, `project.name: ${safe(project.name, 180)}`, `project.slug: ${safe(project.slug, 120)}`, `project.path: ${project.path}`, `project.provider: ${safe(project.provider, 80)}`, `project.providers: ${(project.providers ?? [project.provider]).join(', ')}`, `project.runtime: ${context ? 'available' : 'unavailable; do not interpret this as a deleted project'}`, `project.repositories: ${JSON.stringify((0, project_repositories_1.getProjectRepositories)(project).map(repository => ({ id: repository.id, name: repository.name, path: repository.path, workspacePaths: repository.workspacePaths ?? [repository.workspacePath ?? repository.path], isPrimary: repository.isPrimary, kind: repository.kind, available: repository.available })))}`, 'repository.scope: One shared project backlog. Files and Git operations require repositoryId when more than one member exists; find/search can discover across members. Reading context does not grant implementation write access. Historical specs without repositoryIds target only the primary.');
     try {
         const tickets = Object.values((0, ticket_store_1.readStore)(ticketFileFor(project)).tickets);
         const counts = tickets.reduce((acc, ticket) => {

package/server/dist/modules/missions/runtime/agent-operator-prompt.js

@@ -628,6 +628,13 @@ summary later.
   N-1. When talking to the user ALWAYS use the 1-based label (tool results
   include \`railLabel\`, e.g. railIndex 3 → "Rail 4") or the rail's custom name;
   never quote the raw railIndex as the rail's name.
+- Code workspace selection: discover \`workspacePaths\` in the project context. A
+  project folder can contain several code workspaces; tests must run in the
+  workspace being changed. Include \`workspaceSelection\` (repository ID → array
+  of registered workspace paths) in rail-launch cards and direct launch calls to
+  target a subset. Preserve \`repositoryIds\` for affected Git memberships. Do not
+  invent paths or substitute the parent folder. Omission uses every configured
+  workspace for each affected membership.
 - Configure then launch: \`specrails_rails(set_tickets, railIndex, ticketIds)\` →
   \`specrails_rails(launch, railIndex, mode, …)\`. Setting a profile and then
   switching the rail's engine to a provider without profile support
@@ -657,15 +664,15 @@ summary later.
   relaunch strategy even when \`main\` did not have that spec before the PR. If
   asked why a strategy was chosen, verify against active PR contents before
   answering.
-- **"Change something about work already delivered" = a Quick SDD continuation.** When
+- **"Change something about work already delivered" = a delivery continuation.** When
   the user asks for a modification to a delivery that is awaiting their decision
   (any non-terminal card: \`on_review\`, \`pr_draft\`, \`pr_ready\`, \`no_changes\`,
   \`implementation_failed\`), call \`specrails_rails(launch)\` with
   \`revisionOfDeliveryId\` = that card's \`prDeliveryId\` and \`revisionNote\` = what
   they asked for, in their own words. Do NOT tell them to publish, discard or
-  merge first, and do NOT relaunch the ordinary implement mode: a revision
-  always uses Quick SDD: pass \`loopId:'factory:sdd-quick-openspec'\` alongside the delivery
-  target. The server preserves the branch while running Quick SDD. The rail must still carry exactly that delivery's
+  merge first. Respect the user's explicit loop selection, including Implement:
+  pass that loopId alongside the delivery target. Without a preference, use
+  \`loopId:'factory:sdd-quick-openspec'\`. The server preserves the branch. The rail must still carry exactly that delivery's
   specs; a mismatch returns \`invalid_revision_target\`, which means re-check the
   rail's spec assignment rather than retrying blindly.
 - **"Resolve / fix the review comments on this PR" = a FOLLOW-UP launch, never a
@@ -706,9 +713,9 @@ summary later.
   \`dismiss_addendum\` withdraws it. Prefer an addendum + normal launch over a
   \`revisionNote\` when the change should stay attached to the spec for later
   runs; the two combine freely.
-  **Addenda on an existing branch/open PR ALWAYS run Quick SDD**, never Revision.
-  Use \`loopId:'factory:sdd-quick-openspec'\`; the server routes addenda there
-  even if the rail stores a different loop. A same-spec pending delivery is
+  **Respect explicit loop selection for addenda**, including Implement.
+  Recommend Quick SDD when no preference was given; never silently replace
+  Implement with Quick SDD after agreeing to use Implement. A same-spec pending delivery is
   continued without requiring publish/discard first. Keep the exact ticket and
   repository scope; pass the delivery id when known. The runtime assigns a NEW
   run-specific OpenSpec change for the frozen addenda, so NEVER edit
@@ -889,6 +896,8 @@ never as a launch):
   \`null\` means "the rail's / project's default".
 - \`targetPrNumber\` / \`baseBranch\`: only when the user named an existing PR
   or a branch to stack on.
+- \`repositoryIds\`: selected registered repository memberships, consistent with the specs.
+- \`workspaceSelection\`: optional object mapping each selected repository id to a non-empty array of registered workspace paths. Discover paths from project context; never invent them. Omission uses every configured workspace. The card lets the user edit this choice before Play.
 - \`rationale\`: ONE sentence — why this grouping / engine.
 
 Prose around the block: say what you propose in one or two lines and stop —
@@ -916,7 +925,7 @@ investigate and fix. Read runtime_diagnose before recommending a retry.
 function buildOperatorInstructions() {
     return (0, feature_flags_1.isMissionRailCardsEnabled)() ? `${exports.OPERATOR_INSTRUCTIONS}\n${exports.RAIL_LAUNCH_CARD_SECTION}` : exports.OPERATOR_INSTRUCTIONS;
 }
-exports.RAIL_LAUNCH_CARD_SYSTEM_CLAUSE = ' When the user asks to assign, prepare or launch specs on a rail WITHOUT explicitly saying to launch now, do not call specrails_rails launch — emit one fenced rail-launch JSON block per rail (ticketIds, railIndex or newRail, mode, loopId, aiEngine, model, reasoningEffort, profileName, rationale) so the app renders an editable launch card the user plays; never propose a rail whose availability is not free. A message starting with "[Specrails run-failure briefing" is app-posted: answer in ≤ 6 lines with the failure and ONE recommended next action, and never resume, recover, relaunch or discard in that turn.';
+exports.RAIL_LAUNCH_CARD_SYSTEM_CLAUSE = ' When the user asks to assign, prepare or launch specs on a rail WITHOUT explicitly saying to launch now, do not call specrails_rails launch — emit one fenced rail-launch JSON block per rail (ticketIds, railIndex or newRail, mode, loopId, aiEngine, model, reasoningEffort, profileName, repositoryIds, workspaceSelection, rationale) so the app renders an editable launch card the user plays; never propose a rail whose availability is not free. A message starting with "[Specrails run-failure briefing" is app-posted: answer in ≤ 6 lines with the failure and ONE recommended next action, and never resume, recover, relaunch or discard in that turn.';
 /** The per-turn system prompt (flag-aware). */
 function buildOperatorSystemPrompt() {
     return (0, feature_flags_1.isMissionRailCardsEnabled)() ? `${exports.OPERATOR_SYSTEM_PROMPT}${exports.RAIL_LAUNCH_CARD_SYSTEM_CLAUSE}` : exports.OPERATOR_SYSTEM_PROMPT;

package/server/dist/modules/specs/runtime/spec-models.js

@@ -6,20 +6,17 @@ exports.isValidModelForProvider = isValidModelForProvider;
 exports.getProviderDefault = getProviderDefault;
 const providers_1 = require("../../../providers");
 exports.CLAUDE_MODELS = [
-    { value: 'sonnet', label: 'Claude Sonnet' },
-    { value: 'fable', label: 'Claude Fable' },
+    { value: 'sonnet', label: 'Sonnet 5.5' },
+    { value: 'fable', label: 'Fable 5.1' },
     { value: 'opus', label: 'Claude Opus' },
     { value: 'haiku', label: 'Claude Haiku' },
 ];
 exports.CODEX_MODELS = [
+    { value: 'gpt-6.1-sol', label: 'GPT-6.1 Sol' },
     { value: 'gpt-6-astra', label: 'GPT-6 Astra' },
     { value: 'gpt-5.6-sol', label: 'GPT-5.6 Sol' },
     { value: 'gpt-5.6-terra', label: 'GPT-5.6 Terra' },
     { value: 'gpt-5.6-luna', label: 'GPT-5.6 Luna' },
-    { value: 'gpt-5.5', label: 'GPT-5.5' },
-    { value: 'gpt-5.4', label: 'GPT-5.4' },
-    { value: 'gpt-5.4-mini', label: 'GPT-5.4 Mini' },
-    { value: 'gpt-5.3-codex', label: 'GPT-5.3 Codex' },
 ];
 // Mirrors GEMINI_MODELS in server/providers/gemini-adapter.ts.
 exports.GEMINI_MODELS = [
@@ -43,7 +40,7 @@ const PROVIDER_MODELS = {
 };
 exports.PROVIDER_DEFAULT_MODEL = {
     claude: 'sonnet',
-    codex: 'gpt-5.5',
+    codex: 'gpt-6.1-sol',
     gemini: 'gemini-3.5-flash',
     kimi: 'k3',
 };

package/server/dist/modules/subscription-usage/adapters/claude.js

@@ -0,0 +1,113 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createClaudeReader = createClaudeReader;
+const node_child_process_1 = require("node:child_process");
+const node_os_1 = require("node:os");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const domain_1 = require("../domain");
+const errors_1 = require("./errors");
+const local_auth_1 = require("./local-auth");
+function readKeychain(service, signal) {
+    return new Promise((resolve, reject) => {
+        let account;
+        try {
+            account = process.env.USER || process.env.USERNAME || (0, node_os_1.userInfo)().username;
+        }
+        catch {
+            account = 'claude-code-user';
+        }
+        if (!/^[a-zA-Z0-9._-]+$/.test(account))
+            account = 'claude-code-user';
+        (0, node_child_process_1.execFile)('/usr/bin/security', ['find-generic-password', '-s', service, '-a', account, '-w'], { timeout: 3000, maxBuffer: 1024 * 1024, signal }, (error, stdout) => {
+            if (!error)
+                resolve(stdout);
+            else if (error.code === 44)
+                resolve(null);
+            else
+                reject(new errors_1.UsageError('credentials-unreadable'));
+        });
+    });
+}
+function createClaudeReader(options = {}) {
+    const configured = options.configDir ?? process.env.CLAUDE_CONFIG_DIR;
+    const configDir = configured ?? node_path_1.default.join((0, node_os_1.homedir)(), '.claude');
+    async function credentials(signal) {
+        if (!node_path_1.default.isAbsolute(configDir))
+            throw new errors_1.UsageError('unsupported-platform');
+        let keychainFailure = false;
+        if ((options.platform ?? process.platform) === 'darwin') {
+            const aliases = configured ? [configDir] : [];
+            if (configured) {
+                try {
+                    const canonical = await (0, promises_1.realpath)(configDir);
+                    if (canonical !== configDir)
+                        aliases.push(canonical);
+                }
+                catch { /* use the exact resolved context */ }
+            }
+            const services = configured ? aliases.map(dir => `Claude Code-credentials-${(0, local_auth_1.fingerprint)(dir.normalize('NFC')).slice(0, 8)}`) : ['Claude Code-credentials'];
+            for (const service of services) {
+                try {
+                    const raw = await (options.keychain ?? readKeychain)(service, signal);
+                    if (raw)
+                        return raw;
+                }
+                catch {
+                    keychainFailure = true;
+                    break;
+                }
+            }
+        }
+        const file = await (options.readFile ?? local_auth_1.readAuthFile)(node_path_1.default.join(configDir, '.credentials.json'));
+        if (file)
+            return file;
+        if (keychainFailure)
+            throw new errors_1.UsageError('credentials-unreadable');
+        return null;
+    }
+    return {
+        async context(signal) { return (0, local_auth_1.fingerprint)(`${configDir}:${await credentials(signal) ?? 'none'}`); },
+        async read(signal) {
+            const raw = await credentials(signal);
+            if (!raw)
+                return { availability: 'signed-out', windows: [], plan: null, source: null };
+            let data;
+            try {
+                data = (0, domain_1.record)(JSON.parse(raw));
+            }
+            catch {
+                throw new errors_1.UsageError('credentials-unreadable');
+            }
+            const oauth = (0, domain_1.record)(data.claudeAiOauth);
+            if (typeof oauth.accessToken !== 'string' || !oauth.accessToken)
+                return { availability: 'unsupported-auth', windows: [], plan: null, source: null };
+            const response = await (options.request ?? fetch)('https://api.anthropic.com/api/oauth/usage', {
+                headers: { Authorization: `Bearer ${oauth.accessToken}`, 'anthropic-beta': 'oauth-2025-04-20', 'User-Agent': 'claude-code/2.1.0' },
+                signal: AbortSignal.any([signal, AbortSignal.timeout(10_000)]), redirect: 'error',
+            });
+            if (!response.ok) {
+                await response.body?.cancel().catch(() => { });
+                if (response.status === 401)
+                    throw new errors_1.UsageError('signed-out');
+                if (response.status === 403)
+                    throw new errors_1.UsageError('permission-denied');
+                if (response.status === 429) {
+                    const header = response.headers.get('retry-after');
+                    const seconds = header !== null && header.trim() !== '' ? Number(header) : NaN;
+                    const date = header ? Date.parse(header) : NaN;
+                    const retry = Number.isFinite(seconds) ? seconds * 1000 : Number.isFinite(date) ? date - Date.now() : 60_000;
+                    throw new errors_1.UsageError('rate-limited', true, Math.max(30_000, Math.min(24 * 60 * 60_000, retry)));
+                }
+                throw new errors_1.UsageError('provider-error', response.status >= 500);
+            }
+            const payload = await (0, local_auth_1.limitedJson)(response), windows = (0, domain_1.normalizeClaude)(payload);
+            if (!windows.length)
+                throw new errors_1.UsageError('usage-unavailable');
+            return { availability: 'available', windows, plan: null, source: 'oauth' };
+        },
+    };
+}