specrails-desktop 2.64.2 → 2.65.0

package/server/dist/modules/project-rules/runtime/rules-inventory-runs.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rulesInventoryRuns = void 0;
+exports.createRulesInventoryRuns = createRulesInventoryRuns;
+/**
+ * One place that runs Core's rules inventory for a project (task 4.4): the
+ * settings panel's **Re-run** and the automatic run after project setup share
+ * it, so two runs never overlap for a project and the panel can show how the
+ * last run went (an automatic run has nobody watching a toast).
+ *
+ * State is per project id and in memory: whether a run is in flight, the last
+ * run's outcome, and whether the after-setup run already happened in this
+ * process. Nothing here outlives a restart; the inventory file itself is the
+ * durable record.
+ */
+const rules_store_1 = require("./rules-store");
+/** Classifications that already reflect the project's rules: an after-setup run adds nothing. */
+const SETTLED_CLASSIFICATIONS = new Set(['classified', 'cached', 'empty']);
+const OUTPUT_CAP = 2000;
+function createRulesInventoryRuns(deps = {}) {
+    const running = new Set();
+    const lastRuns = new Map();
+    const afterSetup = new Set();
+    const now = deps.now ?? (() => new Date().toISOString());
+    const log = deps.log ?? console;
+    /** Run now unless a run is already in flight (null). Never throws. */
+    async function run(project, trigger, runner) {
+        if (running.has(project.id))
+            return null;
+        running.add(project.id);
+        try {
+            let result;
+            try {
+                result = await (runner ?? deps.run ?? rules_store_1.runRulesInventory)(project);
+            }
+            catch (error) {
+                result = { ok: false, exitCode: null, output: error instanceof Error ? error.message : String(error) };
+            }
+            lastRuns.set(project.id, {
+                trigger, ok: result.ok, exitCode: result.exitCode,
+                output: result.ok ? null : (result.output || '').slice(-OUTPUT_CAP) || null,
+                at: now(),
+            });
+            return result;
+        }
+        finally {
+            running.delete(project.id);
+        }
+    }
+    /**
+     * After a project's setup succeeded: run the inventory once, in the
+     * background of the caller (await it only in tests). Idempotent: at most one
+     * after-setup run per project per process, never while another run is in
+     * flight, and never when the stored inventory is already classified. Gated
+     * on Core's `rulesInventory` capability. A failure is logged and kept as the
+     * last run, which the rules panel shows.
+     */
+    async function runAfterSetup(project, supported) {
+        try {
+            if (afterSetup.has(project.id))
+                return 'already_ran';
+            if (running.has(project.id))
+                return 'running';
+            if (!(await supported()))
+                return 'unsupported';
+            const current = (deps.read ?? rules_store_1.readProjectRules)(project);
+            if (current.state === 'ok' && SETTLED_CLASSIFICATIONS.has(current.inventory.classification?.status ?? '')) {
+                afterSetup.add(project.id);
+                return 'up_to_date';
+            }
+            afterSetup.add(project.id);
+            const result = await run(project, 'setup');
+            if (!result)
+                return 'running';
+            if (!result.ok)
+                log.warn(`[project-rules] the rules inventory after setup failed for ${project.id} (exit ${result.exitCode ?? 'none'}): ${result.output.slice(-300)}`);
+            return result.ok ? 'ran' : 'failed';
+        }
+        catch (error) {
+            log.warn(`[project-rules] the rules inventory after setup could not start for ${project.id}: ${error instanceof Error ? error.message : String(error)}`);
+            return 'failed';
+        }
+    }
+    return {
+        run,
+        runAfterSetup,
+        isRunning: (projectId) => running.has(projectId),
+        lastRun: (projectId) => lastRuns.get(projectId) ?? null,
+        /** A removed project leaves nothing behind. */
+        forget(projectId) {
+            lastRuns.delete(projectId);
+            afterSetup.delete(projectId);
+        },
+    };
+}
+/** The process's coordinator (production wiring: settings routes and setup completion). */
+exports.rulesInventoryRuns = createRulesInventoryRuns();

package/server/dist/modules/project-rules/runtime/rules-store.js

@@ -0,0 +1,109 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULES_INVENTORY_ARGS = exports.RULES_INVENTORY_TIMEOUT_MS = void 0;
+exports.rulesArtifactRoot = rulesArtifactRoot;
+exports.rulesFileCandidates = rulesFileCandidates;
+exports.readProjectRules = readProjectRules;
+exports.readProjectRulesInventory = readProjectRulesInventory;
+exports.runRulesInventory = runRulesInventory;
+/**
+ * Effectful half of the project rules inventory (task 4.4): locate and read
+ * `.specrails/rules.json`, and re-run Core's inventory command.
+ *
+ * The file lives in the project's `.specrails/` directory, which is the
+ * relocated workspace for a relocated project and the repository otherwise;
+ * both are checked, workspace first. Every read is bounded and tolerant.
+ */
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const core_runtime_1 = require("../../../core-runtime");
+const path_resolver_1 = require("../../../path-resolver");
+const workspace_resolution_1 = require("../../../workspace-resolution");
+const domain_1 = require("../domain");
+const FILE_CAP = 2 * 1024 * 1024;
+exports.RULES_INVENTORY_TIMEOUT_MS = 10 * 60 * 1000;
+/**
+ * Core CLI arguments of the re-runnable inventory step (contract 5.7
+ * `agentRuntime.rulesInventory.cli`: `specrails-core rules inventory --root
+ * <repo> [--artifact-root <dir>]`; exits 0 and always writes the file).
+ * Desktop only runs it when Core announces `rulesInventory: 1`.
+ */
+exports.RULES_INVENTORY_ARGS = ['rules', 'inventory'];
+/** The directory that holds `.specrails/agent-runtime.json` (Core's artifact root). */
+function rulesArtifactRoot(project) {
+    try {
+        const execution = (0, workspace_resolution_1.resolveProjectExecution)({ slug: project.slug, path: project.path });
+        if (execution.specrailsDir)
+            return path_1.default.dirname(execution.specrailsDir);
+    }
+    catch { /* fall back to the repository */ }
+    return project.path;
+}
+/** Candidate locations: `<artifactRoot>/.specrails/rules.json` (where Core writes
+ *  it), then the repository's `.specrails/rules.json`. */
+function rulesFileCandidates(project) {
+    const candidates = [path_1.default.join(rulesArtifactRoot(project), '.specrails', domain_1.RULES_FILE)];
+    candidates.push(path_1.default.join(project.path, '.specrails', domain_1.RULES_FILE));
+    return [...new Set(candidates)];
+}
+function readProjectRules(project) {
+    for (const file of rulesFileCandidates(project)) {
+        let raw;
+        try {
+            const stat = fs_1.default.statSync(file);
+            if (!stat.isFile())
+                continue;
+            if (stat.size > FILE_CAP)
+                return { state: 'invalid', file, message: 'rules.json is larger than 2 MB' };
+            raw = fs_1.default.readFileSync(file, 'utf8');
+            let parsed;
+            try {
+                parsed = JSON.parse(raw);
+            }
+            catch {
+                return { state: 'invalid', file, message: 'rules.json is not valid JSON' };
+            }
+            const inventory = (0, domain_1.parseRulesInventory)(parsed);
+            if (!inventory)
+                return { state: 'invalid', file, message: 'rules.json does not match the rules inventory format' };
+            return { state: 'ok', file, inventory, modifiedAt: stat.mtime.toISOString() };
+        }
+        catch {
+            continue;
+        }
+    }
+    return { state: 'missing' };
+}
+/** The inventory or null (absent/invalid) — for packet harvest and suggestions. */
+function readProjectRulesInventory(project) {
+    const result = readProjectRules(project);
+    return result.state === 'ok' ? result.inventory : null;
+}
+const defaultRunner = (file, args, options) => new Promise((resolve) => {
+    (0, child_process_1.execFile)(file, args, { ...options, maxBuffer: 4 * 1024 * 1024, windowsHide: true }, (error, stdout, stderr) => {
+        const output = `${stdout ?? ''}${stderr ?? ''}`.trim().slice(-4000);
+        const code = error && typeof error.code === 'number' ? error.code : error ? null : 0;
+        resolve({ ok: !error, exitCode: code, output });
+    });
+});
+/** Re-run Core's inventory for the project. Never throws. */
+async function runRulesInventory(project, runner = defaultRunner) {
+    let cli = null;
+    try {
+        cli = (0, core_runtime_1.resolveCoreRuntime)()?.cli ?? null;
+    }
+    catch (error) {
+        return { ok: false, exitCode: null, output: error instanceof Error ? error.message : 'Core is unavailable' };
+    }
+    if (!cli)
+        return { ok: false, exitCode: null, output: 'Core is unavailable' };
+    // In the packaged app process.execPath is the server binary, not node.
+    const node = (0, path_resolver_1.resolveBundledNodeExe)() ?? process.execPath;
+    const artifactRoot = rulesArtifactRoot(project);
+    const args = [cli, ...exports.RULES_INVENTORY_ARGS, '--root', project.path, ...(path_1.default.resolve(artifactRoot) !== path_1.default.resolve(project.path) ? ['--artifact-root', artifactRoot] : [])];
+    return runner(node, args, { cwd: project.path, timeout: exports.RULES_INVENTORY_TIMEOUT_MS, env: process.env });
+}

package/server/dist/modules/project-settings/adapters/http.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerProjectSettingsHttp = registerProjectSettingsHttp;
 exports.registerEnvPassthroughStatusHttp = registerEnvPassthroughStatusHttp;
+exports.registerAgentEnvStatusHttp = registerAgentEnvStatusHttp;
 const __1 = require("..");
 /** Inbound adapter: translate HTTP into use cases and domain errors into HTTP. */
 function registerProjectSettingsHttp(router, serviceForRequest, 
@@ -58,3 +59,15 @@ function registerEnvPassthroughStatusHttp(router, port) {
         }
     });
 }
+/** Inbound adapter for `GET /:projectId/agent-env/status`. Names only. */
+function registerAgentEnvStatusHttp(router, port) {
+    router.get('/:projectId/agent-env/status', (req, res) => {
+        try {
+            res.json(port.read(req));
+        }
+        catch (error) {
+            console.error('[project-router] agent env status error:', error);
+            res.status(500).json({ error: 'Failed to read agent environment status' });
+        }
+    });
+}

package/server/dist/modules/project-settings/adapters/sqlite.js

@@ -6,6 +6,7 @@ exports.updateProjectSettings = updateProjectSettings;
 exports.getQuickContractRefineLast = getQuickContractRefineLast;
 exports.hasQuickContractRefineLast = hasQuickContractRefineLast;
 exports.setQuickContractRefineLast = setQuickContractRefineLast;
+exports.getAgentAuditRetentionDays = getAgentAuditRetentionDays;
 exports.createSqliteProjectSettingsRepository = createSqliteProjectSettingsRepository;
 const domain_1 = require("../domain");
 function parseWorktreeEnvPassthrough(raw) {
@@ -19,6 +20,16 @@ function parseWorktreeEnvPassthrough(raw) {
     }
 }
 /** A stored value that no longer parses (hand-edited, older shape) reads as "same as the mission agent". */
+function readAgentAuditRetentionDays(raw) {
+    if (!raw)
+        return domain_1.DEFAULT_AGENT_AUDIT_RETENTION_DAYS;
+    try {
+        return (0, domain_1.parseAgentAuditRetentionDays)(Number(raw));
+    }
+    catch {
+        return domain_1.DEFAULT_AGENT_AUDIT_RETENTION_DAYS;
+    }
+}
 function readSubagentRuntime(raw) {
     if (!raw)
         return null;
@@ -29,6 +40,17 @@ function readSubagentRuntime(raw) {
         return null;
     }
 }
+/** A stored limit that no longer parses reads as "no limit" (fail-open). */
+function readReviewWipLimit(raw) {
+    if (!raw)
+        return null;
+    try {
+        return (0, domain_1.parseReviewWipLimit)(Number(raw));
+    }
+    catch {
+        return null;
+    }
+}
 function getProjectSettings(db) {
     // Read the settings as one snapshot instead of preparing separate queries.
     const rows = db.prepare(`
@@ -36,7 +58,12 @@ function getProjectSettings(db) {
       'config.pipeline_telemetry_enabled', 'config.orchestrator_model',
       'config.pre_prompt', 'config.freestyle_pre_prompt',
       'config.integration_branch', 'config.worktree_env_passthrough',
-      'config.allow_subagents', 'config.subagent_runtime'
+      'config.allow_subagents', 'config.subagent_runtime',
+      'config.reviewer_family_suggestion_dismissed',
+      'config.review_wip_limit',
+      'config.agent_env_mode',
+      'config.agent_audit_retention_days',
+      'config.jira_post_clarifications', 'config.baseline_on_touch'
     )
   `).all();
     const settings = new Map(rows.map(row => [row.key, row]));
@@ -54,8 +81,16 @@ function getProjectSettings(db) {
         freestylePrePrompt: freestylePrePromptRow?.value ?? '',
         integrationBranch: integrationBranchRow?.value ?? '',
         worktreeEnvPassthrough: parseWorktreeEnvPassthrough(worktreeEnvPassthroughRow?.value),
-        allowSubagents: settings.get('config.allow_subagents')?.value === 'true',
+        // Sub-agents default on: only an explicit opt-out disables them.
+        allowSubagents: settings.get('config.allow_subagents')?.value !== 'false',
         subagentRuntime: readSubagentRuntime(settings.get('config.subagent_runtime')?.value),
+        reviewerFamilySuggestionDismissed: settings.get('config.reviewer_family_suggestion_dismissed')?.value === 'true',
+        reviewWipLimit: readReviewWipLimit(settings.get('config.review_wip_limit')?.value),
+        // Anything other than the explicit opt-in reads as the default.
+        agentEnvMode: settings.get('config.agent_env_mode')?.value === 'minimal' ? 'minimal' : 'inherit',
+        agentAuditRetentionDays: readAgentAuditRetentionDays(settings.get('config.agent_audit_retention_days')?.value),
+        jiraPostClarifications: settings.get('config.jira_post_clarifications')?.value === 'true',
+        baselineOnTouch: settings.get('config.baseline_on_touch')?.value === 'true',
     };
 }
 /** Resolve the effective Freestyle pre-prompt: the per-project override when
@@ -96,12 +131,22 @@ function updateProjectSettings(db, patch) {
         }
     }
     if (patch.allowSubagents !== undefined) {
-        if (patch.allowSubagents) {
-            db.prepare(`INSERT OR REPLACE INTO queue_state (key, value) VALUES ('config.allow_subagents', 'true')`).run();
-        }
-        else {
-            db.prepare(`DELETE FROM queue_state WHERE key = 'config.allow_subagents'`).run();
-        }
+        db.prepare(`INSERT OR REPLACE INTO queue_state (key, value) VALUES ('config.allow_subagents', ?)`).run(patch.allowSubagents ? 'true' : 'false');
+    }
+    if (patch.reviewerFamilySuggestionDismissed !== undefined) {
+        if (patch.reviewerFamilySuggestionDismissed)
+            db.prepare(`INSERT OR REPLACE INTO queue_state (key, value) VALUES ('config.reviewer_family_suggestion_dismissed', 'true')`).run();
+        else
+            db.prepare(`DELETE FROM queue_state WHERE key = 'config.reviewer_family_suggestion_dismissed'`).run();
+    }
+    // Opt-in booleans: the row exists only while the setting is on.
+    for (const [key, row] of [['jiraPostClarifications', 'config.jira_post_clarifications'], ['baselineOnTouch', 'config.baseline_on_touch']]) {
+        if (patch[key] === undefined)
+            continue;
+        if (patch[key])
+            db.prepare(`INSERT OR REPLACE INTO queue_state (key, value) VALUES (?, 'true')`).run(row);
+        else
+            db.prepare(`DELETE FROM queue_state WHERE key = ?`).run(row);
     }
     if (patch.subagentRuntime !== undefined) {
         if (patch.subagentRuntime === null)
@@ -109,6 +154,26 @@ function updateProjectSettings(db, patch) {
         else
             db.prepare(`INSERT OR REPLACE INTO queue_state (key, value) VALUES ('config.subagent_runtime', ?)`).run(JSON.stringify(patch.subagentRuntime));
     }
+    if (patch.reviewWipLimit !== undefined) {
+        const limit = (0, domain_1.parseReviewWipLimit)(patch.reviewWipLimit);
+        if (limit === null)
+            db.prepare(`DELETE FROM queue_state WHERE key = 'config.review_wip_limit'`).run();
+        else
+            db.prepare(`INSERT OR REPLACE INTO queue_state (key, value) VALUES ('config.review_wip_limit', ?)`).run(String(limit));
+    }
+    if (patch.agentEnvMode !== undefined) {
+        if (patch.agentEnvMode === 'minimal')
+            db.prepare(`INSERT OR REPLACE INTO queue_state (key, value) VALUES ('config.agent_env_mode', 'minimal')`).run();
+        else
+            db.prepare(`DELETE FROM queue_state WHERE key = 'config.agent_env_mode'`).run();
+    }
+    if (patch.agentAuditRetentionDays !== undefined) {
+        const days = (0, domain_1.parseAgentAuditRetentionDays)(patch.agentAuditRetentionDays);
+        if (days === domain_1.DEFAULT_AGENT_AUDIT_RETENTION_DAYS)
+            db.prepare(`DELETE FROM queue_state WHERE key = 'config.agent_audit_retention_days'`).run();
+        else
+            db.prepare(`INSERT OR REPLACE INTO queue_state (key, value) VALUES ('config.agent_audit_retention_days', ?)`).run(String(days));
+    }
     if (patch.worktreeEnvPassthrough !== undefined) {
         const names = (0, domain_1.normalizeWorktreeEnvPassthrough)(patch.worktreeEnvPassthrough);
         if (names.length === 0) {
@@ -135,6 +200,11 @@ function hasQuickContractRefineLast(db) {
 function setQuickContractRefineLast(db, enabled) {
     db.prepare(`INSERT OR REPLACE INTO queue_state (key, value) VALUES ('config.add_spec_quick_contract_refine_last', ?)`).run(enabled ? 'true' : 'false');
 }
+/** Retention window of the agent actions audit log (project setting). */
+function getAgentAuditRetentionDays(db) {
+    const row = db.prepare(`SELECT value FROM queue_state WHERE key = 'config.agent_audit_retention_days'`).get();
+    return readAgentAuditRetentionDays(row?.value);
+}
 /** Bind one project's connection. No global registry or cross-project cache. */
 function createSqliteProjectSettingsRepository(db) {
     const update = db.transaction((patch) => {

package/server/dist/modules/project-settings/domain.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SettingsValidationError = exports.WORKTREE_ENV_NAME_RE = exports.DEFAULT_FREESTYLE_PRE_PROMPT = void 0;
+exports.SettingsValidationError = exports.WORKTREE_ENV_NAME_RE = exports.MAX_AGENT_AUDIT_RETENTION_DAYS = exports.DEFAULT_AGENT_AUDIT_RETENTION_DAYS = exports.REVIEW_WIP_LIMIT_MAX = exports.DEFAULT_FREESTYLE_PRE_PROMPT = void 0;
+exports.parseReviewWipLimit = parseReviewWipLimit;
+exports.parseAgentEnvMode = parseAgentEnvMode;
+exports.parseAgentAuditRetentionDays = parseAgentAuditRetentionDays;
 exports.parseSubagentRuntimeSetting = parseSubagentRuntimeSetting;
 exports.normalizeWorktreeEnvPassthrough = normalizeWorktreeEnvPassthrough;
 exports.parseProjectSettingsPatch = parseProjectSettingsPatch;
@@ -19,6 +22,31 @@ exports.DEFAULT_FREESTYLE_PRE_PROMPT = [
     'Never ask for confirmation; there is no human to answer. Choose the recommended option and proceed.',
     'Run every command in the FOREGROUND and wait for it to finish — never background a command (no run_in_background, no trailing `&`): your reply ends the step and anything still running is killed with its output lost.',
 ].join('\n');
+/** Upper bound for the review WIP limit; larger values are a typo, not a policy. */
+exports.REVIEW_WIP_LIMIT_MAX = 100;
+/** An integer from 1 to REVIEW_WIP_LIMIT_MAX, or null to remove the limit. */
+function parseReviewWipLimit(value) {
+    if (value === null)
+        return null;
+    if (typeof value !== 'number' || !Number.isInteger(value) || value < 1 || value > exports.REVIEW_WIP_LIMIT_MAX) {
+        throw new SettingsValidationError(`reviewWipLimit must be an integer from 1 to ${exports.REVIEW_WIP_LIMIT_MAX}, or null for no limit`);
+    }
+    return value;
+}
+function parseAgentEnvMode(value) {
+    if (value === 'inherit' || value === 'minimal')
+        return value;
+    throw new SettingsValidationError("agentEnvMode must be 'inherit' or 'minimal'");
+}
+exports.DEFAULT_AGENT_AUDIT_RETENTION_DAYS = 30;
+exports.MAX_AGENT_AUDIT_RETENTION_DAYS = 3650;
+/** Strict integer day count; values outside 1-3650 are rejected. */
+function parseAgentAuditRetentionDays(value) {
+    if (typeof value !== 'number' || !Number.isInteger(value) || value < 1 || value > exports.MAX_AGENT_AUDIT_RETENTION_DAYS) {
+        throw new SettingsValidationError(`agentAuditRetentionDays must be an integer between 1 and ${exports.MAX_AGENT_AUDIT_RETENTION_DAYS}`);
+    }
+    return value;
+}
 const PROVIDER_ID_RE = /^[a-z0-9][a-z0-9-]{0,63}$/;
 /** Strict shape check shared by project and app settings; null clears the choice. */
 function parseSubagentRuntimeSetting(value) {
@@ -99,6 +127,10 @@ function parseProjectSettingsPatch(input) {
             throw new SettingsValidationError(error instanceof Error ? error.message : 'invalid worktreeEnvPassthrough');
         }
     }
+    if (values.reviewWipLimit !== undefined)
+        patch.reviewWipLimit = parseReviewWipLimit(values.reviewWipLimit);
+    if (values.agentEnvMode !== undefined)
+        patch.agentEnvMode = parseAgentEnvMode(values.agentEnvMode);
     if (values.subagentRuntime !== undefined)
         patch.subagentRuntime = parseSubagentRuntimeSetting(values.subagentRuntime);
     if (values.allowSubagents !== undefined) {
@@ -106,6 +138,20 @@ function parseProjectSettingsPatch(input) {
             throw new SettingsValidationError('allowSubagents must be a boolean');
         patch.allowSubagents = values.allowSubagents;
     }
+    for (const key of ['jiraPostClarifications', 'baselineOnTouch']) {
+        if (values[key] === undefined)
+            continue;
+        if (typeof values[key] !== 'boolean')
+            throw new SettingsValidationError(`${key} must be a boolean`);
+        patch[key] = values[key];
+    }
+    if (values.reviewerFamilySuggestionDismissed !== undefined) {
+        if (typeof values.reviewerFamilySuggestionDismissed !== 'boolean')
+            throw new SettingsValidationError('reviewerFamilySuggestionDismissed must be a boolean');
+        patch.reviewerFamilySuggestionDismissed = values.reviewerFamilySuggestionDismissed;
+    }
+    if (values.agentAuditRetentionDays !== undefined)
+        patch.agentAuditRetentionDays = parseAgentAuditRetentionDays(values.agentAuditRetentionDays);
     if (values.integrationBranch !== undefined) {
         const branch = values.integrationBranch;
         if (typeof branch !== 'string')

package/server/dist/modules/project-settings/index.js

@@ -1,12 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SettingsValidationError = exports.parseSubagentRuntimeSetting = exports.normalizeWorktreeEnvPassthrough = exports.WORKTREE_ENV_NAME_RE = exports.DEFAULT_FREESTYLE_PRE_PROMPT = exports.createProjectSettingsService = void 0;
+exports.SettingsValidationError = exports.REVIEW_WIP_LIMIT_MAX = exports.parseReviewWipLimit = exports.parseSubagentRuntimeSetting = exports.parseAgentEnvMode = exports.normalizeWorktreeEnvPassthrough = exports.WORKTREE_ENV_NAME_RE = exports.parseAgentAuditRetentionDays = exports.MAX_AGENT_AUDIT_RETENTION_DAYS = exports.DEFAULT_FREESTYLE_PRE_PROMPT = exports.DEFAULT_AGENT_AUDIT_RETENTION_DAYS = exports.createProjectSettingsService = void 0;
 // Public application API. Infrastructure adapters are wired only at composition roots.
 var application_1 = require("./application");
 Object.defineProperty(exports, "createProjectSettingsService", { enumerable: true, get: function () { return application_1.createProjectSettingsService; } });
 var domain_1 = require("./domain");
+Object.defineProperty(exports, "DEFAULT_AGENT_AUDIT_RETENTION_DAYS", { enumerable: true, get: function () { return domain_1.DEFAULT_AGENT_AUDIT_RETENTION_DAYS; } });
 Object.defineProperty(exports, "DEFAULT_FREESTYLE_PRE_PROMPT", { enumerable: true, get: function () { return domain_1.DEFAULT_FREESTYLE_PRE_PROMPT; } });
+Object.defineProperty(exports, "MAX_AGENT_AUDIT_RETENTION_DAYS", { enumerable: true, get: function () { return domain_1.MAX_AGENT_AUDIT_RETENTION_DAYS; } });
+Object.defineProperty(exports, "parseAgentAuditRetentionDays", { enumerable: true, get: function () { return domain_1.parseAgentAuditRetentionDays; } });
 Object.defineProperty(exports, "WORKTREE_ENV_NAME_RE", { enumerable: true, get: function () { return domain_1.WORKTREE_ENV_NAME_RE; } });
 Object.defineProperty(exports, "normalizeWorktreeEnvPassthrough", { enumerable: true, get: function () { return domain_1.normalizeWorktreeEnvPassthrough; } });
+Object.defineProperty(exports, "parseAgentEnvMode", { enumerable: true, get: function () { return domain_1.parseAgentEnvMode; } });
 Object.defineProperty(exports, "parseSubagentRuntimeSetting", { enumerable: true, get: function () { return domain_1.parseSubagentRuntimeSetting; } });
+Object.defineProperty(exports, "parseReviewWipLimit", { enumerable: true, get: function () { return domain_1.parseReviewWipLimit; } });
+Object.defineProperty(exports, "REVIEW_WIP_LIMIT_MAX", { enumerable: true, get: function () { return domain_1.REVIEW_WIP_LIMIT_MAX; } });
 Object.defineProperty(exports, "SettingsValidationError", { enumerable: true, get: function () { return domain_1.SettingsValidationError; } });

package/server/dist/modules/recovery/adapters/sqlite.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readRunDiagnosis = readRunDiagnosis;
+exports.readJobDiagnosis = readJobDiagnosis;
+const domain_1 = require("../domain");
+/**
+ * The diagnosis of one loop run in THIS project's database: the record stored
+ * when the run ended, or, for a run that finished before diagnosis existed, the
+ * one derivable from its outcome alone (`unknown`/low: nothing else was kept).
+ * Null for a run that did not fail or block.
+ */
+function readRunDiagnosis(db, runId) {
+    const run = db.prepare('SELECT status, final_outcome, failure_diagnosis FROM loop_runs WHERE id = ?').get(runId);
+    if (!run || run.status !== 'completed' || !(0, domain_1.isDiagnosableOutcome)(run.final_outcome))
+        return null;
+    const stored = (0, domain_1.parseStoredDiagnosis)(run.failure_diagnosis);
+    return (0, domain_1.presentFailureDiagnosis)(stored ?? (0, domain_1.deriveFailureDiagnosis)({ outcome: run.final_outcome }));
+}
+/**
+ * A job's diagnosis: its loop run's when it has one; a queue job that failed
+ * has only an exit code, so it is an honest `unknown`.
+ */
+function readJobDiagnosis(db, jobId, jobStatus) {
+    const run = db.prepare('SELECT 1 FROM loop_runs WHERE id = ?').get(jobId);
+    if (run)
+        return readRunDiagnosis(db, jobId);
+    return jobStatus === 'failed' ? (0, domain_1.presentFailureDiagnosis)((0, domain_1.deriveFailureDiagnosis)({ outcome: 'failed' })) : null;
+}

package/server/dist/modules/recovery/domain.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REMEDY_IDS = exports.FAILURE_KINDS = void 0;
+exports.oneSentence = oneSentence;
+exports.parseBlocker = parseBlocker;
+exports.parseCoreFailure = parseCoreFailure;
+exports.deriveFailureDiagnosis = deriveFailureDiagnosis;
+exports.rankRemedies = rankRemedies;
+exports.presentFailureDiagnosis = presentFailureDiagnosis;
+exports.isDiagnosableOutcome = isDiagnosableOutcome;
+exports.parseStoredDiagnosis = parseStoredDiagnosis;
+exports.serializeDiagnosis = serializeDiagnosis;
+/**
+ * Failure diagnosis: pure vocabulary and rules. A failed or blocked run is
+ * explained by ONE typed record (what stopped it, why when known, which
+ * remedies fit). Core classifies on contract 5.8+; for older Core results and
+ * for runs Desktop's own loop engine executes, the record is derived from
+ * signals Desktop already holds. A cause is never invented: anything not tied
+ * to a certain signal is `unknown` with low confidence.
+ */
+const provider_limit_1 = require("../../provider-limit");
+exports.FAILURE_KINDS = ['tests_failed', 'provider_limit', 'environment', 'blocked', 'timeout', 'tool_inactivity', 'crash', 'unknown'];
+/** Remedies that map to ACTIONS THAT ALREADY EXIST; the client shows only those its surface can run. */
+exports.REMEDY_IDS = ['resume', 'retry', 'edit-spec', 'fix-environment', 'open-logs'];
+const DETAIL_LIMIT = 280;
+function oneSentence(value, max = DETAIL_LIMIT) {
+    if (typeof value !== 'string')
+        return null;
+    const flat = value.replace(/\s+/g, ' ').trim();
+    if (!flat)
+        return null;
+    return flat.length > max ? `${flat.slice(0, max - 1)}…` : flat;
+}
+function optionalText(value, max) {
+    return typeof value === 'string' && value.trim() ? value.trim().slice(0, max) : null;
+}
+/** Bounded copy of a host blocker; anything malformed is dropped. */
+function parseBlocker(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return null;
+    const value = raw;
+    const reason = optionalText(value.reason, 600);
+    const requiredAction = optionalText(value.requiredAction, 600);
+    if (!reason || !requiredAction)
+        return null;
+    const args = Array.isArray(value.args) ? value.args.filter((a) => typeof a === 'string').slice(0, 16).map((a) => a.slice(0, 256)) : [];
+    return { kind: optionalText(value.kind, 40) ?? 'environment', reason, command: optionalText(value.command, 512) ?? '', args, cwd: optionalText(value.cwd, 512) ?? '', requiredAction };
+}
+/**
+ * Validate the `failure` record of a Core runtime result. Tolerant: a newer
+ * Core's unknown kind degrades to `unknown`; a malformed record is rejected.
+ */
+function parseCoreFailure(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return null;
+    const value = raw;
+    const known = typeof value.kind === 'string' && exports.FAILURE_KINDS.includes(value.kind);
+    if (typeof value.kind !== 'string')
+        return null;
+    const kind = known ? value.kind : 'unknown';
+    const confidence = known && value.confidence === 'high' ? 'high' : 'low';
+    const rounds = typeof value.rounds === 'number' && Number.isInteger(value.rounds) && value.rounds > 0 ? value.rounds : null;
+    return {
+        // Low confidence is never presented as a cause.
+        kind: confidence === 'low' ? 'unknown' : kind,
+        confidence,
+        phase: optionalText(value.phase, 200),
+        rounds,
+        resetAt: kind === 'provider_limit' ? optionalText(value.resetAt, 80) : null,
+        detail: oneSentence(value.detail),
+        resumablePhase: optionalText(value.resumablePhase, 200),
+        blocker: parseBlocker(value.blocker),
+        source: 'core',
+    };
+}
+const BASELINE_CODE = /baseline_characterization_failed|^Baseline blocked:/i;
+// Core's own sentence for a host precondition (a fixed template, not a guess).
+const HOST_PRECONDITION = /Verification cannot run in this environment/i;
+/**
+ * Diagnosis of a terminal run. Core's classification wins; otherwise only
+ * certain signals (a stall reason, the provider-limit classifier, Core's fixed
+ * blocker sentences) produce a cause. Everything else is `unknown`/low.
+ */
+function deriveFailureDiagnosis(input) {
+    const core = parseCoreFailure(input.core);
+    if (core)
+        return { ...core, phase: core.phase ?? input.stepId ?? null };
+    const make = (kind, confidence, extra = {}) => ({
+        kind, confidence, phase: input.stepId ?? null, rounds: null, resetAt: null, detail: oneSentence(input.errorText), resumablePhase: null, blocker: null, source: 'desktop', ...extra,
+    });
+    if (input.providerLimit) {
+        return make('provider_limit', 'high', { resetAt: optionalText(input.providerLimit.resetsAt, 80), detail: oneSentence(input.providerLimit.message) });
+    }
+    if (input.stallReason === 'provider_limit')
+        return make('provider_limit', 'high');
+    if (input.stallReason === 'idle_timeout')
+        return make('tool_inactivity', 'high');
+    // The loop's own limits (cost cap, iteration cap) are deliberate stops, not failures of the change.
+    if (input.outcome === 'max-cost' || input.outcome === 'max-iterations')
+        return make('blocked', 'high', { detail: null });
+    if (input.stallReason === 'no_progress')
+        return make('blocked', 'high', { detail: oneSentence(input.errorText) ?? 'no_progress' });
+    const blocker = parseBlocker(input.hostBlocker);
+    if (blocker)
+        return make('environment', 'high', { blocker, detail: oneSentence(blocker.reason) });
+    if (input.outcome === 'blocked' && input.blockedReason)
+        return make('blocked', 'high', { detail: oneSentence(input.blockedReason) });
+    const text = input.errorText ?? '';
+    const limit = (0, provider_limit_1.classifyProviderLimit)(text);
+    if (limit)
+        return make('provider_limit', 'high', { resetAt: limit.resetsAt, detail: oneSentence(limit.message) });
+    if (BASELINE_CODE.test(text))
+        return make('blocked', 'high');
+    if (HOST_PRECONDITION.test(text))
+        return make('environment', 'high');
+    return make('unknown', 'low');
+}
+const RESUMABLE_KINDS = new Set(['provider_limit', 'environment', 'blocked', 'timeout', 'tool_inactivity', 'crash']);
+/** Ranked remedies for a diagnosis. Order matters: the client shows the first available ones (at most three). */
+function rankRemedies(diagnosis) {
+    // Resuming can help when Core named a phase, and for causes that are outside the change itself.
+    // A plain failed verification needs a change, not a resume. The client still shows `resume` only
+    // where the surface can actually resume the run.
+    const resume = diagnosis.resumablePhase || RESUMABLE_KINDS.has(diagnosis.kind) ? ['resume'] : [];
+    if (diagnosis.confidence === 'low')
+        return ['open-logs', 'retry'];
+    switch (diagnosis.kind) {
+        case 'tests_failed': return [...resume, 'edit-spec', 'open-logs', 'retry'];
+        case 'provider_limit': return [...resume, 'retry', 'open-logs'];
+        case 'environment': return ['fix-environment', ...resume, 'open-logs', 'retry'];
+        case 'blocked': return [...resume, 'edit-spec', 'open-logs', 'retry'];
+        case 'timeout':
+        case 'tool_inactivity':
+        case 'crash': return [...resume, 'retry', 'open-logs'];
+        default: return ['open-logs', 'retry'];
+    }
+}
+function presentFailureDiagnosis(diagnosis) {
+    return { ...diagnosis, remedies: rankRemedies(diagnosis) };
+}
+/** Outcomes that deserve a diagnosis. */
+function isDiagnosableOutcome(outcome) {
+    return outcome === 'failed' || outcome === 'blocked' || outcome === 'stalled' || outcome === 'max-cost' || outcome === 'max-iterations';
+}
+/** Read a stored record; anything unreadable is treated as absent so the caller re-derives. */
+function parseStoredDiagnosis(raw) {
+    if (!raw)
+        return null;
+    try {
+        const value = JSON.parse(raw);
+        const parsed = parseCoreFailure(value);
+        if (!parsed)
+            return null;
+        return { ...parsed, source: value.source === 'core' ? 'core' : 'desktop' };
+    }
+    catch {
+        return null;
+    }
+}
+function serializeDiagnosis(diagnosis) {
+    return JSON.stringify(diagnosis);
+}