@gethmy/agent 1.7.1 → 1.7.2

package/dist/completion.js

@@ -1,322 +0,0 @@
-import { execFileSync } from "node:child_process";
-import { moveCardToColumn } from "./board-helpers.js";
-import { writeEpisode } from "./episode-writer.js";
-import { captureDiffStat } from "./git-diff-stat.js";
-import { createPullRequest, detectGitProvider, getBranchWebUrl, pushBranch, } from "./git-pr.js";
-import { log } from "./log.js";
-import { AGENT_NAME, agentIdentifier } from "./types.js";
-import { attemptAutoFix, reportFindings, runVerification, } from "./verification.js";
-import { cleanupWorktree } from "./worktree.js";
-const TAG = "completion";
-function formatTokenCount(tokens) {
-    if (tokens >= 1_000_000)
-        return `${(tokens / 1_000_000).toFixed(1)}M`;
-    if (tokens >= 1_000)
-        return `${(tokens / 1_000).toFixed(1)}k`;
-    return String(tokens);
-}
-export function buildTokenPayload(stats) {
-    if (!stats?.cost)
-        return {};
-    return {
-        costCents: Math.round(stats.cost.totalCostUsd * 100),
-        inputTokens: stats.cost.totalInputTokens,
-        outputTokens: stats.cost.totalOutputTokens,
-        cacheCreationInputTokens: stats.cost.totalCacheCreationInputTokens,
-        cacheReadInputTokens: stats.cost.totalCacheReadInputTokens,
-        modelName: stats.cost.modelName,
-    };
-}
-/**
- * Post-work pipeline: push branch, create PR, move card, post summary.
- */
-export async function runCompletion(client, card, branchName, worktreePath, config, workerId, sessionStats, workspaceId, agentSessionId, stateStore) {
-    // Hoisted so the episode write hook can read final verification state.
-    let verificationResult = {
-        passed: true,
-        buildErrors: [],
-        lintWarnings: [],
-        reviewFindings: [],
-    };
-    // Check if there are any commits on the branch
-    const hasCommits = checkHasCommits(worktreePath, config.worktree.baseBranch);
-    if (!hasCommits) {
-        log.warn(TAG, `No commits on branch ${branchName} — skipping completion`);
-        await client.endAgentSession(card.id, {
-            status: "completed",
-            progressPercent: 100,
-            ...buildTokenPayload(sessionStats),
-        });
-        cleanupWorktree(worktreePath, branchName);
-        return true; // nothing to verify — not a failed attempt
-    }
-    // 1. Push branch FIRST so commits are durable on origin regardless of
-    // verification outcome. A failed verify (below) then preserves the work
-    // under `agent-attempts/*` for `failedAttemptRetentionDays`. Without this
-    // ordering, verify failures used to orphan commits in a deleted worktree —
-    // recoverable only via `git reflog`.
-    //
-    // `lastPushedSha` tracks the most recent commit we successfully pushed so
-    // later push points (post-fix, post-fail) can skip when HEAD hasn't moved.
-    log.info(TAG, `Pushing branch ${branchName} (pre-verify)...`);
-    let lastPushedSha = null;
-    try {
-        pushBranch(branchName, worktreePath);
-        lastPushedSha = readHeadSha(worktreePath);
-    }
-    catch (err) {
-        // Push failure shouldn't prevent verification from running, but the
-        // safety guarantee is gone — surface it loudly so the operator notices.
-        log.error(TAG, `pre-verify push failed for ${branchName}: ${err instanceof Error ? err.message : err}`);
-    }
-    // Only surface a recovery URL when the push actually landed — otherwise
-    // the link points at a ref that doesn't exist on origin.
-    const recoveryUrl = lastPushedSha
-        ? getBranchWebUrl(branchName, worktreePath)
-        : null;
-    // 2. Verification gate
-    if (config.verification.enabled) {
-        await client.updateAgentProgress(card.id, {
-            agentIdentifier: agentIdentifier(workerId),
-            agentName: AGENT_NAME,
-            status: "working",
-            currentTask: "Verifying build...",
-            progressPercent: 80,
-        });
-        let result = await runVerification(worktreePath, config, workerId);
-        let autoFixAttempts = 0;
-        if (!result.passed && config.verification.autoFix) {
-            for (let attempt = 0; attempt < config.verification.maxFixAttempts; attempt++) {
-                log.info(TAG, `Auto-fix attempt ${attempt + 1}/${config.verification.maxFixAttempts}`);
-                await client.updateAgentProgress(card.id, {
-                    agentIdentifier: agentIdentifier(workerId),
-                    agentName: AGENT_NAME,
-                    status: "working",
-                    currentTask: `Fixing issues (attempt ${attempt + 1})...`,
-                    progressPercent: 85,
-                });
-                const allErrors = [...result.buildErrors, ...result.lintWarnings];
-                await attemptAutoFix(worktreePath, config, allErrors);
-                result = await runVerification(worktreePath, config, workerId);
-                autoFixAttempts = attempt + 1;
-                if (result.passed) {
-                    log.info(TAG, `Auto-fix succeeded on attempt ${attempt + 1}`);
-                    // Push again so any auto-fix commits are durable on origin. Skip
-                    // when HEAD hasn't moved since the last successful push — autofix
-                    // can pass without producing new commits.
-                    const sha = readHeadSha(worktreePath);
-                    if (sha && sha !== lastPushedSha) {
-                        try {
-                            pushBranch(branchName, worktreePath);
-                            lastPushedSha = sha;
-                        }
-                        catch (err) {
-                            log.warn(TAG, `post-fix push failed for ${branchName}: ${err instanceof Error ? err.message : err}`);
-                        }
-                    }
-                    break;
-                }
-            }
-        }
-        verificationResult = result;
-        if (!result.passed) {
-            log.warn(TAG, `Verification failed for #${card.short_id} — reporting findings`);
-            // Push the latest tip (including any auto-fix attempts) so the
-            // failed branch on origin reflects what verify saw. Skip when HEAD
-            // hasn't advanced since the last successful push — common when
-            // every auto-fix attempt produced no new commits.
-            const failSha = readHeadSha(worktreePath);
-            if (failSha && failSha !== lastPushedSha) {
-                try {
-                    pushBranch(branchName, worktreePath);
-                    lastPushedSha = failSha;
-                }
-                catch (err) {
-                    log.warn(TAG, `post-fail push failed for ${branchName}: ${err instanceof Error ? err.message : err}`);
-                }
-            }
-            const failureSummary = buildVerificationFailureSummary(result, autoFixAttempts);
-            try {
-                await stateStore.recordFailureSummary(card.id, {
-                    summary: failureSummary,
-                    reason: "verification",
-                    recoveryBranch: branchName,
-                });
-            }
-            catch (err) {
-                log.debug(TAG, `recordFailureSummary failed: ${err instanceof Error ? err.message : err}`);
-            }
-            // Only attach recovery instructions when the branch actually exists
-            // on origin — otherwise the `git fetch && git checkout` command we'd
-            // surface would fail for the user.
-            await reportFindings(client, card.id, result, lastPushedSha ? { branchName, branchUrl: recoveryUrl } : null);
-            await moveCardToColumn(client, card, config.verification.failColumn);
-            await client.endAgentSession(card.id, {
-                status: "failed",
-                failureReason: "verification",
-                failureSummary,
-                recoveryBranch: branchName,
-                ...buildTokenPayload(sessionStats),
-            });
-            // Local-only cleanup. The remote ref under `agent-attempts/*` stays
-            // up; the GC sweep (worktree-gc.ts) prunes it after retention.
-            cleanupWorktree(worktreePath, branchName);
-            return false; // verification failed — counts as a failed attempt
-        }
-        log.info(TAG, `Verification passed for #${card.short_id}`);
-    }
-    // 3. Create PR
-    let prUrl = null;
-    if (config.completion.createPR) {
-        const provider = detectGitProvider(worktreePath);
-        prUrl = createPullRequest(card, branchName, worktreePath, config, provider);
-    }
-    // 4. Move card to Review column
-    if (config.completion.moveToColumn) {
-        await moveCardToColumn(client, card, config.completion.moveToColumn);
-    }
-    // 5. Post summary — always includes branch, optionally PR link
-    if (config.completion.postSummary) {
-        await postSummary(client, card, branchName, worktreePath, prUrl, config.worktree.baseBranch, sessionStats);
-    }
-    // 6. End agent session (include final token/cost snapshot)
-    await client.endAgentSession(card.id, {
-        status: "completed",
-        progressPercent: 100,
-        ...buildTokenPayload(sessionStats),
-    });
-    // 6a. Episode write hook (Phase 1.5): completed implement runs accumulate
-    // into project-scoped episodic memory. Best-effort — failures never block
-    // the completion path (plan §"Write hook" + D8).
-    //
-    // Outcome is constant "success" here: verification failures return early
-    // above with status=paused, and D8 mandates paused/orphaned runs skip the
-    // episode write entirely. A failure-outcome episode would require routing
-    // a separate write hook into the pre-return path, which D8 intentionally
-    // omits ("daemon crashes ≠ task outcome").
-    if (workspaceId) {
-        // Capture changed files + churn from the diff (#272). Best-effort + guarded:
-        // a null result just falls back to the ProgressTracker-tracked edit paths.
-        // The diff's file list is authoritative (it reflects what actually landed,
-        // including renames/deletes the tracker can't see) so prefer it.
-        const diffStat = captureDiffStat(worktreePath, config.worktree.baseBranch);
-        const changedFiles = diffStat && diffStat.files.length > 0
-            ? diffStat.files
-            : (sessionStats?.filesEditedPaths ?? []);
-        await writeEpisode(client, {
-            kind: "implement",
-            card,
-            workspaceId,
-            outcome: "success",
-            approachSummary: sessionStats?.lastAssistantText ?? "",
-            approachBlocks: sessionStats?.assistantTextBlocks,
-            result: verificationResult,
-            cost: sessionStats?.cost ?? null,
-            filesEdited: sessionStats?.filesEdited ?? 0,
-            changedFiles,
-            churn: diffStat
-                ? {
-                    insertions: diffStat.insertions,
-                    deletions: diffStat.deletions,
-                }
-                : undefined,
-            agentSessionId: agentSessionId ?? null,
-        });
-    }
-    // 7. Cleanup worktree
-    cleanupWorktree(worktreePath, branchName);
-    log.info(TAG, `Completion done for #${card.short_id}${prUrl ? ` — PR: ${prUrl}` : ""}`);
-    return true;
-}
-function buildVerificationFailureSummary(result, autoFixAttempts) {
-    const counts = [];
-    if (result.buildErrors.length > 0) {
-        counts.push(`${result.buildErrors.length} build error(s)`);
-    }
-    if (result.lintWarnings.length > 0) {
-        counts.push(`${result.lintWarnings.length} lint issue(s)`);
-    }
-    if (result.reviewFindings.length > 0) {
-        counts.push(`${result.reviewFindings.length} review finding(s)`);
-    }
-    const head = counts.length > 0 ? counts.join(", ") : "verification failed";
-    const tail = autoFixAttempts > 0 ? ` after ${autoFixAttempts} auto-fix attempt(s)` : "";
-    return `${head}${tail}`;
-}
-function readHeadSha(worktreePath) {
-    try {
-        return execFileSync("git", ["rev-parse", "HEAD"], {
-            cwd: worktreePath,
-            encoding: "utf-8",
-        }).trim();
-    }
-    catch {
-        return null;
-    }
-}
-function checkHasCommits(worktreePath, baseBranch) {
-    try {
-        const count = execFileSync("git", ["rev-list", "--count", `origin/${baseBranch}..HEAD`], { cwd: worktreePath, encoding: "utf-8" }).trim();
-        return parseInt(count, 10) > 0;
-    }
-    catch {
-        return false;
-    }
-}
-async function postSummary(client, card, branchName, worktreePath, prUrl, baseBranch, sessionStats) {
-    // Build commit summary
-    let commitLog = "";
-    try {
-        commitLog = execFileSync("git", ["log", "--oneline", `origin/${baseBranch}..HEAD`], { cwd: worktreePath, encoding: "utf-8" }).trim();
-    }
-    catch {
-        // best-effort
-    }
-    // Build description note
-    const SUMMARY_MARKER = "---\n**Agent completed**";
-    const parts = [`\n\n${SUMMARY_MARKER}`];
-    if (prUrl) {
-        parts.push(`PR: ${prUrl}`);
-    }
-    parts.push(`Branch: \`${branchName}\``);
-    if (sessionStats) {
-        const statParts = [];
-        statParts.push(`${sessionStats.toolCalls} tool calls`);
-        statParts.push(`${sessionStats.filesEdited} files edited`);
-        statParts.push(`${sessionStats.filesRead} files read`);
-        if (sessionStats.cost) {
-            statParts.push(`$${sessionStats.cost.totalCostUsd.toFixed(2)} cost`);
-            statParts.push(`${sessionStats.cost.numTurns} turns`);
-            const totalInput = sessionStats.cost.totalInputTokens +
-                sessionStats.cost.totalCacheCreationInputTokens +
-                sessionStats.cost.totalCacheReadInputTokens;
-            const totalTokens = totalInput + sessionStats.cost.totalOutputTokens;
-            if (totalTokens > 0) {
-                statParts.push(`${formatTokenCount(totalTokens)} tokens`);
-            }
-            const cacheRead = sessionStats.cost.totalCacheReadInputTokens;
-            if (totalInput > 0 && cacheRead > 0) {
-                const hitPct = Math.round((cacheRead / totalInput) * 100);
-                statParts.push(`${hitPct}% cache hit`);
-            }
-        }
-        parts.push(`Stats: ${statParts.join(" · ")}`);
-    }
-    if (commitLog) {
-        parts.push(`\n\`\`\`\n${commitLog}\n\`\`\``);
-    }
-    try {
-        // Strip any previous agent summary block before appending (rework)
-        const existingDesc = card.description || "";
-        const baseDesc = existingDesc.includes(SUMMARY_MARKER)
-            ? existingDesc.slice(0, existingDesc.indexOf(SUMMARY_MARKER)).trimEnd()
-            : existingDesc;
-        await client.updateCard(card.id, {
-            description: baseDesc + parts.join("\n"),
-        });
-        log.info(TAG, `Posted completion summary to #${card.short_id}`);
-    }
-    catch (err) {
-        log.error(TAG, `Failed to post summary: ${err instanceof Error ? err.message : err}`);
-    }
-}

package/dist/config-validation.d.ts

@@ -1,23 +0,0 @@
-import type { HarmonyApiClient } from "@gethmy/mcp/src/api-client.js";
-import type { AgentConfig } from "./types.js";
-export declare class ConfigValidationError extends Error {
-    readonly issues: string[];
-    constructor(message: string, issues: string[]);
-}
-/**
- * Validate that every column referenced in the agent config actually
- * exists on the board. Labels that the daemon needs to create (agent,
- * Ready to Merge, Merged, Need Review, agent-recovered) are not
- * required to pre-exist — the daemon creates them on demand. Columns
- * must already exist because moving a card to a non-existent column
- * silently fails and leaves cards stuck.
- *
- * Fail-fast on any mismatch: the operator fixes their config OR the
- * board before the daemon is useful.
- */
-export declare function validateColumnReferences(client: HarmonyApiClient, projectId: string, config: AgentConfig): Promise<void>;
-/**
- * Same checks as validateColumnReferences but returns the unique list of
- * validated column names (used by the startup banner). Throws on mismatch.
- */
-export declare function validateAndListColumns(client: HarmonyApiClient, projectId: string, config: AgentConfig): Promise<string[]>;

package/dist/config-validation.js

@@ -1,77 +0,0 @@
-export class ConfigValidationError extends Error {
-    issues;
-    constructor(message, issues) {
-        super(message);
-        this.issues = issues;
-        this.name = "ConfigValidationError";
-    }
-}
-function columnNames(board) {
-    return board.columns.map((c) => c.name);
-}
-function findColumn(board, name) {
-    const target = name.toLowerCase();
-    return board.columns.some((c) => c.name.toLowerCase() === target);
-}
-/**
- * Validate that every column referenced in the agent config actually
- * exists on the board. Labels that the daemon needs to create (agent,
- * Ready to Merge, Merged, Need Review, agent-recovered) are not
- * required to pre-exist — the daemon creates them on demand. Columns
- * must already exist because moving a card to a non-existent column
- * silently fails and leaves cards stuck.
- *
- * Fail-fast on any mismatch: the operator fixes their config OR the
- * board before the daemon is useful.
- */
-export async function validateColumnReferences(client, projectId, config) {
-    const board = (await client.getBoard(projectId, {
-        summary: true,
-    }));
-    const known = columnNames(board);
-    const issues = [];
-    const required = [
-        ...config.pickupColumns.map((c) => ({ value: c, where: "pickupColumns" })),
-        {
-            value: config.completion.moveToColumn,
-            where: "completion.moveToColumn",
-        },
-        {
-            value: config.verification.failColumn,
-            where: "verification.failColumn",
-        },
-    ];
-    if (config.review.enabled) {
-        for (const c of config.review.pickupColumns) {
-            required.push({ value: c, where: "review.pickupColumns" });
-        }
-        required.push({ value: config.review.moveToColumn, where: "review.moveToColumn" }, { value: config.review.failColumn, where: "review.failColumn" });
-    }
-    for (const { value, where } of required) {
-        if (!value)
-            continue;
-        if (!findColumn(board, value)) {
-            issues.push(`${where}: column "${value}" not found on board`);
-        }
-    }
-    if (issues.length > 0) {
-        const help = `Available columns: ${known.join(", ")}`;
-        throw new ConfigValidationError(`Invalid agent config — the following columns are missing:\n  - ${issues.join("\n  - ")}\n${help}`, issues);
-    }
-}
-/**
- * Same checks as validateColumnReferences but returns the unique list of
- * validated column names (used by the startup banner). Throws on mismatch.
- */
-export async function validateAndListColumns(client, projectId, config) {
-    await validateColumnReferences(client, projectId, config);
-    const names = [
-        ...config.pickupColumns,
-        config.completion.moveToColumn,
-        config.verification.failColumn,
-    ];
-    if (config.review.enabled) {
-        names.push(...config.review.pickupColumns, config.review.moveToColumn, config.review.failColumn);
-    }
-    return Array.from(new Set(names.filter(Boolean)));
-}

package/dist/config.d.ts

@@ -1,23 +0,0 @@
-import { HarmonyApiClient } from "@gethmy/mcp/src/api-client.js";
-import type { AgentConfig, RealtimeCredentials } from "./types.js";
-export interface DaemonConfig {
-    apiKey: string;
-    apiUrl: string;
-    workspaceId: string;
-    projectId: string;
-    userEmail: string;
-    agent: AgentConfig;
-}
-/**
- * Load daemon configuration from ~/.harmony-mcp/config.json,
- * merging default agent settings with any user overrides.
- */
-export declare function loadDaemonConfig(): DaemonConfig;
-/**
- * Fetch Supabase realtime credentials from the Harmony API.
- */
-export declare function fetchRealtimeCredentials(client: HarmonyApiClient): Promise<RealtimeCredentials>;
-/**
- * Create an API client from daemon config.
- */
-export declare function createApiClient(config: DaemonConfig): HarmonyApiClient;

package/dist/config.js

@@ -1,103 +0,0 @@
-import { execSync } from "node:child_process";
-import { readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { HarmonyApiClient } from "@gethmy/mcp/src/api-client.js";
-import { getActiveProjectId, getActiveWorkspaceId, getApiKey, getApiUrl, getUserEmail, } from "@gethmy/mcp/src/config.js";
-import { DEFAULT_AGENT_CONFIG } from "./types.js";
-/**
- * Resolve the git repo root so local config lookup always
- * finds .harmony-mcp.json regardless of cwd.
- */
-function getRepoRoot() {
-    return execSync("git rev-parse --show-toplevel", {
-        encoding: "utf-8",
-    }).trim();
-}
-/**
- * Load daemon configuration from ~/.harmony-mcp/config.json,
- * merging default agent settings with any user overrides.
- */
-export function loadDaemonConfig() {
-    const repoRoot = getRepoRoot();
-    const apiKey = getApiKey();
-    const apiUrl = getApiUrl();
-    const workspaceId = getActiveWorkspaceId(repoRoot);
-    const projectId = getActiveProjectId(repoRoot);
-    const userEmail = getUserEmail();
-    if (!workspaceId) {
-        throw new Error("No active workspace configured. Run `npx @gethmy/mcp setup` first.");
-    }
-    if (!projectId) {
-        throw new Error("No active project configured. Run `npx @gethmy/mcp setup` first.");
-    }
-    if (!userEmail) {
-        throw new Error("No user email configured. Run `npx @gethmy/mcp setup` first.");
-    }
-    // Try to load agent-specific overrides from config file
-    let agentOverrides = {};
-    try {
-        const configPath = join(homedir(), ".harmony-mcp", "config.json");
-        const raw = readFileSync(configPath, "utf-8");
-        const parsed = JSON.parse(raw);
-        if (parsed.agent) {
-            agentOverrides = parsed.agent;
-        }
-    }
-    catch {
-        // No overrides, use defaults
-    }
-    const agent = {
-        ...DEFAULT_AGENT_CONFIG,
-        ...agentOverrides,
-        completion: {
-            ...DEFAULT_AGENT_CONFIG.completion,
-            ...(agentOverrides.completion ?? {}),
-        },
-        claude: {
-            ...DEFAULT_AGENT_CONFIG.claude,
-            ...(agentOverrides.claude ?? {}),
-        },
-        worktree: {
-            ...DEFAULT_AGENT_CONFIG.worktree,
-            ...(agentOverrides.worktree ?? {}),
-        },
-        verification: {
-            ...DEFAULT_AGENT_CONFIG.verification,
-            ...(agentOverrides.verification ?? {}),
-        },
-        review: {
-            ...DEFAULT_AGENT_CONFIG.review,
-            ...(agentOverrides.review ?? {}),
-        },
-        budget: {
-            ...DEFAULT_AGENT_CONFIG.budget,
-            ...(agentOverrides.budget ?? {}),
-        },
-        http: {
-            ...DEFAULT_AGENT_CONFIG.http,
-            ...(agentOverrides.http ?? {}),
-        },
-        timing: {
-            ...DEFAULT_AGENT_CONFIG.timing,
-            ...(agentOverrides.timing ?? {}),
-        },
-    };
-    return { apiKey, apiUrl, workspaceId, projectId, userEmail, agent };
-}
-/**
- * Fetch Supabase realtime credentials from the Harmony API.
- */
-export async function fetchRealtimeCredentials(client) {
-    const result = (await client.request("GET", "/config/realtime"));
-    if (!result.supabaseUrl || !result.supabaseAnonKey) {
-        throw new Error("Invalid realtime credentials response from API");
-    }
-    return result;
-}
-/**
- * Create an API client from daemon config.
- */
-export function createApiClient(config) {
-    return new HarmonyApiClient({ apiKey: config.apiKey, apiUrl: config.apiUrl });
-}

package/dist/episode-writer.d.ts

@@ -1,116 +0,0 @@
-import type { HarmonyApiClient } from "@gethmy/mcp/src/api-client.js";
-import type { Card } from "@harmony/shared";
-import type { CostUpdate } from "./stream-parser.js";
-import type { EpisodeMeta, EpisodeOutcome } from "./types.js";
-import type { VerificationResult } from "./verification.js";
-interface ImplementEpisodeInput {
-    kind: "implement";
-    card: Card;
-    workspaceId: string;
-    outcome: EpisodeOutcome;
-    approachSummary: string;
-    /**
-     * All non-trivial assistant text blocks from the run (#272). When present,
-     * used to assemble a richer approach summary + extract a key insight. Falls
-     * back to `approachSummary` (last turn) when empty.
-     */
-    approachBlocks?: string[];
-    result: VerificationResult;
-    cost: CostUpdate | null;
-    filesEdited: number;
-    /** Changed file paths (#272): diff list when available, else tracked paths. */
-    changedFiles?: string[];
-    /** Line churn (#272), best-effort from `git diff --numstat`. */
-    churn?: {
-        insertions: number;
-        deletions: number;
-    };
-    errorMessage?: string;
-    agentSessionId?: string | null;
-}
-interface ReviewEpisodeInput {
-    kind: "review";
-    card: Card;
-    workspaceId: string;
-    verdict: "approved" | "rejected";
-    summary: string;
-    cost: CostUpdate | null;
-    agentSessionId?: string | null;
-    reviewSessionId?: string | null;
-    originalEpisodeId?: string | null;
-}
-export type EpisodeInput = ImplementEpisodeInput | ReviewEpisodeInput;
-/**
- * Rule-derived quality score (0..1) for an implement run. Failures default to 0.
- * Plan §"Quality score": +0.4 if build passed, +0.2 if lint passed, +0.2 if no
- * error thrown, +0.2 if run completed cleanly.
- */
-export declare function computeQualityScore(result: VerificationResult, opts: {
-    errorThrown: boolean;
-    runCompletedCleanly: boolean;
-}): number;
-/**
- * Trim a free-form summary down to the documented 400-char cap. v1 uses a
- * last-turn trim rather than an LLM rewrite (plan §"Write hook"). Empty or
- * whitespace-only input collapses to a marker so the episode still surfaces
- * as a recallable hit (rather than an empty bullet) in future prompts.
- */
-export declare function trimApproachSummary(text: string): string;
-/**
- * Cap the review rationale ("why approved / rejected") richly (#272 task 5)
- * rather than re-trimming to the 400-char implement bound. Empty input
- * collapses to a marker so the episode still surfaces as a recallable hit.
- */
-export declare function trimReviewRationale(text: string): string;
-/**
- * Assemble a richer approach summary from the collected assistant text blocks
- * (#272). Joins the trailing blocks (most relevant context lives near the end
- * of a run) up to a longer bounded cap than the single-turn trim. Falls back to
- * the last-turn `fallback` text when no blocks were collected. No LLM call.
- */
-export declare function buildRichApproachSummary(blocks: string[] | undefined, fallback: string): string;
-/**
- * Extract a cheap deterministic "key insight" line from the run's assistant
- * text (#272 task 3). Scans for a sentence/line matching a root-cause / gotcha
- * pattern. Returns undefined when nothing matches — never fabricated, no LLM.
- */
-export declare function extractKeyInsight(blocks: string[] | undefined, fallback: string): string | undefined;
-/**
- * Build the entity payload for one episode. Pure — returned object can be
- * snapshotted in tests without hitting the network.
- */
-export declare function buildEpisodePayload(input: EpisodeInput, projectId: string): {
-    workspace_id: string;
-    project_id?: string;
-    type: string;
-    memory_tier: string;
-    scope: string;
-    title: string;
-    content: string;
-    metadata: EpisodeMeta;
-    importance: number;
-    confidence: number;
-    tags: string[];
-    agent_identifier: string;
-};
-/**
- * Write one episode entity. Best-effort: any failure is logged and swallowed
- * so the calling pipeline can complete (plan D8: episode writes never block
- * run completion).
- *
- * Returns the entity id on success, or null on swallowed failure.
- */
-export declare function writeEpisode(client: HarmonyApiClient, input: EpisodeInput): Promise<string | null>;
-/**
- * Find the most recent implement episode for a given card so the review
- * pipeline can back-fill its verdict. Returns null when none exists or the
- * lookup throws — back-fill is best-effort.
- */
-export declare function findLatestImplementEpisode(client: HarmonyApiClient, workspaceId: string, projectId: string, cardShortId: number): Promise<string | null>;
-/**
- * Apply the review verdict to an earlier implement episode (plan §"Read hook"
- * back-fill block). Approved nudges the original episode's confidence up;
- * rejected tombstones it via superseded_by.
- */
-export declare function backfillReviewVerdict(client: HarmonyApiClient, originalEpisodeId: string, verdict: "approved" | "rejected", reviewEpisodeId: string | null): Promise<void>;
-export {};