create-principles-disciple 1.109.0 → 1.110.0

package/console/dist/server/config/pd-config-store.d.ts

@@ -140,6 +140,35 @@ export declare function getPrinciplesOutputLanguage(workspaceDir: string): Outpu
  * bypasses; uses Object.hasOwn for untrusted key checks (ERR-013).
  */
 export declare function getFeedbackMaintainerEmail(workspaceDir: string): string;
+/**
+ * Channel-side parameters for the feedback submit ladder (§4 / §10 of
+ * docs/superpowers/specs/2026-08-17-feedback-last-mile-submit-design.md).
+ *
+ * All values are optional-from-config: an empty string means "key not set or
+ * not a string" → the corresponding channel reports unavailable. Presence of
+ * `ingest_url` enables the primary channel; presence of `github_repo` enables
+ * the gh CLI channel.
+ *
+ * Reads parse YAML as unknown (ERR-001/005: no `as` bypasses) and uses
+ * Object.hasOwn for untrusted key checks (ERR-013). Mirrors the
+ * `getFeedbackMaintainerEmail` pattern.
+ */
+export type FeedbackChannelConfig = {
+    ingestUrl: string;
+    ingestToken: string;
+    githubRepo: string;
+    githubProxy: string;
+};
+/**
+ * Read `feedback.ingest_url` / `ingest_token` / `github_repo` / `github_proxy`
+ * from `.pd/config.yaml`. Missing/malformed config falls back to all-empty.
+ *
+ * NOTE: `ingest_token` is returned here but MUST NOT be serialised to any
+ * client-facing payload (channels endpoint omits it; only the server submit
+ * path uses it). It ships in the release and is an anti-abuse boundary, not a
+ * security boundary (spec §9.2).
+ */
+export declare function getFeedbackChannelConfig(workspaceDir: string): FeedbackChannelConfig;
 /**
  * Update principles.outputLanguage in config.yaml.
  * Safe partial write: preserves unknown sections, validates before write.

package/console/dist/server/config/pd-config-store.js

@@ -579,6 +579,61 @@ export function getFeedbackMaintainerEmail(workspaceDir) {
     }
     return emailRaw;
 }
+const EMPTY_FEEDBACK_CHANNEL = {
+    ingestUrl: '',
+    ingestToken: '',
+    githubRepo: '',
+    githubProxy: '',
+};
+/** Read a known string key from an already-validated record, or '' when absent/non-string. */
+function readConfigString(record, key) {
+    if (!Object.hasOwn(record, key))
+        return '';
+    const v = record[key];
+    return typeof v === 'string' ? v : '';
+}
+/**
+ * Read `feedback.ingest_url` / `ingest_token` / `github_repo` / `github_proxy`
+ * from `.pd/config.yaml`. Missing/malformed config falls back to all-empty.
+ *
+ * NOTE: `ingest_token` is returned here but MUST NOT be serialised to any
+ * client-facing payload (channels endpoint omits it; only the server submit
+ * path uses it). It ships in the release and is an anti-abuse boundary, not a
+ * security boundary (spec §9.2).
+ */
+export function getFeedbackChannelConfig(workspaceDir) {
+    const configPath = getPdConfigPath(workspaceDir);
+    if (!fs.existsSync(configPath)) {
+        return { ...EMPTY_FEEDBACK_CHANNEL };
+    }
+    let raw;
+    try {
+        raw = fs.readFileSync(configPath, 'utf8');
+    }
+    catch {
+        return { ...EMPTY_FEEDBACK_CHANNEL };
+    }
+    let parsed;
+    try {
+        parsed = yaml.load(raw, { schema: yaml.JSON_SCHEMA });
+    }
+    catch {
+        return { ...EMPTY_FEEDBACK_CHANNEL };
+    }
+    if (!isRecord(parsed)) {
+        return { ...EMPTY_FEEDBACK_CHANNEL };
+    }
+    const feedbackRaw = Object.hasOwn(parsed, 'feedback') ? parsed.feedback : undefined;
+    if (feedbackRaw === undefined || !isRecord(feedbackRaw)) {
+        return { ...EMPTY_FEEDBACK_CHANNEL };
+    }
+    return {
+        ingestUrl: readConfigString(feedbackRaw, 'ingest_url'),
+        ingestToken: readConfigString(feedbackRaw, 'ingest_token'),
+        githubRepo: readConfigString(feedbackRaw, 'github_repo'),
+        githubProxy: readConfigString(feedbackRaw, 'github_proxy'),
+    };
+}
 /**
  * Update principles.outputLanguage in config.yaml.
  * Safe partial write: preserves unknown sections, validates before write.

package/console/dist/server/feedback/channels.d.ts

@@ -0,0 +1,36 @@
+import type * as childProcessNS from 'node:child_process';
+import type * as fsNS from 'node:fs';
+import type * as osNS from 'node:os';
+import type * as pathNS from 'node:path';
+import type { FeedbackChannelConfig } from '../config/pd-config-store.js';
+type ExecFileFn = typeof childProcessNS.execFile;
+export interface ChannelStatus {
+    id: 'ingest' | 'github' | 'email' | 'file';
+    available: boolean;
+    /** Human-readable reason when unavailable. */
+    reason?: string;
+    /** Concrete next action the user can take (rc-9). */
+    nextAction?: string;
+}
+export interface ChannelsResult {
+    ok: true;
+    channels: ChannelStatus[];
+}
+export declare function clearProbeCache(): void;
+export type ChannelDeps = {
+    fs?: typeof fsNS;
+    os?: typeof osNS;
+    path?: typeof pathNS;
+    execFile?: ExecFileFn;
+    fetchFn?: typeof fetch;
+    probeTimeoutMs?: number;
+};
+/**
+ * Build the full channel ladder status for a workspace.
+ * `maintainerEmail` is supplied by the caller (already computed from config).
+ * `featureFlagEnabled` gates the whole submit area (spec §12: flag off hides it
+ * and the endpoint 403s); channels still probe but the caller may drop the
+ * area entirely when the flag is off.
+ */
+export declare function probeChannels(config: FeedbackChannelConfig, deps: ChannelDeps, maintainerEmail?: string): Promise<ChannelsResult>;
+export {};

package/console/dist/server/feedback/channels.js

@@ -0,0 +1,89 @@
+// channels.ts
+// Channel-ladder availability probing for feedback submission (PRI-543).
+//
+// Spec §4 / §8.1: the UI orders channels by ladder position and disables
+// unavailable ones, showing reason + nextAction (rc-9). Probing is fail-open:
+// inability to probe is reported as available so a transient probe failure
+// never hides a channel; the submit path then fails loudly and surfaces a
+// structured reason + downgrade hint.
+//
+// Probing results are cached per (channel,url-or-repo) for 60s to avoid
+// hammering the relay /shelling out to gh on every list/via fetch.
+import { probeIngestHealth } from './ingest-adapter.js';
+import { detectGithubCli } from './github-adapter.js';
+const PROBE_CACHE_TTL_MS = 60_000;
+const probeCache = new Map();
+function cachedOrCompute(key, compute) {
+    const hit = probeCache.get(key);
+    if (hit && Date.now() - hit.at < PROBE_CACHE_TTL_MS) {
+        return Promise.resolve(hit);
+    }
+    return compute().then((entry) => {
+        probeCache.set(key, entry);
+        return entry;
+    });
+}
+export function clearProbeCache() {
+    probeCache.clear();
+}
+/**
+ * Build the full channel ladder status for a workspace.
+ * `maintainerEmail` is supplied by the caller (already computed from config).
+ * `featureFlagEnabled` gates the whole submit area (spec §12: flag off hides it
+ * and the endpoint 403s); channels still probe but the caller may drop the
+ * area entirely when the flag is off.
+ */
+export async function probeChannels(config, deps, maintainerEmail = '') {
+    const channels = [];
+    // 1. ingest — present iff ingest_url is configured; live-probed against /health.
+    if (config.ingestUrl.length === 0) {
+        channels.push({
+            id: 'ingest',
+            available: false,
+            reason: 'ingest 通道未配置',
+            nextAction: '在 .pd/config.yaml 配置 feedback.ingest_url 后重启 console',
+        });
+    }
+    else {
+        const entry = await cachedOrCompute(`ingest:${config.ingestUrl}`, () => probeIngestHealth(config.ingestUrl, { fetchFn: deps.fetchFn, timeoutMs: deps.probeTimeoutMs }).then((r) => ({
+            available: r.available,
+            reason: r.reason,
+            nextAction: r.nextAction,
+            at: Date.now(),
+        })));
+        channels.push({ id: 'ingest', available: entry.available, reason: entry.reason, nextAction: entry.nextAction });
+    }
+    // 2. github — present iff github_repo configured; gh CLI must exist + be authed.
+    if (config.githubRepo.length === 0) {
+        channels.push({
+            id: 'github',
+            available: false,
+            reason: 'gh 通道未配置',
+            nextAction: '在 .pd/config.yaml 配置 feedback.github_repo 后重启 console',
+        });
+    }
+    else {
+        const entry = await cachedOrCompute(`github:${config.githubRepo}`, () => detectGithubCli(deps).then((r) => ({
+            available: r.available,
+            reason: r.reason,
+            nextAction: r.nextAction,
+            at: Date.now(),
+        })));
+        channels.push({ id: 'github', available: entry.available, reason: entry.reason, nextAction: entry.nextAction });
+    }
+    // 3. email — always depends on a real maintainer email (never the placeholder).
+    if (maintainerEmail.length === 0 || maintainerEmail === 'maintainer@example.com') {
+        channels.push({
+            id: 'email',
+            available: false,
+            reason: '维护者邮箱未配置',
+            nextAction: '在 .pd/config.yaml 设置 feedback.maintainer_email 后重启 console',
+        });
+    }
+    else {
+        channels.push({ id: 'email', available: true });
+    }
+    // 4. file — always available (offline export).
+    channels.push({ id: 'file', available: true });
+    return { ok: true, channels };
+}

package/console/dist/server/feedback/github-adapter.d.ts

@@ -0,0 +1,44 @@
+import type * as childProcessNS from 'node:child_process';
+import type * as fsNS from 'node:fs';
+import type * as osNS from 'node:os';
+import type * as pathNS from 'node:path';
+import type { FeedbackReport } from '@principles/core/runtime-v2/feedback';
+import type { ChannelDeps } from './channels.js';
+type ExecFileFn = typeof childProcessNS.execFile;
+export type GithubCliResult = {
+    available: boolean;
+    reason?: string;
+    nextAction?: string;
+};
+export type GithubSubmitOutcome = {
+    ok: true;
+    issueUrl: string;
+} | {
+    ok: false;
+    reason: string;
+    nextAction: string;
+};
+export declare const DEFAULT_GH_TIMEOUT_MS = 30000;
+/**
+ * Detect whether the gh channel is usable: gh exists and `gh auth status` exits 0.
+ * Any execFile error (command missing / not authenticated / other) reports
+ * unavailable with a structured nextAction. Fail-closed here — unlike channel
+ * probing, a non-zero auth status genuinely means submission would fail.
+ */
+export declare function detectGithubCli(deps?: ChannelDeps): Promise<GithubCliResult>;
+/**
+ * gh issue create --repo <repo> --title <title> --body-file <tmp> --label feedback
+ * Writes the markdown body to a 0600 temp file, runs gh, deletes the temp file,
+ * then parses the issue URL from gh's stdout.
+ */
+export declare function submitToGithub(args: {
+    repo: string;
+    proxy?: string;
+    report: FeedbackReport;
+    execFile?: ExecFileFn;
+    fs?: typeof fsNS;
+    os?: typeof osNS;
+    path?: typeof pathNS;
+    timeoutMs?: number;
+}): Promise<GithubSubmitOutcome>;
+export {};

package/console/dist/server/feedback/github-adapter.js

@@ -0,0 +1,125 @@
+// github-adapter.ts
+// Server-side gh CLI channel adapter (spec §8.4). Secondary channel for
+// developers who can reach GitHub (proxy may be required domestically).
+//
+// - `execFile` with an argument array — zero shell concatenation (injection-safe).
+// - Body written to a 0600 temp file, deleted after submission.
+// - `github_proxy` sets HTTPS_PROXY for the child process when non-empty.
+// - 30s default timeout; success parses the issue URL from stdout.
+export const DEFAULT_GH_TIMEOUT_MS = 30_000;
+const GH_COMMAND = 'gh';
+function execFileAsync(execFile, opts) {
+    return new Promise((resolve, reject) => {
+        execFile(opts.cmd, opts.args, {
+            timeout: opts.timeoutMs,
+            windowsHide: true,
+            env: opts.proxy
+                ? { ...process.env, HTTPS_PROXY: opts.proxy, https_proxy: opts.proxy }
+                : process.env,
+        }, (err, stdout, stderr) => {
+            if (err) {
+                reject(err);
+                return;
+            }
+            resolve({ code: 0, stdout: stdout ?? '', stderr: stderr ?? '' });
+        });
+    });
+}
+async function safeUnlink(fsMod, file) {
+    try {
+        await fsMod.promises.unlink(file);
+    }
+    catch {
+        // Best-effort cleanup; the tmp dir is system-managed.
+    }
+}
+/**
+ * Detect whether the gh channel is usable: gh exists and `gh auth status` exits 0.
+ * Any execFile error (command missing / not authenticated / other) reports
+ * unavailable with a structured nextAction. Fail-closed here — unlike channel
+ * probing, a non-zero auth status genuinely means submission would fail.
+ */
+export async function detectGithubCli(deps) {
+    const execFile = deps?.execFile ?? (await import('node:child_process')).execFile;
+    // 1. gh present? A success here means the version probe ran without error.
+    try {
+        await execFileAsync(execFile, { cmd: GH_COMMAND, args: ['--version'], timeoutMs: 5_000 });
+    }
+    catch {
+        return {
+            available: false,
+            reason: '未安装 gh CLI',
+            nextAction: '安装 GitHub CLI:https://cli.github.com/ 后重试',
+        };
+    }
+    // 2. authenticated?
+    try {
+        await execFileAsync(execFile, { cmd: GH_COMMAND, args: ['auth', 'status'], timeoutMs: 5_000 });
+        return { available: true };
+    }
+    catch {
+        return {
+            available: false,
+            reason: 'gh 未登录 GitHub',
+            nextAction: '运行 `gh auth login` 完成登录后重试',
+        };
+    }
+}
+/**
+ * gh issue create --repo <repo> --title <title> --body-file <tmp> --label feedback
+ * Writes the markdown body to a 0600 temp file, runs gh, deletes the temp file,
+ * then parses the issue URL from gh's stdout.
+ */
+export async function submitToGithub(args) {
+    const execFile = args.execFile ?? (await import('node:child_process')).execFile;
+    const fsMod = args.fs ?? (await import('node:fs'));
+    const osMod = args.os ?? (await import('node:os'));
+    const pathMod = args.path ?? (await import('node:path'));
+    const timeoutMs = args.timeoutMs ?? DEFAULT_GH_TIMEOUT_MS;
+    const { title, id, outputs } = args.report;
+    const body = outputs?.markdown ?? '';
+    // Write body to a 0600 temp file to avoid leaking via argv / shell quoting.
+    const tmpFile = pathMod.join(osMod.tmpdir(), `pd-feedback-${id}.md`);
+    try {
+        await fsMod.promises.writeFile(tmpFile, body, { encoding: 'utf8', mode: 0o600 });
+    }
+    catch (err) {
+        return {
+            ok: false,
+            reason: `无法写入临时文件写入 gh 正文:${err instanceof Error ? err.message : String(err)}`,
+            nextAction: '检查临时目录可写后重试;或改用反馈服务通道',
+        };
+    }
+    let out;
+    try {
+        out = await execFileAsync(execFile, {
+            cmd: GH_COMMAND,
+            args: ['issue', 'create', '--repo', args.repo, '--title', title, '--body-file', tmpFile, '--label', 'feedback'],
+            timeoutMs,
+            proxy: args.proxy && args.proxy.length > 0 ? args.proxy : undefined,
+        });
+    }
+    catch (err) {
+        await safeUnlink(fsMod, tmpFile);
+        const reason = err instanceof Error
+            ? err.code === 'ETIMEDOUT'
+                ? `gh 提交超时(${timeoutMs}ms)`
+                : err.message
+            : String(err);
+        return {
+            ok: false,
+            reason: `gh 建单失败:${reason}`,
+            nextAction: '确认 gh 已登录且网络可达(可能需要代理);重试或改用反馈服务通道',
+        };
+    }
+    await safeUnlink(fsMod, tmpFile);
+    const urlMatch = /\bhttps:\/\/github\.com\/\S+\b/.exec(out.stdout);
+    if (!urlMatch) {
+        return {
+            ok: false,
+            reason: 'gh 建单成功但无法解析 issue 链接',
+            nextAction: '在 GitHub 仓库确认新 issue 已创建,并把链接手动记下',
+        };
+    }
+    return { ok: true, issueUrl: urlMatch[0] };
+}

package/console/dist/server/feedback/ingest-adapter.d.ts

@@ -0,0 +1,45 @@
+import type { FeedbackReport } from '@principles/core/runtime-v2/feedback';
+export interface IngestHealthResult {
+    available: boolean;
+    reason?: string;
+    nextAction?: string;
+}
+export type IngestSubmitOutcome = {
+    ok: true;
+    trackingId?: string;
+    issueUrl?: string;
+    duplicate: boolean;
+    count?: number;
+} | {
+    ok: false;
+    /** HTTP status from the relay when reachable; 0 for network/timeout failure. */
+    status: number;
+    reason: string;
+    nextAction: string;
+};
+export declare const DEFAULT_INGEST_TIMEOUT_MS = 20000;
+export declare const DEFAULT_PROBE_TIMEOUT_MS = 2500;
+/**
+ * Probe the relay `/health` endpoint (spec §9.1) for channels availability.
+ * Any HTTP response (2xx/4xx/5xx) other than a network/timeout error counts as
+ * "reachable" (fail-open — an auth'd health endpoint may legitimately 401; we
+ * only need to confirm a server exists). Non-2xx → available:true so the submit
+ * path can surface a precise relay reason instead of hiding the channel.
+ */
+export declare function probeIngestHealth(ingestUrl: string, deps?: {
+    fetchFn?: typeof fetch;
+    timeoutMs?: number;
+}): Promise<IngestHealthResult>;
+/**
+ * Submit a report body to the relay (POST {ingestUrl}).
+ * Success = any 2xx; the relay returns 202 with { trackingId, issueUrl, duplicate, count }.
+ */
+export declare function submitToIngest(args: {
+    url: string;
+    token: string;
+    report: FeedbackReport;
+    fingerprint: string;
+    area?: string;
+    fetchFn?: typeof fetch;
+    timeoutMs?: number;
+}): Promise<IngestSubmitOutcome>;

package/console/dist/server/feedback/ingest-adapter.js

@@ -0,0 +1,129 @@
+// ingest-adapter.ts
+// Server-side adapter that POSTs a redacted, saved feedback draft to the
+// configured relay endpoint (spec §8.3). The relay is reachable domestically
+// (same origin as the official site), so domestic novices never touch GitHub.
+//
+// - Token lives only in server config (never the browser).
+// - 20s default timeout (relay calls Linear on the happy path).
+// - Failure returns a structured reason + nextAction (rc-9).
+export const DEFAULT_INGEST_TIMEOUT_MS = 20_000;
+export const DEFAULT_PROBE_TIMEOUT_MS = 2_500;
+async function fetchWithTimeout(args) {
+    const { fetchFn, url, init, timeoutMs } = args;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return await fetchFn(url, { ...init, signal: controller.signal });
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/**
+ * Probe the relay `/health` endpoint (spec §9.1) for channels availability.
+ * Any HTTP response (2xx/4xx/5xx) other than a network/timeout error counts as
+ * "reachable" (fail-open — an auth'd health endpoint may legitimately 401; we
+ * only need to confirm a server exists). Non-2xx → available:true so the submit
+ * path can surface a precise relay reason instead of hiding the channel.
+ */
+export async function probeIngestHealth(ingestUrl, deps) {
+    const fetchFn = deps?.fetchFn ?? globalThis.fetch;
+    const timeoutMs = deps?.timeoutMs ?? DEFAULT_PROBE_TIMEOUT_MS;
+    const healthUrl = `${ingestUrl.replace(/\/+$/, '')}/health`;
+    if (typeof fetchFn !== 'function') {
+        return {
+            available: false,
+            reason: '当前运行环境不支持 fetch',
+            nextAction: '使用 Node 18+ 运行 console,或改用导出文件通道',
+        };
+    }
+    try {
+        await fetchWithTimeout({ fetchFn, url: healthUrl, init: { method: 'GET' }, timeoutMs });
+        return { available: true };
+    }
+    catch (err) {
+        const reason = err instanceof Error
+            ? (err.name === 'AbortError' ? `探活超时(${timeoutMs}ms)` : err.message)
+            : String(err);
+        return {
+            available: false,
+            reason: `无法连接反馈服务:${reason}`,
+            nextAction: '检查网络;或改用导出文件通道',
+        };
+    }
+}
+/**
+ * Submit a report body to the relay (POST {ingestUrl}).
+ * Success = any 2xx; the relay returns 202 with { trackingId, issueUrl, duplicate, count }.
+ */
+export async function submitToIngest(args) {
+    const { url, token } = args;
+    const fetchFn = args.fetchFn ?? globalThis.fetch;
+    const timeoutMs = args.timeoutMs ?? DEFAULT_INGEST_TIMEOUT_MS;
+    const payload = {
+        report: args.report,
+        fingerprint: args.fingerprint,
+        area: typeof args.area === 'string' ? args.area : undefined,
+    };
+    let res;
+    try {
+        res = await fetchWithTimeout({
+            fetchFn,
+            url,
+            init: {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${token}`,
+                },
+                body: JSON.stringify(payload),
+            },
+            timeoutMs,
+        });
+    }
+    catch (err) {
+        const reason = err instanceof Error
+            ? (err.name === 'AbortError' ? `提交超时(${timeoutMs}ms)` : err.message)
+            : String(err);
+        return {
+            ok: false,
+            status: 0,
+            reason: `反馈服务不可达:${reason}`,
+            nextAction: '检查网络后重试;或使用导出文件通道发送给维护者',
+        };
+    }
+    if (res.status >= 200 && res.status < 300) {
+        const outcome = {
+            ok: true,
+            duplicate: false,
+        };
+        try {
+            const body = await res.json();
+            if (body !== null && typeof body === 'object') {
+                const b = body;
+                if (typeof b.trackingId === 'string')
+                    outcome.trackingId = b.trackingId;
+                if (typeof b.issueUrl === 'string')
+                    outcome.issueUrl = b.issueUrl;
+                if (typeof b.duplicate === 'boolean')
+                    outcome.duplicate = b.duplicate;
+                if (typeof b.count === 'number')
+                    outcome.count = b.count;
+            }
+        }
+        catch {
+            // 2xx with non-JSON body: still consider submission accepted; no receipt fields.
+        }
+        return outcome;
+    }
+    return {
+        ok: false,
+        status: res.status,
+        reason: `反馈服务返回 ${res.status}`,
+        nextAction: res.status === 429
+            ? '请求过于频繁,请稍后重试'
+            : res.status === 413
+                ? '内容过长,请精简后重试'
+                : `反馈服务异常,请稍后重试;或导出文件发送给维护者`,
+    };
+}

package/console/dist/server/feedback/submit-service.d.ts

@@ -0,0 +1,44 @@
+import { type FeedbackSubmittedVia } from '@principles/core/runtime-v2/feedback';
+import type * as childProcessNS from 'node:child_process';
+import type * as fsNS from 'node:fs';
+import type * as osNS from 'node:os';
+import type * as pathNS from 'node:path';
+import type { FeedbackChannelConfig } from '../config/pd-config-store.js';
+import type { FeedbackReportConsoleModel } from '../models/FeedbackReportConsoleModel.js';
+type ExecFileFn = typeof childProcessNS.execFile;
+export type SubmitChannel = 'ingest' | 'github';
+export type SubmitReportResult = {
+    ok: true;
+    alreadySubmitted: boolean;
+    status: 'submitted';
+    submittedVia?: FeedbackSubmittedVia;
+    trackingId?: string;
+    externalUrl?: string;
+    writeBackFailed?: boolean;
+    nextAction?: string;
+} | {
+    ok: false;
+    statusCode: number;
+    error: string;
+    message: string;
+    nextAction: string;
+};
+export type SubmitDeps = {
+    fetchFn?: typeof fetch;
+    execFile?: ExecFileFn;
+    fs?: typeof fsNS;
+    os?: typeof osNS;
+    path?: typeof pathNS;
+};
+/**
+ * Submit a saved draft by id through the given channel. `maintainerEmail`
+ * (route-level) is accepted separately for parity/future use.
+ */
+export declare function submitReport(opts: {
+    model: FeedbackReportConsoleModel;
+    reportId: string;
+    channel: SubmitChannel;
+    config: FeedbackChannelConfig;
+    deps?: SubmitDeps;
+}): Promise<SubmitReportResult>;
+export {};