toolroll 0.9.67 → 0.9.68

package/dist/{team-cli.d.ts → connect-cli.d.ts}

@@ -1,17 +1,12 @@
-export type TeamCliOptions = {
+export type ConnectOptions = {
     fetch?: typeof fetch;
     env?: NodeJS.ProcessEnv;
     home?: string;
     profileFile?: string;
     readStdin?: () => Promise<string>;
-    readLine?: (prompt: string) => Promise<string | null>;
-    isTTY?: boolean;
     stderr?: (line: string) => void;
     signal?: AbortSignal;
-    sleep?: (milliseconds: number, signal: AbortSignal) => Promise<void>;
 };
-/** D5: deprecated (deprecations.ts). Each still runs this release, hidden from help and the contract, with one warning on stderr. */
-export declare const TEAM_CLI_ACTIONS: readonly ['connect', 'lead list', 'lead create', 'lead update', 'lead member', 'lead transfer', 'conversation list', 'conversation create', 'conversation show', 'conversation member', 'conversation edit', 'conversation withdraw', 'conversation read', 'conversation follow', 'conversation stop'];
 export declare class UsageError extends Error {
 }
 /** Credentials are never sent to a URL with embedded authority, an API path, query, fragment or an insecure remote
@@ -26,13 +21,14 @@ type Profile = {
 export declare const bearerOf: (profile: Profile) => string;
 /** The saved central profile remote commands use: the named one (or the active one), and whether it holds an API token.
  * null when nothing is saved. Reads only the private profile file — never a local login or the database. */
-export declare function centralProfile(options: TeamCliOptions, name?: string): {
+export declare function hasCentralProfile(options: ConnectOptions): boolean;
+export declare function centralProfile(options: ConnectOptions, name?: string): {
     name: string;
     origin: string;
     account: string;
     token: string;
     apiToken: boolean;
 } | null;
-/** null means preserve the existing local command path. Nothing here opens a database. */
-export declare function maybeRunTeamCommand(argv: readonly string[], write: (line: string) => void, options?: TeamCliOptions): Promise<number | null>;
+/** `toolroll connect …`; null for every other command. Nothing here opens a database. */
+export declare function maybeRunConnectCommand(argv: readonly string[], write: (line: string) => void, options?: ConnectOptions): Promise<number | null>;
 export {};

package/dist/connect-cli.js

@@ -0,0 +1,331 @@
+/**
+ * `toolroll connect`: saves a central server's origin and your API token in a private profile file. Remote commands
+ * (remote-exec.ts) and `toolroll health` sign in with it; nothing here opens the local database except to find the
+ * existing local sign-in for --local-login.
+ */
+import { constants, closeSync, existsSync, fstatSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { randomBytes } from 'node:crypto';
+import { envelopeJson } from './envelope.js';
+import { databasePath } from './store.js';
+import { configBase, namedPath } from './names.js';
+import { parseApiToken } from './api-tokens.js';
+import { deprecationWarning } from './deprecations.js';
+import { PASSWORD_PROFILE_WARNING } from './password-bearer.js';
+const HELP = `toolroll connect <HTTPS-origin> --as <account> --token-stdin
+  Pipe your API token (so_…, from Settings → API tokens) or use --token-file <private-file>;
+  --local-login uses your existing local sign-in.
+  With an API token saved, other commands run on that server as you (--local runs here).
+  Optional: --profile <name> (saved as the active profile).`;
+export class UsageError extends Error {
+}
+/** Credentials are never sent to a URL with embedded authority, an API path, query, fragment or an insecure remote
+ * host. Fetch cannot follow redirects. */
+export function serviceOrigin(raw) {
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        throw new UsageError('The service origin must be HTTPS or loopback HTTP.');
+    }
+    if (url.username || url.password || url.search || url.hash || url.pathname !== '/')
+        throw new UsageError('The service origin must contain only the origin, with no credentials, path, query or fragment.');
+    if (url.protocol !== 'https:' && !(url.protocol === 'http:' && ['127.0.0.1', '[::1]', 'localhost'].includes(url.hostname)))
+        throw new UsageError('The service origin requires HTTPS except for loopback HTTP.');
+    return url.origin;
+}
+const value = (flags, name) => typeof flags[name] === 'string' ? flags[name] : '';
+const text = (raw) => raw.replace(/[\x00-\x08\x0b-\x1f\x7f]/g, '');
+const record = (input) => !!input && typeof input === 'object' && !Array.isArray(input);
+const strings = (input) => Array.isArray(input) && input.every(one => typeof one === 'string');
+const accountValid = (input) => !!input && input.length <= 200 && !/[\s:\x00-\x1f\x7f]/.test(input);
+const tokenValid = (input) => !!input && input.length <= 8192 && !/[\s\x00-\x1f\x7f]/.test(input);
+const profilePath = (options) => options.profileFile ?? namedPath(configBase(options.env ?? process.env, options.home ?? homedir()), ['remote', 'profiles.json']);
+/** Open the file itself without following a symlink; nonblocking also rejects FIFOs safely. */
+function privateFile(path, limit) {
+    let fd;
+    try {
+        fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+        const stat = fstatSync(fd);
+        if (!stat.isFile() || (stat.mode & 0o777) !== 0o600 || (process.getuid && stat.uid !== process.getuid()) || stat.size > limit)
+            throw new Error();
+        const bytes = readFileSync(fd);
+        if (bytes.length > limit)
+            throw new Error();
+        return new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+    }
+    catch {
+        throw new UsageError('The credential file must be an owned, private (chmod 600), regular UTF-8 file.');
+    }
+    finally {
+        if (fd !== undefined)
+            closeSync(fd);
+    }
+}
+function profiles(options) {
+    const path = profilePath(options);
+    // lstat distinguishes a dangling symlink from a missing profile.
+    try {
+        lstatSync(path);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        throw new UsageError('The remote profile cannot be read.');
+    }
+    const raw = privateFile(path, 128 * 1024);
+    try {
+        const parsed = JSON.parse(raw);
+        if (!record(parsed) || parsed.version !== 1 || typeof parsed.active !== 'string' || !record(parsed.profiles))
+            throw new Error();
+        for (const [name, one] of Object.entries(parsed.profiles)) {
+            if (!/^[A-Za-z0-9_-]{1,64}$/.test(name) || !record(one) || typeof one.origin !== 'string' || serviceOrigin(one.origin) !== one.origin || typeof one.account !== 'string' || !accountValid(one.account) || typeof one.token !== 'string' || !tokenValid(one.token))
+                throw new Error();
+        }
+        if (!Object.hasOwn(parsed.profiles, parsed.active))
+            throw new Error();
+        return parsed;
+    }
+    catch {
+        throw new UsageError('The remote profile is invalid. Connect again using a private credential source.');
+    }
+}
+function saveProfile(options, name, profile) {
+    const path = profilePath(options), directory = dirname(path);
+    const saved = profiles(options) ?? { version: 1, active: name, profiles: {} };
+    mkdirSync(directory, { recursive: true, mode: 0o700 });
+    const parent = lstatSync(directory);
+    if (!parent.isDirectory() || (parent.mode & 0o777) !== 0o700 || (process.getuid && parent.uid !== process.getuid()))
+        throw new UsageError('The remote profile directory must be owned and private (chmod 700).');
+    saved.active = name;
+    Object.defineProperty(saved.profiles, name, { value: profile, enumerable: true, configurable: true, writable: true });
+    const temporary = join(directory, `.profile-${randomBytes(16).toString('hex')}`);
+    let fd;
+    try {
+        fd = openSync(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
+        writeFileSync(fd, `${JSON.stringify(saved)}\n`);
+        fsyncSync(fd);
+        closeSync(fd);
+        fd = undefined;
+        renameSync(temporary, path);
+        fd = openSync(directory, constants.O_RDONLY);
+        fsyncSync(fd);
+    }
+    finally {
+        if (fd !== undefined)
+            closeSync(fd);
+        if (existsSync(temporary))
+            unlinkSync(temporary);
+    }
+}
+/** An API token (so_…) is sent bare; an older saved sign-in keeps its account:secret form. */
+export const bearerOf = (profile) => parseApiToken(profile.token) !== null ? `Bearer ${profile.token}` : `Bearer ${profile.account}:${profile.token}`;
+/** The saved central profile remote commands use: the named one (or the active one), and whether it holds an API token.
+ * null when nothing is saved. Reads only the private profile file — never a local login or the database. */
+export function hasCentralProfile(options) {
+    // An unreadable or invalid profile file still names a central service: the caller refuses rather than run locally.
+    try {
+        return profiles(options) !== null;
+    }
+    catch {
+        return true;
+    }
+}
+export function centralProfile(options, name) {
+    const saved = profiles(options);
+    if (saved === null)
+        return null;
+    const chosen = name ?? saved.active;
+    if (!/^[A-Za-z0-9_-]{1,64}$/.test(chosen) || !Object.hasOwn(saved.profiles, chosen))
+        throw new UsageError(`No saved connection named ${chosen}. Use connect with your API token first.`);
+    const profile = saved.profiles[chosen];
+    return { name: chosen, ...profile, apiToken: parseApiToken(profile.token) !== null };
+}
+async function stdinSecret() {
+    if (process.stdin.isTTY)
+        throw new UsageError('Pipe your sign-in secret into --token-stdin, or use --token-file.');
+    const chunks = [];
+    let size = 0;
+    for await (const part of process.stdin) {
+        const chunk = Buffer.from(part);
+        size += chunk.length;
+        if (size > 8192)
+            throw new UsageError('The sign-in secret is too large.');
+        chunks.push(chunk);
+    }
+    try {
+        return new TextDecoder('utf-8', { fatal: true }).decode(Buffer.concat(chunks));
+    }
+    catch {
+        throw new UsageError('The sign-in secret must be UTF-8.');
+    }
+}
+async function responseBody(response) {
+    if (!response.body)
+        throw new Error();
+    const reader = response.body.getReader(), chunks = [];
+    let size = 0;
+    try {
+        while (true) {
+            const chunk = await reader.read();
+            if (chunk.done)
+                break;
+            size += chunk.value.byteLength;
+            if (size > 2 * 1024 * 1024) {
+                await reader.cancel();
+                throw new Error();
+            }
+            chunks.push(chunk.value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    return JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(Buffer.concat(chunks)));
+}
+function parse(argv) {
+    const allowed = new Set(['profile', 'json', 'help', 'as', 'token-stdin', 'token-file', 'local-login', 'login-file']);
+    const switches = new Set(['json', 'help', 'token-stdin', 'local-login']);
+    const flags = {}, positions = [];
+    for (let index = 1; index < argv.length; index++) {
+        const arg = argv[index];
+        if (!arg.startsWith('--')) {
+            positions.push(arg);
+            continue;
+        }
+        const name = arg.slice(2);
+        if (!allowed.has(name))
+            throw new UsageError('Unsupported option. Use --help for this command; secrets must come from stdin or a private file.');
+        if (Object.hasOwn(flags, name))
+            throw new UsageError(`Use --${name} only once.`);
+        if (switches.has(name))
+            flags[name] = true;
+        else {
+            const next = argv[++index];
+            if (!next || next.startsWith('--'))
+                throw new UsageError(`--${name} needs a value.`);
+            flags[name] = next;
+        }
+    }
+    if (positions.length !== 1 && !flags.help)
+        throw new UsageError('Name one service origin.');
+    return { flags, positions };
+}
+function isMessage(one) {
+    return record(one) && Number.isSafeInteger(one.id) && typeof one.author === 'string' && ['operator', 'assistant'].includes(String(one.role)) && typeof one.text === 'string' && ['queued', 'running', 'answered', 'failed', 'cancelled', 'uncertain'].includes(String(one.status)) && Number.isSafeInteger(one.revision) && typeof one.createdAt === 'string' && (one.requestId === null || typeof one.requestId === 'string') && (one.turnId === null || Number.isSafeInteger(one.turnId)) && (one.error === null || typeof one.error === 'string');
+}
+/** The listing a central service answers `list` with; a reply without a well-formed one is no proof of a service. */
+function isSnapshot(one) {
+    if (!record(one) || !Array.isArray(one.leads) || !one.leads.every(lead => record(lead) && typeof lead.id === 'string' && typeof lead.name === 'string') || !Array.isArray(one.conversations) || !one.conversations.every(conversation => record(conversation) && typeof conversation.id === 'string' && typeof conversation.leadId === 'string' && typeof conversation.title === 'string') || !(one.selected === null || record(one.selected) && typeof one.selected.id === 'string' && typeof one.selected.leadId === 'string' && typeof one.selected.title === 'string') || !Array.isArray(one.participants) || !one.participants.every(participant => record(participant) && typeof participant.account === 'string' && ['viewer', 'contributor', 'manager'].includes(String(participant.role)) && typeof participant.active === 'boolean') || !Array.isArray(one.messages) || !one.messages.every(isMessage) || typeof one.canManage !== 'boolean' || typeof one.canSend !== 'boolean' || !Number.isSafeInteger(one.cursor) || typeof one.truncated !== 'boolean' || !strings(one.projects) || !strings(one.accounts))
+        return false;
+    if (one.chatAuthorization !== undefined) {
+        const grant = one.chatAuthorization;
+        if (!record(grant) || typeof grant.enabled !== 'boolean' || !(grant.provider === null || typeof grant.provider === 'string') || !(grant.model === null || typeof grant.model === 'string') || !Number.isSafeInteger(grant.dailyTurns) || ![grant.weeklyCeilingUsd, grant.conversationCeilingUsd].every(amount => amount === null || typeof amount === 'number' && Number.isFinite(amount) && amount >= 0) || typeof grant.termsDigest !== 'string')
+            return false;
+    }
+    if (one.tasks !== undefined) {
+        const tasks = one.tasks;
+        if (!record(tasks) || !record(tasks.totals) || !['all', 'needs-you', 'running', 'completed'].every(key => Number.isSafeInteger(tasks.totals[key])) || !Array.isArray(tasks.items) || !tasks.items.every(task => record(task) && typeof task.rootId === 'string' && typeof task.activeTaskId === 'string' && typeof task.title === 'string' && record(task.status) && typeof task.status.label === 'string') || !(tasks.nextCursor === null || typeof tasks.nextCursor === 'string'))
+            return false;
+    }
+    if (one.proposals !== undefined && (!Array.isArray(one.proposals) || !one.proposals.every(proposal => record(proposal) && Number.isSafeInteger(proposal.id) && typeof proposal.title === 'string' && typeof proposal.state === 'string' && typeof proposal.href === 'string')))
+        return false;
+    return true;
+}
+/** The server must accept the credential before it is saved: one read of POST /api/team, never retried. A success
+ * proves itself with a well-formed listing, as the central `list` it is. */
+async function verify(profile, options) {
+    const unconfirmed = { version: 1, ok: false, code: 'service-unavailable', message: 'The service response could not be read.' };
+    try {
+        const response = await (options.fetch ?? fetch)(`${profile.origin}/api/team`, { method: 'POST', redirect: 'manual', credentials: 'omit', signal: options.signal ? AbortSignal.any([options.signal, AbortSignal.timeout(30_000)]) : AbortSignal.timeout(30_000), headers: { authorization: bearerOf(profile), 'content-type': 'application/json', accept: 'application/json' }, body: JSON.stringify({ operation: 'list', args: {} }) });
+        if (response.status >= 300 && response.status < 400) {
+            await response.body?.cancel();
+            return unconfirmed;
+        }
+        if (response.status === 429) {
+            await response.body?.cancel();
+            return { ...unconfirmed, code: 'rate-limited', message: 'Request limit reached. Try again shortly.' };
+        }
+        const payload = await responseBody(response);
+        if (!record(payload) || payload.version !== 1 || typeof payload.ok !== 'boolean' || typeof payload.code !== 'string' || typeof payload.message !== 'string' || payload.snapshot !== undefined && !isSnapshot(payload.snapshot) || payload.ok && !response.ok)
+            return unconfirmed;
+        if (payload.ok && payload.snapshot === undefined)
+            return unconfirmed;
+        return { version: 1, ok: payload.ok, code: payload.code, message: payload.message };
+    }
+    catch {
+        return unconfirmed;
+    }
+}
+/** `toolroll connect …`; null for every other command. Nothing here opens a database. */
+export async function maybeRunConnectCommand(argv, write, options = {}) {
+    if (argv[0] !== 'connect')
+        return null;
+    const json = argv.includes('--json');
+    let secret = '';
+    const stderr = (line) => (options.stderr ?? (line => process.stderr.write(`${line}\n`)))(text(secret ? line.replaceAll(secret, '[redacted]') : line));
+    const emit = (reply) => {
+        // A server's words can echo the credential it was sent: every string it says is redacted before it is shown.
+        const safe = JSON.parse(JSON.stringify(reply, (_key, one) => typeof one === 'string' && secret ? one.replaceAll(secret, '[redacted]') : one));
+        write(json ? envelopeJson({ ...safe, command: 'team connect' }) : text(safe.message));
+    };
+    try {
+        // D5: `connect` belongs to the deprecated central team service; it still saves the profile remote commands use.
+        stderr(deprecationWarning('connect', 'team'));
+        if (argv.includes('--help')) {
+            write(HELP);
+            return 0;
+        }
+        const { flags, positions } = parse(argv);
+        if (flags.help) {
+            write(HELP);
+            return 0;
+        }
+        const profileName = value(flags, 'profile') || 'default';
+        if (!/^[A-Za-z0-9_-]{1,64}$/.test(profileName))
+            throw new UsageError('Profile names use 1–64 letters, digits, underscores or hyphens.');
+        let origin;
+        try {
+            origin = serviceOrigin(positions[0]);
+        }
+        catch {
+            throw new UsageError('Use an HTTPS service origin (loopback HTTP is allowed), without credentials, paths, query or fragment.');
+        }
+        if (['token-stdin', 'token-file', 'local-login'].filter(name => flags[name]).length !== 1)
+            throw new UsageError('Choose one credential source: --token-stdin, --token-file or --local-login.');
+        if (flags['login-file'] && !flags['local-login'])
+            throw new UsageError('--login-file requires --local-login.');
+        let account = value(flags, 'as');
+        if (flags['local-login']) {
+            const login = privateFile(value(flags, 'login-file') || join(dirname(databasePath(options.env ?? process.env, options.home ?? homedir())), 'up-login.txt'), 8192).trim().split(/\s+/);
+            if (login.length !== 2 || account && account !== login[0])
+                throw new UsageError('The local sign-in does not match the requested account.');
+            account = login[0];
+            secret = login[1];
+        }
+        else
+            secret = (flags['token-file'] ? privateFile(value(flags, 'token-file'), 8192) : await (options.readStdin ?? stdinSecret)()).trim();
+        if (!accountValid(account) || !tokenValid(secret))
+            throw new UsageError('Provide an account name and a valid sign-in secret from your selected source.');
+        if (parseApiToken(secret) === null)
+            stderr(PASSWORD_PROFILE_WARNING);
+        const profile = { origin, account, token: secret }, checked = await verify(profile, options);
+        if (!checked.ok) {
+            emit(checked);
+            return 1;
+        }
+        saveProfile(options, profileName, profile);
+        emit({ version: 1, ok: true, code: 'connected', message: `Connected to ${origin} as ${account}.`, result: { profile: profileName, origin, account } });
+        return 0;
+    }
+    catch (error) {
+        const reply = { version: 1, ok: false, code: 'usage', message: error instanceof UsageError ? error.message : 'The connection could not be prepared. Check the private profile and credential files.' };
+        if (json)
+            emit(reply);
+        else
+            stderr(text(reply.message));
+        return 2;
+    }
+}

package/dist/containment.d.ts

@@ -198,5 +198,3 @@ export declare function cgroup2Container(capability: ContainmentCapability, labe
  * the CI windows job exercises it.
  */
 export declare function jobObjectContainer(capability: ContainmentCapability, label: string): Container;
-/** Where the Windows helper lives beside this module (dist or src). */
-export declare function containmentModuleDir(): string;

package/dist/containment.js

@@ -36,9 +36,10 @@ import { randomBytes } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, rmdirSync, writeFileSync } from "node:fs";
 import { captureCgroupIdentity, cgroupEmptiness, containerEmptiness } from "./container-state.js";
 import { createServer } from "node:net";
-import { dirname, join } from "node:path";
+import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { envValue } from "./names.js";
+import { sleep } from "./sleep.js";
 export const CONTAINMENT_POLICIES = ["observed", "preferred", "required"];
 /** The environment name the controller reads when no flag names a policy. */
 export const CONTAINMENT_ENV = "TOOLROLL_CONTAINMENT";
@@ -278,7 +279,6 @@ export function createContainer(effective, label) {
         return { refused: `native containment could not be established for this spawn (${error instanceof Error ? error.message : String(error)}) — nothing ran` };
     }
 }
-const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
 /**
  * The cgroup2 prelude: join, confirm on fd 3, close it, exec the target
  * with argv exactly as given (positional parameters, never re-parsed).
@@ -562,7 +562,3 @@ export function jobObjectContainer(capability, label) {
         },
     };
 }
-/** Where the Windows helper lives beside this module (dist or src). */
-export function containmentModuleDir() {
-    return dirname(fileURLToPath(import.meta.url));
-}

package/dist/contracts/chat-actions.d.ts

@@ -267,7 +267,6 @@ export declare const chatActionRequestSchemas: {
 };
 export type ChatActionOperation = keyof typeof chatActionRequestSchemas;
 export declare const CHAT_ACTION_OPERATIONS: [ChatActionOperation, ...ChatActionOperation[]];
-export type ChatActionRequest<O extends ChatActionOperation = ChatActionOperation> = z.infer<(typeof chatActionRequestSchemas)[O]>;
 /** The fields each action takes, from its schema. */
 export declare const CHAT_ACTION_FIELDS: Record<ChatActionOperation, readonly string[]>;
 /** One action's data, refused by path (`card: required`, `payload: unknown key 'cards' (did you mean card?)`). */

package/dist/contracts/chat-content.d.ts

@@ -335,10 +335,6 @@ export declare const chatActionBodySchema: z.ZodUnion<readonly [z.ZodObject<{
     version: z.ZodLiteral<1>;
     problem: z.ZodString;
 }, z.core.$strict>]>;
-/** A notice carries its parts, not a body. */
-export declare const chatNoticeBodySchema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
-}, z.core.$strict>;
 export type ChatPairBody = z.infer<typeof chatPairBodySchema>;
 export type ChatMessageBody = z.infer<typeof chatMessageBodySchema>;
 export type ChatActionBody = z.infer<typeof chatActionBodySchema>;

package/dist/contracts/chat-content.js

@@ -125,8 +125,6 @@ export const chatMessageBodySchema = versioned(CHAT_EVENT_VERSION, {
 export const chatTokenBodySchema = versioned(CHAT_EVENT_VERSION, { token: z.string().regex(CHAT_BUTTON_TOKEN, { error: "must be a Toolroll button token" }) });
 export const chatProblemBodySchema = versioned(CHAT_EVENT_VERSION, { problem: z.string().min(1) });
 export const chatActionBodySchema = z.union([chatTokenBodySchema, chatProblemBodySchema]);
-/** A notice carries its parts, not a body. */
-export const chatNoticeBodySchema = versioned(CHAT_EVENT_VERSION, {});
 export function savedChatEventBody(body) {
     return JSON.stringify({ version: CHAT_EVENT_VERSION, ...body });
 }

package/dist/contracts/chat-tables.d.ts

@@ -10,4 +10,3 @@ export declare const isChatProvider: (value: unknown) => value is ChatProvider;
 export declare const CHAT_SCHEMA: string;
 /** Every shared chat table, parents before children. */
 export declare const CHAT_TABLES: readonly ["chat_binding", "chat_pair", "chat_event", "chat_part", "chat_action", "chat_progress", "chat_runtime", "chat_room", "chat_meta", "chat_flow_action", "chat_flow_prompt", "chat_flow_choice", "chat_flow_note", "chat_question_action", "chat_question_prompt", "chat_ask_action", "chat_message_ref", "chat_note_draft", "chat_digest"];
-export type ChatTable = (typeof CHAT_TABLES)[number];

package/dist/contracts/cli.d.ts

@@ -54,37 +54,6 @@ export declare const commandRowSchema: z.ZodReadonly<z.ZodObject<{
         meaning: z.ZodString;
     }, z.core.$loose>>>>>;
     notableReasons: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
-    inputSchema: z.ZodOptional<z.ZodCustom<{
-        type: 'object';
-        additionalProperties: false;
-        required: readonly string[];
-        properties: Record<string, {
-            type: 'string' | 'integer' | readonly ['string', 'null'];
-            minLength?: number;
-            maxLength?: number;
-            pattern?: string;
-            minimum?: number;
-            maximum?: number;
-            maxBytes?: number;
-            nonblank?: boolean;
-            const?: number;
-        }>;
-    }, {
-        type: 'object';
-        additionalProperties: false;
-        required: readonly string[];
-        properties: Record<string, {
-            type: 'string' | 'integer' | readonly ['string', 'null'];
-            minLength?: number;
-            maxLength?: number;
-            pattern?: string;
-            minimum?: number;
-            maximum?: number;
-            maxBytes?: number;
-            nonblank?: boolean;
-            const?: number;
-        }>;
-    }>>;
     remote: z.ZodEnum<{
         no: "no";
         "step-up": "step-up";
@@ -134,37 +103,6 @@ export declare const COMMAND_OUTPUTS: {
                 meaning: z.ZodString;
             }, z.core.$loose>>>>>;
             notableReasons: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
-            inputSchema: z.ZodOptional<z.ZodCustom<{
-                type: 'object';
-                additionalProperties: false;
-                required: readonly string[];
-                properties: Record<string, {
-                    type: 'string' | 'integer' | readonly ['string', 'null'];
-                    minLength?: number;
-                    maxLength?: number;
-                    pattern?: string;
-                    minimum?: number;
-                    maximum?: number;
-                    maxBytes?: number;
-                    nonblank?: boolean;
-                    const?: number;
-                }>;
-            }, {
-                type: 'object';
-                additionalProperties: false;
-                required: readonly string[];
-                properties: Record<string, {
-                    type: 'string' | 'integer' | readonly ['string', 'null'];
-                    minLength?: number;
-                    maxLength?: number;
-                    pattern?: string;
-                    minimum?: number;
-                    maximum?: number;
-                    maxBytes?: number;
-                    nonblank?: boolean;
-                    const?: number;
-                }>;
-            }>>;
             remote: z.ZodEnum<{
                 no: "no";
                 "step-up": "step-up";

package/dist/contracts/cli.js

@@ -38,8 +38,6 @@ function answers(command, shape) {
 export const commandFlagSchema = z.looseObject({ name: str, takesValue: z.boolean(), meaning: str }).readonly();
 /** The remote policy every command row states; see `remote` below. */
 export const REMOTE_POLICIES = ["yes", "no", "step-up"];
-/** A session operation's executable input schema, as session-contract.ts states it. */
-const sessionInputSchema = z.custom(value => typeof value === "object" && value !== null && !Array.isArray(value));
 export const commandRowSchema = z.looseObject({
     /** What you type after `toolroll` (subcommands included). */
     invocation: str,
@@ -62,8 +60,6 @@ export const commandRowSchema = z.looseObject({
     positionals: z.array(z.looseObject({ name: str, required: z.boolean(), meaning: str }).readonly()).readonly().optional(),
     flags: z.array(commandFlagSchema).readonly().optional(),
     notableReasons: z.array(str).readonly().optional(),
-    /** Session schemas are executable input contracts, not a grant of authority. */
-    inputSchema: sessionInputSchema.optional(),
     /** Whether a person signed in to a central server with their own API token may run it there (`runOperateAs`):
      *  yes — runs as that person, within their token's scope and project access.
      *  no — this machine's own infrastructure, credentials or files; never run for a remote caller.

package/dist/contracts/coding-workspace.js

@@ -6,6 +6,7 @@
 import { z } from "zod";
 import { readVersioned, versioned } from "./contract.js";
 import { CODING_CONTEXT_VERSION, codingContextSchema } from "./coding-context.js";
+import { isRecord } from "../is-record.js";
 export const CODING_STATUSES = ["starting", "ready", "working", "needs-input", "stopping", "interrupted", "failed", "uncertain", "closed"];
 export const codingSessionSchema = z.strictObject({
     id: z.string(),
@@ -33,7 +34,6 @@ export const codingSessionSchema = z.strictObject({
 });
 export const CODING_SESSION_VERSION = 1;
 export const codingSessionRecordSchema = versioned(CODING_SESSION_VERSION, codingSessionSchema.shape);
-const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 /**
  * Unversioned records were read as a cast, including partial fields, nulls and unknown nested keys. Preserve that
  * boundary exactly; only records explicitly written as version 1 are subject to its strict schema.

package/dist/contracts/contract.js

@@ -8,6 +8,7 @@
  */
 import { z } from "zod";
 import { limitRule, TEXT_LIMITS } from "../text-limits.js";
+import { isRecord } from "../is-record.js";
 /**
  * A string bounded by its TEXT_LIMITS entry, never a literal. The limit rule rides along as the field's description,
  * so a model reads the bound before it writes. Zod counts UTF-16 code units; for a limit named in bytes this is the
@@ -42,7 +43,6 @@ function got(input) {
         return "an array";
     return typeof input === "object" ? "an object" : `a ${typeof input}`;
 }
-const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 /** The schema at `path`, including whether that value may be omitted, following arrays, wrappers and unions. */
 function nodeAt(schema, input, path) {
     let node = schema, value = input;

package/dist/contracts/flow-card.d.ts

@@ -9,7 +9,6 @@
  */
 import { z } from "zod";
 export declare const FLOW_CARD_STATES: readonly ["active", "done", "cancelled"];
-export type FlowCardState = (typeof FLOW_CARD_STATES)[number];
 export declare const flowCardSchema: z.ZodObject<{
     id: z.ZodInt;
     flow: z.ZodInt;

package/dist/contracts/flow-propose.d.ts

@@ -320,6 +320,5 @@ export declare const proposeFlowInputSchema: z.ZodObject<{
         timeZone: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>], "kind">>;
 }, z.core.$strict>;
-export type ProposeFlowInput = z.infer<typeof proposeFlowInputSchema>;
 /** What the lead is told propose_flow takes: exactly the schema its call is read with. */
 export declare const PROPOSE_FLOW_MODEL_SCHEMA: Readonly<Record<string, unknown>>;

package/dist/contracts/flow-send.js

@@ -12,6 +12,7 @@
  */
 import { z } from "zod";
 import { parseContract, readVersioned, versioned } from "./contract.js";
+import { isRecord } from "../is-record.js";
 /** A link the message carries: a page of Toolroll's (a button) or the one outside page, a pull request. */
 export const flowSendLinkSchema = z.union([
     z.strictObject({ label: z.string(), path: z.string().regex(/^\//, { error: "must be a path in Toolroll, starting with /" }) }),
@@ -51,7 +52,6 @@ export const flowChoosePayloadSchema = versioned(FLOW_SEND_VERSION, {
     /** Whether a reply is taken instead (the zone has somewhere replies go). */
     reply: z.boolean(),
 });
-const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 /** A kept item as 0.9.36 read it: its five words (a web link), and a screenshot id only when it is a whole number. */
 const savedItemSchema = z.object({ ...flowSendItemSchema.shape, shot: z.unknown() });
 export function readFlowItems(raw) {

package/dist/contracts/gateway-tools.d.ts

@@ -371,7 +371,6 @@ export declare const GATEWAY_TOOL_OUTPUTS: {
         admission: z.ZodString;
     }, z.core.$loose>;
 };
-export type GatewayToolOutput<N extends GatewayToolName> = z.infer<(typeof GATEWAY_TOOL_OUTPUTS)[N]>;
 export declare const PERSON_TOOL_INPUTS: {
     readonly status: z.ZodObject<{}, z.core.$strict>;
     readonly list_tasks: z.ZodObject<{

package/dist/contracts/integration-metadata.js

@@ -14,9 +14,9 @@
  */
 import { z } from "zod";
 import { parseContract } from "./contract.js";
+import { isRecord } from "../is-record.js";
 /** RFC 6749 scope tokens. */
 export const SCOPE_TOKEN = /^[\x21\x23-\x5b\x5d-\x7e]{1,128}$/;
-const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 /** A field's schema without its optional wrapper. */
 const inner = (field) => (field instanceof z.ZodOptional ? field.unwrap() : field);
 /**

package/dist/contracts/lead-tools.d.ts

@@ -2003,7 +2003,6 @@ export declare const LEAD_TOOL_OUTPUTS: {
         awaiting: z.ZodString;
     }, z.core.$loose>;
 };
-export type LeadToolOutput<N extends LeadToolName> = z.infer<(typeof LEAD_TOOL_OUTPUTS)[N]>;
 /**
  * Report a result that disagrees with its output schema without hiding the actual result, including under Vitest.
  * Contract tests assert output shapes directly; executing a tool always writes the diagnostic and returns its result.

package/dist/contracts/memory-pass.d.ts

@@ -131,7 +131,6 @@ export declare const memoryEvidenceSchema: z.ZodArray<z.ZodObject<{
     session: z.ZodString;
     quote: z.ZodString;
 }, z.core.$strict>>;
-export type MemoryEvidence = z.infer<typeof memoryEvidenceSchema>;
 /** A proposal as its row reads; its evidence is a JSON list (an older runtime reads it as one, so it has no envelope). */
 export declare const memoryProposalSchema: z.ZodObject<{
     id: z.ZodInt;