@sovovs/bycli 1.8.0 → 2.1.0

package/dist/src/manifest-schema.js

@@ -0,0 +1,162 @@
+export class ManifestSchemaError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ManifestSchemaError';
+    }
+}
+function fail(context, path, reason) {
+    throw new ManifestSchemaError(`${context} ${path}: ${reason}`);
+}
+function markSeen(value, context, path, seen) {
+    if (seen.has(value))
+        fail(context, path, 'cyclic or repeated/shared object identities cannot be represented faithfully in JSON');
+    seen.add(value);
+}
+function denseArrayValues(value, context, path) {
+    if (Object.getPrototypeOf(value) !== Array.prototype) {
+        fail(context, path, 'must be a standard JSON array (custom array instances are not supported)');
+    }
+    if (Object.getOwnPropertySymbols(value).length > 0) {
+        fail(context, path, 'symbol-keyed array properties cannot be represented in JSON');
+    }
+    const propertyNames = Object.getOwnPropertyNames(value);
+    const expectedNames = new Set(['length']);
+    for (let index = 0; index < value.length; index += 1)
+        expectedNames.add(String(index));
+    for (const propertyName of propertyNames) {
+        if (!expectedNames.has(propertyName)) {
+            fail(context, `${path}.${propertyName}`, 'extra array properties cannot be represented in JSON');
+        }
+    }
+    if (propertyNames.length !== expectedNames.size) {
+        fail(context, path, 'sparse arrays cannot be represented faithfully in JSON');
+    }
+    const lengthDescriptor = Object.getOwnPropertyDescriptor(value, 'length');
+    if (!lengthDescriptor
+        || !('value' in lengthDescriptor)
+        || lengthDescriptor.value !== value.length
+        || lengthDescriptor.enumerable
+        || lengthDescriptor.configurable
+        || !lengthDescriptor.writable) {
+        fail(context, `${path}.length`, 'non-standard array length descriptors cannot be represented faithfully in JSON');
+    }
+    const values = [];
+    for (let index = 0; index < value.length; index += 1) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+        if (!descriptor)
+            fail(context, `${path}[${index}]`, 'sparse arrays cannot be represented faithfully in JSON');
+        if (!('value' in descriptor)
+            || !descriptor.enumerable
+            || !descriptor.configurable
+            || !descriptor.writable) {
+            fail(context, `${path}[${index}]`, 'non-standard array item descriptors cannot be represented faithfully in JSON');
+        }
+        values.push(descriptor.value);
+    }
+    return values;
+}
+function canonicalJsonValue(value, context, path, seen) {
+    if (value === null)
+        return 'null';
+    if (typeof value === 'string')
+        return `string:${JSON.stringify(value)}`;
+    if (typeof value === 'boolean')
+        return `boolean:${value}`;
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value))
+            fail(context, path, 'must be a finite JSON number');
+        if (Object.is(value, -0))
+            fail(context, path, 'negative zero cannot be represented faithfully in JSON');
+        return `number:${String(value)}`;
+    }
+    if (value === undefined)
+        fail(context, path, 'explicit undefined cannot be represented in JSON');
+    if (typeof value === 'function')
+        fail(context, path, 'functions cannot be represented in JSON');
+    if (typeof value === 'symbol')
+        fail(context, path, 'symbols cannot be represented in JSON');
+    if (typeof value === 'bigint')
+        fail(context, path, 'bigints cannot be represented in JSON');
+    markSeen(value, context, path, seen);
+    {
+        if (Array.isArray(value)) {
+            const items = denseArrayValues(value, context, path)
+                .map((item, index) => canonicalJsonValue(item, context, `${path}[${index}]`, seen));
+            return `array:[${items.join(',')}]`;
+        }
+        if (Object.getPrototypeOf(value) !== Object.prototype) {
+            fail(context, path, 'must be a plain JSON object (Date and custom instances are not supported)');
+        }
+        if (Object.getOwnPropertySymbols(value).length > 0) {
+            fail(context, path, 'symbol-keyed properties cannot be represented in JSON');
+        }
+        const propertyNames = Object.getOwnPropertyNames(value);
+        const entries = [];
+        for (const key of propertyNames.sort()) {
+            const descriptor = Object.getOwnPropertyDescriptor(value, key);
+            if (!descriptor?.enumerable
+                || !('value' in descriptor)
+                || !descriptor.configurable
+                || !descriptor.writable) {
+                fail(context, `${path}.${key}`, 'only enumerable data properties can be represented faithfully in JSON');
+            }
+            entries.push(`${JSON.stringify(key)}:${canonicalJsonValue(descriptor.value, context, `${path}.${key}`, seen)}`);
+        }
+        return `object:{${entries.join(',')}}`;
+    }
+}
+function optionalBoolean(value, context, path) {
+    if (value === undefined)
+        return false;
+    if (typeof value !== 'boolean')
+        fail(context, path, 'must be a boolean when present');
+    return value;
+}
+/**
+ * Canonical execution-relevant argument schema used by both manifest build and
+ * runtime hydration. Objects are key-order independent; arrays remain ordered.
+ */
+export function canonicalizeManifestArgSchema(args, context) {
+    if (!Array.isArray(args))
+        fail(context, 'args', 'must be a dense array');
+    const seen = new Set();
+    markSeen(args, context, 'args', seen);
+    const argValues = denseArrayValues(args, context, 'args');
+    return argValues.map((arg, index) => {
+        const argContext = `${context} argument "${String(arg.name)}"`;
+        if (typeof arg.name !== 'string' || arg.name.length === 0)
+            fail(argContext, 'name', 'must be a non-empty string');
+        if (arg.type !== undefined && typeof arg.type !== 'string')
+            fail(argContext, 'type', 'must be a string when present');
+        if (arg.help !== undefined && typeof arg.help !== 'string')
+            fail(argContext, 'help', 'must be a string when present');
+        const hasDefault = Object.prototype.hasOwnProperty.call(arg, 'default');
+        const defaultValue = hasDefault
+            ? canonicalJsonValue(arg.default, argContext, 'default', seen)
+            : 'missing';
+        const hasChoices = Object.prototype.hasOwnProperty.call(arg, 'choices');
+        let choices = 'missing';
+        if (hasChoices) {
+            if (!Array.isArray(arg.choices))
+                fail(argContext, 'choices', 'must be an array of strings when present');
+            markSeen(arg.choices, argContext, 'choices', seen);
+            choices = `array:[${denseArrayValues(arg.choices, argContext, 'choices').map((choice, choiceIndex) => {
+                if (typeof choice !== 'string') {
+                    fail(argContext, `choices[${choiceIndex}]`, 'choice values must be strings');
+                }
+                return `string:${JSON.stringify(choice)}`;
+            }).join(',')}]`;
+        }
+        return [
+            `arg:${index}`,
+            `name:${JSON.stringify(arg.name)}`,
+            `type:${JSON.stringify(arg.type ?? 'str')}`,
+            `default:${defaultValue}`,
+            `required:${optionalBoolean(arg.required, argContext, 'required')}`,
+            `valueRequired:${optionalBoolean(arg.valueRequired, argContext, 'valueRequired')}`,
+            `positional:${optionalBoolean(arg.positional, argContext, 'positional')}`,
+            `help:${JSON.stringify(arg.help ?? '')}`,
+            `choices:${choices}`,
+        ].join('|');
+    }).join('||');
+}

package/dist/src/manifest-schema.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/manifest-types.d.ts

@@ -15,7 +15,7 @@ export interface ManifestEntry {
     example?: string;
     domain?: string;
     strategy: string;
-    browser: boolean;
+    browser: boolean | 'conditional';
     args: Array<{
         name: string;
         type?: string;

package/dist/src/observation/redaction.js

@@ -10,7 +10,13 @@ const SENSITIVE_HEADER_NAMES = new Set([
     'x-xsrf-token',
 ]);
 const SENSITIVE_FIELD_PATTERN = /(password|passwd|pwd|token|secret|authorization|cookie|set-cookie|api[_-]?key|access[_-]?token|refresh[_-]?token|session[_-]?id|csrf|xsrf)/i;
-const SENSITIVE_URL_PARAMS = /([?&])(token|key|secret|password|auth|access_token|api_key|session_id|csrf|xsrf)=[^&]*/gi;
+const SENSITIVE_URL_PARAMS = /([?&])(token|key|secret|fingerprint|password|auth|access_token|api_key|session_id|csrf|xsrf)=[^&]*/gi;
+function hasFingerprintFieldSegment(name) {
+    return name
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+        .split(/[-_.\s]+/)
+        .some((segment) => segment.toLowerCase() === 'fingerprint');
+}
 export function redactUrl(url) {
     return url.replace(SENSITIVE_URL_PARAMS, '$1$2=[REDACTED]');
 }
@@ -31,8 +37,8 @@ export function redactText(text, opts = {}) {
     const max = opts.maxStringLength ?? 50_000;
     let out = text
         .replace(/Bearer\s+[A-Za-z0-9\-._~+/]+=*/gi, 'Bearer [REDACTED]')
-        .replace(/(["'])(password|passwd|pwd|token|secret|api_key|apikey|access_token|session_id)\1\s*:\s*(["'])(.*?)\3/gi, '$1$2$1:$3[REDACTED]$3')
-        .replace(/(token|secret|password|api_key|apikey|access_token|session_id)[=:]\s*['"]?[^'"\s,;}&]+['"]?/gi, '$1=[REDACTED]')
+        .replace(/(["'])(password|passwd|pwd|token|secret|fingerprint|api_key|apikey|access_token|session_id)\1\s*:\s*(["'])(.*?)\3/gi, '$1$2$1:$3[REDACTED]$3')
+        .replace(/(token|secret|fingerprint|password|api_key|apikey|access_token|session_id)\s*[=:]\s*['"]?[^'"\s,;}&]+['"]?/gi, '$1=[REDACTED]')
         .replace(/(cookie[=:]\s*)[^\n;]{3,}/gi, '$1[REDACTED]')
         .replace(/eyJ[A-Za-z0-9_-]{10,}\.eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/g, '[REDACTED_JWT]');
     if (out.length > max)
@@ -41,7 +47,7 @@ export function redactText(text, opts = {}) {
 }
 export function redactValue(value, opts = {}, keyHint, depth = 0) {
     const allow = new Set((opts.allowlist ?? []).map((key) => key.toLowerCase()));
-    if (keyHint && SENSITIVE_FIELD_PATTERN.test(keyHint) && !allow.has(keyHint.toLowerCase())) {
+    if (keyHint && (SENSITIVE_FIELD_PATTERN.test(keyHint) || hasFingerprintFieldSegment(keyHint)) && !allow.has(keyHint.toLowerCase())) {
         return DEFAULT_REDACTION;
     }
     if (typeof value === 'string') {

package/dist/src/plugin.js

@@ -1013,13 +1013,16 @@ function getPluginSource(dir) {
 }
 /** Parse a plugin source string into clone URL, repo name, and optional sub-plugin. */
 function parseSource(source) {
+    // Strip either the legacy `bycli-plugin-` or the current `opencli-plugin-`
+    // repo-name prefix when deriving the local plugin name.
+    const PLUGIN_NAME_PREFIX = /^(?:bycli|opencli)-plugin-/;
     if (source.startsWith('file://')) {
         try {
             const localPath = path.resolve(fileURLToPath(source));
             return {
                 type: 'local',
                 localPath,
-                name: path.basename(localPath).replace(/^bycli-plugin-/, ''),
+                name: path.basename(localPath).replace(PLUGIN_NAME_PREFIX, ''),
             };
         }
         catch {
@@ -1031,14 +1034,14 @@ function parseSource(source) {
         return {
             type: 'local',
             localPath,
-            name: path.basename(localPath).replace(/^bycli-plugin-/, ''),
+            name: path.basename(localPath).replace(PLUGIN_NAME_PREFIX, ''),
         };
     }
     // github:user/repo/subplugin  (monorepo specific sub-plugin)
     const githubSubMatch = source.match(/^github:([\w.-]+)\/([\w.-]+)\/([\w.-]+)$/);
     if (githubSubMatch) {
         const [, user, repo, sub] = githubSubMatch;
-        const name = repo.replace(/^bycli-plugin-/, '');
+        const name = repo.replace(PLUGIN_NAME_PREFIX, '');
         return {
             type: 'git',
             cloneUrl: `https://github.com/${user}/${repo}.git`,
@@ -1050,7 +1053,7 @@ function parseSource(source) {
     const githubMatch = source.match(/^github:([\w.-]+)\/([\w.-]+)$/);
     if (githubMatch) {
         const [, user, repo] = githubMatch;
-        const name = repo.replace(/^bycli-plugin-/, '');
+        const name = repo.replace(PLUGIN_NAME_PREFIX, '');
         return {
             type: 'git',
             cloneUrl: `https://github.com/${user}/${repo}.git`,
@@ -1061,7 +1064,7 @@ function parseSource(source) {
     const urlMatch = source.match(/^https?:\/\/github\.com\/([\w.-]+)\/([\w.-]+?)(?:\.git)?$/);
     if (urlMatch) {
         const [, user, repo] = urlMatch;
-        const name = repo.replace(/^bycli-plugin-/, '');
+        const name = repo.replace(PLUGIN_NAME_PREFIX, '');
         return {
             type: 'git',
             cloneUrl: `https://github.com/${user}/${repo}.git`,
@@ -1075,7 +1078,7 @@ function parseSource(source) {
         const pathPart = sshUrlMatch[1];
         const segments = pathPart.split('/');
         const repoSegment = segments.pop();
-        const name = repoSegment.replace(/^bycli-plugin-/, '');
+        const name = repoSegment.replace(PLUGIN_NAME_PREFIX, '');
         return { type: 'git', cloneUrl: source, name };
     }
     // git@host:user/repo.git (SCP-style)
@@ -1084,7 +1087,7 @@ function parseSource(source) {
         const pathPart = scpMatch[1];
         const segments = pathPart.split('/');
         const repoSegment = segments.pop();
-        const name = repoSegment.replace(/^bycli-plugin-/, '');
+        const name = repoSegment.replace(PLUGIN_NAME_PREFIX, '');
         return { type: 'git', cloneUrl: source, name };
     }
     // Generic https/http git URL (non-GitHub hosts)
@@ -1093,7 +1096,7 @@ function parseSource(source) {
         const pathPart = genericHttpMatch[1];
         const segments = pathPart.split('/');
         const repoSegment = segments.pop();
-        const name = repoSegment.replace(/^bycli-plugin-/, '');
+        const name = repoSegment.replace(PLUGIN_NAME_PREFIX, '');
         // Ensure clone URL ends with .git
         const cloneUrl = source.endsWith('.git') ? source : `${source}.git`;
         return { type: 'git', cloneUrl, name };

package/dist/src/recorder/highlevel/analyze.d.ts

@@ -0,0 +1,29 @@
+/**
+ * High-Level analyze module (M5a, 07-high-level-services.md · analyzeBrowser).
+ *
+ * Module-first (ADR-0004): drives the Page abstraction through the multi-step
+ * site probe (goto / wait / network capture / window-global probe / cookies) to
+ * assemble PageSignals, then calls the PURE analyzeSite() classifier. In-process
+ * async, no child process (07:50). Hosted by the main-repo daemon high-level
+ * surface (Codex A' verdict); dashboard-be only forwards.
+ *
+ * Timeout surfaces as `analyze_timeout` (07:52), never a runner error.
+ */
+import type { IPage } from '../../types.js';
+import { type AdapterRef, type AnalyzeReport } from '../../browser/analyze.js';
+export interface AnalyzeInput {
+    url: string;
+    /** site-level settle window after load (ms); default 2000 (07 input). */
+    settleMs?: number;
+}
+export declare class AnalyzeTimeoutError extends Error {
+    readonly code = "analyze_timeout";
+    constructor(ms: number);
+}
+/**
+ * Collect PageSignals by driving the page, then classify with the pure analyzeSite.
+ * `registry` is the adapter registry used for nearest-adapter matching.
+ */
+export declare function analyzeBrowser(page: IPage, registry: Map<string, AdapterRef>, input: AnalyzeInput): Promise<AnalyzeReport>;
+/** Wrap analyzeBrowser with a deadline → AnalyzeTimeoutError (07:52 analyze_timeout). */
+export declare function analyzeBrowserWithTimeout(page: IPage, registry: Map<string, AdapterRef>, input: AnalyzeInput, timeoutMs: number): Promise<AnalyzeReport>;

package/dist/src/recorder/highlevel/analyze.js

@@ -0,0 +1,91 @@
+/**
+ * High-Level analyze module (M5a, 07-high-level-services.md · analyzeBrowser).
+ *
+ * Module-first (ADR-0004): drives the Page abstraction through the multi-step
+ * site probe (goto / wait / network capture / window-global probe / cookies) to
+ * assemble PageSignals, then calls the PURE analyzeSite() classifier. In-process
+ * async, no child process (07:50). Hosted by the main-repo daemon high-level
+ * surface (Codex A' verdict); dashboard-be only forwards.
+ *
+ * Timeout surfaces as `analyze_timeout` (07:52), never a runner error.
+ */
+import { analyzeSite } from '../../browser/analyze.js';
+import { generateInterceptorJs } from '../../interceptor.js';
+export class AnalyzeTimeoutError extends Error {
+    code = 'analyze_timeout';
+    constructor(ms) {
+        super(`analyze timed out after ${ms}ms`);
+        this.name = 'AnalyzeTimeoutError';
+    }
+}
+const DEFAULT_SETTLE_MS = 2000;
+/** Window-global + cookie + finalUrl probe (mirrors the CLI analyze probe). */
+const PROBE_JS = `(function(){
+  return {
+    cookieNames: (document.cookie || '').split(';').map(function(c){ return c.trim().split('=')[0]; }).filter(Boolean),
+    initialState: {
+      __INITIAL_STATE__: typeof window.__INITIAL_STATE__ !== 'undefined',
+      __NUXT__: typeof window.__NUXT__ !== 'undefined',
+      __NEXT_DATA__: typeof window.__NEXT_DATA__ !== 'undefined',
+      __APOLLO_STATE__: typeof window.__APOLLO_STATE__ !== 'undefined',
+    },
+    title: document.title || '',
+    finalUrl: location.href,
+  };
+})()`;
+/**
+ * Collect PageSignals by driving the page, then classify with the pure analyzeSite.
+ * `registry` is the adapter registry used for nearest-adapter matching.
+ */
+export async function analyzeBrowser(page, registry, input) {
+    const settleMs = input.settleMs ?? DEFAULT_SETTLE_MS;
+    // Prefer the session-level CDP network capture; fall back to an injected interceptor.
+    const hasSessionCapture = (await page.startNetworkCapture?.()) ?? false;
+    await page.goto(input.url);
+    await page.wait(Math.max(1, Math.round(settleMs / 1000)));
+    if (!hasSessionCapture) {
+        // match-all: analyze wants every json/text response, not a filtered subset.
+        try {
+            await page.evaluate(generateInterceptorJs('true'));
+        }
+        catch { /* non-fatal */ }
+    }
+    await page.wait(1);
+    const rawItems = ((await page.readNetworkCapture?.()) ?? []);
+    const networkEntries = rawItems.map((e) => ({
+        url: e.url ?? '',
+        status: e.status ?? 0,
+        contentType: e.ct ?? '',
+        bodyPreview: typeof e.body === 'string'
+            ? e.body.slice(0, 2000)
+            : (e.body ? JSON.stringify(e.body).slice(0, 2000) : null),
+    }));
+    const probe = await page.evaluate(PROBE_JS);
+    const browserCookieNames = (await page.getCookies({ url: probe.finalUrl || input.url }).catch(() => []))
+        .map((c) => c.name)
+        .filter(Boolean);
+    const cookieNames = [...new Set([...probe.cookieNames, ...browserCookieNames])];
+    const signals = {
+        requestedUrl: input.url,
+        finalUrl: probe.finalUrl,
+        cookieNames,
+        networkEntries,
+        initialState: probe.initialState,
+        title: probe.title,
+    };
+    return analyzeSite(signals, registry);
+}
+/** Wrap analyzeBrowser with a deadline → AnalyzeTimeoutError (07:52 analyze_timeout). */
+export async function analyzeBrowserWithTimeout(page, registry, input, timeoutMs) {
+    let timer;
+    const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new AnalyzeTimeoutError(timeoutMs)), timeoutMs);
+    });
+    try {
+        return await Promise.race([analyzeBrowser(page, registry, input), timeout]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}

package/dist/src/recorder/highlevel/init.d.ts

@@ -0,0 +1,125 @@
+/**
+ * High-Level init module (M5b · createAdapterDraft, 07-high-level-services.md).
+ *
+ * Hosted main-repo side (Codex A' verdict): FS writes live here, not in dashboard-be.
+ * Uses the PURE pieces from @sovovs/bycli-recorder-core (validate/render/provenance/
+ * dry-run); this module adds the IO: overwrite/shadow check, write to disk, commit
+ * marker, config-snapshot injection.
+ *
+ * SCOPE (甲 / phase-1): writes report + adapter with an embedded provenance header
+ * and a commit marker, so a visible adapter always carries provenance (07 forbids an
+ * un-provenanced adapter). The FULL multi-file atomic write transaction (txn manifest
+ * + fsync + atomic rename) and the crash-recovery table (07:97-104) are deferred —
+ * tracked as M5b follow-up. Until then writes are direct (non-atomic), which is
+ * acceptable for a single-user local tool with the provenance+marker guard.
+ */
+import { type DryRunDiff } from '@sovovs/bycli-recorder-core';
+/**
+ * High-Level init input (be → daemon /v1/init). Per 03:74 these are the DERIVED draft inputs:
+ * be derives `domain`/`strategy` from the selected RankCandidate (the UI-facing Recorder
+ * InitRequest is select-only and never carries them). `browser` is normally omitted and
+ * derived from `strategy` (COOKIE/UI ⇒ true), matching registry normalizeCommand; pass it
+ * only to force a value.
+ */
+export interface InitInput {
+    /** site/command */
+    name: string;
+    /** derived by be from the candidate endpoint host (03:74). */
+    domain?: string;
+    /** derived by be from the candidate: authRequired ⇒ COOKIE else PUBLIC (03:74). */
+    strategy?: 'PUBLIC' | 'COOKIE' | 'UI';
+    /** optional explicit override; default is derived from strategy (COOKIE/UI ⇒ true). */
+    browser?: boolean;
+    /** ADR-0005: required when writePolicy=write. */
+    writePolicy?: 'dry-run' | 'write';
+    responsibleUseAcknowledgedAt?: number;
+    /** LLM 合成产物(MVP):有则填进 adapter 模板留白(func/columns/...);无则空骨架(行为不变)。 */
+    funcBody?: string;
+    columns?: Array<{
+        name: string;
+    }>;
+    description?: string;
+    access?: 'read' | 'write';
+    /** 合成所用模型;标进 provenance(@generated-by adapter-recorder-llm + @model)。 */
+    llmModel?: string;
+}
+/** Config snapshot injected into every RecorderReport (09). */
+export interface ConfigSnapshot {
+    releaseChannel: 'stable' | 'preview';
+    localExperimentProfile: 'off' | 'control' | 'candidate';
+    configSnapshotVersion: number;
+}
+export interface RecorderReport {
+    adapterPath: string;
+    reportPath: string;
+    warnings: string[];
+    responsibleUseAcknowledgedAt: number;
+    releaseChannel: string;
+    localExperimentProfile: string;
+    configSnapshotVersion: number;
+}
+export type InitResult = {
+    ok: true;
+    report: RecorderReport;
+    dryRun: DryRunDiff;
+    generatedSource: string;
+} | {
+    ok: false;
+    errorCode: 'validation_failed' | 'responsible_use_required';
+    reason: string;
+};
+/** Transaction manifest persisted under the recorder `.txn` dir (07:99). The crash-recovery
+ * sweep (recoverInitTransactions) reads these to resolve interrupted writes. */
+export interface InitTxnManifest {
+    txnId: string;
+    adapterPath: string;
+    reportPath: string;
+    markerPath: string;
+    adapterSha256: string;
+    reportSha256: string;
+    state: 'preparing' | 'committed';
+    createdAt: number;
+}
+/**
+ * Create an adapter draft. With writePolicy 'dry-run' (default) nothing is written —
+ * only the diff + intended report is returned. With 'write' it requires
+ * responsibleUseAcknowledgedAt (ADR-0005) and writes report + adapter to disk.
+ */
+export declare function createAdapterDraft(input: InitInput, snapshot?: ConfigSnapshot): InitResult;
+export interface SaveAdapterInput {
+    /** site/command */
+    name: string;
+    /** 完整 adapter 源码(已审阅;若无 provenance 头会自动补)。 */
+    source: string;
+    /** 生成所用模型(标进 provenance)。 */
+    llmModel?: string;
+}
+export type SaveAdapterResult = {
+    ok: true;
+    adapterPath: string;
+    reportPath: string;
+} | {
+    ok: false;
+    errorCode: 'validation_failed';
+    reason: string;
+};
+export declare function saveAdapterSource(input: SaveAdapterInput): SaveAdapterResult;
+export interface InitRecoveryResult {
+    scanned: number;
+    committed: number;
+    rolledForward: number;
+    rolledBack: number;
+    quarantined: number;
+}
+/**
+ * Resolve init write transactions interrupted by a crash (07:106-117). Scans every
+ * ~/.bycli/sites/<site>/recorder/.txn/*.manifest.json, observes the referenced artifacts, and
+ * applies decideInitRecovery: write/refresh the marker for a provenance-complete transaction,
+ * quarantine an unprovenanced/corrupt adapter, or roll back an empty one. Only manifest paths
+ * (and adapters with the provenance header) are touched — unknown user files are never deleted.
+ * Designed to run once at daemon startup (extends the verify reap).
+ */
+export declare function recoverInitTransactions(opts?: {
+    sitesRoot?: string;
+    log?: (msg: string) => void;
+}): InitRecoveryResult;