@orthacms/copilot-server 0.0.0-reserve.0

package/dist/lib/skills/infrastructure/schema/skills.d.ts

@@ -0,0 +1,212 @@
+/** Whether a skill applies to every run or only when someone attaches it. */
+export declare const copilotSkillMode: import("drizzle-orm/pg-core").PgEnum<["manual", "always"]>;
+/**
+ * One CMS-authored skill — a reusable instruction packet the copilot can run
+ * with, scoped to the workspace it was written in.
+ *
+ * **Workspace-scoped, not deployment-wide.** A skill is editorial guidance
+ * about a particular body of content, which is exactly what a workspace
+ * bounds; the deployment-wide case is served by the host's code-defined skills,
+ * which are reviewed in git and identical everywhere. That split also keeps the
+ * blast radius of the write permission inside one workspace.
+ *
+ * `instructions` is **prompt text, not content**. Writing here is authoring
+ * part of the system prompt for everyone in the workspace, which is why the
+ * write routes require `copilot:skills:manage` (admin-only) rather than a
+ * content permission — see ADR-0010.
+ */
+export declare const copilotSkills: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "copilot_skills";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "copilot_skills";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        workspaceId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "workspace_id";
+            tableName: "copilot_skills";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        name: import("drizzle-orm/pg-core").PgColumn<{
+            name: "name";
+            tableName: "copilot_skills";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        title: import("drizzle-orm/pg-core").PgColumn<{
+            name: "title";
+            tableName: "copilot_skills";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        description: import("drizzle-orm/pg-core").PgColumn<{
+            name: "description";
+            tableName: "copilot_skills";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        instructions: import("drizzle-orm/pg-core").PgColumn<{
+            name: "instructions";
+            tableName: "copilot_skills";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        mode: import("drizzle-orm/pg-core").PgColumn<{
+            name: "mode";
+            tableName: "copilot_skills";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "always" | "manual";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["manual", "always"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        enabled: import("drizzle-orm/pg-core").PgColumn<{
+            name: "enabled";
+            tableName: "copilot_skills";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdBy: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_by";
+            tableName: "copilot_skills";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "copilot_skills";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "copilot_skills";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+//# sourceMappingURL=skills.d.ts.map

package/dist/lib/skills/infrastructure/schema/skills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skills.d.ts","sourceRoot":"","sources":["../../../../../src/lib/skills/infrastructure/schema/skills.ts"],"names":[],"mappings":"AAcA,6EAA6E;AAC7E,eAAO,MAAM,gBAAgB,4DAG3B,CAAC;AAEH;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2DzB,CAAC"}

package/dist/lib/skills/infrastructure/schema/skills.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copilotSkills = exports.copilotSkillMode = void 0;
+const pg_core_1 = require("drizzle-orm/pg-core");
+const external_refs_1 = require("../../../chat/infrastructure/schema/external-refs");
+/** Whether a skill applies to every run or only when someone attaches it. */
+exports.copilotSkillMode = (0, pg_core_1.pgEnum)('copilot_skill_mode', [
+    'manual',
+    'always'
+]);
+/**
+ * One CMS-authored skill — a reusable instruction packet the copilot can run
+ * with, scoped to the workspace it was written in.
+ *
+ * **Workspace-scoped, not deployment-wide.** A skill is editorial guidance
+ * about a particular body of content, which is exactly what a workspace
+ * bounds; the deployment-wide case is served by the host's code-defined skills,
+ * which are reviewed in git and identical everywhere. That split also keeps the
+ * blast radius of the write permission inside one workspace.
+ *
+ * `instructions` is **prompt text, not content**. Writing here is authoring
+ * part of the system prompt for everyone in the workspace, which is why the
+ * write routes require `copilot:skills:manage` (admin-only) rather than a
+ * content permission — see ADR-0010.
+ */
+exports.copilotSkills = (0, pg_core_1.pgTable)('copilot_skills', {
+    /** Primary key. */
+    id: (0, pg_core_1.uuid)('id').primaryKey().defaultRandom(),
+    /** The workspace this skill belongs to. */
+    workspaceId: (0, pg_core_1.uuid)('workspace_id')
+        .notNull()
+        .references(() => external_refs_1.workspaces.id, { onDelete: 'cascade' }),
+    /**
+     * Machine name, unique within the workspace and refused if a
+     * code-defined skill already holds it. What a run request names.
+     */
+    name: (0, pg_core_1.text)('name').notNull(),
+    /** What a person reads in the picker and on a chip. */
+    title: (0, pg_core_1.text)('title').notNull(),
+    /**
+     * When to use it, written for the model. In the prompt for **every**
+     * enabled skill in the workspace, whether or not it is in force — which
+     * is what lets the model recommend one it has not been given.
+     */
+    description: (0, pg_core_1.text)('description').notNull(),
+    /** The body. Reaches the model only when the skill is in force. */
+    instructions: (0, pg_core_1.text)('instructions').notNull(),
+    /** `always` puts it in force on every run in this workspace. */
+    mode: (0, exports.copilotSkillMode)('mode').notNull().default('manual'),
+    /**
+     * Off without deleting. A disabled skill is absent from the catalogue
+     * rather than greyed out in it: the picker's job is to show what can be
+     * used, and the manage page reads the disabled ones separately.
+     */
+    enabled: (0, pg_core_1.boolean)('enabled').notNull().default(true),
+    /**
+     * Who wrote it — attribution only. `set null` rather than `cascade`,
+     * unlike the conversation tables: a thread is personal and goes with
+     * its owner, while a skill is workspace configuration that must survive
+     * the admin who happened to type it.
+     */
+    createdBy: (0, pg_core_1.uuid)('created_by').references(() => external_refs_1.users.id, {
+        onDelete: 'set null'
+    }),
+    /** Row creation timestamp. */
+    createdAt: (0, pg_core_1.timestamp)('created_at', { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+    /** Last edit. Bumped on every write, unlike a conversation's. */
+    updatedAt: (0, pg_core_1.timestamp)('updated_at', { withTimezone: true })
+        .notNull()
+        .defaultNow()
+}, (table) => [
+    // The uniqueness the resolver depends on: a run names a skill by
+    // `name`, so two rows sharing one in a workspace would make which
+    // instructions the model receives a matter of row order.
+    (0, pg_core_1.uniqueIndex)('copilot_skills_workspace_name_idx').on(table.workspaceId, table.name)
+]);

package/dist/lib/types/copilot-config.d.ts

@@ -0,0 +1,55 @@
+import type { RunLimits } from '@orthacms/copilot-domain';
+/**
+ * The copilot plugin's host-supplied config.
+ *
+ * Deliberately **adapter-agnostic**: it names no provider kind and imports no
+ * adapter package, so adding a Bedrock or Vertex adapter is a new package and
+ * a line in the composition root — never a change here
+ * ([ADR-0004](../../../../../docs/adr/0004-model-agnostic-copilot-provider.md) §2).
+ *
+ * Provider *connection* settings therefore live with the host, next to the
+ * factories that consume them; each adapter exports its own config type. The
+ * routing handler, if any, is code in the composition root rather than config.
+ */
+export interface CopilotPluginConfig {
+    /**
+     * The global kill switch. **Off by default**
+     * ([ADR-0005](../../../../../docs/adr/0005-copilot-authority-model.md) §10):
+     * enabling a hosted provider sends workspace content to a third party, and
+     * that is an operator's decision to make explicitly.
+     */
+    enabled: boolean;
+    /** Ceiling on a single model response, in tokens. */
+    maxOutputTokens: number;
+    /**
+     * Optional overrides for the run engine's ceilings. Omitted fields keep
+     * `DEFAULT_RUN_LIMITS`.
+     *
+     * `maxSteps` is the one an operator reaches for first — a smaller local
+     * model needs more tool round trips than a frontier one to answer the same
+     * question — but raising it alone rarely helps, because all three are
+     * checked in the same loop and a run that no longer runs out of steps runs
+     * out of seconds instead. Move them together. Raising them costs tokens
+     * rather than safety: every step is still authorized and audited, and a
+     * `propose` tool still records its row before it applies anything.
+     */
+    limits?: Partial<RunLimits>;
+    /**
+     * How long a parked run waits for the user to answer a permission request,
+     * in milliseconds — **for the whole run**, not per call. Defaults to
+     * {@link DEFAULT_RUN_DECISION_BUDGET_MS}.
+     *
+     * Configurable because the default was a bare five minutes with no warning,
+     * no countdown and nothing to press for more time, and five minutes to read
+     * a JSON argument block, decide, and click is not generous for a
+     * screen-magnifier or switch-access user (WCAG 2.2.1, `ORT-118`). The user
+     * can now extend it themselves from the prompt, which is what actually
+     * satisfies the criterion; this is the operator's floor underneath that.
+     *
+     * What the limit protects is a held connection, a live generator and a
+     * model context — the *operator's* cost, not the user's — so an operator
+     * who can afford more should be able to say so.
+     */
+    permissionDecisionBudgetMs?: number;
+}
+//# sourceMappingURL=copilot-config.d.ts.map

package/dist/lib/types/copilot-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"copilot-config.d.ts","sourceRoot":"","sources":["../../../src/lib/types/copilot-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAE1D;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,mBAAmB;IAChC;;;;;OAKG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB,qDAAqD;IACrD,eAAe,EAAE,MAAM,CAAC;IACxB;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IAC5B;;;;;;;;;;;;;;;OAeG;IACH,0BAA0B,CAAC,EAAE,MAAM,CAAC;CACvC"}

package/dist/lib/types/copilot-config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/utils/copilot-plugin.d.ts

@@ -0,0 +1,66 @@
+import type { ServerPlugin } from '@orthacms/bootstrap-server';
+import { type ModelResolver, type SkillDefinition } from '@orthacms/copilot-domain';
+import type { ProviderRegistration } from '../infrastructure/model-registry';
+import type { CopilotPluginConfig } from '../types/copilot-config';
+/** The copilot plugin shape, with its config attached. */
+export type CopilotServerPluginDefinition = ServerPlugin & {
+    copilotConfig: CopilotPluginConfig;
+};
+/** Options the host passes to {@link CopilotPlugin}. */
+export interface CopilotPluginOptions {
+    /**
+     * The model backends this deployment can reach, in preference order. Each
+     * entry pairs an operator-chosen name with an already-constructed adapter,
+     * so the plugin never learns which adapters exist — register two of the
+     * same kind (`ollama-fast`, `ollama-big`) freely.
+     *
+     * **The order is the setting.** The first entry serves any run that names
+     * no provider, and is what the admin's model picker opens on. There is no
+     * separate `defaultProvider` to name one of these — a name that could be
+     * misspelled, could point at a provider nobody registered, and had to be
+     * kept in step with this list on every change. A deployment that should
+     * not reach a backend does not register it.
+     */
+    providers: readonly ProviderRegistration[];
+    /** Optional custom handler picking a provider per run (plain code). */
+    resolve?: ModelResolver;
+    /**
+     * Skills defined **in code** — reusable instruction packets available in
+     * every workspace of this deployment.
+     *
+     * Here rather than in `config` for the same reason the providers are: the
+     * bodies are usually read off disk next to `plugins.ts`, and config is the
+     * typed view of the environment. A workspace can author its own alongside
+     * these in the CMS; a code skill wins a name collision, and is read-only in
+     * the admin.
+     */
+    skills?: readonly SkillDefinition[];
+    /** Host config (kill switch + output ceiling + run limits). */
+    config: CopilotPluginConfig;
+}
+/**
+ * Creates the copilot plugin. Register it **after** `WorkspacesPlugin` (runs
+ * are workspace-scoped) and `IdentityPlugin` (runs execute as the calling
+ * user, with the `copilot:use` permission checked by its guard). Model
+ * providers are constructed at the composition root and passed in here — the
+ * plugin never imports a vendor SDK, and never learns which adapters exist
+ * ([ADR-0004](../../../../../docs/adr/0004-model-agnostic-copilot-provider.md) §1).
+ *
+ * **Phase 1 ships the chat vertical slice**: the SSE run route, the bounded run
+ * engine, the capability profile, and the transcript tables this plugin now
+ * owns and migrates.
+ *
+ * @example
+ * ```typescript
+ * CopilotPlugin({
+ *     providers: [
+ *         { name: 'claude', provider: createAnthropicProvider(providers.claude) },
+ *         { name: 'ollama', provider: createOpenAiProvider(providers.ollama) },
+ *         { name: 'fake', provider: createFakeProvider() }
+ *     ],
+ *     config: config.plugins.copilot
+ * });
+ * ```
+ */
+export declare function CopilotPlugin(options: CopilotPluginOptions): CopilotServerPluginDefinition;
+//# sourceMappingURL=copilot-plugin.d.ts.map

package/dist/lib/utils/copilot-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"copilot-plugin.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/copilot-plugin.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,EAEH,KAAK,aAAa,EAClB,KAAK,eAAe,EACvB,MAAM,0BAA0B,CAAC;AAElC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAC;AAC7E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAEnE,0DAA0D;AAC1D,MAAM,MAAM,6BAA6B,GAAG,YAAY,GAAG;IACvD,aAAa,EAAE,mBAAmB,CAAC;CACtC,CAAC;AAEF,wDAAwD;AACxD,MAAM,WAAW,oBAAoB;IACjC;;;;;;;;;;;;OAYG;IACH,SAAS,EAAE,SAAS,oBAAoB,EAAE,CAAC;IAC3C,uEAAuE;IACvE,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB;;;;;;;;;OASG;IACH,MAAM,CAAC,EAAE,SAAS,eAAe,EAAE,CAAC;IACpC,+DAA+D;IAC/D,MAAM,EAAE,mBAAmB,CAAC;CAC/B;AAsDD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,aAAa,CACzB,OAAO,EAAE,oBAAoB,GAC9B,6BAA6B,CAa/B"}

package/dist/lib/utils/copilot-plugin.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CopilotPlugin = CopilotPlugin;
+const node_path_1 = require("node:path");
+const copilot_domain_1 = require("@orthacms/copilot-domain");
+const copilot_module_1 = require("../copilot.module");
+/**
+ * Validate the wiring **eagerly** (like `ContentPlugin`'s registry and
+ * `I18nServerPlugin`'s locales): an empty provider list, or a provider
+ * declaring no models, is a misconfiguration that should fail at construction —
+ * before boot — rather than on the first chat message, where it is most
+ * expensive to diagnose.
+ *
+ * Name uniqueness is enforced by `buildModelRegistry`, which the module builds
+ * from the same list.
+ */
+function assertOptions(options) {
+    const names = options.providers.map((entry) => entry.name);
+    if (names.length === 0) {
+        throw new Error('CopilotPlugin requires at least one model provider. Register one at the composition root, ' +
+            "e.g. `providers: [{ name: 'fake', provider: createFakeProvider() }]`.");
+    }
+    for (const entry of options.providers) {
+        if (entry.provider.models().length === 0) {
+            throw new Error(`Copilot model provider "${entry.name}" declares no models. Configure at least one.`);
+        }
+    }
+    if (options.config.maxOutputTokens <= 0) {
+        throw new Error(`CopilotPlugin's maxOutputTokens must be a positive number (got ${options.config.maxOutputTokens}).`);
+    }
+    // The ceilings, on the same terms. `maxSteps` is the one an operator
+    // reaches for (`COPILOT_MAX_STEPS`), and it was the only number in this
+    // config that could be set to something meaningless and still boot:
+    // `maxSteps: 0` makes `for (step = 0; step < 0; …)` skip the loop entirely,
+    // so the run yields `run-started` and then `done` with `max-steps` — no
+    // model call, no answer, and no assistant row at all, leaving a thread
+    // showing a question and silence. A typo'd env var should not be able to
+    // turn the copilot into that.
+    for (const [key, value] of Object.entries(options.config.limits ?? {})) {
+        if (value !== undefined && (!Number.isFinite(value) || value <= 0)) {
+            throw new Error(`CopilotPlugin's limits.${key} must be a positive number (got ${value}).`);
+        }
+    }
+    // Built here and thrown away: the module builds its own from the same list.
+    // The point is *when* — a malformed or duplicated skill fails at
+    // construction, like a mistyped provider name, rather than on the first
+    // chat message in the workspace that happened to use it.
+    (0, copilot_domain_1.buildSkillRegistry)(options.skills ?? []);
+}
+/**
+ * Creates the copilot plugin. Register it **after** `WorkspacesPlugin` (runs
+ * are workspace-scoped) and `IdentityPlugin` (runs execute as the calling
+ * user, with the `copilot:use` permission checked by its guard). Model
+ * providers are constructed at the composition root and passed in here — the
+ * plugin never imports a vendor SDK, and never learns which adapters exist
+ * ([ADR-0004](../../../../../docs/adr/0004-model-agnostic-copilot-provider.md) §1).
+ *
+ * **Phase 1 ships the chat vertical slice**: the SSE run route, the bounded run
+ * engine, the capability profile, and the transcript tables this plugin now
+ * owns and migrates.
+ *
+ * @example
+ * ```typescript
+ * CopilotPlugin({
+ *     providers: [
+ *         { name: 'claude', provider: createAnthropicProvider(providers.claude) },
+ *         { name: 'ollama', provider: createOpenAiProvider(providers.ollama) },
+ *         { name: 'fake', provider: createFakeProvider() }
+ *     ],
+ *     config: config.plugins.copilot
+ * });
+ * ```
+ */
+function CopilotPlugin(options) {
+    assertOptions(options);
+    return {
+        name: 'copilot',
+        module: copilot_module_1.CopilotModule.forRoot(options),
+        copilotConfig: options.config,
+        migrations: {
+            // Lazy — only called at migrate time. Source layout: src/lib/utils
+            // → ../../../migrations = <pkg>/migrations.
+            dir: () => (0, node_path_1.join)(__dirname, '../../../migrations'),
+            table: '__drizzle_migrations_copilot'
+        }
+    };
+}

package/migrations/0000_copilot_chat.sql

@@ -0,0 +1,48 @@
+CREATE TYPE "public"."copilot_message_role" AS ENUM('user', 'assistant');--> statement-breakpoint
+CREATE TABLE "copilot_conversations" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"user_id" uuid NOT NULL,
+	"workspace_id" uuid NOT NULL,
+	"title" text,
+	"surface" text DEFAULT 'chat' NOT NULL,
+	"archived" boolean DEFAULT false NOT NULL,
+	"created_at" timestamp with time zone DEFAULT now() NOT NULL,
+	"updated_at" timestamp with time zone DEFAULT now() NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE "copilot_messages" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"conversation_id" uuid NOT NULL,
+	"run_id" uuid NOT NULL,
+	"role" "copilot_message_role" NOT NULL,
+	"content" jsonb NOT NULL,
+	"model" text,
+	"provider" text,
+	"stop_reason" text,
+	"input_tokens" integer,
+	"output_tokens" integer,
+	"position" integer NOT NULL,
+	"created_at" timestamp with time zone DEFAULT now() NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE "copilot_tool_calls" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"conversation_id" uuid NOT NULL,
+	"run_id" uuid NOT NULL,
+	"call_id" text NOT NULL,
+	"name" text NOT NULL,
+	"input" jsonb,
+	"output_summary" text,
+	"ok" boolean NOT NULL,
+	"error" text,
+	"duration_ms" integer NOT NULL,
+	"created_at" timestamp with time zone DEFAULT now() NOT NULL
+);
+--> statement-breakpoint
+ALTER TABLE "copilot_conversations" ADD CONSTRAINT "copilot_conversations_user_id_users_id_fk" FOREIGN KEY ("user_id") REFERENCES "public"."users"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "copilot_conversations" ADD CONSTRAINT "copilot_conversations_workspace_id_workspaces_id_fk" FOREIGN KEY ("workspace_id") REFERENCES "public"."workspaces"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "copilot_messages" ADD CONSTRAINT "copilot_messages_conversation_id_copilot_conversations_id_fk" FOREIGN KEY ("conversation_id") REFERENCES "public"."copilot_conversations"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "copilot_tool_calls" ADD CONSTRAINT "copilot_tool_calls_conversation_id_copilot_conversations_id_fk" FOREIGN KEY ("conversation_id") REFERENCES "public"."copilot_conversations"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+CREATE INDEX "copilot_conversations_owner_idx" ON "copilot_conversations" USING btree ("user_id","workspace_id","updated_at");--> statement-breakpoint
+CREATE INDEX "copilot_messages_thread_idx" ON "copilot_messages" USING btree ("conversation_id","position");--> statement-breakpoint
+CREATE INDEX "copilot_tool_calls_run_idx" ON "copilot_tool_calls" USING btree ("run_id","created_at");

package/migrations/0001_proposals.sql

@@ -0,0 +1,34 @@
+CREATE TABLE "copilot_proposals" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"conversation_id" uuid NOT NULL,
+	"run_id" uuid NOT NULL,
+	"tool_call_id" text NOT NULL,
+	"tool_name" text NOT NULL,
+	"kind" text NOT NULL,
+	"workspace_id" uuid NOT NULL,
+	"created_by" uuid NOT NULL,
+	"target" jsonb NOT NULL,
+	"patch" jsonb NOT NULL,
+	"summary" text NOT NULL,
+	"changes" jsonb,
+	"status" text DEFAULT 'pending' NOT NULL,
+	"decided_by" uuid,
+	"decided_at" timestamp with time zone,
+	"result" jsonb,
+	"error" text,
+	"created_at" timestamp with time zone DEFAULT now() NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE "copilot_workspace_policies" (
+	"workspace_id" uuid PRIMARY KEY NOT NULL,
+	"auto_apply_tools" jsonb DEFAULT '[]'::jsonb NOT NULL,
+	"updated_at" timestamp with time zone DEFAULT now() NOT NULL
+);
+--> statement-breakpoint
+ALTER TABLE "copilot_proposals" ADD CONSTRAINT "copilot_proposals_conversation_id_copilot_conversations_id_fk" FOREIGN KEY ("conversation_id") REFERENCES "public"."copilot_conversations"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "copilot_proposals" ADD CONSTRAINT "copilot_proposals_workspace_id_workspaces_id_fk" FOREIGN KEY ("workspace_id") REFERENCES "public"."workspaces"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "copilot_proposals" ADD CONSTRAINT "copilot_proposals_created_by_users_id_fk" FOREIGN KEY ("created_by") REFERENCES "public"."users"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "copilot_proposals" ADD CONSTRAINT "copilot_proposals_decided_by_users_id_fk" FOREIGN KEY ("decided_by") REFERENCES "public"."users"("id") ON DELETE set null ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "copilot_workspace_policies" ADD CONSTRAINT "copilot_workspace_policies_workspace_id_workspaces_id_fk" FOREIGN KEY ("workspace_id") REFERENCES "public"."workspaces"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+CREATE INDEX "copilot_proposals_workspace_idx" ON "copilot_proposals" USING btree ("workspace_id","status","created_at");--> statement-breakpoint
+CREATE INDEX "copilot_proposals_run_idx" ON "copilot_proposals" USING btree ("run_id");

package/migrations/0002_drop_workspace_policies.sql

@@ -0,0 +1 @@
+DROP TABLE "copilot_workspace_policies" CASCADE;

package/migrations/0003_conversation_allowed_tools.sql

@@ -0,0 +1 @@
+ALTER TABLE "copilot_conversations" ADD COLUMN "allowed_tools" jsonb DEFAULT '[]'::jsonb NOT NULL;

package/migrations/0004_message_attachments.sql

@@ -0,0 +1 @@
+ALTER TABLE "copilot_messages" ADD COLUMN "attachments" jsonb;

package/migrations/0005_skills.sql

@@ -0,0 +1,19 @@
+CREATE TYPE "public"."copilot_skill_mode" AS ENUM('manual', 'always');--> statement-breakpoint
+CREATE TABLE "copilot_skills" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"workspace_id" uuid NOT NULL,
+	"name" text NOT NULL,
+	"title" text NOT NULL,
+	"description" text NOT NULL,
+	"instructions" text NOT NULL,
+	"mode" "copilot_skill_mode" DEFAULT 'manual' NOT NULL,
+	"enabled" boolean DEFAULT true NOT NULL,
+	"created_by" uuid,
+	"created_at" timestamp with time zone DEFAULT now() NOT NULL,
+	"updated_at" timestamp with time zone DEFAULT now() NOT NULL
+);
+--> statement-breakpoint
+ALTER TABLE "copilot_messages" ADD COLUMN "skills" jsonb;--> statement-breakpoint
+ALTER TABLE "copilot_skills" ADD CONSTRAINT "copilot_skills_workspace_id_workspaces_id_fk" FOREIGN KEY ("workspace_id") REFERENCES "public"."workspaces"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "copilot_skills" ADD CONSTRAINT "copilot_skills_created_by_users_id_fk" FOREIGN KEY ("created_by") REFERENCES "public"."users"("id") ON DELETE set null ON UPDATE no action;--> statement-breakpoint
+CREATE UNIQUE INDEX "copilot_skills_workspace_name_idx" ON "copilot_skills" USING btree ("workspace_id","name");

package/migrations/0006_conversation_model_choice.sql

@@ -0,0 +1 @@
+ALTER TABLE "copilot_conversations" ADD COLUMN "model_choice" text;