@cjhyy/code-shell-core 0.5.0-rc.1 → 0.6.0-rc.1

package/dist/tool-system/builtin/memory.js

@@ -25,9 +25,23 @@ function parseScope(raw) {
     }
     return raw;
 }
-function mmFor(ctx, scope) {
-    return new MemoryManager({ projectDir: ctx?.cwd, scope });
+/** Location: "global" → cross-project store (no projectDir); "project"
+ *  (default, back-compat) → this repo's store. Anything else → "project". */
+function parseLocation(raw) {
+    return raw === "global" ? "global" : "project";
 }
+function mmFor(ctx, scope, location = "project") {
+    // location=global → omit projectDir so the manager points at the global store.
+    return new MemoryManager({
+        projectDir: location === "global" ? undefined : ctx?.cwd,
+        scope,
+    });
+}
+const LOCATION_SCHEMA = {
+    type: "string",
+    enum: ["global", "project"],
+    description: 'Which store: "global" (applies across all projects) or "project" (this repo only). Defaults to "project".',
+};
 // ─── MemoryList ────────────────────────────────────────────────────────────
 export const memoryListToolDef = {
     name: "MemoryList",
@@ -43,6 +57,7 @@ export const memoryListToolDef = {
                 enum: ["user", "dream"],
                 description: "Which scope to list",
             },
+            location: LOCATION_SCHEMA,
         },
         required: ["scope"],
     },
@@ -53,7 +68,7 @@ export async function memoryListTool(args, ctx) {
         return scope;
     }
     try {
-        const mm = mmFor(ctx, scope);
+        const mm = mmFor(ctx, scope, parseLocation(args.location));
         const entries = mm.loadAll();
         if (entries.length === 0)
             return `(no memories in scope "${scope}")`;
@@ -78,6 +93,7 @@ export const memoryReadToolDef = {
                 enum: ["user", "dream"],
                 description: "Which scope to read from",
             },
+            location: LOCATION_SCHEMA,
             name: {
                 type: "string",
                 description: "The memory entry's name (from MemoryList output)",
@@ -91,15 +107,32 @@ export async function memoryReadTool(args, ctx) {
     if (typeof scope !== "string" || !VALID_SCOPES.includes(scope)) {
         return scope;
     }
+    const location = parseLocation(args.location);
     const name = args.name;
     if (typeof name !== "string" || !name)
         return "Error: name is required";
     try {
-        const mm = mmFor(ctx, scope);
+        const mm = mmFor(ctx, scope, location);
         const entries = mm.loadAll();
         const entry = entries.find((e) => e.name === name || e.fileName === name);
         if (!entry)
             return `Error: no memory named "${name}" in scope "${scope}"`;
+        // Recall signal (用户拍板 C + 可见性): reading a memory bumps its usage so
+        // the recall-TTL sweep keeps frequently-read memories alive, and emits a
+        // stream event so the UI can show the user this memory was actually used.
+        // Best-effort — never let accounting failure break the read.
+        try {
+            mm.recordRecall(entry.name);
+            const cb = ctx?.streamCallback;
+            if (cb) {
+                // scope here is always "user"|"dream" (validated above); pending is
+                // never tool-readable, so the narrower event type is correct.
+                void cb({ type: "memory_recalled", name: entry.name, scope: scope, location });
+            }
+        }
+        catch {
+            // ignore — the read result below is what matters
+        }
         return (`name: ${entry.name}\n` +
             `description: ${entry.description}\n` +
             `type: ${entry.type}\n` +
@@ -120,6 +153,8 @@ export const memorySaveToolDef = {
         "feedback (how to approach work), " +
         "project (non-obvious facts about ongoing work), " +
         "reference (pointers to external resources). " +
+        "Pick `location`: global (a lesson/preference true in ANY project) vs project (this repo only). " +
+        "If a memory in the injected index is now stale or wrong, overwrite it (same name) or MemoryDelete it — keep the store correct rather than letting contradictions pile up. " +
         "The `description` is a one-line summary shown in the index; the `content` is the full body.",
     inputSchema: {
         type: "object",
@@ -129,6 +164,7 @@ export const memorySaveToolDef = {
                 enum: ["user", "dream"],
                 description: "Which scope to save to",
             },
+            location: LOCATION_SCHEMA,
             name: {
                 type: "string",
                 description: "Short kebab-case identifier (also becomes the filename slug)",
@@ -169,14 +205,15 @@ export async function memorySaveTool(args, ctx) {
         return `Error: type must be one of ${VALID_TYPES.join(", ")}`;
     }
     try {
-        const mm = mmFor(ctx, scope);
+        const location = parseLocation(args.location);
+        const mm = mmFor(ctx, scope, location);
         const fileName = mm.save({
             name,
             description,
             type: type,
             content,
         });
-        return `Saved memory "${name}" → ${scope}/${fileName}`;
+        return `Saved memory "${name}" → ${location}/${scope}/${fileName}`;
     }
     catch (err) {
         return `Error saving memory: ${err.message}`;
@@ -197,6 +234,7 @@ export const memoryDeleteToolDef = {
                 enum: ["user", "dream"],
                 description: "Which scope to delete from",
             },
+            location: LOCATION_SCHEMA,
             name: {
                 type: "string",
                 description: "The memory entry's name (from MemoryList output)",
@@ -214,7 +252,7 @@ export async function memoryDeleteTool(args, ctx) {
     if (typeof name !== "string" || !name)
         return "Error: name is required";
     try {
-        const mm = mmFor(ctx, scope);
+        const mm = mmFor(ctx, scope, parseLocation(args.location));
         const ok = mm.delete(name);
         return ok
             ? `Deleted memory "${name}" from scope "${scope}" (moved to memory-trash/)`

package/dist/tool-system/builtin/notebook-edit.d.ts

@@ -2,5 +2,6 @@
  * NotebookEditTool — read and edit Jupyter notebook (.ipynb) cells.
  */
 import type { ToolDefinition } from "../../types.js";
+import type { ToolContext } from "../context.js";
 export declare const notebookEditToolDef: ToolDefinition;
-export declare function notebookEditTool(args: Record<string, unknown>): Promise<string>;
+export declare function notebookEditTool(args: Record<string, unknown>, ctx?: ToolContext): Promise<string>;

package/dist/tool-system/builtin/notebook-edit.js

@@ -36,7 +36,7 @@ export const notebookEditToolDef = {
         required: ["file_path", "action"],
     },
 };
-export async function notebookEditTool(args) {
+export async function notebookEditTool(args, ctx) {
     const filePath = args.file_path;
     const action = args.action;
     if (!filePath)

package/dist/tool-system/builtin/powershell.js

@@ -27,7 +27,10 @@ export const powershellToolDef = {
 const PS_MAX_BUFFER = 5 * 1024 * 1024;
 export async function powershellTool(args, ctx) {
     const command = args.command;
-    const timeout = args.timeout ?? 120_000;
+    // `??` only catches null/undefined — a non-positive timeout (0/-5) would slip
+    // through to setTimeout (clamped to 0 → near-instant kill). Floor to default.
+    const rawTimeout = args.timeout;
+    const timeout = typeof rawTimeout === "number" && rawTimeout > 0 ? rawTimeout : 120_000;
     if (!command.trim()) {
         return "Error: command is required.";
     }

package/dist/tool-system/builtin/read.d.ts

@@ -2,5 +2,6 @@
  * Built-in Read file tool.
  */
 import type { ToolDefinition } from "../../types.js";
+import type { ToolContext } from "../context.js";
 export declare const readToolDef: ToolDefinition;
-export declare function readTool(args: Record<string, unknown>): Promise<string>;
+export declare function readTool(args: Record<string, unknown>, ctx?: ToolContext): Promise<string>;

package/dist/tool-system/builtin/read.js

@@ -4,6 +4,7 @@
 import { readFile, stat } from "node:fs/promises";
 import { existsSync } from "node:fs";
 import { fileCache } from "./file-cache.js";
+import { toLf } from "./eol.js";
 export const readToolDef = {
     name: "Read",
     description: "Read a file from the local filesystem. Returns the file content with line numbers. " +
@@ -26,7 +27,7 @@ export const readToolDef = {
     },
 };
 const MAX_CONTENT_CHARS = 200_000;
-export async function readTool(args) {
+export async function readTool(args, ctx) {
     const filePath = args.file_path;
     if (!filePath)
         return "Error: file_path is required";
@@ -46,10 +47,17 @@ export async function readTool(args) {
             content = await readFile(filePath, "utf-8");
             fileCache.set(filePath, content, fileInfo.mtimeMs);
         }
-        const lines = content.split("\n");
+        // Split on LF after normalizing CRLF → LF so a Windows (CRLF) file doesn't
+        // render a trailing ^M on every line. Display-only; the file isn't written.
+        const lines = toLf(content).split("\n");
         const totalLines = lines.length;
         const offset = Math.max(1, args.offset || 1);
-        const limit = args.limit || 2000;
+        // A non-positive limit (a misbehaving caller passing 0 / -5 / NaN) falls back
+        // to the default page size — NOT through to `lines.slice(start, start+limit)`
+        // with a NEGATIVE end, which JS reads as "all but the last N" and would
+        // silently return the wrong window. `|| 2000` only caught 0/NaN, not negatives.
+        const rawLimit = args.limit;
+        const limit = typeof rawLimit === "number" && rawLimit > 0 ? rawLimit : 2000;
         const end = Math.min(totalLines, offset - 1 + limit);
         const selected = lines.slice(offset - 1, end);
         let numbered = selected.map((line, i) => `${offset + i}\t${line}`).join("\n");

package/dist/tool-system/builtin/repl.js

@@ -34,7 +34,10 @@ const REPL_MAX_BUFFER = 1024 * 1024;
 export async function replTool(args, ctx) {
     const language = args.language;
     const code = args.code;
-    const timeout = args.timeout ?? 30_000;
+    // `??` only catches null/undefined — a non-positive timeout (0/-5) would slip
+    // through to setTimeout (clamped to 0 → near-instant kill). Floor to default.
+    const rawTimeout = args.timeout;
+    const timeout = typeof rawTimeout === "number" && rawTimeout > 0 ? rawTimeout : 30_000;
     // A4: child process runs in the Engine's cwd, not the host process cwd.
     const cwd = ctx?.cwd ?? process.cwd();
     if (!code.trim()) {

package/dist/tool-system/builtin/skill.js

@@ -42,6 +42,14 @@ export async function skillTool(args, ctx) {
     // ordering is observable but not load-bearing.
     const disabledSkills = ctx?.disabledSkills;
     const disabledPlugins = ctx?.disabledPlugins;
+    const skillAllowlist = ctx?.skillAllowlist;
+    // Sub-agent skill isolation: when this agent has an allowlist, a skill
+    // outside it must be refused — even invoking it by exact name. The scan
+    // below also drops it, but an explicit message beats a misleading "not
+    // found" for a skill that exists in the project but isn't this agent's.
+    if (skillAllowlist !== undefined && !skillAllowlist.includes(skillName)) {
+        return `Skill "${skillName}" is not available to this sub-agent. This agent's role restricts it to: ${skillAllowlist.length > 0 ? skillAllowlist.join(", ") : "(no skills)"}.`;
+    }
     if (disabledSkills && disabledSkills.includes(skillName)) {
         return `Skill "${skillName}" is disabled. Enable it in Customize or remove it from settings.disabledSkills.`;
     }
@@ -58,6 +66,7 @@ export async function skillTool(args, ctx) {
     const skills = scanSkills(ctx?.cwd ?? process.cwd(), {
         disabledSkills,
         disabledPlugins,
+        skillAllowlist,
     });
     const found = skills.find((s) => s.name === skillName);
     if (!found) {

package/dist/tool-system/builtin/sleep.js

@@ -3,8 +3,9 @@
  */
 export const sleepToolDef = {
     name: "Sleep",
-    description: "Pause execution for a specified number of seconds. " +
-        "Useful for polling workflows or waiting for external processes. " +
+    description: "Pause execution for a brief, deterministic wait (e.g. letting a just-started service settle for a few seconds). " +
+        "Do NOT use Sleep to poll for or wait on background work (background shells, async sub-agents, video generation): " +
+        "the system wakes you automatically when that work completes — just end your turn instead of looping Sleep. " +
         "Maximum duration is 300 seconds (5 minutes).",
     inputSchema: {
         type: "object",
@@ -23,11 +24,17 @@ export async function sleepTool(args) {
     if (signal?.aborted)
         return "Sleep aborted.";
     await new Promise((resolve, reject) => {
-        const timer = setTimeout(resolve, seconds * 1000);
-        signal?.addEventListener("abort", () => {
+        const onAbort = () => {
             clearTimeout(timer);
             reject(new Error("Sleep aborted"));
-        });
+        };
+        const timer = setTimeout(() => {
+            // Remove the abort listener on normal completion — otherwise every Sleep
+            // call leaks a listener on the (shared, per-turn) signal.
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, seconds * 1000);
+        signal?.addEventListener("abort", onAbort, { once: true });
     }).catch(() => { });
     return `Slept for ${seconds} seconds.`;
 }

package/dist/tool-system/builtin/task.js

@@ -30,7 +30,10 @@ export const todoWriteToolDef = {
     name: "TodoWrite",
     description: "Manage the session todo list. Pass the COMPLETE list each call — there's no per-item update API, you rewrite the entire snapshot. " +
         "Use proactively for tasks with 3+ steps. Exactly one item should be in_progress at a time. " +
-        "Always provide both `content` (imperative) and `activeForm` (present continuous) so the UI can show what's happening right now.",
+        "Always provide both `content` (imperative) and `activeForm` (present continuous) so the UI can show what's happening right now. " +
+        "Skip the todo list for straightforward tasks (roughly the easiest 25%) and don't make single-step lists. " +
+        "Update the list immediately after finishing a sub-task — mark it completed in the same turn you completed it, don't batch updates across turns. " +
+        "If you change direction and a planned item will no longer be done, rewrite the list with that item dropped rather than leaving it pending; the list must reflect what you're actually going to do next.",
     inputSchema: {
         type: "object",
         properties: {

package/dist/tool-system/builtin/tool-search.js

@@ -31,20 +31,38 @@ export async function toolSearchTool(args, ctx) {
         return "Error: query is required";
     if (!ctx?.toolRegistry)
         return "Error: ToolSearch is not configured (no registry in ctx)";
-    const maxResults = Math.min(args.max_results || 5, 20);
+    // Floor to default on non-positive: a negative max_results would reach
+    // `.slice(0, maxResults)` with a negative end (= all but the last N), silently
+    // returning the wrong tool set. `|| 5` only caught 0/NaN, not negatives.
+    const rawMax = args.max_results;
+    const maxResults = Math.min(typeof rawMax === "number" && rawMax > 0 ? rawMax : 5, 20);
+    // The tool registry is worker-SHARED (B1): it holds MCP tools registered by
+    // every session, including servers another project enabled. ToolSearch is a
+    // side door around the per-turn toolDefs filter — without this gate it would
+    // surface (and let the model `select:` into) MCP tools from a server THIS
+    // session never enabled, which is exactly the chrome-devtools-in-writeflow
+    // leak. Mirror the engine's toolDefs visibility: keep an MCP tool only when
+    // its server is in this session's allowedMcpServers. Undefined set = no
+    // gating (sub-agents / hosts that don't populate it).
+    const visible = (tool) => {
+        if (tool.source !== "mcp")
+            return true;
+        const allowed = ctx.allowedMcpServers;
+        return !allowed || allowed.has(tool.serverName ?? "");
+    };
     // "select:Name1,Name2" → exact match
     if (query.startsWith("select:")) {
         const names = query.slice(7).split(",").map((n) => n.trim());
-        return matchExact(ctx.toolRegistry, names);
+        return matchExact(ctx.toolRegistry, names, visible);
     }
     // Keyword search
-    return searchByKeyword(ctx.toolRegistry, query, maxResults);
+    return searchByKeyword(ctx.toolRegistry, query, maxResults, visible);
 }
-function matchExact(registry, names) {
+function matchExact(registry, names, visible) {
     const results = [];
     for (const name of names) {
         const tool = registry.getTool(name);
-        if (tool) {
+        if (tool && visible(tool)) {
             results.push(formatTool(tool));
         }
         else {
@@ -53,8 +71,8 @@ function matchExact(registry, names) {
     }
     return results.join("\n\n---\n\n");
 }
-function searchByKeyword(registry, query, maxResults) {
-    const allTools = registry.listToolsDetailed();
+function searchByKeyword(registry, query, maxResults, visible) {
+    const allTools = registry.listToolsDetailed().filter(visible);
     const queryLower = query.toLowerCase();
     const keywords = queryLower.split(/\s+/);
     // Score each tool

package/dist/tool-system/builtin/update-automation-memory.d.ts

@@ -0,0 +1,24 @@
+/**
+ * UpdateAutomationMemory — lets an automation (cron/scheduled) run persist a
+ * one-paragraph summary of what it did, so the NEXT run starts with context.
+ *
+ * This is a FACTORY: core must not depend on desktop's filesystem layer, so the
+ * actual persistence is supplied by an injected `sink` callback. A later task
+ * (the desktop automation runner) injects a sink that appends to the task's
+ * memory.md; this module only builds the tool + validates input.
+ */
+import type { BuiltinTool } from "./index.js";
+import type { ToolDefinition } from "../../types.js";
+/**
+ * Bare tool definition (name/description/inputSchema) — mirrors the export
+ * style of the other builtin tool defs (e.g. cron.ts). The factory below wraps
+ * this into a registry-ready RegisteredTool.
+ */
+export declare const updateAutomationMemoryToolDef: ToolDefinition;
+/**
+ * Build an UpdateAutomationMemory tool bound to a persistence `sink`.
+ *
+ * @param sink Called with the trimmed summary when a non-empty summary is given.
+ *             The caller decides where/how to persist it.
+ */
+export declare function makeUpdateAutomationMemoryTool(sink: (summary: string) => void): BuiltinTool;

package/dist/tool-system/builtin/update-automation-memory.js

@@ -0,0 +1,60 @@
+/**
+ * UpdateAutomationMemory — lets an automation (cron/scheduled) run persist a
+ * one-paragraph summary of what it did, so the NEXT run starts with context.
+ *
+ * This is a FACTORY: core must not depend on desktop's filesystem layer, so the
+ * actual persistence is supplied by an injected `sink` callback. A later task
+ * (the desktop automation runner) injects a sink that appends to the task's
+ * memory.md; this module only builds the tool + validates input.
+ */
+/**
+ * Bare tool definition (name/description/inputSchema) — mirrors the export
+ * style of the other builtin tool defs (e.g. cron.ts). The factory below wraps
+ * this into a registry-ready RegisteredTool.
+ */
+export const updateAutomationMemoryToolDef = {
+    name: "UpdateAutomationMemory",
+    description: "Persist a short memory note for this automation task so your NEXT scheduled run " +
+        "starts with context. Call this EXACTLY ONCE, at the very end of the run, with a " +
+        "concise one-paragraph summary of what you did, what you found, and anything the " +
+        "next run should know or continue (e.g. items processed, last cursor/timestamp, " +
+        "open issues). Keep it to a few sentences — it is prepended to your future prompts.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            summary: {
+                type: "string",
+                description: "A concise one-paragraph summary of this run for the next run to build on.",
+            },
+        },
+        required: ["summary"],
+    },
+};
+/**
+ * Build an UpdateAutomationMemory tool bound to a persistence `sink`.
+ *
+ * @param sink Called with the trimmed summary when a non-empty summary is given.
+ *             The caller decides where/how to persist it.
+ */
+export function makeUpdateAutomationMemoryTool(sink) {
+    return {
+        definition: {
+            ...updateAutomationMemoryToolDef,
+            source: "builtin",
+            // The summary is automation-internal bookkeeping (not user code); no prompt.
+            permissionDefault: "allow",
+            // Writes (via the injected sink), so not read-only / not concurrency-safe.
+            isReadOnly: false,
+            isConcurrencySafe: false,
+        },
+        execute: async (args) => {
+            const raw = typeof args.summary === "string" ? args.summary : "";
+            const summary = raw.trim();
+            if (!summary) {
+                return "Error: summary is required and must not be empty";
+            }
+            sink(summary);
+            return "Automation memory saved for the next run.";
+        },
+    };
+}

package/dist/tool-system/builtin/video-providers.d.ts

@@ -0,0 +1,154 @@
+/**
+ * VideoProvider — adapter interface for text-to-video generation (TODO 7.1).
+ *
+ * Unlike images (one request → bytes), video generation is asynchronous and
+ * long: SUBMIT a job → POLL its status until it finishes → DOWNLOAD the bytes.
+ * The interface captures exactly those three steps so the GenerateVideo tool's
+ * background polling loop is provider-agnostic, and concrete adapters
+ * (Seedance/Kling — filled in once their private API docs are available) only
+ * implement submit/poll/download.
+ *
+ * Credentials are resolved by the tool layer from settings; adapters are pure
+ * "creds + request → job lifecycle". `fetch` is injected for testability.
+ */
+export interface VideoProviderCreds {
+    baseUrl: string;
+    apiKey: string;
+}
+export interface VideoSubmitRequest {
+    prompt: string;
+    model: string;
+    creds: VideoProviderCreds;
+    /** Single image URL (http/https) — image-to-video. Back-compat. */
+    image?: string;
+    /** Multiple image URLs — ≥2 triggers reference-to-video. Takes precedence over `image`. */
+    images?: string[];
+    /** Reference/continuation video URLs (http/https) — passed through to fal's `video_urls`. Reference them in the prompt as @Video1/@Video2. Forces reference-to-video. */
+    videos?: string[];
+    signal?: AbortSignal;
+}
+export type VideoSubmitResult = {
+    ok: true;
+    jobId: string;
+} | {
+    ok: false;
+    error: string;
+};
+export type VideoPollResult = {
+    ok: true;
+    status: "running";
+} | {
+    ok: true;
+    status: "succeeded";
+} | {
+    ok: true;
+    status: "failed";
+    error: string;
+} | {
+    ok: false;
+    error: string;
+};
+export type VideoDownloadResult = {
+    ok: true;
+    bytes: Uint8Array;
+    ext: string;
+    url?: string;
+} | {
+    ok: false;
+    error: string;
+};
+export interface VideoProvider {
+    readonly kind: string;
+    submit(req: VideoSubmitRequest): Promise<VideoSubmitResult>;
+    poll(req: {
+        jobId: string;
+        creds: VideoProviderCreds;
+        signal?: AbortSignal;
+    }): Promise<VideoPollResult>;
+    download(req: {
+        jobId: string;
+        creds: VideoProviderCreds;
+        signal?: AbortSignal;
+    }): Promise<VideoDownloadResult>;
+}
+/**
+ * Deterministic in-memory adapter for tests and local dev — no network. Models
+ * the three-step lifecycle: submit mints a job; poll returns `running` for the
+ * first N calls then `succeeded` (or `failed` after M); download returns the
+ * configured bytes. Lets the GenerateVideo background loop be tested end-to-end
+ * before any real (Seedance/Kling) adapter exists.
+ */
+export declare class FakeVideoProvider implements VideoProvider {
+    private readonly opts;
+    readonly kind = "fake";
+    private polls;
+    private counter;
+    constructor(opts?: {
+        succeedAfterPolls?: number;
+        failAfterPolls?: number;
+        failMessage?: string;
+        bytes?: string;
+    });
+    submit(_req: VideoSubmitRequest): Promise<VideoSubmitResult>;
+    poll(req: {
+        jobId: string;
+        creds?: VideoProviderCreds;
+        signal?: AbortSignal;
+    }): Promise<VideoPollResult>;
+    download(_req: {
+        jobId: string;
+        creds?: VideoProviderCreds;
+        signal?: AbortSignal;
+    }): Promise<VideoDownloadResult>;
+}
+/**
+ * fal.ai video adapter — submit/poll/download against the fal queue API
+ * (https://queue.fal.run). model id selects the underlying model
+ * (e.g. fal-ai/kling-video/v3/pro/text-to-video). When `image` is present we
+ * switch a `...text-to-video` model to `...image-to-video` and send image_url,
+ * so callers only need to pass an image to get i2v.
+ *
+ * IMPORTANT: fal's status/result URLs use a model-FAMILY prefix
+ * (`fal-ai/kling-video/requests/<id>`), NOT the full submit path
+ * (`.../v3/pro/text-to-video/requests/<id>` → HTTP 405). So we never
+ * reconstruct those URLs; we encode the `status_url` + `response_url` that
+ * submit returns into the jobId (`<status_url>|<response_url>`) and use them
+ * verbatim in poll/download. Verified against the live API 2026-06-10.
+ */
+export declare class FalVideoProvider implements VideoProvider {
+    private readonly fetchImpl;
+    readonly kind = "fal";
+    constructor(fetchImpl?: typeof fetch);
+    /** Effective image list: images[] wins; else single image; else []. */
+    private imageList;
+    /**
+     * Does this model family support reference-to-video (multi-image)? Verified
+     * 2026-06-10 against the live API: Seedance has it; Kling does NOT (routing a
+     * Kling model to `.../reference-to-video` 404s at result fetch). Keep this a
+     * conservative allowlist — only families confirmed to expose the endpoint.
+     */
+    private supportsReference;
+    /** Route model suffix by image count: 0→text, 1→image, ≥2→reference. */
+    private resolveModel;
+    /** jobId = `${statusUrl}|${responseUrl}` (fal returns both from submit). */
+    private split;
+    submit(req: VideoSubmitRequest): Promise<VideoSubmitResult>;
+    poll(req: {
+        jobId: string;
+        creds: VideoProviderCreds;
+        signal?: AbortSignal;
+    }): Promise<VideoPollResult>;
+    download(req: {
+        jobId: string;
+        creds: VideoProviderCreds;
+        signal?: AbortSignal;
+    }): Promise<VideoDownloadResult>;
+}
+/** Default model per video provider kind (filled in with real adapters). */
+export declare const DEFAULT_VIDEO_MODEL: Record<string, string>;
+/**
+ * Registry of video-provider adapters, keyed by `kind`. Only `fake` exists
+ * today (test/dev). Real adapters (seedance, kling) are intentionally absent
+ * until their private API contracts are confirmed — see TODO 7.1 块3.
+ */
+export declare function getVideoProvider(kind: string, fetchImpl?: typeof fetch): VideoProvider | null;