@syntesseraai/opencode-feature-factory 0.2.7 → 0.2.9

package/dist/discovery.js

@@ -1,4 +1,7 @@
-import { DEFAULT_QUALITY_GATE, fileExists, hasConfiguredCommands, readJsonFile, } from './quality-gate-config';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveCommands = resolveCommands;
+const quality_gate_config_1 = require("./quality-gate-config");
 // ============================================================================
 // Package Manager Detection
 // ============================================================================
@@ -11,15 +14,15 @@ async function detectPackageManager($, directory, override) {
         return override;
     }
     // Priority order: pnpm > bun > yarn > npm
-    if (await fileExists($, `${directory}/pnpm-lock.yaml`))
+    if (await (0, quality_gate_config_1.fileExists)($, `${directory}/pnpm-lock.yaml`))
         return 'pnpm';
-    if (await fileExists($, `${directory}/bun.lockb`))
+    if (await (0, quality_gate_config_1.fileExists)($, `${directory}/bun.lockb`))
         return 'bun';
-    if (await fileExists($, `${directory}/bun.lock`))
+    if (await (0, quality_gate_config_1.fileExists)($, `${directory}/bun.lock`))
         return 'bun';
-    if (await fileExists($, `${directory}/yarn.lock`))
+    if (await (0, quality_gate_config_1.fileExists)($, `${directory}/yarn.lock`))
         return 'yarn';
-    if (await fileExists($, `${directory}/package-lock.json`))
+    if (await (0, quality_gate_config_1.fileExists)($, `${directory}/package-lock.json`))
         return 'npm';
     return 'npm'; // fallback
 }
@@ -45,7 +48,7 @@ function buildRunCommand(pm, script) {
  * Discover Node.js lint/build/test commands from package.json scripts
  */
 async function discoverNodeCommands($, directory, pm) {
-    const pkgJson = await readJsonFile($, `${directory}/package.json`);
+    const pkgJson = await (0, quality_gate_config_1.readJsonFile)($, `${directory}/package.json`);
     if (!pkgJson?.scripts)
         return [];
     const scripts = pkgJson.scripts;
@@ -74,7 +77,7 @@ async function discoverNodeCommands($, directory, pm) {
  * Discover Rust commands from Cargo.toml presence
  */
 async function discoverRustCommands($, directory, includeClippy) {
-    if (!(await fileExists($, `${directory}/Cargo.toml`)))
+    if (!(await (0, quality_gate_config_1.fileExists)($, `${directory}/Cargo.toml`)))
         return [];
     const steps = [{ step: 'lint (fmt)', cmd: 'cargo fmt --check' }];
     if (includeClippy) {
@@ -94,7 +97,7 @@ async function discoverRustCommands($, directory, includeClippy) {
  * Discover Go commands from go.mod presence
  */
 async function discoverGoCommands($, directory) {
-    if (!(await fileExists($, `${directory}/go.mod`)))
+    if (!(await (0, quality_gate_config_1.fileExists)($, `${directory}/go.mod`)))
         return [];
     return [{ step: 'test', cmd: 'go test ./...' }];
 }
@@ -106,8 +109,8 @@ async function discoverGoCommands($, directory) {
  */
 async function discoverPythonCommands($, directory) {
     // Only add pytest if we have strong signal
-    const hasPytestIni = await fileExists($, `${directory}/pytest.ini`);
-    const hasPyproject = await fileExists($, `${directory}/pyproject.toml`);
+    const hasPytestIni = await (0, quality_gate_config_1.fileExists)($, `${directory}/pytest.ini`);
+    const hasPyproject = await (0, quality_gate_config_1.fileExists)($, `${directory}/pyproject.toml`);
     if (!hasPytestIni && !hasPyproject)
         return [];
     // pytest.ini is strong signal
@@ -142,11 +145,11 @@ async function discoverPythonCommands($, directory) {
  *
  * @returns Array of command steps to execute, or empty if nothing found
  */
-export async function resolveCommands(args) {
+async function resolveCommands(args) {
     const { $, directory, config } = args;
-    const mergedConfig = { ...DEFAULT_QUALITY_GATE, ...config };
+    const mergedConfig = { ...quality_gate_config_1.DEFAULT_QUALITY_GATE, ...config };
     // 1. Configured commands take priority (do NOT run ci.sh if these exist)
-    if (hasConfiguredCommands(config)) {
+    if ((0, quality_gate_config_1.hasConfiguredCommands)(config)) {
         const steps = [];
         const order = mergedConfig.steps;
         for (const stepName of order) {
@@ -160,14 +163,14 @@ export async function resolveCommands(args) {
     // 2. Feature Factory CI script (only if no configured commands)
     if (mergedConfig.useCiSh !== 'never') {
         const ciShPath = `${directory}/management/ci.sh`;
-        if (await fileExists($, ciShPath)) {
+        if (await (0, quality_gate_config_1.fileExists)($, ciShPath)) {
             return [{ step: 'ci', cmd: `bash ${ciShPath}` }];
         }
     }
     // 3. Conventional discovery (only if no ci.sh)
     const pm = await detectPackageManager($, directory, mergedConfig.packageManager);
     // Try Node first (most common)
-    if (await fileExists($, `${directory}/package.json`)) {
+    if (await (0, quality_gate_config_1.fileExists)($, `${directory}/package.json`)) {
         const nodeSteps = await discoverNodeCommands($, directory, pm);
         if (nodeSteps.length > 0)
             return nodeSteps;

package/dist/discovery.test.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Unit tests for discovery module
  *
@@ -7,6 +8,7 @@
  * Note: Most functions in discovery.ts require shell access ($) so they're
  * integration-tested elsewhere. This file tests the pure utility functions.
  */
+Object.defineProperty(exports, "__esModule", { value: true });
 // Re-implement buildRunCommand for testing since it's not exported
 function buildRunCommand(pm, script) {
     switch (pm) {
@@ -92,4 +94,3 @@ describe('PackageManager type', () => {
         });
     });
 });
-export {};

package/dist/index.d.ts

@@ -1,4 +1,6 @@
-import type { Plugin } from '@opencode-ai/plugin';
+import type { Plugin } from '@opencode-ai/plugin' with {
+    'resolution-mode': 'import'
+};
 export declare const SKILL_PATHS: {
     'ff-mini-plan': string;
     'ff-todo-management': string;

package/dist/index.js

@@ -1,12 +1,15 @@
-import { createQualityGateHooks } from './stop-quality-gate';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StopQualityGatePlugin = exports.AGENT_PATHS = exports.SKILL_PATHS = void 0;
+const stop_quality_gate_1 = require("./stop-quality-gate");
 // Export skill and agent paths for programmatic access
-export const SKILL_PATHS = {
+exports.SKILL_PATHS = {
     'ff-mini-plan': './skills/ff-mini-plan/SKILL.md',
     'ff-todo-management': './skills/ff-todo-management/SKILL.md',
     'ff-severity-classification': './skills/ff-severity-classification/SKILL.md',
     'ff-report-templates': './skills/ff-report-templates/SKILL.md',
 };
-export const AGENT_PATHS = {
+exports.AGENT_PATHS = {
     'ff-acceptance': './agents/ff-acceptance.md',
     'ff-review': './agents/ff-review.md',
     'ff-security': './agents/ff-security.md',
@@ -56,7 +59,7 @@ function resolveRootDir(input) {
  * - On failure: passes full CI output to LLM for fix instructions
  * - If management/ci.sh does not exist, quality gate does not run
  */
-export const StopQualityGatePlugin = async (input) => {
+const StopQualityGatePlugin = async (input) => {
     const { worktree, directory, client } = input;
     const rootDir = resolveRootDir({ worktree, directory });
     // Skip quality gate if no valid directory (e.g., global config with no project)
@@ -66,7 +69,7 @@ export const StopQualityGatePlugin = async (input) => {
     // Create quality gate hooks
     let qualityGateHooks = {};
     try {
-        qualityGateHooks = await createQualityGateHooks(input);
+        qualityGateHooks = await (0, stop_quality_gate_1.createQualityGateHooks)(input);
     }
     catch (error) {
         await log(client, 'error', 'quality-gate.init-error', {
@@ -77,5 +80,6 @@ export const StopQualityGatePlugin = async (input) => {
         ...qualityGateHooks,
     };
 };
+exports.StopQualityGatePlugin = StopQualityGatePlugin;
 // Default export for OpenCode plugin discovery
-export default StopQualityGatePlugin;
+exports.default = exports.StopQualityGatePlugin;

package/dist/output.js

@@ -1,3 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractErrorLines = extractErrorLines;
+exports.tailLines = tailLines;
 /**
  * Regex pattern for detecting error-like lines in command output
  */
@@ -10,7 +14,7 @@ const ERROR_PATTERNS = /(error|failed|failure|panic|assert|exception|traceback|T
  * @param maxLines - Maximum number of error lines to extract
  * @returns Array of error-like lines (up to maxLines)
  */
-export function extractErrorLines(output, maxLines) {
+function extractErrorLines(output, maxLines) {
     const lines = output.split('\n');
     const errorLines = [];
     for (let i = 0; i < lines.length && errorLines.length < maxLines; i++) {
@@ -37,7 +41,7 @@ export function extractErrorLines(output, maxLines) {
  * @param maxLines - Maximum number of lines to return
  * @returns Truncated output with notice, or full output if short enough
  */
-export function tailLines(output, maxLines) {
+function tailLines(output, maxLines) {
     const lines = output.split('\n');
     if (lines.length <= maxLines) {
         return output;

package/dist/output.test.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Unit tests for output module
  *
@@ -5,10 +6,11 @@
  * - extractErrorLines: extracts error-like lines from command output
  * - tailLines: returns last N lines with truncation notice
  */
-import { extractErrorLines, tailLines } from './output';
+Object.defineProperty(exports, "__esModule", { value: true });
+const output_1 = require("./output");
 describe('extractErrorLines', () => {
     it('should return empty array for empty input', () => {
-        expect(extractErrorLines('', 10)).toEqual([]);
+        expect((0, output_1.extractErrorLines)('', 10)).toEqual([]);
     });
     it('should return empty array when no errors found', () => {
         const output = `
@@ -16,7 +18,7 @@ Build started
 Compiling modules...
 Build completed successfully
 `;
-        expect(extractErrorLines(output, 10)).toEqual([]);
+        expect((0, output_1.extractErrorLines)(output, 10)).toEqual([]);
     });
     it('should extract lines containing "error"', () => {
         const output = `
@@ -24,7 +26,7 @@ Starting build
 error: Cannot find module 'missing'
 Build failed
 `;
-        const result = extractErrorLines(output, 10);
+        const result = (0, output_1.extractErrorLines)(output, 10);
         expect(result.some((line) => line.includes('error:'))).toBe(true);
     });
     it('should extract lines containing "Error" (case insensitive)', () => {
@@ -33,7 +35,7 @@ Running tests
 TypeError: undefined is not a function
   at test.js:10:5
 `;
-        const result = extractErrorLines(output, 10);
+        const result = (0, output_1.extractErrorLines)(output, 10);
         expect(result.some((line) => line.includes('TypeError'))).toBe(true);
     });
     it('should extract lines containing "failed"', () => {
@@ -42,7 +44,7 @@ Test suite: MyTests
 Test failed: should work correctly
 1 test failed
 `;
-        const result = extractErrorLines(output, 10);
+        const result = (0, output_1.extractErrorLines)(output, 10);
         expect(result.some((line) => line.toLowerCase().includes('failed'))).toBe(true);
     });
     it('should extract lines containing "FAILED"', () => {
@@ -50,7 +52,7 @@ Test failed: should work correctly
 Running: test_function
 FAILED test_function - assertion error
 `;
-        const result = extractErrorLines(output, 10);
+        const result = (0, output_1.extractErrorLines)(output, 10);
         expect(result.some((line) => line.includes('FAILED'))).toBe(true);
     });
     it('should extract lines containing "panic"', () => {
@@ -58,7 +60,7 @@ FAILED test_function - assertion error
 thread 'main' panicked at 'assertion failed'
 note: run with RUST_BACKTRACE=1
 `;
-        const result = extractErrorLines(output, 10);
+        const result = (0, output_1.extractErrorLines)(output, 10);
         expect(result.some((line) => line.includes('panic'))).toBe(true);
     });
     it('should extract lines containing "exception"', () => {
@@ -66,7 +68,7 @@ note: run with RUST_BACKTRACE=1
 Exception in thread "main" java.lang.NullPointerException
   at Main.main(Main.java:5)
 `;
-        const result = extractErrorLines(output, 10);
+        const result = (0, output_1.extractErrorLines)(output, 10);
         expect(result.some((line) => line.includes('Exception'))).toBe(true);
     });
     it('should extract lines containing "traceback"', () => {
@@ -75,7 +77,7 @@ Traceback (most recent call last):
   File "test.py", line 10
 NameError: name 'x' is not defined
 `;
-        const result = extractErrorLines(output, 10);
+        const result = (0, output_1.extractErrorLines)(output, 10);
         expect(result.some((line) => line.includes('Traceback'))).toBe(true);
     });
     it('should include 2 lines of context after error', () => {
@@ -84,7 +86,7 @@ error: something went wrong
 context line 1
 context line 2
 line5`;
-        const result = extractErrorLines(output, 10);
+        const result = (0, output_1.extractErrorLines)(output, 10);
         expect(result).toContain('error: something went wrong');
         expect(result).toContain('context line 1');
         expect(result).toContain('context line 2');
@@ -101,36 +103,36 @@ error: third error
 context5
 context6
 `;
-        const result = extractErrorLines(output, 5);
+        const result = (0, output_1.extractErrorLines)(output, 5);
         expect(result.length).toBeLessThanOrEqual(5);
     });
     it('should handle error at end of output without enough context lines', () => {
         const output = `line1
 line2
 error: final error`;
-        const result = extractErrorLines(output, 10);
+        const result = (0, output_1.extractErrorLines)(output, 10);
         expect(result).toContain('error: final error');
     });
     it('should extract ReferenceError', () => {
         const output = `ReferenceError: x is not defined`;
-        const result = extractErrorLines(output, 10);
+        const result = (0, output_1.extractErrorLines)(output, 10);
         expect(result).toContain('ReferenceError: x is not defined');
     });
     it('should extract SyntaxError', () => {
         const output = `SyntaxError: Unexpected token '}'`;
-        const result = extractErrorLines(output, 10);
+        const result = (0, output_1.extractErrorLines)(output, 10);
         expect(result).toContain("SyntaxError: Unexpected token '}'");
     });
     it('should extract ERR! (npm style errors)', () => {
         const output = `npm ERR! code ENOENT
 npm ERR! path /app/package.json`;
-        const result = extractErrorLines(output, 10);
+        const result = (0, output_1.extractErrorLines)(output, 10);
         expect(result.some((line) => line.includes('ERR!'))).toBe(true);
     });
     it('should extract FAIL (test runner style)', () => {
         const output = `FAIL src/test.ts
   Test suite failed to run`;
-        const result = extractErrorLines(output, 10);
+        const result = (0, output_1.extractErrorLines)(output, 10);
         expect(result.some((line) => line.includes('FAIL'))).toBe(true);
     });
     it('should extract multiple error types in same output', () => {
@@ -141,7 +143,7 @@ TypeError: Cannot read property 'x'
 FAILED: test_something
 Build process ended
 `;
-        const result = extractErrorLines(output, 20);
+        const result = (0, output_1.extractErrorLines)(output, 20);
         expect(result.some((line) => line.includes('error:'))).toBe(true);
         expect(result.some((line) => line.includes('TypeError'))).toBe(true);
         expect(result.some((line) => line.includes('FAILED'))).toBe(true);
@@ -150,15 +152,15 @@ Build process ended
 describe('tailLines', () => {
     it('should return full output when lines count is less than maxLines', () => {
         const output = 'line1\nline2\nline3';
-        expect(tailLines(output, 10)).toBe(output);
+        expect((0, output_1.tailLines)(output, 10)).toBe(output);
     });
     it('should return full output when lines count equals maxLines', () => {
         const output = 'line1\nline2\nline3';
-        expect(tailLines(output, 3)).toBe(output);
+        expect((0, output_1.tailLines)(output, 3)).toBe(output);
     });
     it('should truncate and add notice when output exceeds maxLines', () => {
         const output = 'line1\nline2\nline3\nline4\nline5';
-        const result = tailLines(output, 3);
+        const result = (0, output_1.tailLines)(output, 3);
         expect(result).toContain('... (2 lines truncated)');
         expect(result).toContain('line3');
         expect(result).toContain('line4');
@@ -168,38 +170,38 @@ describe('tailLines', () => {
     });
     it('should handle single line output', () => {
         const output = 'single line';
-        expect(tailLines(output, 5)).toBe('single line');
+        expect((0, output_1.tailLines)(output, 5)).toBe('single line');
     });
     it('should handle empty output', () => {
-        expect(tailLines('', 5)).toBe('');
+        expect((0, output_1.tailLines)('', 5)).toBe('');
     });
     it('should handle maxLines of 1', () => {
         const output = 'line1\nline2\nline3';
-        const result = tailLines(output, 1);
+        const result = (0, output_1.tailLines)(output, 1);
         expect(result).toContain('... (2 lines truncated)');
         expect(result).toContain('line3');
     });
     it('should correctly count truncated lines', () => {
         const lines = Array.from({ length: 100 }, (_, i) => `line${i + 1}`);
         const output = lines.join('\n');
-        const result = tailLines(output, 10);
+        const result = (0, output_1.tailLines)(output, 10);
         expect(result).toContain('... (90 lines truncated)');
     });
     it('should preserve line content in tail', () => {
         const output = 'first\nsecond\nthird\nfourth\nfifth';
-        const result = tailLines(output, 2);
+        const result = (0, output_1.tailLines)(output, 2);
         const resultLines = result.split('\n');
         expect(resultLines[resultLines.length - 1]).toBe('fifth');
         expect(resultLines[resultLines.length - 2]).toBe('fourth');
     });
     it('should handle output with empty lines', () => {
         const output = 'line1\n\nline3\n\nline5';
-        const result = tailLines(output, 3);
+        const result = (0, output_1.tailLines)(output, 3);
         expect(result).toContain('... (2 lines truncated)');
     });
     it('should handle output with only newlines', () => {
         const output = '\n\n\n\n';
-        const result = tailLines(output, 2);
+        const result = (0, output_1.tailLines)(output, 2);
         expect(result).toContain('... (3 lines truncated)');
     });
 });

package/dist/quality-gate-config.js

@@ -1,7 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_QUALITY_GATE = void 0;
+exports.readJsonFile = readJsonFile;
+exports.fileExists = fileExists;
+exports.mergeQualityGateConfig = mergeQualityGateConfig;
+exports.loadQualityGateConfig = loadQualityGateConfig;
+exports.hasConfiguredCommands = hasConfiguredCommands;
 /**
  * Default configuration values for StopQualityGate
  */
-export const DEFAULT_QUALITY_GATE = {
+exports.DEFAULT_QUALITY_GATE = {
     steps: ['lint', 'build', 'test'],
     useCiSh: 'auto',
     packageManager: 'auto',
@@ -15,7 +23,7 @@ export const DEFAULT_QUALITY_GATE = {
 /**
  * Read a JSON file safely, returning null if not found or invalid
  */
-export async function readJsonFile($, path) {
+async function readJsonFile($, path) {
     try {
         const result = await $ `cat ${path}`.quiet();
         return JSON.parse(result.text());
@@ -27,7 +35,7 @@ export async function readJsonFile($, path) {
 /**
  * Check if a file exists
  */
-export async function fileExists($, path) {
+async function fileExists($, path) {
     try {
         await $ `test -f ${path}`.quiet();
         return true;
@@ -42,7 +50,7 @@ export async function fileExists($, path) {
  * Precedence: `.opencode/opencode.json` overrides `opencode.json` (root).
  * Deep-merges nested objects like `include`.
  */
-export function mergeQualityGateConfig(root, dotOpencode) {
+function mergeQualityGateConfig(root, dotOpencode) {
     const base = root ?? {};
     const override = dotOpencode ?? {};
     return {
@@ -64,7 +72,7 @@ export function mergeQualityGateConfig(root, dotOpencode) {
  *
  * Merges ONLY the `qualityGate` key. `.opencode/opencode.json` takes precedence.
  */
-export async function loadQualityGateConfig($, directory) {
+async function loadQualityGateConfig($, directory) {
     const rootConfigPath = `${directory}/opencode.json`;
     const dotOpencodeConfigPath = `${directory}/.opencode/opencode.json`;
     const [rootJson, dotOpencodeJson] = await Promise.all([
@@ -79,6 +87,6 @@ export async function loadQualityGateConfig($, directory) {
  * Check if any explicit commands are configured (lint/build/test).
  * If so, these take priority over ci.sh and discovery.
  */
-export function hasConfiguredCommands(config) {
+function hasConfiguredCommands(config) {
     return !!(config.lint || config.build || config.test);
 }

package/dist/quality-gate-config.test.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Unit tests for quality-gate-config module
  *
@@ -6,21 +7,22 @@
  * - hasConfiguredCommands: checks if explicit commands are configured
  * - DEFAULT_QUALITY_GATE: verify default values
  */
-import { mergeQualityGateConfig, hasConfiguredCommands, DEFAULT_QUALITY_GATE, } from './quality-gate-config';
+Object.defineProperty(exports, "__esModule", { value: true });
+const quality_gate_config_1 = require("./quality-gate-config");
 describe('DEFAULT_QUALITY_GATE', () => {
     it('should have correct default values', () => {
-        expect(DEFAULT_QUALITY_GATE.steps).toEqual(['lint', 'build', 'test']);
-        expect(DEFAULT_QUALITY_GATE.useCiSh).toBe('auto');
-        expect(DEFAULT_QUALITY_GATE.packageManager).toBe('auto');
-        expect(DEFAULT_QUALITY_GATE.cacheSeconds).toBe(30);
-        expect(DEFAULT_QUALITY_GATE.maxOutputLines).toBe(160);
-        expect(DEFAULT_QUALITY_GATE.maxErrorLines).toBe(60);
-        expect(DEFAULT_QUALITY_GATE.include.rustClippy).toBe(true);
+        expect(quality_gate_config_1.DEFAULT_QUALITY_GATE.steps).toEqual(['lint', 'build', 'test']);
+        expect(quality_gate_config_1.DEFAULT_QUALITY_GATE.useCiSh).toBe('auto');
+        expect(quality_gate_config_1.DEFAULT_QUALITY_GATE.packageManager).toBe('auto');
+        expect(quality_gate_config_1.DEFAULT_QUALITY_GATE.cacheSeconds).toBe(30);
+        expect(quality_gate_config_1.DEFAULT_QUALITY_GATE.maxOutputLines).toBe(160);
+        expect(quality_gate_config_1.DEFAULT_QUALITY_GATE.maxErrorLines).toBe(60);
+        expect(quality_gate_config_1.DEFAULT_QUALITY_GATE.include.rustClippy).toBe(true);
     });
 });
 describe('mergeQualityGateConfig', () => {
     it('should return empty config when both inputs are undefined', () => {
-        const result = mergeQualityGateConfig(undefined, undefined);
+        const result = (0, quality_gate_config_1.mergeQualityGateConfig)(undefined, undefined);
         expect(result).toEqual({ include: {} });
     });
     it('should return root config when dotOpencode is undefined', () => {
@@ -28,7 +30,7 @@ describe('mergeQualityGateConfig', () => {
             lint: 'pnpm lint',
             cacheSeconds: 60,
         };
-        const result = mergeQualityGateConfig(root, undefined);
+        const result = (0, quality_gate_config_1.mergeQualityGateConfig)(root, undefined);
         expect(result).toEqual({ lint: 'pnpm lint', cacheSeconds: 60, include: {} });
     });
     it('should return dotOpencode config when root is undefined', () => {
@@ -36,7 +38,7 @@ describe('mergeQualityGateConfig', () => {
             build: 'npm run build',
             maxOutputLines: 200,
         };
-        const result = mergeQualityGateConfig(undefined, dotOpencode);
+        const result = (0, quality_gate_config_1.mergeQualityGateConfig)(undefined, dotOpencode);
         expect(result).toEqual({ build: 'npm run build', maxOutputLines: 200, include: {} });
     });
     it('should override root values with dotOpencode values', () => {
@@ -49,7 +51,7 @@ describe('mergeQualityGateConfig', () => {
             lint: 'npm run lint:strict',
             cacheSeconds: 60,
         };
-        const result = mergeQualityGateConfig(root, dotOpencode);
+        const result = (0, quality_gate_config_1.mergeQualityGateConfig)(root, dotOpencode);
         expect(result.lint).toBe('npm run lint:strict');
         expect(result.build).toBe('pnpm build');
         expect(result.cacheSeconds).toBe(60);
@@ -65,7 +67,7 @@ describe('mergeQualityGateConfig', () => {
                 rustClippy: true,
             },
         };
-        const result = mergeQualityGateConfig(root, dotOpencode);
+        const result = (0, quality_gate_config_1.mergeQualityGateConfig)(root, dotOpencode);
         expect(result.include?.rustClippy).toBe(true);
     });
     it('should preserve root include values not overridden by dotOpencode', () => {
@@ -78,7 +80,7 @@ describe('mergeQualityGateConfig', () => {
             lint: 'custom lint',
             // No include specified
         };
-        const result = mergeQualityGateConfig(root, dotOpencode);
+        const result = (0, quality_gate_config_1.mergeQualityGateConfig)(root, dotOpencode);
         expect(result.include?.rustClippy).toBe(true);
         expect(result.lint).toBe('custom lint');
     });
@@ -102,7 +104,7 @@ describe('mergeQualityGateConfig', () => {
             useCiSh: 'never',
             include: { rustClippy: true },
         };
-        const result = mergeQualityGateConfig(root, dotOpencode);
+        const result = (0, quality_gate_config_1.mergeQualityGateConfig)(root, dotOpencode);
         expect(result.lint).toBe('lint-override');
         expect(result.build).toBe('build-root');
         expect(result.test).toBe('test-root');
@@ -118,7 +120,7 @@ describe('mergeQualityGateConfig', () => {
 });
 describe('hasConfiguredCommands', () => {
     it('should return false for empty config', () => {
-        expect(hasConfiguredCommands({})).toBe(false);
+        expect((0, quality_gate_config_1.hasConfiguredCommands)({})).toBe(false);
     });
     it('should return false when only non-command properties are set', () => {
         const config = {
@@ -127,25 +129,25 @@ describe('hasConfiguredCommands', () => {
             useCiSh: 'always',
             packageManager: 'pnpm',
         };
-        expect(hasConfiguredCommands(config)).toBe(false);
+        expect((0, quality_gate_config_1.hasConfiguredCommands)(config)).toBe(false);
     });
     it('should return true when lint is configured', () => {
         const config = {
             lint: 'pnpm lint',
         };
-        expect(hasConfiguredCommands(config)).toBe(true);
+        expect((0, quality_gate_config_1.hasConfiguredCommands)(config)).toBe(true);
     });
     it('should return true when build is configured', () => {
         const config = {
             build: 'pnpm build',
         };
-        expect(hasConfiguredCommands(config)).toBe(true);
+        expect((0, quality_gate_config_1.hasConfiguredCommands)(config)).toBe(true);
     });
     it('should return true when test is configured', () => {
         const config = {
             test: 'pnpm test',
         };
-        expect(hasConfiguredCommands(config)).toBe(true);
+        expect((0, quality_gate_config_1.hasConfiguredCommands)(config)).toBe(true);
     });
     it('should return true when multiple commands are configured', () => {
         const config = {
@@ -153,12 +155,12 @@ describe('hasConfiguredCommands', () => {
             build: 'pnpm build',
             test: 'pnpm test',
         };
-        expect(hasConfiguredCommands(config)).toBe(true);
+        expect((0, quality_gate_config_1.hasConfiguredCommands)(config)).toBe(true);
     });
     it('should return false for empty string commands', () => {
         const config = {
             lint: '',
         };
-        expect(hasConfiguredCommands(config)).toBe(false);
+        expect((0, quality_gate_config_1.hasConfiguredCommands)(config)).toBe(false);
     });
 });

package/dist/stop-quality-gate.d.ts

@@ -1,4 +1,4 @@
-import type { PluginInput, Hooks } from '@opencode-ai/plugin';
+import type { PluginInput, Hooks } from '@opencode-ai/plugin' with { 'resolution-mode': 'import' };
 export declare const SECRET_PATTERNS: Array<{
     pattern: RegExp;
     replacement: string;

package/dist/stop-quality-gate.js

@@ -1,9 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SECRET_PATTERNS = void 0;
+exports.sanitizeOutput = sanitizeOutput;
+exports.truncateOutput = truncateOutput;
+exports.createQualityGateHooks = createQualityGateHooks;
 const SERVICE_NAME = 'feature-factory';
 const IDLE_DEBOUNCE_MS = 500;
 const CI_TIMEOUT_MS = 300000; // 5 minutes
 const SESSION_TTL_MS = 3600000; // 1 hour
 const CLEANUP_INTERVAL_MS = 600000; // 10 minutes
-export const SECRET_PATTERNS = [
+exports.SECRET_PATTERNS = [
     // AWS Access Key IDs
     { pattern: /AKIA[0-9A-Z]{16}/g, replacement: '[REDACTED_AWS_KEY]' },
     // GitHub Personal Access Tokens (classic)
@@ -67,9 +73,9 @@ export const SECRET_PATTERNS = [
  * Sanitizes CI output by redacting common secret patterns before sending to the LLM.
  * This helps prevent accidental exposure of sensitive information in prompts.
  */
-export function sanitizeOutput(output) {
+function sanitizeOutput(output) {
     let sanitized = output;
-    for (const { pattern, replacement } of SECRET_PATTERNS) {
+    for (const { pattern, replacement } of exports.SECRET_PATTERNS) {
         sanitized = sanitized.replace(pattern, replacement);
     }
     return sanitized;
@@ -78,7 +84,7 @@ export function sanitizeOutput(output) {
  * Truncates CI output to the last N lines to reduce prompt size and focus on relevant errors.
  * Adds a header indicating truncation if the output was longer than the limit.
  */
-export function truncateOutput(output, maxLines = 20) {
+function truncateOutput(output, maxLines = 20) {
     const lines = output.split('\n');
     if (lines.length <= maxLines) {
         return output;
@@ -154,7 +160,7 @@ async function log(client, level, message, extra) {
         return undefined;
     }
 }
-export async function createQualityGateHooks(input) {
+async function createQualityGateHooks(input) {
     const { client, $, directory } = input;
     async function ciShExists() {
         try {

package/dist/stop-quality-gate.test.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Unit tests for stop-quality-gate module
  *
@@ -5,7 +6,8 @@
  * - sanitizeOutput: redacts secrets from CI output
  * - isSessionReadOnly: determines if session has write permissions
  */
-import { sanitizeOutput, truncateOutput } from './stop-quality-gate';
+Object.defineProperty(exports, "__esModule", { value: true });
+const stop_quality_gate_1 = require("./stop-quality-gate");
 function isSessionReadOnly(permission) {
     if (!permission)
         return false;
@@ -15,178 +17,178 @@ describe('sanitizeOutput', () => {
     describe('AWS credentials', () => {
         it('should redact AWS Access Key IDs', () => {
             const input = 'Found credentials: AKIAIOSFODNN7EXAMPLE in config';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('Found credentials: [REDACTED_AWS_KEY] in config');
         });
         it('should redact multiple AWS keys', () => {
             const input = 'Key1: AKIAIOSFODNN7EXAMPLE Key2: AKIAI44QH8DHBEXAMPLE';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('Key1: [REDACTED_AWS_KEY] Key2: [REDACTED_AWS_KEY]');
         });
         it('should not redact partial AWS key patterns', () => {
             const input = 'AKIA123'; // Too short
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('AKIA123');
         });
     });
     describe('GitHub tokens', () => {
         it('should redact GitHub Personal Access Tokens (classic)', () => {
             const input = 'Using ghp_aBcDeFgHiJkLmNoPqRsTuVwXyZ0123456789';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('Using [REDACTED_GH_TOKEN]');
         });
         it('should redact GitHub Personal Access Tokens (fine-grained)', () => {
             const input = 'Using github_pat_11ABCDEFG_abcdefghijklmnopqrstuvwxyz';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('Using [REDACTED_GH_TOKEN]');
         });
         it('should redact GitHub OAuth tokens', () => {
             const input = 'oauth=gho_aBcDeFgHiJkLmNoPqRsTuVwXyZ0123456789';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('oauth=[REDACTED_GH_TOKEN]');
         });
         it('should redact GitHub App user-to-server tokens', () => {
             const input = 'Using ghu_aBcDeFgHiJkLmNoPqRsTuVwXyZ0123456789';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('Using [REDACTED_GH_TOKEN]');
         });
         it('should redact GitHub App server-to-server tokens', () => {
             const input = 'Using ghs_aBcDeFgHiJkLmNoPqRsTuVwXyZ0123456789';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('Using [REDACTED_GH_TOKEN]');
         });
         it('should not redact partial GitHub token patterns', () => {
             const input = 'ghp_abc'; // Too short
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('ghp_abc');
         });
     });
     describe('GitLab tokens', () => {
         it('should redact GitLab Personal Access Tokens', () => {
             const input = 'Using glpat-abcdefghij1234567890';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('Using [REDACTED_GITLAB_TOKEN]');
         });
         it('should redact GitLab tokens with hyphens', () => {
             const input = 'Using glpat-abc-def-ghi-jkl-mnop-qrs';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('Using [REDACTED_GITLAB_TOKEN]');
         });
         it('should not redact partial GitLab token patterns', () => {
             const input = 'glpat-short'; // Too short
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('glpat-short');
         });
     });
     describe('npm tokens', () => {
         it('should redact npm tokens', () => {
             const input = 'Using npm_aBcDeFgHiJkLmNoPqRsTuVwXyZ0123456789';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('Using [REDACTED_NPM_TOKEN]');
         });
         it('should not redact partial npm token patterns', () => {
             const input = 'npm_abc'; // Too short
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('npm_abc');
         });
     });
     describe('Bearer tokens', () => {
         it('should redact Bearer tokens', () => {
             const input = 'Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('Authorization: Bearer [REDACTED]');
         });
         it('should handle case-insensitive Bearer', () => {
             const input = 'bearer abc123-token.value';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('Bearer [REDACTED]');
         });
     });
     describe('API keys', () => {
         it('should redact api_key assignments', () => {
             const input = 'api_key=sk-1234567890abcdef';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('api_key=[REDACTED]');
         });
         it('should redact api-key with hyphen', () => {
             const input = 'api-key: my-secret-key';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('api_key=[REDACTED]');
         });
         it('should redact apikey without separator', () => {
             const input = 'apikey=abc123';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('api_key=[REDACTED]');
         });
         it('should redact quoted api keys', () => {
             const input = "api_key='secret-value'";
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('api_key=[REDACTED]');
         });
     });
     describe('tokens', () => {
         it('should redact token assignments with 8+ char values', () => {
             const input = 'token=ghp_xxxxxxxxxxxxxxxxxxxx';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('token=[REDACTED]');
         });
         it('should redact tokens plural with 8+ char values', () => {
             const input = 'tokens: secret12345';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('token=[REDACTED]');
         });
         it('should NOT redact token with short values (less than 8 chars)', () => {
             const input = 'token=abc123';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('token=abc123');
         });
         it('should NOT redact phrases like "token count: 5" (value too short)', () => {
             const input = 'token count: 5';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('token count: 5');
         });
         it('should NOT redact "token: abc" (value too short)', () => {
             const input = 'token: abc';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('token: abc');
         });
         it('should redact actual token values that are 8+ chars', () => {
             const input = 'token=abcd1234efgh';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('token=[REDACTED]');
         });
         it('should redact quoted tokens with 8+ char values', () => {
             const input = 'token="my-secret-token-value"';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('token=[REDACTED]');
         });
     });
     describe('passwords', () => {
         it('should redact password assignments', () => {
             const input = 'password=super-secret-123!';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('password=[REDACTED]');
         });
         it('should redact passwords plural', () => {
             const input = 'passwords: "admin123"';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('password=[REDACTED]');
         });
         it('should handle special characters in passwords', () => {
             const input = 'password=P@$$w0rd!#%';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('password=[REDACTED]');
         });
     });
     describe('generic secrets', () => {
         it('should redact secret assignments', () => {
             const input = 'secret=my-app-secret-key';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('secret=[REDACTED]');
         });
         it('should redact secrets plural', () => {
             const input = 'secrets: "confidential-data"';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('secret=[REDACTED]');
         });
     });
@@ -194,40 +196,40 @@ describe('sanitizeOutput', () => {
         it('should redact long base64-like strings', () => {
             const base64 = 'YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXoxMjM0NTY3ODk=';
             const input = `Encoded value: ${base64}`;
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('Encoded value: [REDACTED_BASE64]');
         });
         it('should not redact short base64 strings', () => {
             const input = 'Short: abc123';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('Short: abc123');
         });
         it('should redact base64 without padding', () => {
             const base64 = 'YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXoxMjM0NTY3ODkw';
-            const result = sanitizeOutput(base64);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(base64);
             expect(result).toBe('[REDACTED_BASE64]');
         });
         it('should redact base64 strings up to 500 chars (ReDoS prevention)', () => {
             // Generate a 500-char base64 string
             const base64 = 'A'.repeat(500);
-            const result = sanitizeOutput(base64);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(base64);
             expect(result).toBe('[REDACTED_BASE64]');
         });
         it('should handle base64 strings over 500 chars by matching only first 500 (ReDoS prevention)', () => {
             // Generate a 501-char base64 string - only first 500 chars match
             const base64 = 'A'.repeat(501);
-            const result = sanitizeOutput(base64);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(base64);
             // Pattern matches the first 500 chars, leaving 1 char behind
             expect(result).toBe('[REDACTED_BASE64]A');
         });
         it('should handle base64 at exactly 40 chars (minimum threshold)', () => {
             const base64 = 'A'.repeat(40);
-            const result = sanitizeOutput(base64);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(base64);
             expect(result).toBe('[REDACTED_BASE64]');
         });
         it('should NOT redact base64 strings under 40 chars', () => {
             const base64 = 'A'.repeat(39);
-            const result = sanitizeOutput(base64);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(base64);
             expect(result).toBe(base64);
         });
     });
@@ -238,7 +240,7 @@ describe('sanitizeOutput', () => {
         Auth: Bearer my-jwt-token
         password=admin123
       `;
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toContain('[REDACTED_AWS_KEY]');
             expect(result).toContain('Bearer [REDACTED]');
             expect(result).toContain('password=[REDACTED]');
@@ -252,28 +254,28 @@ describe('sanitizeOutput', () => {
             const input = `-----BEGIN RSA PRIVATE KEY-----
 MIIEowIBAAKCAQEA0Z3VS5JJcds3xfn/ygWyF8PbnGy
 -----END RSA PRIVATE KEY-----`;
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('[REDACTED_PRIVATE_KEY]');
         });
         it('should redact OpenSSH private keys', () => {
             const input = `-----BEGIN OPENSSH PRIVATE KEY-----
 b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAA
 -----END OPENSSH PRIVATE KEY-----`;
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('[REDACTED_PRIVATE_KEY]');
         });
         it('should redact EC private keys', () => {
             const input = `-----BEGIN EC PRIVATE KEY-----
 MHQCAQEEICg7E4NN6YPWoU6/FXa5ON6Pt6LKBfA8WL
 -----END EC PRIVATE KEY-----`;
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('[REDACTED_PRIVATE_KEY]');
         });
         it('should redact generic private keys', () => {
             const input = `-----BEGIN PRIVATE KEY-----
 MIIEvgIBADANBgkqhkiG9w0BAQEFAASC
 -----END PRIVATE KEY-----`;
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('[REDACTED_PRIVATE_KEY]');
         });
         it('should redact private keys embedded in output', () => {
@@ -282,7 +284,7 @@ MIIEvgIBADANBgkqhkiG9w0BAQEFAASC
 MIIEowIBAAKCAQEA0Z3VS5JJcds3xfn/ygWyF8PbnGy
 -----END RSA PRIVATE KEY-----
 Done loading.`;
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe(`Loading configuration...
 [REDACTED_PRIVATE_KEY]
 Done loading.`);
@@ -291,49 +293,49 @@ Done loading.`);
     describe('GCP credentials', () => {
         it('should redact GCP API keys', () => {
             const input = 'Using GCP key: AIzaSyDaGmWKa4JsXZ-HjGw7ISLn_3namBGewQe';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('Using GCP key: [REDACTED_GCP_KEY]');
         });
         it('should redact multiple GCP API keys', () => {
             const input = 'Key1: AIzaSyDaGmWKa4JsXZ-HjGw7ISLn_3namBGewQe Key2: AIzaSyB-1234567890abcdefghijklmnopqrstu';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('Key1: [REDACTED_GCP_KEY] Key2: [REDACTED_GCP_KEY]');
         });
         it('should not redact partial GCP API key patterns', () => {
             const input = 'AIza123'; // Too short
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('AIza123');
         });
         it('should redact GCP OAuth tokens', () => {
             const input = 'Authorization: ya29.a0AfH6SMBx-example-token-value_123';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('Authorization: [REDACTED_GCP_TOKEN]');
         });
         it('should redact GCP OAuth tokens with various characters', () => {
             const input = 'token=ya29.Gl-abc_XYZ-123';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('token=[REDACTED_GCP_TOKEN]');
         });
     });
     describe('Slack tokens', () => {
         it('should redact Slack bot tokens', () => {
             const input = 'SLACK_BOT_TOKEN=xoxb-123456789012-1234567890123-AbCdEfGhIjKlMnOpQrStUvWx';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('SLACK_BOT_TOKEN=[REDACTED_SLACK_TOKEN]');
         });
         it('should redact Slack user tokens', () => {
             const input = 'Using xoxp-123456789012-123456789012-123456789012-abcdef1234567890abcdef1234567890';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('Using [REDACTED_SLACK_TOKEN]');
         });
         it('should redact Slack app tokens', () => {
             const input = 'APP_TOKEN=xapp-1-A0123BCDEFG-1234567890123-abcdefghijklmnopqrstuvwxyz0123456789';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('APP_TOKEN=[REDACTED_SLACK_TOKEN]');
         });
         it('should redact Slack webhook URLs', () => {
             const input = 'Webhook: https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('Webhook: https://[REDACTED_SLACK_WEBHOOK]');
         });
         it('should redact multiple different Slack token types', () => {
@@ -342,7 +344,7 @@ Done loading.`);
         User: xoxp-789-012-def
         App: xapp-345-ghi
       `;
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toContain('[REDACTED_SLACK_TOKEN]');
             expect(result).not.toContain('xoxb-');
             expect(result).not.toContain('xoxp-');
@@ -353,100 +355,100 @@ Done loading.`);
         it('should redact Stripe live secret keys', () => {
             // 24 chars after sk_live_: 51ABC123DEF456GHI789JKLM
             const input = 'STRIPE_SECRET_KEY=sk_live_51ABC123DEF456GHI789JKLM';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('STRIPE_SECRET_KEY=[REDACTED_STRIPE_KEY]');
         });
         it('should redact Stripe test secret keys', () => {
             // 24 chars after sk_test_: 51ABC123DEF456GHI789JKLM
             const input = 'Using sk_test_51ABC123DEF456GHI789JKLM for testing';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('Using [REDACTED_STRIPE_KEY] for testing');
         });
         it('should redact Stripe live restricted keys', () => {
             // 24 chars after rk_live_: 51ABC123DEF456GHI789JKLM
             const input = 'RESTRICTED_KEY=rk_live_51ABC123DEF456GHI789JKLM';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('RESTRICTED_KEY=[REDACTED_STRIPE_KEY]');
         });
         it('should redact Stripe test restricted keys', () => {
             // 24 chars after rk_test_: 51ABC123DEF456GHI789JKLM
             const input = 'Using rk_test_51ABC123DEF456GHI789JKLM for testing';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('Using [REDACTED_STRIPE_KEY] for testing');
         });
         it('should not redact Stripe keys that are too short', () => {
             const input = 'sk_live_short'; // Less than 24 characters after prefix
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('sk_live_short');
         });
         it('should redact multiple Stripe keys', () => {
             // 24 chars after each prefix
             const input = 'Live: sk_live_51ABC123DEF456GHI789JKLM Test: sk_test_51XYZ789ABC123DEF456GHIJ';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('Live: [REDACTED_STRIPE_KEY] Test: [REDACTED_STRIPE_KEY]');
         });
         it('should redact long Stripe keys', () => {
             const input = 'sk_live_51ABC123DEF456GHI789JKLmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOP';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('[REDACTED_STRIPE_KEY]');
         });
     });
     describe('database connection strings', () => {
         it('should redact PostgreSQL connection strings', () => {
             const input = 'DATABASE_URL=postgres://admin:secretpass123@db.example.com:5432/mydb';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('DATABASE_URL=[REDACTED_CONNECTION_STRING]');
         });
         it('should redact MongoDB connection strings with +srv', () => {
             const input = 'Connecting to mongodb+srv://user:p@ssw0rd@cluster.mongodb.net/database';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('Connecting to [REDACTED_CONNECTION_STRING]');
         });
         it('should redact Redis connection strings', () => {
             const input = 'REDIS_URL=redis://default:myredispassword@redis.example.com:6379';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('REDIS_URL=[REDACTED_CONNECTION_STRING]');
         });
         it('should redact MySQL connection strings', () => {
             const input = 'mysql://root:rootpassword@localhost:3306/testdb';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('[REDACTED_CONNECTION_STRING]');
         });
         it('should redact rediss (TLS) connection strings', () => {
             const input = 'rediss://user:password@secure-redis.example.com:6380';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('[REDACTED_CONNECTION_STRING]');
         });
         it('should redact connection strings with URL-encoded passwords', () => {
             const input = 'mongodb://user:p%40ss%23word@host/db';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('[REDACTED_CONNECTION_STRING]');
         });
         it('should redact PostgreSQL with URL-encoded @ in password', () => {
             const input = 'postgres://admin:secret%40pass@db.example.com:5432/mydb';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('[REDACTED_CONNECTION_STRING]');
         });
         it('should redact connection strings with multiple URL-encoded characters', () => {
             const input = 'mysql://root:p%40ss%3Dw%26rd%21@localhost:3306/testdb';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('[REDACTED_CONNECTION_STRING]');
         });
         it('should redact MongoDB+srv with URL-encoded password', () => {
             const input = 'mongodb+srv://user:my%40complex%23pass@cluster.mongodb.net/database';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe('[REDACTED_CONNECTION_STRING]');
         });
     });
     describe('non-secret content', () => {
         it('should preserve normal log output', () => {
             const input = 'Build completed successfully in 2.5s';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe(input);
         });
         it('should preserve error messages without secrets', () => {
             const input = 'Error: Cannot find module "./missing-file"';
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe(input);
         });
         it('should preserve stack traces', () => {
@@ -455,7 +457,7 @@ Done loading.`);
           at Object.<anonymous> (/app/test.js:10:5)
           at Module._compile (internal/modules/cjs/loader.js:1085:14)
       `;
-            const result = sanitizeOutput(input);
+            const result = (0, stop_quality_gate_1.sanitizeOutput)(input);
             expect(result).toBe(input);
         });
     });
@@ -506,17 +508,17 @@ describe('isSessionReadOnly', () => {
 describe('truncateOutput', () => {
     it('should return output unchanged if under maxLines', () => {
         const input = 'line1\nline2\nline3';
-        expect(truncateOutput(input, 20)).toBe(input);
+        expect((0, stop_quality_gate_1.truncateOutput)(input, 20)).toBe(input);
     });
     it('should return output unchanged if exactly at maxLines', () => {
         const lines = Array.from({ length: 20 }, (_, i) => `line${i + 1}`);
         const input = lines.join('\n');
-        expect(truncateOutput(input, 20)).toBe(input);
+        expect((0, stop_quality_gate_1.truncateOutput)(input, 20)).toBe(input);
     });
     it('should truncate to last 20 lines by default', () => {
         const lines = Array.from({ length: 30 }, (_, i) => `line${i + 1}`);
         const input = lines.join('\n');
-        const result = truncateOutput(input);
+        const result = (0, stop_quality_gate_1.truncateOutput)(input);
         expect(result).toContain('... (10 lines omitted)');
         expect(result).toContain('line11');
         expect(result).toContain('line30');
@@ -526,7 +528,7 @@ describe('truncateOutput', () => {
     it('should truncate to custom maxLines', () => {
         const lines = Array.from({ length: 15 }, (_, i) => `line${i + 1}`);
         const input = lines.join('\n');
-        const result = truncateOutput(input, 5);
+        const result = (0, stop_quality_gate_1.truncateOutput)(input, 5);
         expect(result).toContain('... (10 lines omitted)');
         expect(result).toContain('line11');
         expect(result).toContain('line15');
@@ -534,15 +536,15 @@ describe('truncateOutput', () => {
     });
     it('should handle single line output', () => {
         const input = 'single line';
-        expect(truncateOutput(input, 20)).toBe(input);
+        expect((0, stop_quality_gate_1.truncateOutput)(input, 20)).toBe(input);
     });
     it('should handle empty output', () => {
-        expect(truncateOutput('', 20)).toBe('');
+        expect((0, stop_quality_gate_1.truncateOutput)('', 20)).toBe('');
     });
     it('should preserve line content exactly', () => {
         const lines = Array.from({ length: 25 }, (_, i) => `Error at line ${i + 1}: something failed`);
         const input = lines.join('\n');
-        const result = truncateOutput(input, 10);
+        const result = (0, stop_quality_gate_1.truncateOutput)(input, 10);
         expect(result).toContain('Error at line 16: something failed');
         expect(result).toContain('Error at line 25: something failed');
     });

package/dist/types.js

@@ -1 +1,2 @@
-export {};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,23 +1,14 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@syntesseraai/opencode-feature-factory",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "description": "OpenCode plugin for Feature Factory agents - provides sub-agents and skills for validation, review, security, and architecture assessment",
-  "type": "module",
   "license": "MIT",
   "main": "./dist/index.js",
-  "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "bin": {
     "ff-deploy": "./bin/ff-deploy.js"
   },
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "default": "./dist/index.js"
-    }
-  },
   "files": [
     "dist",
     "assets",
@@ -40,7 +31,7 @@
   ],
   "scripts": {},
   "dependencies": {
-    "@opencode-ai/plugin": "1.1.48"
+    "@opencode-ai/plugin": "1.1.36"
   },
   "devDependencies": {
     "@types/bun": "^1.2.6",