@gobing-ai/knowledge-kit 0.0.13 → 0.0.14

package/plugins/sp/scripts/task-evidence-precheck.ts

@@ -0,0 +1,181 @@
+#!/usr/bin/env bun
+/**
+ * task-evidence-precheck — deterministic evidence-channel precheck (R2, task 0726).
+ *
+ * Parses the task content for an exact `evidence-channel:` declaration and proves the
+ * declared live-data channel exists in the local spur database before implementation
+ * begins. Currently exactly one channel is allowlisted:
+ *
+ *   evidence-channel: history_tool_call.args_raw[pi]
+ *
+ * …satisfied only when the fixed query
+ *
+ *   SELECT COUNT(*) FROM history_tool_call WHERE args_raw IS NOT NULL AND source = 'pi'
+ *
+ * returns a positive count on `<cwd>/.spur/spur.db` — i.e. a live non-dry-run pi import
+ * has already preserved tool-call `args_raw` (0722 R1). Unknown declarations, a missing
+ * database, a missing table, and a zero count all fail closed.
+ *
+ * A task without any `evidence-channel:` declaration passes without opening SQLite —
+ * the check only gates tasks that declare a live-data evidence channel.
+ *
+ * Always exits 0 (soft action). Both precheck→implement guards in task-pipeline.yaml
+ * read the status file; a missing or failing checker writes FAIL, so readiness fails
+ * closed.
+ *
+ * Ships with the plugin to arbitrary projects; node-builtin + bun:sqlite only —
+ * no workspace imports.
+ *
+ * Usage:
+ *   bun plugins/sp/scripts/task-evidence-precheck.ts <wbs> [--spur-bin <path>]
+ *
+ * Env: SPUR_BIN
+ */
+
+import { Database } from 'bun:sqlite';
+import { execFileSync } from 'node:child_process';
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+/** Exact task-content declaration that activates the live-evidence gate (0726 R2). */
+const DECLARATION_PREFIX = 'evidence-channel:';
+
+/** The only allowlisted live-data channel (0726 R2). */
+const EVIDENCE_CHANNEL = 'history_tool_call.args_raw[pi]';
+
+/** Declaration text as it must appear in the task body. */
+const DECLARATION = `${DECLARATION_PREFIX} ${EVIDENCE_CHANNEL}`;
+
+/** The only live-data query this precheck is allowed to run — fixed, never task-authored. */
+const EVIDENCE_QUERY = "SELECT COUNT(*) AS n FROM history_tool_call WHERE args_raw IS NOT NULL AND source = 'pi'";
+
+// ─── CLI (same spur-bin chain as task-size-precheck.ts) ─────────────────────
+
+function usage(): never {
+    console.error('Usage: bun plugins/sp/scripts/task-evidence-precheck.ts <wbs> [--spur-bin <path>]');
+    process.exit(1);
+}
+
+function defaultSpurBin(): string {
+    if (process.env.SPUR_BIN) return process.env.SPUR_BIN;
+    const local = fileURLToPath(new URL('../../../apps/cli/src/index.ts', import.meta.url));
+    if (existsSync(local)) return `bun ${local}`;
+    return 'spur';
+}
+
+function parseArgs(argv: string[]): { wbs: string; spurBin: string } {
+    let spurBin = defaultSpurBin();
+    let wbs = '';
+    let i = 0;
+    while (i < argv.length) {
+        const arg = argv[i];
+        if (arg === '--spur-bin') {
+            spurBin = argv[i + 1] ?? defaultSpurBin();
+            i += 2;
+        } else if (!arg.startsWith('--')) {
+            wbs = arg;
+            i++;
+        } else {
+            i++;
+        }
+    }
+    if (!wbs) usage();
+    return { wbs, spurBin };
+}
+
+/**
+ * Split a multi-token `spurBin` (`<runtime> <mainModule>`) the same way
+ * `runSpurJson` does in feature-sync-bounded.ts — execFileSync's first arg is
+ * one executable path, not a shell command line.
+ */
+function runSpur(spurBin: string, args: string[]): string {
+    const [file = 'spur', ...lead] = spurBin.split(/\s+/).filter(Boolean);
+    return execFileSync(file, [...lead, ...args], {
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+    });
+}
+
+function writeStatus(wbs: string, status: 'PASS' | 'FAIL'): void {
+    const statusDir = join(process.cwd(), '.spur', 'run');
+    if (!existsSync(statusDir)) mkdirSync(statusDir, { recursive: true });
+    writeFileSync(join(statusDir, `${wbs}-precheck-evidence.status`), `${status}\n`);
+}
+
+function fail(wbs: string, reasons: string[]): void {
+    writeStatus(wbs, 'FAIL');
+    console.error(`task-evidence-precheck: FAIL`);
+    for (const r of reasons) {
+        console.error(`  ${r}`);
+    }
+    process.exit(0);
+}
+
+function main(): void {
+    const { wbs, spurBin } = parseArgs(process.argv.slice(2));
+
+    let taskContent: string;
+    try {
+        const result = runSpur(spurBin, ['task', 'show', wbs, '--json']);
+        const task = JSON.parse(result);
+        taskContent = task.content ?? task.body ?? '';
+    } catch {
+        fail(wbs, [`could not fetch task ${wbs} via ${spurBin} — evidence channel unverifiable`]);
+    }
+
+    // Collect every declaration token. A repeated exact declaration still gates the
+    // single fixed query; any non-allowlisted token is an unknown declaration.
+    const declarations: string[] = [];
+    for (const match of taskContent.matchAll(/evidence-channel:\s*(\S+)/g)) {
+        declarations.push(match[1] ?? '');
+    }
+    const unknown = declarations.filter((d) => d !== EVIDENCE_CHANNEL);
+    if (unknown.length > 0) {
+        fail(wbs, [
+            `unknown evidence-channel declaration(s): ${unknown.join(', ')}`,
+            `allowlisted declaration: ${DECLARATION}`,
+        ]);
+    }
+    if (declarations.length === 0) {
+        writeStatus(wbs, 'PASS');
+        console.error(`task-evidence-precheck: PASS — no evidence-channel declaration; live-data gate not active`);
+        process.exit(0);
+    }
+
+    const dbPath = join(process.cwd(), '.spur', 'spur.db');
+    if (!existsSync(dbPath)) {
+        fail(wbs, [`local spur database not found at ${dbPath} — run a real history import first`]);
+    }
+
+    let count: number;
+    try {
+        const db = new Database(dbPath, { readonly: true });
+        try {
+            const row = db.query(EVIDENCE_QUERY).get() as { n: number } | undefined;
+            count = row?.n ?? 0;
+        } finally {
+            db.close();
+        }
+    } catch (e) {
+        fail(wbs, [
+            `evidence query failed on ${dbPath}: ${e instanceof Error ? e.message : String(e)}`,
+            'history_tool_call table missing or unreadable — run a real history import first',
+        ]);
+    }
+
+    if (!(count > 0)) {
+        fail(wbs, [
+            `0 live pi rows with args_raw (query: ${EVIDENCE_QUERY})`,
+            'run a non-dry-run pi history import with a safe importer before implementing',
+        ]);
+    }
+
+    writeStatus(wbs, 'PASS');
+    console.error(
+        `task-evidence-precheck: PASS — ${count} live pi history_tool_call row(s) with args_raw (declaration: ${DECLARATION})`,
+    );
+    process.exit(0);
+}
+
+main();

package/plugins/sp/scripts/task-size-precheck.ts

@@ -0,0 +1,175 @@
+#!/usr/bin/env bun
+/**
+ * task-size-precheck — pipeline size precheck guard (R2, task 0454; count-only
+ * since task 0723).
+ *
+ * Shells `spur task show <wbs> --json`, evaluates R-item count and Plan
+ * checklist count against limits, writes PASS/FAIL to status file. No executor
+ * or doctor involvement: executor liveness/routing/capabilities are attested
+ * fail-closed at the `agent.run` dispatch boundary, not predicted here.
+ *
+ * Always exits 0 (soft action). The precheck→implement guard in
+ * task-pipeline.yaml reads the status file; a missing or failing checker writes
+ * FAIL, so readiness fails closed.
+ *
+ * Ships with the plugin to arbitrary projects, so it stays node-builtin-only —
+ * no workspace imports.
+ *
+ * Usage:
+ *   bun plugins/sp/scripts/task-size-precheck.ts <wbs> [--spur-bin <path>]
+ *     [--max-reqs <n>] [--max-plan-items <n>]
+ *
+ * Env: SPUR_BIN, MAX_IMPLEMENT_REQS, MAX_IMPLEMENT_PLAN_ITEMS
+ */
+
+import { execFileSync } from 'node:child_process';
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+// ─── Regex (sync with packages/app/src/services/task-size-precheck.ts) ───────
+
+/** Matches `- [ ] **R1.**` or `- [x] R1.` etc. Requires period after digits. */
+const R_ITEM_RE = /^\s*-\s*\[[ xX]\]\s*(\*\*)?R\d+\./m;
+
+/** Matches checklist items under the Plan section. */
+const CHECKLIST_ITEM_RE = /^\s*-\s*\[[ xX]\]/m;
+
+// ─── CLI ─────────────────────────────────────────────────────────────────────
+
+function usage(): never {
+    console.error(
+        'Usage: bun plugins/sp/scripts/task-size-precheck.ts <wbs> [--spur-bin <path>] [--max-reqs <n>] [--max-plan-items <n>]',
+    );
+    process.exit(1);
+}
+
+/**
+ * Resolve the spur CLI command in a monorepo-safe way:
+ * --spur-bin > SPUR_BIN > monorepo-local CLI entry > PATH `spur`.
+ * The plugin's own CI always passes an explicit --spur-bin; this fallback chain
+ * keeps ad-hoc invocations from silently hitting a stale PATH install.
+ */
+function defaultSpurBin(): string {
+    if (process.env.SPUR_BIN) return process.env.SPUR_BIN;
+    // scripts/ -> plugins/sp/ -> <repo>/apps/cli/src/index.ts (fileURLToPath — raw pathname breaks
+    // on %-encoded paths, e.g. spaces in the checkout directory)
+    const local = fileURLToPath(new URL('../../../apps/cli/src/index.ts', import.meta.url));
+    if (existsSync(local)) return `bun ${local}`;
+    return 'spur';
+}
+
+function parseArgs(argv: string[]): {
+    wbs: string;
+    spurBin: string;
+    maxReqs: number;
+    maxPlanItems: number;
+} {
+    let spurBin = defaultSpurBin();
+    let wbs = '';
+    // Doubled deterministic ceiling (0723 operator decision): 10 R-items / 16
+    // Plan items — keep in sync with DEFAULT_TASK_SIZE_LIMITS in
+    // packages/app/src/services/task-size-precheck.ts (asserted by test).
+    let maxReqs = Number(process.env.MAX_IMPLEMENT_REQS) || 10;
+    let maxPlanItems = Number(process.env.MAX_IMPLEMENT_PLAN_ITEMS) || 16;
+
+    let i = 0;
+    while (i < argv.length) {
+        const arg = argv[i];
+        if (arg === '--spur-bin') {
+            spurBin = argv[i + 1] ?? defaultSpurBin();
+            i += 2;
+        } else if (arg === '--max-reqs') {
+            maxReqs = Number(argv[i + 1]) || 10;
+            i += 2;
+        } else if (arg === '--max-plan-items') {
+            maxPlanItems = Number(argv[i + 1]) || 16;
+            i += 2;
+        } else if (!arg.startsWith('--')) {
+            wbs = arg;
+            i++;
+        } else {
+            i++;
+        }
+    }
+
+    if (!wbs) usage();
+    return { wbs, spurBin, maxReqs, maxPlanItems };
+}
+
+/**
+ * Split a multi-token `spurBin` (`<runtime> <mainModule>`) the same way
+ * `runSpurJson` does in feature-sync-bounded.ts — execFileSync's first arg is
+ * one executable path, not a shell command line.
+ */
+function runSpur(spurBin: string, args: string[]): string {
+    const [file = 'spur', ...lead] = spurBin.split(/\s+/).filter(Boolean);
+    return execFileSync(file, [...lead, ...args], {
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+    });
+}
+
+function main(): void {
+    const { wbs, spurBin, maxReqs, maxPlanItems } = parseArgs(process.argv.slice(2));
+
+    // Fetch task content via spur
+    let taskContent: string;
+    try {
+        const result = runSpur(spurBin, ['task', 'show', wbs, '--json']);
+        const task = JSON.parse(result);
+        taskContent = task.content ?? task.body ?? '';
+    } catch {
+        // If spur fails, write FAIL and exit 0 — the status file carries the verdict
+        const statusDir = join(process.cwd(), '.spur', 'run');
+        if (!existsSync(statusDir)) mkdirSync(statusDir, { recursive: true });
+        writeFileSync(join(statusDir, `${wbs}-precheck-size.status`), 'FAIL\n');
+        console.error(`task-size-precheck: FAIL — could not fetch task ${wbs} via ${spurBin}`);
+        process.exit(0);
+    }
+
+    const reqCount = taskContent.match(new RegExp(R_ITEM_RE.source, 'gm'))?.length ?? 0;
+
+    const planMatch = taskContent.match(/^#{2,3}\s+Plan\s*$/m);
+    const planBody = planMatch
+        ? (() => {
+              const rest = taskContent.slice((planMatch.index ?? 0) + planMatch[0].length);
+              const nextSection = rest.match(/^#{2,3}\s+/m);
+              return nextSection ? rest.slice(0, nextSection.index ?? 0) : rest;
+          })()
+        : '';
+    const planItemCount = planBody.match(new RegExp(CHECKLIST_ITEM_RE.source, 'gm'))?.length ?? 0;
+
+    const reasons: string[] = [];
+    if (reqCount > maxReqs) {
+        reasons.push(
+            `Task has ${reqCount} R-items (max ${maxReqs}). ` +
+                `Consider decomposing or raise maxImplementReqs via --vars.`,
+        );
+    }
+    if (planItemCount > maxPlanItems) {
+        reasons.push(
+            `Task has ${planItemCount} Plan items (max ${maxPlanItems}). ` +
+                `Consider simplifying the plan or raise maxImplementPlanItems via --vars.`,
+        );
+    }
+
+    const ok = reasons.length === 0;
+    const status = ok ? 'PASS' : 'FAIL';
+
+    const statusDir = join(process.cwd(), '.spur', 'run');
+    if (!existsSync(statusDir)) mkdirSync(statusDir, { recursive: true });
+    writeFileSync(join(statusDir, `${wbs}-precheck-size.status`), `${status}\n`);
+
+    const msg = `task-size-precheck: ${status} — ${reqCount} R-items, ${planItemCount} Plan items`;
+    console.error(msg);
+    if (!ok) {
+        for (const r of reasons) {
+            console.error(`  ${r}`);
+        }
+    }
+
+    process.exit(0);
+}
+
+main();

package/plugins/sp/scripts/transition-shim-check.ts

@@ -0,0 +1,238 @@
+#!/usr/bin/env bun
+/**
+ * transition-shim-check — two-sided gate over `config/transition-shims.json`
+ * (task 0541, feature B2).
+ *
+ * A transition shim is a compatibility path that must survive the agent-role
+ * transition. Every shim carries a source marker comment `@transition-shim(<id>)`
+ * so it is a grep target and a review signal, and a manifest entry in
+ * `config/transition-shims.json` records who owns it and when it can be removed.
+ *
+ * The gate is deliberately two-sided: a marker with no manifest entry
+ * FAILS, and a manifest entry whose marker no longer appears in source
+ * FAILS. Without the second half the manifest would rot into a permanent
+ * suppression list — the exact invisible-debt pattern this gate exists to
+ * end.
+ *
+ * Marker convention (docs/04_DESIGN.md §2.5):
+ *   // @transition-shim(<id>) — <one line on what this keeps working>
+ *   <id> matches ^[a-z0-9][a-z0-9-]*$ (lowercase kebab).
+ * Markers live in production source roots (apps, packages, plugins, config,
+ * scripts, tooling). Docs and test fixtures are not scanned — prose examples
+ * and gate-fixture marker text must not trip the gate.
+ *
+ * The manifest is the removal worklist: emptying it is the definition of the
+ * transition being complete (R4).
+ *
+ * Ships with the plugin to arbitrary projects, so it stays node-builtin-only —
+ * no workspace imports.
+ *
+ * Usage:
+ *   bun plugins/sp/scripts/transition-shim-check.ts
+ *     [--manifest <path>]           default: config/transition-shims.json
+ *     [--roots <a,b,c>]             default: apps,packages,plugins,config,scripts,tooling
+ *
+ * Exit code: 0 when every manifest entry is present in source and every source
+ * marker is registered; 1 on any violation (unregistered marker, stale entry,
+ * or incomplete entry). Violations are printed to stderr; a summary to stdout.
+ */
+
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { join, relative, resolve } from 'node:path';
+
+const MARKER_RE = /@transition-shim\(\s*([a-z0-9][a-z0-9-]*)\s*\)/g;
+const ID_RE = /^[a-z0-9][a-z0-9-]*$/;
+
+/** Directories never scanned for markers (build output, vendored, VCS internals).
+ * `tests`/`test` are excluded too: a test fixture that mentions a marker id is
+ * data exercising the gate, not a compatibility path — shims live in production
+ * source, and only there do they need tracking. */
+const SKIP_DIRS = new Set([
+    'node_modules',
+    '.git',
+    'dist',
+    'coverage',
+    '.spur',
+    'build',
+    '.next',
+    '.venv',
+    '__pycache__',
+    'vendors',
+    '_legacy_reference',
+    'artifacts',
+    'tests',
+    'test',
+]);
+
+const DEFAULT_ROOTS = ['apps', 'packages', 'plugins', 'config', 'scripts', 'tooling'];
+
+/** One manifest record — every field is required (R1). */
+interface ManifestEntry {
+    id: string;
+    wbs: string;
+    file: string;
+    keepsWorking: string;
+    removalCondition: string;
+}
+
+interface Violation {
+    kind: 'unregistered' | 'stale' | 'incomplete';
+    id: string;
+    message: string;
+}
+
+function parseArgs(argv: string[]): { manifest: string; roots: string[]; cwd: string } {
+    let manifest = 'config/transition-shims.json';
+    let roots = DEFAULT_ROOTS;
+    for (let i = 0; i < argv.length; i++) {
+        if (argv[i] === '--manifest') manifest = argv[++i] ?? manifest;
+        else if (argv[i] === '--roots') roots = (argv[++i] ?? '').split(',').filter(Boolean);
+    }
+    return { manifest, roots, cwd: process.cwd() };
+}
+
+/** Walk a root and return marker id -> repo-relative files. */
+function scanMarkers(cwd: string, roots: string[]): Map<string, Set<string>> {
+    const found = new Map<string, Set<string>>();
+    const walk = (dir: string): void => {
+        let entries: string[];
+        try {
+            entries = readdirSync(dir);
+        } catch {
+            return; // unreadable or missing root — skip
+        }
+        for (const name of entries) {
+            if (SKIP_DIRS.has(name)) continue;
+            const abs = join(dir, name);
+            let st: ReturnType<typeof statSync>;
+            try {
+                st = statSync(abs);
+            } catch {
+                continue;
+            }
+            if (st.isDirectory()) {
+                walk(abs);
+                continue;
+            }
+            if (!st.isFile()) continue;
+            let text: string;
+            try {
+                text = readFileSync(abs, 'utf8');
+            } catch {
+                continue; // binary or unreadable — markers are text only
+            }
+            for (const m of text.matchAll(MARKER_RE)) {
+                const id = m[1] as string;
+                const file = relative(cwd, abs);
+                const set = found.get(id) ?? new Set<string>();
+                set.add(file);
+                found.set(id, set);
+            }
+        }
+    };
+    for (const root of roots) walk(resolve(cwd, root));
+    return found;
+}
+
+/** Load the manifest; a missing file degrades to no entries (fail-open). */
+function loadManifest(path: string): { entries: ManifestEntry[]; raw: string | null } {
+    if (!existsSync(path)) return { entries: [], raw: null };
+    const raw = readFileSync(path, 'utf8');
+    let parsed: unknown;
+    try {
+        parsed = JSON.parse(raw);
+    } catch (error) {
+        return { entries: [], raw: `malformed JSON at ${path}: ${String(error)}` };
+    }
+    const entries = (parsed as { entries?: unknown[] }).entries;
+    if (!Array.isArray(entries)) return { entries: [], raw: `${path}: missing "entries" array` };
+    return { entries: entries as ManifestEntry[], raw: null };
+}
+
+function validateEntry(e: ManifestEntry, violations: Violation[]): void {
+    const field = (key: keyof ManifestEntry, value: unknown, why: string): void => {
+        if (typeof value !== 'string' || value.trim() === '') {
+            violations.push({
+                kind: 'incomplete',
+                id: typeof e.id === 'string' ? e.id : '<missing>',
+                message: `manifest entry ${JSON.stringify(e.id ?? null)} is missing required field "${key}"${why}`,
+            });
+        }
+    };
+    field('id', e.id, '');
+    field('wbs', e.wbs, ` in entry ${JSON.stringify(e.id ?? null)}`);
+    field('file', e.file, ` in entry ${JSON.stringify(e.id ?? null)}`);
+    field('keepsWorking', e.keepsWorking, ` in entry ${JSON.stringify(e.id ?? null)}`);
+    field('removalCondition', e.removalCondition, ` in entry ${JSON.stringify(e.id ?? null)}`);
+    if (typeof e.id === 'string' && e.id !== '' && !ID_RE.test(e.id)) {
+        violations.push({
+            kind: 'incomplete',
+            id: e.id,
+            message: `manifest entry id ${JSON.stringify(e.id)} is not lowercase-kebab (^[a-z0-9][a-z0-9-]*$)`,
+        });
+    }
+}
+
+function run(): number {
+    const { manifest, roots, cwd } = parseArgs(process.argv.slice(2));
+    const manifestPath = resolve(cwd, manifest);
+    const { entries, raw } = loadManifest(manifestPath);
+    const violations: Violation[] = [];
+    const incomplete = new Set<string>();
+
+    if (raw !== null) {
+        violations.push({ kind: 'incomplete', id: '<manifest>', message: raw });
+        // A manifest that cannot be parsed has no valid entries to compare against.
+        for (const v of violations) console.error(`transition-shim-check: FAIL - ${v.message}`);
+        console.error('transition-shim-check: FAIL - manifest unreadable; refusing to pass');
+        return 1;
+    }
+
+    for (const e of entries) {
+        const before = violations.length;
+        validateEntry(e, violations);
+        if (violations.length > before) incomplete.add(String(e.id));
+    }
+
+    const markers = scanMarkers(cwd, roots);
+    const observedIds = new Set(markers.keys());
+    const manifestIds = new Set(entries.filter((e) => !incomplete.has(String(e.id))).map((e) => e.id));
+
+    for (const [id, files] of markers) {
+        if (manifestIds.has(id)) continue;
+        const file = [...files].sort().join(', ');
+        violations.push({
+            kind: 'unregistered',
+            id,
+            message: `new unregistered shim @transition-shim(${id}) in ${file} — add an entry to ${manifest} or remove the marker`,
+        });
+    }
+    for (const e of entries) {
+        if (incomplete.has(e.id)) continue;
+        if (observedIds.has(e.id)) continue;
+        violations.push({
+            kind: 'stale',
+            id: e.id,
+            message: `stale manifest entry ${e.id} (wbs ${e.wbs}) — @transition-shim(${e.id}) no longer appears in source; remove the entry, its removal condition was: ${e.removalCondition}`,
+        });
+    }
+
+    const unregistered = violations.filter((v) => v.kind === 'unregistered');
+    const stale = violations.filter((v) => v.kind === 'stale');
+    const incompleteCount = violations.filter((v) => v.kind === 'incomplete').length;
+    const ok = violations.length === 0;
+
+    const noun = entries.length === 1 ? 'entry' : 'entries';
+    console.log(
+        `transition-shim-check: ${markers.size} marker(s) observed, ${entries.length} manifest ${noun} baselined, ` +
+            `${unregistered.length} new, ${stale.length} stale, ${incompleteCount} incomplete — ${ok ? 'PASS' : 'FAIL'}`,
+    );
+    if (ok) return 0;
+
+    for (const v of violations) {
+        console.error(`transition-shim-check: ${v.kind === 'incomplete' ? 'FAIL' : `FAIL (${v.kind})`} - ${v.message}`);
+    }
+    return 1;
+}
+
+process.exit(run());