@delegance/claude-autopilot 5.5.2 → 7.2.0

package/dist/src/core/run-state/types.d.ts

@@ -0,0 +1,284 @@
+/** Schema version for everything written by this engine. Bump on breaking
+ *  changes to RunState / RunEvent / PhaseSnapshot shape.
+ *
+ *  v7.0 — bumped from 1 to 2 to signal the v7 cycle on every newly-written
+ *  state.json. v6.x runs (schema_version=1) remain readable by v7 binaries
+ *  because `RUN_STATE_MIN_SUPPORTED_SCHEMA_VERSION` stays at 1. v6 binaries
+ *  cannot read v7-written runs; the corrupted_state error includes a
+ *  "downgrade resume is not supported" hint so operators know why. */
+export declare const RUN_STATE_SCHEMA_VERSION: 2;
+export type SchemaVersion = typeof RUN_STATE_SCHEMA_VERSION;
+/** Identifies a single OS-level writer. PID + a hash of the hostname (we
+ *  don't persist the raw hostname to the lock metadata so co-tenant signal
+ *  doesn't leak between users sharing a directory). */
+export interface WriterId {
+    pid: number;
+    hostHash: string;
+}
+/** Top-level run status, mirroring the lifecycle diagram in the spec. */
+export type RunStatus = 'pending' | 'running' | 'paused' | 'success' | 'failed' | 'aborted';
+/** Per-phase status within a run. */
+export type PhaseStatus = 'pending' | 'running' | 'succeeded' | 'failed' | 'skipped' | 'aborted';
+/** External operation reference — the persisted breadcrumb that makes replay
+ *  decisions deterministic. Used heavily in Phase 6 (idempotency contracts);
+ *  typed now so events can carry it without later schema churn.
+ *
+ *  v6.2.1 — `migration-batch` joins the union as the side-effect contract's
+ *  PRE-effect breadcrumb for the `migrate` phase. Semantics: a deterministic
+ *  id covers a planned migration batch and is emitted BEFORE the dispatcher
+ *  is invoked, so a partial crash leaves a resume target visible to the
+ *  orchestrator's preflight readback. The post-effect `migration-version`
+ *  refs (one per actually-applied migration) remain authoritative for
+ *  reconciliation; `migration-batch` exists purely so resume can tell
+ *  "we started this batch but didn't finish" apart from "we never started." */
+export type ExternalRefKind = 'github-pr' | 'github-comment' | 'git-remote-push' | 'deploy' | 'migration-batch' | 'migration-version' | 'rollback-target' | 'spec-file' | 'plan-file' | 'sarif-artifact' | 'review-comments';
+export interface ExternalRef {
+    kind: ExternalRefKind;
+    /** Provider-specific identifier (PR number, commit SHA, deploy ID, …). */
+    id: string;
+    provider?: string;
+    /** Human-readable artifact link if the provider exposes one. */
+    url?: string;
+    /** ISO timestamp of the platform's confirmation. */
+    observedAt: string;
+}
+/** Per-phase artifact pointer recorded inside the snapshot. */
+export interface PhaseArtifactRef {
+    /** Logical name (e.g. "spec", "plan", "impl-diff"). */
+    name: string;
+    /** Path inside `artifacts/` (relative to run dir). */
+    path: string;
+    sha256?: string;
+    size?: number;
+    copiedAt?: string;
+}
+/** Snapshot of a single phase, persisted under `phases/<name>.json` and
+ *  reflected inside state.json's `phases[]`. */
+export interface PhaseSnapshot {
+    schema_version: SchemaVersion;
+    name: string;
+    /** Order within the run (0-indexed). */
+    index: number;
+    status: PhaseStatus;
+    /** True iff `RunPhase.idempotent` was declared true at registration. */
+    idempotent: boolean;
+    /** True iff `RunPhase.hasSideEffects` was declared true at registration. */
+    hasSideEffects: boolean;
+    startedAt?: string;
+    endedAt?: string;
+    durationMs?: number;
+    /** Sum of `phase.cost` events for this phase. */
+    costUSD: number;
+    attempts: number;
+    /** Last failure message (string) if status === 'failed'. */
+    lastError?: string;
+    artifacts: PhaseArtifactRef[];
+    externalRefs: ExternalRef[];
+    /** Phase-specific metadata. Free-form; engine doesn't introspect. */
+    meta?: Record<string, unknown>;
+    /** Phase 6 — last successful output, persisted so a future
+     *  `skip-already-applied` decision can return it without re-execution.
+     *  The engine writes this on every `phase.success`; absent on failed
+     *  / pre-Phase-6 snapshots. JSON-serializable values only. */
+    result?: unknown;
+}
+/** The state.json checkpoint. Authoritative answer is always
+ *  events.ndjson; this is a derived snapshot for O(1) status queries. */
+export interface RunState {
+    schema_version: SchemaVersion;
+    runId: string;
+    /** ULID generation time, ISO. */
+    startedAt: string;
+    endedAt?: string;
+    status: RunStatus;
+    /** Phase order is fixed at run creation. */
+    phases: PhaseSnapshot[];
+    /** Index into `phases[]` of the currently-running or last-attempted phase. */
+    currentPhaseIdx: number;
+    /** Sum of phase.cost events across the whole run. */
+    totalCostUSD: number;
+    /** Last seq written to events.ndjson at the time of the snapshot. */
+    lastEventSeq: number;
+    /** The writer that wrote this snapshot. */
+    writerId: WriterId;
+    /** Working directory the run was started in (absolute path). */
+    cwd: string;
+    /** Snapshot of the run config at creation (subset of guardrail.config.yaml).
+     *  Free-form; engine doesn't introspect here, later phases do. */
+    config?: Record<string, unknown>;
+}
+/** Universal envelope on every event line. */
+export interface RunEventBase {
+    schema_version: SchemaVersion;
+    /** ISO timestamp. */
+    ts: string;
+    runId: string;
+    /** Monotonic per-run sequence. Receivers MUST detect gaps. */
+    seq: number;
+    /** The writer that appended this event. */
+    writerId: WriterId;
+}
+export interface RunStartEvent extends RunEventBase {
+    event: 'run.start';
+    phases: string[];
+    config?: Record<string, unknown>;
+}
+export interface RunCompleteEvent extends RunEventBase {
+    event: 'run.complete';
+    status: 'success' | 'failed' | 'aborted';
+    totalCostUSD: number;
+    durationMs: number;
+}
+export interface RunWarningEvent extends RunEventBase {
+    event: 'run.warning';
+    message: string;
+    details?: Record<string, unknown>;
+}
+export interface RunRecoveryEvent extends RunEventBase {
+    event: 'run.recovery';
+    reason: 'recovered-from-partial-write' | 'recovered-from-corrupt-snapshot' | 'recovered-from-missing-snapshot';
+    details?: Record<string, unknown>;
+}
+export interface PhaseStartEvent extends RunEventBase {
+    event: 'phase.start';
+    phase: string;
+    phaseIdx: number;
+    idempotent: boolean;
+    hasSideEffects: boolean;
+    /** Attempt counter, 1-based. >1 implies a resume / retry. */
+    attempt: number;
+}
+export interface PhaseSuccessEvent extends RunEventBase {
+    event: 'phase.success';
+    phase: string;
+    phaseIdx: number;
+    durationMs: number;
+    artifacts: PhaseArtifactRef[];
+}
+export interface PhaseFailedEvent extends RunEventBase {
+    event: 'phase.failed';
+    phase: string;
+    phaseIdx: number;
+    durationMs: number;
+    /** Stringified error message. Stack traces stay out of the durable log. */
+    error: string;
+    /** Optional structured error code (matches GuardrailError.code if thrown). */
+    errorCode?: string;
+}
+export interface PhaseAbortedEvent extends RunEventBase {
+    event: 'phase.aborted';
+    phase: string;
+    phaseIdx: number;
+    reason: 'user-interrupt' | 'budget-exceeded' | 'lock-takeover' | 'crash';
+}
+export interface PhaseCostEvent extends RunEventBase {
+    event: 'phase.cost';
+    phase: string;
+    phaseIdx: number;
+    provider: string;
+    inputTokens: number;
+    outputTokens: number;
+    costUSD: number;
+}
+export interface PhaseExternalRefEvent extends RunEventBase {
+    event: 'phase.externalRef';
+    phase: string;
+    phaseIdx: number;
+    ref: ExternalRef;
+}
+export interface PhaseNeedsHumanEvent extends RunEventBase {
+    event: 'phase.needs-human';
+    phase: string;
+    phaseIdx: number;
+    reason: string;
+    /** Hint surfaced to the user / CI consumer. */
+    nextActions?: string[];
+}
+export interface LockTakeoverEvent extends RunEventBase {
+    event: 'lock.takeover';
+    /** Identity of the writer who previously held the lock (best-effort —
+     *  may be null if metadata was missing). */
+    previousWriter: WriterId | null;
+    reason: string;
+}
+export interface IndexRebuiltEvent extends RunEventBase {
+    event: 'index.rebuilt';
+    /** Why the rebuild was needed: "missing", "corrupt", or "force". */
+    cause: 'missing' | 'corrupt' | 'force';
+}
+/** Phase 4 — budget enforcement preflight. Emitted by `runPhase` BEFORE
+ *  `phase.start` for every phase whose parent run carries a `BudgetConfig`.
+ *  Carries the full `BudgetCheck` payload from `checkPhaseBudget` so
+ *  consumers (cost dashboards, CI) can attribute spend and decisions
+ *  without re-running the policy. Per the v6 spec "Budget enforcement"
+ *  section + Codex CRITICAL #3 (two-layer guard, layer 2 always runs). */
+export interface BudgetCheckEvent extends RunEventBase {
+    event: 'budget.check';
+    phase: string;
+    phaseIdx: number;
+    decision: 'proceed' | 'pause' | 'hard-fail';
+    /** `estimate.high` from `RunPhase.estimateCost` if it returned a value;
+     *  null when the phase doesn't implement estimateCost. Layer 2 (the
+     *  mandatory floor) ALWAYS runs regardless. */
+    estimatedHigh: number | null;
+    /** Sum of every prior `phase.cost` event in this run, in USD. */
+    actualSoFar: number;
+    /** The reserve the runner deducted against `perRunUSD` for this phase
+     *  (Layer 2 floor, expressed in USD). */
+    reserveApplied: number;
+    /** USD remaining under `perRunUSD` after `actualSoFar` + the larger of
+     *  `estimatedHigh` and `reserveApplied`. May be negative on hard-fail. */
+    capRemaining: number;
+    reason: string;
+    /** v6.2.0 — which scope produced the decision. `'phase'` (legacy
+     *  default) is the single-phase wrapper path; `'run'` is the
+     *  orchestrator's cross-phase mode. Optional only for back-compat
+     *  with older events.ndjson files; events emitted on v6.2.0+ always
+     *  carry a value. */
+    scope?: 'phase' | 'run';
+}
+/** Phase 6 — emitted when a `forceReplay` override flips a needs-human (or
+ *  any other refusal) into a retry. Carries the phase and the refs that
+ *  WERE consulted so the durable log shows exactly what was overridden.
+ *  Spec: "a `--force-replay` override writes an explicit `replay.override`
+ *  event with user-supplied reason." */
+export interface ReplayOverrideEvent extends RunEventBase {
+    event: 'replay.override';
+    phase: string;
+    phaseIdx: number;
+    /** Free-form user / CI reason for the override. */
+    reason: string;
+    /** Refs the underlying refusal cited (echoed for triage). */
+    refsConsulted: ExternalRef[];
+}
+/** Discriminated union of every event variant. Add new variants here and
+ *  the code that switches over `event` will type-error at compile time. */
+export type RunEvent = RunStartEvent | RunCompleteEvent | RunWarningEvent | RunRecoveryEvent | PhaseStartEvent | PhaseSuccessEvent | PhaseFailedEvent | PhaseAbortedEvent | PhaseCostEvent | PhaseExternalRefEvent | PhaseNeedsHumanEvent | LockTakeoverEvent | IndexRebuiltEvent | BudgetCheckEvent | ReplayOverrideEvent;
+/** Distributive Omit so the discriminated-union shape is preserved when we
+ *  strip the fields the appender fills in. Plain `Omit<RunEvent, ...>`
+ *  collapses the union into a single intersection and loses variant-specific
+ *  fields — so a literal `{ event: 'phase.cost', costUSD: 1, ... }` would
+ *  fail typecheck. */
+type DistributiveOmit<T, K extends keyof T> = T extends unknown ? Omit<T, K> : never;
+/** When appending we don't know `seq`, `ts`, `runId`, `schema_version`,
+ *  or `writerId` yet — the appender supplies them. */
+export type RunEventInput = DistributiveOmit<RunEvent, 'seq' | 'ts' | 'runId' | 'schema_version' | 'writerId'>;
+export interface RunIndexEntry {
+    runId: string;
+    status: RunStatus;
+    startedAt: string;
+    endedAt?: string;
+    totalCostUSD: number;
+    /** Last completed phase name (for `runs list` summary). */
+    lastPhase?: string;
+    /** True if state.json was synthesized via replay because it was missing
+     *  or corrupt at last open. Surfaces as a warning in the UI. */
+    recovered?: boolean;
+}
+export interface RunIndex {
+    schema_version: SchemaVersion;
+    /** Newest first. */
+    runs: RunIndexEntry[];
+}
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/src/core/run-state/types.js

@@ -0,0 +1,19 @@
+// src/core/run-state/types.ts
+//
+// v6 Run State Engine — pure data layer types. Phase 1 (persistence) only.
+// Behavior — phase wrapping, CLI verbs, budget enforcement, etc. — lands in
+// later phases. The shapes here are versioned via `schema_version: 1` so a
+// future migration can detect and migrate older runs.
+//
+// Spec: docs/specs/v6-run-state-engine.md ("State on disk", "Run lifecycle",
+// "Idempotency rules + external operation ledger", "Persistence protocol").
+/** Schema version for everything written by this engine. Bump on breaking
+ *  changes to RunState / RunEvent / PhaseSnapshot shape.
+ *
+ *  v7.0 — bumped from 1 to 2 to signal the v7 cycle on every newly-written
+ *  state.json. v6.x runs (schema_version=1) remain readable by v7 binaries
+ *  because `RUN_STATE_MIN_SUPPORTED_SCHEMA_VERSION` stays at 1. v6 binaries
+ *  cannot read v7-written runs; the corrupted_state error includes a
+ *  "downgrade resume is not supported" hint so operators know why. */
+export const RUN_STATE_SCHEMA_VERSION = 2;
+//# sourceMappingURL=types.js.map

package/dist/src/core/run-state/ulid.d.ts

@@ -0,0 +1,11 @@
+/** Validate that a string matches the ULID shape (length + alphabet). */
+export declare function isValidULID(s: string): boolean;
+/** Generate a new ULID. Optionally pass a fixed `now` (ms epoch) for tests. */
+export declare function ulid(now?: number): string;
+/** Decode the timestamp-portion of a ULID back to ms epoch. Throws on
+ *  malformed input. Useful for `runs list` ordering and for tests. */
+export declare function decodeTime(id: string): number;
+/** Exposed for tests that want to verify alphabet membership. */
+export declare const ULID_ALPHABET = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+export declare const ULID_LENGTH: number;
+//# sourceMappingURL=ulid.d.ts.map

package/dist/src/core/run-state/ulid.js

@@ -0,0 +1,95 @@
+// src/core/run-state/ulid.ts
+//
+// Tiny pure-TS ULID generator. We deliberately avoid pulling in the `ulid`
+// npm package — the algorithm is short and the runtime dep budget for the
+// engine is tight. Conforms to https://github.com/ulid/spec :
+//
+//   - 26 characters, Crockford's Base32 (no I, L, O, U).
+//   - First 10 chars  = 48-bit Unix-millisecond timestamp (ms since epoch).
+//   - Last 16 chars   = 80 bits of randomness (crypto.randomBytes).
+//   - Lexicographic sort == chronological sort (within ms; tie-break is
+//     random within the same ms — Phase 1 does not implement the optional
+//     monotonic-overflow within-ms behavior, since runIDs are issued by a
+//     single writer and one-per-millisecond is unreachable in practice).
+//   - URL-safe (Crockford Base32 only emits [0-9A-Z]).
+import { randomBytes } from 'node:crypto';
+const ENCODING = '0123456789ABCDEFGHJKMNPQRSTVWXYZ'; // Crockford Base32 alphabet (32 chars).
+const ENCODING_LEN = ENCODING.length; // 32.
+const TIME_LEN = 10;
+const RANDOM_LEN = 16;
+const ULID_LEN = TIME_LEN + RANDOM_LEN; // 26.
+/** Max representable timestamp = 2^48 - 1 ms. Sanity-check, not a bug
+ *  most callers will hit (it's the year 10889). */
+const TIME_MAX = 281474976710655;
+/** Validate that a string matches the ULID shape (length + alphabet). */
+export function isValidULID(s) {
+    if (typeof s !== 'string')
+        return false;
+    if (s.length !== ULID_LEN)
+        return false;
+    for (let i = 0; i < ULID_LEN; i++) {
+        if (ENCODING.indexOf(s[i]) < 0)
+            return false;
+    }
+    return true;
+}
+function encodeTime(now) {
+    if (!Number.isFinite(now) || now < 0 || now > TIME_MAX) {
+        throw new RangeError(`ulid: timestamp out of range (got ${now})`);
+    }
+    let out = '';
+    let t = now;
+    for (let i = TIME_LEN - 1; i >= 0; i--) {
+        const mod = t % ENCODING_LEN;
+        out = ENCODING[mod] + out;
+        t = (t - mod) / ENCODING_LEN;
+    }
+    return out;
+}
+function encodeRandom() {
+    // 16 chars * 5 bits each = 80 bits. We draw 10 bytes (80 bits) of
+    // crypto-grade randomness and encode 5 bits at a time. Any extra fractional
+    // bits are discarded — this is the standard ULID approach.
+    const bytes = randomBytes(10);
+    // Pack the 10 bytes into a 80-bit unsigned integer view, 5-bit chunks.
+    // We do it manually rather than using BigInt for portability — the array
+    // is short enough that the explicit math is just as fast and avoids any
+    // dependency on BigInt-typed regression in older runtimes.
+    const bits = new Array(80);
+    for (let i = 0; i < 10; i++) {
+        const b = bytes[i];
+        for (let j = 0; j < 8; j++) {
+            bits[i * 8 + j] = (b >> (7 - j)) & 1;
+        }
+    }
+    let out = '';
+    for (let i = 0; i < RANDOM_LEN; i++) {
+        let v = 0;
+        for (let j = 0; j < 5; j++) {
+            v = (v << 1) | bits[i * 5 + j];
+        }
+        out += ENCODING[v];
+    }
+    return out;
+}
+/** Generate a new ULID. Optionally pass a fixed `now` (ms epoch) for tests. */
+export function ulid(now = Date.now()) {
+    return encodeTime(now) + encodeRandom();
+}
+/** Decode the timestamp-portion of a ULID back to ms epoch. Throws on
+ *  malformed input. Useful for `runs list` ordering and for tests. */
+export function decodeTime(id) {
+    if (!isValidULID(id)) {
+        throw new Error(`ulid: not a valid ULID: ${String(id)}`);
+    }
+    let t = 0;
+    for (let i = 0; i < TIME_LEN; i++) {
+        const idx = ENCODING.indexOf(id[i]);
+        t = t * ENCODING_LEN + idx;
+    }
+    return t;
+}
+/** Exposed for tests that want to verify alphabet membership. */
+export const ULID_ALPHABET = ENCODING;
+export const ULID_LENGTH = ULID_LEN;
+//# sourceMappingURL=ulid.js.map

package/dist/src/core/schema-alignment/extractor/index.d.ts

@@ -1,3 +1,3 @@
 import type { SchemaEntity } from '../types.ts';
-export declare function extract(filePath: string): SchemaEntity[];
+export declare function extract(filePath: string, previousContent?: string | null): SchemaEntity[];
 //# sourceMappingURL=index.d.ts.map

package/dist/src/core/schema-alignment/extractor/index.js

@@ -3,7 +3,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { extractFromSql } from "./sql.js";
 import { extractFromPrisma } from "./prisma.js";
-export function extract(filePath) {
+export function extract(filePath, previousContent) {
     let content;
     try {
         content = fs.readFileSync(filePath, 'utf8');
@@ -16,7 +16,7 @@ export function extract(filePath) {
     if (ext === '.sql')
         return extractFromSql(content);
     if (base === 'schema.prisma' || ext === '.prisma')
-        return extractFromPrisma(content);
+        return extractFromPrisma(content, previousContent);
     process.stderr.write(`[schema-alignment] no extractor for ${ext} files — skipping ${path.basename(filePath)}\n`);
     return [];
 }

package/dist/src/core/schema-alignment/extractor/prisma.d.ts

@@ -1,3 +1,15 @@
 import type { SchemaEntity } from '../types.ts';
-export declare function extractFromPrisma(content: string): SchemaEntity[];
+/**
+ * Extract schema entities from a Prisma schema file.
+ *
+ * When `previousContent` is provided, only the diff (added/removed fields,
+ * new/dropped tables) is emitted — this avoids over-reporting when a user
+ * touches schema.prisma for any reason (adding one field, editing a comment)
+ * and every long-existing field gets re-checked against type/API/UI layers.
+ *
+ * When `previousContent` is null/undefined, every model and field is emitted
+ * — the original "all entities are new" behavior used as a fallback when git
+ * history isn't available.
+ */
+export declare function extractFromPrisma(content: string, previousContent?: string | null): SchemaEntity[];
 //# sourceMappingURL=prisma.d.ts.map

package/dist/src/core/schema-alignment/extractor/prisma.js

@@ -1,18 +1,73 @@
-export function extractFromPrisma(content) {
-    const entities = [];
-    // Match model blocks: model Name { ... }
-    const modelRe = /^model\s+(\w+)\s*\{([^}]+)\}/gm;
-    for (const modelMatch of content.matchAll(modelRe)) {
+const MODEL_RE = /^model\s+(\w+)\s*\{([^}]+)\}/gm;
+const FIELD_RE = /^\s+(\w+)\s+\S/gm;
+function parseModels(content) {
+    const models = new Map();
+    for (const modelMatch of content.matchAll(MODEL_RE)) {
         const table = modelMatch[1];
-        entities.push({ table, operation: 'create_table' });
+        const fields = new Set();
         const body = modelMatch[2];
-        // Match field lines: fieldName TypeName ...
-        const fieldRe = /^\s+(\w+)\s+\S/gm;
-        for (const fieldMatch of body.matchAll(fieldRe)) {
+        for (const fieldMatch of body.matchAll(FIELD_RE)) {
             const column = fieldMatch[1];
             if (column.startsWith('@') || column === 'id')
                 continue;
-            entities.push({ table, column, operation: 'add_column' });
+            fields.add(column);
+        }
+        models.set(table, fields);
+    }
+    return models;
+}
+/**
+ * Extract schema entities from a Prisma schema file.
+ *
+ * When `previousContent` is provided, only the diff (added/removed fields,
+ * new/dropped tables) is emitted — this avoids over-reporting when a user
+ * touches schema.prisma for any reason (adding one field, editing a comment)
+ * and every long-existing field gets re-checked against type/API/UI layers.
+ *
+ * When `previousContent` is null/undefined, every model and field is emitted
+ * — the original "all entities are new" behavior used as a fallback when git
+ * history isn't available.
+ */
+export function extractFromPrisma(content, previousContent) {
+    const current = parseModels(content);
+    if (previousContent === undefined || previousContent === null) {
+        const entities = [];
+        for (const [table, fields] of current) {
+            entities.push({ table, operation: 'create_table' });
+            for (const column of fields)
+                entities.push({ table, column, operation: 'add_column' });
+        }
+        return entities;
+    }
+    const previous = parseModels(previousContent);
+    const entities = [];
+    for (const [table, currentFields] of current) {
+        const previousFields = previous.get(table);
+        if (!previousFields) {
+            // New table — emit create_table + add_column for every field
+            entities.push({ table, operation: 'create_table' });
+            for (const column of currentFields)
+                entities.push({ table, column, operation: 'add_column' });
+            continue;
+        }
+        for (const column of currentFields) {
+            if (!previousFields.has(column))
+                entities.push({ table, column, operation: 'add_column' });
+        }
+        for (const column of previousFields) {
+            if (!currentFields.has(column))
+                entities.push({ table, column, operation: 'drop_column' });
+        }
+    }
+    // Second pass — entirely dropped models. The first loop only iterates
+    // `current`, so a model present in `previous` but removed from `current`
+    // would never emit any entity, leaving stale references in type/API/UI
+    // layers undetected. Caught by Cursor Bugbot on PR #44 (MEDIUM).
+    for (const [table, previousFields] of previous) {
+        if (current.has(table))
+            continue;
+        for (const column of previousFields) {
+            entities.push({ table, column, operation: 'drop_column' });
         }
     }
     return entities;

package/dist/src/core/schema-alignment/git-history.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Read the previous version of a file from git, comparing against `base`.
+ * Returns null if the file has no git history at that ref (untracked,
+ * brand-new, not in a repo, or the ref doesn't resolve) — callers should
+ * fall back to whole-file extraction in that case.
+ *
+ * When `base` is omitted, the default is CI-aware (see `resolveDefaultBase`):
+ * - GitHub Actions PR build → `origin/<GITHUB_BASE_REF>`
+ * - GitLab MR build → `origin/<CI_MERGE_REQUEST_TARGET_BRANCH_NAME>`
+ * - everything else → `HEAD~1`
+ *
+ * Reading from `HEAD` directly is wrong in CI (any post-commit context):
+ * `HEAD` IS the current commit, so the diff against the working-tree file
+ * is always empty and no schema entities are emitted. Caught by Cursor
+ * Bugbot on PR #44 (HIGH); the multi-commit-PR variant of the same bug
+ * caught as a MEDIUM follow-up on the rebased commit.
+ */
+export declare function getPreviousFileContent(filePath: string, cwd?: string, base?: string): string | null;
+//# sourceMappingURL=git-history.d.ts.map

package/dist/src/core/schema-alignment/git-history.js

@@ -0,0 +1,53 @@
+import { spawnSync } from 'node:child_process';
+import * as path from 'node:path';
+/**
+ * Resolve the default base ref for git diffs in a CI-aware way.
+ *
+ * Priority: `GITHUB_BASE_REF` (GitHub Actions PR builds), then
+ * `CI_MERGE_REQUEST_TARGET_BRANCH_NAME` (GitLab MR builds), then `HEAD~1`
+ * for local / single-commit contexts. Branch-name env vars are prefixed
+ * with `origin/` so `git show <ref>:<file>` resolves to the
+ * remote-tracking-branch tip (the actual merge base).
+ *
+ * Caught + extended by Cursor Bugbot follow-up on PR #44 (MEDIUM): a static
+ * default of `HEAD~1` is wrong for multi-commit PRs — it points at the
+ * previous commit on the branch, not the merge base.
+ */
+function resolveDefaultBase() {
+    const ghBase = process.env.GITHUB_BASE_REF;
+    if (ghBase && ghBase.length > 0)
+        return `origin/${ghBase}`;
+    const glBase = process.env.CI_MERGE_REQUEST_TARGET_BRANCH_NAME;
+    if (glBase && glBase.length > 0)
+        return `origin/${glBase}`;
+    return 'HEAD~1';
+}
+/**
+ * Read the previous version of a file from git, comparing against `base`.
+ * Returns null if the file has no git history at that ref (untracked,
+ * brand-new, not in a repo, or the ref doesn't resolve) — callers should
+ * fall back to whole-file extraction in that case.
+ *
+ * When `base` is omitted, the default is CI-aware (see `resolveDefaultBase`):
+ * - GitHub Actions PR build → `origin/<GITHUB_BASE_REF>`
+ * - GitLab MR build → `origin/<CI_MERGE_REQUEST_TARGET_BRANCH_NAME>`
+ * - everything else → `HEAD~1`
+ *
+ * Reading from `HEAD` directly is wrong in CI (any post-commit context):
+ * `HEAD` IS the current commit, so the diff against the working-tree file
+ * is always empty and no schema entities are emitted. Caught by Cursor
+ * Bugbot on PR #44 (HIGH); the multi-commit-PR variant of the same bug
+ * caught as a MEDIUM follow-up on the rebased commit.
+ */
+export function getPreviousFileContent(filePath, cwd = process.cwd(), base = resolveDefaultBase()) {
+    const relPath = path.isAbsolute(filePath) ? path.relative(cwd, filePath) : filePath;
+    const result = spawnSync('git', ['show', `${base}:${relPath}`], {
+        cwd,
+        encoding: 'utf8',
+        timeout: 5000,
+    });
+    if (result.status !== 0)
+        return null;
+    return result.stdout;
+}
+//# sourceMappingURL=git-history.js.map

package/dist/src/core/static-rules/rules/brand-tokens.js

@@ -36,8 +36,8 @@ function buildPalette(brandCfg, cwd) {
 export const brandTokensRule = {
     name: 'brand-tokens',
     severity: 'warning',
-    async check(touchedFiles, config = {}) {
-        const brandCfg = config.brand;
+    async check(touchedFiles, ctx = {}) {
+        const brandCfg = ctx.config?.brand;
         if (!brandCfg)
             return [];
         const cwd = process.cwd();

package/dist/src/core/static-rules/rules/schema-alignment.js

@@ -1,5 +1,6 @@
 import { detect } from "../../schema-alignment/detector.js";
 import { extract } from "../../schema-alignment/extractor/index.js";
+import { getPreviousFileContent } from "../../schema-alignment/git-history.js";
 import { scanLayers } from "../../schema-alignment/scanner.js";
 import { runLlmCheck } from "../../schema-alignment/llm-check.js";
 function isDestructive(entity) {
@@ -50,15 +51,24 @@ function structuralFinding(result, layer, defaultSev, sourceFile) {
 export const schemaAlignmentRule = {
     name: 'schema-alignment',
     severity: 'warning',
-    async check(touchedFiles, config = {}) {
-        const saConfig = config['schema-alignment'];
+    async check(touchedFiles, ctx = {}) {
+        const saConfig = ctx.config?.['schema-alignment'];
         if (saConfig?.enabled === false)
             return [];
         const cwd = process.cwd();
         const migrationFiles = detect(touchedFiles, saConfig);
         if (migrationFiles.length === 0)
             return [];
-        const allEntities = migrationFiles.flatMap(f => extract(f).map(entity => ({ entity, sourceFile: f })));
+        // For Prisma schema files, fetch the previous version from git so we only
+        // emit entities for what actually changed in this diff. SQL migrations
+        // are inherently a diff already; the SQL extractor ignores
+        // `previousContent`, so skipping the `git show` spawn there avoids pure
+        // waste (Bugbot LOW on PR #44).
+        const allEntities = migrationFiles.flatMap(f => {
+            const isPrisma = f.endsWith('.prisma');
+            const previousContent = isPrisma ? getPreviousFileContent(f, cwd) : null;
+            return extract(f, previousContent).map(entity => ({ entity, sourceFile: f }));
+        });
         if (allEntities.length === 0)
             return [];
         const scanResults = scanLayers(allEntities.map(e => e.entity), cwd, saConfig);
@@ -75,7 +85,7 @@ export const schemaAlignmentRule = {
             return [];
         const defaultSev = saConfig?.severity ?? 'warning';
         const llmEnabled = saConfig?.llmCheck !== false;
-        const engine = config['_engine'];
+        const engine = ctx.engine;
         // Structural mode — always compute these so we can fall back if LLM path yields nothing
         const structural = [];
         for (const { result: r, sourceFile } of gapResults) {