@spikedpunch/align-agent 0.1.0

package/dist/git.d.ts

@@ -0,0 +1,3 @@
+import type { GitEffects } from './effects.js';
+export declare function createNodeGitEffects(rootDir: string): GitEffects;
+//# sourceMappingURL=git.d.ts.map

package/dist/git.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"git.d.ts","sourceRoot":"","sources":["../src/git.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAmB,UAAU,EAAsC,MAAM,cAAc,CAAC;AAiBpG,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU,CA0EhE"}

package/dist/git.js

@@ -0,0 +1,91 @@
+/**
+ * Real `git`/`gh` implementation of `GitEffects` — the only place in `@spikedpunch/align-agent` that shells
+ * out. No git library dependency exists anywhere else in this monorepo (confirmed at Stage-4
+ * research time), so this is net-new plumbing: thin wrappers over `git`/`gh` via
+ * `node:child_process`, never a shell string (execFile, not exec — no shell-injection surface
+ * from LLM-controlled commit messages/branch names).
+ */
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+async function git(rootDir, args) {
+    return execFileAsync('git', [...args], { cwd: rootDir, maxBuffer: 32 * 1024 * 1024 });
+}
+async function commandExists(cmd) {
+    try {
+        await execFileAsync(cmd, ['--version']);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function createNodeGitEffects(rootDir) {
+    return {
+        async isWorktreeClean() {
+            const { stdout } = await git(rootDir, ['status', '--porcelain']);
+            return stdout.trim().length === 0;
+        },
+        async currentBranch() {
+            const { stdout } = await git(rootDir, ['rev-parse', '--abbrev-ref', 'HEAD']);
+            return stdout.trim();
+        },
+        async createBranch(name) {
+            await git(rootDir, ['checkout', '-b', name]);
+        },
+        async commit(message, paths) {
+            if (paths.length === 0)
+                throw new Error('commit() requires at least one path');
+            await git(rootDir, ['add', '--', ...paths]);
+            await git(rootDir, ['commit', '-m', message]);
+            const { stdout } = await git(rootDir, ['rev-parse', 'HEAD']);
+            return { sha: stdout.trim() };
+        },
+        async revertCommit(sha) {
+            // Work-branch commits are throwaway per REPAIR attempt — a hard reset to the commit's
+            // parent is the git-native "undo," not a revert-commit (no noise commits on a branch that
+            // may itself be discarded on escalation).
+            await git(rootDir, ['reset', '--hard', `${sha}~1`]);
+        },
+        async rebaseOnto(ontoBranch) {
+            try {
+                await git(rootDir, ['rebase', ontoBranch]);
+                return { ok: true };
+            }
+            catch {
+                await git(rootDir, ['rebase', '--abort']).catch(() => undefined);
+                return { ok: false, conflict: true };
+            }
+        },
+        async push(branch) {
+            const { stdout } = await git(rootDir, ['remote']);
+            if (stdout.trim().length === 0)
+                return { ok: false, reason: 'no-remote' };
+            try {
+                await git(rootDir, ['push', '-u', 'origin', branch]);
+                return { ok: true };
+            }
+            catch {
+                return { ok: false, reason: 'push-failed' };
+            }
+        },
+        async createDraftPr(params) {
+            if (!(await commandExists('gh'))) {
+                return { ok: false, reason: 'gh CLI not found on PATH' };
+            }
+            try {
+                const { stdout } = await execFileAsync('gh', ['pr', 'create', '--draft', '--base', params.base, '--head', params.branch, '--title', params.title, '--body', params.body], { cwd: rootDir });
+                return { ok: true, url: stdout.trim() };
+            }
+            catch (err) {
+                return { ok: false, reason: err instanceof Error ? err.message : String(err) };
+            }
+        },
+        async ffMergeAndDeleteBranch(branch, base) {
+            await git(rootDir, ['checkout', base]);
+            await git(rootDir, ['merge', '--ff-only', branch]);
+            await git(rootDir, ['branch', '-d', branch]);
+        },
+    };
+}
+//# sourceMappingURL=git.js.map

package/dist/git.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"git.js","sourceRoot":"","sources":["../src/git.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export * from './fixProvider.js';
+export * from './anthropicFixProvider.js';
+export * from './coverage.js';
+export * from './symbolTable.js';
+export * from './symbolDiff.js';
+export * from './oscillation.js';
+export * from './rails.js';
+export * from './repairDecision.js';
+export * from './effects.js';
+export * from './git.js';
+export * from './format.js';
+export * from './run.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC;AAC3B,cAAc,qBAAqB,CAAC;AACpC,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC"}

package/dist/index.js

@@ -0,0 +1,13 @@
+export * from './fixProvider.js';
+export * from './anthropicFixProvider.js';
+export * from './coverage.js';
+export * from './symbolTable.js';
+export * from './symbolDiff.js';
+export * from './oscillation.js';
+export * from './rails.js';
+export * from './repairDecision.js';
+export * from './effects.js';
+export * from './git.js';
+export * from './format.js';
+export * from './run.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC;AAC3B,cAAc,qBAAqB,CAAC;AACpC,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC"}

package/dist/oscillation.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Oscillation detection (REPAIR loop guard, ADR 012 shape-2 conflicts): per-file fingerprint-set
+ * history across REPAIR attempts. Fix A introduces violation B; fix B reintroduces violation A —
+ * the violation-id set returns to one already seen earlier in this group's history. That's a
+ * cycle in the state space, not progress — stop immediately and escalate naming both rule ids,
+ * rather than burning the remaining REPAIR budget ping-ponging.
+ */
+import type { RuleId, ViolationId } from '@spikedpunch/align-core';
+export interface AttemptFingerprint {
+    readonly violationIds: ReadonlySet<ViolationId>;
+    readonly ruleIds: ReadonlySet<RuleId>;
+}
+export interface OscillationResult {
+    readonly oscillating: boolean;
+    /** Index into the history array of the earlier attempt whose fingerprint the latest attempt
+     * repeats — present only when `oscillating` is true. */
+    readonly repeatedAtIndex?: number;
+    /** Rule ids present in both the repeated attempt and the current one — named in the escalation
+     * report per the plan's "conflicting rules" requirement. */
+    readonly conflictingRuleIds?: readonly RuleId[];
+}
+/**
+ * `history` is ordered oldest-to-newest, one entry per REPAIR attempt (including the initial
+ * DISCOVER state as index 0). Detects whether the LATEST entry's violation-id set exactly matches
+ * any earlier entry's set.
+ */
+export declare function detectOscillation(history: readonly AttemptFingerprint[]): OscillationResult;
+//# sourceMappingURL=oscillation.d.ts.map

package/dist/oscillation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"oscillation.d.ts","sourceRoot":"","sources":["../src/oscillation.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAEnE,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,YAAY,EAAE,WAAW,CAAC,WAAW,CAAC,CAAC;IAChD,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CACvC;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B;4DACwD;IACxD,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC;gEAC4D;IAC5D,QAAQ,CAAC,kBAAkB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACjD;AAQD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,SAAS,kBAAkB,EAAE,GAAG,iBAAiB,CAgB3F"}

package/dist/oscillation.js

@@ -0,0 +1,31 @@
+function setsEqual(a, b) {
+    if (a.size !== b.size)
+        return false;
+    for (const item of a)
+        if (!b.has(item))
+            return false;
+    return true;
+}
+/**
+ * `history` is ordered oldest-to-newest, one entry per REPAIR attempt (including the initial
+ * DISCOVER state as index 0). Detects whether the LATEST entry's violation-id set exactly matches
+ * any earlier entry's set.
+ */
+export function detectOscillation(history) {
+    if (history.length < 2)
+        return { oscillating: false };
+    const latest = history[history.length - 1];
+    for (let i = 0; i < history.length - 1; i++) {
+        const earlier = history[i];
+        if (setsEqual(earlier.violationIds, latest.violationIds) && earlier.violationIds.size > 0) {
+            // Name every rule id seen across the whole repeated span (index i..latest), not just the
+            // two matching endpoints — "fix A introduces B, fix B reintroduces A" means the rule ids
+            // that changed hands mid-cycle (B) are exactly what the escalation report must name
+            // alongside the rule that oscillated back (A).
+            const conflictingRuleIds = [...new Set(history.slice(i).flatMap((h) => [...h.ruleIds]))];
+            return { oscillating: true, repeatedAtIndex: i, conflictingRuleIds };
+        }
+    }
+    return { oscillating: false };
+}
+//# sourceMappingURL=oscillation.js.map

package/dist/oscillation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"oscillation.js","sourceRoot":"","sources":["../src/oscillation.ts"],"names":[],"mappings":"AAwBA,SAAS,SAAS,CAAI,CAAiB,EAAE,CAAiB;IACxD,IAAI,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,IAAI;QAAE,OAAO,KAAK,CAAC;IACpC,KAAK,MAAM,IAAI,IAAI,CAAC;QAAE,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC;YAAE,OAAO,KAAK,CAAC;IACrD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAAC,OAAsC;IACtE,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC;QAAE,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,CAAC;IACtD,MAAM,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAuB,CAAC;IAEjE,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAC5C,MAAM,OAAO,GAAG,OAAO,CAAC,CAAC,CAAuB,CAAC;QACjD,IAAI,SAAS,CAAC,OAAO,CAAC,YAAY,EAAE,MAAM,CAAC,YAAY,CAAC,IAAI,OAAO,CAAC,YAAY,CAAC,IAAI,GAAG,CAAC,EAAE,CAAC;YAC1F,yFAAyF;YACzF,yFAAyF;YACzF,oFAAoF;YACpF,+CAA+C;YAC/C,MAAM,kBAAkB,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;YACzF,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,eAAe,EAAE,CAAC,EAAE,kBAAkB,EAAE,CAAC;QACvE,CAAC;IACH,CAAC;IACD,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,CAAC;AAChC,CAAC"}

package/dist/rails.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Safety-rail pure checks (IMPLEMENTATION_PLAN.md Stage 4 "Safety rails"). Kept separate from the
+ * git/fs imperative shell so every rail is independently unit-testable with plain data.
+ */
+import type { RepoRelativePath } from '@spikedpunch/align-core';
+import type { FixProposal } from '@spikedpunch/align-core';
+/** True if `rawPath` (as proposed by the LLM, not yet branded) targets `align.config.ts`,
+ * anything under `.align/`, or escapes the repo root (`..` traversal / absolute path). */
+export declare function isForbiddenPath(rawPath: string): boolean;
+export interface ForbiddenPathViolation {
+    readonly path: string;
+}
+/** Reject any `FixProposal` touching a forbidden path — checked BEFORE the apply pipeline ever
+ * runs, so a proposal that reaches for `align.config.ts` never gets a chance to validate an edit
+ * block against it. */
+export declare function findForbiddenPathsInProposal(proposal: FixProposal): readonly ForbiddenPathViolation[];
+/** Suppressions are dormant machinery in arch-first v1 (ADR 010/012): no lint gates exist yet, so
+ * no rule category is suppressible. Any proposal that uses `suppressions` is rejected outright —
+ * tested as such; see the agent package README for the one-paragraph explanation. */
+export declare function usesSuppressions(proposal: FixProposal): boolean;
+export type GroupFile = {
+    readonly file: RepoRelativePath;
+};
+/** Group violations by file — GROUP step (ADR 010/plan: "all of a file's violations in one
+ * prompt"). Pure, deterministic ordering (first-seen file order, stable). */
+export declare function groupViolationsByFile<V extends GroupFile>(violations: readonly V[]): ReadonlyMap<RepoRelativePath, readonly V[]>;
+//# sourceMappingURL=rails.d.ts.map

package/dist/rails.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rails.d.ts","sourceRoot":"","sources":["../src/rails.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAK3D;0FAC0F;AAC1F,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAKxD;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;uBAEuB;AACvB,wBAAgB,4BAA4B,CAAC,QAAQ,EAAE,WAAW,GAAG,SAAS,sBAAsB,EAAE,CAErG;AAED;;qFAEqF;AACrF,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,WAAW,GAAG,OAAO,CAE/D;AAED,MAAM,MAAM,SAAS,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAA;CAAE,CAAC;AAE5D;6EAC6E;AAC7E,wBAAgB,qBAAqB,CAAC,CAAC,SAAS,SAAS,EAAE,UAAU,EAAE,SAAS,CAAC,EAAE,GAAG,WAAW,CAAC,gBAAgB,EAAE,SAAS,CAAC,EAAE,CAAC,CAQhI"}

package/dist/rails.js

@@ -0,0 +1,38 @@
+const FORBIDDEN_PATH_PREFIXES = ['.align/', '.align'];
+const FORBIDDEN_EXACT_FILES = ['align.config.ts'];
+/** True if `rawPath` (as proposed by the LLM, not yet branded) targets `align.config.ts`,
+ * anything under `.align/`, or escapes the repo root (`..` traversal / absolute path). */
+export function isForbiddenPath(rawPath) {
+    const normalized = rawPath.replace(/\\/g, '/').replace(/^\.\//, '');
+    if (normalized.startsWith('/') || normalized.startsWith('..'))
+        return true;
+    if (FORBIDDEN_EXACT_FILES.includes(normalized))
+        return true;
+    return FORBIDDEN_PATH_PREFIXES.some((prefix) => normalized === prefix.replace(/\/$/, '') || normalized.startsWith(prefix));
+}
+/** Reject any `FixProposal` touching a forbidden path — checked BEFORE the apply pipeline ever
+ * runs, so a proposal that reaches for `align.config.ts` never gets a chance to validate an edit
+ * block against it. */
+export function findForbiddenPathsInProposal(proposal) {
+    return proposal.files.filter((f) => isForbiddenPath(f.path)).map((f) => ({ path: f.path }));
+}
+/** Suppressions are dormant machinery in arch-first v1 (ADR 010/012): no lint gates exist yet, so
+ * no rule category is suppressible. Any proposal that uses `suppressions` is rejected outright —
+ * tested as such; see the agent package README for the one-paragraph explanation. */
+export function usesSuppressions(proposal) {
+    return (proposal.suppressions?.length ?? 0) > 0;
+}
+/** Group violations by file — GROUP step (ADR 010/plan: "all of a file's violations in one
+ * prompt"). Pure, deterministic ordering (first-seen file order, stable). */
+export function groupViolationsByFile(violations) {
+    const groups = new Map();
+    for (const v of violations) {
+        const list = groups.get(v.file);
+        if (list === undefined)
+            groups.set(v.file, [v]);
+        else
+            list.push(v);
+    }
+    return groups;
+}
+//# sourceMappingURL=rails.js.map

package/dist/rails.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rails.js","sourceRoot":"","sources":["../src/rails.ts"],"names":[],"mappings":"AAOA,MAAM,uBAAuB,GAAG,CAAC,SAAS,EAAE,QAAQ,CAAU,CAAC;AAC/D,MAAM,qBAAqB,GAAG,CAAC,iBAAiB,CAAU,CAAC;AAE3D;0FAC0F;AAC1F,MAAM,UAAU,eAAe,CAAC,OAAe;IAC7C,MAAM,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;IACpE,IAAI,UAAU,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,UAAU,CAAC,UAAU,CAAC,IAAI,CAAC;QAAE,OAAO,IAAI,CAAC;IAC3E,IAAI,qBAAqB,CAAC,QAAQ,CAAC,UAAoD,CAAC;QAAE,OAAO,IAAI,CAAC;IACtG,OAAO,uBAAuB,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,UAAU,KAAK,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,UAAU,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC;AAC7H,CAAC;AAMD;;uBAEuB;AACvB,MAAM,UAAU,4BAA4B,CAAC,QAAqB;IAChE,OAAO,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,eAAe,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;AAC9F,CAAC;AAED;;qFAEqF;AACrF,MAAM,UAAU,gBAAgB,CAAC,QAAqB;IACpD,OAAO,CAAC,QAAQ,CAAC,YAAY,EAAE,MAAM,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;AAClD,CAAC;AAID;6EAC6E;AAC7E,MAAM,UAAU,qBAAqB,CAAsB,UAAwB;IACjF,MAAM,MAAM,GAAG,IAAI,GAAG,EAAyB,CAAC;IAChD,KAAK,MAAM,CAAC,IAAI,UAAU,EAAE,CAAC;QAC3B,MAAM,IAAI,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QAChC,IAAI,IAAI,KAAK,SAAS;YAAE,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;;YAC3C,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACpB,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/repairDecision.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Pure REPAIR decision core (CODING_BEST_PRACTICES.md §14: functional core, imperative shell).
+ * Given a group's attempt history, decides the next action — never touches git, the network, or
+ * the filesystem. Consumed by `run.ts`'s imperative shell.
+ */
+import type { RuleId } from '@spikedpunch/align-core';
+import { type AttemptFingerprint } from './oscillation.js';
+export type RepairDecision = {
+    readonly action: 'retry';
+    readonly attempt: number;
+} | {
+    readonly action: 'escalate';
+    readonly reason: 'max-attempts';
+} | {
+    readonly action: 'escalate-oscillation';
+    readonly reason: 'oscillation';
+    readonly conflictingRuleIds: readonly RuleId[];
+};
+/** `history` includes the initial (pre-fix) fingerprint at index 0 and one entry per completed
+ * attempt after that; `attemptsSoFar` is the count of REPAIR attempts already made (not counting
+ * the original PLAN+FIX). Max 3 REPAIR attempts per group, per the plan. */
+export declare function decideNextRepairAction(history: readonly AttemptFingerprint[], attemptsSoFar: number, maxAttempts?: number): RepairDecision;
+//# sourceMappingURL=repairDecision.d.ts.map

package/dist/repairDecision.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repairDecision.d.ts","sourceRoot":"","sources":["../src/repairDecision.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AACtD,OAAO,EAAqB,KAAK,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAE9E,MAAM,MAAM,cAAc,GACtB;IAAE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACtD;IAAE,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAA;CAAE,GAChE;IAAE,QAAQ,CAAC,MAAM,EAAE,sBAAsB,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAAC,QAAQ,CAAC,kBAAkB,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,CAAC;AAEhI;;4EAE4E;AAC5E,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,SAAS,kBAAkB,EAAE,EACtC,aAAa,EAAE,MAAM,EACrB,WAAW,SAAI,GACd,cAAc,CAOhB"}

package/dist/repairDecision.js

@@ -0,0 +1,14 @@
+import { detectOscillation } from './oscillation.js';
+/** `history` includes the initial (pre-fix) fingerprint at index 0 and one entry per completed
+ * attempt after that; `attemptsSoFar` is the count of REPAIR attempts already made (not counting
+ * the original PLAN+FIX). Max 3 REPAIR attempts per group, per the plan. */
+export function decideNextRepairAction(history, attemptsSoFar, maxAttempts = 3) {
+    const oscillation = detectOscillation(history);
+    if (oscillation.oscillating) {
+        return { action: 'escalate-oscillation', reason: 'oscillation', conflictingRuleIds: oscillation.conflictingRuleIds ?? [] };
+    }
+    if (attemptsSoFar >= maxAttempts)
+        return { action: 'escalate', reason: 'max-attempts' };
+    return { action: 'retry', attempt: attemptsSoFar + 1 };
+}
+//# sourceMappingURL=repairDecision.js.map

package/dist/repairDecision.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"repairDecision.js","sourceRoot":"","sources":["../src/repairDecision.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,iBAAiB,EAA2B,MAAM,kBAAkB,CAAC;AAO9E;;4EAE4E;AAC5E,MAAM,UAAU,sBAAsB,CACpC,OAAsC,EACtC,aAAqB,EACrB,WAAW,GAAG,CAAC;IAEf,MAAM,WAAW,GAAG,iBAAiB,CAAC,OAAO,CAAC,CAAC;IAC/C,IAAI,WAAW,CAAC,WAAW,EAAE,CAAC;QAC5B,OAAO,EAAE,MAAM,EAAE,sBAAsB,EAAE,MAAM,EAAE,aAAa,EAAE,kBAAkB,EAAE,WAAW,CAAC,kBAAkB,IAAI,EAAE,EAAE,CAAC;IAC7H,CAAC;IACD,IAAI,aAAa,IAAI,WAAW;QAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,cAAc,EAAE,CAAC;IACxF,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,aAAa,GAAG,CAAC,EAAE,CAAC;AACzD,CAAC"}

package/dist/run.d.ts

@@ -0,0 +1,68 @@
+/**
+ * The imperative shell (CODING_BEST_PRACTICES.md §14) that drives one `align agent run`:
+ * DISCOVER -> GROUP -> PLAN+FIX -> APPLY -> VERIFY -> REPAIR -> ESCALATE -> DONE -> TERMINAL MERGE.
+ * All I/O goes through `AgentEffects`; all decisions with real branching logic are pure functions
+ * imported from `repairDecision.ts`/`oscillation.ts`/`rails.ts`/`coverage.ts`/`symbolDiff.ts` —
+ * this file is deliberately thin sequencing, testable end-to-end with a fake `AgentEffects` +
+ * `FakeFixProvider` (see `test/run.test.ts`), never mocking a module.
+ */
+import { type CheckRun, type FixProposal, type RepoRelativePath, type RulesetIR } from '@spikedpunch/align-core';
+import type { AgentEffects } from './effects.js';
+export interface AgentRunOptions {
+    readonly maxAttempts: number;
+    readonly mode: 'pr' | 'auto-merge';
+    readonly allowUntested: boolean;
+    readonly allowSymbolRemovals: boolean;
+    readonly dryRun: boolean;
+    readonly workBranchName: string;
+    readonly baseBranch: string;
+    readonly prTitle?: string;
+}
+export type GroupOutcome = {
+    readonly status: 'done';
+    readonly file: RepoRelativePath;
+    readonly commitSha: string;
+    readonly rationale: string;
+} | {
+    readonly status: 'escalated';
+    readonly file: RepoRelativePath;
+    readonly reason: string;
+} | {
+    readonly status: 'dry-run';
+    readonly file: RepoRelativePath;
+    readonly proposal: FixProposal;
+};
+export type TerminalMergeOutcome = {
+    readonly status: 'no-commits';
+} | {
+    readonly status: 'rebase-conflict';
+} | {
+    readonly status: 'final-check-red';
+    readonly finalCheck: CheckRun;
+} | {
+    readonly status: 'auto-merged';
+} | {
+    readonly status: 'pr-created';
+    readonly url: string;
+    readonly summary: string;
+} | {
+    readonly status: 'no-remote-or-no-gh';
+    readonly summary: string;
+    readonly branch: string;
+};
+export type AgentRunVerdict = 'refused' | 'nothing-to-fix' | 'dry-run' | 'done' | 'partial-escalated';
+export interface AgentRunResult {
+    readonly verdict: AgentRunVerdict;
+    readonly refusalReason?: string;
+    readonly groups: readonly GroupOutcome[];
+    readonly finalCheck?: CheckRun;
+    readonly terminalMerge?: TerminalMergeOutcome;
+}
+/**
+ * Top-level entry point. `ruleset` is passed as data (not an effect) — it's already loaded by the
+ * CLI composition root exactly as `align check` loads it, and is needed only to build
+ * `ruleExplanations` (pure).
+ */
+export declare function runAgentLoop(effects: AgentEffects, ruleset: RulesetIR, options: AgentRunOptions): Promise<AgentRunResult>;
+export declare function defaultWorkBranchName(now?: () => number): string;
+//# sourceMappingURL=run.d.ts.map

package/dist/run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../src/run.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAIL,KAAK,QAAQ,EAEb,KAAK,WAAW,EAChB,KAAK,gBAAgB,EAErB,KAAK,SAAS,EAEf,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AASjD,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,YAAY,CAAC;IACnC,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,mBAAmB,EAAE,OAAO,CAAC;IACtC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,MAAM,YAAY,GACpB;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GACpH;IAAE,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAC1F;IAAE,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAA;CAAE,CAAC;AAEpG,MAAM,MAAM,oBAAoB,GAC5B;IAAE,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAA;CAAE,GACjC;IAAE,QAAQ,CAAC,MAAM,EAAE,iBAAiB,CAAA;CAAE,GACtC;IAAE,QAAQ,CAAC,MAAM,EAAE,iBAAiB,CAAC;IAAC,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAA;CAAE,GACrE;IAAE,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAA;CAAE,GAClC;IAAE,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACjF;IAAE,QAAQ,CAAC,MAAM,EAAE,oBAAoB,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAEjG,MAAM,MAAM,eAAe,GAAG,SAAS,GAAG,gBAAgB,GAAG,SAAS,GAAG,MAAM,GAAG,mBAAmB,CAAC;AAEtG,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;IAClC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,CAAC;IACzC,QAAQ,CAAC,UAAU,CAAC,EAAE,QAAQ,CAAC;IAC/B,QAAQ,CAAC,aAAa,CAAC,EAAE,oBAAoB,CAAC;CAC/C;AAqMD;;;;GAIG;AACH,wBAAsB,YAAY,CAAC,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC,CAkC/H;AAED,wBAAgB,qBAAqB,CAAC,GAAG,GAAE,MAAM,MAAiB,GAAG,MAAM,CAG1E"}

package/dist/run.js

@@ -0,0 +1,211 @@
+/**
+ * The imperative shell (CODING_BEST_PRACTICES.md §14) that drives one `align agent run`:
+ * DISCOVER -> GROUP -> PLAN+FIX -> APPLY -> VERIFY -> REPAIR -> ESCALATE -> DONE -> TERMINAL MERGE.
+ * All I/O goes through `AgentEffects`; all decisions with real branching logic are pure functions
+ * imported from `repairDecision.ts`/`oscillation.ts`/`rails.ts`/`coverage.ts`/`symbolDiff.ts` —
+ * this file is deliberately thin sequencing, testable end-to-end with a fake `AgentEffects` +
+ * `FakeFixProvider` (see `test/run.test.ts`), never mocking a module.
+ */
+import { applyFixProposalFiles, toRepoRelativePath, toRuleId, } from '@spikedpunch/align-core';
+import { buildCondensedSymbolTable } from './symbolTable.js';
+import { isFileCovered } from './coverage.js';
+import { diffExportedSymbols } from './symbolDiff.js';
+import { decideNextRepairAction } from './repairDecision.js';
+import { findForbiddenPathsInProposal, groupViolationsByFile, usesSuppressions } from './rails.js';
+function ruleExplanationMap(ruleset) {
+    const map = new Map();
+    for (const rule of ruleset.rules) {
+        const because = rule.provenance.because ?? rule.provenance.sourceQuote;
+        const ruleId = toRuleId(rule.id);
+        map.set(ruleId, because === undefined ? { ruleId, kind: rule.kind } : { ruleId, kind: rule.kind, because });
+    }
+    return map;
+}
+function explanationsFor(violations, map) {
+    const ids = [...new Set(violations.map((v) => v.ruleId))];
+    return ids.map((id) => map.get(id) ?? { ruleId: id, kind: 'unknown' });
+}
+function fingerprintOf(violations) {
+    return { violationIds: new Set(violations.map((v) => v.id)), ruleIds: new Set(violations.map((v) => v.ruleId)) };
+}
+function escalationFromDecision(decision) {
+    if (decision.action === 'escalate-oscillation') {
+        return `oscillation detected — conflicting rules: ${decision.conflictingRuleIds.join(', ')} (fix A introduced B, fix B reintroduced A)`;
+    }
+    return 'exceeded the maximum REPAIR attempts for this group';
+}
+async function buildInputForFile(effects, file, violations, explanations, previousFailure) {
+    const graph = await effects.scanGraph();
+    const fileContent = await effects.readFile(file);
+    return {
+        violations,
+        fileContents: new Map([[file, fileContent]]),
+        condensedSymbolTable: buildCondensedSymbolTable(file, graph),
+        ruleExplanations: explanationsFor(violations, explanations),
+        ...(previousFailure !== undefined ? { previousFailure } : {}),
+    };
+}
+/** DISCOVER + GROUP + PLAN only — used both for `--dry-run` and internally is NOT reused for the
+ * real run (the real run needs the full per-group loop below, not just one proposal). */
+async function planOnly(effects, groupsMap, explanations) {
+    const outcomes = [];
+    for (const [file, violations] of groupsMap) {
+        const input = await buildInputForFile(effects, file, violations, explanations);
+        const proposal = await effects.fixProvider.proposeFix(input);
+        outcomes.push({ status: 'dry-run', file, proposal });
+    }
+    return outcomes;
+}
+/** PLAN+FIX -> APPLY -> VERIFY -> REPAIR for one file GROUP. Returns once the group reaches DONE
+ * or ESCALATE. */
+async function runGroup(effects, file, initialViolations, explanations, options) {
+    // Green≠correct guard (b): zero-coverage refusal — checked once, before any PLAN+FIX call.
+    if (!options.allowUntested) {
+        const graph = await effects.scanGraph();
+        if (!isFileCovered(file, graph)) {
+            return {
+                status: 'escalated',
+                file,
+                reason: 'zero test coverage — no scanned test file transitively imports this file (pass --allow-untested to override)',
+            };
+        }
+    }
+    const history = [fingerprintOf(initialViolations)];
+    let attemptsSoFar = 0;
+    let currentViolations = initialViolations;
+    let previousFailure;
+    for (;;) {
+        const input = await buildInputForFile(effects, file, currentViolations, explanations, previousFailure);
+        const proposal = await effects.fixProvider.proposeFix(input);
+        const forbidden = findForbiddenPathsInProposal(proposal);
+        if (forbidden.length > 0) {
+            return { status: 'escalated', file, reason: `proposal touched a forbidden path: ${forbidden.map((f) => f.path).join(', ')}` };
+        }
+        if (usesSuppressions(proposal)) {
+            return { status: 'escalated', file, reason: 'no suppressible rule categories active — suppressions field is dormant in v1' };
+        }
+        const originals = new Map();
+        for (const f of proposal.files) {
+            const p = toRepoRelativePath(f.path);
+            originals.set(p, await effects.readFile(p));
+        }
+        const validated = applyFixProposalFiles(originals, proposal.files, toRepoRelativePath);
+        const applyFailure = validated.find((v) => !v.ok);
+        if (applyFailure !== undefined && !applyFailure.ok) {
+            attemptsSoFar += 1;
+            const decision = decideNextRepairAction(history, attemptsSoFar, options.maxAttempts);
+            if (decision.action !== 'retry')
+                return { status: 'escalated', file, reason: escalationFromDecision(decision) };
+            previousFailure = applyFailure.failure;
+            continue;
+        }
+        const touchedPaths = validated.filter((v) => v.ok).map((v) => v.path);
+        const graphBefore = await effects.scanGraph();
+        for (const v of validated)
+            if (v.ok)
+                await effects.writeFile(v.path, v.content);
+        await effects.formatIfAvailable(touchedPaths);
+        // Green≠correct guard (a): exported-symbol surface diff.
+        const graphAfter = await effects.scanGraph();
+        const before = touchedPaths.map((p) => ({ file: p, exports: graphBefore.nodes.find((n) => n.file === p)?.exports ?? [] }));
+        const after = touchedPaths.map((p) => ({ file: p, exports: graphAfter.nodes.find((n) => n.file === p)?.exports ?? [] }));
+        const removals = diffExportedSymbols(before, after);
+        if (removals.length > 0 && !options.allowSymbolRemovals) {
+            for (const [p, content] of originals)
+                await effects.writeFile(p, content); // revert uncommitted writes
+            return {
+                status: 'escalated',
+                file,
+                reason: `exported-symbol removal requires --allow-symbol-removals: ${removals.map((r) => `${r.file}(${r.removedSymbols.join(',')})`).join('; ')}`,
+            };
+        }
+        const { sha } = await effects.git.commit(proposal.rationale, touchedPaths);
+        const checkRun = await effects.runCheck();
+        if (checkRun.verdict === 'error') {
+            return { status: 'escalated', file, reason: 'gate error during VERIFY — environmental, halting this group' };
+        }
+        const remaining = checkRun.gates.flatMap((g) => g.violations).filter((v) => touchedPaths.includes(v.file));
+        if (remaining.length === 0) {
+            return { status: 'done', file, commitSha: sha, rationale: proposal.rationale };
+        }
+        history.push(fingerprintOf(remaining));
+        attemptsSoFar += 1;
+        const decision = decideNextRepairAction(history, attemptsSoFar, options.maxAttempts);
+        await effects.git.revertCommit(sha);
+        if (decision.action !== 'retry')
+            return { status: 'escalated', file, reason: escalationFromDecision(decision) };
+        currentViolations = remaining;
+        previousFailure = undefined; // a "still red" retry is not an apply-mismatch retry
+    }
+}
+function renderPrSummary(doneGroups) {
+    const lines = ['## Violations fixed by `align agent run`', ''];
+    for (const g of doneGroups)
+        lines.push(`- \`${g.file}\` (${g.commitSha.slice(0, 7)}): ${g.rationale}`);
+    return `${lines.join('\n')}\n`;
+}
+async function performTerminalMerge(effects, options, groups) {
+    const doneGroups = groups.filter((g) => g.status === 'done');
+    if (doneGroups.length === 0)
+        return { status: 'no-commits' };
+    const rebase = await effects.git.rebaseOnto(options.baseBranch);
+    if (!rebase.ok)
+        return { status: 'rebase-conflict' };
+    const finalCheck = await effects.runCheck();
+    if (finalCheck.verdict !== 'green')
+        return { status: 'final-check-red', finalCheck };
+    if (options.mode === 'auto-merge') {
+        await effects.git.ffMergeAndDeleteBranch(options.workBranchName, options.baseBranch);
+        return { status: 'auto-merged' };
+    }
+    const summary = renderPrSummary(doneGroups);
+    const pushResult = await effects.git.push(options.workBranchName);
+    if (!pushResult.ok)
+        return { status: 'no-remote-or-no-gh', summary, branch: options.workBranchName };
+    const pr = await effects.git.createDraftPr({
+        branch: options.workBranchName,
+        base: options.baseBranch,
+        title: options.prTitle ?? `align: automated fixes (${options.workBranchName})`,
+        body: summary,
+    });
+    if (!pr.ok)
+        return { status: 'no-remote-or-no-gh', summary, branch: options.workBranchName };
+    return { status: 'pr-created', url: pr.url, summary };
+}
+/**
+ * Top-level entry point. `ruleset` is passed as data (not an effect) — it's already loaded by the
+ * CLI composition root exactly as `align check` loads it, and is needed only to build
+ * `ruleExplanations` (pure).
+ */
+export async function runAgentLoop(effects, ruleset, options) {
+    if (!(await effects.git.isWorktreeClean())) {
+        return { verdict: 'refused', refusalReason: 'dirty worktree — commit or stash changes before running the agent', groups: [] };
+    }
+    const initialCheck = await effects.runCheck();
+    if (initialCheck.verdict === 'error') {
+        return { verdict: 'refused', refusalReason: 'gate error on initial check — environmental, not fixable by the agent', groups: [], finalCheck: initialCheck };
+    }
+    const violations = initialCheck.gates.flatMap((g) => g.violations);
+    if (violations.length === 0) {
+        return { verdict: 'nothing-to-fix', groups: [], finalCheck: initialCheck };
+    }
+    const groupsMap = groupViolationsByFile(violations);
+    const explanations = ruleExplanationMap(ruleset);
+    if (options.dryRun) {
+        const groups = await planOnly(effects, groupsMap, explanations);
+        return { verdict: 'dry-run', groups };
+    }
+    await effects.git.createBranch(options.workBranchName);
+    const groups = [];
+    for (const [file, groupViolations] of groupsMap) {
+        groups.push(await runGroup(effects, file, groupViolations, explanations, options));
+    }
+    const anyEscalated = groups.some((g) => g.status === 'escalated');
+    const terminalMerge = await performTerminalMerge(effects, options, groups);
+    return { verdict: anyEscalated ? 'partial-escalated' : 'done', groups, terminalMerge };
+}
+export function defaultWorkBranchName(now = Date.now) {
+    const iso = new Date(now()).toISOString().slice(0, 10);
+    return `align/fixes-${iso}`;
+}
+//# sourceMappingURL=run.js.map