peaks-loop 4.0.0-beta.8 → 4.0.0-beta.9

package/dist/services/qa/browser-restart-detector.js

@@ -0,0 +1,138 @@
+/**
+ * Slice 2026-06-16-playwright-restart-loop — G1.
+ *
+ * BrowserRestartDetector
+ *
+ * Watches a stream of `mcp__playwright__browser_*` tool invocations
+ * (synthetic, fed in by tests or by the sub-agent-progress signal)
+ * and emits a halt signal when the model repeatedly tears down
+ * and re-spawns the browser context.
+ *
+ * The detector is intentionally simple and dependency-free:
+ *   - `record(event)` appends one event to a ring buffer.
+ *   - `shouldHalt()` returns true when >= `maxRestarts` close->navigate
+ *     pairs have occurred within `windowMs` of each other.
+ *   - `diagnostic()` renders the user-facing message.
+ *
+ * It does NOT call playwright MCP. It does NOT spawn processes. It
+ * only inspects the synthetic event log.
+ *
+ * R2 (per PRD): server-restart is a different MCP-level event;
+ * only `browser_close` followed by `browser_navigate` (or
+ * `browser_navigate` followed by `browser_close`, in either order)
+ * within `windowMs` counts as a restart. A standalone
+ * `browser_install` is not a tab close.
+ *
+ * Window: pairs are evaluated per (close_ts, navigate_ts) delta. The
+ * detector uses a sliding window of `windowMs` (default 30s, the
+ * PRD R4 default). Older events fall out of the window.
+ *
+ * Test seam: the test suite feeds a hand-rolled sequence of
+ * `BrowserEvent` objects; production will call `record` from the
+ * sub-agent-progress signal when it sees an
+ * `mcp__playwright__browser_*` invocation.
+ */
+const DEFAULT_MAX_RESTARTS = 3;
+const DEFAULT_WINDOW_MS = 30_000;
+/**
+ * Tools that count as "tab close" (PRD R2: distinguishes tab-close
+ * from server-restart). A close must be followed by a `browser_navigate`
+ * to count as a restart.
+ */
+const TAB_CLOSE_TOOLS = new Set(['browser_close']);
+/**
+ * Tools that count as "tab spawn" (resets context). The detector
+ * specifically tracks `browser_navigate` because the user-reported
+ * loop pattern is `browser_close` -> `browser_navigate` -> `browser_close`.
+ * Other browser tools (e.g. `browser_click`, `browser_screenshot`)
+ * are inert for restart counting.
+ */
+const TAB_SPAWN_TOOLS = new Set(['browser_navigate']);
+export class BrowserRestartDetector {
+    maxRestarts;
+    windowMs;
+    enabled;
+    events = [];
+    constructor(options = {}) {
+        this.maxRestarts = options.maxRestarts ?? DEFAULT_MAX_RESTARTS;
+        this.windowMs = options.windowMs ?? DEFAULT_WINDOW_MS;
+        this.enabled = options.enabled !== false;
+    }
+    /**
+     * Record a single browser event. Returns true when this event
+     * caused a restart count to increment (i.e. it was a navigate
+     * that paired with a prior close inside the window). Returns
+     * false for inert events.
+     */
+    record(event) {
+        if (!this.enabled)
+            return false;
+        this.events.push(event);
+        // Trim old events that fall outside the window relative to
+        // the LATEST event we have seen (not Date.now()). Tests feed
+        // synthetic 2026-06-16 timestamps; using Date.now() would drop
+        // everything. We only need a 2-event sliding window per pair,
+        // but keep more for the diagnostic.
+        const last = this.events[this.events.length - 1];
+        if (last === undefined)
+            return false;
+        const cutoff = Date.parse(last.ts) - this.windowMs;
+        while (this.events.length > 0) {
+            const first = this.events[0];
+            if (first === undefined)
+                break;
+            if (Date.parse(first.ts) >= cutoff)
+                break;
+            this.events.shift();
+        }
+        return false;
+    }
+    /**
+     * Count of close->navigate pairs detected within the window. A
+     * pair is one `browser_close` followed by a `browser_navigate`
+     * within `windowMs` of each other.
+     */
+    restartCount() {
+        if (!this.enabled)
+            return 0;
+        let count = 0;
+        let pendingCloseTs = null;
+        // Walk in chronological order (the contract is: events are
+        // pushed in order; if not, the worst case is a missed pair
+        // which is still conservative).
+        for (const ev of this.events) {
+            const t = Date.parse(ev.ts);
+            if (TAB_CLOSE_TOOLS.has(ev.tool)) {
+                pendingCloseTs = t;
+                continue;
+            }
+            if (TAB_SPAWN_TOOLS.has(ev.tool)) {
+                if (pendingCloseTs !== null) {
+                    const delta = t - pendingCloseTs;
+                    if (delta >= 0 && delta <= this.windowMs) {
+                        count += 1;
+                        // Reset so we don't double-count. The next close must
+                        // re-arm the pending state.
+                        pendingCloseTs = null;
+                        continue;
+                    }
+                }
+                // A navigate WITHOUT a preceding close is a normal
+                // session start, not a restart.
+                pendingCloseTs = null;
+            }
+        }
+        return count;
+    }
+    shouldHalt() {
+        return this.restartCount() >= this.maxRestarts;
+    }
+    /**
+     * Returns the human-readable diagnostic the user will see when
+     * `shouldHalt` flips to true. Format: AC1 contract.
+     */
+    diagnostic() {
+        const count = this.restartCount();
+        return `playwright browser restart loop detected (${count} restarts in this slice). Reusing the same browser tab is the intended pattern. See .peaks/memory/playwright-restart-loop-2026-06-16.md`;
+    }
+}

package/dist/services/qa/browser-reuse-hint.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Slice 2026-06-16-playwright-restart-loop — G2.
+ *
+ * The browser-context reuse hint is appended to the sub-agent prompt
+ * whenever a peaks-qa-dispatched sub-agent (peaks-ui or general-purpose
+ * with a browser-E2E role) is invoked. The hint tells the model to
+ * keep one browser tab alive across the QA slice and to NOT call
+ * `browser_close` between steps.
+ *
+ * The constant lives here so both the dispatch CLI
+ * (`src/cli/commands/sub-agent-commands.ts`) and any future
+ * SKILL.md / dispatch table can reference the SAME string. Drift
+ * between "the detector knows X" and "the dispatch prompt says X"
+ * is the most common bug in this slice, so a single source of
+ * truth is non-negotiable.
+ */
+export declare const BROWSER_REUSE_HINT = "reuse existing browser tab; do NOT call mcp__playwright__browser_close between steps within this slice \u2014 closing and re-opening the tab repeatedly is a restart loop and will be halted by the slice guard";
+export declare const BROWSER_RESTART_LOOP_MEMORY_PATH = ".peaks/memory/playwright-restart-loop-2026-06-16.md";

package/dist/services/qa/browser-reuse-hint.js

@@ -0,0 +1,18 @@
+/**
+ * Slice 2026-06-16-playwright-restart-loop — G2.
+ *
+ * The browser-context reuse hint is appended to the sub-agent prompt
+ * whenever a peaks-qa-dispatched sub-agent (peaks-ui or general-purpose
+ * with a browser-E2E role) is invoked. The hint tells the model to
+ * keep one browser tab alive across the QA slice and to NOT call
+ * `browser_close` between steps.
+ *
+ * The constant lives here so both the dispatch CLI
+ * (`src/cli/commands/sub-agent-commands.ts`) and any future
+ * SKILL.md / dispatch table can reference the SAME string. Drift
+ * between "the detector knows X" and "the dispatch prompt says X"
+ * is the most common bug in this slice, so a single source of
+ * truth is non-negotiable.
+ */
+export const BROWSER_REUSE_HINT = 'reuse existing browser tab; do NOT call mcp__playwright__browser_close between steps within this slice — closing and re-opening the tab repeatedly is a restart loop and will be halted by the slice guard';
+export const BROWSER_RESTART_LOOP_MEMORY_PATH = '.peaks/memory/playwright-restart-loop-2026-06-16.md';

package/dist/services/qa/browser-wrapper-service.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Slice 3 — `peaks browser action <intent> [args...]` thin wrapper.
+ *
+ * Five supported intents: navigate, click, fill, snapshot, extract.
+ * Each intent invokes EXACTLY ONE Playwright MCP tool call. No auto
+ * snapshots between intents, no retry, no selector caching, no healing.
+ *
+ * Anti-features (per slice 3 spec):
+ *   - No retry / circuit-breaker
+ *   - No selector caching
+ *   - No accessibility tree customization
+ *   - No screenshot / video
+ *   - No "smart selector healing"
+ *
+ * Selectors are restricted to simple forms (`#id`, `.class`, `tag#id`,
+ * `tag.class`, `tag`). Anything else returns a fall-back error pointing
+ * the caller to the raw MCP.
+ */
+export type BrowserIntent = 'navigate' | 'click' | 'fill' | 'snapshot' | 'extract';
+export type McpCaller = (tool: string, args: Record<string, unknown>) => Promise<unknown>;
+export interface BrowserActionArgs {
+    url?: string | undefined;
+    selector?: string | undefined;
+    value?: string | undefined;
+    expression?: string | undefined;
+}
+export interface BrowserActionResult {
+    readonly intent: BrowserIntent;
+    readonly ok: boolean;
+    readonly data: unknown;
+    readonly elapsedMs: number;
+}
+/**
+ * Run a single browser intent. Throws on validation errors; returns
+ * a structured result on success.
+ */
+export declare function runBrowserAction(intent: BrowserIntent, args: BrowserActionArgs, caller: McpCaller): Promise<BrowserActionResult>;

package/dist/services/qa/browser-wrapper-service.js

@@ -0,0 +1,88 @@
+/**
+ * Slice 3 — `peaks browser action <intent> [args...]` thin wrapper.
+ *
+ * Five supported intents: navigate, click, fill, snapshot, extract.
+ * Each intent invokes EXACTLY ONE Playwright MCP tool call. No auto
+ * snapshots between intents, no retry, no selector caching, no healing.
+ *
+ * Anti-features (per slice 3 spec):
+ *   - No retry / circuit-breaker
+ *   - No selector caching
+ *   - No accessibility tree customization
+ *   - No screenshot / video
+ *   - No "smart selector healing"
+ *
+ * Selectors are restricted to simple forms (`#id`, `.class`, `tag#id`,
+ * `tag.class`, `tag`). Anything else returns a fall-back error pointing
+ * the caller to the raw MCP.
+ */
+// Simple selectors only: `#id`, `.class`, `tag`, `tag#id`, `tag.class`.
+// Anything else (xpath, attribute, pseudo-class chains, descendants) →
+// fall back to raw MCP.
+const SIMPLE_SELECTOR = /^([a-zA-Z][a-zA-Z0-9-]*)?([#.][a-zA-Z][a-zA-Z0-9_-]*)?$/;
+/**
+ * Run a single browser intent. Throws on validation errors; returns
+ * a structured result on success.
+ */
+export async function runBrowserAction(intent, args, caller) {
+    const start = Date.now();
+    const tool = toolFor(intent, args);
+    const data = await caller(tool.name, tool.args);
+    return {
+        intent,
+        ok: true,
+        data,
+        elapsedMs: Date.now() - start
+    };
+}
+function toolFor(intent, args) {
+    switch (intent) {
+        case 'navigate': {
+            if (typeof args.url !== 'string' || args.url.length === 0) {
+                throw new Error('navigate requires a non-empty --url');
+            }
+            return { name: 'mcp__playwright__browser_navigate', args: { url: args.url } };
+        }
+        case 'click': {
+            assertSimpleSelector(args.selector);
+            return {
+                name: 'mcp__playwright__browser_click',
+                args: { selector: args.selector }
+            };
+        }
+        case 'fill': {
+            assertSimpleSelector(args.selector);
+            if (typeof args.value !== 'string') {
+                throw new Error('fill requires both --selector and --value');
+            }
+            return {
+                name: 'mcp__playwright__browser_fill_form',
+                args: { fields: [{ selector: args.selector, value: args.value }] }
+            };
+        }
+        case 'snapshot': {
+            return { name: 'mcp__playwright__browser_snapshot', args: {} };
+        }
+        case 'extract': {
+            if (typeof args.expression !== 'string' || args.expression.length === 0) {
+                throw new Error('extract requires a non-empty --expression');
+            }
+            return {
+                name: 'mcp__playwright__browser_evaluate',
+                args: { function: args.expression }
+            };
+        }
+        default: {
+            const exhaustive = intent;
+            throw new Error(`unknown intent "${String(exhaustive)}" — fall back to raw MCP`);
+        }
+    }
+}
+function assertSimpleSelector(selector) {
+    if (typeof selector !== 'string' || selector.length === 0) {
+        throw new Error('selector is required (fall back to raw MCP for complex selectors)');
+    }
+    if (!SIMPLE_SELECTOR.test(selector)) {
+        throw new Error(`selector "${selector}" is not a simple selector — fall back to raw MCP`);
+    }
+}

package/dist/services/qa/qa-business-review-state.d.ts

@@ -0,0 +1,47 @@
+/**
+ * v2.15.0 follow-up — G5: QA business-perspective review state.
+ *
+ * Similar in shape to G1 (slice review) but lives on the QA side and
+ * uses the 6-item business checklist from the 12 Gaps positioning
+ * memory. Technical verification (coverage / P99 / security scan) is
+ * AI auto-decided in `peaks-rd`'s fan-out; QA only records what the
+ * user (business / product reviewer) sees.
+ *
+ * Persistence: `.peaks/_runtime/<sid>/qa-business-reviews/<rid>.json`.
+ *
+ *   6 items: business-flow / req-coverage / boundary-cases / ui-assembly /
+ *            exception-tone / mergeable
+ *   decision: pending | accepted | rejected
+ *   threshold: avg >= 3 AND no item <= 2 (same as G1)
+ */
+export type QaReviewDecision = 'pending' | 'accepted' | 'rejected';
+export interface QaReviewItem {
+    readonly id: string;
+    readonly question: string;
+    readonly score: number | null;
+    readonly note?: string;
+}
+export interface QaBusinessReview {
+    readonly requestId: string;
+    readonly sessionId: string;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    readonly decision: QaReviewDecision;
+    readonly items: readonly QaReviewItem[];
+    readonly rejectionReason?: string;
+}
+/** 6-item business checklist (12 Gaps QA perspective). */
+export declare const QA_BUSINESS_ITEMS: readonly {
+    id: string;
+    question: string;
+}[];
+export declare function buildEmptyQaReview(requestId: string, sessionId: string, now?: Date): QaBusinessReview;
+export declare function getQaReviewDir(projectRoot: string, sessionId: string): string;
+export declare function getQaReviewPath(projectRoot: string, sessionId: string, requestId: string): string;
+export declare function readQaReview(projectRoot: string, sessionId: string, requestId: string): QaBusinessReview | null;
+export declare function writeQaReview(projectRoot: string, review: QaBusinessReview): void;
+export declare function scoreQaItem(review: QaBusinessReview, itemId: string, score: number, note?: string, now?: Date): QaBusinessReview;
+export declare function averageQaScore(review: QaBusinessReview): number | null;
+export declare function deriveQaDecision(review: QaBusinessReview): QaReviewDecision;
+export declare function acceptQaReview(review: QaBusinessReview, now?: Date): QaBusinessReview;
+export declare function rejectQaReview(review: QaBusinessReview, reason: string, now?: Date): QaBusinessReview;

package/dist/services/qa/qa-business-review-state.js

@@ -0,0 +1,96 @@
+/**
+ * v2.15.0 follow-up — G5: QA business-perspective review state.
+ *
+ * Similar in shape to G1 (slice review) but lives on the QA side and
+ * uses the 6-item business checklist from the 12 Gaps positioning
+ * memory. Technical verification (coverage / P99 / security scan) is
+ * AI auto-decided in `peaks-rd`'s fan-out; QA only records what the
+ * user (business / product reviewer) sees.
+ *
+ * Persistence: `.peaks/_runtime/<sid>/qa-business-reviews/<rid>.json`.
+ *
+ *   6 items: business-flow / req-coverage / boundary-cases / ui-assembly /
+ *            exception-tone / mergeable
+ *   decision: pending | accepted | rejected
+ *   threshold: avg >= 3 AND no item <= 2 (same as G1)
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+/** 6-item business checklist (12 Gaps QA perspective). */
+export const QA_BUSINESS_ITEMS = [
+    { id: 'business-flow', question: '这个功能"用起来"对吗?(业务流程顺不顺,操作路径是否反人类,跟现有系统交互有没有断层)' },
+    { id: 'req-coverage', question: '老板提的需求都覆盖了吗?(大需求点 vs 小需求点,显式需求 vs 隐式需求)' },
+    { id: 'boundary-cases', question: '边界 case 跟业务预期一致吗?(异常输入 / 错误提示用户语言 / 空加载失败状态)' },
+    { id: 'ui-assembly', question: '页面模式 / 关键交互 / 信息密度 跟产品预期一致吗?(装配验收,非视觉设计)' },
+    { id: 'exception-tone', question: '异常态 / 边界态视觉跟产品语调一致吗?(空状态有引导 / 加载态不闪烁 / 失败态有重试入口)' },
+    { id: 'mergeable', question: '能合入下个小版本吗?(业务风险 / 用户体验风险 / 集成断点)' }
+];
+export function buildEmptyQaReview(requestId, sessionId, now = new Date()) {
+    return {
+        requestId,
+        sessionId,
+        createdAt: now.toISOString(),
+        updatedAt: now.toISOString(),
+        decision: 'pending',
+        items: QA_BUSINESS_ITEMS.map((it) => ({ id: it.id, question: it.question, score: null }))
+    };
+}
+export function getQaReviewDir(projectRoot, sessionId) {
+    return resolve(projectRoot, '.peaks', '_runtime', sessionId, 'qa-business-reviews');
+}
+export function getQaReviewPath(projectRoot, sessionId, requestId) {
+    return join(getQaReviewDir(projectRoot, sessionId), `${requestId}.json`);
+}
+export function readQaReview(projectRoot, sessionId, requestId) {
+    const path = getQaReviewPath(projectRoot, sessionId, requestId);
+    if (!existsSync(path))
+        return null;
+    try {
+        return JSON.parse(readFileSync(path, 'utf8'));
+    }
+    catch (err) {
+        console.warn(`readQaReview: failed to read or parse ${path}: ${err.message}`);
+        return null;
+    }
+}
+export function writeQaReview(projectRoot, review) {
+    const path = getQaReviewPath(projectRoot, review.sessionId, review.requestId);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(review, null, 2), 'utf8');
+}
+export function scoreQaItem(review, itemId, score, note, now = new Date()) {
+    let found = false;
+    const items = review.items.map((it) => {
+        if (it.id !== itemId)
+            return it;
+        found = true;
+        return { id: it.id, question: it.question, score, ...(note !== undefined ? { note } : {}) };
+    });
+    if (!found)
+        return review;
+    return { ...review, items, updatedAt: now.toISOString() };
+}
+export function averageQaScore(review) {
+    const scored = review.items.filter((it) => it.score !== null);
+    if (scored.length === 0)
+        return null;
+    return scored.reduce((sum, it) => sum + it.score, 0) / scored.length;
+}
+export function deriveQaDecision(review) {
+    if (review.items.some((it) => it.score === 1))
+        return 'rejected';
+    const avg = averageQaScore(review);
+    if (avg === null)
+        return 'pending';
+    if (avg < 3)
+        return 'rejected';
+    if (review.items.some((it) => it.score !== null && it.score <= 2))
+        return 'rejected';
+    return 'accepted';
+}
+export function acceptQaReview(review, now = new Date()) {
+    return { ...review, decision: 'accepted', updatedAt: now.toISOString() };
+}
+export function rejectQaReview(review, reason, now = new Date()) {
+    return { ...review, decision: 'rejected', rejectionReason: reason, updatedAt: now.toISOString() };
+}

package/dist/services/rd/ast-gate.d.ts

@@ -0,0 +1,19 @@
+import type { AstGateResult } from './types.js';
+export interface AstGateContext {
+    readonly deps: Readonly<Record<string, {
+        readonly version: string;
+        readonly source: string;
+        readonly resolved: string;
+    }>>;
+    readonly docSummaries: ReadonlyArray<{
+        readonly dep: string;
+        readonly version: string;
+        readonly apis: ReadonlyArray<string>;
+    }>;
+}
+export interface RunAstGateInput {
+    readonly project: string;
+    readonly changedFiles: ReadonlyArray<string>;
+    readonly context: AstGateContext;
+}
+export declare function runAstGate(input: RunAstGateInput): Promise<AstGateResult>;

package/dist/services/rd/ast-gate.js

@@ -0,0 +1,71 @@
+/**
+ * Per spec §4.2 战术审计 — AST hard gate.
+ *
+ * Hard constraints:
+ *   H6 (CLI裁决): gate result is computed by AST analysis, not LLM.
+ *   H2 (locked version): any external API call whose name is NOT in the
+ *       locked-version doc summary fails the gate.
+ *
+ * Implementation: TypeScript Compiler API for import + call expression
+ * extraction. v1 uses regex for speed; production wiring migrates to
+ * the Compiler API for accuracy.
+ */
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+const IMPORT_RE = /import\s*\{([^}]+)\}\s*from\s*['"]([^'"]+)['"]/g;
+const CALL_RE = /\b([a-zA-Z_$][\w$]*)\s*\(/g;
+export async function runAstGate(input) {
+    const violations = [];
+    const externalCalls = [];
+    for (const file of input.changedFiles) {
+        const fullPath = join(input.project, file);
+        let content;
+        try {
+            content = await readFile(fullPath, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        // Find imports from external deps.
+        const imports = [...content.matchAll(IMPORT_RE)];
+        const importMap = new Map(); // localName -> depName
+        for (const imp of imports) {
+            const depName = imp[2];
+            if (input.context.deps[depName] === undefined)
+                continue; // not an external dep
+            const names = imp[1].split(',').map((n) => n.trim().split(/\s+as\s+/)[0]);
+            for (const n of names) {
+                if (n)
+                    importMap.set(n, depName);
+            }
+        }
+        // Find call expressions that match imported names.
+        const calls = [...content.matchAll(CALL_RE)];
+        for (const c of calls) {
+            const name = c[1];
+            const dep = importMap.get(name);
+            if (!dep)
+                continue;
+            const idx = c.index ?? 0;
+            const line = content.slice(0, idx).split('\n').length;
+            const depVersion = input.context.deps[dep]?.version ?? '';
+            const docSummary = input.context.docSummaries.find((d) => d.dep === dep && d.version === depVersion);
+            const apis = docSummary?.apis ?? [];
+            externalCalls.push({ file, line, api: name, version: depVersion });
+            if (apis.length > 0 && !apis.includes(name)) {
+                violations.push({
+                    file,
+                    line,
+                    api: name,
+                    expectedVersion: depVersion,
+                    actualVersion: 'unknown', // could resolve via npm view if needed
+                    severity: 'error',
+                });
+            }
+        }
+    }
+    return {
+        passed: violations.length === 0,
+        violations,
+    };
+}

package/dist/services/rd/impl.d.ts

@@ -0,0 +1,9 @@
+import { type AstGateResult, type ExternalApiCall, type ImplOutput } from './types.js';
+export interface WriteImplInput {
+    readonly out: string;
+    readonly inputSig: string;
+    readonly changedFiles: ReadonlyArray<string>;
+    readonly externalApiCalls: ReadonlyArray<ExternalApiCall>;
+    readonly astGate: AstGateResult;
+}
+export declare function writeImpl(input: WriteImplInput): Promise<ImplOutput>;

package/dist/services/rd/impl.js

@@ -0,0 +1,57 @@
+/**
+ * Per spec §4.3 战术审计 (peaks-rd/战术) — impl.json writer + TACT.sig computation.
+ * Spec anchor: docs/superpowers/specs/2026-06-21-context-audit-redesign-design.md §4.3
+ * (R1-W3 consolidation; previously referenced as §4.2 which is `peaks-mut`).
+ *
+ * Hard constraints:
+ *   H8 (audit trail hashable): TACT.sig chains from STRAT.sig via inputSig.
+ *   H6 (CLI裁决): refuses to write when AST gate has violations —
+ *       LLM MUST auto-fix and re-run.
+ */
+import { createHash } from 'node:crypto';
+import { writeFile, rename, unlink } from 'node:fs/promises';
+import { ImplOutputSchema } from './types.js';
+function sha256Of(content) {
+    const { sha256: _omit, ...rest } = content;
+    void _omit;
+    const canonical = JSON.stringify(rest, Object.keys(rest).sort());
+    return createHash('sha256').update(canonical).digest('hex');
+}
+export async function writeImpl(input) {
+    // Defense-in-depth: passed flag and violations[] must agree.
+    // A caller passing passed=true with non-empty violations (lying input)
+    // would otherwise bypass the gate. Both checks are load-bearing.
+    if (!input.astGate.passed) {
+        throw new Error(`BLOCKED: AST gate failed — ${input.astGate.violations.length} violations. ` +
+            'LLM MUST auto-fix and re-run before TACT.sig can be written. ' +
+            '(spec §4.2 战术审计)');
+    }
+    if (input.astGate.violations.length > 0) {
+        throw new Error(`BLOCKED: AST gate state is inconsistent — passed=true but ` +
+            `${input.astGate.violations.length} violations present. ` +
+            'Refusing to write TACT.sig to prevent gate bypass. ' +
+            '(impl.ts: defense-in-depth check, audit R2-W2)');
+    }
+    const partial = {
+        version: '1.0',
+        sha256: '',
+        generatedAt: new Date().toISOString(),
+        inputSig: input.inputSig,
+        changedFiles: [...input.changedFiles],
+        externalApiCalls: [...input.externalApiCalls],
+        astGateResult: input.astGate,
+    };
+    const sha256 = sha256Of(partial);
+    const final = { ...partial, sha256 };
+    ImplOutputSchema.parse(final);
+    const tmp = `${input.out}.tmp`;
+    try {
+        await writeFile(tmp, JSON.stringify(final, null, 2), 'utf8');
+        await rename(tmp, input.out);
+    }
+    catch (err) {
+        await unlink(tmp).catch(() => undefined);
+        throw err;
+    }
+    return final;
+}