diff --git a/apps/server/src/kin/chat/KinChatService.ts b/apps/server/src/kin/chat/KinChatService.ts index 03cb68cf5dcfc..1661671409ab4 100644 --- a/apps/server/src/kin/chat/KinChatService.ts +++ b/apps/server/src/kin/chat/KinChatService.ts @@ -196,7 +196,7 @@ const requireRecord = Effect.fn("KinChatService.requireRecord")(function* ) => +const testLayer = ( + judge: Layer.Layer, + sqlLayer: + | Layer.Layer + | Layer.Layer = Layer.empty, + off = false, +) => Chat.layer.pipe( - Layer.provideMerge(Shadow.layer.pipe(Layer.provide(judge))), + Layer.provideMerge( + (off ? Shadow.layerOff : Shadow.layer).pipe(Layer.provide(judge), Layer.provide(sqlLayer)), + ), Layer.provideMerge(dependencies), Layer.provide(environment), ); @@ -83,15 +99,43 @@ const seed = Effect.gen(function* () { mutedUntil: null, }); }); -const send = (key: string) => +const send = (key: string, grant = true) => Effect.flatMap(Chat.KinChatService, (service) => service.send(person, { chatId, clientMessageId: key, body: `Untrusted human text ${key}`, - mentions: [agentMemberId], + mentions: grant ? [agentMemberId] : [], }), ); +const otherChatId = KinChatId.make("other-group"); +const sendInOtherChat = Effect.gen(function* () { + const repo = yield* Repository.KinChatRepository; + yield* repo.createChat({ + orgId, + chatId: otherChatId, + kind: "team_group", + title: "Other", + teamId: null, + directKey: null, + lastMessageAt: null, + createdAt: timestamp, + archivedAt: null, + }); + yield* repo.addMember({ + orgId, + chatId: otherChatId, + memberId: KinMemberId.make("owner-other"), + principal: { _tag: "person", personId }, + role: "owner", + joinedAt: timestamp, + leftAt: null, + mutedUntil: null, + }); + return yield* Effect.flatMap(Chat.KinChatService, (service) => + service.send(person, { chatId: otherChatId, clientMessageId: "other", body: "Other chat" }), + ); +}); const logs = Effect.gen(function* () { const sql = yield* SqlClient.SqlClient; return yield* sql<{ @@ -106,8 +150,11 @@ const logs = Effect.gen(function* () { }); 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`; + return { + runs: yield* sql`SELECT * FROM kin_floor_runs WHERE org_id = ${orgId} AND chat_id = ${chatId} ORDER BY run_id`, + grants: + yield* sql`SELECT * FROM kin_floor_grants WHERE org_id = ${orgId} AND chat_id = ${chatId} ORDER BY token`, + }; }); describe("JudgeShadow", () => { @@ -151,43 +198,184 @@ describe("JudgeShadow", () => { }).pipe(Effect.provide(testLayer(NoopJudge.layer))), ); + it.effect("the record deadline includes the log write", () => + Effect.gen(function* () { + const modelEntered = yield* Deferred.make(); + const modelResult = yield* Deferred.make(); + const writeEntered = yield* Deferred.make(); + const writeResult = yield* Deferred.make(); + const judge = Layer.succeed(Judge, { + name: "blocked-write", + judge: () => + Deferred.succeed(modelEntered, undefined).pipe( + Effect.andThen(Deferred.await(modelResult)), + ), + }); + const sqlLayer = Layer.effect( + SqlClient.SqlClient, + Effect.map( + SqlClient.SqlClient, + (sql) => + new Proxy(sql, { + apply(target, thisArg, args) { + const query = Reflect.apply(target, thisArg, args) as Statement.Statement; + if (String(args[0]).includes("INSERT INTO kin_judge_log")) + return Deferred.succeed(writeEntered, undefined).pipe( + Effect.andThen(Deferred.await(writeResult)), + Effect.andThen(query), + ); + return query; + }, + }), + ), + ); + yield* Effect.gen(function* () { + yield* seed; + yield* send("deadline"); + yield* Deferred.await(modelEntered); + yield* TestClock.adjust(2000); + yield* Deferred.succeed(modelResult, { + 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 }, + }); + yield* Deferred.await(writeEntered); + const drained = yield* (yield* Shadow.JudgeShadow).drain.pipe(Effect.forkScoped); + yield* TestClock.adjust(1000); + assert.isTrue(drained.pollUnsafe() !== undefined); + yield* Deferred.succeed(writeResult, undefined); + yield* Fiber.join(drained); + assert.deepStrictEqual(yield* logs, []); + }).pipe(Effect.provide(testLayer(judge, sqlLayer))); + }), + ); + + it.effect.each([ + "extra", + "text", + "name", + "agent", + "chat", + "org", + "message", + "crossChat", + "null", + ] as const)("drops records outside the allowlist: %s", (invalid) => + Effect.gen(function* () { + const verdict: JudgeVerdict = { + needsResponse: { value: true, confidence: 1 }, + role: { value: "lead", confidence: 1 }, + urgency: { value: "normal", confidence: 1 }, + needsHumanDecision: { value: false, confidence: 1 }, + commitment: { + value: { kind: "promise", text: invalid === "text" ? "x".repeat(1001) : null }, + confidence: 1, + }, + }; + const judge = Layer.succeed(Judge, { + name: invalid === "name" ? "x".repeat(101) : "boundary", + judge: () => + Effect.succeed( + invalid === "null" + ? (null as unknown as JudgeVerdict) + : invalid === "extra" + ? { ...verdict, token: "not-authority" } + : verdict, + ), + }); + yield* Effect.gen(function* () { + yield* seed; + const message = invalid === "crossChat" ? yield* sendInOtherChat : yield* send("boundary"); + const shadow = yield* Shadow.JudgeShadow; + yield* shadow.drain; + const sql = yield* SqlClient.SqlClient; + yield* sql`DELETE FROM kin_judge_log`; + const before = yield* floor; + yield* shadow.observe( + { + ...message, + chatId: invalid === "chat" ? KinChatId.make("other") : chatId, + orgId: invalid === "org" ? KinOrgId.make("other") : orgId, + messageId: invalid === "message" ? KinMessageId.make("missing") : message.messageId, + }, + { _tag: "grant", agentId: invalid === "agent" ? KinAgentId.make("outsider") : agentId }, + ); + yield* shadow.drain; + assert.deepStrictEqual(yield* logs, []); + assert.deepStrictEqual(yield* floor, before); + }).pipe(Effect.provide(testLayer(judge))); + }), + ); + it.effect.prop( "arbitrary verdicts cannot change a group floor decision", { + grant: Schema.Boolean, + off: Schema.Boolean, 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 })), + confidence: Schema.Union([ + Schema.Number.check(Schema.isBetween({ minimum: 0, maximum: 1 })), + Schema.Literals([-1, 2]), + ]), commitment: Schema.Literals(["none", "defer", "promise"]), }, (values) => Effect.gen(function* () { + const ready = yield* Deferred.make(); + // Normalise -0 so the JSON round-trip compares equal. + const confidence = values.confidence + 0; 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) }, + needsResponse: { + value: values.response, + confidence, + }, + needsHumanDecision: { + value: values.human, + confidence, + }, + role: { value: values.role, confidence }, + urgency: { + value: values.urgency, + confidence, + }, commitment: { value: { kind: values.commitment, text: null }, - confidence: Math.abs(values.confidence), + confidence, }, }; const judge = Layer.succeed(Judge, { name: "generated", - judge: (input) => Effect.succeed({ ...verdict, untrustedExtra: input.text }), + judge: () => Deferred.await(ready).pipe(Effect.as(verdict)), }); yield* Effect.gen(function* () { yield* seed; - yield* send("generated"); + yield* send("generated", values.grant); const before = yield* floor; + yield* Deferred.succeed(ready, undefined); yield* (yield* Shadow.JudgeShadow).drain; assert.deepStrictEqual(yield* floor, before); const [row] = yield* logs; + if (values.off || values.confidence < 0 || values.confidence > 1) { + assert.isUndefined(row); + return; + } 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))); + assert.deepStrictEqual( + JSON.parse(row!.floor_decision_json), + values.grant ? { _tag: "grant", agentId } : { _tag: "wait" }, + ); + const stored: JudgeVerdict = JSON.parse(row!.verdict_json!); + assert.deepStrictEqual(stored, verdict); + for (const score of Object.values(stored)) { + assert.isAtLeast(score.confidence, 0); + assert.isAtMost(score.confidence, 1); + } + }).pipe(Effect.provide(testLayer(judge, Layer.empty, values.off))); }), { arbitrary: { runs: 20 } }, ); @@ -248,8 +436,12 @@ describe("JudgeShadow", () => { 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); + if (mode === "slow") { + assert.isUndefined(row); + return; + } + assert.strictEqual(row!.error, "judge_error"); + assert.strictEqual(row!.latency_ms, 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 index 3f52c2af097d4..4123d84b96ca6 100644 --- a/apps/server/src/kin/floor/JudgeShadow.ts +++ b/apps/server/src/kin/floor/JudgeShadow.ts @@ -1,4 +1,4 @@ -import { KinAgentRole, type KinMessage } from "@t3tools/contracts"; +import { KinAgentId, KinAgentRole, type KinMessage } from "@t3tools/contracts"; import * as Clock from "effect/Clock"; import * as Context from "effect/Context"; import * as Effect from "effect/Effect"; @@ -28,10 +28,27 @@ const decodeVerdict = Schema.decodeUnknownEffect( }), ), }), + { onExcessProperty: "error" }, +); +const decodeDecision = Schema.decodeUnknownEffect( + Schema.NullOr( + Schema.Union([ + Schema.TaggedStruct("grant", { agentId: KinAgentId }), + Schema.TaggedStruct("wait", {}), + Schema.TaggedStruct("close", { + reason: Schema.Literals(["turn_budget", "no_bids", "nothing_to_add"]), + }), + ]), + ), + { onExcessProperty: "error" }, +); +const decodeName = Schema.decodeUnknownEffect( + Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(100)), ); const decodeAgents = Schema.decodeUnknownEffect( Schema.Array( Schema.Struct({ + agent_id: KinAgentId, role: KinAgentRole, }), ), @@ -60,6 +77,28 @@ const make = Effect.gen(function* () { ORDER BY CASE a.role WHEN 'lead' THEN 0 ELSE 1 END, m.joined_at, a.agent_id`.pipe( Effect.flatMap(decodeAgents), ); + const validMessage = yield* sql`SELECT message_id FROM kin_messages + WHERE org_id = ${message.orgId} AND chat_id = ${message.chatId} + AND message_id = ${message.messageId} AND author_kind = 'human' AND status = 'posted'`; + const boundary = yield* Effect.all({ + decision: decodeDecision(floorDecision), + name: decodeName(judge.name), + }).pipe(Effect.option); + if ( + validMessage.length !== 1 || + boundary._tag === "None" || + (boundary.value.decision?._tag === "grant" && + !agents.some( + (agent) => + boundary.value.decision?._tag === "grant" && + agent.agent_id === boundary.value.decision.agentId, + )) + ) { + yield* Effect.logWarning("Kin shadow judge record rejected.", { + category: "invalid_boundary", + }); + return; + } const recent = yield* sql<{ author_kind: "human" | "agent"; author_role: string; @@ -82,31 +121,37 @@ const make = Effect.gen(function* () { }; 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 verdict = + result.error !== null ? null : yield* decodeVerdict(result.verdict).pipe(Effect.option); + if (verdict?._tag === "None") { + yield* Effect.logWarning("Kin shadow judge record rejected.", { + category: "invalid_verdict", + }); + return; + } 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}) + ${boundary.value.name}, ${verdict === null ? null : yield* encodeJson(verdict.value)}, + ${yield* encodeJson(boundary.value.decision)}, ${Math.max(0, now - started)}, ${result.error}, ${now}) ON CONFLICT DO NOTHING RETURNING id`; }, + Effect.timeout(3000), + Effect.catchTags({ + TimeoutError: () => Effect.logWarning("Kin shadow judge record timed out."), + }), 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; + if (message.author._tag !== "human" || message.status !== "posted") return; // Fork only after commit, without inheriting the post's transaction connection. yield* sql.afterCommit( permits @@ -120,4 +165,8 @@ const make = Effect.gen(function* () { }), }); }); -export const layer = Layer.effect(JudgeShadow, make); +export const layerOff = Layer.succeed(JudgeShadow, { + drain: Effect.void, + observe: Effect.fn("KinJudge.observeOff")(() => Effect.void), +}); +export const layer = JUDGE_MODE === "shadow" ? Layer.effect(JudgeShadow, make) : layerOff; diff --git a/apps/server/src/kin/layer.ts b/apps/server/src/kin/layer.ts index 1bc96ce9d55d8..114519b091408 100644 --- a/apps/server/src/kin/layer.ts +++ b/apps/server/src/kin/layer.ts @@ -1,5 +1,3 @@ -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"; @@ -36,11 +34,7 @@ const enabled = Layer.effect( subscribeForViewer: Option.some(hub.subscribeForViewer), }; }), -).pipe( - Layer.provide( - KinChat.layer.pipe(Layer.provide(JudgeShadow.layer.pipe(Layer.provide(NoopJudge.layer)))), - ), -); +).pipe(Layer.provide(KinChat.layer)); const disabled = Layer.succeed(KinServer, { taskCardUpdater: Layer.empty, services: Option.none(), diff --git a/apps/server/src/kin/triggers/pings.test.ts b/apps/server/src/kin/triggers/pings.test.ts index 499ba4ec9ae9d..9d51dbb2463fc 100644 --- a/apps/server/src/kin/triggers/pings.test.ts +++ b/apps/server/src/kin/triggers/pings.test.ts @@ -1,3 +1,4 @@ +import * as JudgeShadow from "../floor/JudgeShadow.ts"; import { assert, describe, it } from "@effect/vitest"; import { KinChatId, @@ -72,6 +73,7 @@ function layer( hubLayer = Hub.layer, ) { const dependencies = Chat.layer.pipe( + Layer.provide(JudgeShadow.layerOff), Layer.provideMerge(hubLayer), Layer.provideMerge(Repo.layer), Layer.provideMerge(Cache.layer), diff --git a/docs/kin/specs/chat.md b/docs/kin/specs/chat.md index 7ed4f5a892289..1a481b0a1ccd0 100644 --- a/docs/kin/specs/chat.md +++ b/docs/kin/specs/chat.md @@ -460,7 +460,7 @@ export const JUDGE_MODE: "off" | "shadow" | "live" = "shadow"; export const JUDGE_THRESHOLDS = { act: 0.8, ask: 0.5 } as const; // below ask: ask an LLM or the user ``` -- **Shadow runner:** after the floor manager decides, `JudgeShadow` calls the judge in a forked fiber with a 3 s timeout and writes `kin_judge_log (org_id, id, chat_id, message_id, judge, verdict_json, floor_decision_json, latency_ms, error, created_at)`. It never changes the decision. Errors and timeouts are logged and dropped. +- **Shadow runner:** after the floor manager decides, `JudgeShadow` calls the judge in a forked fiber with one 3 s deadline covering context reads, the model call and the log write, and writes `kin_judge_log (org_id, id, chat_id, message_id, judge, verdict_json, floor_decision_json, latency_ms, error, created_at)`. It never changes the decision. Errors and timeouts are logged and dropped; a timeout does not attempt a second log-table write. Before storage, an explicit allowlist rejects unknown verdict fields, out-of-range confidence, invalid verdict values, commitment text over 1,000 characters, judge names outside 1–100 characters, message ids outside the same org/chat, and grant agent ids outside its active membership. Rejected records are logged without payloads and never stored. `JudgeShadow` is a required chat dependency supplied by the Kin layer; `off` mode supplies a no-op. - **Implementations:** `NoopJudge` (always low confidence) ships first. Jev and the cheap-LLM fallback are later tasks outside this spec. - **It never authorises an action.** `JudgeVerdict` has no field any approvals code reads. A test asserts that nothing under `apps/server/src/kin/approvals/` imports `kin/floor/Judge.ts`. - The lead spec may read `commitment` from the log to propose deferrals, as a suggestion only.