@loopover/engine 1.0.0

package/dist/governor/write-rate-limit.d.ts

@@ -0,0 +1,52 @@
+import type { GovernorLedgerEvent } from "../governor-ledger.js";
+import { type LocalRateBucket, type LocalRateLimitConfig, type LocalRateLimitDecision } from "./rate-limit.js";
+/** Conservative jitter base when a write is over-limit (not hard-coded at call sites). */
+export declare const DEFAULT_WRITE_RATE_LIMIT_BACKOFF_BASE_MS = 1000;
+export type WriteRateLimitPolicies = {
+    /** Per actionClass global ceiling across all repos. */
+    global: Readonly<Record<string, LocalRateLimitConfig>>;
+    /** Per actionClass per-repo ceiling. */
+    perRepo: Readonly<Record<string, LocalRateLimitConfig>>;
+    /** Jitter backoff base when a write is rate-limited. */
+    backoffBaseMs: number;
+};
+export declare const DEFAULT_WRITE_RATE_LIMIT_POLICIES: Readonly<WriteRateLimitPolicies>;
+export type WriteRateLimitBucketStore = {
+    global: Record<string, LocalRateBucket>;
+    perRepo: Record<string, LocalRateBucket>;
+};
+/** Burst-attempt counter keyed by `${actionClass}:${repo}` for jittered backoff growth. */
+export type WriteRateLimitBackoffStore = Record<string, number>;
+export type WriteRateLimitBlockedBy = "global" | "per_repo";
+export type WriteRateLimitVerdict = {
+    allowed: boolean;
+    blockedBy: WriteRateLimitBlockedBy | null;
+    global: LocalRateLimitDecision;
+    perRepo: LocalRateLimitDecision;
+    /** When blocked: milliseconds until the caller should retry (window wait ∪ jittered backoff). */
+    retryAfterMs: number;
+    backoffAttempt: number;
+    reason: string;
+};
+export declare function writeRateLimitRepoKey(actionClass: string, repoFullName: string): string;
+/**
+ * Consult global and per-repo rolling-window buckets before a governor write. Both must permit the event;
+ * a repo under its own limit can still be blocked by the global ceiling.
+ */
+export declare function evaluateWriteRateLimit(input: {
+    actionClass: string;
+    repoFullName: string;
+    buckets: WriteRateLimitBucketStore;
+    backoffAttempts: WriteRateLimitBackoffStore;
+    policies?: WriteRateLimitPolicies;
+    nowMs: number;
+    randomFn?: () => number;
+}): WriteRateLimitVerdict;
+/** Record a permitted write against both bucket scopes. */
+export declare function recordWriteRateLimitAllowed(buckets: WriteRateLimitBucketStore, actionClass: string, repoFullName: string, nowMs: number, policies?: WriteRateLimitPolicies): WriteRateLimitBucketStore;
+/** Bump the jitter backoff attempt after a throttled write (does not mutate rate buckets). */
+export declare function recordWriteRateLimitDenied(backoffAttempts: WriteRateLimitBackoffStore, actionClass: string, repoFullName: string): WriteRateLimitBackoffStore;
+/** Clear backoff attempts after a successful write. */
+export declare function clearWriteRateLimitBackoff(backoffAttempts: WriteRateLimitBackoffStore, actionClass: string, repoFullName: string): WriteRateLimitBackoffStore;
+/** Governor-ledger row for a write-rate-limit decision (#2344 deliverable). */
+export declare function buildWriteRateLimitGovernorLedgerEvent(repoFullName: string, actionClass: string, verdict: WriteRateLimitVerdict): GovernorLedgerEvent;

package/dist/governor/write-rate-limit.js

@@ -0,0 +1,132 @@
+// Governor write-rate-limit enforcement (#2344): composes the pure `evaluateLocalRateLimit` calculator with
+// global + per-repo buckets and jittered retry scheduling for the local Governor chokepoint. Maintains bucket
+// math only — callers own persistence/scheduling; this module returns updated in-memory state snapshots.
+import { evaluateLocalRateLimit, jitteredBackoffMs, } from "./rate-limit.js";
+/** Conservative jitter base when a write is over-limit (not hard-coded at call sites). */
+export const DEFAULT_WRITE_RATE_LIMIT_BACKOFF_BASE_MS = 1_000;
+const PERMISSIVE_CONFIG = Object.freeze({
+    limit: 1_000_000,
+    windowMs: 60_000,
+});
+export const DEFAULT_WRITE_RATE_LIMIT_POLICIES = Object.freeze({
+    global: Object.freeze({
+        open_pr: Object.freeze({ limit: 30, windowMs: 60_000 }),
+        comment: Object.freeze({ limit: 60, windowMs: 60_000 }),
+    }),
+    perRepo: Object.freeze({
+        open_pr: Object.freeze({ limit: 3, windowMs: 60_000 }),
+        comment: Object.freeze({ limit: 10, windowMs: 60_000 }),
+    }),
+    backoffBaseMs: DEFAULT_WRITE_RATE_LIMIT_BACKOFF_BASE_MS,
+});
+export function writeRateLimitRepoKey(actionClass, repoFullName) {
+    return `${actionClass.trim()}:${repoFullName.trim().toLowerCase()}`;
+}
+function policyFor(policies, actionClass, scope) {
+    const table = scope === "global" ? policies.global : policies.perRepo;
+    return table[actionClass] ?? PERMISSIVE_CONFIG;
+}
+function emptyBucket(nowMs) {
+    return { count: 0, windowStartMs: nowMs };
+}
+function incrementBucket(bucket, config, nowMs) {
+    const windowMs = Number.isFinite(config.windowMs) ? Math.max(0, Math.floor(config.windowMs)) : 0;
+    const windowStartMs = Number.isFinite(bucket.windowStartMs) ? bucket.windowStartMs : nowMs;
+    const windowElapsed = nowMs - windowStartMs >= windowMs;
+    const effectiveCount = windowElapsed ? 0 : Math.max(0, Math.floor(bucket.count));
+    return {
+        count: effectiveCount + 1,
+        windowStartMs: windowElapsed ? nowMs : windowStartMs,
+    };
+}
+/**
+ * Consult global and per-repo rolling-window buckets before a governor write. Both must permit the event;
+ * a repo under its own limit can still be blocked by the global ceiling.
+ */
+export function evaluateWriteRateLimit(input) {
+    const policies = input.policies ?? DEFAULT_WRITE_RATE_LIMIT_POLICIES;
+    const randomFn = input.randomFn ?? (() => 0.5);
+    const nowMs = Number.isFinite(input.nowMs) ? input.nowMs : 0;
+    const repoKey = writeRateLimitRepoKey(input.actionClass, input.repoFullName);
+    const backoffAttempt = input.backoffAttempts[repoKey] ?? 0;
+    const globalBucket = input.buckets.global[input.actionClass] ?? emptyBucket(nowMs);
+    const perRepoBucket = input.buckets.perRepo[repoKey] ?? emptyBucket(nowMs);
+    const globalConfig = policyFor(policies, input.actionClass, "global");
+    const perRepoConfig = policyFor(policies, input.actionClass, "perRepo");
+    const global = evaluateLocalRateLimit(globalBucket, globalConfig, nowMs);
+    const perRepo = evaluateLocalRateLimit(perRepoBucket, perRepoConfig, nowMs);
+    if (global.allowed && perRepo.allowed) {
+        return {
+            allowed: true,
+            blockedBy: null,
+            global,
+            perRepo,
+            retryAfterMs: 0,
+            backoffAttempt,
+            reason: "under_limit",
+        };
+    }
+    const blockedBy = global.allowed ? "per_repo" : "global";
+    const windowWait = Math.max(global.retryAfterMs, perRepo.retryAfterMs);
+    const jitterWait = jitteredBackoffMs(policies.backoffBaseMs, backoffAttempt, randomFn);
+    return {
+        allowed: false,
+        blockedBy,
+        global,
+        perRepo,
+        retryAfterMs: Math.max(windowWait, jitterWait),
+        backoffAttempt,
+        reason: blockedBy === "global" ? "global_rate_limit" : "per_repo_rate_limit",
+    };
+}
+/** Record a permitted write against both bucket scopes. */
+export function recordWriteRateLimitAllowed(buckets, actionClass, repoFullName, nowMs, policies = DEFAULT_WRITE_RATE_LIMIT_POLICIES) {
+    const repoKey = writeRateLimitRepoKey(actionClass, repoFullName);
+    const globalConfig = policyFor(policies, actionClass, "global");
+    const perRepoConfig = policyFor(policies, actionClass, "perRepo");
+    const globalBucket = buckets.global[actionClass] ?? emptyBucket(nowMs);
+    const perRepoBucket = buckets.perRepo[repoKey] ?? emptyBucket(nowMs);
+    return {
+        global: {
+            ...buckets.global,
+            [actionClass]: incrementBucket(globalBucket, globalConfig, nowMs),
+        },
+        perRepo: {
+            ...buckets.perRepo,
+            [repoKey]: incrementBucket(perRepoBucket, perRepoConfig, nowMs),
+        },
+    };
+}
+/** Bump the jitter backoff attempt after a throttled write (does not mutate rate buckets). */
+export function recordWriteRateLimitDenied(backoffAttempts, actionClass, repoFullName) {
+    const key = writeRateLimitRepoKey(actionClass, repoFullName);
+    return { ...backoffAttempts, [key]: (backoffAttempts[key] ?? 0) + 1 };
+}
+/** Clear backoff attempts after a successful write. */
+export function clearWriteRateLimitBackoff(backoffAttempts, actionClass, repoFullName) {
+    const key = writeRateLimitRepoKey(actionClass, repoFullName);
+    if (!(key in backoffAttempts))
+        return backoffAttempts;
+    const next = { ...backoffAttempts };
+    delete next[key];
+    return next;
+}
+/** Governor-ledger row for a write-rate-limit decision (#2344 deliverable). */
+export function buildWriteRateLimitGovernorLedgerEvent(repoFullName, actionClass, verdict) {
+    return {
+        eventType: verdict.allowed ? "allowed" : "throttled",
+        repoFullName,
+        actionClass,
+        decision: verdict.allowed ? "allow" : "throttle",
+        reason: verdict.reason,
+        payload: verdict.allowed
+            ? {}
+            : {
+                blockedBy: verdict.blockedBy,
+                retryAfterMs: verdict.retryAfterMs,
+                backoffAttempt: verdict.backoffAttempt,
+                globalResetAtMs: verdict.global.resetAtMs,
+                perRepoResetAtMs: verdict.perRepo.resetAtMs,
+            },
+    };
+}

package/dist/governor-ledger.d.ts

@@ -0,0 +1,25 @@
+/** Immutable governor decision vocabulary — unknown values fail closed before insert. */
+export declare const GOVERNOR_LEDGER_EVENT_TYPES: readonly ["allowed", "denied", "throttled", "kill_switch"];
+export type GovernorLedgerEventType = (typeof GOVERNOR_LEDGER_EVENT_TYPES)[number];
+export type GovernorLedgerEvent = {
+    eventType: GovernorLedgerEventType;
+    repoFullName?: string | null | undefined;
+    actionClass: string;
+    decision: string;
+    reason: string;
+    payload?: Record<string, unknown> | undefined;
+};
+export type NormalizedGovernorLedgerEvent = {
+    eventType: GovernorLedgerEventType;
+    repoFullName: string | null;
+    actionClass: string;
+    decision: string;
+    reason: string;
+    payloadJson: string;
+};
+/**
+ * Validate and normalize a governor ledger row before append-only insert. Mirrors the structured-event shape of
+ * `logAudit` in `src/selfhost/audit.ts`, but for local SQLite storage. This module does NOT wire into live
+ * governor enforcement — it only defines the storage contract other issues will write into. (#2328)
+ */
+export declare function normalizeGovernorLedgerEvent(input: unknown): NormalizedGovernorLedgerEvent;

package/dist/governor-ledger.js

@@ -0,0 +1,91 @@
+/** Immutable governor decision vocabulary — unknown values fail closed before insert. */
+export const GOVERNOR_LEDGER_EVENT_TYPES = Object.freeze([
+    "allowed",
+    "denied",
+    "throttled",
+    "kill_switch",
+]);
+const governorEventTypeSet = new Set(GOVERNOR_LEDGER_EVENT_TYPES);
+/* v8 ignore start -- Normalization helpers are covered through normalizeGovernorLedgerEvent export tests. */
+function normalizeRequiredString(value, code) {
+    if (typeof value !== "string")
+        throw new Error(code);
+    const trimmed = value.trim();
+    if (!trimmed)
+        throw new Error(code);
+    return trimmed;
+}
+function normalizeOptionalRepoFullName(repoFullName) {
+    if (repoFullName === undefined || repoFullName === null)
+        return null;
+    if (typeof repoFullName !== "string")
+        throw new Error("invalid_repo_full_name");
+    const [owner, repo, extra] = repoFullName.trim().split("/");
+    if (!owner || !repo || extra !== undefined)
+        throw new Error("invalid_repo_full_name");
+    return `${owner}/${repo}`;
+}
+// Structural equality between a JSON.parse() result and the plain object it was stringified from. One side is
+// always JSON-safe (parsed from JSON text); this only needs to compare plain objects/arrays/primitives, not the
+// full generality of node:util's isDeepStrictEqual (no Dates/RegExp/Maps/getters/symbols to worry about) — this
+// package's tsconfig deliberately sets `types: []` (no Node ambient types leak into its public .d.ts surface),
+// so importing "node:util" here isn't viable; a small local check avoids that entirely.
+function jsonRoundTripEqual(a, b) {
+    if (a === b)
+        return true;
+    if (typeof a !== typeof b || a === null || b === null)
+        return false;
+    if (typeof a !== "object")
+        return false;
+    const aIsArray = Array.isArray(a);
+    if (aIsArray !== Array.isArray(b))
+        return false;
+    if (aIsArray) {
+        const bArr = b;
+        const aArr = a;
+        return aArr.length === bArr.length && aArr.every((value, index) => jsonRoundTripEqual(value, bArr[index]));
+    }
+    const aKeys = Object.keys(a);
+    const bRecord = b;
+    return aKeys.length === Object.keys(bRecord).length && aKeys.every((key) => Object.hasOwn(bRecord, key) && jsonRoundTripEqual(a[key], bRecord[key]));
+}
+function serializePayload(payload) {
+    if (payload === undefined)
+        return "{}";
+    if (payload === null || typeof payload !== "object" || Array.isArray(payload)) {
+        throw new Error("invalid_payload");
+    }
+    let json;
+    try {
+        json = JSON.stringify(payload);
+    }
+    catch {
+        throw new Error("invalid_payload");
+    }
+    if (!jsonRoundTripEqual(JSON.parse(json), payload)) {
+        throw new Error("invalid_payload");
+    }
+    return json;
+}
+/* v8 ignore stop */
+/**
+ * Validate and normalize a governor ledger row before append-only insert. Mirrors the structured-event shape of
+ * `logAudit` in `src/selfhost/audit.ts`, but for local SQLite storage. This module does NOT wire into live
+ * governor enforcement — it only defines the storage contract other issues will write into. (#2328)
+ */
+export function normalizeGovernorLedgerEvent(input) {
+    if (!input || typeof input !== "object")
+        throw new Error("invalid_event");
+    const event = input;
+    const eventType = normalizeRequiredString(event.eventType, "invalid_event_type");
+    if (!governorEventTypeSet.has(eventType))
+        throw new Error("invalid_event_type");
+    return {
+        eventType: eventType,
+        repoFullName: normalizeOptionalRepoFullName(event.repoFullName),
+        actionClass: normalizeRequiredString(event.actionClass, "invalid_action_class"),
+        decision: normalizeRequiredString(event.decision, "invalid_decision"),
+        reason: normalizeRequiredString(event.reason, "invalid_reason"),
+        payloadJson: serializePayload(event.payload),
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,99 @@
+export { ENGINE_VERSION } from "./version.js";
+export { pickTopRankedOpportunities, rankOpportunityScore, rankOpportunities, type OpportunityRankInput, } from "./opportunity-ranker.js";
+export { rankOpportunitiesAtOrAboveScore } from "./ranked-opportunity-min-score.js";
+export { pickTopRankedOpportunitiesAtOrAboveScore } from "./ranked-opportunity-top-min-score.js";
+export { bestRankedOpportunity } from "./ranked-opportunity-best-pick.js";
+export { bestRankedOpportunityAtOrAboveScore } from "./ranked-opportunity-best-min-score.js";
+export { extractObjectiveAnchorHistory, extractObjectiveAnchorFeatures, scoreObjectiveAnchor, scoreObjectiveAnchorHistory, renderObjectiveAnchorAuditMarkdown, type ObjectiveAnchorAudit, type ObjectiveAnchorChangeKind, type ObjectiveAnchorDimensionScores, type ObjectiveAnchorFeatures, type ObjectiveAnchorHistoryExtraction, type ObjectiveAnchorHistoryItem, type ObjectiveAnchorHistoryItemAudit, type ObjectiveAnchorHistoryScore, type ObjectiveAnchorInput, type ObjectiveAnchorScore, type ObjectiveAnchorWeights, } from "./objective-anchor.js";
+export { computePairwiseCalibrationScore, resolvePairwiseCalibrationSample, type PairwiseCalibrationAttempt, type PairwiseCalibrationResolvedSample, type PairwiseCalibrationScore, type PairwiseCalibrationVerdict, type PairwiseCalibrationWeights, } from "./pairwise-calibration.js";
+export { computeGateVerdictCompositeCalibrationScore, ingestGateVerdictCalibrationSignals, renderGateVerdictCalibrationAuditMarkdown, resolveGateVerdictCalibrationConfig, type GateVerdictCalibrationConfig, type GateVerdictCalibrationDimension, type GateVerdictCalibrationDimensionInput, type GateVerdictCalibrationDimensionSignal, type GateVerdictCalibrationIngestion, type GateVerdictCalibrationManifest, type GateVerdictCalibrationOutcome, type GateVerdictCalibrationSignal, type GateVerdictCalibrationSignalInput, type GateVerdictCalibrationWeights, type GateVerdictCompositeCalibrationScore, } from "./gate-verdict-calibration.js";
+export { computePhase7CalibrationLoop, computePrOutcomeCalibrationAccuracy, DOCUMENTED_CALIBRATION_BASELINE, evaluateAutonomyIncreaseEligibility, isHistoricalReplayRunFresh, renderPhase7CalibrationAuditMarkdown, resolvePhase7CalibrationConfig, shouldScheduleHistoricalReplayRun, type CalibrationSignalSource, type CalibrationSourceMetric, type HistoricalReplayCalibrationInput, type Phase7CalibrationConfig, type Phase7CalibrationLoopResult, type Phase7CalibrationManifest, type PrOutcomeCalibrationInput, type ReplayHarnessStatus, } from "./phase7-calibration-loop.js";
+export { buildCalibrationDashboardView, resolveCalibrationDashboardStatus, type CalibrationDashboardRow, type CalibrationDashboardStatus, type CalibrationDashboardView, } from "./calibration-dashboard.js";
+export { buildCalibrationTrendView, calibrationSnapshotFromResult, type CalibrationTrendDirection, type CalibrationTrendPoint, type CalibrationTrendSnapshot, type CalibrationTrendView, } from "./calibration-trend.js";
+export { computeFindingSeverityCompositeCalibrationScore, ingestFindingSeverityCalibrationSignals, renderFindingSeverityCalibrationAuditMarkdown, resolveFindingSeverityCalibrationConfig, type FindingSeverityCalibrationConfig, type FindingSeverityCalibrationIngestion, type FindingSeverityCalibrationManifest, type FindingSeverityCalibrationSignal, type FindingSeverityCalibrationSignalInput, type FindingSeverityCalibrationWeights, type FindingSeverityCompositeCalibrationScore, type FindingSeverityTier, type FindingSeverityTierInput, type FindingSeverityTierSignal, } from "./finding-severity-calibration.js";
+export { computeReviewerConsensusCompositeCalibrationScore, ingestReviewerConsensusCalibrationSignals, renderReviewerConsensusCalibrationAuditMarkdown, resolveReviewerConsensusCalibrationConfig, type ReviewerConsensusCalibrationConfig, type ReviewerConsensusCalibrationIngestion, type ReviewerConsensusCalibrationManifest, type ReviewerConsensusCalibrationSignal, type ReviewerConsensusCalibrationSignalInput, type ReviewerConsensusCalibrationWeights, type ReviewerConsensusCompositeCalibrationScore, type ReviewerConsensusDimension, type ReviewerConsensusDimensionInput, type ReviewerConsensusDimensionSignal, type ReviewerConsensusVote, } from "./reviewer-consensus-calibration.js";
+export { computeTrackRecordSummary, renderTrackRecordSummaryMarkdown, resolveTrackRecordSummaryConfig, shouldIncludeTrackRecordSummary, type TrackRecordIncidentKind, type TrackRecordIncidentRecord, type TrackRecordIncidentStatus, type TrackRecordMergeRate, type TrackRecordPullRequestOutcome, type TrackRecordPullRequestState, type TrackRecordSummary, type TrackRecordSummaryAudit, type TrackRecordSummaryConfig, type TrackRecordSummaryManifest, type TrackRecordSummaryOutcomeCounts, type TrackRecordTenure, } from "./track-record-summary.js";
+export * from "./governor/rate-limit.js";
+export * from "./governor/budget-cap.js";
+export * from "./governor/self-plagiarism.js";
+export * from "./governor/reputation-throttle.js";
+export * from "./governor/write-rate-limit.js";
+export * from "./governor/run-halt.js";
+export * from "./governor/kill-switch.js";
+export * from "./governor/action-mode.js";
+export * from "./governor/chokepoint.js";
+export { GOVERNOR_LEDGER_EVENT_TYPES, normalizeGovernorLedgerEvent, type GovernorLedgerEvent, type GovernorLedgerEventType, type NormalizedGovernorLedgerEvent, } from "./governor-ledger.js";
+export { MINER_TELEMETRY_EVENT_TYPES, MINER_TELEMETRY_OUTCOME_BUCKETS, normalizeMinerTelemetryEvent, type MinerTelemetryEvent, type MinerTelemetryEventType, type MinerTelemetryOutcomeBucket, type NormalizedMinerTelemetryEvent, } from "./miner-telemetry.js";
+export { MINER_PREDICTIONS_TOTAL, MINER_PREDICTION_CORRECT_TOTAL, MINER_PREDICTION_INCORRECT_TOTAL, renderMinerPredictionMetrics, type MinerPredictionMetricRow, } from "./miner-prediction-metrics.js";
+export { ATTEMPT_LOG_EVENT_TYPES, createAttemptLogBuffer, formatAttemptLogJsonl, normalizeAttemptLogEvent, type AttemptLogEvent, type AttemptLogEventType, type NormalizedAttemptLogEvent, } from "./miner/attempt-log.js";
+export { ACCEPTANCE_CRITERIA_FILENAME, ACCEPTANCE_CRITERIA_VERSION, buildAcceptanceCriteria, serializeAcceptanceCriteria, shouldWriteAcceptanceCriteria, type AcceptanceCriteria, type AcceptanceCriteriaInput, } from "./miner/acceptance-criteria.js";
+export type { AdvisoryFinding, BountyRecord, IssueQualityReport, IssueRecord, PullRequestRecord, RepositoryRecord, } from "./types/predicted-gate-types.js";
+export { buildSelfReviewChangedPaths, buildSelfReviewPredictedGateInput, buildSelfReviewSlopInput, runSelfReview, SELF_REVIEW_PASSING_CONCLUSION, type AttemptDiffState, type SelfReviewAdapterDeps, type SelfReviewChangedFile, type SelfReviewContext, type SelfReviewSlopAssessment, type SelfReviewSlopBand, type SelfReviewSlopInput, type SelfReviewVerdict, } from "./miner/self-review-adapter.js";
+export { decideNextAction, decideNextActionWithReason, deriveSelfReviewOutcome, type AbandonReason, type HandoffPacket, type IterateLoopAction, type IterateLoopDecision, type IterationState, type SelfReviewOutcome, } from "./miner/iterate-policy.js";
+export { runIterateLoop, type IterateLoopDeps, type IterateLoopInput, type IterateLoopIterationRecord, type IterateLoopOutcome, type IterateLoopResult, } from "./miner/iterate-loop.js";
+export { isSlopBandWithinThreshold, shouldSubmit, SUBMISSION_GATE_PASSING_CONCLUSION, type SubmissionGateCandidate, type SubmissionGateDecision, type SubmissionGateMode, } from "./miner/submission-gate.js";
+export { DEFAULT_MAX_CONSECUTIVE_DISENGAGEMENTS, DEFAULT_MAX_REENTRIES_PER_HOUR, DEFAULT_MAX_REENTRIES_PER_SESSION, shouldReenter, type LoopReentryCandidate, type LoopReentryDecision, type LoopReentryOutcome, } from "./miner/loop-reentry-policy.js";
+export { DEFAULT_MAX_CONSECUTIVE_GATE_BLOCKS, evaluateHarnessSubmissionTrigger, type HarnessSubmissionTriggerCandidate, type HarnessSubmissionTriggerDecision, } from "./miner/harness-submission-trigger.js";
+export { codingAgentModeExecutes, isGlobalMinerCodingAgentPause, resolveCodingAgentExecutionMode, resolveCodingAgentModeFromConfig, type CodingAgentExecutionMode, } from "./miner/coding-agent-mode.js";
+export { createFakeCodingAgentDriver, createNoopCodingAgentDriver, type CodingAgentDriver, type CodingAgentDriverResult, type CodingAgentDriverTask, } from "./miner/coding-agent-driver.js";
+export { createCliSubprocessCodingAgentDriver, defaultClaudeCliArgs, defaultCodexCliArgs, type CliSubprocessDriverOptions, type CliSubprocessSpawnFn, } from "./miner/cli-subprocess-driver.js";
+export { addWorktree, planWorktree, removeWorktree, shouldRetainWorktree, WORKTREE_BRANCH_PREFIX, WORKTREE_SUBDIR, type WorktreeAddResult, type WorktreeExecFn, type WorktreeExecResult, type WorktreePlan, type WorktreeRemoveResult, } from "./miner/worktree-allocator.js";
+export * from "./miner/worktree-pool.js";
+export { invokeCodingAgentDriver, type AttemptLogSink, } from "./miner/coding-agent-invoke.js";
+export { classifyLintGuardPackage, guardChangedFiles, guardCodingAgentDriverResult, type LintGuardCheckResult, type LintGuardedDriverResult, type LintGuardOptions, type LintGuardPackage, type LintGuardResult, type LintGuardSpawnFn, } from "./miner/lint-guard.js";
+export { CODING_AGENT_DRIVER_CONFIG_ENV, CODING_AGENT_DRIVER_NAMES, createCodingAgentDriver, createFakeCodingAgentDriverForFactory, isConfiguredCodingAgentDriver, resolveConfiguredCodingAgentDriverNames, resolveFirstConfiguredCodingAgentDriverName, runCodingAgentAttempt, type CodingAgentDriverName, type CreateCodingAgentDriverOptions, type RunCodingAgentAttemptOptions, } from "./miner/driver-factory.js";
+export * from "./miner/attempt-metering.js";
+export { buildRepoMap, extractRepoMapSymbols, renderRepoMap, resolveRepoMapLanguage, type BuildRepoMapOptions, type ExtractRepoMapSymbolsOptions, type LoadRepoMapLanguageFn, type RepoMapFileEntry, type RepoMapSkipReason, type RepoMapSourceFile, type RepoMapSymbol, type RepoMapSymbolKind, } from "./miner/repo-map.js";
+export { createAgentSdkCodingAgentDriver, type AgentSdkHooks, type AgentSdkQueryFn, type AgentSdkQueryOptions, type CreateAgentSdkDriverOptions, } from "./miner/agent-sdk-driver.js";
+export { LOCAL_WRITE_BOUNDARY, buildApplyLabelsSpec, buildClosePrSpec, buildCreateBranchSpec, buildDeleteBranchSpec, buildFileIssueSpec, buildFollowUpIssueSpec, buildOpenPrSpec, buildPostEligibilityCommentSpec, buildTestGenSpec, type LocalWriteActionSpec, type LocalWriteJsonValue, } from "./miner/local-write-tools.js";
+export { GENERIC_COMMIT_PATTERN, SLOP_RUBRIC_MARKDOWN, SLOP_WEIGHTS, buildDuplicateClusterFinding, buildEmptyDescriptionFinding, buildLowQualityCommitMessageFinding, buildMissingTestEvidenceFinding, buildNoLinkedIssueRationaleFinding, buildNonSubstantivePaddingFinding, buildSlopAssessment, buildTrivialWhitespaceChurnFinding, hasClearNoIssueRationale, type SlopAssessment, type SlopAssessmentInput, type SlopBand, type SlopChangedFile, } from "./signals/slop.js";
+export { buildCollisionReport, type CollisionCluster, type CollisionReport } from "./signals/predicted-gate-engine.js";
+export type { CollisionItem } from "./types/predicted-gate-types.js";
+export * from "./plan-export.js";
+export { countPlanStepsByStatus } from "./plan-step-stats.js";
+export { countPlanSteps } from "./plan-step-count.js";
+export { isPlanEmpty } from "./plan-empty.js";
+export { isPlanFullyCompleted } from "./plan-completion.js";
+export { hasPlanFailedSteps } from "./plan-failure.js";
+export { hasPlanPendingSteps } from "./plan-pending.js";
+export { hasPlanRunningSteps } from "./plan-running.js";
+export { hasPlanSkippedSteps } from "./plan-skipped.js";
+export { hasPlanCompletedSteps } from "./plan-completed.js";
+export { isPlanBlocked } from "./plan-blocked.js";
+export { isPlanProgressComplete } from "./plan-progress-complete.js";
+export { resolvePlanOverallStatus, type PlanOverallStatus, } from "./plan-overall-status.js";
+export { hasPlanReadySteps } from "./plan-ready.js";
+export { isPlanTerminated } from "./plan-terminated.js";
+export * from "./plan-templates.js";
+export * from "./issue-plan-decomposition.js";
+export { PROMPT_PACKET_REDACTED_PATH, PROMPT_PACKET_REDACTED_TERM, PROMPT_PACKET_TEXT_FIELDS, buildPromptPacket, sanitizePromptPacketField, type PromptPacket, type PromptPacketInput, type PromptPacketTextField, } from "./prompt-packet.js";
+export * from "./portfolio/queue.js";
+export * from "./portfolio/non-convergence.js";
+export { applyAiPolicyFatigueToRankInput, createAiPolicyFatigueCacheEntry, describeAiPolicyFatigueCache, renderAiPolicyFatigueMarkdown, resolveAiPolicyFatigueVerdict, resolveAiPolicyVerdict, scanAiPolicyText, type AiFatigueDocLanguageChange, type AiFatiguePullRequestMetadata, type AiPolicyFatigueRankAdjustment, type AiPolicyFatigueRankInput, type AiPolicyFatigueCacheEntry, type AiPolicyFatigueCacheState, type AiPolicyFatigueEvidence, type AiPolicyFatigueEvidenceKind, type AiPolicyFatigueInput, type AiPolicyFatigueLevel, type AiPolicyFatigueVerdict, type AiPolicyPriorityAdjustment, type AiPolicySource, type AiPolicyVerdict, } from "./ai-policy-map.js";
+export { DEFAULT_MINER_GOAL_SPEC, parseMinerGoalSpec, parseMinerGoalSpecContent, discoverMinerGoalSpecPath, MINER_GOAL_SPEC_FILENAMES, type FeasibilityGatePolicy, type MinerExecutionPolicy, type MinerGoalSpec, type MinerIssueDiscoveryPolicy, type MinerKillSwitchPolicy, type ParsedMinerGoalSpec, } from "./miner-goal-spec.js";
+export { DEFAULT_AMS_POLICY_SPEC, parseAmsPolicySpec, parseAmsPolicySpecContent, AMS_POLICY_SPEC_FILENAMES, type AmsCapLimits, type AmsPolicySpec, type AmsSlopThreshold, type AmsSubmissionMode, type ParsedAmsPolicySpec, } from "./ams-policy-spec.js";
+export { DEFAULT_FLEET_RUN_MANIFEST, parseFleetRunManifest, parseFleetRunManifestContent, type FleetRunManifest, type FleetRunManifestRepo, type ParsedFleetRunManifest, } from "./fleet-run-manifest.js";
+export { DISCOVERY_INDEX_CONTRACT_VERSION, DISCOVERY_INDEX_FORBIDDEN_FIELDS, discoveryIndexBoundaryViolations, normalizeDiscoveryIndexCandidate, normalizeDiscoveryIndexRequest, normalizeDiscoveryIndexResponse, type DiscoveryIndexAiPolicySource, type DiscoveryIndexCandidate, type DiscoveryIndexQuery, type DiscoveryIndexRequest, type DiscoveryIndexResponse, type ParsedDiscoveryIndexRequest, type ParsedDiscoveryIndexResponse, } from "./discovery-index-contract.js";
+export { buildSoftClaimRequest, softClaimActionForStatus, type SoftClaimAction, type SoftClaimRecord, type SoftClaimRequest, type SoftClaimRequestContext, type SoftClaimStatus, } from "./discovery-soft-claim.js";
+export { computeMetadataLaneFit, computeMinerGoalLaneFit, isMinerRepoTargetable, } from "./miner-goal-lane-fit.js";
+export { computeOpportunityFreshness, type FreshnessIssue, } from "./opportunity-freshness.js";
+export { computeOpportunityCompetition } from "./opportunity-competition.js";
+export { computeLaneFit, type GoalModelInput } from "./goal-model.js";
+export { classifyContributorFit, type ContributorFit, type ContributorFitCheck, type ContributorFitProfile, } from "./contributor-fit.js";
+export { buildFeasibilityVerdict, feasibilityInputFromPreStartCheck, type FeasibilityClaimStatus, type FeasibilityDuplicateClusterRisk, type FeasibilityGateInput, type FeasibilityGateResult, type FeasibilityIssueStatus, type FeasibilityVerdict, } from "./feasibility.js";
+export { buildMetadataRankInput, computeMetadataDupRisk, computeMetadataFeasibility, computeMetadataPotential, rankMetadataOpportunities, type MetadataCandidateIssue, type MetadataRankContext, } from "./opportunity-metadata.js";
+export { pickTopMetadataOpportunities } from "./metadata-top-pick.js";
+export { rankMetadataOpportunitiesAtOrAboveScore } from "./metadata-min-score.js";
+export { pickTopMetadataOpportunitiesAtOrAboveScore } from "./metadata-top-min-score.js";
+export { bestMetadataOpportunity } from "./metadata-best-pick.js";
+export { bestMetadataOpportunityAtOrAboveScore } from "./metadata-best-min-score.js";
+export * as scoringModel from "./scoring/model.js";
+export * as scoringPreview from "./scoring/preview.js";
+export * as scoringPendingPrScenarios from "./scoring/pending-pr-scenarios.js";
+export { isDuplicateClusterWinner, isDuplicateClusterWinnerByClaim, resolveDuplicateClusterWinnerNumber, type DuplicateClaimMember, } from "./duplicate-winner.js";
+export { MIN_QUERY_CHARS, buildIssueRagQuery, type IssueRagQueryInput, } from "./issue-rag-query.js";
+export { computeLocalScorerTokens, type LocalScorerChangedFile, type LocalScorerValidation, type LocalScorerResult, } from "./local-scorer.js";
+export { buildPredictedGateVerdict, predictedGateNote, publicSafeFinding, applyContributorCalibration, MIN_CALIBRATION_SAMPLES, MAX_READINESS_ADJUSTMENT, type GateCheckConclusion, type GatePolicyPack, type PredictedGateInput, type PredictedGateVerdict, type ContributorCalibrationSignal, } from "./predicted-gate.js";
+export { compileFocusManifestPolicy, contentLaneConfigToJson, experimentalConfigToJson, featuresConfigToJson, formatManifestValidationNotice, gateConfigToJson, isFocusManifestPublicSafe, matchesManifestPath, normalizeReadinessGateMode, parseFocusManifest, parseFocusManifestContent, repoDocGenerationConfigToJson, reviewConfigToJson, reviewRecapConfigToJson, maintainerRecapConfigToJson, settingsOverrideToJson, MAX_FOCUS_MANIFEST_BYTES, CONVERGED_FEATURE_KEYS, EXPERIMENTAL_PLUGIN_KEYS, COMMENT_VERBOSITY_LEVELS, EMPTY_AUTO_REVIEW_CONFIG, EMPTY_MAX_FINDINGS_CONFIG, EMPTY_SELF_HOST_AI_MODEL_CONFIG, EMPTY_VISUAL_CONFIG, LINKED_ISSUE_SATISFACTION_MODES, REVIEW_FIELD_KEYS, REVIEW_FINDING_SEVERITY_LADDER, REVIEW_PROFILES, type AutoReviewConfig, type CommentVerbosity, type ConvergedFeatureKey, type ExperimentalPluginKey, type FocusManifest, type FocusManifestContentLaneConfig, type FocusManifestExperimentalConfig, type FocusManifestFeaturesConfig, type FocusManifestGateConfig, type FocusManifestIssueDiscoveryPolicy, type FocusManifestLanePreference, type FocusManifestLinkedIssuePolicy, type FocusManifestPolicy, type FocusManifestPolicyContributionLane, type FocusManifestPolicyLabelPolicy, type FocusManifestPolicyValidation, type FocusManifestRepoDocGenerationConfig, type FocusManifestRepoDocGenerationScope, type FocusManifestReviewConfig, type FocusManifestReviewRecapConfig, type FocusManifestMaintainerRecapConfig, type FocusManifestSettings, type FocusManifestSource, type LinkedIssueSatisfactionMode, type MaxFindingsConfig, type PreMergeCheck, type ReviewFieldKey, type ReviewFindingSeverity, type ReviewPathInstruction, type ReviewProfile, type SelfHostAiModelConfig, type VisualConfig, type VisualPreviewConfig, type VisualRoutesConfig, type VisualTheme, } from "./focus-manifest.js";
+export { buildRepoRewardRisk, buildContributorRewardRiskStrategy, buildMaintainerNoiseReport, buildPullRequestReviewability, rewardRiskFreshnessInternals, type RewardRiskEngineDeps, type PullRequestReviewabilityInput, type PullRequestReviewIntelligenceView, type RewardRiskAction, type RewardRiskActionKind, type RewardRiskActionSeverity, type RepoRewardRisk, type EligibilityGapEntry, type ContributorRewardRiskStrategy, type MaintainerNoiseReport, type PullRequestReviewability, } from "./reward-risk.js";
+export { SUBPROCESS_CLI_ENV_ALLOWLIST, buildAllowlistedEnv, SECRET_PATTERNS, redactSecrets, } from "./subprocess-env.js";

package/dist/index.js

@@ -0,0 +1,120 @@
+// Barrel export for @loopover/engine.
+//
+// This package houses the deterministic, side-effect-free logic shared by the Gittensory review-stack
+// backend and the gittensory-miner (scoring preview/model, predicted-gate types, reward-risk, slop signals,
+// focus-manifest parse/compile core, duplicate-winner adjudication, and their engine-parity fixtures).
+// More modules land in follow-up issues.
+export { ENGINE_VERSION } from "./version.js";
+export { pickTopRankedOpportunities, rankOpportunityScore, rankOpportunities, } from "./opportunity-ranker.js";
+export { rankOpportunitiesAtOrAboveScore } from "./ranked-opportunity-min-score.js";
+export { pickTopRankedOpportunitiesAtOrAboveScore } from "./ranked-opportunity-top-min-score.js";
+export { bestRankedOpportunity } from "./ranked-opportunity-best-pick.js";
+export { bestRankedOpportunityAtOrAboveScore } from "./ranked-opportunity-best-min-score.js";
+export { extractObjectiveAnchorHistory, extractObjectiveAnchorFeatures, scoreObjectiveAnchor, scoreObjectiveAnchorHistory, renderObjectiveAnchorAuditMarkdown, } from "./objective-anchor.js";
+export { computePairwiseCalibrationScore, resolvePairwiseCalibrationSample, } from "./pairwise-calibration.js";
+export { computeGateVerdictCompositeCalibrationScore, ingestGateVerdictCalibrationSignals, renderGateVerdictCalibrationAuditMarkdown, resolveGateVerdictCalibrationConfig, } from "./gate-verdict-calibration.js";
+export { computePhase7CalibrationLoop, computePrOutcomeCalibrationAccuracy, DOCUMENTED_CALIBRATION_BASELINE, evaluateAutonomyIncreaseEligibility, isHistoricalReplayRunFresh, renderPhase7CalibrationAuditMarkdown, resolvePhase7CalibrationConfig, shouldScheduleHistoricalReplayRun, } from "./phase7-calibration-loop.js";
+export { buildCalibrationDashboardView, resolveCalibrationDashboardStatus, } from "./calibration-dashboard.js";
+export { buildCalibrationTrendView, calibrationSnapshotFromResult, } from "./calibration-trend.js";
+export { computeFindingSeverityCompositeCalibrationScore, ingestFindingSeverityCalibrationSignals, renderFindingSeverityCalibrationAuditMarkdown, resolveFindingSeverityCalibrationConfig, } from "./finding-severity-calibration.js";
+export { computeReviewerConsensusCompositeCalibrationScore, ingestReviewerConsensusCalibrationSignals, renderReviewerConsensusCalibrationAuditMarkdown, resolveReviewerConsensusCalibrationConfig, } from "./reviewer-consensus-calibration.js";
+export { computeTrackRecordSummary, renderTrackRecordSummaryMarkdown, resolveTrackRecordSummaryConfig, shouldIncludeTrackRecordSummary, } from "./track-record-summary.js";
+export * from "./governor/rate-limit.js";
+export * from "./governor/budget-cap.js";
+export * from "./governor/self-plagiarism.js";
+export * from "./governor/reputation-throttle.js";
+export * from "./governor/write-rate-limit.js";
+export * from "./governor/run-halt.js";
+export * from "./governor/kill-switch.js";
+export * from "./governor/action-mode.js";
+export * from "./governor/chokepoint.js";
+export { GOVERNOR_LEDGER_EVENT_TYPES, normalizeGovernorLedgerEvent, } from "./governor-ledger.js";
+export { MINER_TELEMETRY_EVENT_TYPES, MINER_TELEMETRY_OUTCOME_BUCKETS, normalizeMinerTelemetryEvent, } from "./miner-telemetry.js";
+export { MINER_PREDICTIONS_TOTAL, MINER_PREDICTION_CORRECT_TOTAL, MINER_PREDICTION_INCORRECT_TOTAL, renderMinerPredictionMetrics, } from "./miner-prediction-metrics.js";
+export { ATTEMPT_LOG_EVENT_TYPES, createAttemptLogBuffer, formatAttemptLogJsonl, normalizeAttemptLogEvent, } from "./miner/attempt-log.js";
+export { ACCEPTANCE_CRITERIA_FILENAME, ACCEPTANCE_CRITERIA_VERSION, buildAcceptanceCriteria, serializeAcceptanceCriteria, shouldWriteAcceptanceCriteria, } from "./miner/acceptance-criteria.js";
+export { buildSelfReviewChangedPaths, buildSelfReviewPredictedGateInput, buildSelfReviewSlopInput, runSelfReview, SELF_REVIEW_PASSING_CONCLUSION, } from "./miner/self-review-adapter.js";
+export { decideNextAction, decideNextActionWithReason, deriveSelfReviewOutcome, } from "./miner/iterate-policy.js";
+export { runIterateLoop, } from "./miner/iterate-loop.js";
+export { isSlopBandWithinThreshold, shouldSubmit, SUBMISSION_GATE_PASSING_CONCLUSION, } from "./miner/submission-gate.js";
+export { DEFAULT_MAX_CONSECUTIVE_DISENGAGEMENTS, DEFAULT_MAX_REENTRIES_PER_HOUR, DEFAULT_MAX_REENTRIES_PER_SESSION, shouldReenter, } from "./miner/loop-reentry-policy.js";
+export { DEFAULT_MAX_CONSECUTIVE_GATE_BLOCKS, evaluateHarnessSubmissionTrigger, } from "./miner/harness-submission-trigger.js";
+export { codingAgentModeExecutes, isGlobalMinerCodingAgentPause, resolveCodingAgentExecutionMode, resolveCodingAgentModeFromConfig, } from "./miner/coding-agent-mode.js";
+export { createFakeCodingAgentDriver, createNoopCodingAgentDriver, } from "./miner/coding-agent-driver.js";
+export { createCliSubprocessCodingAgentDriver, defaultClaudeCliArgs, defaultCodexCliArgs, } from "./miner/cli-subprocess-driver.js";
+export { addWorktree, planWorktree, removeWorktree, shouldRetainWorktree, WORKTREE_BRANCH_PREFIX, WORKTREE_SUBDIR, } from "./miner/worktree-allocator.js";
+export * from "./miner/worktree-pool.js";
+export { invokeCodingAgentDriver, } from "./miner/coding-agent-invoke.js";
+export { classifyLintGuardPackage, guardChangedFiles, guardCodingAgentDriverResult, } from "./miner/lint-guard.js";
+export { CODING_AGENT_DRIVER_CONFIG_ENV, CODING_AGENT_DRIVER_NAMES, createCodingAgentDriver, createFakeCodingAgentDriverForFactory, isConfiguredCodingAgentDriver, resolveConfiguredCodingAgentDriverNames, resolveFirstConfiguredCodingAgentDriverName, runCodingAgentAttempt, } from "./miner/driver-factory.js";
+export * from "./miner/attempt-metering.js";
+export { buildRepoMap, extractRepoMapSymbols, renderRepoMap, resolveRepoMapLanguage, } from "./miner/repo-map.js";
+export { createAgentSdkCodingAgentDriver, } from "./miner/agent-sdk-driver.js";
+export { LOCAL_WRITE_BOUNDARY, buildApplyLabelsSpec, buildClosePrSpec, buildCreateBranchSpec, buildDeleteBranchSpec, buildFileIssueSpec, buildFollowUpIssueSpec, buildOpenPrSpec, buildPostEligibilityCommentSpec, buildTestGenSpec, } from "./miner/local-write-tools.js";
+export { GENERIC_COMMIT_PATTERN, SLOP_RUBRIC_MARKDOWN, SLOP_WEIGHTS, buildDuplicateClusterFinding, buildEmptyDescriptionFinding, buildLowQualityCommitMessageFinding, buildMissingTestEvidenceFinding, buildNoLinkedIssueRationaleFinding, buildNonSubstantivePaddingFinding, buildSlopAssessment, buildTrivialWhitespaceChurnFinding, hasClearNoIssueRationale, } from "./signals/slop.js";
+// Scoped (not `export *`) because predicted-gate-engine.ts also defines its own hasClearNoIssueRationale --
+// a near-duplicate of slop.js's own export (see that function's doc comment) -- which would collide with the
+// one already re-exported above. Only buildCollisionReport + its result types are needed publicly so far
+// (#5145, the miner's real SelfReviewContext fetcher needs to compute inDuplicateCluster the same way the
+// live gate does), not this file's full internal surface.
+export { buildCollisionReport } from "./signals/predicted-gate-engine.js";
+export * from "./plan-export.js";
+export { countPlanStepsByStatus } from "./plan-step-stats.js";
+export { countPlanSteps } from "./plan-step-count.js";
+export { isPlanEmpty } from "./plan-empty.js";
+export { isPlanFullyCompleted } from "./plan-completion.js";
+export { hasPlanFailedSteps } from "./plan-failure.js";
+export { hasPlanPendingSteps } from "./plan-pending.js";
+export { hasPlanRunningSteps } from "./plan-running.js";
+export { hasPlanSkippedSteps } from "./plan-skipped.js";
+export { hasPlanCompletedSteps } from "./plan-completed.js";
+export { isPlanBlocked } from "./plan-blocked.js";
+export { isPlanProgressComplete } from "./plan-progress-complete.js";
+export { resolvePlanOverallStatus, } from "./plan-overall-status.js";
+export { hasPlanReadySteps } from "./plan-ready.js";
+export { isPlanTerminated } from "./plan-terminated.js";
+export * from "./plan-templates.js";
+export * from "./issue-plan-decomposition.js";
+export { PROMPT_PACKET_REDACTED_PATH, PROMPT_PACKET_REDACTED_TERM, PROMPT_PACKET_TEXT_FIELDS, buildPromptPacket, sanitizePromptPacketField, } from "./prompt-packet.js";
+export * from "./portfolio/queue.js";
+export * from "./portfolio/non-convergence.js";
+export { applyAiPolicyFatigueToRankInput, createAiPolicyFatigueCacheEntry, describeAiPolicyFatigueCache, renderAiPolicyFatigueMarkdown, resolveAiPolicyFatigueVerdict, resolveAiPolicyVerdict, scanAiPolicyText, } from "./ai-policy-map.js";
+export { DEFAULT_MINER_GOAL_SPEC, parseMinerGoalSpec, parseMinerGoalSpecContent, discoverMinerGoalSpecPath, MINER_GOAL_SPEC_FILENAMES, } from "./miner-goal-spec.js";
+export { DEFAULT_AMS_POLICY_SPEC, parseAmsPolicySpec, parseAmsPolicySpecContent, AMS_POLICY_SPEC_FILENAMES, } from "./ams-policy-spec.js";
+export { DEFAULT_FLEET_RUN_MANIFEST, parseFleetRunManifest, parseFleetRunManifestContent, } from "./fleet-run-manifest.js";
+export { DISCOVERY_INDEX_CONTRACT_VERSION, DISCOVERY_INDEX_FORBIDDEN_FIELDS, discoveryIndexBoundaryViolations, normalizeDiscoveryIndexCandidate, normalizeDiscoveryIndexRequest, normalizeDiscoveryIndexResponse, } from "./discovery-index-contract.js";
+export { buildSoftClaimRequest, softClaimActionForStatus, } from "./discovery-soft-claim.js";
+export { computeMetadataLaneFit, computeMinerGoalLaneFit, isMinerRepoTargetable, } from "./miner-goal-lane-fit.js";
+export { computeOpportunityFreshness, } from "./opportunity-freshness.js";
+export { computeOpportunityCompetition } from "./opportunity-competition.js";
+export { computeLaneFit } from "./goal-model.js";
+export { classifyContributorFit, } from "./contributor-fit.js";
+export { buildFeasibilityVerdict, feasibilityInputFromPreStartCheck, } from "./feasibility.js";
+export { buildMetadataRankInput, computeMetadataDupRisk, computeMetadataFeasibility, computeMetadataPotential, rankMetadataOpportunities, } from "./opportunity-metadata.js";
+export { pickTopMetadataOpportunities } from "./metadata-top-pick.js";
+export { rankMetadataOpportunitiesAtOrAboveScore } from "./metadata-min-score.js";
+export { pickTopMetadataOpportunitiesAtOrAboveScore } from "./metadata-top-min-score.js";
+export { bestMetadataOpportunity } from "./metadata-best-pick.js";
+export { bestMetadataOpportunityAtOrAboveScore } from "./metadata-best-min-score.js";
+// Score-preview machinery (#2282): namespaced (rather than flattened) so the three ported files keep their
+// own identity and cannot collide with each other or the ~50 other top-level exports above.
+export * as scoringModel from "./scoring/model.js";
+export * as scoringPreview from "./scoring/preview.js";
+export * as scoringPendingPrScenarios from "./scoring/pending-pr-scenarios.js";
+export { isDuplicateClusterWinner, isDuplicateClusterWinnerByClaim, resolveDuplicateClusterWinnerNumber, } from "./duplicate-winner.js";
+// Issue-centric RAG query composition (#2320, extracted in #4254): the pure query builder + the shared
+// minimum-query floor; the Vectorize/D1 retrieval backend intentionally stays in the backend.
+export { MIN_QUERY_CHARS, buildIssueRagQuery, } from "./issue-rag-query.js";
+// #782 deterministic local scorer (extracted in #4253): pure token-scoring from changed-file metadata,
+// shared by the published CLIs and the hosted Worker. The Node-coupled local-branch.ts stays in the backend.
+export { computeLocalScorerTokens, } from "./local-scorer.js";
+export { buildPredictedGateVerdict, predictedGateNote, publicSafeFinding, applyContributorCalibration, MIN_CALIBRATION_SAMPLES, MAX_READINESS_ADJUSTMENT, } from "./predicted-gate.js";
+// Focus-manifest parse/compile core (#2280): shared by the maintainer review stack and the miner's
+// `.gittensory-miner.yml` goal-spec parser (see miner-goal-spec.ts for the parallel surface).
+export { compileFocusManifestPolicy, contentLaneConfigToJson, experimentalConfigToJson, featuresConfigToJson, formatManifestValidationNotice, gateConfigToJson, isFocusManifestPublicSafe, matchesManifestPath, normalizeReadinessGateMode, parseFocusManifest, parseFocusManifestContent, repoDocGenerationConfigToJson, reviewConfigToJson, reviewRecapConfigToJson, maintainerRecapConfigToJson, settingsOverrideToJson, MAX_FOCUS_MANIFEST_BYTES, CONVERGED_FEATURE_KEYS, EXPERIMENTAL_PLUGIN_KEYS, COMMENT_VERBOSITY_LEVELS, EMPTY_AUTO_REVIEW_CONFIG, EMPTY_MAX_FINDINGS_CONFIG, EMPTY_SELF_HOST_AI_MODEL_CONFIG, EMPTY_VISUAL_CONFIG, LINKED_ISSUE_SATISFACTION_MODES, REVIEW_FIELD_KEYS, REVIEW_FINDING_SEVERITY_LADDER, REVIEW_PROFILES, } from "./focus-manifest.js";
+// Reward/risk reasoning signals (#2281). The four builders depend on the still-in-`src` maintainer signal
+// stack, so they take an injected `RewardRiskEngineDeps` (the `src/signals/reward-risk.ts` shim binds it).
+export { buildRepoRewardRisk, buildContributorRewardRiskStrategy, buildMaintainerNoiseReport, buildPullRequestReviewability, rewardRiskFreshnessInternals, } from "./reward-risk.js";
+// Shared subprocess env-allowlist + secret-redaction helpers (#4284) — one source of truth for every driver that
+// spawns a locally-authenticated CLI subprocess (src/selfhost/ai.ts and the coming gittensory-miner drivers).
+export { SUBPROCESS_CLI_ENV_ALLOWLIST, buildAllowlistedEnv, SECRET_PATTERNS, redactSecrets, } from "./subprocess-env.js";

package/dist/issue-plan-decomposition.d.ts

@@ -0,0 +1,18 @@
+import type { RawPlanStep } from "./plan-templates.js";
+/** Issue-level metadata this heuristic decomposes into an execution plan. Every field is optional so a bare issue
+ *  (title-only, or nothing at all) still yields a valid baseline DAG. A PromptPacket caller (#2321) can map its
+ *  `taskBrief` onto `title` and `retrievalContext`/`constraints` onto `body`. */
+export type IssuePlanInput = {
+    title?: string | undefined;
+    body?: string | undefined;
+    labels?: readonly string[] | undefined;
+};
+/**
+ * Decompose a target issue into a deterministic execution-plan DAG of {@link RawPlanStep}s. Same input always
+ * yields identical output (no clock, no randomness) — matching every other pure composer in this package. The spine
+ * is always `locate → implement → test → verify`; a bug signal inserts a `reproduce` step before `implement` (and
+ * asks `test` for a regression test), and a docs signal inserts a `docs` step that `verify` then also waits on.
+ * Every `dependsOn` references an EARLIER step, so the result is acyclic with a ready topological order and passes
+ * rawPlanStepSchema + plan-store.js's `validatePlanDag` unchanged (unique ids, in-plan deps, no cycles).
+ */
+export declare function decomposeIssueToPlan(issue?: IssuePlanInput): RawPlanStep[];

package/dist/issue-plan-decomposition.js

@@ -0,0 +1,56 @@
+// Issue-to-plan decomposition heuristic (pure) (#4292).
+//
+// The stateless plan-DAG surface (rawPlanStepSchema / gittensory_build_plan, src/mcp/server.ts; plan-store.js
+// persistence) consumes a caller-supplied RawPlanStep[], but nothing in the repo turns a TARGET ISSUE into those
+// steps — every caller has to hand it one already-built. plan-templates.ts's PLAN_TEMPLATE_BUILDERS describe the
+// miner's OWN fixed lifecycle, not the issue's actual implementation work; planPlanTemplate even carries a
+// `plan-dag-build` placeholder step with no logic behind it. This module is that missing piece: a deterministic,
+// side-effect-free function that folds issue-level metadata (title / body / labels only — never source content)
+// into a RawPlanStep[] execution DAG in the SAME raw-step shape plan-templates.ts emits, so build_plan and
+// plan-store.js's validatePlanDag validate it identically.
+// Title ceiling of rawPlanStepSchema.title (max 300) and a subject cap kept well under it, mirroring
+// plan-templates.ts, so a long issue title can never produce an out-of-range step title.
+const MAX_TITLE_CHARS = 300;
+const MAX_SUBJECT_CHARS = 200;
+// Collapse any run of whitespace to a single space and trim/bound, so a subject yields a clean deterministic
+// one-line title (mirrors plan-templates.ts's normalizeSubject).
+function normalizeSubject(subject) {
+    return (subject ?? "").replace(/\s+/g, " ").trim().slice(0, MAX_SUBJECT_CHARS);
+}
+// Compose a step title from a fixed prefix and the optional subject, hard-capped to the schema's title ceiling.
+function titleFor(prefix, subject) {
+    const full = subject ? `${prefix}: ${subject}` : prefix;
+    return full.slice(0, MAX_TITLE_CHARS);
+}
+// Low-cardinality issue-kind signals derived deterministically from the combined title+body+labels text. Labels
+// are folded into the SAME lowercased haystack as the free text, so an issue tagged `bug` and one whose title
+// merely says "fix the crash" take the same path without a separate label-only branch.
+const BUG_SIGNAL = /\b(bug|bugs|fix|fixes|regression|broken|crash|crashes|incorrect)\b/;
+const DOCS_SIGNAL = /\b(doc|docs|documentation|readme|guide)\b/;
+/**
+ * Decompose a target issue into a deterministic execution-plan DAG of {@link RawPlanStep}s. Same input always
+ * yields identical output (no clock, no randomness) — matching every other pure composer in this package. The spine
+ * is always `locate → implement → test → verify`; a bug signal inserts a `reproduce` step before `implement` (and
+ * asks `test` for a regression test), and a docs signal inserts a `docs` step that `verify` then also waits on.
+ * Every `dependsOn` references an EARLIER step, so the result is acyclic with a ready topological order and passes
+ * rawPlanStepSchema + plan-store.js's `validatePlanDag` unchanged (unique ids, in-plan deps, no cycles).
+ */
+export function decomposeIssueToPlan(issue = {}) {
+    const subject = normalizeSubject(issue.title);
+    const haystack = `${issue.title ?? ""} ${issue.body ?? ""} ${(issue.labels ?? []).join(" ")}`.toLowerCase();
+    const isBugFix = BUG_SIGNAL.test(haystack);
+    const wantsDocs = DOCS_SIGNAL.test(haystack);
+    const steps = [
+        { id: "locate", title: titleFor("Locate the code to change", subject), actionClass: "analyze", dependsOn: [], maxAttempts: 2 },
+    ];
+    if (isBugFix) {
+        steps.push({ id: "reproduce", title: titleFor("Reproduce the reported behavior", subject), actionClass: "analyze", dependsOn: ["locate"], maxAttempts: 1 });
+    }
+    steps.push({ id: "implement", title: titleFor("Implement the change", subject), actionClass: "codegen", dependsOn: [isBugFix ? "reproduce" : "locate"], maxAttempts: 1 });
+    steps.push({ id: "test", title: titleFor(isBugFix ? "Add a regression test and run the suite" : "Add tests and run the suite", subject), actionClass: "test", dependsOn: ["implement"], maxAttempts: 2 });
+    if (wantsDocs) {
+        steps.push({ id: "docs", title: titleFor("Update documentation", subject), actionClass: "compose", dependsOn: ["implement"], maxAttempts: 1 });
+    }
+    steps.push({ id: "verify", title: titleFor("Verify the full gate is green", subject), actionClass: "analyze", dependsOn: wantsDocs ? ["test", "docs"] : ["test"], maxAttempts: 2 });
+    return steps;
+}