@tangle-network/agent-app 0.45.54 → 0.45.55

package/dist/harness/index.d.ts

@@ -1,6 +1,3 @@
-import { HarnessType } from '@tangle-network/agent-interface';
-export { modelProvider } from '@tangle-network/agent-interface';
-
 /**
  * Coding-agent harness selection — taxonomy, coercion, and the session-lock invariant.
  *
@@ -21,7 +18,7 @@ export { modelProvider } from '@tangle-network/agent-interface';
  * sandbox-ui pickers and the cli-bridge backends. This module owns the harness TAXONOMY + the
  * session lock.
  */
-
+import { modelProvider, type HarnessType } from '@tangle-network/agent-interface';
 /**
  * Canonical harnesses that are NOT sandbox backends. Each value in `KNOWN_HARNESSES` is dispatched
  * as `backend.type`, so a harness the platform ships no provider adapter for must stay out —
@@ -29,21 +26,21 @@ export { modelProvider } from '@tangle-network/agent-interface';
  */
 declare const NON_BACKEND_HARNESSES: readonly ["gemini"];
 /** A coding-agent backend this shell can dispatch a session onto. */
-type Harness = Exclude<HarnessType, (typeof NON_BACKEND_HARNESSES)[number]>;
+export type Harness = Exclude<HarnessType, (typeof NON_BACKEND_HARNESSES)[number]>;
 /**
  * The known coding-agent backends: the canonical harness set minus what has no provider adapter,
  * Derived from `harnessTypeSchema.options` so a harness added upstream reaches this shell without
  * an edit here, and kept structural so this module still needs no sandbox dependency.
  */
-declare const KNOWN_HARNESSES: readonly Harness[];
+export declare const KNOWN_HARNESSES: readonly Harness[];
 /** Define the default harness to use for code execution and testing environments */
-declare const DEFAULT_HARNESS: Harness;
+export declare const DEFAULT_HARNESS: Harness;
 /** Determine if a value is a recognized harness string identifier */
-declare function isHarness(value: unknown): value is Harness;
+export declare function isHarness(value: unknown): value is Harness;
 /** Coerce an arbitrary value to a known harness, falling back (default `opencode`). */
-declare function coerceHarness(value: unknown, fallback?: Harness): Harness;
+export declare function coerceHarness(value: unknown, fallback?: Harness): Harness;
 /** Resolve input options to determine the appropriate session harness to use */
-interface ResolveSessionHarnessInput {
+export interface ResolveSessionHarnessInput {
     /** The harness already locked to this session (recorded at its first turn). */
     sessionHarness?: unknown;
     /** The harness requested now — a new session's choice, or a turn's attempt to switch. */
@@ -54,7 +51,7 @@ interface ResolveSessionHarnessInput {
     fallback?: Harness;
 }
 /** Represent resolved session state including harness, lock status, and swap attempt flag */
-interface ResolvedSessionHarness {
+export interface ResolvedSessionHarness {
     /** The harness to actually run — the locked one when the session already has it. */
     harness: Harness;
     /** True when the session already had a locked harness (this turn did not pick it). */
@@ -72,21 +69,26 @@ interface ResolvedSessionHarness {
  * - **Fresh session**: pick `requested → workspaceDefault → fallback`. The caller
  *   persists the result as the session's lock for every subsequent turn.
  */
-declare function resolveSessionHarness(input?: ResolveSessionHarnessInput): ResolvedSessionHarness;
-
+export declare function resolveSessionHarness(input?: ResolveSessionHarnessInput): ResolvedSessionHarness;
+/**
+ * Harness ↔ model compatibility + snapping — delegated to `@tangle-network/agent-interface`.
+ *
+ * `Harness` is the dispatchable subset of `HarnessType`: this shell drops only canonical harnesses
+ * for which the platform has no backend. Compatibility therefore comes entirely from Interface;
+ * this package keeps no second harness taxonomy.
+ */
+export { modelProvider };
 /** Provider-less ids (sentinels like "default", or a session's own config) are
  *  compatible everywhere — every harness honors its own configuration. */
-declare function isModelCompatibleWithHarness(harness: Harness, modelId: string): boolean;
+export declare function isModelCompatibleWithHarness(harness: Harness, modelId: string): boolean;
 /** Keep `modelId` when the harness can run it; else the harness's best compatible
  *  catalog id (preferred patterns in order, highest version). When nothing in the
  *  catalog fits, return the original so the caller sees the incompatibility. */
-declare function snapModelToHarness(harness: Harness, modelId: string, canonicalIds: readonly string[]): string;
+export declare function snapModelToHarness(harness: Harness, modelId: string, canonicalIds: readonly string[]): string;
 /** Keep the harness when it can run `modelId`; else the model's native harness
  *  (anthropic → claude-code, openai → codex, moonshot → kimi-code), falling back to opencode. */
-declare function snapHarnessToModel(harness: Harness, modelId: string): Harness;
+export declare function snapHarnessToModel(harness: Harness, modelId: string): Harness;
 /** Fail-loud server guard: throw when a harness is asked to run a model it can't.
  *  Call before dispatching a sandbox turn so a bypassed UI can't reach the sidecar
  *  with an incompatible pair. */
-declare function assertHarnessModelCompatible(harness: Harness, modelId: string): void;
-
-export { DEFAULT_HARNESS, type Harness, KNOWN_HARNESSES, type ResolveSessionHarnessInput, type ResolvedSessionHarness, assertHarnessModelCompatible, coerceHarness, isHarness, isModelCompatibleWithHarness, resolveSessionHarness, snapHarnessToModel, snapModelToHarness };
+export declare function assertHarnessModelCompatible(harness: Harness, modelId: string): void;

package/dist/intakes/api.d.ts

@@ -1,8 +1,3 @@
-import { I as IntakeAnswerValue, a as IntakeQuestion, b as IntakeGraph } from '../model-C8U0HZxL.js';
-import { IntakeStore } from './drizzle.js';
-import 'drizzle-orm/sqlite-core';
-import '../completion-CvcNUz07.js';
-
 /**
  * Framework-neutral intake API: the get-current / save-answer / complete logic,
  * lifted out of any one app's route file. Each app mounts these in its own
@@ -22,9 +17,10 @@ import '../completion-CvcNUz07.js';
  * Imports `drizzle-orm` transitively (through the store types), so this is a
  * subpath, never re-exported from root.
  */
-
+import { type IntakeAnswerValue, type IntakeGraph, type IntakeQuestion } from './model';
+import { type IntakeStore } from './drizzle/store';
 /** What the client renders: the saved state, the next prompt, and progress. */
-interface CurrentIntakeView {
+export interface CurrentIntakeView {
     graphId: string;
     title: string;
     description?: string;
@@ -39,7 +35,7 @@ interface CurrentIntakeView {
     };
 }
 /** Define configuration options for initializing the intake API with store and graph components */
-interface IntakeApiOptions {
+export interface IntakeApiOptions {
     store: IntakeStore;
     graph: IntakeGraph;
 }
@@ -48,7 +44,7 @@ interface IntakeApiOptions {
  * app maps its route methods onto them (GET→getCurrentIntake, POST→saveAnswer,
  * a complete action→completeIntake).
  */
-declare function createIntakeApi(opts: IntakeApiOptions): {
+export declare function createIntakeApi(opts: IntakeApiOptions): {
     getCurrentIntake: () => Promise<Response>;
     saveAnswer: (input: {
         questionId?: string;
@@ -56,5 +52,3 @@ declare function createIntakeApi(opts: IntakeApiOptions): {
     }) => Promise<Response>;
     completeIntake: () => Promise<Response>;
 };
-
-export { type CurrentIntakeView, type IntakeApiOptions, createIntakeApi };

package/dist/{completion-CvcNUz07.d.ts → intakes/completion.d.ts}

@@ -1,5 +1,3 @@
-import { e as IntakeAnswers, b as IntakeGraph, I as IntakeAnswerValue } from './model-C8U0HZxL.js';
-
 /**
  * Pure completion-state helpers for an intake payload — the small algebra over
  * the JSON blob the store persists. No I/O: the store reads/writes the row;
@@ -11,9 +9,9 @@ import { e as IntakeAnswers, b as IntakeGraph, I as IntakeAnswerValue } from './
  * revision can detect a stale payload (`graphId` mismatch) rather than
  * silently mixing answers from two question sets.
  */
-
+import type { IntakeAnswers, IntakeAnswerValue, IntakeGraph } from './model';
 /** The persisted JSON for one intake (the `payload` column). */
-interface IntakePayload {
+export interface IntakePayload {
     /** The graph id the answers were collected against — guards stale schemas. */
     graphId: string;
     answers: IntakeAnswers;
@@ -21,21 +19,19 @@ interface IntakePayload {
     completedAt?: string;
 }
 /** An empty payload for a fresh intake against `graph`. */
-declare function emptyPayload(graph: IntakeGraph): IntakePayload;
+export declare function emptyPayload(graph: IntakeGraph): IntakePayload;
 /** A copy of `payload` with one answer set (does not mutate the input). */
-declare function withAnswer(payload: IntakePayload, questionId: string, value: IntakeAnswerValue): IntakePayload;
+export declare function withAnswer(payload: IntakePayload, questionId: string, value: IntakeAnswerValue): IntakePayload;
 /**
  * True when the payload's answers complete the graph AND the payload was
  * collected against THIS graph. A `graphId` mismatch is never "complete" —
  * the answers belong to a different question set and must be re-collected.
  */
-declare function payloadComplete(graph: IntakeGraph, payload: IntakePayload): boolean;
+export declare function payloadComplete(graph: IntakeGraph, payload: IntakePayload): boolean;
 /** True when the payload was collected against a DIFFERENT graph revision. */
-declare function payloadIsStale(graph: IntakeGraph, payload: IntakePayload): boolean;
+export declare function payloadIsStale(graph: IntakeGraph, payload: IntakePayload): boolean;
 /**
  * Stamp the payload complete at `at` (default now). Returns a copy; pure. The
  * caller has already checked `payloadComplete` — this only records the instant.
  */
-declare function markComplete(payload: IntakePayload, at?: Date): IntakePayload;
-
-export { type IntakePayload as I, payloadIsStale as a, emptyPayload as e, markComplete as m, payloadComplete as p, withAnswer as w };
+export declare function markComplete(payload: IntakePayload, at?: Date): IntakePayload;

package/dist/intakes/context-sufficiency.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Pure context-sufficiency floor + conversational-gather scaffold — the
+ * product-agnostic core of a CONVERSATIONAL intake. Where the question-graph
+ * model (`./model`) runs a one-question-at-a-time interview, this leaf judges
+ * whether an agent has gathered ENOUGH context to act, and renders the prompt
+ * directive that tells the agent to fold the remaining gaps into its work
+ * instead of running a form.
+ *
+ * Zero dependencies: no drizzle, no env, no react, no I/O, no product reads.
+ * A product declares WHICH facts matter (`ContextFactSpec`), and its own
+ * adapter resolves those facts + named substrate flags from whatever substrate
+ * it owns (`ResolvedContextSignals`); this leaf only does the deterministic
+ * combine and the wording. That separation is what makes the framework opt-in
+ * and tree-shakeable, and what lets gtm/tax/legal/insurance share one core.
+ *
+ * Readiness is a two-part floor: SCOPE (every required fact has a value) AND
+ * SUBSTRATE (at least one named substrate flag is true). Scope alone is not
+ * enough — knowing the goal without any durable thing to act on is still
+ * not-ready; substrate alone is not enough either. The product's adapter
+ * decides what counts as a fact and what counts as substrate.
+ */
+/** One fact the product treats as known context once it has a value. */
+export interface ContextFact {
+    /** Stable key the resolved-signals map is keyed on. */
+    key: string;
+    /** Human label shown in the prompt's known/missing lists. */
+    label: string;
+    /** When true, this fact must have a value for SCOPE to be met. */
+    required?: boolean;
+    /** How the agent should gather this fact conversationally, if missing. */
+    gatherHint?: string;
+}
+/**
+ * The product's declaration of what context matters: the facts that make up
+ * scope, plus optional tool hints appended verbatim to the gather prompt (e.g.
+ * a product passes the command that extracts a brand from a URL). Pure data —
+ * the product supplies labels, hints, and tool lines; the framework never
+ * names a product-specific concept itself.
+ */
+export interface ContextFactSpec {
+    facts: ContextFact[];
+    /** Lines appended after the gather directive — e.g. product tool pointers. */
+    toolHints?: string[];
+}
+/**
+ * What a product's adapter resolves from its own substrate, ready to combine.
+ * `facts` carries the resolved VALUE per fact key (undefined/empty = not
+ * known); `substrate` carries named boolean flags (e.g.
+ * `{ brandConfirmed, configHasContext, coreKnowledgePresent }`) — any one true
+ * satisfies the substrate half of the floor.
+ */
+export interface ResolvedContextSignals {
+    facts: Record<string, string | undefined>;
+    substrate: Record<string, boolean>;
+}
+/** A resolved fact that has a value — surfaced to the prompt as known context. */
+export interface KnownFact {
+    key: string;
+    label: string;
+    value: string;
+}
+/** A required fact with no value — surfaced to the prompt as a gap to close. */
+export interface MissingFact {
+    key: string;
+    label: string;
+    gatherHint?: string;
+}
+/** The deterministic verdict over the resolved signals. */
+export interface ContextSufficiency {
+    /** True when the floor is met: `hasScope && hasSubstrate`. */
+    ready: boolean;
+    /** Every REQUIRED fact has a non-empty value. */
+    hasScope: boolean;
+    /** At least one named substrate flag is true. */
+    hasSubstrate: boolean;
+    /** Facts (required or not) that have a value. */
+    knownFacts: KnownFact[];
+    /** Required facts that have no value yet. */
+    missingFacts: MissingFact[];
+    /** The substrate flags as resolved, passed through for the prompt/caller. */
+    substrate: Record<string, boolean>;
+}
+/**
+ * Combine a fact spec with resolved signals into the readiness verdict. Pure,
+ * deterministic, never throws — a missing fact key or an empty substrate map
+ * reads as not-ready, not an error, so a fresh scope is honestly not-ready
+ * rather than crashing the caller.
+ *
+ * SCOPE = every `required` fact resolves to a non-empty value.
+ * SUBSTRATE = any value in `signals.substrate` is true.
+ * READY = SCOPE && SUBSTRATE.
+ *
+ * `knownFacts` lists every fact (required or optional) that resolved to a
+ * value, in spec declaration order; `missingFacts` lists every REQUIRED fact
+ * that did not — optional facts never appear as missing because they never gate
+ * scope.
+ */
+export declare function computeContextSufficiency(spec: ContextFactSpec, signals: ResolvedContextSignals): ContextSufficiency;
+/**
+ * Render the prompt section that mirrors a conversational-gather flow:
+ *  - "### Context you already have" — the known facts, as `label: value`.
+ *  - "### Context still missing — gather it while you work, not as a form" —
+ *    the missing facts (with their gather hints), the act-first directive, and
+ *    any product tool hints appended verbatim.
+ *
+ * When scope is met but the floor still is not (no substrate flag), it emits
+ * the substrate directive instead of a missing-facts list. Returns '' when
+ * there is nothing to say (no known facts, no gaps, and ready) so a caller can
+ * concatenate it unconditionally. Pure: wording is product-neutral; every
+ * product-specific phrase comes from the spec's labels, gather hints, and tool
+ * hints.
+ */
+export declare function buildContextGatherPrompt(spec: ContextFactSpec, sufficiency: ContextSufficiency): string;

package/dist/intakes/drizzle/schema.d.ts

@@ -0,0 +1,338 @@
+/**
+ * Drizzle schema factory for the intake tables. The product owns the user (and
+ * optionally workspace) tables; this factory creates the intake tables and
+ * wires their foreign keys into the passed-in tables so the whole graph lives
+ * in one drizzle schema with real cascade semantics.
+ *
+ * Two tables, two scopes:
+ *   - `user_intake`    — the one-time onboarding interview, keyed on `user.id`
+ *     (UNIQUE per user: one onboarding payload per user). ALWAYS created.
+ *   - `project_intake` — the structured intake attached to a workspace, keyed
+ *     on `workspace.id` (UNIQUE per workspace). Created ONLY when a
+ *     `workspaceTable` is passed.
+ *
+ * `workspaceTable` is OPTIONAL by design: a non-workspace app (a single-user
+ * tool, tax-without-workspaces) adopts per-user onboarding alone with zero
+ * teams and zero workspace concept. When omitted, `createIntakeTables` returns
+ * `{ userIntake }` and no `projectIntake` — the FK to a workspace table that
+ * does not exist is never created.
+ *
+ * Imports `drizzle-orm` at module top — that is WHY this lives behind the
+ * `/intakes/drizzle` sub-subpath. The pure `./intakes` leaf imports none of
+ * this, so a consumer that never touches the DB never pulls the optional peer.
+ */
+import type { AnySQLiteColumn, AnySQLiteTable } from 'drizzle-orm/sqlite-core';
+/** A product table referenced by FK — only the `id` column is touched. */
+export type IntakeParentTable = AnySQLiteTable & {
+    id: AnySQLiteColumn;
+};
+/** Define options for creating intake tables including user and optional workspace references */
+export interface CreateIntakeTablesOptions {
+    /** The product's user table — user-intake rows reference `userTable.id`. */
+    userTable: IntakeParentTable;
+    /**
+     * The product's workspace table — project-intake rows reference
+     * `workspaceTable.id`. OPTIONAL: omit it for a single-user / non-workspace
+     * app that wants per-user onboarding only. When omitted, no `projectIntake`
+     * table is created.
+     */
+    workspaceTable?: IntakeParentTable;
+}
+declare function createUserIntakeTable(userTable: IntakeParentTable): import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "user_intake";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "user_intake";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        userId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "user_id";
+            tableName: "user_intake";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        graphId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "graph_id";
+            tableName: "user_intake";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        payload: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "payload";
+            tableName: "user_intake";
+            dataType: "json";
+            columnType: "SQLiteTextJson";
+            data: unknown;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        completedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "completed_at";
+            tableName: "user_intake";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "created_at";
+            tableName: "user_intake";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "updated_at";
+            tableName: "user_intake";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "sqlite";
+}>;
+declare function createProjectIntakeTable(workspaceTable: IntakeParentTable): import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "project_intake";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "project_intake";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        workspaceId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "workspace_id";
+            tableName: "project_intake";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        graphId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "graph_id";
+            tableName: "project_intake";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        payload: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "payload";
+            tableName: "project_intake";
+            dataType: "json";
+            columnType: "SQLiteTextJson";
+            data: unknown;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        completedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "completed_at";
+            tableName: "project_intake";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "created_at";
+            tableName: "project_intake";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "updated_at";
+            tableName: "project_intake";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "sqlite";
+}>;
+/**
+ * Build the intake tables wired to the product's tables. Always returns
+ * `userIntake`; returns `projectIntake` only when `workspaceTable` is passed.
+ * The return type carries `projectIntake?` so a consumer that passes no
+ * workspace table cannot reference a table that does not exist.
+ */
+export declare function createIntakeTables<O extends CreateIntakeTablesOptions>(opts: O): IntakeTables<O>;
+/** Resolve the structure and data of a user intake table based on the createUserIntakeTable function */
+export type UserIntakeTable = ReturnType<typeof createUserIntakeTable>;
+/** Resolve the structure and data of the project intake table from the factory function */
+export type ProjectIntakeTable = ReturnType<typeof createProjectIntakeTable>;
+/**
+ * The tables returned for a given options shape: `projectIntake` is present in
+ * the type exactly when `workspaceTable` was provided.
+ */
+export type IntakeTables<O extends CreateIntakeTablesOptions> = O extends {
+    workspaceTable: IntakeParentTable;
+} ? {
+    userIntake: UserIntakeTable;
+    projectIntake: ProjectIntakeTable;
+} : {
+    userIntake: UserIntakeTable;
+    projectIntake?: ProjectIntakeTable;
+};
+/** The union table shape, for code that handles either scope generically. */
+export type AnyIntakeTables = {
+    userIntake: UserIntakeTable;
+    projectIntake?: ProjectIntakeTable;
+};
+/** Infer and represent a selected row from the UserIntakeTable data structure */
+export type UserIntakeRow = UserIntakeTable['$inferSelect'];
+/** Resolve the selected data structure for a project intake table row */
+export type ProjectIntakeRow = ProjectIntakeTable['$inferSelect'];
+export {};