salmon-loop 0.2.3

package/dist/core/grizzco/steps/research.js

@@ -0,0 +1,188 @@
+import { text } from '../../../locales/index.js';
+import { composeChatMessages } from '../../llm/message-composition.js';
+import { emitLlmOutput } from '../../llm/output-policy.js';
+import { formatContextForPrompt } from '../../llm/utils.js';
+import { chatWithTools, chatWithToolsStreaming } from '../../tools/session.js';
+import { Phase } from '../../types/runtime.js';
+import { resolveLlmToolCallingPolicy } from '../dsl/llm-strategy.js';
+function buildResearchPrompt(contextText, instruction) {
+    return [
+        'You are running in deep research mode.',
+        'Use available tools to gather external information as needed.',
+        'Return JSON with keys: researchNotes, researchFindings, sources, researchText.',
+        'Each researchFinding should include: summary, confidence (0-1), uncertainty (string).',
+        'Each source should include: toolName, summary, ok, timestamp (epoch ms).',
+        '',
+        `Instruction:\n${instruction}`,
+        '',
+        `Context:\n${contextText}`,
+    ].join('\n');
+}
+function normalizeFindings(value) {
+    if (!value)
+        return [];
+    if (Array.isArray(value)) {
+        return value
+            .map((item) => {
+            if (typeof item === 'string')
+                return { summary: item };
+            if (item && typeof item === 'object')
+                return item;
+            return { summary: String(item) };
+        })
+            .filter((item) => Boolean(item.summary));
+    }
+    if (typeof value === 'string')
+        return [{ summary: value }];
+    if (typeof value === 'object')
+        return [value];
+    return [{ summary: String(value) }];
+}
+function normalizeSources(value, fallback) {
+    if (!value)
+        return fallback;
+    if (Array.isArray(value)) {
+        return value
+            .map((item) => {
+            if (item && typeof item === 'object')
+                return item;
+            return undefined;
+        })
+            .filter(Boolean);
+    }
+    if (typeof value === 'object')
+        return [value];
+    return fallback;
+}
+function parseResearchResponse(content, fallbackSources) {
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    }
+    catch {
+        parsed = undefined;
+    }
+    const researchText = String(parsed?.researchText ?? content ?? text.grizzco.research.empty ?? '');
+    const researchNotes = Array.isArray(parsed?.researchNotes)
+        ? parsed?.researchNotes
+        : parsed?.researchNotes
+            ? [parsed?.researchNotes]
+            : [];
+    const researchFindings = normalizeFindings(parsed?.researchFindings ?? parsed);
+    const sources = normalizeSources(parsed?.sources, fallbackSources);
+    return {
+        researchNotes,
+        researchFindings,
+        sources,
+        researchText,
+    };
+}
+function buildSourcesFromAudit(entries) {
+    return entries.map((entry) => ({
+        toolName: entry.toolName,
+        summary: entry.parsedArgsPreview || entry.rawArgsPreview,
+        ok: entry.toolResultStatus === 'ok',
+        timestamp: Number.isFinite(Date.parse(entry.timestamp))
+            ? Date.parse(entry.timestamp)
+            : Date.now(),
+    }));
+}
+export async function generateResearch(ctx) {
+    const contextText = formatContextForPrompt(ctx.context);
+    const prompt = buildResearchPrompt(contextText, ctx.options.instruction);
+    const systemPrompt = 'You are a research assistant. Prefer evidence-backed claims.';
+    const baseMessages = composeChatMessages({
+        system: systemPrompt,
+        user: prompt,
+        conversationContext: ctx.options.conversationContext,
+    });
+    const toolPolicy = resolveLlmToolCallingPolicy(Phase.RESEARCH, ctx.options.llm);
+    const supportsStreaming = typeof ctx.options.llm.chatStream === 'function';
+    const localAudit = [];
+    const sourcesFromAudit = () => buildSourcesFromAudit(localAudit);
+    if (!ctx.toolstack || !toolPolicy.enabled) {
+        const response = await ctx.options.llm.chat(baseMessages, {
+            signal: ctx.options.signal,
+            phase: Phase.RESEARCH,
+        });
+        if (!response?.content) {
+            throw new Error(text.llm.reviewEmpty);
+        }
+        emitLlmOutput({
+            emit: ctx.emit,
+            policy: ctx.options.llmOutput,
+            kind: 'research',
+            step: 'RESEARCH',
+            content: response.content,
+        });
+        const parsed = parseResearchResponse(response.content, []);
+        const timestamp = Date.now();
+        return {
+            ...ctx,
+            ...parsed,
+            report: {
+                kind: 'research',
+                summary: parsed.researchText,
+                findings: parsed.researchFindings,
+                timestamp,
+            },
+        };
+    }
+    const llmOutput = {
+        policy: ctx.options.llmOutput,
+        kind: 'research',
+        step: 'RESEARCH',
+    };
+    const response = await (supportsStreaming ? chatWithToolsStreaming : chatWithTools)(baseMessages, { signal: ctx.options.signal }, {
+        phase: Phase.RESEARCH,
+        llm: ctx.options.llm,
+        runtime: {
+            repoRoot: ctx.workspace.workPath,
+            persistenceRoot: ctx.workspace.baseRepoPath || ctx.workspace.workPath,
+            worktreeRoot: ctx.workspace.strategy === 'worktree' ? ctx.workspace.workPath : undefined,
+            attemptId: ctx.attempt ?? 1,
+            dryRun: Boolean(ctx.options?.dryRun),
+            llm: ctx.options.llm,
+            model: ctx.options.llm.getModelId?.() || process.env.SALMONLOOP_MODEL || process.env.S8P_MODEL,
+            userInputProvider: ctx.options.userInputProvider,
+            agentKind: ctx.options.agentKind ?? 'primary',
+            languagePlugins: ctx.options.languagePlugins,
+            subAgentController: ctx.options.subAgentController,
+        },
+        toolstack: ctx.toolstack,
+        eventPayload: ctx.options.eventPayload,
+        toolCallingAudit: {
+            event: (entry) => {
+                localAudit.push(entry);
+                const list = ctx.toolCallingAudit ?? [];
+                list.push(entry);
+                ctx.toolCallingAudit = list;
+            },
+        },
+        maxRounds: toolPolicy.maxRounds,
+        llmOutput,
+        emit: (event) => ctx.emit({ ...event, timestamp: event.timestamp ?? new Date() }),
+    });
+    if (!response?.content) {
+        throw new Error(text.llm.reviewEmpty);
+    }
+    ctx.emit({
+        type: 'log',
+        level: 'info',
+        message: text.grizzco.research.generated,
+        timestamp: new Date(),
+    });
+    const parsed = parseResearchResponse(response.content, sourcesFromAudit());
+    const timestamp = Date.now();
+    return {
+        ...ctx,
+        ...parsed,
+        report: {
+            kind: 'research',
+            summary: parsed.researchText,
+            findings: parsed.researchFindings,
+            timestamp,
+        },
+    };
+}
+//# sourceMappingURL=research.js.map

package/dist/core/grizzco/steps/rollback.js

@@ -0,0 +1,138 @@
+import { text } from '../../../locales/index.js';
+import { GitAdapter } from '../../adapters/git/git-adapter.js';
+import { recordAuditEvent } from '../../observability/audit-trail.js';
+import { CheckpointManager } from '../../strata/checkpoint/manager.js';
+/**
+ * Normal Rollback (triggered by verification failure or user request)
+ */
+export const runRollback = async (ctx) => {
+    const shouldRollback = !ctx.verifyResult.ok || ctx.options.forceReset;
+    if (!shouldRollback || ctx.options.dryRun) {
+        recordAuditEvent('rollback.summary', {
+            shouldRollback,
+            rolledBack: false,
+            dryRun: ctx.options.dryRun,
+            changedFilesCount: ctx.changedFiles?.length ?? 0,
+        }, { source: 'grizzco', severity: 'low', scope: 'session', phase: 'ROLLBACK' });
+        return {
+            ...ctx,
+            rolledBack: false,
+        };
+    }
+    const rolled = await executeGitRollback(ctx);
+    recordAuditEvent('rollback.summary', {
+        shouldRollback,
+        rolledBack: rolled.rolledBack,
+        hasRollbackAnchor: Boolean(ctx.shadowInitialRef || ctx.options?.shadowInitialRef),
+        changedFilesCount: ctx.changedFiles?.length ?? 0,
+    }, { source: 'grizzco', severity: 'medium', scope: 'session', phase: 'ROLLBACK' });
+    return rolled;
+};
+/**
+ * Emergency Rollback (triggered by pipeline exception)
+ * Works with any context that might have changedFiles
+ */
+export const runEmergencyRollback = async (ctx) => {
+    if (ctx.options?.dryRun) {
+        return ctx;
+    }
+    try {
+        // Only attempt rollback if we have modified files and a snapshot
+        if (ctx.changedFiles && ctx.changedFiles.length > 0) {
+            ctx.emit?.({
+                type: 'log',
+                level: 'warn',
+                message: text.loop.emergencyRollbackTriggered,
+                timestamp: new Date(),
+            });
+            await executeGitRollback(ctx);
+        }
+    }
+    catch (error) {
+        // Emergency rollback failed - log but don't crash (we are already in error handling)
+        ctx.emit?.({
+            type: 'log',
+            level: 'error',
+            message: text.loop.emergencyRollbackFailed(String(error)),
+            timestamp: new Date(),
+        });
+    }
+    return ctx;
+};
+/**
+ * Executes Git rollback to restore workspace to initial snapshot state.
+ *
+ * ROLLBACK SEMANTICS - STATE MACHINE INTERPRETATION:
+ * ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ * Return value { rolledBack: boolean } indicates STATE, not OPERATION.
+ *
+ * Common Misunderstanding:
+ * ❌ "rolledBack: true means rollback operation was executed"
+ * ✅ Correct: "rolledBack: true means system IS IN expected rollback state"
+ *
+ * State Machine Logic:
+ * ┌──────────────────────┬─────────────┬──────────────────────────────┐
+ * │ Scenario             │ rolledBack  │ Meaning                      │
+ * ├──────────────────────┼─────────────┼──────────────────────────────┤
+ * │ Has anchor + executed│ true        │ Rollback performed           │
+ * │ No anchor (clean)    │ true        │ Already in target state      │
+ * │ Skipped by policy    │ false       │ Rollback not needed          │
+ * └──────────────────────┴─────────────┴──────────────────────────────┘
+ *
+ * Why "No Anchor" Returns true (Idempotency Pattern):
+ * - No shadowInitialRef = workspace never modified (no snapshot needed)
+ * - Workspace ALREADY in "clean" state we want
+ * - Returning true = "postcondition (clean state) is satisfied"
+ * - NOT "lying" - it's correct state machine semantics
+ *
+ * Analogy:
+ *   Q: "Is the door closed?"
+ *   A: If never opened → YES (current state, not action history)
+ *
+ * Design Pattern (Command Pattern + Idempotency):
+ * - Executing rollback() multiple times reaches same end state
+ * - State matters, not whether action was taken
+ *
+ * See: docs/design/execution-contract.md, docs/design/checkpoint.md
+ */
+async function executeGitRollback(ctx) {
+    const shadowInitialRef = ctx.shadowInitialRef || ctx.options?.shadowInitialRef;
+    if (!shadowInitialRef) {
+        // No snapshot anchor exists - workspace never modified
+        // System already in target state (no rollback needed)
+        ctx.emit?.({
+            type: 'log',
+            level: 'warn', // Warn (not error) - expected edge case
+            message: text.loop.rollbackSkippedNoAnchor,
+            timestamp: new Date(),
+        });
+        // STATE MACHINE: Return true because postcondition satisfied
+        // Workspace IS in expected clean state (no modified files)
+        return {
+            ...ctx,
+            rolledBack: true, // "In rollback state" (not "rollback executed")
+        };
+    }
+    // Worktree strategy needs a snapshot-aware rollback to preserve staged/unstaged semantics.
+    // `git checkout <snapshot> -- <path>` mutates the index and can break MM handling in retries.
+    if (ctx.workspace?.strategy === 'worktree') {
+        const checkpoints = new CheckpointManager();
+        await checkpoints.restoreToShadow(ctx.workspace.baseRepoPath || ctx.options?.repoPath, ctx.workspace.workPath, shadowInitialRef);
+    }
+    else {
+        const git = new GitAdapter(ctx.workspace.workPath);
+        const paths = ctx.changedFiles && ctx.changedFiles.length > 0 ? ctx.changedFiles : ['.'];
+        await git.safeRollback(paths, shadowInitialRef);
+    }
+    ctx.emit?.({
+        type: 'log',
+        level: 'info',
+        message: text.loop.rollbackCompleted,
+        timestamp: new Date(),
+    });
+    return {
+        ...ctx,
+        rolledBack: true,
+    };
+}
+//# sourceMappingURL=rollback.js.map

package/dist/core/grizzco/steps/shrink.js

@@ -0,0 +1,64 @@
+import { CONTEXT_AUDIT_ACTION, CONTEXT_AUDIT_PHASE } from '../../context/audit-constants.js';
+import { recordContextAuditEvent } from '../../context/audit.js';
+import { ContextBuilder } from '../../context/builder.js';
+import { refineFeedback } from '../../feedback/index.js';
+import { classifyError } from '../../verification/runner.js';
+function inferDependencyDepth(output) {
+    const lower = output.toLowerCase();
+    if (lower.includes('cannot find module') ||
+        lower.includes('module not found') ||
+        lower.includes('cannot find name') ||
+        lower.includes('is not defined') ||
+        lower.includes('type') ||
+        lower.includes('interface') ||
+        /ts\d{3,5}/i.test(output)) {
+        return 2;
+    }
+    return 1;
+}
+export const runShrink = async (ctx) => {
+    if (!ctx.verifyResult.ok) {
+        // Only shrink if verification failed
+        const failedFiles = ContextBuilder.extractFailedFiles(ctx.verifyResult.output, {
+            languagePlugins: ctx.options.languagePlugins,
+        });
+        const errorType = classifyError(ctx.verifyResult.output);
+        const dependencyDepth = inferDependencyDepth(ctx.verifyResult.output);
+        const newContext = await ContextBuilder.shrinkContext(ctx.context, failedFiles, {
+            errorType,
+            dependencyDepth,
+        });
+        const lastError = refineFeedback(ctx.verifyResult.output);
+        recordContextAuditEvent(CONTEXT_AUDIT_ACTION.shrinkSummary, {
+            shrunk: true,
+            failedFiles: failedFiles.slice(0, 20),
+            failedFilesCount: failedFiles.length,
+            errorType,
+            dependencyDepth,
+            verifyExitCode: ctx.verifyResult.exitCode,
+        }, {
+            source: 'context',
+            severity: 'medium',
+            scope: 'session',
+            phase: CONTEXT_AUDIT_PHASE.shrink,
+        });
+        ctx.emit({
+            type: 'log',
+            level: 'debug',
+            message: 'Context shrunk for retry',
+            timestamp: new Date(),
+        });
+        return {
+            ...ctx,
+            context: newContext,
+            lastError,
+            shrunk: true,
+        };
+    }
+    recordContextAuditEvent(CONTEXT_AUDIT_ACTION.shrinkSummary, { shrunk: false }, { source: 'context', severity: 'low', scope: 'session', phase: CONTEXT_AUDIT_PHASE.shrink });
+    return {
+        ...ctx,
+        shrunk: false,
+    };
+};
+//# sourceMappingURL=shrink.js.map

package/dist/core/grizzco/steps/validate.js

@@ -0,0 +1,40 @@
+import { text } from '../../../locales/index.js';
+import { GitAdapter } from '../../adapters/git/git-adapter.js';
+import { PatchNotApplicableError } from '../../types/errors.js';
+export const validatePatch = async (ctx) => {
+    // Validation logic
+    const isValid = ctx.diffMeta !== null;
+    if (!isValid) {
+        ctx.emit({
+            type: 'log',
+            level: 'error',
+            message: text.loop.patchValidationFailed,
+            timestamp: new Date(),
+        });
+        throw new Error(text.loop.patchValidationFailed);
+    }
+    // Deterministic contract: the generated patch must be applicable to the current workspace.
+    // This shifts "patch does not apply" failures from APPLY to VALIDATE, producing better feedback
+    // for the next PATCH attempt.
+    const git = new GitAdapter(ctx.workspace.workPath);
+    const check = await git.execMeta(['apply', '--check', '--recount', '--ignore-whitespace', '--whitespace=nowarn', '-'], {
+        input: Buffer.from(ctx.diff, 'utf8'),
+        timeoutMs: 15000,
+        limits: { maxStdoutBytes: 0, maxStderrChars: 4000 },
+    });
+    if (!check.ok) {
+        const details = (check.stderr || '').trim();
+        throw new PatchNotApplicableError(text.diff.patchDoesNotApply(details.slice(0, 2000)));
+    }
+    ctx.emit({
+        type: 'log',
+        level: 'info',
+        message: text.loop.diffValidationPassed,
+        timestamp: new Date(),
+    });
+    return {
+        ...ctx,
+        isValid,
+    };
+};
+//# sourceMappingURL=validate.js.map

package/dist/core/grizzco/steps/verify.js

@@ -0,0 +1,136 @@
+import { text } from '../../../locales/index.js';
+import { collectBudgetMetrics, evaluateBudgetAlert, getGlobalAdjuster, recordBudgetAlert, } from '../../context/budget/integration.js';
+import { recordAuditEvent } from '../../observability/audit-trail.js';
+import { ArtifactStore } from '../../sub-agent/artifacts/store.js';
+import { runVerify as runVerifyCommand } from '../../verification/runner.js';
+function extractCommandProgram(command) {
+    const trimmed = command.trim();
+    if (!trimmed)
+        return '';
+    return trimmed.split(/\s+/)[0] ?? '';
+}
+export const runVerify = async (ctx) => {
+    if (!ctx.options.verify) {
+        return {
+            ...ctx,
+            verifyResult: { ok: true, output: text.loop.verificationSkipped, exitCode: null },
+        };
+    }
+    const verifyResult = await runVerifyCommand(ctx.workspace.workPath, ctx.options.verify, undefined, ctx.options.signal);
+    let verifyArtifact;
+    recordAuditEvent('verify.summary', {
+        ok: verifyResult.ok,
+        exitCode: verifyResult.exitCode,
+        outputChars: verifyResult.output?.length ?? 0,
+        commandProgram: extractCommandProgram(ctx.options.verify),
+        commandLength: ctx.options.verify.length,
+    }, {
+        source: 'verification',
+        severity: verifyResult.ok ? 'low' : 'medium',
+        scope: 'session',
+        phase: 'VERIFY',
+    });
+    // Collect budget metrics after verification
+    if (ctx.contextResult) {
+        const metrics = collectBudgetMetrics({
+            contextResult: ctx.contextResult,
+            verifyResult,
+            iteration: ctx.attempt ?? 1,
+        });
+        getGlobalAdjuster().recordMetrics(metrics);
+        // Log budget stats for observability
+        const stats = getGlobalAdjuster().getStats();
+        if (stats) {
+            ctx.emit({
+                type: 'log',
+                level: 'debug',
+                message: text.loop.budgetStatusSummary(Math.round(stats.avgUtilization * 100), Math.round(stats.truncationRate * 100), Math.round(stats.successRate * 100), Math.round(stats.criticalDropRate * 100), stats.sampleSize),
+                timestamp: new Date(),
+            });
+            recordAuditEvent('context.budget.stats', {
+                avgUtilization: stats.avgUtilization,
+                truncationRate: stats.truncationRate,
+                successRate: stats.successRate,
+                criticalDropRate: stats.criticalDropRate,
+                sampleSize: stats.sampleSize,
+            }, {
+                source: 'context',
+                severity: 'low',
+                scope: 'session',
+                phase: 'VERIFY',
+            });
+            const alert = evaluateBudgetAlert(stats, getGlobalAdjuster().getAlertThresholds());
+            if (alert) {
+                recordBudgetAlert();
+                recordAuditEvent('context.budget.alert', {
+                    level: alert.level,
+                    reason: alert.reason,
+                    avgUtilization: stats.avgUtilization,
+                    truncationRate: stats.truncationRate,
+                    successRate: stats.successRate,
+                    criticalDropRate: stats.criticalDropRate,
+                    sampleSize: stats.sampleSize,
+                }, {
+                    source: 'context',
+                    severity: 'medium',
+                    scope: 'session',
+                    phase: 'VERIFY',
+                });
+                ctx.emit({
+                    type: 'log',
+                    level: 'warn',
+                    message: `Budget alert: ${alert.reason}`,
+                    timestamp: new Date(),
+                });
+            }
+        }
+    }
+    if (!verifyResult.ok) {
+        ctx.emit({
+            type: 'log',
+            level: 'warn',
+            message: text.loop.verificationFailedSummary,
+            timestamp: new Date(),
+        });
+        if (verifyResult.output) {
+            try {
+                verifyArtifact = await ArtifactStore.saveText({
+                    content: verifyResult.output,
+                    mimeType: 'text/plain',
+                    fileExt: 'log',
+                });
+                ctx.emit({
+                    type: 'log',
+                    level: 'debug',
+                    message: text.loop.verificationOutputStored(verifyArtifact.handle),
+                    timestamp: new Date(),
+                });
+            }
+            catch {
+                // Best-effort only; keep verifyResult.output in-memory for shrink/error classification.
+            }
+        }
+        // We don't throw here, because we want to trigger rollback/shrink in the pipeline
+        // But wait, the Pipeline abstraction propagates errors immediately.
+        // If we want Rollback/Shrink to handle this, we should NOT throw here, but return a failed context?
+        // OR, we throw a specific error that the Pipeline knows how to handle?
+        // If a step fails, the pipeline aborts.
+        // BUT we have a linear flow: Verify -> Rollback -> Shrink.
+        // If Verify fails, we DO want to continue to Rollback/Shrink.
+        // So we should NOT throw Error here. We return the result, and let next steps decide.
+    }
+    else {
+        ctx.emit({
+            type: 'log',
+            level: 'info',
+            message: text.loop.verificationPassed,
+            timestamp: new Date(),
+        });
+    }
+    return {
+        ...ctx,
+        verifyResult,
+        ...(verifyArtifact ? { verifyArtifact } : {}),
+    };
+};
+//# sourceMappingURL=verify.js.map