@deftai/directive-core 0.55.0

package/dist/triage/scope-drift/scope-rules.js

@@ -0,0 +1,149 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+const PROJECT_DEFINITION_REL_PATH = "vbrief/PROJECT-DEFINITION.vbrief.json";
+const DEFAULT_TRIAGE_SCOPE = [{ rule: "all-open" }];
+function loadProjectDefinition(projectRoot) {
+    const path = join(resolve(projectRoot), PROJECT_DEFINITION_REL_PATH);
+    if (!existsSync(path))
+        return null;
+    try {
+        const data = JSON.parse(readFileSync(path, "utf8"));
+        return typeof data === "object" && data !== null && !Array.isArray(data)
+            ? data
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Resolve effective `plan.policy.triageScope` rules. */
+export function resolveScopeRules(projectRoot, projectDefinition) {
+    const data = projectDefinition ?? loadProjectDefinition(projectRoot);
+    if (data === null)
+        return DEFAULT_TRIAGE_SCOPE.map((r) => ({ ...r }));
+    const plan = data.plan;
+    if (typeof plan !== "object" || plan === null || Array.isArray(plan)) {
+        return DEFAULT_TRIAGE_SCOPE.map((r) => ({ ...r }));
+    }
+    const policy = plan.policy;
+    if (typeof policy !== "object" || policy === null || Array.isArray(policy)) {
+        return DEFAULT_TRIAGE_SCOPE.map((r) => ({ ...r }));
+    }
+    const scope = policy.triageScope;
+    if (!Array.isArray(scope) || scope.length === 0) {
+        return DEFAULT_TRIAGE_SCOPE.map((r) => ({ ...r }));
+    }
+    const rules = scope.filter((r) => typeof r === "object" && r !== null && !Array.isArray(r));
+    return rules.length > 0
+        ? rules.map((r) => ({ ...r }))
+        : DEFAULT_TRIAGE_SCOPE.map((x) => ({ ...x }));
+}
+/** Return label/milestone/author ignore sets from PROJECT-DEFINITION. */
+export function resolveScopeIgnores(projectRoot, projectDefinition) {
+    const out = { labels: new Set(), milestones: new Set(), authors: new Set() };
+    const data = projectDefinition ?? loadProjectDefinition(projectRoot);
+    if (data === null)
+        return out;
+    const plan = data.plan;
+    if (typeof plan !== "object" || plan === null || Array.isArray(plan))
+        return out;
+    const policy = plan.policy;
+    if (typeof policy !== "object" || policy === null || Array.isArray(policy))
+        return out;
+    const raw = policy.triageScopeIgnores;
+    if (!Array.isArray(raw))
+        return out;
+    for (const entry of raw) {
+        if (typeof entry !== "object" || entry === null || Array.isArray(entry))
+            continue;
+        const rec = entry;
+        const label = rec.label;
+        if (typeof label === "string" && label.trim())
+            out.labels.add(label);
+        const milestone = rec.milestone;
+        if (typeof milestone === "string" && milestone.trim())
+            out.milestones.add(milestone);
+        if (rec.rule === "author") {
+            const anyOf = rec["any-of"];
+            if (Array.isArray(anyOf)) {
+                for (const name of anyOf) {
+                    if (typeof name === "string" && name.trim())
+                        out.authors.add(name);
+                }
+            }
+        }
+    }
+    return out;
+}
+export function subscribedLabels(rules) {
+    const out = new Set();
+    for (const rule of rules) {
+        if (rule.rule !== "labels")
+            continue;
+        for (const key of ["any-of", "all-of"]) {
+            const value = rule[key];
+            if (Array.isArray(value)) {
+                for (const label of value) {
+                    if (typeof label === "string" && label)
+                        out.add(label);
+                }
+            }
+        }
+    }
+    return out;
+}
+export function collectMilestoneSubscribedNames(rules) {
+    const out = new Set();
+    for (const rule of rules) {
+        if (rule.rule !== "milestone")
+            continue;
+        const name = rule.name;
+        if (typeof name === "string" && name)
+            out.add(name);
+        const anyOf = rule["any-of"];
+        if (Array.isArray(anyOf)) {
+            for (const item of anyOf) {
+                if (typeof item === "string" && item)
+                    out.add(item);
+            }
+        }
+    }
+    return out;
+}
+export function rulesRequestIsOpen(rules) {
+    return rules.some((r) => r.rule === "milestone" && r["is-open"] === true);
+}
+export function subscribedMilestones(rules, openMilestonesSnapshot) {
+    const out = collectMilestoneSubscribedNames(rules);
+    if (rulesRequestIsOpen(rules) && openMilestonesSnapshot) {
+        for (const name of openMilestonesSnapshot)
+            out.add(name);
+    }
+    return out;
+}
+const GITHUB_HOSTNAMES = new Set(["github.com", "api.github.com"]);
+/** Best-effort owner/name inference from cached issue payloads. */
+export function inferRepoFromIssues(issues) {
+    for (const issue of issues) {
+        for (const key of ["repository_url", "html_url"]) {
+            const value = issue[key];
+            if (typeof value !== "string" || !value)
+                continue;
+            try {
+                const parsed = new URL(value);
+                const host = (parsed.hostname || "").toLowerCase();
+                if (!GITHUB_HOSTNAMES.has(host))
+                    continue;
+                const segments = parsed.pathname.split("/").filter(Boolean);
+                if (host === "api.github.com" && segments[0] === "repos" && segments.length >= 3) {
+                    return `${segments[1]}/${segments[2]}`;
+                }
+                if (segments.length >= 2)
+                    return `${segments[0]}/${segments[1]}`;
+            }
+            catch { }
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=scope-rules.js.map

package/dist/triage/scope-drift/types.d.ts

@@ -0,0 +1,13 @@
+/** Framework drift threshold (D14 / #1133). */
+export declare const DRIFT_MIN_ISSUES = 3;
+export declare const CACHE_DIR_NAME = ".deft-cache";
+export declare const CACHE_SOURCE = "github-issue";
+/** Structured drift report — mirrors Python `DriftReport`. */
+export interface DriftReport {
+    readonly labels: Readonly<Record<string, number>>;
+    readonly milestones: Readonly<Record<string, number>>;
+    readonly total: number;
+    readonly threshold: number;
+}
+export declare function isEmptyReport(report: DriftReport): boolean;
+//# sourceMappingURL=types.d.ts.map

package/dist/triage/scope-drift/types.js

@@ -0,0 +1,8 @@
+/** Framework drift threshold (D14 / #1133). */
+export const DRIFT_MIN_ISSUES = 3;
+export const CACHE_DIR_NAME = ".deft-cache";
+export const CACHE_SOURCE = "github-issue";
+export function isEmptyReport(report) {
+    return Object.keys(report.labels).length === 0 && Object.keys(report.milestones).length === 0;
+}
+//# sourceMappingURL=types.js.map

package/dist/triage/smoketest/index.d.ts

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+export declare const DEFAULT_FIXTURE_REL = "tests/fixtures/triage_smoketest";
+export declare const LAST_RUN_FILENAME = "last_run.json";
+export declare const TOTAL_STAGES = 9;
+export declare const STAGE_LABELS: readonly string[];
+export declare const FIXTURE_REPO = "deftai/smoketest";
+declare const WARN_GLYPH = "\u26A0";
+declare const SUMMARY_MAX_CHARS = 120;
+export declare class SmoketestError extends Error {
+    readonly stage: number;
+    readonly failureName: string;
+    readonly expected: unknown;
+    readonly actual: unknown;
+    readonly failureCause: string;
+    constructor(stage: number, name: string, expected: unknown, actual: unknown, cause: string);
+}
+export interface AssertRecord {
+    stage: number;
+    name: string;
+    status: string;
+    detail?: string;
+    expected?: unknown;
+    actual?: unknown;
+    cause?: string;
+    reason?: string;
+}
+export declare class AssertLog {
+    readonly records: AssertRecord[];
+    readonly verbose: boolean;
+    constructor(options: {
+        verbose: boolean;
+    });
+    private emit;
+    passed(stage: number, name: string, detail?: string): void;
+    fail(stage: number, name: string, options: {
+        expected: unknown;
+        actual: unknown;
+        cause: string;
+    }): SmoketestError;
+    skipped(stage: number, name: string, reason: string): void;
+    writeJson(path: string, options: {
+        exitCode: number;
+        fixtureRepo: string;
+    }): void;
+}
+export interface ScriptCapture {
+    readonly returncode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+export interface ScriptRunner {
+    run(scriptName: string, args: readonly string[], options: {
+        projectRoot: string;
+        includeRepoEnv?: boolean;
+        extraEnv?: Record<string, string>;
+    }): ScriptCapture;
+}
+export interface SmoketestDeps {
+    readonly scriptsDir: string;
+    readonly scriptRunner: ScriptRunner;
+    readonly runInlinePython?: (code: string, stdin: string, cwd: string) => ScriptCapture;
+}
+export declare function copyFixtureToTmp(fixtureRoot: string, tmpRoot: string): string;
+export declare function renderCache(projectRoot: string, issuesSpec: Record<string, unknown>, scriptsDir: string, runInline?: NonNullable<SmoketestDeps["runInlinePython"]>, cwd?: string): void;
+export declare function runSmoketest(fixtureRoot: string, options?: {
+    verbose?: boolean;
+    keepTempdir?: boolean;
+    cacheOnly?: boolean;
+    deftRoot?: string;
+    deps?: SmoketestDeps;
+}): number;
+export declare function parseSmoketestArgs(argv: readonly string[]): {
+    fixture: string;
+    verbose: boolean;
+    keepTempdir: boolean;
+    cacheOnly: boolean;
+    showHelp: boolean;
+    error?: string;
+};
+export { SUMMARY_MAX_CHARS, WARN_GLYPH };
+//# sourceMappingURL=index.d.ts.map

package/dist/triage/smoketest/index.js

@@ -0,0 +1,335 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import { copyFileSync, existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, writeFileSync, } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+export const DEFAULT_FIXTURE_REL = "tests/fixtures/triage_smoketest";
+export const LAST_RUN_FILENAME = "last_run.json";
+export const TOTAL_STAGES = 9;
+export const STAGE_LABELS = [
+    "",
+    "bootstrap + auto-classify",
+    "audit decision counts",
+    "queue ranking determinism",
+    "defer with resume-on",
+    "evaluate-resume marker",
+    "scope:promote (D18 fallback)",
+    "scope:demote single-file",
+    "scope:undo idempotency",
+    "triage:summary bounded output",
+];
+export const FIXTURE_REPO = "deftai/smoketest";
+const WARN_GLYPH = "\u26a0";
+const SUMMARY_MAX_CHARS = 120;
+export class SmoketestError extends Error {
+    stage;
+    failureName;
+    expected;
+    actual;
+    failureCause;
+    constructor(stage, name, expected, actual, cause) {
+        super(`[${stage}/${TOTAL_STAGES}] ${name} FAIL: expected=${JSON.stringify(expected)} ` +
+            `actual=${JSON.stringify(actual)} cause=${cause}`);
+        this.stage = stage;
+        this.failureName = name;
+        this.expected = expected;
+        this.actual = actual;
+        this.failureCause = cause;
+    }
+}
+export class AssertLog {
+    records = [];
+    verbose;
+    constructor(options) {
+        this.verbose = options.verbose;
+    }
+    emit(stage, suffix) {
+        const label = stage >= 1 && stage < STAGE_LABELS.length ? STAGE_LABELS[stage] : "stage";
+        const prefix = `[${stage}/${TOTAL_STAGES}] ${label} `.padEnd(56, ".");
+        process.stderr.write(`${prefix} ${suffix}\n`);
+    }
+    passed(stage, name, detail = "") {
+        this.records.push({ stage, name, status: "PASS", detail });
+        if (this.verbose) {
+            this.emit(stage, "PASS");
+        }
+    }
+    fail(stage, name, options) {
+        this.records.push({
+            stage,
+            name,
+            status: "FAIL",
+            expected: options.expected,
+            actual: options.actual,
+            cause: options.cause,
+        });
+        return new SmoketestError(stage, name, options.expected, options.actual, options.cause);
+    }
+    skipped(stage, name, reason) {
+        this.records.push({ stage, name, status: "SKIP", reason });
+        if (this.verbose) {
+            this.emit(stage, `SKIP (${reason})`);
+        }
+    }
+    writeJson(path, options) {
+        const payload = {
+            schema: "deft.triage.smoketest.v1",
+            fixture_repo: options.fixtureRepo,
+            emitted_at: new Date().toISOString().replace(/\.\d{3}Z$/, "Z"),
+            exit_code: options.exitCode,
+            stage_count: TOTAL_STAGES,
+            records: this.records,
+        };
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(path, `${JSON.stringify(payload, null, 2)}\n`, { encoding: "utf8" });
+    }
+}
+function defaultScriptRunner(scriptsDir) {
+    return {
+        run(scriptName, args, options) {
+            const env = {
+                ...process.env,
+                PYTHONUTF8: "1",
+                DEFT_PROJECT_ROOT: options.projectRoot,
+            };
+            if (options.includeRepoEnv !== false) {
+                env.DEFT_TRIAGE_REPO = FIXTURE_REPO;
+            }
+            else {
+                delete env.DEFT_TRIAGE_REPO;
+            }
+            if (options.extraEnv !== undefined) {
+                Object.assign(env, options.extraEnv);
+            }
+            const result = spawnSync("uv", ["run", "python", join(scriptsDir, scriptName), ...args], {
+                cwd: options.projectRoot,
+                env,
+                encoding: "utf8",
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+            return {
+                returncode: result.status ?? 2,
+                stdout: typeof result.stdout === "string" ? result.stdout : "",
+                stderr: typeof result.stderr === "string" ? result.stderr : "",
+            };
+        },
+    };
+}
+export function copyFixtureToTmp(fixtureRoot, tmpRoot) {
+    const project = tmpRoot;
+    mkdirSync(project, { recursive: true });
+    mkdirSync(join(project, "vbrief"), { recursive: true });
+    copyFileSync(join(fixtureRoot, "PROJECT-DEFINITION.vbrief.json"), join(project, "vbrief", "PROJECT-DEFINITION.vbrief.json"));
+    for (const sub of ["active", "proposed", "pending", "completed", "cancelled"]) {
+        const srcDir = join(fixtureRoot, "vbrief", sub);
+        const dstDir = join(project, "vbrief", sub);
+        mkdirSync(dstDir, { recursive: true });
+        if (existsSync(srcDir)) {
+            for (const name of readdirSync(srcDir)) {
+                if (name.endsWith(".vbrief.json")) {
+                    copyFileSync(join(srcDir, name), join(dstDir, name));
+                }
+            }
+        }
+    }
+    mkdirSync(join(project, "vbrief", ".eval"), { recursive: true });
+    return project;
+}
+function defaultInlineRunner() {
+    return (code, stdin, cwd) => {
+        const result = spawnSync("uv", ["run", "python", "-c", code], {
+            input: stdin,
+            encoding: "utf8",
+            cwd,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        return {
+            returncode: result.status ?? 2,
+            stdout: typeof result.stdout === "string" ? result.stdout : "",
+            stderr: typeof result.stderr === "string" ? result.stderr : "",
+        };
+    };
+}
+export function renderCache(projectRoot, issuesSpec, scriptsDir, runInline = defaultInlineRunner(), cwd = dirname(scriptsDir)) {
+    const py = `
+import json, sys
+from datetime import datetime
+from pathlib import Path
+sys.path.insert(0, ${JSON.stringify(scriptsDir)})
+from cache import cache_put
+spec = json.loads(sys.stdin.read())
+now_dt = datetime.fromisoformat(spec['now_iso'].replace('Z', '+00:00'))
+repo = spec['repo']
+cache_root = Path(${JSON.stringify(projectRoot)}) / '.deft-cache'
+for issue in spec['issues']:
+    n = int(issue['number'])
+    raw = {
+        'number': n,
+        'title': issue['title'],
+        'state': issue.get('state', 'open'),
+        'labels': [{'name': label} for label in issue.get('labels', [])],
+        'body': issue.get('body', ''),
+        'updated_at': issue.get('updated_at', spec['now_iso']),
+        'created_at': issue.get('created_at', spec['now_iso']),
+        'url': f'https://api.github.com/repos/{repo}/issues/{n}',
+        'html_url': f'https://github.com/{repo}/issues/{n}',
+    }
+    cache_put('github-issue', f'{repo}/{n}', raw, cache_root=cache_root, fetched_at=now_dt)
+`;
+    const result = runInline(py, JSON.stringify(issuesSpec), cwd);
+    if (result.returncode !== 0) {
+        throw new Error(`renderCache failed: ${result.stderr}`);
+    }
+}
+export function runSmoketest(fixtureRoot, options = {}) {
+    const deftRoot = options.deftRoot ??
+        (process.env.DEFT_ROOT !== undefined && process.env.DEFT_ROOT.length > 0
+            ? resolve(process.env.DEFT_ROOT)
+            : resolve(dirname(fileURLToPath(import.meta.url)), "..", "..", "..", "..", ".."));
+    const scriptsDir = join(deftRoot, "scripts");
+    const deps = options.deps ?? {
+        scriptsDir,
+        scriptRunner: defaultScriptRunner(scriptsDir),
+    };
+    const runInline = deps.runInlinePython ?? defaultInlineRunner();
+    const lastRunPath = join(fixtureRoot, LAST_RUN_FILENAME);
+    const log = new AssertLog({ verbose: options.verbose ?? false });
+    const issuesSpecPath = join(fixtureRoot, "issues.json");
+    if (!existsSync(issuesSpecPath)) {
+        process.stderr.write(`[triage:smoketest] FAIL: fixture issues.json not found at ${issuesSpecPath}\n`);
+        log.records.push({
+            stage: 0,
+            name: "fixture-load",
+            status: "FAIL",
+            cause: `issues.json missing at ${issuesSpecPath}`,
+        });
+        log.writeJson(lastRunPath, { exitCode: 1, fixtureRepo: FIXTURE_REPO });
+        return 1;
+    }
+    const issuesSpec = JSON.parse(readFileSync(issuesSpecPath, { encoding: "utf8" }));
+    const tmpDir = mkdtempSync(join(tmpdir(), "deft-triage-smoketest-"));
+    try {
+        const projectRoot = copyFixtureToTmp(fixtureRoot, join(tmpDir, "project"));
+        renderCache(projectRoot, issuesSpec, deps.scriptsDir, runInline, deftRoot);
+        const stageRunner = `
+import json, sys
+from pathlib import Path
+sys.path.insert(0, ${JSON.stringify(deps.scriptsDir)})
+from triage_smoketest import AssertLog, TOTAL_STAGES, STAGE_LABELS
+import _triage_smoketest_stages as stages
+
+payload = json.loads(sys.stdin.read())
+project_root = Path(payload['project_root'])
+issues_spec = payload['issues_spec']
+cache_only = payload['cache_only']
+verbose = payload['verbose']
+log = AssertLog(verbose=verbose)
+try:
+    stages.stage_bootstrap_and_classify(project_root, issues_spec, log)
+    stages.stage_audit_counts(project_root, log)
+    stages.stage_queue_determinism(project_root, log)
+    prior = stages.stage_defer_resume_on(project_root, log)
+    stages.stage_evaluate_resume(project_root, prior, log)
+    if cache_only:
+        for stage in (6, 7, 8):
+            label = STAGE_LABELS[stage] if stage < len(STAGE_LABELS) else f'stage-{stage}'
+            log.skipped(stage, label, reason='--cache-only')
+    else:
+        pending = stages.stage_scope_promote(project_root, log)
+        stages.stage_scope_demote(project_root, pending, log)
+        stages.stage_scope_undo(project_root, log)
+    stages.stage_triage_summary(project_root, log)
+    print(json.dumps({'exit_code': 0, 'records': log.records}))
+except Exception as e:
+    import traceback
+    from triage_smoketest import SmoketestError
+    if isinstance(e, SmoketestError):
+        print(json.dumps({'exit_code': 1, 'records': log.records, 'error': str(e)}))
+    else:
+        print(json.dumps({'exit_code': 1, 'records': log.records, 'error': traceback.format_exc()}))
+        raise
+`;
+        const result = runInline(stageRunner, JSON.stringify({
+            project_root: projectRoot,
+            issues_spec: issuesSpec,
+            cache_only: options.cacheOnly ?? false,
+            verbose: options.verbose ?? false,
+        }), deftRoot);
+        if (result.returncode !== 0) {
+            process.stderr.write(`[triage:smoketest] stage runner failed: ${result.stderr}\n`);
+            log.writeJson(lastRunPath, { exitCode: 1, fixtureRepo: FIXTURE_REPO });
+            return 1;
+        }
+        const payload = JSON.parse(result.stdout);
+        log.records.push(...payload.records);
+        if (payload.exit_code !== 0) {
+            if (payload.error !== undefined) {
+                process.stderr.write(`${payload.error}\n`);
+            }
+            log.writeJson(lastRunPath, { exitCode: 1, fixtureRepo: FIXTURE_REPO });
+            return 1;
+        }
+        log.writeJson(lastRunPath, { exitCode: 0, fixtureRepo: FIXTURE_REPO });
+        if (options.verbose) {
+            process.stderr.write("[triage:smoketest] exit 0\n");
+        }
+        return 0;
+    }
+    catch (failure) {
+        if (failure instanceof SmoketestError) {
+            process.stderr.write(`${failure.message}\n`);
+        }
+        log.writeJson(lastRunPath, { exitCode: 1, fixtureRepo: FIXTURE_REPO });
+        return 1;
+    }
+    finally {
+        if (options.keepTempdir) {
+            process.stderr.write(`[triage:smoketest] --keep-tempdir: temp working dir preserved at ${tmpDir}\n`);
+        }
+        else {
+            rmSync(tmpDir, { recursive: true, force: true });
+        }
+    }
+}
+export function parseSmoketestArgs(argv) {
+    const parsed = {
+        fixture: "",
+        verbose: false,
+        keepTempdir: false,
+        cacheOnly: false,
+        showHelp: false,
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === undefined)
+            continue;
+        if (arg === "--verbose") {
+            parsed.verbose = true;
+        }
+        else if (arg === "--keep-tempdir") {
+            parsed.keepTempdir = true;
+        }
+        else if (arg === "--cache-only") {
+            parsed.cacheOnly = true;
+        }
+        else if (arg === "--help" || arg === "-h") {
+            parsed.showHelp = true;
+        }
+        else if (arg === "--fixture") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --fixture: expected one argument" };
+            }
+            parsed.fixture = value;
+            i += 1;
+        }
+        else {
+            return { ...parsed, error: `unrecognized arguments: ${arg}` };
+        }
+    }
+    return parsed;
+}
+// Export stage constants for tests
+export { SUMMARY_MAX_CHARS, WARN_GLYPH };
+//# sourceMappingURL=index.js.map

package/dist/triage/subscribe/index.d.ts

@@ -0,0 +1,38 @@
+export declare const SUBSCRIPTION_HISTORY_REL_PATH = "vbrief/.eval/subscription-history.jsonl";
+export declare const SUBSCRIPTION_HISTORY_SCHEMA = "deft.triage.subscription-change.v1";
+export declare const PROJECT_DEFINITION_REL_PATH = "vbrief/PROJECT-DEFINITION.vbrief.json";
+/** Python ``!r``-style quoting for parity with triage_subscribe.py messages. */
+export declare function pyRepr(value: string): string;
+export declare class ProjectDefinitionIOError extends Error {
+    constructor(message: string);
+}
+type TriageRule = Record<string, unknown>;
+export declare function loadProjectDefinitionForMutation(projectRoot: string): [Record<string, unknown>, string];
+export declare function atomicWriteProjectDefinition(path: string, data: Record<string, unknown>): void;
+export declare function recordSubscriptionChange(projectRoot: string, options: {
+    op: string;
+    label?: string | null;
+    milestone?: string | null;
+    issue?: number | null;
+    author?: string | null;
+    before?: TriageRule[] | null;
+    after?: TriageRule[] | null;
+    actor?: string | null;
+    extra?: Record<string, unknown> | null;
+}): void;
+export declare function subscribe(projectRoot: string, options?: {
+    label?: string | null;
+    milestone?: string | null;
+    issue?: number | null;
+    issueNote?: string;
+    actor?: string | null;
+}): [boolean, string];
+export declare function unsubscribe(projectRoot: string, options?: {
+    label?: string | null;
+    milestone?: string | null;
+    issue?: number | null;
+    actor?: string | null;
+}): [boolean, string];
+export declare const RECONCILE_HINT: string;
+export {};
+//# sourceMappingURL=index.d.ts.map