@4fu/arbor-tools 2026.1106.0 → 2026.1106.1

package/code-exec.js

@@ -2,10 +2,11 @@
  * `code_exec`: everything that is not a decision runs from a script
  * (docs/tools.md#rules).
  *
- * A script that names a direct tool is refused with the rule and never reaches
- * the host. Calls from a script go through the same hooks as direct calls, so
- * anchors, watermarks, quotas, validation and logging behave the same: every
- * module function is the same service call the direct tool makes.
+ * A script that names one of arbor's own direct tools is refused with the rule
+ * and never reaches the host. Calls from a script go through the same hooks as
+ * direct calls, so anchors, watermarks, quotas, validation and logging behave
+ * the same: every module function is the same service call the direct tool
+ * makes, and so is every tool a plugin or a backend declared.
  *
  * Two lookups are script globals: `tool_search` takes keywords, an exact
  * `module.function` name, or nothing for every module; `tool_describe` returns
@@ -14,7 +15,6 @@
  */
 import vm from "node:vm";
 import { textOf } from "@4fu/arbor-prompt";
-import { boundResult } from "./bound.js";
 /** How long one script may run before it is stopped. */
 const SCRIPT_TIMEOUT_MS = 60000;
 /** Run one script in its own context, with the modules as globals. */
@@ -41,6 +41,22 @@ export async function runScript(script, catalog, services, context) {
     for (const module of catalog.modules()) {
         globals[module.name] = moduleFunctions(module, catalog, context);
     }
+    // A tool a plugin or a backend declared is a capability of its own, not one
+    // of arbor's decisions, so a script may call it - through the same path a
+    // module function takes (docs/tools.md#rules). A module's name and the
+    // script's own globals keep theirs: the catalog has already refused a tool
+    // whose name a module declares, and nothing here shadows `tool_search` or
+    // `console`.
+    for (const tool of catalog.scriptTools()) {
+        if (globals[tool.name] !== undefined)
+            continue;
+        globals[tool.name] = async (args = {}) => {
+            const result = await catalog.callModule(tool.name, args, context);
+            if (!result.ok)
+                throw new Error(result.error?.message ?? result.content);
+            return result.content;
+        };
+    }
     const sandbox = vm.createContext(globals);
     const wrapped = `(async () => {\n${script}\n})()`;
     let value;
@@ -49,6 +65,21 @@ export async function runScript(script, catalog, services, context) {
         value = await compiled.runInContext(sandbox, { timeout: SCRIPT_TIMEOUT_MS });
     }
     catch (error) {
+        // A script that outran the timeout gets its own rule: the message is the
+        // vm's, and the next action says what to do about a long one.
+        const timedOut = typeof error === "object" && error !== null && error.code === "ERR_SCRIPT_EXECUTION_TIMEOUT";
+        if (timedOut) {
+            return {
+                callId: "",
+                ok: false,
+                content: "",
+                error: {
+                    rule: "script.timeout",
+                    message: textOf(table, "refused.script_timeout", { ms: SCRIPT_TIMEOUT_MS }),
+                    nextAction: textOf(table, "next.script_timeout"),
+                },
+            };
+        }
         const message = error instanceof Error ? error.message : String(error);
         return {
             callId: "",
@@ -62,15 +93,9 @@ export async function runScript(script, catalog, services, context) {
         };
     }
     const text = value === undefined ? "" : typeof value === "string" ? value : JSON.stringify(value);
-    return {
-        callId: "",
-        ok: true,
-        content: await boundResult(text ?? "", {
-            workspace: context.workspace,
-            callId: context.call,
-            table,
-        }),
-    };
+    // The whole answer goes back to the script's caller; the cut happens once,
+    // at the one exit every direct call leaves by (docs/prompting.md).
+    return { callId: "", ok: true, content: text ?? "" };
 }
 /** One module's functions, as the globals a script calls. */
 function moduleFunctions(module, catalog, context) {
@@ -87,7 +112,10 @@ function moduleFunctions(module, catalog, context) {
 }
 /**
  * The direct tool a script names, if any. This is a guard, not a sandbox: it
- * keeps a decision out of a script, and the host still enforces every rule.
+ * keeps one of arbor's own decisions or commands out of a script, and the host
+ * still enforces every rule. A tool a plugin or a backend declared is not in
+ * the list - a script may call it, the way it calls a module function
+ * (docs/tools.md#rules).
  */
 export function directToolIn(script, tools) {
     for (const tool of tools) {

package/groups/core.d.ts

@@ -19,7 +19,7 @@ export declare class CoreToolGroup implements ToolGroup {
     private send;
     /**
      * `end` with unfinished work needs a handoff: current topics, progress,
-     * pending items and agreements. The host knows whether work is open; the
+     * pending items and agreements. The host knows what is open and names it; the
      * tool does not guess.
      */
     private end;

package/groups/core.js

@@ -68,27 +68,23 @@ export class CoreToolGroup {
     }
     /**
      * `end` with unfinished work needs a handoff: current topics, progress,
-     * pending items and agreements. The host knows whether work is open; the
+     * pending items and agreements. The host knows what is open and names it; the
      * tool does not guess.
      */
     async end(request, window) {
         const table = this.services.table;
         const handoff = handoffOf(request.args.handoff);
-        if (handoff === undefined && (await this.services.hasOpenWork(window))) {
-            return refused("end.handoff.required", table, "end.no_handoff");
-        }
         const result = await this.services.endWindow(window, handoff);
-        return {
-            ...result,
-            callId: request.callId,
-            content: textOf(table, "result.ended", { window }),
-        };
+        if (!result.ok)
+            return { ...result, callId: request.callId };
+        return { ...result, callId: request.callId, content: textOf(table, "result.ended", { window }) };
     }
     async search(request, window) {
         const table = this.services.table;
         const query = stringArg(request.args, "query");
         const scope = stringArg(request.args, "scope");
-        const outcome = await this.services.search(window, query, scope === "" ? undefined : scope.split(",").map((part) => part.trim()));
+        const wanted = scope === "" ? undefined : scope.split(",").map((part) => part.trim());
+        const outcome = await this.services.search(window, query, wanted);
         const lines = [];
         for (const hit of outcome.hits) {
             lines.push(`${hit.ref} ${hit.kind} ${hit.summary}`);
@@ -100,8 +96,21 @@ export class CoreToolGroup {
             lines.push(`${live.window} ${live.doing}`);
         }
         const body = lines.length === 0 ? textOf(table, "result.search.empty") : lines.join("\n");
-        const total = textOf(table, "result.search.total", { total: outcome.total });
-        return { callId: request.callId, ok: true, content: `${body}\n${total}\n${outcome.nextCall}` };
+        // What was searched, how much there is, and how to reach the rest: a limit
+        // that shapes a result without refusing is reported every time
+        // (docs/prompting.md#rules-surface-where-they-bite).
+        const more = outcome.total - lines.length;
+        return {
+            callId: request.callId,
+            ok: true,
+            content: [
+                body,
+                textOf(table, "result.search.total", { total: outcome.total }),
+                textOf(table, "result.search.scope", { scope: outcome.scope.join("、") }),
+                ...(more > 0 ? [textOf(table, "result.search.more", { count: more })] : []),
+                outcome.nextCall,
+            ].join("\n"),
+        };
     }
     notOwned(request) {
         return {

package/groups/external.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The group a plugin's or a backend's direct tools are registered as
+ * (docs/tools.md#external-tools).
+ *
+ * One group per source, holding every tool that source declared. Nothing here
+ * is special: the group declares its tools the way any group does and runs a
+ * call the way any group does, so the hooks, the journaling, the scrub and the
+ * one result cut around a call are the ones the host and the catalog apply to
+ * every direct tool.
+ *
+ * The `source` rides on each spec, so the tools list the model reads says where
+ * a tool comes from and `tool_search` answers with the same line.
+ */
+import type { CallContext, DirectToolSpec, ExternalTool, ToolCall, ToolGroup, ToolResult } from "@4fu/arbor-interfaces";
+import { type ToolServices } from "../host.ts";
+export declare class ExternalToolGroup implements ToolGroup {
+    readonly id: string;
+    private readonly declared;
+    private readonly source;
+    private readonly services;
+    constructor(declared: readonly ExternalTool[], source: string, services: Pick<ToolServices, "table">);
+    tools(): readonly DirectToolSpec[];
+    modules(): readonly [];
+    call(request: ToolCall, context: CallContext): Promise<ToolResult>;
+}

package/groups/external.js

@@ -0,0 +1,45 @@
+/**
+ * The group a plugin's or a backend's direct tools are registered as
+ * (docs/tools.md#external-tools).
+ *
+ * One group per source, holding every tool that source declared. Nothing here
+ * is special: the group declares its tools the way any group does and runs a
+ * call the way any group does, so the hooks, the journaling, the scrub and the
+ * one result cut around a call are the ones the host and the catalog apply to
+ * every direct tool.
+ *
+ * The `source` rides on each spec, so the tools list the model reads says where
+ * a tool comes from and `tool_search` answers with the same line.
+ */
+import { refused } from "../host.js";
+export class ExternalToolGroup {
+    id;
+    declared;
+    source;
+    services;
+    constructor(declared, source, services) {
+        this.id = `external:${source}`;
+        this.declared = declared;
+        this.source = source;
+        this.services = services;
+    }
+    tools() {
+        return this.declared.map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.parameters,
+            source: this.source,
+        }));
+    }
+    modules() {
+        return [];
+    }
+    async call(request, context) {
+        const tool = this.declared.find((one) => one.name === request.name);
+        // The catalog routes by name, so a call reaches this group only for a name
+        // it declares; the refusal keeps the answer in the core's error shape.
+        if (tool === undefined)
+            return refused("tool.not_owned", this.services.table, "unknown_tool", { name: request.name });
+        return tool.execute(request, context);
+    }
+}

package/groups/files.d.ts

@@ -17,6 +17,14 @@
  * stopped with `bash_stop`, through the host's own process path.
  */
 import type { CallContext, DirectToolSpec, ToolCall, ToolGroup, ToolResult } from "@4fu/arbor-interfaces";
+/**
+ * The environment one command runs with: the host's environment, the window's
+ * own directory, and the extra environment the workspace
+ * implementation asks for. This is the one place a command's environment is
+ * built, so everything a deployment adds to it is added here
+ * (docs/environment.md#what-a-subprocess-gets).
+ */
+export declare function bashEnvironment(cwd: string, extraEnv?: Record<string, string>): Record<string, string>;
 export declare class FileToolGroup implements ToolGroup {
     readonly id = "files";
     private readonly services;

package/groups/files.js

@@ -20,13 +20,23 @@ import { spawn } from "node:child_process";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, join, normalize, resolve } from "node:path";
 import { textOf } from "@4fu/arbor-prompt";
-import { boundResult } from "../bound.js";
+import { childEnvironment } from "../child-env.js";
 import { envCommand } from "../env-stage.js";
 import { toolSpec } from "../host.js";
 /** How long `bash` waits before it hands the command to `bash_output`. */
 const BASH_WAIT_MS = 20000;
 /** How much one background job keeps in memory. */
 const JOB_BUFFER = 200000;
+/**
+ * The environment one command runs with: the host's environment, the window's
+ * own directory, and the extra environment the workspace
+ * implementation asks for. This is the one place a command's environment is
+ * built, so everything a deployment adds to it is added here
+ * (docs/environment.md#what-a-subprocess-gets).
+ */
+export function bashEnvironment(cwd, extraEnv) {
+    return childEnvironment({ workspace: cwd, env: extraEnv });
+}
 export class FileToolGroup {
     id = "files";
     services;
@@ -119,13 +129,16 @@ export class FileToolGroup {
             // there and `path` is not a host path.
             return this.ran(request, await runToEnd(workspace.exec, command));
         }
-        const job = this.start(command, workspace.path);
-        await sleep(numberArg(request.args, "timeout", BASH_WAIT_MS));
-        return {
-            callId: request.callId,
-            ok: job.done ? job.code === 0 : true,
-            content: `${job.output}\n${textOf(table, "result.bash.started", { job: job.id })}`,
-        };
+        const job = this.start(command, workspace.path, this.services.workspace?.bashEnv?.(window));
+        const wait = numberArg(request.args, "timeout", BASH_WAIT_MS);
+        await Promise.race([job.ended, sleep(wait)]);
+        // A command that ran to its end inside the wait window is answered with
+        // what it wrote; one that outlived it becomes a background job, and the
+        // result line says the window is not woken when it ends.
+        const content = job.done
+            ? job.output
+            : `${job.output}\n${textOf(table, "result.bash.started", { job: job.id, ms: wait })}`;
+        return { callId: request.callId, ok: job.done ? job.code === 0 : true, content };
     }
     /** One command that ran to its end: what it wrote, and whether it succeeded. */
     ran(request, outcome) {
@@ -174,15 +187,12 @@ export class FileToolGroup {
         const lines = text.split("\n");
         const offset = Math.max(0, numberArg(request.args, "offset", 0));
         const limit = Math.min(500, Math.max(1, numberArg(request.args, "limit", 400)));
-        const body = await boundResult(lines.slice(offset, offset + limit).join("\n"), {
-            workspace: workspace?.path ?? path,
-            callId: request.callId,
-            table,
-        });
+        // The page is bounded once, at the one exit every call leaves by, so this
+        // tool cuts nothing of its own.
         return {
             callId: request.callId,
             ok: true,
-            content: `${textOf(table, "result.read.file", { path, lines: lines.length })}\n${body}`,
+            content: `${textOf(table, "result.read.file", { path, lines: lines.length })}\n${lines.slice(offset, offset + limit).join("\n")}`,
         };
     }
     async write(request, window) {
@@ -243,34 +253,45 @@ export class FileToolGroup {
         await mkdir(dirname(target), { recursive: true });
         await writeFile(target, text, "utf8");
     }
-    start(command, cwd) {
+    start(command, cwd, extraEnv) {
         const id = `b${this.nextJob}`;
         this.nextJob += 1;
-        const child = spawn("/bin/sh", ["-c", command], { cwd });
-        let output = "";
-        const append = (chunk) => {
-            output = (output + chunk.toString("utf8")).slice(-JOB_BUFFER);
-        };
-        child.stdout.on("data", append);
-        child.stderr.on("data", append);
+        // The one place a command's environment is built: the host's environment,
+        // the window's own directory, and the extra environment the workspace
+        // implementation asks for - the ovnfs workspace's `ARBOR_WINDOW` and git
+        // hook path. The extra variables reach no MCP server and no service
+        // (docs/environment.md#what-a-subprocess-gets).
+        const child = spawn("/bin/sh", ["-c", command], { cwd, env: bashEnvironment(cwd, extraEnv) });
+        let end = () => { };
         const job = {
             id,
             output: "",
             done: false,
             code: null,
+            ended: new Promise((resolve) => {
+                end = resolve;
+            }),
             stop: () => {
                 child.kill("SIGTERM");
             },
         };
+        // Output lands on the job as it is written, so a running job's output can
+        // be read before it ends.
+        const append = (chunk) => {
+            job.output = (job.output + chunk.toString("utf8")).slice(-JOB_BUFFER);
+        };
+        child.stdout.on("data", append);
+        child.stderr.on("data", append);
         child.on("close", (code) => {
             job.done = true;
             job.code = code;
-            job.output = output;
+            end();
         });
         child.on("error", (error) => {
             job.done = true;
             job.code = 1;
-            job.output = output + error.message;
+            job.output += error.message;
+            end();
         });
         this.jobs.set(id, job);
         return job;

package/groups/notes.d.ts

@@ -27,6 +27,12 @@ export declare class NoteToolGroup implements ToolGroup {
      * that changed since the one the writer read.
      */
     private record;
+    /**
+     * One write's answer, with the active set's budget beside it: the budget is
+     * part of every prefix, so a window that writes hears how full it is
+     * (docs/memory.md#the-active-set). A delete is its own line: it removed a
+     * note rather than writing one.
+     */
     private answer;
     /** One refusal the note store returned, in the core's error shape. */
     private refusalOf;

package/groups/notes.js

@@ -24,6 +24,7 @@ export class NoteToolGroup {
                 title: { type: "string", required: true },
                 summary: { type: "string" },
                 body: { type: "string", required: true },
+                refs: { type: "refs" },
             }),
             toolSpec(table, "note_replace", {
                 id: { type: "string", required: true },
@@ -31,6 +32,7 @@ export class NoteToolGroup {
                 title: { type: "string" },
                 summary: { type: "string" },
                 body: { type: "string", required: true },
+                refs: { type: "refs" },
             }),
             toolSpec(table, "note_delete", {
                 id: { type: "string", required: true },
@@ -57,59 +59,76 @@ export class NoteToolGroup {
         }
     }
     async write(request, store, window) {
-        const title = stringArg(request.args, "title");
-        const body = stringArg(request.args, "body");
-        if (title === "" || body === "")
-            return this.refusal(request, "note.write.empty");
+        // Every rule a write has to meet lives in the store, which answers in the
+        // core's error shape; the group adds nothing of its own.
+        const refs = refsArg(request.args, "refs");
         return this.record(request, store, window, {
-            title,
-            body,
+            title: stringArg(request.args, "title"),
+            body: stringArg(request.args, "body"),
             ...(stringArg(request.args, "summary") === "" ? {} : { summary: stringArg(request.args, "summary") }),
+            ...(refs.length === 0 ? {} : { refs }),
         });
     }
     async replace(request, store, window) {
-        const id = stringArg(request.args, "id");
-        const revision = numberArg(request.args, "revision");
-        const body = stringArg(request.args, "body");
-        if (id === "" || body === "")
-            return this.refusal(request, "note.write.empty");
+        const refs = refsArg(request.args, "refs");
         return this.record(request, store, window, {
-            id: id,
+            id: stringArg(request.args, "id"),
             title: stringArg(request.args, "title"),
-            body,
+            body: stringArg(request.args, "body"),
             replace: true,
-            expectedRevision: revision,
+            expectedRevision: numberArg(request.args, "revision"),
             ...(stringArg(request.args, "summary") === "" ? {} : { summary: stringArg(request.args, "summary") }),
+            ...(refs.length === 0 ? {} : { refs }),
         });
     }
     async remove(request, store, window) {
-        const id = stringArg(request.args, "id");
-        if (id === "")
-            return this.refusal(request, "note.write.empty");
         return this.record(request, store, window, {
-            id: id,
+            id: stringArg(request.args, "id"),
             title: "",
             body: "",
             delete: true,
             expectedRevision: numberArg(request.args, "revision"),
-        });
+        }, true);
     }
     /**
      * One write, with the anchor the host fills in. A refused write changes
      * nothing; the answer carries the rule, the next action and the revisions
      * that changed since the one the writer read.
      */
-    async record(request, _store, window, input) {
+    async record(request, store, window, input, deleted = false) {
         try {
             const note = await this.services.writeNote(window, input);
-            return this.answer(request, note.ref, this.services.table);
+            return this.answer(request, note.ref, store, deleted);
         }
         catch (error) {
             return this.refusalOf(request, error);
         }
     }
-    answer(request, ref, table) {
-        return { callId: request.callId, ok: true, content: textOf(table, "result.note_written", { ref }) };
+    /**
+     * One write's answer, with the active set's budget beside it: the budget is
+     * part of every prefix, so a window that writes hears how full it is
+     * (docs/memory.md#the-active-set). A delete is its own line: it removed a
+     * note rather than writing one.
+     */
+    async answer(request, ref, store, deleted = false) {
+        const table = this.services.table;
+        const snapshot = await store.snapshot().catch(() => null);
+        return {
+            callId: request.callId,
+            ok: true,
+            content: [
+                textOf(table, deleted ? "result.note_deleted" : "result.note_written", { ref }),
+                ...(snapshot === null
+                    ? []
+                    : [
+                        textOf(table, "result.note.budget", {
+                            used: snapshot.tokens,
+                            hard: snapshot.budget.tokens,
+                            left: Math.max(0, snapshot.budget.count - snapshot.total),
+                        }),
+                    ]),
+            ].join("\n"),
+        };
     }
     /** One refusal the note store returned, in the core's error shape. */
     refusalOf(request, error) {
@@ -117,8 +136,9 @@ export class NoteToolGroup {
         const info = error;
         const revisions = info.details?.revisions ?? [];
         const lines = [info.message ?? String(error)];
-        if (info.nextAction !== undefined)
-            lines.push(`${textOf(table, "error.next", {})}${info.nextAction}`.trim());
+        if (info.nextAction !== undefined) {
+            lines.push(textOf(table, "error.next", { next: info.nextAction }));
+        }
         for (const revision of revisions) {
             lines.push(`${revision.ref} ${revision.window ?? ""}`);
         }
@@ -174,3 +194,10 @@ function numberArg(args, name) {
     const value = args[name];
     return typeof value === "number" && Number.isFinite(value) ? value : undefined;
 }
+/** The refs a write names, so the store can link them to the note. */
+function refsArg(args, name) {
+    const value = args[name];
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((item) => typeof item === "string");
+}

package/host.d.ts

@@ -76,8 +76,6 @@ export interface ToolServices {
     ensureWorkspace(window: WindowRef): Promise<WorkspaceMount | undefined>;
     /** End the run, with a handoff when there is unfinished work. */
     endWindow(window: WindowRef, handoff?: Handoff): Promise<ToolResult>;
-    /** True when the window still has work the host can see. */
-    hasOpenWork(window: WindowRef): Promise<boolean>;
     /**
      * One note write, with the anchor the host fills in: the window, the event
      * and the evidence. The model never declares an anchor.

package/index.d.ts

@@ -7,11 +7,14 @@
  * in `code_exec`. There is no CLI, and there is no second path around the
  * service layer.
  */
-export { ToolCatalog, type ToolCatalogOptions } from "./catalog.ts";
+export { ToolCatalog, type ExternalToolRefusal, type ToolCatalogOptions } from "./catalog.ts";
 export { SCRIPT_TIMEOUT_MS, directToolIn, runScript, type CodeExecContext, type ScriptCatalog, } from "./code-exec.ts";
 export { RESULT_LIMIT, boundResult, boundText, nextCall, type Bound } from "./bound.ts";
+export { WORKSPACE_ENV, childEnvironment, type ChildEnvInput } from "./child-env.ts";
 export { callContext, moduleSpec, refused, toolSpec, type EnvCatalog, type LiveWindow, type ReloadOutcome, type SearchOutcome, type SendOutcome, type TaskRecord, type TaskSummary, type ToolServices, } from "./host.ts";
 export { CoreToolGroup, handoffOf } from "./groups/core.ts";
+export { ExternalToolGroup } from "./groups/external.ts";
+export { bashEnvironment } from "./groups/files.ts";
 export { EnvToolGroup } from "./groups/env.ts";
 export { NoteToolGroup } from "./groups/notes.ts";
 export { FileToolGroup } from "./groups/files.ts";

package/index.js

@@ -10,8 +10,11 @@
 export { ToolCatalog } from "./catalog.js";
 export { SCRIPT_TIMEOUT_MS, directToolIn, runScript, } from "./code-exec.js";
 export { RESULT_LIMIT, boundResult, boundText, nextCall } from "./bound.js";
+export { WORKSPACE_ENV, childEnvironment } from "./child-env.js";
 export { callContext, moduleSpec, refused, toolSpec, } from "./host.js";
 export { CoreToolGroup, handoffOf } from "./groups/core.js";
+export { ExternalToolGroup } from "./groups/external.js";
+export { bashEnvironment } from "./groups/files.js";
 export { EnvToolGroup } from "./groups/env.js";
 export { NoteToolGroup } from "./groups/notes.js";
 export { FileToolGroup } from "./groups/files.js";

package/modules/modules.d.ts

@@ -17,7 +17,14 @@ export declare class JournalModuleGroup implements ToolGroup {
     tools(): readonly [];
     modules(): readonly ModuleSpec[];
     call(request: ToolCall, _context: CallContext): Promise<ToolResult>;
+    /**
+     * One answer: the items, then one 相关 line per returned item for the first
+     * three of them, then the total and the call that pages the rest
+     * (docs/prompting.md#information-density).
+     */
     private answer;
+    /** One 相关 line per item, for the first three: no line without neighbours. */
+    private related;
     private notOwned;
 }
 /** `windows`: list, show, send, broadcast, inbox. */
@@ -90,7 +97,7 @@ export declare class ScheduleModuleGroup implements ToolGroup {
     private create;
     /** `schedule.update`: only the fields the script named change. */
     private update;
-    /** One repeat rule as one line: only once, a period, or a daily clock time. */
+    /** One repeat rule as one line: only once, a period, a daily or a weekly time. */
     private repeatText;
     /** One argument the script did not name in a shape this module can read. */
     private badInput;