@tealbrick/kit 0.3.0-rc.1 → 0.3.0-rc.10

package/dist/native-enroll.js

@@ -0,0 +1,85 @@
+import { realpath } from 'node:fs/promises';
+import { PortalHttpError } from '@tealbrick/portal';
+import { readKit } from './index.js';
+import { harnessLabels } from './native-selection.js';
+import { normalizeOrigin, readServeConfig, writeServeConfig } from './native-serve-config.js';
+/** Register this kit root's public chat endpoint on its EXISTING native Portal agent.
+ * Never creates or relabels an identity: the URL goes through Portal's owned-connection
+ * upsert, which preserves the agent's harness runtime (the Eve registration route would
+ * rewrite it to "eve"). The user token stays in memory. */
+export async function enrollNative(root, input, login, options = {}) {
+    root = await realpath(root);
+    const kit = await readKit(root);
+    if (!kit.native || !kit.runtime)
+        throw Error('kit_native_setup_required');
+    const { runtime } = kit, label = harnessLabels[kit.native.harness];
+    if (login.issuer !== runtime.issuer || login.org !== runtime.org)
+        throw Error('kit_runtime_existing_binding_mismatch');
+    const url = normalizeOrigin(input.url), old = await readServeConfig(root), port = input.port ?? old?.port ?? 5331;
+    if (!Number.isInteger(port) || port < 1024 || port > 65535)
+        throw Error('kit_native_serve_invalid_port');
+    const path = `/api/workspace?workspaceId=${encodeURIComponent(runtime.workspaceId)}`;
+    const owned = (snapshot) => {
+        const agent = snapshot.agents?.find(a => a.id === runtime.agentId && a.bindable);
+        const nodes = snapshot.draft?.nodes?.filter(n => n.data?.kind === 'agent' && n.data.agentId === runtime.agentId) ?? [];
+        if (snapshot.workspace?.id !== runtime.workspaceId || !agent || nodes.length !== 1)
+            throw Error('kit_owned_agent_card_required');
+        if (agent.runtime !== label || nodes[0].data.harness !== label)
+            throw Error('kit_native_portal_harness_mismatch');
+        return { agent, node: nodes[0] };
+    };
+    const { agent } = owned(await login.client.request(path));
+    let registered;
+    try {
+        registered = await login.client.request('/api/connections', { name: agent.name, runtime: label, url });
+    }
+    catch (error) {
+        if (error instanceof PortalHttpError && [404, 405].includes(error.status))
+            throw Error('kit_portal_connections_unsupported');
+        throw error;
+    }
+    const c = registered.connection;
+    if (c?.id !== agent.id || c.url !== url || c.runtime !== label)
+        throw Error('kit_portal_registration_mismatch');
+    await writeServeConfig(root, { ...(old ?? { version: 1, port }), version: 1, port, publicUrl: url, agent: { id: agent.id, name: agent.name, ownerId: login.userId } });
+    // Re-read after registration: preserve concurrent canvas changes and revision checks.
+    for (let attempt = 0;; attempt++) {
+        const fresh = await login.client.request(path), { node } = owned(fresh);
+        if (node.data.endpoint === url && node.data.authMethod === 'portal-pairing')
+            break;
+        const nodes = fresh.draft.nodes.map(n => n.id === node.id ? { ...n, data: { ...n.data, endpoint: url, authMethod: 'portal-pairing' } } : n);
+        try {
+            await login.client.request('/api/workspace/draft', { workspaceId: runtime.workspaceId, draftRevision: fresh.draftRevision, draft: { ...fresh.draft, nodes } });
+            break;
+        }
+        catch (error) {
+            if (error instanceof PortalHttpError && error.code === 'draft_changed_reload' && attempt < 2)
+                continue;
+            throw error;
+        }
+    }
+    const directory = await login.client.request(`/api/me/agents?workspaceId=${encodeURIComponent(runtime.workspaceId)}`);
+    if (directory.workspaceId !== runtime.workspaceId || !directory.agents?.some(a => a.id === agent.id && a.url === url))
+        throw Error('kit_portal_sidebar_verification_failed');
+    const endpoint = { healthy: false, authenticated: false, reason: undefined };
+    if (options.verifyEndpoint !== false) {
+        const f = options.fetch ?? fetch, get = (route, headers = {}) => f(url + route, { headers, redirect: 'error', signal: AbortSignal.timeout(10000) });
+        try {
+            const health = await get('/healthz'), body = health.ok ? await health.json() : undefined;
+            endpoint.healthy = body?.harness === kit.native.harness;
+            if (!endpoint.healthy)
+                endpoint.reason = 'health_check_failed';
+            else if (login.identity) {
+                const info = await get('/tealbrick/v1/info', { authorization: `Bearer ${login.identity.token}`, 'x-tealbrick-bundle': login.identity.bundle });
+                const value = info.ok ? await info.json() : undefined;
+                endpoint.authenticated = value?.harness === kit.native.harness && value.name === agent.name;
+                if (!endpoint.authenticated)
+                    endpoint.reason = 'authenticated_info_failed_' + info.status;
+            }
+        }
+        catch {
+            endpoint.reason = 'endpoint_unreachable';
+        }
+    }
+    return { enrolled: true, agentId: agent.id, name: agent.name, harness: label, endpoint: url, workspaceId: runtime.workspaceId, portalVerified: true, endpointVerified: endpoint.healthy && endpoint.authenticated, ...(endpoint.reason ? { endpointReason: endpoint.reason } : {}) };
+}

package/dist/native-runtime-sync.d.ts

@@ -0,0 +1,49 @@
+import { RuntimeConnector } from '@tealbrick/portal/runtime';
+import type { JWTVerifyGetKey } from 'jose';
+export type RuntimeCapabilities = Awaited<ReturnType<RuntimeConnector['capabilities']>>;
+export type RuntimeSyncStatus = 'starting' | 'synced' | 'retrying' | 'inactive' | 'stopped';
+export interface RuntimeSyncSnapshot {
+    status: RuntimeSyncStatus;
+    revision?: string;
+    expiresAt?: number;
+    lastSyncAt?: number;
+    failures: number;
+    error?: string;
+    capabilities?: RuntimeCapabilities;
+}
+export interface RuntimeSyncOptions {
+    fetch?: typeof fetch;
+    keys?: JWTVerifyGetKey;
+    log?: (event: Record<string, unknown>) => void;
+    /** Base delay between successful syncs. Portal's signed config lives 300s, so this must stay well below it. */
+    intervalMs?: number;
+    jitterMs?: number;
+    /** First retry delay after a failure; doubles per consecutive failure up to maxRetryMs. */
+    retryMs?: number;
+    maxRetryMs?: number;
+    random?: () => number;
+    now?: () => number;
+}
+/**
+ * Keeps this customer runtime's Portal configuration acknowledged while `native serve` is idle.
+ * The per-turn Teal Brick MCP child still fetches a fresh authorization for every call; this loop
+ * only fetches the signed config, acknowledges it (Portal derives runtime sync freshness from that)
+ * and holds the latest capability snapshot in memory. App credentials never leave the kit root.
+ */
+export declare function startRuntimeSync(root: string, options?: RuntimeSyncOptions): {
+    snapshot: () => RuntimeSyncSnapshot;
+    capabilities: () => {
+        revision: string;
+        expiresAt: number;
+        apps: {
+            registrationId: string;
+            appId: "knowledge";
+            actions: import("@tealbrick/portal/runtime").CrudAction[];
+            available: boolean;
+            operations: import("@tealbrick/portal/runtime").KnowledgeOperation[];
+        }[];
+    } | undefined;
+    syncNow: () => Promise<void>;
+    stop(): Promise<void>;
+};
+export type RuntimeSync = ReturnType<typeof startRuntimeSync>;

package/dist/native-runtime-sync.js

@@ -0,0 +1,101 @@
+import { RuntimeConnector } from '@tealbrick/portal/runtime';
+import { readKit } from './index.js';
+import { runtimeSecret } from './secrets.js';
+const defaults = { intervalMs: 90_000, jitterMs: 30_000, retryMs: 15_000, maxRetryMs: 240_000 };
+const code = (v) => typeof v === 'string' && /^[a-z][a-z0-9_]{0,80}$/.test(v) ? v : undefined;
+/**
+ * Keeps this customer runtime's Portal configuration acknowledged while `native serve` is idle.
+ * The per-turn Teal Brick MCP child still fetches a fresh authorization for every call; this loop
+ * only fetches the signed config, acknowledges it (Portal derives runtime sync freshness from that)
+ * and holds the latest capability snapshot in memory. App credentials never leave the kit root.
+ */
+export function startRuntimeSync(root, options = {}) {
+    const o = { ...defaults, ...options }, random = o.random ?? Math.random, now = o.now ?? Date.now;
+    const log = o.log ?? ((event) => process.stderr.write(JSON.stringify(event) + '\n'));
+    const base = o.fetch ?? fetch;
+    let state = { status: 'starting', failures: 0 };
+    let timer, stopped = false, running;
+    let connector, connectorKey;
+    let observed = {};
+    const observe = async (input, init) => {
+        const response = await base(input, init);
+        const path = new URL(input instanceof Request ? input.url : String(input)).pathname;
+        if (path === '/api/runtime/config' || path === '/api/runtime/ack') {
+            observed[path === '/api/runtime/config' ? 'config' : 'ack'] = response.status;
+            if (!response.ok)
+                observed.code = code(await response.clone().json().then((b) => b?.error ?? b?.code, () => undefined)) ?? observed.code;
+        }
+        return response;
+    };
+    const jitter = (ms, spread) => Math.max(1, Math.round(ms + (random() * 2 - 1) * spread));
+    function schedule(ms) { if (stopped)
+        return; clearTimeout(timer); timer = setTimeout(() => { void syncNow(); }, ms); timer.unref?.(); }
+    async function cycle() {
+        let kit;
+        try {
+            kit = await readKit(root);
+        }
+        catch {
+            kit = undefined;
+        }
+        if (!kit?.native?.active || !kit.runtime) {
+            if (state.status !== 'inactive')
+                log({ event: 'native.runtime.sync.inactive', message: 'Teal Brick runtime is not active in this kit root; Portal sync is paused.' });
+            connector = undefined;
+            connectorKey = undefined;
+            state = { status: 'inactive', failures: 0 };
+            schedule(jitter(o.intervalMs, o.jitterMs));
+            return;
+        }
+        const { credentialRef, ...runtime } = kit.runtime, key = JSON.stringify(kit.runtime);
+        if (!connector || key !== connectorKey) {
+            connector = new RuntimeConnector({ ...runtime, credential: () => runtimeSecret(credentialRef, root), resolveCredential: name => runtimeSecret(name, root), fetch: observe, ...(o.keys ? { keys: o.keys } : {}) });
+            connectorKey = key;
+        }
+        observed = {};
+        let capabilities;
+        try {
+            capabilities = await connector.capabilities(true);
+        }
+        catch (error) {
+            const reason = code(error?.message) ?? 'runtime_sync_failed';
+            if (observed.config === 401) {
+                const why = observed.code ?? 'runtime_credential_invalid';
+                stopped = true;
+                clearTimeout(timer);
+                state = { ...state, status: 'stopped', error: why };
+                log({ event: 'native.runtime.sync.stopped', reason: 'credential_revoked', code: why, message: `Portal rejected this runtime's credential (${why}); background runtime sync has stopped and Portal will show the runtime as expired. Re-enroll with \`tealbrick native setup\`, then restart native serve.` });
+                return;
+            }
+            const failures = state.failures + 1, delay = jitter(Math.min(o.maxRetryMs, o.retryMs * 2 ** (failures - 1)), Math.min(o.maxRetryMs, o.retryMs * 2 ** (failures - 1)) * 0.2);
+            state = { ...state, status: 'retrying', failures, error: observed.code ?? reason };
+            log({ event: 'native.runtime.sync.failed', code: state.error, ...(observed.config !== undefined ? { status: observed.config } : {}), failures, retryInMs: delay });
+            schedule(delay);
+            return;
+        }
+        const changed = state.status !== 'synced' || state.revision !== capabilities.revision;
+        const ackFailed = observed.ack !== undefined && !(observed.ack >= 200 && observed.ack < 300);
+        state = { status: ackFailed ? 'retrying' : 'synced', revision: capabilities.revision, expiresAt: capabilities.expiresAt, lastSyncAt: now(), failures: ackFailed ? state.failures + 1 : 0, capabilities, ...(ackFailed ? { error: observed.code ?? 'runtime_ack_failed' } : {}) };
+        if (ackFailed)
+            log({ event: 'native.runtime.ack.failed', code: state.error, status: observed.ack, failures: state.failures });
+        else if (changed)
+            log({ event: 'native.runtime.synced', revision: capabilities.revision.slice(0, 12), apps: capabilities.apps.length, available: capabilities.apps.filter(a => a.available).length, expiresAt: new Date(capabilities.expiresAt).toISOString() });
+        // Never let the acknowledged lease lapse between syncs; a failed ack retries on the short schedule.
+        const next = ackFailed ? jitter(o.retryMs, o.retryMs * 0.2) : jitter(o.intervalMs, o.jitterMs);
+        schedule(Math.max(1, Math.min(next, capabilities.expiresAt - now() - 30_000)));
+    }
+    async function syncNow() {
+        if (stopped)
+            return;
+        running ??= cycle().catch(error => { log({ event: 'native.runtime.sync.failed', code: code(error?.message) ?? 'runtime_sync_failed' }); schedule(o.maxRetryMs); }).finally(() => { running = undefined; });
+        return running;
+    }
+    void syncNow();
+    return {
+        snapshot: () => ({ ...state }),
+        capabilities: () => state.capabilities,
+        syncNow,
+        async stop() { stopped = true; clearTimeout(timer); await running; if (state.status !== 'stopped')
+            state = { ...state, status: 'stopped' }; },
+    };
+}

package/dist/native-selection.js

@@ -37,6 +37,8 @@ export async function selectNativeIdentity(root, flags, login, prompts) {
     if (workspaceName && flags.node)
         throw Error('kit_native_existing_node_requires_workspace');
     const cards = directory.agents.filter(a => a.harness === harness).map(agent => ({ agent }));
+    const unavailable = directory.agents.filter(a => a.harness !== harness).map(a => `${a.name} (${a.harness})`);
+    const context = unavailable.length ? ` Unavailable for ${harness}: ${unavailable.join(', ')}. Existing cards cannot be converted.` : '';
     let agentId = flags.agent;
     if (flags['agent-name']) {
         const matches = cards.filter((c) => c.agent.name === flags['agent-name']);
@@ -48,9 +50,9 @@ export async function selectNativeIdentity(root, flags, login, prompts) {
         agentId = old.runtime.agentId;
     let name = flags['create-agent'];
     if (!agentId && !name) {
-        const choice = cards.length ? await prompts.choose('Choose an agent to attach', [...cards.map((c) => ({ name: `${c.agent.name} (${c.agent.id})`, value: c.agent.id })), { name: 'Create an agent', value: '__create__' }]) : '__create__';
+        const choice = cards.length ? await prompts.choose('Choose an agent to attach.' + context, [...cards.map((c) => ({ name: `${c.agent.name} — ${c.agent.harness} (${c.agent.id})`, value: c.agent.id })), { name: 'Create an agent', value: '__create__' }]) : '__create__';
         if (choice === '__create__')
-            name = await prompts.name('New agent name');
+            name = await prompts.name('New agent name.' + context);
         else {
             const card = cards.find((c) => c.agent.id === choice);
             if (!card)
@@ -58,8 +60,21 @@ export async function selectNativeIdentity(root, flags, login, prompts) {
             agentId = card.agent.id;
         }
     }
-    if (name)
-        return { workspace, agent: { name: validName(name) } };
+    while (name) {
+        name = validName(name);
+        const conflicts = directory.agents.filter(a => a.name === name);
+        if (!conflicts.length)
+            return { workspace, agent: { name } };
+        const choice = await prompts.choose(`The name "${name}" already belongs to ${conflicts.map(a => `${a.name} (${a.harness}, ${a.id})`).join(', ')}. Select a compatible ${harness} card or choose another name.`, [...cards.map(c => ({ name: `${c.agent.name} — ${c.agent.harness} (${c.agent.id})`, value: c.agent.id })), { name: 'Choose another name', value: '__create__' }]);
+        if (choice === '__create__') {
+            name = await prompts.name('Different agent name.' + context);
+            continue;
+        }
+        if (!cards.some(c => c.agent.id === choice))
+            throw Error('kit_owned_agent_card_required');
+        agentId = choice;
+        name = undefined;
+    }
     const matches = cards.filter((c) => c.agent.id === agentId);
     if (matches.length !== 1)
         throw Error('kit_owned_agent_card_required');

package/dist/native-serve-config.d.ts

@@ -0,0 +1,286 @@
+import { z } from 'zod';
+export declare const hostPattern: RegExp;
+declare const stdio: z.ZodObject<{
+    type: z.ZodOptional<z.ZodLiteral<"stdio">>;
+    command: z.ZodString;
+    args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strict>;
+export declare const tealbrickCallGrant: z.ZodObject<{
+    registrationId: z.ZodString;
+    operation: z.ZodString;
+    inputEquals: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
+}, z.core.$strict>;
+declare const effort: z.ZodEnum<{
+    low: "low";
+    high: "high";
+    medium: "medium";
+    xhigh: "xhigh";
+    max: "max";
+}>;
+/** Tools an agent may add to its default (Restricted) session access: research and expert delegation, never shell or writes. */
+export declare const defaultAccessTools: readonly ["WebSearch", "WebFetch", "Agent", "TodoWrite"];
+export declare const expertContractSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"tealbrick.expert-contract/v1">;
+    id: z.ZodString;
+    version: z.ZodString;
+    purpose: z.ZodString;
+    instructions: z.ZodString;
+    input: z.ZodObject<{
+        type: z.ZodLiteral<"object">;
+    }, z.core.$loose>;
+    output: z.ZodObject<{
+        type: z.ZodLiteral<"object">;
+    }, z.core.$loose>;
+    capabilities: z.ZodObject<{
+        builtinTools: z.ZodArray<z.ZodEnum<{
+            WebSearch: "WebSearch";
+            WebFetch: "WebFetch";
+            Read: "Read";
+            Glob: "Glob";
+            Grep: "Grep";
+        }>>;
+        apps: z.ZodArray<z.ZodObject<{
+            appId: z.ZodString;
+            operations: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        marketplace: z.ZodArray<z.ZodObject<{
+            plugin: z.ZodString;
+            actions: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    approval: z.ZodObject<{
+        outwardWrites: z.ZodEnum<{
+            always: "always";
+            "never-allowed": "never-allowed";
+        }>;
+        operations: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    model: z.ZodEnum<{
+        haiku: "haiku";
+        inherit: "inherit";
+        opus: "opus";
+        sonnet: "sonnet";
+    }>;
+    effort: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        high: "high";
+        medium: "medium";
+    }>>;
+    budget: z.ZodObject<{
+        maxTurns: z.ZodNumber;
+    }, z.core.$strict>;
+    runtime: z.ZodEnum<{
+        subagent: "subagent";
+        "desktop-operator": "desktop-operator";
+    }>;
+    changelog: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type ExpertContract = z.infer<typeof expertContractSchema>;
+/**
+ * Owner-defined standing grant: a bounded class of calls that would otherwise pause for payload approval
+ * and that the kit hook approves without a prompt, within caps, until it expires. Never a wider scope than
+ * decideTool already allows; it only replaces the per-payload prompt.
+ */
+export declare const standingGrantSchema: z.ZodObject<{
+    id: z.ZodString;
+    description: z.ZodString;
+    operation: z.ZodDefault<z.ZodString>;
+    match: z.ZodObject<{
+        registrationId: z.ZodOptional<z.ZodString>;
+        plugin: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+        action: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>;
+    experts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    caps: z.ZodObject<{
+        perDay: z.ZodNumber;
+        perHour: z.ZodOptional<z.ZodNumber>;
+        minIntervalSeconds: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    expires: z.ZodISODateTime;
+    deny: z.ZodOptional<z.ZodObject<{
+        inputPattern: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type StandingGrant = z.infer<typeof standingGrantSchema>;
+export declare const serveConfigSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    port: z.ZodNumber;
+    publicUrl: z.ZodOptional<z.ZodString>;
+    allowedHosts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    maxActiveTurns: z.ZodOptional<z.ZodNumber>;
+    agent: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        ownerId: z.ZodString;
+    }, z.core.$strict>>;
+    claude: z.ZodOptional<z.ZodObject<{
+        sdkModule: z.ZodOptional<z.ZodString>;
+        cwd: z.ZodString;
+        instructionsFile: z.ZodOptional<z.ZodString>;
+        recipe: z.ZodOptional<z.ZodObject<{
+            path: z.ZodString;
+            agent: z.ZodString;
+        }, z.core.$strict>>;
+        model: z.ZodOptional<z.ZodString>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            high: "high";
+            medium: "medium";
+            xhigh: "xhigh";
+            max: "max";
+        }>>;
+        maxTurns: z.ZodOptional<z.ZodNumber>;
+        maxBudgetUsd: z.ZodOptional<z.ZodNumber>;
+        timeoutSeconds: z.ZodOptional<z.ZodNumber>;
+        defaultTools: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            WebSearch: "WebSearch";
+            WebFetch: "WebFetch";
+            Agent: "Agent";
+            TodoWrite: "TodoWrite";
+        }>>>;
+        experts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            promptFile: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            tools: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                WebSearch: "WebSearch";
+                WebFetch: "WebFetch";
+                Read: "Read";
+                Glob: "Glob";
+                Grep: "Grep";
+            }>>>;
+            maxTurns: z.ZodOptional<z.ZodNumber>;
+            effort: z.ZodOptional<z.ZodEnum<{
+                low: "low";
+                high: "high";
+                medium: "medium";
+                xhigh: "xhigh";
+                max: "max";
+            }>>;
+        }, z.core.$strict>>>;
+        contracts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        approvalOperations: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        standingGrants: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            description: z.ZodString;
+            operation: z.ZodDefault<z.ZodString>;
+            match: z.ZodObject<{
+                registrationId: z.ZodOptional<z.ZodString>;
+                plugin: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+                action: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+            }, z.core.$strict>;
+            experts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            caps: z.ZodObject<{
+                perDay: z.ZodNumber;
+                perHour: z.ZodOptional<z.ZodNumber>;
+                minIntervalSeconds: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>;
+            expires: z.ZodISODateTime;
+            deny: z.ZodOptional<z.ZodObject<{
+                inputPattern: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
+        nativeTools: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>>;
+        readTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        mcpServers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodOptional<z.ZodLiteral<"stdio">>;
+            command: z.ZodString;
+            args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strict>>>;
+        tealbrickCalls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            registrationId: z.ZodString;
+            operation: z.ZodString;
+            inputEquals: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
+        }, z.core.$strict>>>;
+        requireSubscription: z.ZodOptional<z.ZodBoolean>;
+        workspace: z.ZodOptional<z.ZodObject<{
+            dir: z.ZodString;
+            network: z.ZodOptional<z.ZodObject<{
+                allowedDomains: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+            envAllow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+        envPassthrough: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    codex: z.ZodOptional<z.ZodObject<{
+        codexBin: z.ZodString;
+        cwd: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ServeConfig = z.infer<typeof serveConfigSchema>;
+export interface ClaudeProfile {
+    cwd: string;
+    sdkModule?: string;
+    instructions?: string;
+    model?: string;
+    effort?: z.infer<typeof effort>;
+    maxTurns: number;
+    maxBudgetUsd?: number;
+    timeoutSeconds: number;
+    defaultTools: string[];
+    experts: Record<string, ClaudeExpert>;
+    contracts: Record<string, ExpertContract>;
+    approvalOperations: string[];
+    standingGrants: StandingGrant[];
+    nativeTools: string[];
+    readTools: string[];
+    mcpServers: Record<string, z.infer<typeof stdio>>;
+    tealbrickCalls: Array<z.infer<typeof tealbrickCallGrant>>;
+    requireSubscription: boolean;
+    envPassthrough: string[];
+    /** Present only when `claude.workspace` is configured; `cwd` is then the workspace directory. */
+    workspace?: ClaudeWorkspace;
+}
+export interface ClaudeWorkspace {
+    dir: string;
+    root: string;
+    allowedDomains: string[];
+    /** envPassthrough names explicitly marked non-secret (still visible to sandboxed shell commands). */
+    envAllow: string[];
+}
+export interface ClaudeExpert {
+    description: string;
+    prompt: string;
+    tools: string[];
+    maxTurns: number;
+    effort?: z.infer<typeof effort>;
+}
+export declare const servePaths: (root: string) => {
+    config: string;
+    state: string;
+    sdk: string;
+    /** Kit-owned attachment inbox: written only by the kit process, readable (never writable) by the sandboxed workspace session. */
+    inbox: string;
+};
+export declare function normalizeOrigin(value: string): string;
+/** Host header values a TLS-terminating proxy for `publicUrl` may present. */
+export declare function publicHosts(config: ServeConfig): string[];
+export declare function readServeConfig(root: string): Promise<ServeConfig | undefined>;
+export declare function writeServeConfig(root: string, config: ServeConfig): Promise<void>;
+/** The kit-generated Claude attachment: tealbrick MCP server plus the child guard hook. */
+declare const generatedClaude: z.ZodObject<{
+    settings: z.ZodObject<{
+        hooks: z.ZodObject<{
+            PreToolUse: z.ZodArray<z.ZodObject<{
+                matcher: z.ZodLiteral<"mcp__tealbrick__.*">;
+                hooks: z.ZodArray<z.ZodObject<{
+                    type: z.ZodLiteral<"command">;
+                    command: z.ZodString;
+                    args: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    mcpServers: z.ZodObject<{
+        tealbrick: z.ZodObject<{
+            command: z.ZodString;
+            args: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type ClaudeAttachment = z.infer<typeof generatedClaude>;
+export declare function readClaudeAttachment(root: string): Promise<ClaudeAttachment>;
+/** Resolve the effective Claude profile. Explicit serve fields override the imported recipe. */
+export declare function resolveClaudeProfile(root: string, config: ServeConfig): Promise<ClaudeProfile>;
+export {};