@anchrd/intel 0.59.0

package/dist/bundle/bundle.types.d.ts

@@ -0,0 +1,33 @@
+import type { BundleImportResult, BundleManifest } from "../contract/bundle.js";
+import type { FlowRepository } from "../flows/flows.types.js";
+import type { Actor, ContentStore, NodeRepository } from "../nodes/nodes.types.js";
+export interface BundleActor extends Actor {
+    canReadFlows: boolean;
+    canCreateFlows?: boolean;
+}
+export interface BundleDeps {
+    repository: Pick<NodeRepository, "getVisible" | "listVisibleSubtree" | "listVersionContentKeys" | "can" | "importTree" | "findImportReplay" | "resolveVisibleTitles">;
+    flows: Pick<FlowRepository, "listVisible" | "getVisible" | "getVersions">;
+    content: Pick<ContentStore, "get" | "getStream" | "put" | "putBytes" | "delete">;
+    id(): string;
+    now(): Date;
+    hash(content: string | Uint8Array): Promise<string>;
+    indexing: {
+        enqueue(versionId: string): Promise<void>;
+    };
+}
+export interface BundleExport {
+    filename: string;
+    stream: ReadableStream<Uint8Array>;
+}
+export interface BundleImportInput {
+    targetNodeId: string | null;
+    zip: ReadableStream<Uint8Array> | Uint8Array;
+    idempotencyKey: string;
+}
+export interface BundleService {
+    exportSubtree(actor: BundleActor, rootId: string | null): Promise<BundleExport>;
+    exportFlow(actor: BundleActor, flowId: string): Promise<BundleExport>;
+    manifest(actor: BundleActor, rootId: string | null): Promise<BundleManifest>;
+    importBundle(actor: BundleActor, input: BundleImportInput): Promise<BundleImportResult>;
+}

package/dist/bundle/bundle.types.js

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

package/dist/cli/cli.d.ts

@@ -0,0 +1,4 @@
+import type { CliDeps } from "./cli.types.js";
+export declare function createCli(deps: CliDeps): {
+    run(argv: string[]): Promise<number>;
+};

package/dist/cli/cli.js

@@ -0,0 +1,262 @@
+import { createBuild } from "../build/build.js";
+import { createPrepare } from "../prepare/prepare.js";
+const interfaces = [
+    // ⚠️ No `use`. Nothing asked it (#475): every door in Intel asks a concrete capability —
+    // `nodes:read`, `flows:run`, `mcp:connect` — and a coarse "may use Intel at all" beside them is a
+    // permission an operator sets and nothing consults. Worse than useless: somebody granted only
+    // `intel:use` gets the empty screen the README warns about and reads it as a defect.
+    // `admin` stays and is the opposite case — it is the one way into a tree that carries no grant
+    // yet (ADR-0004 §6), read in ten places.
+    { handle: "intel", functions: ["admin"] },
+    // ⚠️ `nodes`, not `knowledge` — and the rename cost something, which is why it needed its own
+    // ticket (#152) five months after #125 renamed everything else. This handle is only half Intel's:
+    // `bootstrap` DECLARES it in Gate and touches no grant on an interface it does not name, so to
+    // Gate a renamed handle is a NEW one. Every grant on the old name keeps pointing at the old name,
+    // and everybody loses access at once, silently, until an operator hands the permissions out again.
+    //
+    // It was done in the one window where that is free: the installation on anchrd.sh was being
+    // rebuilt anyway (#385, anchrd/core#93) and there is no other. Doing it later would mean doing it
+    // to somebody.
+    //
+    // ⚠️ The old `knowledge` interface stays declared in Gate — bootstrap declares only the handles in
+    // this list and never revokes a whole INTERFACE. It is a harmless leftover on installations that
+    // have it, and nothing in Intel asks about it any more; removing it is an act in Gate, by hand,
+    // when somebody is sure nothing else uses it.
+    { handle: "nodes", functions: ["read", "create", "write", "share"] },
+    // ⚠️ No `approve`. The approval node is gone (#73), and this list is what Intel declares to Gate:
+    // a function nobody asks about is a permission an operator has to decide on for no reason.
+    //
+    // ⚠️ Dropping a FUNCTION from a still-declared interface is not the harmless leftover the two
+    // blocks around this one describe (#474). `gate.set` is `PUT /api/v1/service/interfaces/:handle`,
+    // an upsert that REPLACES the function list, and in the same batch Gate runs `obsoleteGrants` —
+    // `DELETE FROM grants WHERE interface_id = ? AND function NOT IN (…)`. Gate holds that down with
+    // a test of its own (`service-interfaces.int.ts`, "scoped set/remove per App-Key und entfernt
+    // Grants gestrichener Funktionen"), and it is right to: catalog and grants are one change against
+    // Gate's own reasoning above `obsoleteGrants`. So an installation that granted `approve` does
+    // NOT keep it — the next bootstrap deletes every role assignment on it. That is why bootstrap
+    // reads the current list before it writes and names what it takes away.
+    {
+        handle: "flows",
+        functions: ["read", "create", "write", "publish", "run", "share"],
+    },
+    // ⚠️ No `admin`. Nothing asked it either (#475), and here the reason is architectural rather than
+    // an oversight: the Cloudflare MCP Portal owns which servers exist and who may reach each one, and
+    // Intel stores no tool permissions at all — the catalog is a live `tools/list` with the asking
+    // person's token. There is no administration of tools inside Intel for the function to guard, so
+    // it cannot grow a reader later without that boundary moving first.
+    { handle: "tools", functions: ["read", "test", "execute"] },
+    // ⚠️ `agents:run` is deliberately NOT here any more (#390). The whole `agents` handle left the
+    // list, and bootstrap writes only the handles it names, so an installation that has that
+    // interface keeps it and its grants as a harmless leftover — but a new one is not asked to decide
+    // about a permission nothing reads. ⚠️ This holds because a whole INTERFACE went; a single
+    // function taken out of a handle that is still listed here is deleted along with its grants, see
+    // the block above (#474).
+    // `mcp:connect` means the same thing at every MCP service of this installation. A separate name
+    // for the same thing forces the operator to check, service by service, which permission carries
+    // portal access.
+    { handle: "mcp", functions: ["connect"] },
+];
+// What Intel used to declare and no longer does, keyed by handle for a whole interface and by
+// `handle:function` for a single function.
+//
+// ⚠️ It exists because "surplus: approve" is not actionable on its own (#466). An operator who reads
+// only the name has to decide whether somebody meant it, and the cheapest way out of that decision
+// is to leave it standing — which is how `approve` outlived #73 by months. The reason is the half
+// that turns the note into a decision instead of a puzzle, so a new retirement belongs in here in
+// the same pull request that takes its entry out of `interfaces` above.
+const retired = {
+    knowledge: "the whole interface became `nodes` (#152, after #125).",
+    agents: "the whole interface went when Agents left the surface (#390, #388).",
+    "flows:approve": "the approval node is gone (#73).",
+    "intel:use": "no door ever asked it; every one of them asks a concrete capability (#475).",
+    "tools:admin": "the portal owns tool administration, so Intel never had anything to guard (#475).",
+};
+// An unlisted surplus gets a sentence too. "no reason recorded" is an answer an operator can act on;
+// an empty dash reads as an omission and sends them looking for the missing half.
+function reason(key) {
+    return retired[key] ?? "no reason is recorded here, so read the history before removing it.";
+}
+const usage = `Usage: intel <prepare|bootstrap|build|doctor|reindex>
+  intel prepare    Copy versioned D1 migrations to .intel/migrations
+  intel bootstrap  Idempotently declare Intel interfaces in Gate
+  intel build      Apply intel.json and atomically build the customer UI
+  intel doctor     Check packages, environment, migrations, UI, and Gate interfaces
+  intel reindex    Request a full authorized search-index rebuild`;
+export function createCli(deps) {
+    const envValue = (name) => deps.env[name]?.trim() || null;
+    const fail = (message) => {
+        deps.log(`Error: ${message}`);
+        return 1;
+    };
+    const within = async (work, milliseconds = 10_000) => {
+        let timer;
+        try {
+            return await Promise.race([
+                work,
+                new Promise((_resolve, reject) => {
+                    timer = setTimeout(() => reject(new Error("operation timed out")), milliseconds);
+                }),
+            ]);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    };
+    async function bootstrap() {
+        const gateUrl = envValue("GATE_URL");
+        const serviceKey = envValue("GATE_SERVICE_KEY") ?? envValue("GATE_KEY");
+        if (!gateUrl || !serviceKey) {
+            return fail("GATE_URL and GATE_SERVICE_KEY must be set.");
+        }
+        const gate = deps.createGateInterfaces(gateUrl, serviceKey);
+        // ⚠️ Read before writing, and refuse if the read fails. The current list is the only place the
+        // functions Gate is about to lose are named; `set` replaces it, and afterwards nothing can say
+        // which grants went with them (#474). A run that writes anyway takes permissions away and has
+        // nothing left to report — the old "No grants were changed." in exactly the shape that made it
+        // wrong. Bootstrap is idempotent, so refusing costs a second run.
+        let current;
+        try {
+            current = await within(gate.list());
+        }
+        catch {
+            return fail("Gate interfaces could not be read, so bootstrap cannot say which grants it would delete.");
+        }
+        let removed = 0;
+        for (const entry of interfaces) {
+            const declared = entry.functions;
+            const dropped = (current.find((row) => row.handle === entry.handle)?.functions ?? []).filter((fn) => !declared.includes(fn));
+            await gate.set(entry.handle, [...entry.functions]);
+            // Logged per interface, right after its own write returned, so a run that fails halfway still
+            // named every deletion it actually caused.
+            if (dropped.length) {
+                removed += dropped.length;
+                const names = dropped.map((fn) => `${entry.handle}:${fn}`).join(", ");
+                deps.log(`Removed ${names} from Gate; every grant on ${dropped.length === 1 ? "it" : "them"} was deleted with it.`);
+            }
+        }
+        deps.log(`Declared ${interfaces.length} Intel interfaces in Gate.`);
+        if (!removed)
+            deps.log("No declared function was dropped, so Gate deleted no grant.");
+        return 0;
+    }
+    async function doctor() {
+        const failures = [];
+        // A surplus hinders nothing, so it is never a `FAIL`: a doctor one knows red is a doctor nobody
+        // reads, and then the next real failure goes with it (#466).
+        const notes = [];
+        const gateUrl = envValue("GATE_URL");
+        const intelUrl = envValue("INTEL_URL");
+        const serviceKey = envValue("GATE_SERVICE_KEY") ?? envValue("GATE_KEY");
+        const sessionSecret = envValue("INTEL_SESSION_SECRET");
+        const toolSourceOrigins = envValue("TOOL_SOURCE_ORIGINS");
+        const portalUrl = envValue("MCP_PORTAL_URL");
+        if (!gateUrl)
+            failures.push("GATE_URL is missing");
+        if (!intelUrl)
+            failures.push("INTEL_URL is missing");
+        if (!serviceKey)
+            failures.push("GATE_SERVICE_KEY is missing");
+        if (!toolSourceOrigins)
+            failures.push("TOOL_SOURCE_ORIGINS is missing");
+        // Tools are optional for a deployment that only uses nodes and Flows, so a missing portal
+        // is reported as a warning rather than a failure.
+        if (!portalUrl) {
+            deps.log("Note: MCP_PORTAL_URL is unset, so the Tools area stays empty.");
+        }
+        else if (toolSourceOrigins && !toolSourceOrigins.includes(new URL(portalUrl).origin)) {
+            failures.push("MCP_PORTAL_URL origin is missing from TOOL_SOURCE_ORIGINS");
+        }
+        if (!sessionSecret || new TextEncoder().encode(sessionSecret).byteLength < 32) {
+            failures.push("INTEL_SESSION_SECRET must contain at least 32 bytes");
+        }
+        if (!(await deps.resolveUi()))
+            failures.push("the Intel UI is not installed (@anchrd/intel/ui)");
+        if (!(await deps.resolveMigrations()))
+            failures.push("Intel migrations are not installed");
+        if (gateUrl && serviceKey) {
+            try {
+                const current = await within(deps.createGateInterfaces(gateUrl, serviceKey).list());
+                let surplusFunction = false;
+                for (const expected of interfaces) {
+                    const actual = current.find((entry) => entry.handle === expected.handle);
+                    const missing = expected.functions.filter((fn) => !actual?.functions.includes(fn));
+                    if (missing.length)
+                        failures.push(`Gate interface ${expected.handle} misses ${missing}`);
+                    const declared = expected.functions;
+                    for (const fn of actual?.functions ?? []) {
+                        if (declared.includes(fn))
+                            continue;
+                        surplusFunction = true;
+                        notes.push(`Gate carries ${expected.handle}:${fn}, which Intel does not declare — ${reason(`${expected.handle}:${fn}`)}`);
+                    }
+                }
+                // ⚠️ The other direction, and it is the half a loop over `interfaces` can never reach: a
+                // handle Intel stopped declaring appears in no expectation, so it is never looked up. The
+                // comparison runs both ways or it does not run (#466).
+                const declaredHandles = interfaces.map((entry) => entry.handle);
+                const surplusHandles = current.filter((row) => !declaredHandles.includes(row.handle));
+                for (const row of surplusHandles) {
+                    notes.push(`Gate carries the interface ${row.handle} (${row.functions.join(", ")}), which Intel does not declare — ${reason(row.handle)}`);
+                }
+                // What to do about it, once per kind — because the two kinds need opposite acts. A surplus
+                // FUNCTION on a still-declared handle disappears by itself on the next `bootstrap`, grants
+                // and all (#474); a surplus HANDLE is never written and therefore never goes away on its own.
+                if (surplusFunction) {
+                    notes.push("The next `intel bootstrap` removes a surplus function and every grant on it (#474). Take the grant away in Gate first if anybody should keep it.");
+                }
+                if (surplusHandles.length) {
+                    notes.push("`bootstrap` never touches an interface Intel does not declare, so a surplus one stays until somebody removes it in Gate by hand — which takes its grants with it.");
+                }
+            }
+            catch {
+                failures.push("Gate interface check failed");
+            }
+        }
+        for (const note of notes)
+            deps.log(`NOTE ${note}`);
+        if (failures.length) {
+            for (const failure of failures)
+                deps.log(`FAIL ${failure}`);
+            return 1;
+        }
+        deps.log("OK Intel packages, configuration, and Gate interfaces are ready.");
+        return 0;
+    }
+    async function reindex() {
+        const intelUrl = envValue("INTEL_URL")?.replace(/\/+$/, "");
+        const token = envValue("INTEL_OPERATOR_TOKEN");
+        if (!intelUrl || !token) {
+            return fail("INTEL_URL and a short-lived INTEL_OPERATOR_TOKEN must be set.");
+        }
+        const response = await deps.fetch(`${intelUrl}/api/v1/nodes/reindex`, {
+            method: "POST",
+            headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
+            body: "{}",
+            signal: AbortSignal.timeout(10_000),
+        });
+        if (!response.ok)
+            return fail(`reindex responded with ${response.status}`);
+        deps.log("Intel accepted the reindex request.");
+        return 0;
+    }
+    return {
+        async run(argv) {
+            switch (argv[0]) {
+                case "prepare":
+                    return await createPrepare(deps).prepare();
+                case "bootstrap":
+                    return await bootstrap();
+                case "build":
+                    return await createBuild(deps).build();
+                case "doctor":
+                    return await doctor();
+                case "reindex":
+                    return await reindex();
+                default:
+                    deps.log(usage);
+                    return argv[0] ? 1 : 0;
+            }
+        },
+    };
+}

package/dist/cli/cli.types.d.ts

@@ -0,0 +1,14 @@
+import type { BuildDeps } from "../build/build.types.js";
+import type { PrepareDeps } from "../prepare/prepare.types.js";
+export interface GateInterfaces {
+    list(): Promise<Array<{
+        handle: string;
+        functions: string[];
+    }>>;
+    set(handle: string, functions: string[]): Promise<unknown>;
+}
+export interface CliDeps extends BuildDeps, PrepareDeps {
+    env: Record<string, string | undefined>;
+    fetch: typeof fetch;
+    createGateInterfaces(url: string, serviceKey: string): GateInterfaces;
+}

package/dist/cli/cli.types.js

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

package/dist/contract/audit.d.ts

@@ -0,0 +1,50 @@
+import { z } from "zod";
+export declare const AuditResourceType: z.ZodEnum<{
+    flow: "flow";
+    node: "node";
+    "flow-run": "flow-run";
+}>;
+export type AuditResourceType = z.infer<typeof AuditResourceType>;
+export declare const AuditEvent: z.ZodObject<{
+    id: z.ZodString;
+    actorId: z.ZodString;
+    action: z.ZodString;
+    resourceType: z.ZodEnum<{
+        flow: "flow";
+        node: "node";
+        "flow-run": "flow-run";
+    }>;
+    resourceId: z.ZodString;
+    metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    occurredAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type AuditEvent = z.infer<typeof AuditEvent>;
+export declare const AuditCursor: z.ZodString;
+export declare const AuditListRequest: z.ZodObject<{
+    resourceType: z.ZodEnum<{
+        flow: "flow";
+        node: "node";
+        "flow-run": "flow-run";
+    }>;
+    after: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+export type AuditListRequest = z.infer<typeof AuditListRequest>;
+export declare const AuditListResponse: z.ZodObject<{
+    events: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        actorId: z.ZodString;
+        action: z.ZodString;
+        resourceType: z.ZodEnum<{
+            flow: "flow";
+            node: "node";
+            "flow-run": "flow-run";
+        }>;
+        resourceId: z.ZodString;
+        metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        occurredAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+    hasMore: z.ZodBoolean;
+}, z.core.$strict>;
+export type AuditListResponse = z.infer<typeof AuditListResponse>;

package/dist/contract/audit.js

@@ -0,0 +1,72 @@
+import { z } from "zod";
+import { IntelId, IsoDateTime } from "./contract.js";
+// Which kind of resource an event is about — all three the column carries, since #774.
+//
+// ⚠️ It was `["node"]` alone until then, and that was a decision rather than a gap (#620): each
+// kind needs a DIFFERENT visibility check, and asking for one that had none was REFUSED rather than
+// answered with an empty list. An empty list reads as "nothing happened", and a consumer built on
+// that would miss every flow event without ever learning they exist.
+//
+// What changed is that the other two checks now exist. `flow` walks the folder a flow hangs in
+// (`flowInSubtree`), and `flow-run` walks one join further — run → flow → folder — which #767 built
+// for the feed. **Widening the enum without those walks would have been the silent answer the
+// original decision refused**, so the order matters: the check first, the enum second.
+export const AuditResourceType = z.enum(["node", "flow", "flow-run"]);
+// One line of the change journal. `resourceId` is the node the event is about; `actorId` is who
+// caused it. `metadata` is whatever the write site recorded — its shape belongs to `action` and is
+// deliberately not typed here, because a schema per action would have to be kept in step with 11
+// write sites and would go stale in silence.
+export const AuditEvent = z.strictObject({
+    id: IntelId,
+    actorId: z.string().min(1),
+    action: z.string().min(1),
+    resourceType: AuditResourceType,
+    resourceId: IntelId,
+    metadata: z.record(z.string(), z.unknown()),
+    occurredAt: IsoDateTime,
+});
+// ⚠️ Opaque BY CONTRACT, not merely by encoding. The reader gets a string back and hands the same
+// string in again; it must not take it apart, and it must not build one.
+//
+// The reason is that the cursor is a PAIR — `(occurredAt, id)` — and the pair is the whole point.
+// A timestamp alone cannot separate two events written in the same millisecond, which for a batch
+// is the normal case rather than the exception; a reader continuing on `occurredAt > X` skips the
+// second one silently. If the cursor were two fields, a caller would eventually send only the
+// timestamp, and the loss would look like nothing at all: no error, no log, just an event that
+// never arrived.
+export const AuditCursor = z.string().min(1).max(400);
+export const AuditListRequest = z.strictObject({
+    resourceType: AuditResourceType.describe("Which kind of resource to read events about: `node` for documents, folders, tables and attachments, `flow` for changes to a flow itself, `flow-run` for its runs. One kind per call — the three are separate journals with separate cursors."),
+    after: AuditCursor.optional().describe("Where to continue: the `nextCursor` of a previous answer, passed back unchanged. Omit it to start at the oldest event you may see. Do not build one — it is opaque on purpose."),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(200)
+        .default(50)
+        .describe("How many events to return at most. The answer may be shorter."),
+});
+// `nextCursor` is the cursor of the LAST returned row — a position, not a page number. A reader
+// stores it and sends it back as `after`.
+//
+// ⚠️ **It answers WHERE THE READER GOT TO, never whether more is waiting.** Those are two questions,
+// and for a while one field answered both: the cursor was omitted whenever no further page followed,
+// so a reader that was catching up got fifty events and no position, started over on its next run,
+// and would have delivered the same fifty for ever. Measured against the running installation
+// (`#793`); a reader paging through never notices, because it always asks for a full page.
+//
+// ⚠️ **`hasMore` is the other question, and it is a MAY, not a promise.** The journal is a live table
+// and the rows a reader may see can shrink between calls. Treating `hasMore` as "there is data" is a
+// fair reading; treating an empty answer as "the feed ended" is not.
+export const AuditListResponse = z.strictObject({
+    events: z.array(AuditEvent),
+    // `null` only when nothing was returned: no rows, no position.
+    nextCursor: AuditCursor.nullable(),
+    /**
+     * ⚠️ **Added rather than repurposed** (`#793`). A reader written against the old shape reads
+     * "cursor present" as "more may follow"; it now sees a cursor on the last page as well and asks
+     * once more, which answers empty. That costs one request and loses nothing — whereas changing what
+     * `nextCursor` MEANS would have made those readers skip.
+     */
+    hasMore: z.boolean(),
+});

package/dist/contract/board.d.ts

@@ -0,0 +1,150 @@
+import { z } from "zod";
+/**
+ * The id of the archive column, on every board (D68, #674).
+ *
+ * ⚠️ **It is derived, never stored.** A card sits in it because `nodes.archived_at` is set, and
+ * `board_tasks.status` keeps naming the working column it came from — that is what lets a card
+ * pulled back out land where it was. A configured column may not claim this id; `board_update`
+ * refuses it, because two columns with one id means every card in them lands in whichever the view
+ * draws first.
+ */
+export declare const ARCHIVE_COLUMN_ID = "archived";
+/**
+ * What a colour picker starts on for a column that has none (#725).
+ *
+ * ⚠️ **Here rather than in the browser package, and that is not tidiness.** The token linter refuses
+ * a hard-coded hex in `packages/intel/ui`, and it is right to: a colour written into a component bypasses
+ * the theme. This one is not a theme colour, it is DATA — the value a person is about to choose
+ * from and the api writes as a default — so it belongs where both sides may read it, which is here.
+ *
+ * ⚠️ **It is the widget's starting point, never a written value.** `color` stays absent until
+ * somebody picks one, so opening the dialog does not repaint a board that predates colours.
+ */
+export declare const DEFAULT_COLUMN_COLOR = "#9ca3af";
+export declare const BoardColumn: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    terminal: z.ZodDefault<z.ZodBoolean>;
+    color: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type BoardColumn = z.infer<typeof BoardColumn>;
+export declare const BoardTask: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodString;
+    assigneeId: z.ZodNullable<z.ZodString>;
+    labels: z.ZodArray<z.ZodString>;
+    startDate: z.ZodNullable<z.ZodISODateTime>;
+    dueDate: z.ZodNullable<z.ZodISODateTime>;
+    dependsOn: z.ZodNullable<z.ZodString>;
+    parentTaskId: z.ZodNullable<z.ZodString>;
+    position: z.ZodNumber;
+    archivedAt: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strict>;
+export type BoardTask = z.infer<typeof BoardTask>;
+export declare const BoardTaskFilter: z.ZodObject<{
+    status: z.ZodOptional<z.ZodString>;
+    assigneeId: z.ZodOptional<z.ZodString>;
+    dueBefore: z.ZodOptional<z.ZodISODateTime>;
+    dependsOn: z.ZodOptional<z.ZodString>;
+    includeArchived: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export type BoardTaskFilter = z.infer<typeof BoardTaskFilter>;
+export declare const BoardGetInput: z.ZodObject<{
+    status: z.ZodOptional<z.ZodString>;
+    assigneeId: z.ZodOptional<z.ZodString>;
+    dueBefore: z.ZodOptional<z.ZodISODateTime>;
+    dependsOn: z.ZodOptional<z.ZodString>;
+    includeArchived: z.ZodDefault<z.ZodBoolean>;
+    boardId: z.ZodString;
+}, z.core.$strict>;
+export type BoardGetInput = z.infer<typeof BoardGetInput>;
+export declare const BoardView: z.ZodObject<{
+    boardId: z.ZodString;
+    title: z.ZodString;
+    columns: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        terminal: z.ZodDefault<z.ZodBoolean>;
+        color: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    archiveVisible: z.ZodBoolean;
+    tasks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        status: z.ZodString;
+        assigneeId: z.ZodNullable<z.ZodString>;
+        labels: z.ZodArray<z.ZodString>;
+        startDate: z.ZodNullable<z.ZodISODateTime>;
+        dueDate: z.ZodNullable<z.ZodISODateTime>;
+        dependsOn: z.ZodNullable<z.ZodString>;
+        parentTaskId: z.ZodNullable<z.ZodString>;
+        position: z.ZodNumber;
+        archivedAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type BoardView = z.infer<typeof BoardView>;
+export declare const BoardUpdateInput: z.ZodObject<{
+    boardId: z.ZodString;
+    columns: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        terminal: z.ZodDefault<z.ZodBoolean>;
+        color: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    archiveVisible: z.ZodOptional<z.ZodBoolean>;
+    idempotencyKey: z.ZodString;
+}, z.core.$strict>;
+export type BoardUpdateInput = z.infer<typeof BoardUpdateInput>;
+export declare const BoardTaskCreateInput: z.ZodObject<{
+    boardId: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodOptional<z.ZodString>;
+    assigneeId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    labels: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    startDate: z.ZodDefault<z.ZodNullable<z.ZodISODateTime>>;
+    dueDate: z.ZodDefault<z.ZodNullable<z.ZodISODateTime>>;
+    dependsOn: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    parentTaskId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    idempotencyKey: z.ZodString;
+}, z.core.$strict>;
+export type BoardTaskCreateInput = z.infer<typeof BoardTaskCreateInput>;
+export declare const BoardTaskUpdateInput: z.ZodObject<{
+    taskId: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodString>;
+    position: z.ZodOptional<z.ZodNumber>;
+    assigneeId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    startDate: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
+    dueDate: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
+    dependsOn: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    idempotencyKey: z.ZodString;
+}, z.core.$strict>;
+export type BoardTaskUpdateInput = z.infer<typeof BoardTaskUpdateInput>;
+export declare const DirectoryPerson: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    email: z.ZodEmail;
+    isMachine: z.ZodBoolean;
+}, z.core.$strict>;
+export type DirectoryPerson = z.infer<typeof DirectoryPerson>;
+export declare const BoardAssigneeSearchInput: z.ZodObject<{
+    boardId: z.ZodString;
+    query: z.ZodString;
+}, z.core.$strict>;
+export type BoardAssigneeSearchInput = z.infer<typeof BoardAssigneeSearchInput>;
+export declare const DirectoryResolveInput: z.ZodObject<{
+    ids: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type DirectoryResolveInput = z.infer<typeof DirectoryResolveInput>;
+export declare const DirectoryPersonList: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        email: z.ZodEmail;
+        isMachine: z.ZodBoolean;
+    }, z.core.$strict>>;
+    more: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+export type DirectoryPersonList = z.infer<typeof DirectoryPersonList>;