@orthacms/copilot-server 0.0.0-reserve.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ortha CMS contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,7 @@
+# @orthacms/copilot-server
+
+Part of [Ortha CMS](https://github.com/ortha-source/ortha-cms).
+
+```sh
+npm install @orthacms/copilot-server
+```

package/dist/index.d.ts

@@ -0,0 +1,24 @@
+export { CopilotPlugin } from './lib/utils/copilot-plugin';
+export type { CopilotPluginOptions, CopilotServerPluginDefinition } from './lib/utils/copilot-plugin';
+export { CopilotModule } from './lib/copilot.module';
+export type { CopilotModuleOptions } from './lib/copilot.module';
+export { COPILOT_CONFIG, COPILOT_RUN_LIMITS, COPILOT_SKILL_REGISTRY, InjectCopilotConfig } from './lib/copilot.tokens';
+export type { CopilotPluginConfig } from './lib/types/copilot-config';
+export { buildModelRegistry } from './lib/infrastructure/model-registry';
+export type { ProviderRegistration } from './lib/infrastructure/model-registry';
+export { ProposalApplierRegistry } from './lib/chat/application/proposal-applier.registry';
+export { copilotAppliersRegistrar } from './lib/chat/application/appliers-registrar';
+export { RunEngine, CopilotDisabledError, UnknownModelChoiceError } from './lib/chat/application/run-engine.service';
+export type { StartRunInput } from './lib/chat/application/run-engine.service';
+export { CapabilityProfileService } from './lib/chat/application/capability-profile.service';
+export { ConversationRepository } from './lib/chat/infrastructure/persistence/conversation.repository';
+export type { ConversationView, MessageView, ToolCallRecord } from './lib/chat/infrastructure/persistence/conversation.repository';
+export { buildSystemPrompt, SYSTEM_PROMPT_VERSION } from './lib/chat/application/system-prompt';
+export type { SurfaceContext, SystemPromptInput } from './lib/chat/application/system-prompt';
+export { SkillCatalogService, SkillResolutionError } from './lib/skills/application/skill-catalog.service';
+export type { SkillSummary } from './lib/skills/application/skill-catalog.service';
+export { SkillRepository } from './lib/skills/infrastructure/persistence/skill.repository';
+export type { SkillRecord } from './lib/skills/infrastructure/persistence/skill.repository';
+export * from './lib/chat/infrastructure/schema';
+export * from './lib/skills/infrastructure/schema';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,YAAY,EACR,oBAAoB,EACpB,6BAA6B,EAChC,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,YAAY,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AACjE,OAAO,EACH,cAAc,EACd,kBAAkB,EAClB,sBAAsB,EACtB,mBAAmB,EACtB,MAAM,sBAAsB,CAAC;AAC9B,YAAY,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACtE,OAAO,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACzE,YAAY,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAC;AAMhF,OAAO,EAAE,uBAAuB,EAAE,MAAM,kDAAkD,CAAC;AAG3F,OAAO,EAAE,wBAAwB,EAAE,MAAM,2CAA2C,CAAC;AAKrF,OAAO,EACH,SAAS,EACT,oBAAoB,EACpB,uBAAuB,EAC1B,MAAM,2CAA2C,CAAC;AACnD,YAAY,EAAE,aAAa,EAAE,MAAM,2CAA2C,CAAC;AAC/E,OAAO,EAAE,wBAAwB,EAAE,MAAM,mDAAmD,CAAC;AAC7F,OAAO,EAAE,sBAAsB,EAAE,MAAM,+DAA+D,CAAC;AACvG,YAAY,EACR,gBAAgB,EAChB,WAAW,EACX,cAAc,EACjB,MAAM,+DAA+D,CAAC;AACvE,OAAO,EACH,iBAAiB,EACjB,qBAAqB,EACxB,MAAM,sCAAsC,CAAC;AAC9C,YAAY,EACR,cAAc,EACd,iBAAiB,EACpB,MAAM,sCAAsC,CAAC;AAG9C,OAAO,EACH,mBAAmB,EACnB,oBAAoB,EACvB,MAAM,gDAAgD,CAAC;AACxD,YAAY,EAAE,YAAY,EAAE,MAAM,gDAAgD,CAAC;AACnF,OAAO,EAAE,eAAe,EAAE,MAAM,0DAA0D,CAAC;AAC3F,YAAY,EAAE,WAAW,EAAE,MAAM,0DAA0D,CAAC;AAG5F,cAAc,kCAAkC,CAAC;AACjD,cAAc,oCAAoC,CAAC"}

package/dist/index.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkillRepository = exports.SkillResolutionError = exports.SkillCatalogService = exports.SYSTEM_PROMPT_VERSION = exports.buildSystemPrompt = exports.ConversationRepository = exports.CapabilityProfileService = exports.UnknownModelChoiceError = exports.CopilotDisabledError = exports.RunEngine = exports.copilotAppliersRegistrar = exports.ProposalApplierRegistry = exports.buildModelRegistry = exports.InjectCopilotConfig = exports.COPILOT_SKILL_REGISTRY = exports.COPILOT_RUN_LIMITS = exports.COPILOT_CONFIG = exports.CopilotModule = exports.CopilotPlugin = void 0;
+const tslib_1 = require("tslib");
+var copilot_plugin_1 = require("./lib/utils/copilot-plugin");
+Object.defineProperty(exports, "CopilotPlugin", { enumerable: true, get: function () { return copilot_plugin_1.CopilotPlugin; } });
+var copilot_module_1 = require("./lib/copilot.module");
+Object.defineProperty(exports, "CopilotModule", { enumerable: true, get: function () { return copilot_module_1.CopilotModule; } });
+var copilot_tokens_1 = require("./lib/copilot.tokens");
+Object.defineProperty(exports, "COPILOT_CONFIG", { enumerable: true, get: function () { return copilot_tokens_1.COPILOT_CONFIG; } });
+Object.defineProperty(exports, "COPILOT_RUN_LIMITS", { enumerable: true, get: function () { return copilot_tokens_1.COPILOT_RUN_LIMITS; } });
+Object.defineProperty(exports, "COPILOT_SKILL_REGISTRY", { enumerable: true, get: function () { return copilot_tokens_1.COPILOT_SKILL_REGISTRY; } });
+Object.defineProperty(exports, "InjectCopilotConfig", { enumerable: true, get: function () { return copilot_tokens_1.InjectCopilotConfig; } });
+var model_registry_1 = require("./lib/infrastructure/model-registry");
+Object.defineProperty(exports, "buildModelRegistry", { enumerable: true, get: function () { return model_registry_1.buildModelRegistry; } });
+// Tools are no longer registered here. A binding plugin registers with the
+// shared `ToolRegistry` from `@orthacms/tools-server` — the same catalogue the
+// MCP endpoint serves — and marks a copilot-only tool `surfaces: ['copilot']`
+// (ADR-0006 §2).
+var proposal_applier_registry_1 = require("./lib/chat/application/proposal-applier.registry");
+Object.defineProperty(exports, "ProposalApplierRegistry", { enumerable: true, get: function () { return proposal_applier_registry_1.ProposalApplierRegistry; } });
+// The sibling one-liner for the plugins that own writes. A plugin binding
+// propose tools must register the appliers for the kinds they produce.
+var appliers_registrar_1 = require("./lib/chat/application/appliers-registrar");
+Object.defineProperty(exports, "copilotAppliersRegistrar", { enumerable: true, get: function () { return appliers_registrar_1.copilotAppliersRegistrar; } });
+// The run engine and its collaborators, exported for tests and for a future
+// non-HTTP surface (a job runner in phase 5) that needs the loop without the
+// controller.
+var run_engine_service_1 = require("./lib/chat/application/run-engine.service");
+Object.defineProperty(exports, "RunEngine", { enumerable: true, get: function () { return run_engine_service_1.RunEngine; } });
+Object.defineProperty(exports, "CopilotDisabledError", { enumerable: true, get: function () { return run_engine_service_1.CopilotDisabledError; } });
+Object.defineProperty(exports, "UnknownModelChoiceError", { enumerable: true, get: function () { return run_engine_service_1.UnknownModelChoiceError; } });
+var capability_profile_service_1 = require("./lib/chat/application/capability-profile.service");
+Object.defineProperty(exports, "CapabilityProfileService", { enumerable: true, get: function () { return capability_profile_service_1.CapabilityProfileService; } });
+var conversation_repository_1 = require("./lib/chat/infrastructure/persistence/conversation.repository");
+Object.defineProperty(exports, "ConversationRepository", { enumerable: true, get: function () { return conversation_repository_1.ConversationRepository; } });
+var system_prompt_1 = require("./lib/chat/application/system-prompt");
+Object.defineProperty(exports, "buildSystemPrompt", { enumerable: true, get: function () { return system_prompt_1.buildSystemPrompt; } });
+Object.defineProperty(exports, "SYSTEM_PROMPT_VERSION", { enumerable: true, get: function () { return system_prompt_1.SYSTEM_PROMPT_VERSION; } });
+// --- skills ---
+var skill_catalog_service_1 = require("./lib/skills/application/skill-catalog.service");
+Object.defineProperty(exports, "SkillCatalogService", { enumerable: true, get: function () { return skill_catalog_service_1.SkillCatalogService; } });
+Object.defineProperty(exports, "SkillResolutionError", { enumerable: true, get: function () { return skill_catalog_service_1.SkillResolutionError; } });
+var skill_repository_1 = require("./lib/skills/infrastructure/persistence/skill.repository");
+Object.defineProperty(exports, "SkillRepository", { enumerable: true, get: function () { return skill_repository_1.SkillRepository; } });
+// The Drizzle tables this plugin owns and migrates.
+tslib_1.__exportStar(require("./lib/chat/infrastructure/schema"), exports);
+tslib_1.__exportStar(require("./lib/skills/infrastructure/schema"), exports);

package/dist/lib/chat/application/appliers-registrar.d.ts

@@ -0,0 +1,16 @@
+import { type Provider, type Type } from '@nestjs/common';
+import type { ProposalApplier } from '@orthacms/copilot-domain';
+/**
+ * Builds the DI provider that registers `appliers` with the copilot's proposal
+ * registry at bootstrap. The sibling of `copilotToolsRegistrar`, and the same
+ * factory shape for the same reason: an explicit `inject` list has no reflected
+ * parameter type to get wrong, so an optional dependency cannot silently
+ * resolve to `undefined` and leave the plugin's writes unappliable.
+ *
+ * A plugin that binds propose tools **must** also register the appliers for the
+ * kinds those tools produce. Forgetting shows up only when a human clicks
+ * Accept — the proposal is refused with "this deployment cannot carry that
+ * change out" — so the two belong in the same module block, next to each other.
+ */
+export declare function copilotAppliersRegistrar(label: string, ...appliers: Type<ProposalApplier>[]): Provider;
+//# sourceMappingURL=appliers-registrar.d.ts.map

package/dist/lib/chat/application/appliers-registrar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"appliers-registrar.d.ts","sourceRoot":"","sources":["../../../../src/lib/chat/application/appliers-registrar.ts"],"names":[],"mappings":"AAAA,OAAO,EAGH,KAAK,QAAQ,EACb,KAAK,IAAI,EACZ,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AA4BhE;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,CACpC,KAAK,EAAE,MAAM,EACb,GAAG,QAAQ,EAAE,IAAI,CAAC,eAAe,CAAC,EAAE,GACrC,QAAQ,CAYV"}

package/dist/lib/chat/application/appliers-registrar.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copilotAppliersRegistrar = copilotAppliersRegistrar;
+const common_1 = require("@nestjs/common");
+const proposal_applier_registry_1 = require("./proposal-applier.registry");
+/** Registers a plugin's proposal appliers with the copilot at bootstrap. */
+class AppliersBootstrapper {
+    label;
+    registry;
+    appliers;
+    logger = new common_1.Logger(AppliersBootstrapper.name);
+    constructor(label, registry, appliers) {
+        this.label = label;
+        this.registry = registry;
+        this.appliers = appliers;
+    }
+    onApplicationBootstrap() {
+        // A deployment that doesn't register `CopilotPlugin` is normal, and
+        // every binding plugin must boot without it.
+        if (!this.registry) {
+            return;
+        }
+        for (const applier of this.appliers) {
+            this.registry.register(applier);
+        }
+        this.logger.log(`Registered ${this.label} proposal appliers with the copilot.`);
+    }
+}
+/**
+ * Builds the DI provider that registers `appliers` with the copilot's proposal
+ * registry at bootstrap. The sibling of `copilotToolsRegistrar`, and the same
+ * factory shape for the same reason: an explicit `inject` list has no reflected
+ * parameter type to get wrong, so an optional dependency cannot silently
+ * resolve to `undefined` and leave the plugin's writes unappliable.
+ *
+ * A plugin that binds propose tools **must** also register the appliers for the
+ * kinds those tools produce. Forgetting shows up only when a human clicks
+ * Accept — the proposal is refused with "this deployment cannot carry that
+ * change out" — so the two belong in the same module block, next to each other.
+ */
+function copilotAppliersRegistrar(label, ...appliers) {
+    return {
+        provide: `COPILOT_APPLIERS_REGISTRAR_${label.toUpperCase()}`,
+        useFactory: (registry, ...resolved) => new AppliersBootstrapper(label, registry, resolved),
+        inject: [
+            { token: proposal_applier_registry_1.ProposalApplierRegistry, optional: true },
+            ...appliers
+        ]
+    };
+}

package/dist/lib/chat/application/capability-profile.service.d.ts

@@ -0,0 +1,43 @@
+import { PermissionsService } from '@orthacms/identity-server';
+import { ToolRegistry, type ToolContext, type ToolDefinition } from '@orthacms/tools-server';
+import { type CapabilityProfile } from '@orthacms/copilot-domain';
+/** A run's authority: the profile the model is offered, and the tool context. */
+export interface RunAuthority {
+    /** The tools offered this run, and what was withheld. */
+    profile: CapabilityProfile<ToolDefinition>;
+    /** What a tool call is handed — reused for every call in the run. */
+    context: ToolContext;
+}
+/**
+ * Resolves the tool set one run may use.
+ *
+ * **The catalogue is the shared `ToolRegistry`** (ADR-0006 §2) — the same
+ * instance the MCP endpoint serves — narrowed to the `copilot` surface. What
+ * stays copilot-specific is the pure `resolveCapabilityProfile` in
+ * `copilot-domain` and the `withheld` reasons it returns. Keeping that rule
+ * pure is what makes "a viewer is offered no write tools" a unit test rather
+ * than an e2e hope.
+ *
+ * **The caller's grants are the whole decision**
+ * ([ADR-0009](../../../../../../docs/adr/0009-copilot-applies-directly.md)).
+ * There used to be a second input — the workspace's auto-apply policy, read
+ * here per run — and it is gone along with the table behind it. One resolution
+ * per run, one rule.
+ *
+ * **Nothing here is cached.** [ADR-0005](../../../../../../docs/adr/0005-copilot-authority-model.md) §2
+ * requires the profile be recomputed per run: permissions can be revoked
+ * mid-thread, and a long conversation must not carry stale authority. The cost
+ * is one indexed read per run, which the ADR accepts explicitly.
+ */
+export declare class CapabilityProfileService {
+    private readonly permissions;
+    private readonly tools;
+    constructor(permissions: PermissionsService, tools: ToolRegistry);
+    /** The authority for a run by `user` in `workspaceId`. */
+    resolve(user: {
+        id: string;
+        email: string;
+        roleId: string;
+    }, workspaceId: string, signal?: AbortSignal): Promise<RunAuthority>;
+}
+//# sourceMappingURL=capability-profile.service.d.ts.map

package/dist/lib/chat/application/capability-profile.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capability-profile.service.d.ts","sourceRoot":"","sources":["../../../../src/lib/chat/application/capability-profile.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,EAEH,YAAY,EAEZ,KAAK,WAAW,EAChB,KAAK,cAAc,EACtB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAEH,KAAK,iBAAiB,EAEzB,MAAM,0BAA0B,CAAC;AAElC,iFAAiF;AACjF,MAAM,WAAW,YAAY;IACzB,yDAAyD;IACzD,OAAO,EAAE,iBAAiB,CAAC,cAAc,CAAC,CAAC;IAC3C,qEAAqE;IACrE,OAAO,EAAE,WAAW,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBACa,wBAAwB;IAE7B,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,KAAK;gBADL,WAAW,EAAE,kBAAkB,EAC/B,KAAK,EAAE,YAAY;IAGxC,0DAA0D;IACpD,OAAO,CACT,IAAI,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,EACnD,WAAW,EAAE,MAAM,EACnB,MAAM,CAAC,EAAE,WAAW,GACrB,OAAO,CAAC,YAAY,CAAC;CAkC3B"}

package/dist/lib/chat/application/capability-profile.service.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CapabilityProfileService = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const identity_server_1 = require("@orthacms/identity-server");
+const tools_server_1 = require("@orthacms/tools-server");
+const copilot_domain_1 = require("@orthacms/copilot-domain");
+/**
+ * Resolves the tool set one run may use.
+ *
+ * **The catalogue is the shared `ToolRegistry`** (ADR-0006 §2) — the same
+ * instance the MCP endpoint serves — narrowed to the `copilot` surface. What
+ * stays copilot-specific is the pure `resolveCapabilityProfile` in
+ * `copilot-domain` and the `withheld` reasons it returns. Keeping that rule
+ * pure is what makes "a viewer is offered no write tools" a unit test rather
+ * than an e2e hope.
+ *
+ * **The caller's grants are the whole decision**
+ * ([ADR-0009](../../../../../../docs/adr/0009-copilot-applies-directly.md)).
+ * There used to be a second input — the workspace's auto-apply policy, read
+ * here per run — and it is gone along with the table behind it. One resolution
+ * per run, one rule.
+ *
+ * **Nothing here is cached.** [ADR-0005](../../../../../../docs/adr/0005-copilot-authority-model.md) §2
+ * requires the profile be recomputed per run: permissions can be revoked
+ * mid-thread, and a long conversation must not carry stale authority. The cost
+ * is one indexed read per run, which the ADR accepts explicitly.
+ */
+let CapabilityProfileService = class CapabilityProfileService {
+    permissions;
+    tools;
+    constructor(permissions, tools) {
+        this.permissions = permissions;
+        this.tools = tools;
+    }
+    /** The authority for a run by `user` in `workspaceId`. */
+    async resolve(user, workspaceId, signal) {
+        const granted = new Set(await this.permissions.forRole(user.roleId));
+        // `kind: 'user'` is what separates a run from an MCP call in every
+        // handler that cares — and `userId` is the *same* id here, because the
+        // copilot has no identity of its own and a run acts as the person
+        // driving it (ADR-0005 §1).
+        const actor = {
+            kind: 'user',
+            id: user.id,
+            displayName: user.email,
+            grantedPermissions: granted,
+            userId: user.id
+        };
+        const context = {
+            ...(0, tools_server_1.createToolContext)(actor, workspaceId),
+            ...(signal ? { signal } : {})
+        };
+        const copilotActor = {
+            userId: user.id,
+            grantedPermissions: granted
+        };
+        const profile = (0, copilot_domain_1.resolveCapabilityProfile)({
+            // The registry authorizes; this decides what to *offer*. Passing
+            // the whole surface rather than `visibleTo` keeps the withheld
+            // reasons — "you lack content:update" is what the settings page
+            // shows, and a pre-filtered list cannot say it.
+            tools: this.tools.forSurface('copilot'),
+            actor: copilotActor
+        });
+        return { profile, context };
+    }
+};
+exports.CapabilityProfileService = CapabilityProfileService;
+exports.CapabilityProfileService = CapabilityProfileService = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__metadata("design:paramtypes", [identity_server_1.PermissionsService,
+        tools_server_1.ToolRegistry])
+], CapabilityProfileService);

package/dist/lib/chat/application/content-type-summary.service.d.ts

@@ -0,0 +1,32 @@
+import { type Database } from '@orthacms/database';
+import { type ContentCatalog } from '@orthacms/workspaces-server';
+/**
+ * The content-type summaries the system prompt is built from — `name — label
+ * (kind)` for each type the open workspace was actually granted.
+ *
+ * Two deliberate choices about where this reads from:
+ *
+ * - **The catalogue comes through `CONTENT_CATALOG`, not `content-server`.**
+ *   That port already exists for exactly this shape of question, and it is
+ *   owned by `workspaces-server`, which this package already depends on for
+ *   `WorkspaceGuard`. Importing `content-server` here would put the copilot at
+ *   the bottom of the package graph, which `docs/design/copilot.md` §4 rules
+ *   out. Injected `@Optional()`: a deployment with no content plugin gets an
+ *   empty list and a copilot that says so, rather than a boot failure.
+ * - **The grants come from `workspace_content` directly**, mirroring
+ *   `content-server`'s own `WorkspaceGrantsQuery`. That table is workspaces-
+ *   owned and its schema is deliberately re-exported; inverting it into another
+ *   port would mean workspaces depending on copilot.
+ *
+ * Scoping to grants matters: the prompt must not name a type the workspace
+ * cannot reach, or the model will confidently offer to search something every
+ * tool call will then refuse.
+ */
+export declare class ContentTypeSummaryService {
+    private readonly db;
+    private readonly catalogue;
+    constructor(db: Database, catalogue?: ContentCatalog | null);
+    /** Summaries for the types `workspaceId` was granted, in catalogue order. */
+    summaries(workspaceId: string): Promise<string[]>;
+}
+//# sourceMappingURL=content-type-summary.service.d.ts.map

package/dist/lib/chat/application/content-type-summary.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-type-summary.service.d.ts","sourceRoot":"","sources":["../../../../src/lib/chat/application/content-type-summary.service.ts"],"names":[],"mappings":"AAEA,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AACnE,OAAO,EAGH,KAAK,cAAc,EACtB,MAAM,6BAA6B,CAAC;AAErC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBACa,yBAAyB;IAEZ,OAAO,CAAC,QAAQ,CAAC,EAAE;IAGrC,OAAO,CAAC,QAAQ,CAAC,SAAS;gBAHS,EAAE,EAAE,QAAQ,EAG9B,SAAS,GAAE,cAAc,GAAG,IAAW;IAG5D,6EAA6E;IACvE,SAAS,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;CAsB1D"}

package/dist/lib/chat/application/content-type-summary.service.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentTypeSummaryService = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const drizzle_orm_1 = require("drizzle-orm");
+const database_1 = require("@orthacms/database");
+const workspaces_server_1 = require("@orthacms/workspaces-server");
+/**
+ * The content-type summaries the system prompt is built from — `name — label
+ * (kind)` for each type the open workspace was actually granted.
+ *
+ * Two deliberate choices about where this reads from:
+ *
+ * - **The catalogue comes through `CONTENT_CATALOG`, not `content-server`.**
+ *   That port already exists for exactly this shape of question, and it is
+ *   owned by `workspaces-server`, which this package already depends on for
+ *   `WorkspaceGuard`. Importing `content-server` here would put the copilot at
+ *   the bottom of the package graph, which `docs/design/copilot.md` §4 rules
+ *   out. Injected `@Optional()`: a deployment with no content plugin gets an
+ *   empty list and a copilot that says so, rather than a boot failure.
+ * - **The grants come from `workspace_content` directly**, mirroring
+ *   `content-server`'s own `WorkspaceGrantsQuery`. That table is workspaces-
+ *   owned and its schema is deliberately re-exported; inverting it into another
+ *   port would mean workspaces depending on copilot.
+ *
+ * Scoping to grants matters: the prompt must not name a type the workspace
+ * cannot reach, or the model will confidently offer to search something every
+ * tool call will then refuse.
+ */
+let ContentTypeSummaryService = class ContentTypeSummaryService {
+    db;
+    catalogue;
+    constructor(db, catalogue = null) {
+        this.db = db;
+        this.catalogue = catalogue;
+    }
+    /** Summaries for the types `workspaceId` was granted, in catalogue order. */
+    async summaries(workspaceId) {
+        if (!this.catalogue) {
+            return [];
+        }
+        const rows = await this.db
+            .select({ slug: workspaces_server_1.workspaceContent.slug })
+            .from(workspaces_server_1.workspaceContent)
+            .where((0, drizzle_orm_1.eq)(workspaces_server_1.workspaceContent.workspaceId, workspaceId));
+        const granted = new Set(rows.map((row) => row.slug));
+        // An empty grant set means "no access", never "no filtering" — the
+        // same rule WorkspaceGrantsQuery documents. Getting this backwards
+        // would describe every type in the deployment to every workspace.
+        return this.catalogue
+            .list()
+            .filter((type) => granted.has(type.name))
+            .map((type) => `${type.name} — ${type.label ?? type.name} (${type.kind})`);
+    }
+};
+exports.ContentTypeSummaryService = ContentTypeSummaryService;
+exports.ContentTypeSummaryService = ContentTypeSummaryService = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__param(0, (0, database_1.InjectDatabase)()),
+    tslib_1.__param(1, (0, common_1.Optional)()),
+    tslib_1.__param(1, (0, common_1.Inject)(workspaces_server_1.CONTENT_CATALOG)),
+    tslib_1.__metadata("design:paramtypes", [Object, Object])
+], ContentTypeSummaryService);

package/dist/lib/chat/application/decide-proposal.service.d.ts

@@ -0,0 +1,80 @@
+import { ProposalRepository, type ProposalView } from '../infrastructure/persistence/proposal.repository';
+import { ProposalApplierRegistry } from './proposal-applier.registry';
+/** Who the change is made by, and where. */
+export interface Applicant {
+    userId: string;
+    /** The actor's email — frozen onto the audit event the write raises. */
+    email: string;
+    workspaceId: string;
+}
+/** Why a change could not be carried out. */
+export type ApplyRefusal = 
+/** Someone already applied it. */
+'already-decided'
+/** No plugin claimed this proposal's kind — a wiring bug, not a user error. */
+ | 'no-applier'
+/** The applier ran and failed; the proposal stays pending. */
+ | 'apply-failed';
+/** The outcome of an apply. */
+export type ApplyOutcome = {
+    ok: true;
+    proposal: ProposalView;
+} | {
+    ok: false;
+    reason: ApplyRefusal;
+    message: string;
+};
+/**
+ * Applies a proposal through the plugin that owns it.
+ *
+ * **There is no human step any more**
+ * ([ADR-0009](../../../../../../docs/adr/0009-copilot-applies-directly.md)).
+ * This used to be the accept boundary — `accept`, `reject`, and a re-resolution
+ * of the capability profile deciding whether the clicker could have proposed
+ * the change themselves. All three are gone: the engine calls {@link apply} the
+ * moment a `propose` tool returns, and the only authority check is the one the
+ * offer and the tool call already made against the caller's own grants.
+ *
+ * What survives, and why each still earns its place:
+ *
+ * - **Applying runs the ordinary use-case.** This service never writes the
+ *   change itself; it hands the proposal to the plugin that owns it. Same
+ *   validation, same revision, same activity row, with the human as actor. That
+ *   is what makes a copilot change indistinguishable from a hand-made one in
+ *   the audit log — and it is what "undoable, never invisible" now rests on
+ *   entirely, since nothing pauses to be looked at first.
+ * - **The status flips first, and only once.** `decide` updates with a
+ *   `status = 'pending'` predicate, so the applier is unreachable twice for the
+ *   same row. That still matters with no reviewers in the picture: a model that
+ *   re-proposes an identical change, or a retried run, must not write twice.
+ * - **A failed apply reopens the row** with the message recorded. Nobody will
+ *   retry it, so this is a receipt saying the change did not happen — the run
+ *   engine reads it back and tells the model to say so rather than claim
+ *   success.
+ */
+export declare class DecideProposalService {
+    private readonly proposals;
+    private readonly appliers;
+    private readonly logger;
+    constructor(proposals: ProposalRepository, appliers: ProposalApplierRegistry);
+    /**
+     * Applies a freshly drafted proposal.
+     *
+     * No permission check of its own, and that is not an omission: the
+     * capability profile offered the tool at the start of the run, and
+     * `executeTool` re-authorized it against a freshly resolved session
+     * immediately before this proposal existed. Re-resolving a third time in
+     * the same millisecond would only add a query.
+     */
+    apply(proposal: ProposalView, by: Applicant): Promise<ApplyOutcome>;
+    /**
+     * Flips the status, then hands the change to its owner.
+     *
+     * The order matters: the `pending` predicate on the update is what makes
+     * the apply happen at most once, so it has to win the race *before* the
+     * write runs. A failure afterwards returns the row to `pending` with the
+     * reason; the alternative — apply first, record after — can apply twice.
+     */
+    private applyThroughOwner;
+}
+//# sourceMappingURL=decide-proposal.service.d.ts.map

package/dist/lib/chat/application/decide-proposal.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decide-proposal.service.d.ts","sourceRoot":"","sources":["../../../../src/lib/chat/application/decide-proposal.service.ts"],"names":[],"mappings":"AAEA,OAAO,EACH,kBAAkB,EAClB,KAAK,YAAY,EACpB,MAAM,mDAAmD,CAAC;AAC3D,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AAEtE,4CAA4C;AAC5C,MAAM,WAAW,SAAS;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,wEAAwE;IACxE,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;CACvB;AAED,6CAA6C;AAC7C,MAAM,MAAM,YAAY;AACpB,kCAAkC;AAChC,iBAAiB;AACnB,+EAA+E;GAC7E,YAAY;AACd,8DAA8D;GAC5D,cAAc,CAAC;AAErB,+BAA+B;AAC/B,MAAM,MAAM,YAAY,GAClB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,EAAE,YAAY,CAAA;CAAE,GACpC;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,YAAY,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qBACa,qBAAqB;IAI1B,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAJ7B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA0C;gBAG5C,SAAS,EAAE,kBAAkB,EAC7B,QAAQ,EAAE,uBAAuB;IAGtD;;;;;;;;OAQG;IACG,KAAK,CAAC,QAAQ,EAAE,YAAY,EAAE,EAAE,EAAE,SAAS,GAAG,OAAO,CAAC,YAAY,CAAC;IAkBzE;;;;;;;OAOG;YACW,iBAAiB;CAmDlC"}

package/dist/lib/chat/application/decide-proposal.service.js

@@ -0,0 +1,112 @@
+"use strict";
+var DecideProposalService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DecideProposalService = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const proposal_repository_1 = require("../infrastructure/persistence/proposal.repository");
+const proposal_applier_registry_1 = require("./proposal-applier.registry");
+/**
+ * Applies a proposal through the plugin that owns it.
+ *
+ * **There is no human step any more**
+ * ([ADR-0009](../../../../../../docs/adr/0009-copilot-applies-directly.md)).
+ * This used to be the accept boundary — `accept`, `reject`, and a re-resolution
+ * of the capability profile deciding whether the clicker could have proposed
+ * the change themselves. All three are gone: the engine calls {@link apply} the
+ * moment a `propose` tool returns, and the only authority check is the one the
+ * offer and the tool call already made against the caller's own grants.
+ *
+ * What survives, and why each still earns its place:
+ *
+ * - **Applying runs the ordinary use-case.** This service never writes the
+ *   change itself; it hands the proposal to the plugin that owns it. Same
+ *   validation, same revision, same activity row, with the human as actor. That
+ *   is what makes a copilot change indistinguishable from a hand-made one in
+ *   the audit log — and it is what "undoable, never invisible" now rests on
+ *   entirely, since nothing pauses to be looked at first.
+ * - **The status flips first, and only once.** `decide` updates with a
+ *   `status = 'pending'` predicate, so the applier is unreachable twice for the
+ *   same row. That still matters with no reviewers in the picture: a model that
+ *   re-proposes an identical change, or a retried run, must not write twice.
+ * - **A failed apply reopens the row** with the message recorded. Nobody will
+ *   retry it, so this is a receipt saying the change did not happen — the run
+ *   engine reads it back and tells the model to say so rather than claim
+ *   success.
+ */
+let DecideProposalService = DecideProposalService_1 = class DecideProposalService {
+    proposals;
+    appliers;
+    logger = new common_1.Logger(DecideProposalService_1.name);
+    constructor(proposals, appliers) {
+        this.proposals = proposals;
+        this.appliers = appliers;
+    }
+    /**
+     * Applies a freshly drafted proposal.
+     *
+     * No permission check of its own, and that is not an omission: the
+     * capability profile offered the tool at the start of the run, and
+     * `executeTool` re-authorized it against a freshly resolved session
+     * immediately before this proposal existed. Re-resolving a third time in
+     * the same millisecond would only add a query.
+     */
+    async apply(proposal, by) {
+        const applier = this.appliers.get(proposal.kind);
+        if (!applier) {
+            // A deployment wiring bug rather than a user error, so it is logged
+            // loudly and the row is left pending — the change is still valid,
+            // and it becomes applicable again the moment the binder is fixed.
+            this.logger.error(`No applier registered for proposal kind "${proposal.kind}"; ` +
+                `proposal ${proposal.id} was not applied.`);
+            return refuse('no-applier', 'This kind of change cannot be applied by this deployment.');
+        }
+        return this.applyThroughOwner(proposal, applier, by);
+    }
+    /**
+     * Flips the status, then hands the change to its owner.
+     *
+     * The order matters: the `pending` predicate on the update is what makes
+     * the apply happen at most once, so it has to win the race *before* the
+     * write runs. A failure afterwards returns the row to `pending` with the
+     * reason; the alternative — apply first, record after — can apply twice.
+     */
+    async applyThroughOwner(proposal, applier, by) {
+        const claimed = await this.proposals.decide(proposal.id, by.workspaceId, 'accepted', by.userId);
+        if (!claimed) {
+            return refuse('already-decided', 'This change was already applied.');
+        }
+        try {
+            const result = await applier.apply({ target: proposal.target, patch: proposal.patch }, {
+                userId: by.userId,
+                actorEmail: by.email,
+                workspaceId: by.workspaceId,
+                runId: proposal.runId
+            });
+            // A second write rather than folding the result into the status
+            // transition: that transition only matches a `pending` row, and
+            // this one is now `accepted` by design — the claim is what makes
+            // the apply happen at most once.
+            const finished = await this.proposals.recordResult(proposal.id, by.workspaceId, { ...result });
+            return { ok: true, proposal: finished ?? claimed };
+        }
+        catch (error) {
+            const message = error instanceof Error && error.message
+                ? error.message
+                : 'The change could not be applied.';
+            this.logger.warn(`Applying proposal ${proposal.id} (${proposal.kind}) failed: ${message}`);
+            await this.proposals.reopen(proposal.id, by.workspaceId, message);
+            return refuse('apply-failed', message);
+        }
+    }
+};
+exports.DecideProposalService = DecideProposalService;
+exports.DecideProposalService = DecideProposalService = DecideProposalService_1 = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__metadata("design:paramtypes", [proposal_repository_1.ProposalRepository,
+        proposal_applier_registry_1.ProposalApplierRegistry])
+], DecideProposalService);
+/** A refusal, with the message the run engine reports to the model. */
+function refuse(reason, message) {
+    return { ok: false, reason, message };
+}