bopodev-db 0.1.31 → 0.1.33

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
 
-> bopodev-db@0.1.31 build /Users/danielkrusenstrahle/Documents/Projects/Monorepo/bopohq/packages/db
+> bopodev-db@0.1.33 build /Users/danielkrusenstrahle/Documents/Projects/Monorepo/bopohq/packages/db
 > tsc -p tsconfig.json --emitDeclarationOnly
 

package/.turbo/turbo-typecheck.log

@@ -1,4 +1,4 @@
 
-> bopodev-db@0.1.30 typecheck /Users/danielkrusenstrahle/Documents/Projects/Monorepo/bopohq/packages/db
+> bopodev-db@0.1.32 typecheck /Users/danielkrusenstrahle/Documents/Projects/Monorepo/bopohq/packages/db
 > tsc -p tsconfig.json --noEmit
 

package/dist/repositories/company-assistant-chat.d.ts

@@ -0,0 +1,56 @@
+import type { BopoDb } from "../client";
+export type AssistantMessageRole = "user" | "assistant" | "system";
+export declare function getOrCreateAssistantThread(db: BopoDb, companyId: string): Promise<{
+    id: string;
+    companyId: string;
+    createdAt: Date;
+    updatedAt: Date;
+}>;
+/** New empty thread; previous threads and messages remain in the database. */
+export declare function createAssistantThread(db: BopoDb, companyId: string): Promise<{
+    id: string;
+    companyId: string;
+    createdAt: Date;
+    updatedAt: Date;
+}>;
+export declare function getAssistantThreadById(db: BopoDb, companyId: string, threadId: string): Promise<{
+    id: string;
+    companyId: string;
+    createdAt: Date;
+    updatedAt: Date;
+} | null>;
+export declare function touchAssistantThread(db: BopoDb, threadId: string): Promise<void>;
+export declare function insertAssistantMessage(db: BopoDb, input: {
+    threadId: string;
+    companyId: string;
+    role: AssistantMessageRole;
+    body: string;
+    metadataJson?: string | null;
+}): Promise<{
+    id: string;
+    threadId: string;
+    companyId: string;
+    role: string;
+    body: string;
+    metadataJson: string | null;
+    createdAt: Date;
+}>;
+export declare function listAssistantMessages(db: BopoDb, threadId: string, limit?: number): Promise<{
+    id: string;
+    threadId: string;
+    companyId: string;
+    role: string;
+    body: string;
+    metadataJson: string | null;
+    createdAt: Date;
+}[]>;
+/** Threads with at least one message in `[startInclusive, endExclusive)` on `created_at`. */
+export declare function listAssistantChatThreadStatsInCreatedAtRange(db: BopoDb, companyId: string, startInclusive: Date, endExclusive: Date): Promise<Array<{
+    threadId: string;
+    messageCount: number;
+}>>;
+/** Threads with at least one message in the UTC calendar month (for callers without local bounds). */
+export declare function listAssistantChatThreadStatsInUtcMonth(db: BopoDb, companyId: string, year: number, month1Based: number): Promise<Array<{
+    threadId: string;
+    messageCount: number;
+}>>;

package/dist/repositories/helpers.d.ts

@@ -14,3 +14,17 @@ export declare function assertTemplateBelongsToCompany(db: BopoDb, companyId: st
 export declare function compactUpdate<T extends Record<string, unknown>>(input: T): {
     [k: string]: unknown;
 };
+type GoalLevel = "company" | "project" | "agent";
+/**
+ * Validates level ↔ projectId and optional parent_goal_id tree rules:
+ * - company: projectId must be null; parent must be company-level (or absent).
+ * - project: projectId required; parent must be company-level or absent.
+ * - agent: parent absent, company-level, or project-level with same projectId as child (child projectId required in that case).
+ */
+export declare function assertValidGoalHierarchy(db: BopoDb, companyId: string, input: {
+    id?: string;
+    level: GoalLevel;
+    projectId: string | null;
+    parentGoalId: string | null;
+}): Promise<void>;
+export {};

package/dist/repositories/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./helpers";
 export * from "./companies";
+export * from "./company-assistant-chat";
 export * from "./legacy";

package/dist/repositories/legacy.d.ts

@@ -566,9 +566,9 @@ export declare function createGoal(db: BopoDb, input: {
     title: string;
     description?: string;
 }): Promise<{
+    projectId: string | null;
+    parentGoalId: string | null;
     companyId: string;
-    projectId?: string | null;
-    parentGoalId?: string | null;
     ownerAgentId?: string | null;
     level: "company" | "project" | "agent";
     title: string;
@@ -880,6 +880,10 @@ export declare function appendCost(db: BopoDb, input: {
     projectId?: string | null;
     issueId?: string | null;
     agentId?: string | null;
+    /** Discriminator for reporting (e.g. `company_assistant`); null for heartbeat / legacy */
+    costCategory?: string | null;
+    assistantThreadId?: string | null;
+    assistantMessageId?: string | null;
 }): Promise<string>;
 export declare function listCostEntries(db: BopoDb, companyId: string, limit?: number): Promise<{
     id: string;
@@ -888,6 +892,9 @@ export declare function listCostEntries(db: BopoDb, companyId: string, limit?: n
     projectId: string | null;
     issueId: string | null;
     agentId: string | null;
+    costCategory: string | null;
+    assistantThreadId: string | null;
+    assistantMessageId: string | null;
     providerType: string;
     runtimeModelId: string | null;
     pricingProviderType: string | null;
@@ -899,6 +906,16 @@ export declare function listCostEntries(db: BopoDb, companyId: string, limit?: n
     usdCostStatus: string | null;
     createdAt: Date;
 }[]>;
+export type CostLedgerAggregate = {
+    rowCount: number;
+    tokenInput: number;
+    tokenOutput: number;
+    /** Sum of `usd_cost` as a decimal string (full precision from DB). */
+    usdTotal: string;
+};
+/** Sum every ledger row for the company in `[startInclusive, endExclusive)` (typically UTC month). */
+export declare function aggregateCompanyCostLedgerInRange(db: BopoDb, companyId: string, startInclusive: Date, endExclusive: Date): Promise<CostLedgerAggregate>;
+export declare function aggregateCompanyCostLedgerAllTime(db: BopoDb, companyId: string): Promise<CostLedgerAggregate>;
 export declare function listHeartbeatRuns(db: BopoDb, companyId: string, limit?: number): Promise<{
     id: string;
     companyId: string;

package/dist/schema.d.ts

@@ -3854,6 +3854,207 @@ export declare const attentionInboxStates: import("drizzle-orm/pg-core").PgTable
     };
     dialect: "pg";
 }>;
+export declare const companyAssistantThreads: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "company_assistant_threads";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "company_assistant_threads";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        companyId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "company_id";
+            tableName: "company_assistant_threads";
+            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;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "company_assistant_threads";
+            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: "company_assistant_threads";
+            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";
+}>;
+export declare const companyAssistantMessages: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "company_assistant_messages";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "company_assistant_messages";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        threadId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "thread_id";
+            tableName: "company_assistant_messages";
+            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;
+        }, {}, {}>;
+        companyId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "company_id";
+            tableName: "company_assistant_messages";
+            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;
+        }, {}, {}>;
+        role: import("drizzle-orm/pg-core").PgColumn<{
+            name: "role";
+            tableName: "company_assistant_messages";
+            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;
+        }, {}, {}>;
+        body: import("drizzle-orm/pg-core").PgColumn<{
+            name: "body";
+            tableName: "company_assistant_messages";
+            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;
+        }, {}, {}>;
+        metadataJson: import("drizzle-orm/pg-core").PgColumn<{
+            name: "metadata_json";
+            tableName: "company_assistant_messages";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "company_assistant_messages";
+            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";
+}>;
 export declare const costLedger: import("drizzle-orm/pg-core").PgTableWithColumns<{
     name: "cost_ledger";
     schema: undefined;
@@ -3960,6 +4161,57 @@ export declare const costLedger: import("drizzle-orm/pg-core").PgTableWithColumn
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        costCategory: import("drizzle-orm/pg-core").PgColumn<{
+            name: "cost_category";
+            tableName: "cost_ledger";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        assistantThreadId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "assistant_thread_id";
+            tableName: "cost_ledger";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        assistantMessageId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "assistant_message_id";
+            tableName: "cost_ledger";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
         providerType: import("drizzle-orm/pg-core").PgColumn<{
             name: "provider_type";
             tableName: "cost_ledger";
@@ -9114,6 +9366,57 @@ export declare const schema: {
                 identity: undefined;
                 generated: undefined;
             }, {}, {}>;
+            costCategory: import("drizzle-orm/pg-core").PgColumn<{
+                name: "cost_category";
+                tableName: "cost_ledger";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            assistantThreadId: import("drizzle-orm/pg-core").PgColumn<{
+                name: "assistant_thread_id";
+                tableName: "cost_ledger";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            assistantMessageId: import("drizzle-orm/pg-core").PgColumn<{
+                name: "assistant_message_id";
+                tableName: "cost_ledger";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
             providerType: import("drizzle-orm/pg-core").PgColumn<{
                 name: "provider_type";
                 tableName: "cost_ledger";
@@ -10659,5 +10962,206 @@ export declare const schema: {
         };
         dialect: "pg";
     }>;
+    companyAssistantThreads: import("drizzle-orm/pg-core").PgTableWithColumns<{
+        name: "company_assistant_threads";
+        schema: undefined;
+        columns: {
+            id: import("drizzle-orm/pg-core").PgColumn<{
+                name: "id";
+                tableName: "company_assistant_threads";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: true;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            companyId: import("drizzle-orm/pg-core").PgColumn<{
+                name: "company_id";
+                tableName: "company_assistant_threads";
+                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;
+            }, {}, {}>;
+            createdAt: import("drizzle-orm/pg-core").PgColumn<{
+                name: "created_at";
+                tableName: "company_assistant_threads";
+                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: "company_assistant_threads";
+                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";
+    }>;
+    companyAssistantMessages: import("drizzle-orm/pg-core").PgTableWithColumns<{
+        name: "company_assistant_messages";
+        schema: undefined;
+        columns: {
+            id: import("drizzle-orm/pg-core").PgColumn<{
+                name: "id";
+                tableName: "company_assistant_messages";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: true;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            threadId: import("drizzle-orm/pg-core").PgColumn<{
+                name: "thread_id";
+                tableName: "company_assistant_messages";
+                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;
+            }, {}, {}>;
+            companyId: import("drizzle-orm/pg-core").PgColumn<{
+                name: "company_id";
+                tableName: "company_assistant_messages";
+                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;
+            }, {}, {}>;
+            role: import("drizzle-orm/pg-core").PgColumn<{
+                name: "role";
+                tableName: "company_assistant_messages";
+                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;
+            }, {}, {}>;
+            body: import("drizzle-orm/pg-core").PgColumn<{
+                name: "body";
+                tableName: "company_assistant_messages";
+                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;
+            }, {}, {}>;
+            metadataJson: import("drizzle-orm/pg-core").PgColumn<{
+                name: "metadata_json";
+                tableName: "company_assistant_messages";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            createdAt: import("drizzle-orm/pg-core").PgColumn<{
+                name: "created_at";
+                tableName: "company_assistant_messages";
+                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";
+    }>;
 };
 export declare const touchUpdatedAtSql: import("drizzle-orm").SQL<unknown>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bopodev-db",
-  "version": "0.1.31",
+  "version": "0.1.33",
   "license": "MIT",
   "type": "module",
   "main": "src/index.ts",

package/src/migrations/0006_company_assistant_chat.sql

@@ -0,0 +1,20 @@
+CREATE TABLE "company_assistant_threads" (
+	"id" text PRIMARY KEY NOT NULL,
+	"company_id" text NOT NULL REFERENCES "companies"("id") ON DELETE CASCADE,
+	"created_at" timestamp DEFAULT now() NOT NULL,
+	"updated_at" timestamp DEFAULT now() NOT NULL
+);
+
+CREATE INDEX "company_assistant_threads_company_idx" ON "company_assistant_threads" ("company_id");
+
+CREATE TABLE "company_assistant_messages" (
+	"id" text PRIMARY KEY NOT NULL,
+	"thread_id" text NOT NULL REFERENCES "company_assistant_threads"("id") ON DELETE CASCADE,
+	"company_id" text NOT NULL REFERENCES "companies"("id") ON DELETE CASCADE,
+	"role" text NOT NULL,
+	"body" text NOT NULL,
+	"metadata_json" text,
+	"created_at" timestamp DEFAULT now() NOT NULL
+);
+
+CREATE INDEX "company_assistant_messages_thread_created_idx" ON "company_assistant_messages" ("thread_id","created_at");

package/src/migrations/0007_cost_ledger_company_assistant.sql

@@ -0,0 +1,7 @@
+ALTER TABLE "cost_ledger" ADD COLUMN "cost_category" text;
+--> statement-breakpoint
+ALTER TABLE "cost_ledger" ADD COLUMN "assistant_thread_id" text REFERENCES "company_assistant_threads"("id") ON DELETE SET NULL;
+--> statement-breakpoint
+ALTER TABLE "cost_ledger" ADD COLUMN "assistant_message_id" text REFERENCES "company_assistant_messages"("id") ON DELETE SET NULL;
+--> statement-breakpoint
+CREATE INDEX "idx_cost_ledger_company_category_created" ON "cost_ledger" ("company_id", "cost_category", "created_at");

package/src/migrations/0008_goals_parent_goal_fk.sql

@@ -0,0 +1 @@
+ALTER TABLE "goals" ADD CONSTRAINT "goals_parent_goal_id_goals_id_fk" FOREIGN KEY ("parent_goal_id") REFERENCES "goals"("id") ON DELETE SET NULL;

package/src/migrations/meta/_journal.json

@@ -43,6 +43,27 @@
       "when": 1743000000000,
       "tag": "0005_work_loops",
       "breakpoints": true
+    },
+    {
+      "idx": 6,
+      "version": "7",
+      "when": 1743100000000,
+      "tag": "0006_company_assistant_chat",
+      "breakpoints": true
+    },
+    {
+      "idx": 7,
+      "version": "7",
+      "when": 1743200000000,
+      "tag": "0007_cost_ledger_company_assistant",
+      "breakpoints": true
+    },
+    {
+      "idx": 8,
+      "version": "7",
+      "when": 1743300000000,
+      "tag": "0008_goals_parent_goal_fk",
+      "breakpoints": true
     }
   ]
 }

package/src/repositories/company-assistant-chat.ts

@@ -0,0 +1,126 @@
+import { and, asc, count, desc, eq, gte, lt } from "drizzle-orm";
+import { nanoid } from "nanoid";
+import type { BopoDb } from "../client";
+import { companyAssistantMessages, companyAssistantThreads } from "../schema";
+
+export type AssistantMessageRole = "user" | "assistant" | "system";
+
+export async function getOrCreateAssistantThread(db: BopoDb, companyId: string) {
+  const [existing] = await db
+    .select()
+    .from(companyAssistantThreads)
+    .where(eq(companyAssistantThreads.companyId, companyId))
+    .orderBy(desc(companyAssistantThreads.updatedAt))
+    .limit(1);
+  if (existing) {
+    return existing;
+  }
+  return createAssistantThreadRow(db, companyId);
+}
+
+async function createAssistantThreadRow(db: BopoDb, companyId: string) {
+  const id = nanoid(16);
+  const now = new Date();
+  await db.insert(companyAssistantThreads).values({
+    id,
+    companyId,
+    createdAt: now,
+    updatedAt: now
+  });
+  const [row] = await db.select().from(companyAssistantThreads).where(eq(companyAssistantThreads.id, id)).limit(1);
+  return row!;
+}
+
+/** New empty thread; previous threads and messages remain in the database. */
+export async function createAssistantThread(db: BopoDb, companyId: string) {
+  return createAssistantThreadRow(db, companyId);
+}
+
+export async function getAssistantThreadById(db: BopoDb, companyId: string, threadId: string) {
+  const [row] = await db
+    .select()
+    .from(companyAssistantThreads)
+    .where(and(eq(companyAssistantThreads.id, threadId), eq(companyAssistantThreads.companyId, companyId)))
+    .limit(1);
+  return row ?? null;
+}
+
+export async function touchAssistantThread(db: BopoDb, threadId: string) {
+  await db
+    .update(companyAssistantThreads)
+    .set({ updatedAt: new Date() })
+    .where(eq(companyAssistantThreads.id, threadId));
+}
+
+export async function insertAssistantMessage(
+  db: BopoDb,
+  input: {
+    threadId: string;
+    companyId: string;
+    role: AssistantMessageRole;
+    body: string;
+    metadataJson?: string | null;
+  }
+) {
+  const id = nanoid(16);
+  await db.insert(companyAssistantMessages).values({
+    id,
+    threadId: input.threadId,
+    companyId: input.companyId,
+    role: input.role,
+    body: input.body,
+    metadataJson: input.metadataJson ?? null
+  });
+  await touchAssistantThread(db, input.threadId);
+  const [row] = await db.select().from(companyAssistantMessages).where(eq(companyAssistantMessages.id, id)).limit(1);
+  return row!;
+}
+
+export async function listAssistantMessages(db: BopoDb, threadId: string, limit = 100) {
+  const capped = Math.min(Math.max(1, limit), 200);
+  return db
+    .select()
+    .from(companyAssistantMessages)
+    .where(eq(companyAssistantMessages.threadId, threadId))
+    .orderBy(asc(companyAssistantMessages.createdAt))
+    .limit(capped);
+}
+
+/** Threads with at least one message in `[startInclusive, endExclusive)` on `created_at`. */
+export async function listAssistantChatThreadStatsInCreatedAtRange(
+  db: BopoDb,
+  companyId: string,
+  startInclusive: Date,
+  endExclusive: Date
+): Promise<Array<{ threadId: string; messageCount: number }>> {
+  const rows = await db
+    .select({
+      threadId: companyAssistantMessages.threadId,
+      messageCount: count()
+    })
+    .from(companyAssistantMessages)
+    .where(
+      and(
+        eq(companyAssistantMessages.companyId, companyId),
+        gte(companyAssistantMessages.createdAt, startInclusive),
+        lt(companyAssistantMessages.createdAt, endExclusive)
+      )
+    )
+    .groupBy(companyAssistantMessages.threadId);
+  return rows.map((r) => ({
+    threadId: r.threadId,
+    messageCount: Number(r.messageCount) || 0
+  }));
+}
+
+/** Threads with at least one message in the UTC calendar month (for callers without local bounds). */
+export async function listAssistantChatThreadStatsInUtcMonth(
+  db: BopoDb,
+  companyId: string,
+  year: number,
+  month1Based: number
+): Promise<Array<{ threadId: string; messageCount: number }>> {
+  const startUtc = new Date(Date.UTC(year, month1Based - 1, 1, 0, 0, 0, 0));
+  const endExclusiveUtc = new Date(Date.UTC(year, month1Based, 1, 0, 0, 0, 0));
+  return listAssistantChatThreadStatsInCreatedAtRange(db, companyId, startUtc, endExclusiveUtc);
+}

package/src/repositories/helpers.ts

@@ -102,3 +102,113 @@ export async function assertTemplateBelongsToCompany(db: BopoDb, companyId: stri
 export function compactUpdate<T extends Record<string, unknown>>(input: T) {
   return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined));
 }
+
+const GOAL_PARENT_CHAIN_MAX_DEPTH = 32;
+
+type GoalLevel = "company" | "project" | "agent";
+
+/** Walk parent_goal_id upward; detects cycles and whether `selfId` appears (would make self an ancestor of the parent). */
+async function walkGoalParentChain(
+  db: BopoDb,
+  companyId: string,
+  startParentId: string,
+  selfId: string | undefined
+) {
+  const visited = new Set<string>();
+  let current: string | null = startParentId;
+  let depth = 0;
+  while (current && depth < GOAL_PARENT_CHAIN_MAX_DEPTH) {
+    if (selfId && current === selfId) {
+      throw new RepositoryValidationError("Goal cannot be its own ancestor.");
+    }
+    if (visited.has(current)) {
+      throw new RepositoryValidationError("Parent goal chain contains a cycle.");
+    }
+    visited.add(current);
+    const [row] = await db
+      .select({ parentGoalId: goals.parentGoalId })
+      .from(goals)
+      .where(and(eq(goals.companyId, companyId), eq(goals.id, current)))
+      .limit(1);
+    current = row?.parentGoalId?.trim() ? row.parentGoalId : null;
+    depth += 1;
+  }
+  if (current && depth >= GOAL_PARENT_CHAIN_MAX_DEPTH) {
+    throw new RepositoryValidationError("Parent goal chain exceeds maximum depth.");
+  }
+}
+
+/**
+ * Validates level ↔ projectId and optional parent_goal_id tree rules:
+ * - company: projectId must be null; parent must be company-level (or absent).
+ * - project: projectId required; parent must be company-level or absent.
+ * - agent: parent absent, company-level, or project-level with same projectId as child (child projectId required in that case).
+ */
+export async function assertValidGoalHierarchy(
+  db: BopoDb,
+  companyId: string,
+  input: {
+    id?: string;
+    level: GoalLevel;
+    projectId: string | null;
+    parentGoalId: string | null;
+  }
+) {
+  const level = input.level;
+  const projectId = input.projectId?.trim() ? input.projectId.trim() : null;
+  const parentGoalId = input.parentGoalId?.trim() ? input.parentGoalId.trim() : null;
+
+  if (level === "company" && projectId) {
+    throw new RepositoryValidationError("Company goals cannot be scoped to a project.");
+  }
+  if (level === "project" && !projectId) {
+    throw new RepositoryValidationError("Project goals must have a project.");
+  }
+
+  if (!parentGoalId) {
+    return;
+  }
+
+  const [parent] = await db
+    .select({
+      id: goals.id,
+      level: goals.level,
+      projectId: goals.projectId
+    })
+    .from(goals)
+    .where(and(eq(goals.companyId, companyId), eq(goals.id, parentGoalId)))
+    .limit(1);
+
+  if (!parent) {
+    throw new RepositoryValidationError("Parent goal not found for company.");
+  }
+
+  const pLevel = parent.level as GoalLevel;
+  if (pLevel !== "company" && pLevel !== "project") {
+    throw new RepositoryValidationError("Parent goal must be company or project level.");
+  }
+
+  if (level === "company") {
+    if (pLevel !== "company") {
+      throw new RepositoryValidationError("Company goals may only have a company-level parent.");
+    }
+  } else if (level === "project") {
+    if (pLevel !== "company") {
+      throw new RepositoryValidationError("Project goals may only have a company-level parent.");
+    }
+  } else {
+    // agent
+    if (pLevel === "company") {
+      // ok
+    } else if (pLevel === "project") {
+      const parentPid = parent.projectId?.trim() ? parent.projectId : null;
+      if (!parentPid || parentPid !== projectId) {
+        throw new RepositoryValidationError(
+          "Agent goals with a project parent must use the same project as the parent goal."
+        );
+      }
+    }
+  }
+
+  await walkGoalParentChain(db, companyId, parentGoalId, input.id);
+}

package/src/repositories/index.ts

@@ -1,3 +1,4 @@
 export * from "./helpers";
 export * from "./companies";
+export * from "./company-assistant-chat";
 export * from "./legacy";

package/src/repositories/legacy.ts

@@ -1,4 +1,4 @@
-import { and, asc, desc, eq, gt, inArray, notInArray, sql } from "drizzle-orm";
+import { and, asc, desc, eq, gt, gte, inArray, lt, notInArray, sql } from "drizzle-orm";
 import { nanoid } from "nanoid";
 import type { BopoDb } from "../client";
 import {
@@ -29,11 +29,11 @@ import {
 } from "../schema";
 import {
   assertAgentBelongsToCompany,
-  assertGoalBelongsToCompany,
   assertIssueGoalsAssignable,
   assertIssueBelongsToCompany,
   assertProjectBelongsToCompany,
   assertTemplateBelongsToCompany,
+  assertValidGoalHierarchy,
   compactUpdate,
   RepositoryValidationError
 } from "./helpers";
@@ -946,11 +946,15 @@ export async function createGoal(
     description?: string;
   }
 ) {
-  if (input.projectId) {
-    await assertProjectBelongsToCompany(db, input.companyId, input.projectId);
-  }
-  if (input.parentGoalId) {
-    await assertGoalBelongsToCompany(db, input.companyId, input.parentGoalId);
+  const projectId = input.projectId?.trim() ? input.projectId.trim() : null;
+  const parentGoalId = input.parentGoalId?.trim() ? input.parentGoalId.trim() : null;
+  await assertValidGoalHierarchy(db, input.companyId, {
+    level: input.level,
+    projectId,
+    parentGoalId
+  });
+  if (projectId) {
+    await assertProjectBelongsToCompany(db, input.companyId, projectId);
   }
   if (input.ownerAgentId) {
     await assertAgentBelongsToCompany(db, input.companyId, input.ownerAgentId);
@@ -959,14 +963,14 @@ export async function createGoal(
   await db.insert(goals).values({
     id,
     companyId: input.companyId,
-    projectId: input.projectId ?? null,
-    parentGoalId: input.parentGoalId ?? null,
+    projectId,
+    parentGoalId,
     ownerAgentId: input.ownerAgentId?.trim() ? input.ownerAgentId.trim() : null,
     level: input.level,
     title: input.title,
     description: input.description ?? null
   });
-  return { id, ...input };
+  return { id, ...input, projectId, parentGoalId };
 }
 
 export async function listGoals(db: BopoDb, companyId: string) {
@@ -987,14 +991,37 @@ export async function updateGoal(
     status?: string;
   }
 ) {
-  if (input.projectId) {
-    await assertProjectBelongsToCompany(db, input.companyId, input.projectId);
+  const [existing] = await db
+    .select({
+      level: goals.level,
+      projectId: goals.projectId,
+      parentGoalId: goals.parentGoalId
+    })
+    .from(goals)
+    .where(and(eq(goals.companyId, input.companyId), eq(goals.id, input.id)))
+    .limit(1);
+  if (!existing) {
+    return null;
   }
-  if (input.parentGoalId) {
-    await assertGoalBelongsToCompany(db, input.companyId, input.parentGoalId);
+
+  const effectiveLevel = (input.level ?? existing.level) as "company" | "project" | "agent";
+  const effectiveProjectId = input.projectId !== undefined ? input.projectId : existing.projectId;
+  const effectiveProjectIdNorm = effectiveProjectId?.trim() ? effectiveProjectId.trim() : null;
+  const effectiveParent =
+    input.parentGoalId !== undefined ? input.parentGoalId : existing.parentGoalId;
+  const effectiveParentNorm = effectiveParent?.trim() ? effectiveParent.trim() : null;
+
+  await assertValidGoalHierarchy(db, input.companyId, {
+    id: input.id,
+    level: effectiveLevel,
+    projectId: effectiveProjectIdNorm,
+    parentGoalId: effectiveParentNorm
+  });
+  if (effectiveProjectIdNorm) {
+    await assertProjectBelongsToCompany(db, input.companyId, effectiveProjectIdNorm);
   }
-  if (input.ownerAgentId) {
-    await assertAgentBelongsToCompany(db, input.companyId, input.ownerAgentId);
+  if (input.ownerAgentId?.trim()) {
+    await assertAgentBelongsToCompany(db, input.companyId, input.ownerAgentId.trim());
   }
   const [goal] = await db
     .update(goals)
@@ -1518,6 +1545,10 @@ export async function appendCost(
     projectId?: string | null;
     issueId?: string | null;
     agentId?: string | null;
+    /** Discriminator for reporting (e.g. `company_assistant`); null for heartbeat / legacy */
+    costCategory?: string | null;
+    assistantThreadId?: string | null;
+    assistantMessageId?: string | null;
   }
 ) {
   const id = nanoid(14);
@@ -1525,6 +1556,9 @@ export async function appendCost(
     id,
     companyId: input.companyId,
     runId: input.runId ?? null,
+    costCategory: input.costCategory ?? null,
+    assistantThreadId: input.assistantThreadId ?? null,
+    assistantMessageId: input.assistantMessageId ?? null,
     providerType: input.providerType,
     runtimeModelId: input.runtimeModelId ?? null,
     pricingProviderType: input.pricingProviderType ?? null,
@@ -1550,6 +1584,83 @@ export async function listCostEntries(db: BopoDb, companyId: string, limit = 200
     .limit(limit);
 }
 
+export type CostLedgerAggregate = {
+  rowCount: number;
+  tokenInput: number;
+  tokenOutput: number;
+  /** Sum of `usd_cost` as a decimal string (full precision from DB). */
+  usdTotal: string;
+};
+
+/** Sum every ledger row for the company in `[startInclusive, endExclusive)` (typically UTC month). */
+export async function aggregateCompanyCostLedgerInRange(
+  db: BopoDb,
+  companyId: string,
+  startInclusive: Date,
+  endExclusive: Date
+): Promise<CostLedgerAggregate> {
+  const [row] = await db
+    .select({
+      rowCount: sql<number>`count(*)::int`,
+      tokenInput: sql<string>`coalesce(sum(${costLedger.tokenInput})::text, '0')`,
+      tokenOutput: sql<string>`coalesce(sum(${costLedger.tokenOutput})::text, '0')`,
+      usdTotal: sql<string>`coalesce(sum(${costLedger.usdCost})::text, '0')`
+    })
+    .from(costLedger)
+    .where(
+      and(
+        eq(costLedger.companyId, companyId),
+        gte(costLedger.createdAt, startInclusive),
+        lt(costLedger.createdAt, endExclusive)
+      )
+    );
+
+  const parseBigIntish = (v: string) => {
+    try {
+      return Number(BigInt(v));
+    } catch {
+      return Number.parseInt(v, 10) || 0;
+    }
+  };
+
+  return {
+    rowCount: Number(row?.rowCount ?? 0),
+    tokenInput: parseBigIntish(String(row?.tokenInput ?? "0")),
+    tokenOutput: parseBigIntish(String(row?.tokenOutput ?? "0")),
+    usdTotal: String(row?.usdTotal ?? "0").trim() || "0"
+  };
+}
+
+export async function aggregateCompanyCostLedgerAllTime(
+  db: BopoDb,
+  companyId: string
+): Promise<CostLedgerAggregate> {
+  const [row] = await db
+    .select({
+      rowCount: sql<number>`count(*)::int`,
+      tokenInput: sql<string>`coalesce(sum(${costLedger.tokenInput})::text, '0')`,
+      tokenOutput: sql<string>`coalesce(sum(${costLedger.tokenOutput})::text, '0')`,
+      usdTotal: sql<string>`coalesce(sum(${costLedger.usdCost})::text, '0')`
+    })
+    .from(costLedger)
+    .where(eq(costLedger.companyId, companyId));
+
+  const parseBigIntish = (v: string) => {
+    try {
+      return Number(BigInt(v));
+    } catch {
+      return Number.parseInt(v, 10) || 0;
+    }
+  };
+
+  return {
+    rowCount: Number(row?.rowCount ?? 0),
+    tokenInput: parseBigIntish(String(row?.tokenInput ?? "0")),
+    tokenOutput: parseBigIntish(String(row?.tokenOutput ?? "0")),
+    usdTotal: String(row?.usdTotal ?? "0").trim() || "0"
+  };
+}
+
 export async function listHeartbeatRuns(db: BopoDb, companyId: string, limit = 100) {
   return db
     .select()

package/src/schema.ts

@@ -1,4 +1,5 @@
 import { sql } from "drizzle-orm";
+import type { AnyPgColumn } from "drizzle-orm/pg-core";
 import { boolean, integer, numeric, pgTable, primaryKey, text, timestamp } from "drizzle-orm/pg-core";
 
 export const companies = pgTable("companies", {
@@ -52,7 +53,7 @@ export const goals = pgTable("goals", {
     .notNull()
     .references(() => companies.id, { onDelete: "cascade" }),
   projectId: text("project_id").references(() => projects.id, { onDelete: "set null" }),
-  parentGoalId: text("parent_goal_id"),
+  parentGoalId: text("parent_goal_id").references((): AnyPgColumn => goals.id, { onDelete: "set null" }),
   /** When set, this agent-level goal is included only for that agent's heartbeats; null = all agents. */
   ownerAgentId: text("owner_agent_id"),
   level: text("level").notNull(),
@@ -366,6 +367,29 @@ export const attentionInboxStates = pgTable(
   (table) => [primaryKey({ columns: [table.companyId, table.actorId, table.itemKey] })]
 );
 
+export const companyAssistantThreads = pgTable("company_assistant_threads", {
+  id: text("id").primaryKey(),
+  companyId: text("company_id")
+    .notNull()
+    .references(() => companies.id, { onDelete: "cascade" }),
+  createdAt: timestamp("created_at", { mode: "date" }).defaultNow().notNull(),
+  updatedAt: timestamp("updated_at", { mode: "date" }).defaultNow().notNull()
+});
+
+export const companyAssistantMessages = pgTable("company_assistant_messages", {
+  id: text("id").primaryKey(),
+  threadId: text("thread_id")
+    .notNull()
+    .references(() => companyAssistantThreads.id, { onDelete: "cascade" }),
+  companyId: text("company_id")
+    .notNull()
+    .references(() => companies.id, { onDelete: "cascade" }),
+  role: text("role").notNull(),
+  body: text("body").notNull(),
+  metadataJson: text("metadata_json"),
+  createdAt: timestamp("created_at", { mode: "date" }).defaultNow().notNull()
+});
+
 export const costLedger = pgTable("cost_ledger", {
   id: text("id").primaryKey(),
   companyId: text("company_id")
@@ -375,6 +399,10 @@ export const costLedger = pgTable("cost_ledger", {
   projectId: text("project_id").references(() => projects.id, { onDelete: "set null" }),
   issueId: text("issue_id").references(() => issues.id, { onDelete: "set null" }),
   agentId: text("agent_id").references(() => agents.id, { onDelete: "set null" }),
+  /** e.g. `company_assistant` for owner-assistant chat; null for heartbeat and legacy rows */
+  costCategory: text("cost_category"),
+  assistantThreadId: text("assistant_thread_id").references(() => companyAssistantThreads.id, { onDelete: "set null" }),
+  assistantMessageId: text("assistant_message_id").references(() => companyAssistantMessages.id, { onDelete: "set null" }),
   providerType: text("provider_type").notNull(),
   runtimeModelId: text("runtime_model_id"),
   pricingProviderType: text("pricing_provider_type"),
@@ -536,7 +564,9 @@ export const schema = {
   templateVersions,
   templateInstalls,
   agentIssueLabels,
-  projectWorkspaces
+  projectWorkspaces,
+  companyAssistantThreads,
+  companyAssistantMessages
 };
 
 export const touchUpdatedAtSql = sql`CURRENT_TIMESTAMP`;