specrails-desktop 2.59.2 → 2.60.0

package/server/dist/modules/agent-runtime/runtime/agent-runtime-verification-log.js

@@ -0,0 +1,252 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createVerificationLogProjection = createVerificationLogProjection;
+const node_util_1 = require("node:util");
+const object = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+const text = (value) => typeof value === 'string' ? value : '';
+const display = (value, limit = 512) => (0, node_util_1.stripVTControlCharacters)(value).replace(/[\r\n]/g, ' ').slice(0, limit);
+const attemptId = (event) => typeof event.attemptId === 'string' && event.attemptId.length <= 256 && event.attemptId.trim() ? event.attemptId : undefined;
+const output = (value, id) => ({ text: value, ...(id ? { attemptId: id } : {}) });
+const scope = (event) => JSON.stringify([event.runId, event.scopeId, event.nodePath, event.attemptId, event.attempt, event.visit]
+    .map(value => typeof value === 'string' && value.length <= 512 || typeof value === 'number' && Number.isSafeInteger(value) ? value : null));
+const reference = 'Details → Verification evidence (stdout/stderr; retained evidence may be truncated)';
+const shortPrefix = (value) => value.length > 96 ? value.slice(0, 92) + '…] ' : value;
+/** This is presentation only. Neither its heuristics nor check progress can
+ * certify a candidate; original runtime events and command evidence are untouched. */
+function createVerificationLogProjection() {
+    const streams = new Map();
+    const active = new Map();
+    let overflow = false;
+    const binding = (event, repository) => JSON.stringify([scope(event), repository]);
+    function get(key, event, prefix) {
+        let state = streams.get(key);
+        if (!state && streams.size < 64) {
+            state = { scope: scope(event), attemptId: attemptId(event), prefix: shortPrefix(prefix), tap: false, failed: false, yaml: false, inputLines: null, inputShortened: false,
+                headLines: 0, headChars: 0, shown: new Set(), diagnostics: [[], [], [], []], summaries: new Map(), tail: [], previous: [], context: 0, omitted: 0, announced: false };
+            streams.set(key, state);
+        }
+        return state;
+    }
+    function omitted(state) {
+        state.omitted++;
+        if (state.announced)
+            return '';
+        state.announced = true;
+        return state.prefix + '[Verbose output omitted; ' + reference + ']\n';
+    }
+    function diagnostic(state, line, priority) {
+        const bounded = line.slice(0, priority === 3 ? 256 : 512), bucket = state.diagnostics[priority];
+        if (state.shown.has(line) || bucket.includes(bounded))
+            return;
+        // First fact plus three recent facts in each class; warnings cannot consume
+        // the compiler/assertion budget, and later failures remain represented.
+        if (bucket.length === (priority === 3 ? 2 : 4))
+            bucket.splice(1, 1);
+        bucket.push(bounded);
+    }
+    function priority(body) {
+        if (/^(?!['"`]|(?:actual|expected|source):).+(?:\(\d+,\d+\)|:\d+(?::\d+)?)(?::|\s+-)?\s+(?:fatal\s+)?error\b/i.test(body)
+            || /^(?:fatal\s+)?error\s+[A-Z]+\d+\s*:/.test(body)
+            || /^(?:AssertionError|TypeError|ReferenceError|SyntaxError|RangeError)\b/.test(body))
+            return 0;
+        if (/^(?:FAIL\s|not ok \d+\b|[✖✗]\s|(?:fatal\s+)?error(?:\s*\[[^\]]+\])?\s*:)/i.test(body)
+            && !/\b0 errors?\b/i.test(body))
+            return 1;
+        if (/^(?:expected|actual|operator|test at|location)\s*[: ]/i.test(body))
+            return 2;
+        return undefined;
+    }
+    function summary(body) {
+        if (/^Ran all test suites[.\s]*$/.test(body))
+            return 'ran';
+        const match = body.match(/^(Test Suites|Test Files|Tests|Snapshots|Time|Duration|Ran all test suites)\s*:?\s/i)
+            ?? body.match(/^(?:#|ℹ)\s*(tests|suites|pass|fail|cancelled|skipped|todo|duration_ms|duration)\b/i);
+        return match?.[1].toLowerCase();
+    }
+    function line(state, original, body) {
+        let value = original;
+        if (/AssertionError\b.*\bInput:\s*$/.test(body))
+            state.inputLines = 0;
+        else if (state.inputLines !== null) {
+            if (/^["'`]/.test(body)) {
+                state.inputLines++;
+                if (state.inputLines > 2) {
+                    if (state.inputShortened)
+                        return '';
+                    state.inputShortened = true;
+                    return state.prefix + '[Assertion input shortened; inspect raw evidence]\n';
+                }
+            }
+            else if (!body)
+                return '';
+            else
+                state.inputLines = null;
+        }
+        if (/^[✔✓]\s/.test(body))
+            return '';
+        if (/^PASS\s/.test(body))
+            return omitted(state);
+        if (/^[✖✗]\s/.test(body))
+            state.failed = true;
+        if (/^TAP version |^# Subtest:/.test(body)) {
+            state.tap = true;
+            return '';
+        }
+        if (/^(?:not )?ok \d+\b/.test(body)) {
+            state.tap = true;
+            state.failed = body.startsWith('not ok');
+            state.yaml = false;
+            if (!state.failed)
+                return '';
+        }
+        if (state.tap) {
+            if (body === '---') {
+                state.yaml = true;
+                if (!state.failed)
+                    return '';
+            }
+            if (body === '...') {
+                state.yaml = false;
+                if (!state.failed)
+                    return '';
+            }
+            if (state.yaml && !state.failed)
+                return '';
+            if (/^1\.\.\d+$/.test(body))
+                return '';
+        }
+        if (!body)
+            return '';
+        if (value.length > 2_000)
+            value = value.slice(0, 1_900) + '\n[Long diagnostic line shortened; inspect raw evidence]';
+        const total = summary(body);
+        if (total) {
+            // Known totals have a fixed key set, so repeated progress updates do not
+            // become another unbounded stream or evict diagnostics.
+            state.summaries.set(total, state.prefix + body.slice(0, 128));
+            return '';
+        }
+        const rank = priority(body.slice(0, 2_000));
+        if (state.headLines < 24 && state.headChars + value.length <= 3_500) {
+            state.headLines++;
+            state.headChars += value.length;
+            state.shown.add(value);
+            state.previous.push(value);
+            if (state.previous.length > 2)
+                state.previous.shift();
+            return value + '\n';
+        }
+        if (rank !== undefined) {
+            if (rank < 2) {
+                for (const preceding of state.previous)
+                    diagnostic(state, preceding, 3);
+                state.context = 3;
+            }
+            diagnostic(state, value, rank);
+        }
+        else if (state.context > 0) {
+            diagnostic(state, value, 3);
+            state.context--;
+        }
+        state.previous.push(value);
+        if (state.previous.length > 2)
+            state.previous.shift();
+        state.tail.push(value.slice(0, 256));
+        if (state.tail.length > 6)
+            state.tail.shift();
+        return omitted(state);
+    }
+    function flush(key) {
+        const result = [];
+        for (const [id, state] of streams) {
+            if (key !== undefined && id !== key)
+                continue;
+            let content = '';
+            const pending = [...state.diagnostics.flat(), ...state.tail, ...state.summaries.values()];
+            const seen = new Set(state.shown);
+            for (const value of pending)
+                if (!seen.has(value)) {
+                    seen.add(value);
+                    content += value + '\n';
+                }
+            if (state.omitted)
+                content += state.prefix + `[${state.omitted} output lines compacted; ${reference}]\n`;
+            if (content)
+                result.push(output(content, state.attemptId));
+            streams.delete(id);
+            for (const [name, activeId] of active)
+                if (activeId === id)
+                    active.delete(name);
+        }
+        return result;
+    }
+    function project(event) {
+        if (event.type === 'verification-output' && typeof event.text === 'string') {
+            const result = [];
+            for (const value of (0, node_util_1.stripVTControlCharacters)(event.text).split('\n')) {
+                if (!value)
+                    continue;
+                const match = value.match(/^(\[verification ([^/\]]+)\/[^\]]+\] )?(.*)$/);
+                const prefix = match?.[1] ?? '', repository = match?.[2] ?? '', body = (match?.[3] ?? value).trim();
+                const key = active.get(binding(event, repository)) ?? JSON.stringify([scope(event), prefix.slice(0, 1024)]);
+                const state = get(key, event, prefix);
+                if (state) {
+                    const content = line(state, shortPrefix(prefix) + (match?.[3] ?? value), body);
+                    if (content)
+                        result.push(output(content, state.attemptId));
+                }
+                else if (!overflow) {
+                    overflow = true;
+                    result.push(output(`[Additional verification output omitted; ${reference}]\n`, attemptId(event)));
+                }
+            }
+            return result;
+        }
+        if (event.type === 'runtime-efficiency-event') {
+            const data = object(event.payload) ? { ...event, ...event.payload } : event;
+            const kind = text(data.kind), id = text(data.executionId), repository = text(data.repositoryId), label = text(data.label);
+            if (!['check-started', 'check-finished', 'check-reused', 'check-invalidated'].includes(kind) || !id || id.length > 256 || !repository || repository.length > 256 || !label || label.length > 4096)
+                return [];
+            const prefix = `[verification ${display(repository)}/${display(label)}] `;
+            const key = JSON.stringify([scope(data), id]), name = binding(data, repository);
+            if (kind === 'check-started') {
+                if (active.get(name) === key)
+                    return [];
+                const result = active.has(name) ? flush(active.get(name)) : [];
+                if (get(key, data, prefix))
+                    active.set(name, key);
+                result.push(output(prefix + 'started\n', attemptId(data)));
+                return result;
+            }
+            if (kind === 'check-invalidated')
+                return [output(prefix + 'evidence invalidated' + (typeof data.reason === 'string' ? ': ' + display(data.reason) : '') + '\n', attemptId(data))];
+            if (!Number.isSafeInteger(data.exitCode) || typeof data.durationMs !== 'number' || !Number.isFinite(data.durationMs) || data.durationMs < 0)
+                return [];
+            const result = flush(key);
+            return [...result, output(prefix + `${kind === 'check-reused' ? 'reused' : data.exitCode === 0 ? 'command passed' : 'command failed'} (exit ${data.exitCode}, ${(data.durationMs / 1000).toFixed(1)} s)\n`, attemptId(data))];
+        }
+        if (event.type === 'runtime-result')
+            return flush();
+        if (event.type === 'workflow-event' && object(event.event)) {
+            const data = event.event, kind = text(data.type);
+            if (/^workflow_(?:succeeded|failed|cancelled|paused)$/.test(kind))
+                return flush();
+            if (!/^step_(?:started|succeeded|failed|cancelled|interrupted)$/.test(kind))
+                return [];
+            const result = [];
+            for (const [key, state] of streams) {
+                const identity = JSON.parse(state.scope);
+                // Older transports lack attempt identity. Flush them before a phase
+                // boundary; v2 flushes only the ending attempt, leaving siblings intact.
+                const legacy = identity[2] === null && identity[3] === null;
+                const sameAttempt = typeof data.attemptId === 'string' && identity[3] === data.attemptId;
+                const sameNode = !data.attemptId && (data.nodePath ?? data.stepId) === identity[2] && (!data.scopeId || data.scopeId === identity[1]);
+                if (legacy || (kind !== 'step_started' && (sameAttempt || sameNode)))
+                    result.push(...flush(key));
+            }
+            return result;
+        }
+        return [];
+    }
+    return { project, flush };
+}

package/server/dist/modules/agents/runtime/profiles-router.js

@@ -18,6 +18,8 @@ const providers_1 = require("../../../providers");
 const kimi_skill_prompt_1 = require("../../../providers/kimi-skill-prompt");
 const profile_manager_1 = require("./profile-manager");
 const workspace_resolution_1 = require("../../../workspace-resolution");
+const agent_runtime_loader_1 = require("../../agent-runtime/runtime/agent-runtime-loader");
+const agent_runtime_settings_1 = require("../../agent-runtime/runtime/agent-runtime-settings");
 const project_router_helpers_1 = require("../../../project-router-helpers");
 /**
  * Relocate-artifacts gate: the dir whose `.specrails/{profiles,specrails-version}`
@@ -70,6 +72,30 @@ function agentsCatalogDir(project, provider) {
 function listAgentFiles(project, provider) {
     return (0, agent_catalog_1.listNativeAgentFiles)(specRoot(project), provider ?? project.provider ?? 'claude');
 }
+/**
+ * The baseline roles are identifiers of runtime-defined roles: specrails-core
+ * never reads an `sr-*` file for them. Their read-only catalog body is the Core
+ * runtime definition (defaults merged with the global Settings overrides).
+ */
+const BASELINE_RUNTIME_ROLES = {
+    'sr-architect': 'architect',
+    'sr-developer': 'developer',
+    'sr-reviewer': 'reviewer',
+};
+const RUNTIME_DEFINED_DESCRIPTION = 'Runtime-defined by specrails-core: the implement pipeline runs this role from the Core runtime definition below, not from an installed file.';
+async function loadRuntimeRoleDefinitions() {
+    try {
+        const runtime = await (0, agent_runtime_loader_1.loadCoreAgentRuntime)();
+        return { prompts: { ...runtime.rolePromptDefaults(), ...(0, agent_runtime_settings_1.loadRuntimeRolePrompts)() } };
+    }
+    catch (error) {
+        return { prompts: {}, error: error instanceof Error ? error.message : 'Core role prompt catalog is unavailable' };
+    }
+}
+function runtimeRoleBody(definitions, agentId) {
+    const role = BASELINE_RUNTIME_ROLES[agentId];
+    return role ? definitions.prompts[role] : undefined;
+}
 const AGENTS_SECTION_ENABLED = process.env.SPECRAILS_AGENTS_SECTION !== 'false';
 function handleError(res, err) {
     if (err instanceof profile_manager_1.ProfileValidationError) {
@@ -175,12 +201,11 @@ function createProfilesRouter() {
                 ? new Map((0, project_router_helpers_1.readAgentModels)({ ...project, provider })
                     .map((entry) => [entry.name, entry.model]))
                 : null;
-            const agentsDir = agentsCatalogDir(project, provider);
-            if (!fs_1.default.existsSync(agentsDir)) {
-                res.status(400).json({ error: `no ${adapter.projectDirName} roles catalog found` });
-                return;
-            }
+            const baseline = [...adapter.baselineAgents()];
             const agents = [];
+            // Role files are optional: Core >= 6.3 defines the baseline roles in its
+            // runtime. Read `model:` only from `sr-*` files that still exist (older
+            // installs); every other baseline id is seeded with the adapter default.
             for (const entry of listAgentFiles(project, provider)) {
                 if (!entry.id.startsWith('sr-'))
                     continue;
@@ -202,13 +227,10 @@ function createProfilesRouter() {
                 }
                 agents.push({ id, model });
             }
-            const baseline = [...adapter.baselineAgents()];
-            const missing = baseline.filter((id) => !agents.some((a) => a.id === id));
-            if (missing.length > 0) {
-                res.status(400).json({
-                    error: `missing baseline agents in this project: ${missing.join(', ')}. Run 'npx specrails-core@latest update' first.`,
-                });
-                return;
+            for (const id of baseline) {
+                if (agents.some((a) => a.id === id))
+                    continue;
+                agents.push({ id, model: projectedKimiModels?.get(id) ?? adapter.defaultModel() });
             }
             // Order: baseline trio first (architect, developer, reviewer), optional
             // agents in the middle. sr-merge-resolver is no longer a baseline agent;
@@ -379,39 +401,44 @@ function createProfilesRouter() {
         }
     });
     // GET /api/projects/:projectId/profiles/catalog
-    // List all roles in the selected provider-native catalog (sr-* + custom-*).
-    router.get('/catalog', (req, res) => {
+    // List the selected provider's roles: the runtime-defined baseline (upstream,
+    // synthesized from the adapter) plus the native `custom-*` catalog.
+    router.get('/catalog', async (req, res) => {
         try {
             const { project } = ctx(req);
             const provider = requestedProvider(req, project);
-            const files = listAgentFiles(project, provider);
-            if (files.length === 0) {
-                res.json({ agents: [] });
-                return;
-            }
+            const adapter = projectAdapter(project, provider);
             const agents = [];
-            for (const entry of files) {
+            // Baseline roles never depend on `sr-*` files; a missing roles directory
+            // still yields the three runtime-defined entries.
+            const definitions = await loadRuntimeRoleDefinitions();
+            for (const id of adapter.baselineAgents()) {
+                agents.push({
+                    id,
+                    kind: 'upstream',
+                    description: RUNTIME_DEFINED_DESCRIPTION,
+                    body: runtimeRoleBody(definitions, id) ?? '',
+                    roleId: BASELINE_RUNTIME_ROLES[id],
+                    ...(definitions.error ? { runtimeRoleError: definitions.error } : {}),
+                });
+            }
+            for (const entry of listAgentFiles(project, provider)) {
                 const id = entry.id;
-                const kind = id.startsWith('sr-')
-                    ? 'upstream'
-                    : id.startsWith('custom-')
-                        ? 'custom'
-                        : null;
-                if (!kind)
+                // Stale `sr-*` files from older Cores are not catalog entries anymore.
+                if (!id.startsWith('custom-'))
                     continue;
+                const kind = 'custom';
                 let description;
                 let model;
                 let projected = {};
                 try {
                     const body = fs_1.default.readFileSync(entry.file, 'utf8');
-                    if (kind === 'custom') {
-                        try {
-                            const result = (0, agent_role_descriptor_1.projectCustomAgentRole)({ id, content: body }, { provider });
-                            projected = { roleId: result.id, runtimeRoleDefaults: result.role };
-                        }
-                        catch (error) {
-                            projected = { runtimeRoleError: error instanceof Error ? error.message : 'Invalid Core role descriptor' };
-                        }
+                    try {
+                        const result = (0, agent_role_descriptor_1.projectCustomAgentRole)({ id, content: body }, { provider });
+                        projected = { roleId: result.id, runtimeRoleDefaults: result.role };
+                    }
+                    catch (error) {
+                        projected = { runtimeRoleError: error instanceof Error ? error.message : 'Invalid Core role descriptor' };
                     }
                     if (provider === 'kimi') {
                         // Use the same js-yaml metadata parser as validation/execution so
@@ -468,8 +495,9 @@ function createProfilesRouter() {
         }
     });
     // GET /api/projects/:projectId/profiles/catalog/:agentId
-    // Return the full .md body of a single agent file (read-only for sr-*, editable for custom-*)
-    router.get('/catalog/:agentId', (req, res) => {
+    // Return the full body of a single agent: the Core runtime definition for a
+    // baseline role (read-only), the native file for custom-* (editable).
+    router.get('/catalog/:agentId', async (req, res) => {
         try {
             const { project } = ctx(req);
             const provider = requestedProvider(req, project);
@@ -480,6 +508,16 @@ function createProfilesRouter() {
             }
             const file = agentFile(project, agentId, provider);
             if (!fs_1.default.existsSync(file)) {
+                if (projectAdapter(project, provider).baselineAgents().includes(agentId)) {
+                    const definitions = await loadRuntimeRoleDefinitions();
+                    const body = runtimeRoleBody(definitions, agentId);
+                    if (body !== undefined) {
+                        res.json({ id: agentId, body, runtimeDefined: true });
+                        return;
+                    }
+                    res.status(503).json({ error: definitions.error ?? 'Core role prompt catalog is unavailable' });
+                    return;
+                }
                 res.status(404).json({ error: 'agent not found' });
                 return;
             }

package/server/dist/modules/delivery/runtime/rail-relaunch.js

@@ -104,8 +104,16 @@ function resolveRailRelaunch(c, railIndex, sourceId) {
             config.baseBranch = row.base_branch;
         if (delivery.executionManifest) {
             config.repositoryIds = delivery.executionManifest.selectedRepositoryIds;
-            config.workspaceSelection = savedConfig?.workspaceSelection ?? Object.fromEntries(delivery.executionManifest.repositories
-                .filter(repo => repo.selectedWorkspacePaths).map(repo => [repo.repositoryId, repo.selectedWorkspacePaths]));
+            if (savedConfig?.workspaceSelection === undefined) {
+                const entries = delivery.executionManifest.repositories
+                    .filter(repo => repo.selectedWorkspacePaths !== undefined).map(repo => [repo.repositoryId, repo.selectedWorkspacePaths]);
+                // No recorded narrowing means registered defaults, represented by
+                // absence. Explicit values remain subject to ordinary launch validation.
+                if (entries.length)
+                    config.workspaceSelection = Object.fromEntries(entries);
+                else
+                    delete config.workspaceSelection;
+            }
         }
     }
     if (!Array.isArray(ticketIds) || !ticketIds.length || ticketIds.some(id => !Number.isSafeInteger(id) || id <= 0))

package/server/dist/modules/execution/runtime/queue-manager.js

@@ -1935,17 +1935,15 @@ class QueueManager {
         const execution = this._resolveExecution();
         this._jobExecution.set(jobId, execution);
         const spawnCwd = execution.cwd;
-        // Windows repair: a relocated workspace whose `.claude/agents` was left empty
-        // by the broken `current`-junction read during assemble has no sr-* agents,
-        // so the implement pipeline can't delegate and runs inline. Self-heal here
-        // (per rail spawn) by copying the agents from the real version dir. NO-OP on
-        // POSIX (assemble's per-file symlinks already populate them).
+        // Windows repair: a relocated workspace whose dir-linked subtrees
+        // (commands/skills/rules) were left unreadable by the broken `current`
+        // junction during assemble has no `/specrails:*` commands → the CLI reports
+        // "Unknown command: /specrails:implement". Self-heal here (per rail spawn)
+        // from the real version dir. Role agents (architect/developer/reviewer) are
+        // defined by the Core runtime, not by workspace files, so nothing else is
+        // repaired. NO-OP on POSIX (assemble's symlinks already populate them).
         if (execution.relocated) {
             try {
-                (0, workspace_manager_1.ensureFrameworkAgents)(execution.cwd, adapter.projectDirName);
-                // AND the dir-linked subtrees (commands/skills/rules): a broken Windows
-                // `current` junction leaves the workspace with no `/specrails:*` commands
-                // → the CLI reports "Unknown command: /specrails:implement".
                 (0, workspace_manager_1.ensureFrameworkCommandSubtrees)(execution.cwd, adapter.projectDirName);
             }
             catch {

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

@@ -1,16 +1,13 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultLoopAgents = defaultLoopAgents;
-const loop_agent_defaults_json_1 = __importDefault(require("./loop-agent-defaults.json"));
+const agent_runtime_settings_1 = require("../../agent-runtime/runtime/agent-runtime-settings");
 function defaultLoopAgents(mode = 'implementation') {
     return {
         schemaVersion: 1,
         agents: { architect: { provider: 'inherit' }, developer: { provider: 'inherit' }, reviewer: { provider: 'inherit' } },
         fixer: { provider: 'inherit' },
-        rolePrompts: mode === 'implementation' ? { ...loop_agent_defaults_json_1.default } : {
+        rolePrompts: mode === 'implementation' ? { architect: agent_runtime_settings_1.INHERIT_ROLE_PROMPT, developer: agent_runtime_settings_1.INHERIT_ROLE_PROMPT, reviewer: agent_runtime_settings_1.INHERIT_ROLE_PROMPT, fixer: agent_runtime_settings_1.INHERIT_ROLE_PROMPT } : {
             architect: 'Explore the repositories and plan the requested work from the supplied goal and acceptance criteria.',
             developer: 'Implement the supplied spec directly in the existing codebase. Explore relevant code, make the requested changes and add meaningful tests. Use the project verification commands. If a human decision is required, finish with LOOP_BLOCKED: followed by the specific question.',
             reviewer: 'Review actual code and verification evidence against the supplied acceptance criteria. Report correctness, security and regression issues.',

package/server/dist/modules/loops/runtime/loop-command-catalog.js

@@ -116,10 +116,10 @@ exports.LOOP_COMMANDS = [
     {
         name: 'revision-verify',
         label: 'revision verify',
-        description: 'Read-only independent Revision gate: run sr-reviewer, ensure one full-scope pass of record, write fresh confidence evidence when available, and emit VERIFICATION: PASS|FAIL.',
+        description: 'Read-only independent Revision gate: perform an independent senior review of the diff against the OpenSpec package, ensure one full-scope pass of record, write fresh confidence evidence when available, and emit VERIFICATION: PASS|FAIL.',
         ticketScope: 'all',
         // The Revision loop's SINGLE owner of review + verification. It exists because
-        // running sr-reviewer inside `revise` and then a generic `{{cmd:verify}}` made
+        // running a review inside `revise` and then a generic `{{cmd:verify}}` made
         // two independent full gates for one one-sentence change — the exact cost the
         // Architect-less revision path was created to avoid. Kept read-only so a failed
         // gate routes to the loop's separate `fix` step instead of the grader patching
@@ -133,14 +133,14 @@ exports.LOOP_COMMANDS = [
             '',
             'Treat that briefing and the files on disk as the complete source context. Do not depend on the mutating agent remembering or summarizing it for you.',
             '',
-            'Reviewer output-format reconciliation: the installed `sr-reviewer` may require its review phase to finish with only `Score:` and `Verdict:` lines and then end. In this OUTER verification gate those two lines are an intermediate reviewer result, not the end of your turn. Preserve every reviewer rule except that terminal response-format instruction; after recording its score/verdict, continue with any missing project gates and emit the outer `VERIFICATION` sentinel required below.',
+            'Reviewer output-format reconciliation: a senior review phase conventionally finishes with only `Score:` and `Verdict:` lines and then ends. In this OUTER verification gate those two lines are an intermediate reviewer result, not the end of your turn. Keep every review rule except that terminal response-format instruction; after recording the score/verdict, continue with any missing project gates and emit the outer `VERIFICATION` sentinel required below.',
             '',
             'Work in this order:',
-            '1. Load and follow the installed `sr-reviewer` role over the resulting diff and the governing OpenSpec package (use its archived package when that is the delivery context; do not archive or re-archive anything). Produce a fresh `confidence-score.json` for this pass when the reviewer is applicable.',
+            '1. Perform an independent senior review of the resulting diff against the governing OpenSpec package: proposal, design, delta specs and tasks (use its archived package when that is the delivery context; do not archive or re-archive anything). Check correctness, scope discipline, test coverage and alignment with the spec, and record a `Score:` and `Verdict:`. Produce a fresh `confidence-score.json` for this pass when an OpenSpec package governs the candidate.',
             '2. Establish exactly ONE full-scope project gate for this candidate: the complete configured test suite plus typecheck, lint, and build when present. Inspect what the reviewer actually ran. If it already ran that full gate, treat those commands as the pass of record and DO NOT repeat them. If it ran only scoped/focused checks, run only the missing full-scope commands once.',
             '3. Independently map the user revision request and frozen spec to the real diff. A clean command exit alone is not enough when required behavior is missing or out-of-scope work was introduced.',
             '',
-            'If the reviewer is unavailable or inapplicable, run the full-scope project gate yourself exactly once, continue the semantic diff review, and report reviewer confidence as unavailable. Never infer PASS from missing reviewer evidence.',
+            'If no OpenSpec package governs this candidate, review the diff against the frozen spec alone, run the full-scope project gate yourself exactly once, and report reviewer confidence as unavailable. Never infer PASS from missing review evidence.',
             '',
             'This gate is read-only: do NOT edit source, tests, configuration, or OpenSpec contract artifacts, and do NOT fix findings. The only permitted writes are reviewer/evidence artifacts. On any defect or failed/missing required gate, report FAIL so the loop routes to its separate fix step.',
             '',

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

@@ -75,7 +75,7 @@ function compileLoopToDefinition(graph, launch) {
                 }
             }
             if (kind === 'prompt' && graph.config.agents) {
-                const definition = graph.config.agents.rolePrompts?.[promptRole]?.replaceAll('{{', '{{{{');
+                const definition = agents?.rolePrompts?.[promptRole]?.replaceAll('{{', '{{{{');
                 if (definition) {
                     if (object(params.nativeCommand))
                         params.nativeCommand = { ...params.nativeCommand, args: String(params.nativeCommand.args ?? '') + '\n\nLoop agent definition:\n' + definition };

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

@@ -347,7 +347,6 @@ function createLoopExecutors(opts = {}) {
             };
             if (repoDir) {
                 try {
-                    (0, workspace_manager_1.ensureFrameworkAgents)(cwd, adapter.projectDirName);
                     (0, workspace_manager_1.ensureFrameworkCommandSubtrees)(cwd, adapter.projectDirName);
                 }
                 catch { /* best-effort */ }
@@ -556,7 +555,6 @@ function createLoopExecutors(opts = {}) {
             const extraArgs = aiStepExtraArgs(adapter, cwd, repoDir, executionManifest);
             if (repoDir) {
                 try {
-                    (0, workspace_manager_1.ensureFrameworkAgents)(cwd, adapter.projectDirName);
                     (0, workspace_manager_1.ensureFrameworkCommandSubtrees)(cwd, adapter.projectDirName);
                 }
                 catch { /* best-effort */ }

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.configurableImplementGraph = configurableImplementGraph;
+const agent_runtime_settings_1 = require("../../agent-runtime/runtime/agent-runtime-settings");
 const loop_agents_1 = require("./loop-agents");
 const objectSchema = (properties, required = Object.keys(properties)) => ({ type: 'object', properties, required, additionalProperties: false });
 const string = { type: 'string' };
@@ -12,10 +13,10 @@ const reviewPolicy = 'approved == true; issues must be empty; score >= 70; ' + O
 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 },
+        plan: { ...agents.agents.architect, access: 'read', artifacts: 'all', openspecSkill: 'openspec-ff-change', prompt: (0, agent_runtime_settings_1.inheritedRolePrompt)(agents.rolePrompts, 'architect') },
+        build: { ...agents.agents.developer, access: 'write', artifacts: 'tasks-checkboxes', openspecSkill: 'openspec-apply-change', prompt: (0, agent_runtime_settings_1.inheritedRolePrompt)(agents.rolePrompts, 'developer') },
+        assess: { ...agents.agents.reviewer, access: 'read', artifacts: 'none', openspecSkill: 'openspec-verify-change', prompt: (0, agent_runtime_settings_1.inheritedRolePrompt)(agents.rolePrompts, 'reviewer') },
+        correct: { ...agents.fixer, access: 'write', artifacts: 'tasks-checkboxes', openspecSkill: 'openspec-apply-change', prompt: (0, agent_runtime_settings_1.inheritedRolePrompt)(agents.rolePrompts, 'fixer') },
     };
     const nodes = [{ id: 'start', type: 'start', position: { x: 0, y: 0 } }], edges = [];
     const node = (id, label, kind, params, outcomes) => {

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

@@ -950,13 +950,15 @@ class LoopRunManager {
             openStep = null;
             emitRunEvent('loop_step_end', payload);
         };
-        const logLine = (line, source = 'stdout') => {
+        const logLine = (line, source = 'stdout', metadata) => {
+            const attemptId = metadata?.attemptId;
+            const attribution = typeof attemptId === 'string' && attemptId.trim() && attemptId.length <= 256 ? { attemptId } : {};
             const s = takeSeq();
             try {
-                (0, db_1.appendEvent)(this.db, runId, s, { event_type: 'log', source, payload: JSON.stringify({ line }) });
+                (0, db_1.appendEvent)(this.db, runId, s, { event_type: 'log', source, payload: JSON.stringify({ line, ...attribution }) });
             }
             catch { /* events table best-effort */ }
-            this._emit({ type: 'log', source, line, timestamp: new Date(this.now()).toISOString(), processId: runId });
+            this._emit({ type: 'log', source, line, timestamp: new Date(this.now()).toISOString(), processId: runId, ...attribution });
         };
         // Forward a RAW provider stdout line (claude/codex JSONL) as an `event` —
         // identical to QueueManager — so JobStatusPanel parses real activity

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

@@ -63,7 +63,9 @@ function registerLoopsRoutes(router, deps) {
         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 ?? [] } });
+        // `inherit` definitions resolve at launch; the editor previews what they resolve to today.
+        const rolePromptDefaults = runtime ? { ...runtime.rolePromptDefaults(), ...(0, agent_runtime_settings_1.loadRuntimeRolePrompts)() } : null;
+        res.json({ agents: (0, loop_agents_1.defaultLoopAgents)(), rolePromptDefaults, guardrails: { supported: runtime?.api?.capabilities?.configurableGuardrails === 1, catalog: runtime?.api?.guardrails ?? [] } });
     });
     // ── Templates ──────────────────────────────────────────────────────────────
     router.get('/loop-templates', async (_req, res) => {