diff --git a/apps/server/src/kin/chat/KinChatService.ts b/apps/server/src/kin/chat/KinChatService.ts index a1da120e5de07..4c04ef40bca20 100644 --- a/apps/server/src/kin/chat/KinChatService.ts +++ b/apps/server/src/kin/chat/KinChatService.ts @@ -1,3 +1,4 @@ +import { JudgeShadow } from "../floor/JudgeShadow.ts"; import * as Floor from "../floor/KinFloor.ts"; import { ServerEnvironment } from "../../environment/ServerEnvironment.ts"; import { OrchestratorV2 } from "../../orchestration-v2/Orchestrator.ts"; @@ -195,6 +196,7 @@ const requireRecord = Effect.fn("KinChatService.requireRecord")(function* ; + readonly agentRoles: ReadonlyArray; +} +export interface Scored { + readonly value: A; + readonly confidence: number; +} +export interface JudgeVerdict { + readonly needsResponse: Scored; + readonly role: Scored; + readonly urgency: Scored<"low" | "normal" | "high">; + readonly needsHumanDecision: Scored; + readonly commitment: Scored<{ + readonly kind: "none" | "defer" | "promise"; + readonly text: string | null; + }>; +} +export class JudgeError extends Schema.TaggedError()("JudgeError", {}) {} +export class Judge extends Context.Service< + Judge, + { + readonly name: string; + readonly judge: (input: JudgeInput) => Effect.Effect; + } +>()("t3/kin/floor/Judge") {} +export const JUDGE_MODE: "off" | "shadow" | "live" = "shadow"; +export const JUDGE_THRESHOLDS = { act: 0.8, ask: 0.5 } as const; diff --git a/apps/server/src/kin/floor/JudgeBoundary.test.ts b/apps/server/src/kin/floor/JudgeBoundary.test.ts new file mode 100644 index 0000000000000..376a65a978d37 --- /dev/null +++ b/apps/server/src/kin/floor/JudgeBoundary.test.ts @@ -0,0 +1,64 @@ +import * as NodeServices from "@effect/platform-node/NodeServices"; +import * as NodeURL from "node:url"; +import { assert, it } from "@effect/vitest"; +import * as Effect from "effect/Effect"; +import * as FileSystem from "effect/FileSystem"; +import * as Path from "effect/Path"; + +const kin = NodeURL.fileURLToPath(new URL("../", import.meta.url)); + +it.effect( + "approvals and floor enforcement cannot depend on the judge, even through a re-export", + () => + Effect.gen(function* () { + const fs = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const files = (yield* fs.readDirectory(kin, { recursive: true })).filter( + (file) => + file.endsWith(".ts") && !file.endsWith(".test.ts") && !file.endsWith(".testkit.ts"), + ); + const graph = new Map>(); + for (const file of files) { + const filename = path.resolve(kin, file); + const source = yield* fs.readFileString(filename); + // Kin uses relative, literal ES imports; follow re-exports and dynamic imports too. + const imports = [ + ...source.matchAll( + /(?:\b(?:import|export)\s+(?:type\s+)?(?:[^;"']*?\s+from\s*)?|\bimport\s*\(\s*)["'](\.[^"']+)["']/g, + ), + ]; + graph.set( + filename, + imports.map((match) => path.resolve(path.dirname(filename), match[1]!)), + ); + } + const reachable = (entry: string) => { + const seen = new Set(); + const visit = (filename: string) => { + if (seen.has(filename)) return; + seen.add(filename); + for (const dependency of graph.get(filename) ?? []) visit(dependency); + }; + visit(path.resolve(kin, entry)); + return [...seen].map((filename) => path.relative(kin, filename)); + }; + const roots = [ + "floor/FloorManager.ts", + "floor/KinFloor.ts", + ...files.filter((file) => file.startsWith("approvals/")), + ]; + for (const root of roots) { + assert.isFalse(reachable(root).includes("floor/Judge.ts"), root); + assert.isFalse(reachable(root).includes("floor/JudgeShadow.ts"), root); + } + assert.include(reachable("floor/KinFloor.ts"), "floor/FloorManager.ts"); + assert.isFalse( + reachable("floor/Judge.ts").some( + (file) => + file.startsWith("approvals/") || + file === "chat/KinChatService.ts" || + file === "floor/KinFloor.ts", + ), + ); + }).pipe(Effect.provide(NodeServices.layer)), +); diff --git a/apps/server/src/kin/floor/JudgeShadow.test.ts b/apps/server/src/kin/floor/JudgeShadow.test.ts new file mode 100644 index 0000000000000..585c1292698b8 --- /dev/null +++ b/apps/server/src/kin/floor/JudgeShadow.test.ts @@ -0,0 +1,257 @@ +import { assert, describe, it } from "@effect/vitest"; +import { KinAgentId, KinChatId, KinMemberId, KinOrgId, KinPersonId } from "@t3tools/contracts"; +import * as Schema from "effect/Schema"; +import * as Clock from "effect/Clock"; +import * as Deferred from "effect/Deferred"; +import * as Effect from "effect/Effect"; +import * as Exit from "effect/Exit"; +import * as Fiber from "effect/Fiber"; +import * as Layer from "effect/Layer"; +import * as Option from "effect/Option"; +import * as Stream from "effect/Stream"; +import * as TestClock from "effect/testing/TestClock"; +import * as SqlClient from "effect/sql/SqlClient"; +import { environment } from "../chat/TaskCard.testkit.ts"; +import { authorityLayer } from "../chat/WakeupAuthority.testkit.ts"; +import * as Repository from "../chat/KinChatRepository.ts"; +import * as Hub from "../chat/KinChatHub.ts"; +import * as Chat from "../chat/KinChatService.ts"; +import { Judge, JudgeError, JUDGE_THRESHOLDS, type JudgeVerdict } from "./Judge.ts"; +import * as Shadow from "./JudgeShadow.ts"; +import * as NoopJudge from "./NoopJudge.ts"; + +const orgId = KinOrgId.make("kin-default"); +const chatId = KinChatId.make("group"); +const personId = KinPersonId.make("owner"); +const agentId = KinAgentId.make("lead"); +const memberId = KinMemberId.make("owner-member"); +const agentMemberId = KinMemberId.make("lead-member"); +const timestamp = "1970-01-01T00:00:00.000Z"; +const person = { _tag: "person" as const, orgId, personId }; +const database = Repository.layer.pipe(Layer.provideMerge(authorityLayer)); +const dependencies = Hub.layer.pipe(Layer.provideMerge(database)); +const testLayer = (judge: Layer.Layer) => + Chat.layer.pipe( + Layer.provideMerge(Shadow.layer.pipe(Layer.provide(judge))), + Layer.provideMerge(dependencies), + Layer.provide(environment), + ); +const seed = Effect.gen(function* () { + const repo = yield* Repository.KinChatRepository; + yield* repo.insertOrg({ orgId, name: "Test", createdAt: timestamp }); + yield* repo.insertPerson({ + orgId, + personId, + handle: "owner", + displayName: "Owner", + githubLogin: null, + createdAt: timestamp, + }); + yield* repo.insertAgent({ + orgId, + agentId, + ownerPersonId: personId, + displayName: "Lead", + role: "lead", + createdAt: timestamp, + }); + yield* repo.createChat({ + orgId, + chatId, + kind: "team_group", + title: "Group", + teamId: null, + directKey: null, + lastMessageAt: null, + createdAt: timestamp, + archivedAt: null, + }); + for (const member of [ + { memberId, principal: { _tag: "person" as const, personId }, role: "owner" as const }, + { + memberId: agentMemberId, + principal: { _tag: "agent" as const, agentId }, + role: "member" as const, + }, + ]) + yield* repo.addMember({ + orgId, + chatId, + ...member, + joinedAt: timestamp, + leftAt: null, + mutedUntil: null, + }); +}); +const send = (key: string) => + Effect.flatMap(Chat.KinChatService, (service) => + service.send(person, { + chatId, + clientMessageId: key, + body: `Untrusted human text ${key}`, + mentions: [agentMemberId], + }), + ); +const logs = Effect.gen(function* () { + const sql = yield* SqlClient.SqlClient; + return yield* sql<{ + message_id: string; + verdict_json: string | null; + floor_decision_json: string; + latency_ms: number; + error: string | null; + }>` + SELECT message_id, verdict_json, floor_decision_json, latency_ms, error FROM kin_judge_log + WHERE org_id = ${orgId} AND chat_id = ${chatId} ORDER BY created_at, message_id`; +}); +const floor = Effect.gen(function* () { + const sql = yield* SqlClient.SqlClient; + return yield* sql`SELECT run_id, opened_by, state, agent_turns, last_speaker FROM kin_floor_runs + WHERE org_id = ${orgId} AND chat_id = ${chatId} ORDER BY opened_at, run_id`; +}); + +describe("JudgeShadow", () => { + it.effect( + "logs one row per committed group human message, deduplicates retries, and rolls back cleanly", + () => + Effect.gen(function* () { + yield* seed; + const shadow = yield* Shadow.JudgeShadow; + const sql = yield* SqlClient.SqlClient; + const first = yield* send("first"); + const retry = yield* send("first"); + assert.strictEqual(first.messageId, retry.messageId); + const second = yield* send("second"); + yield* shadow.drain; + const before = yield* floor; + yield* shadow.observe(first, { _tag: "grant", agentId }); + yield* shadow.drain; + assert.deepStrictEqual(yield* floor, before); + const rows = yield* logs; + assert.deepStrictEqual( + rows.map((row) => row.message_id).sort(), + [first.messageId, second.messageId].sort(), + ); + for (const row of rows) { + assert.strictEqual(row.error, null); + assert.deepStrictEqual(JSON.parse(row.floor_decision_json), { _tag: "grant", agentId }); + assert.isBelow( + JSON.parse(row.verdict_json!).needsResponse.confidence, + JUDGE_THRESHOLDS.ask, + ); + assert.notInclude(row.verdict_json!, "Untrusted human text"); + } + const rolledBack = yield* sql + .withTransaction(send("rollback").pipe(Effect.andThen(Effect.fail("rollback")))) + .pipe(Effect.exit); + assert.isTrue(Exit.isFailure(rolledBack)); + yield* shadow.drain; + assert.strictEqual((yield* logs).length, 2); + assert.deepStrictEqual(yield* floor, before); + }).pipe(Effect.provide(testLayer(NoopJudge.layer))), + ); + + it.effect.prop( + "arbitrary verdicts cannot change a group floor decision", + { + response: Schema.Boolean, + human: Schema.Boolean, + role: Schema.NullOr(Schema.Literals(["lead", "qa", "release"])), + urgency: Schema.Literals(["low", "normal", "high"]), + confidence: Schema.Number.check(Schema.isBetween({ minimum: 0, maximum: 1 })), + commitment: Schema.Literals(["none", "defer", "promise"]), + }, + (values) => + Effect.gen(function* () { + const verdict: JudgeVerdict = { + needsResponse: { value: values.response, confidence: Math.abs(values.confidence) }, + needsHumanDecision: { value: values.human, confidence: Math.abs(values.confidence) }, + role: { value: values.role, confidence: Math.abs(values.confidence) }, + urgency: { value: values.urgency, confidence: Math.abs(values.confidence) }, + commitment: { + value: { kind: values.commitment, text: null }, + confidence: Math.abs(values.confidence), + }, + }; + const judge = Layer.succeed(Judge, { + name: "generated", + judge: (input) => Effect.succeed({ ...verdict, untrustedExtra: input.text }), + }); + yield* Effect.gen(function* () { + yield* seed; + yield* send("generated"); + const before = yield* floor; + yield* (yield* Shadow.JudgeShadow).drain; + assert.deepStrictEqual(yield* floor, before); + const [row] = yield* logs; + assert.isNull(row!.error); + assert.deepStrictEqual(JSON.parse(row!.floor_decision_json), { _tag: "grant", agentId }); + assert.deepStrictEqual(JSON.parse(row!.verdict_json!), verdict); + }).pipe(Effect.provide(testLayer(judge))); + }), + { arbitrary: { runs: 20 } }, + ); + + it.effect("a failed log write cannot roll back a post or hold its transaction", () => + Effect.gen(function* () { + yield* seed; + const sql = yield* SqlClient.SqlClient; + yield* sql`DROP TABLE kin_judge_log`; + const first = yield* send("log-failed"); + yield* (yield* Shadow.JudgeShadow).drain; + const repo = yield* Repository.KinChatRepository; + assert.isTrue(Option.isSome(yield* repo.getMessage({ orgId, messageId: first.messageId }))); + const second = yield* send("still-writable"); + assert.strictEqual(second.seq, first.seq + 1); + yield* (yield* Shadow.JudgeShadow).drain; + }).pipe(Effect.provide(testLayer(NoopJudge.layer))), + ); + + it.effect.each(["failure", "defect", "slow"] as const)( + "%s never holds the post transaction or alters floor or delivery", + (mode) => + Effect.gen(function* () { + const entered = yield* Deferred.make(); + const blocked = yield* Deferred.make(); + const judge = Layer.succeed(Judge, { + name: mode, + judge: Effect.fn("TestJudge.judge")(function* () { + yield* Deferred.succeed(entered, undefined); + if (mode === "failure") return yield* new JudgeError({}); + if (mode === "defect") return yield* Effect.die("Untrusted private body"); + return yield* Deferred.await(blocked); + }), + }); + yield* Effect.gen(function* () { + yield* seed; + const hub = yield* Hub.KinChatHub; + const events = yield* hub.subscribeForViewer(person); + const event = yield* events.pipe( + Stream.filter((e) => e.type === "message.posted"), + Stream.runHead, + Effect.forkScoped, + ); + const started = yield* Clock.currentTimeMillis; + const message = yield* send(mode); + assert.strictEqual(yield* Clock.currentTimeMillis, started); + yield* Deferred.await(entered); + const before = yield* floor; + const repo = yield* Repository.KinChatRepository; + assert.isTrue( + Option.isSome(yield* repo.getMessage({ orgId, messageId: message.messageId })), + ); + assert.isTrue(Option.isSome(yield* Fiber.join(event))); + if (mode === "slow") { + assert.isFalse(yield* Deferred.isDone(blocked)); + yield* TestClock.adjust(3000); + } + yield* (yield* Shadow.JudgeShadow).drain; + assert.deepStrictEqual(yield* floor, before); + const [row] = yield* logs; + assert.strictEqual(row!.error, mode === "slow" ? "timeout" : "judge_error"); + assert.strictEqual(row!.latency_ms, mode === "slow" ? 3000 : 0); + assert.isNull(row!.verdict_json); + }).pipe(Effect.provide(testLayer(judge))); + }), + ); +}); diff --git a/apps/server/src/kin/floor/JudgeShadow.ts b/apps/server/src/kin/floor/JudgeShadow.ts new file mode 100644 index 0000000000000..3f52c2af097d4 --- /dev/null +++ b/apps/server/src/kin/floor/JudgeShadow.ts @@ -0,0 +1,123 @@ +import { KinAgentRole, type KinMessage } from "@t3tools/contracts"; +import * as Clock from "effect/Clock"; +import * as Context from "effect/Context"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; +import * as FiberSet from "effect/FiberSet"; +import * as Schema from "effect/Schema"; +import * as Semaphore from "effect/Semaphore"; +import * as SecureRandom from "effect/crypto/SecureRandom"; +import * as SqlClient from "effect/sql/SqlClient"; +import { toPersistenceSqlError } from "../../persistence/Errors.ts"; +import type { FloorDecision } from "./FloorManager.ts"; +import { Judge, type JudgeInput, JUDGE_MODE } from "./Judge.ts"; + +const confidence = Schema.Number.check(Schema.isBetween({ minimum: 0, maximum: 1 })); +const scored = (value: S) => Schema.Struct({ value, confidence }); +const encodeJson = Schema.encodeEffect(Schema.fromJsonString(Schema.Unknown)); +const decodeVerdict = Schema.decodeUnknownEffect( + Schema.Struct({ + needsResponse: scored(Schema.Boolean), + role: scored(Schema.NullOr(KinAgentRole)), + urgency: scored(Schema.Literals(["low", "normal", "high"])), + needsHumanDecision: scored(Schema.Boolean), + commitment: scored( + Schema.Struct({ + kind: Schema.Literals(["none", "defer", "promise"]), + text: Schema.NullOr(Schema.String.check(Schema.isMaxLength(1000))), + }), + ), + }), +); +const decodeAgents = Schema.decodeUnknownEffect( + Schema.Array( + Schema.Struct({ + role: KinAgentRole, + }), + ), +); + +export class JudgeShadow extends Context.Service< + JudgeShadow, + { + readonly drain: Effect.Effect; + readonly observe: (message: KinMessage, decision: FloorDecision | null) => Effect.Effect; + } +>()("t3/kin/floor/JudgeShadow") {} + +const make = Effect.gen(function* () { + const sql = yield* SqlClient.SqlClient; + const judge = yield* Judge; + const workers = yield* FiberSet.make(); + // Bounds concurrent judge calls and log writes under a burst of human messages. + const permits = yield* Semaphore.make(2); + const record = Effect.fn("KinJudge.record")( + function* (message: KinMessage, floorDecision: FloorDecision | null) { + const agents = yield* sql`SELECT a.agent_id, a.role FROM kin_chat_members m + JOIN kin_agents a ON a.org_id = m.org_id AND a.agent_id = m.agent_id + WHERE m.org_id = ${message.orgId} AND m.chat_id = ${message.chatId} + AND m.left_at IS NULL AND a.retired_at IS NULL + ORDER BY CASE a.role WHEN 'lead' THEN 0 ELSE 1 END, m.joined_at, a.agent_id`.pipe( + Effect.flatMap(decodeAgents), + ); + const recent = yield* sql<{ + author_kind: "human" | "agent"; + author_role: string; + body: string; + }>` + SELECT author_kind, author_role, body FROM kin_messages + WHERE org_id = ${message.orgId} AND chat_id = ${message.chatId} AND seq < ${message.seq} + AND author_kind IN ('human', 'agent') AND status = 'posted' + ORDER BY seq DESC LIMIT 10`; + const input: JudgeInput = { + orgId: message.orgId, + chatId: message.chatId, + messageId: message.messageId, + text: message.body, + authorRole: message.authorRole, + recent: recent + .toReversed() + .map((row) => ({ authorKind: row.author_kind, role: row.author_role, text: row.body })), + agentRoles: agents.map((agent) => agent.role), + }; + const started = yield* Clock.currentTimeMillis; + const result = yield* Effect.suspend(() => judge.judge(input)).pipe( + Effect.flatMap(decodeVerdict), + Effect.map((verdict) => ({ verdict, error: null })), + Effect.catchCause(() => Effect.succeed({ verdict: null, error: "judge_error" as const })), + Effect.timeoutOrElse({ + duration: 3000, + orElse: () => Effect.succeed({ verdict: null, error: "timeout" as const }), + }), + ); + const now = yield* Clock.currentTimeMillis; + if (result.error !== null) + yield* Effect.logWarning("Kin shadow judge failed.", { category: result.error }); + yield* sql`INSERT INTO kin_judge_log + (org_id, id, chat_id, message_id, judge, verdict_json, floor_decision_json, latency_ms, error, created_at) + VALUES (${message.orgId}, ${SecureRandom.uuidV4Unsafe()}, ${message.chatId}, ${message.messageId}, + ${judge.name.slice(0, 100)}, ${result.verdict === null ? null : yield* encodeJson(result.verdict)}, + ${yield* encodeJson(floorDecision)}, ${Math.max(0, now - started)}, ${result.error}, ${now}) + ON CONFLICT DO NOTHING RETURNING id`; + }, + Effect.mapError(toPersistenceSqlError("KinJudge.record")), + ); + return JudgeShadow.of({ + drain: FiberSet.awaitEmpty(workers), + observe: Effect.fn("KinJudge.observe")(function* (message, decision) { + if (JUDGE_MODE !== "shadow" || message.author._tag !== "human" || message.status !== "posted") + return; + // Fork only after commit, without inheriting the post's transaction connection. + yield* sql.afterCommit( + permits + .withPermits(1)(record(message, decision)) + .pipe( + Effect.catchCause(() => Effect.logWarning("Kin shadow judge log failed.")), + FiberSet.run(workers, { startImmediately: false }), + Effect.asVoid, + ), + ); + }), + }); +}); +export const layer = Layer.effect(JudgeShadow, make); diff --git a/apps/server/src/kin/floor/KinFloor.ts b/apps/server/src/kin/floor/KinFloor.ts index e895bb0cde605..f51c30bc88cd1 100644 --- a/apps/server/src/kin/floor/KinFloor.ts +++ b/apps/server/src/kin/floor/KinFloor.ts @@ -22,6 +22,7 @@ import { toPersistenceSqlError, type PersistenceSqlError } from "../../persisten import type { AgentIdentity } from "../chat/KinIdentity.ts"; import { decideFloor, + type FloorDecision, FLOOR_GRANT_TTL_MS, FLOOR_MAX_AGENT_TURNS, noticeIntentAllowed, @@ -63,7 +64,10 @@ type Authorization = { readonly runId: string | null }; export class KinFloor extends Context.Service< KinFloor, { - readonly open: (message: KinMessage, chat: KinChat) => Effect.Effect; + readonly open: ( + message: KinMessage, + chat: KinChat, + ) => Effect.Effect; readonly authorize: ( identity: AgentIdentity, chat: KinChat, @@ -99,7 +103,7 @@ const make = Effect.gen(function* () { }); const open = Effect.fn("KinFloor.open")( function* (message: KinMessage, chat: KinChat) { - if (message.author._tag !== "human" || message.status !== "posted") return; + if (message.author._tag !== "human" || message.status !== "posted") return null; const now = yield* Clock.currentTimeMillis; yield* close(message); const agents = yield* sql` @@ -120,7 +124,7 @@ const make = Effect.gen(function* () { yield* sql`INSERT INTO kin_floor_runs (org_id, run_id, chat_id, opened_by, mention_queue, state, opened_at) VALUES (${message.orgId}, ${runId}, ${message.chatId}, ${message.messageId}, ${yield* encodeAgents(mentionQueue)}, 'open', ${now}) ON CONFLICT DO NOTHING RETURNING run_id`; - if (lead === undefined) return; + if (lead === undefined) return null; const decision = decideFloor({ run: { runId, @@ -140,8 +144,9 @@ const make = Effect.gen(function* () { now, }); // Group tokens remain internal until phase-2 wake-up delivery. - if (decision._tag !== "grant") return; + if (decision._tag !== "grant") return decision; yield* issue({ ...message, runId, agentId: decision.agentId }, now); + return decision; }, Effect.mapError(toPersistenceSqlError("KinFloor.open")), ); diff --git a/apps/server/src/kin/floor/NoopJudge.ts b/apps/server/src/kin/floor/NoopJudge.ts new file mode 100644 index 0000000000000..e9f0b546eed08 --- /dev/null +++ b/apps/server/src/kin/floor/NoopJudge.ts @@ -0,0 +1,15 @@ +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; +import { Judge, type JudgeVerdict } from "./Judge.ts"; + +const verdict: JudgeVerdict = { + needsResponse: { value: false, confidence: 0 }, + role: { value: null, confidence: 0 }, + urgency: { value: "normal", confidence: 0 }, + needsHumanDecision: { value: false, confidence: 0 }, + commitment: { value: { kind: "none", text: null }, confidence: 0 }, +}; +export const layer = Layer.succeed(Judge, { + name: "noop", + judge: Effect.fn("KinJudge.judge")(() => Effect.succeed(verdict)), +}); diff --git a/apps/server/src/kin/layer.ts b/apps/server/src/kin/layer.ts index 114519b091408..1bc96ce9d55d8 100644 --- a/apps/server/src/kin/layer.ts +++ b/apps/server/src/kin/layer.ts @@ -1,3 +1,5 @@ +import * as JudgeShadow from "./floor/JudgeShadow.ts"; +import * as NoopJudge from "./floor/NoopJudge.ts"; import { TaskCardIndex } from "./widgets/taskCard.ts"; import { KinChatRepository } from "./chat/KinChatRepository.ts"; import type * as SqlClient from "effect/sql/SqlClient"; @@ -34,7 +36,11 @@ const enabled = Layer.effect( subscribeForViewer: Option.some(hub.subscribeForViewer), }; }), -).pipe(Layer.provide(KinChat.layer)); +).pipe( + Layer.provide( + KinChat.layer.pipe(Layer.provide(JudgeShadow.layer.pipe(Layer.provide(NoopJudge.layer)))), + ), +); const disabled = Layer.succeed(KinServer, { taskCardUpdater: Layer.empty, services: Option.none(), diff --git a/apps/server/src/kin/persistence/KinMigrations.test.ts b/apps/server/src/kin/persistence/KinMigrations.test.ts index 49fcc7b9498e4..1c67fefcdc3e2 100644 --- a/apps/server/src/kin/persistence/KinMigrations.test.ts +++ b/apps/server/src/kin/persistence/KinMigrations.test.ts @@ -23,6 +23,7 @@ const tableNames = [ "kin_floor_grants", "kin_floor_notices", "kin_floor_runs", + "kin_judge_log", "kin_leads", "kin_memory_reads", "kin_messages", @@ -93,6 +94,7 @@ describe("Kin migrations", () => { { migration_id: 6, name: "Pings" }, { migration_id: 7, name: "Budget" }, { migration_id: 8, name: "Floor" }, + { migration_id: 9, name: "JudgeLog" }, ]); assert.deepStrictEqual( upstreamBefore.map((row) => [row.migration_id, row.name] as const), @@ -143,6 +145,7 @@ describe("Kin migrations", () => { { migration_id: 6, name: "Pings" }, { migration_id: 7, name: "Budget" }, { migration_id: 8, name: "Floor" }, + { migration_id: 9, name: "JudgeLog" }, ]); assert.deepStrictEqual(yield* upstreamHistory, upstreamBefore); assert.deepStrictEqual(yield* sql`SELECT * FROM kin_orgs`, [ @@ -217,6 +220,7 @@ describe("Kin migrations", () => { [6, "Pings"], [7, "Budget"], [8, "Floor"], + [9, "JudgeLog"], ]); const before = yield* kinSchema; assert.deepStrictEqual( @@ -234,6 +238,7 @@ describe("Kin migrations", () => { VALUES ('existing-chat', 'org', 'project_group', 0, ${timestamp})`; yield* sql`INSERT INTO kin_chat_members (member_id, org_id, chat_id, principal_kind, person_id, role, joined_at) VALUES ('existing-owner', 'org', 'existing-chat', 'person', 'owner', 'owner', ${timestamp})`; + yield* sql`DROP TABLE kin_judge_log`; yield* sql`DROP TABLE kin_floor_notices`; yield* sql`DROP TABLE kin_floor_grants`; yield* sql`DROP TABLE kin_floor_runs`; @@ -249,6 +254,7 @@ describe("Kin migrations", () => { [6, "Pings"], [7, "Budget"], [8, "Floor"], + [9, "JudgeLog"], ]); assert.deepStrictEqual( yield* sql`SELECT member_id FROM kin_chat_members WHERE org_id = 'org' ORDER BY member_id`, @@ -269,6 +275,7 @@ describe("Kin migrations", () => { { migration_id: 6, name: "Pings" }, { migration_id: 7, name: "Budget" }, { migration_id: 8, name: "Floor" }, + { migration_id: 9, name: "JudgeLog" }, ]); assert.deepStrictEqual(yield* runKinMigrations(), []); assert.deepStrictEqual(yield* runMigrations(), []); diff --git a/apps/server/src/kin/persistence/KinMigrations.ts b/apps/server/src/kin/persistence/KinMigrations.ts index d9df0a3102951..d140ffa0b4398 100644 --- a/apps/server/src/kin/persistence/KinMigrations.ts +++ b/apps/server/src/kin/persistence/KinMigrations.ts @@ -10,6 +10,8 @@ import Pings from "./migrations/K006_Pings.ts"; import Budget from "./migrations/K007_Budget.ts"; import Floor from "./migrations/K008_Floor.ts"; +import JudgeLog from "./migrations/K009_JudgeLog.ts"; + const run = Migrator.make({}); const loader = Migrator.fromRecord({ "1_ChatCore": ChatCore, @@ -20,6 +22,7 @@ const loader = Migrator.fromRecord({ "6_Pings": Pings, "7_Budget": Budget, "8_Floor": Floor, + "9_JudgeLog": JudgeLog, }); export const runKinMigrations = Effect.fn("KinMigrations.run")(function* () { diff --git a/apps/server/src/kin/persistence/migrations/K009_JudgeLog.ts b/apps/server/src/kin/persistence/migrations/K009_JudgeLog.ts new file mode 100644 index 0000000000000..c3f81a08dab99 --- /dev/null +++ b/apps/server/src/kin/persistence/migrations/K009_JudgeLog.ts @@ -0,0 +1,21 @@ +import * as Effect from "effect/Effect"; +import * as SqlClient from "effect/sql/SqlClient"; + +export default Effect.gen(function* () { + const sql = yield* SqlClient.SqlClient; + yield* sql`CREATE TABLE kin_judge_log ( + org_id TEXT NOT NULL REFERENCES kin_orgs(org_id), + id TEXT NOT NULL, + chat_id TEXT NOT NULL, + message_id TEXT NOT NULL REFERENCES kin_messages(message_id), + judge TEXT NOT NULL, + verdict_json TEXT, + floor_decision_json TEXT NOT NULL, + latency_ms INTEGER NOT NULL CHECK (latency_ms >= 0), + error TEXT CHECK (error IN ('timeout', 'judge_error')), + created_at INTEGER NOT NULL, + PRIMARY KEY (org_id, id), + UNIQUE (org_id, message_id), + FOREIGN KEY (org_id, chat_id) REFERENCES kin_chats(org_id, chat_id) + )`; +});