Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
40 changes: 40 additions & 0 deletions apps/server/scripts/migrate-dev-db.test.ts
Original file line number Diff line number Diff line change
Expand Up @@ -211,6 +211,34 @@ it.layer(NodeServices.layer)("migrate-dev-db", (it) => {
yield* sql`UPDATE orchestration_v2_tool_search_state
SET cursor = (SELECT max(rowid) FROM orchestration_v2_projection_turn_items),
backfill_end = (SELECT max(rowid) FROM orchestration_v2_projection_turn_items) WHERE id = 1`;
for (const [summaryId, projectId, threadId, text, scrubbed] of [
["summary-kept", "project-kept", "stopped-thread", "keptsummaryterm", false],
[
"summary-dropped",
"project-deleted",
"deleted-project-thread",
"droppedsummaryterm",
false,
],
["summary-scrubbed", "project-kept", "stopped-thread", "scrubbedsummaryterm", true],
[
"summary-legacy-scrubbed",
"project-kept",
"stopped-thread",
"[Source unavailable: removed or changed.]",
false,
],
] as const) {
yield* sql`INSERT INTO conversation_summaries
(summary_id, project_id, thread_id, position, created_at, payload_json)
VALUES (${summaryId}, ${projectId}, ${threadId}, '0', '2026-08-01',
${JSON.stringify({ statements: [{ text }], scrubbed })})`;
}
assert.deepEqual(
yield* sql`SELECT text FROM conversation_summary_fts
WHERE conversation_summary_fts MATCH 'keptsummaryterm'`,
[{ text: "keptsummaryterm" }],
);
}),
);

Expand All @@ -233,6 +261,18 @@ it.layer(NodeServices.layer)("migrate-dev-db", (it) => {
toolHits.map((hit) => hit.id),
["tool-copy"],
);
const summaryHits = yield* sql<{ id: string }>`
SELECT summary.summary_id AS id FROM conversation_summary_fts
JOIN conversation_summary_search_ids AS ids ON ids.id = conversation_summary_fts.rowid
JOIN conversation_summaries AS summary USING (summary_id)
WHERE conversation_summary_fts MATCH 'keptsummaryterm'`;
assert.deepEqual(
summaryHits.map((hit) => hit.id),
["summary-kept"],
);
assert.deepEqual(yield* sql`SELECT text FROM conversation_summary_fts`, [
{ text: "keptsummaryterm" },
]);
const threads = yield* sql<{ thread_id: string }>`
SELECT thread_id FROM orchestration_v2_projection_threads ORDER BY thread_id`;
const events = yield* sql<{ stream_id: string }>`
Expand Down
10 changes: 10 additions & 0 deletions apps/server/scripts/migrate-dev-db.ts
Original file line number Diff line number Diff line change
Expand Up @@ -322,6 +322,16 @@ const copySourceSlice = Effect.fn("copyDevDbSourceSlice")(function* (sourcePath:
if (virtualTables.includes("project_knowledge_fts")) {
yield* sql`INSERT INTO project_knowledge_fts(project_knowledge_fts) VALUES ('rebuild')`;
}
if (virtualTables.includes("conversation_summary_fts")) {
yield* sql`INSERT INTO conversation_summary_fts (rowid, text)
SELECT ids.id, (SELECT group_concat(json_extract(value, '$.text'), ' ')
FROM json_each(summary.payload_json, '$.statements'))
FROM conversation_summaries AS summary
JOIN conversation_summary_search_ids AS ids USING (summary_id)
WHERE coalesce(json_extract(summary.payload_json, '$.scrubbed'), 0) = 0
AND coalesce(json_extract(summary.payload_json, '$.statements[0].text'), '')
!= '[Source unavailable: removed or changed.]'`;
}
}),
);
yield* sql`DETACH DATABASE src`;
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -101,6 +101,7 @@ const optedIn = {
const decodeSettings = Schema.decodeUnknownEffect(ServerSettingsSchema);
const decodeSummarySearchInput = Schema.decodeEffect(ConversationSummarySearchInput);
const encodeSummary = Schema.encodeEffect(Schema.fromJsonString(ConversationSummary));
const encodeModelSelection = Schema.encodeSync(Schema.fromJsonString(ModelSelection));
// Freeze the protocol-2 summary codec from before ranged/tool sources. An older client
// compiles these shapes into RpcClient; merely accepting our current schema proves nothing.
const LegacySummary = Schema.Struct({
Expand Down Expand Up @@ -239,13 +240,28 @@ const settingsLayer = (overrides: Parameters<typeof ServerSettings.layerTest>[0]
}),
).pipe(Layer.provide(ServerSettings.layerTest(overrides)));

const makeLayer = (generate: Generate, settings: Parameters<typeof ServerSettings.layerTest>[0]) =>
const makeLayer = (
generate: Generate,
settings: Parameters<typeof ServerSettings.layerTest>[0],
afterSourceRead: (
input: Parameters<ProjectKnowledge.ProjectKnowledge["Service"]["readSources"]>[0],
) => Effect.Effect<void> = () => Effect.void,
) =>
Layer.merge(ConversationSummaries.layer, ContextHandoffService.layer).pipe(
Layer.provide(
Layer.mock(TextGeneration.TextGeneration)({ generateConversationSummary: generate }),
),
Layer.provide(IdAllocator.layer),
Layer.provideMerge(ProjectKnowledge.layer.pipe(Layer.provide(HolographicMemory.layer))),
Layer.provideMerge(
Layer.effect(
ProjectKnowledge.ProjectKnowledge,
Effect.map(ProjectKnowledge.ProjectKnowledge, (knowledge) => ({
...knowledge,
readSources: (input) =>
knowledge.readSources(input).pipe(Effect.tap(() => afterSourceRead(input))),
})),
).pipe(Layer.provide(ProjectKnowledge.layer.pipe(Layer.provide(HolographicMemory.layer)))),
),
Layer.provideMerge(
Layer.mergeAll(
ProjectStore.layer,
Expand Down Expand Up @@ -474,10 +490,39 @@ const onlySummary = Effect.gen(function* () {
return read.summary;
});

const adoptThreadProject = Effect.fn("test.adoptSummaryThreadProject")(function* () {
const sql = yield* SqlClient.SqlClient;
const adoptedProjectId = ProjectId.make("adopted-project");
yield* sql`INSERT INTO projection_projects
(project_id, title, workspace_root, scripts_json, created_at, updated_at)
SELECT ${adoptedProjectId}, title, workspace_root, scripts_json, created_at, updated_at
FROM projection_projects WHERE project_id = ${projectId}`;
const projections = yield* ProjectionStore.ProjectionStoreV2;
yield* projections.apply({
id: EventId.make("thread-project-adopted"),
type: "thread.metadata-updated",
threadId,
providerInstanceId: instanceId,
occurredAt: at,
payload: { ...threadPayload, projectId: adoptedProjectId },
});
const settings = yield* ServerSettings.ServerSettingsService;
yield* settings.updateSettings({
projectSettingsOverrides: {
...optedIn.projectSettingsOverrides,
[adoptedProjectId]: { enableConversationSummaries: true },
},
});
return adoptedProjectId;
});

it.effect(
"summarizes the settled range once with exact citations and no stored source text",
() => {
const model = citing();
let sourceRead:
| { entered: Deferred.Deferred<void>; release: Deferred.Deferred<void> }
| undefined;
return Effect.gen(function* () {
yield* seed;
yield* summarize;
Expand Down Expand Up @@ -507,7 +552,44 @@ it.effect(
SELECT payload_json FROM conversation_summaries
`;
assert.isTrue(rows.every((row) => !row.payload_json.includes("Detail. Detail.")));
}).pipe(Effect.provide(makeLayer(model.generate, optedIn)));

const adoptedProjectId = yield* adoptThreadProject();
const service = yield* ConversationSummaries.ConversationSummaries;
const gate = { entered: yield* Deferred.make<void>(), release: yield* Deferred.make<void>() };
sourceRead = gate;
const oldRead = yield* service
.describe({ ...scope, summaryId: summary.id })
.pipe(Effect.forkChild);
yield* Deferred.await(gate.entered);
yield* Effect.gen(function* () {
yield* summarize;
const adopted = yield* service.list({ projectId: adoptedProjectId, threadId });
assert.equal(adopted.summaries.length, 1);
assert.deepInclude(adopted.summaries[0], {
state: "available",
summary: { ...summary, projectId: adoptedProjectId },
});
}).pipe(Effect.ensuring(Deferred.succeed(gate.release, undefined)));
assert.equal((yield* Fiber.join(oldRead)).state, "stale");
assert.equal(
(yield* service.describe({ projectId: adoptedProjectId, threadId, summaryId: summary.id }))
.state,
"available",
);
yield* summarize;
assert.equal(model.calls.length, 2);
}).pipe(
Effect.provide(
makeLayer(model.generate, optedIn, (input) => {
if (sourceRead === undefined || input.projectId !== projectId) return Effect.void;
const gate = sourceRead;
sourceRead = undefined;
return Deferred.succeed(gate.entered, undefined).pipe(
Effect.andThen(Deferred.await(gate.release)),
);
}),
),
);
},
);

Expand Down Expand Up @@ -871,6 +953,44 @@ it.effect.each([
yield* sql`UPDATE projection_projects SET deleted_at = '2026-01-01T00:00:00.000Z'
WHERE project_id = ${projectId}`;
assert.deepEqual(yield* stalled(), []);

const adoptedProjectId = yield* adoptThreadProject();
assert.deepInclude((yield* stalled())[0], { threadId, runId: freshRunId, retry: 1 });
const adoptedModel = { instanceId, model: "gpt-5-mini" };
const adoptedModelKey = encodeModelSelection(adoptedModel);
const adoptedSettings = {
projectSettingsOverrides: {
[projectId]: { enableConversationSummaries: false },
[adoptedProjectId]: {
enableConversationSummaries: true,
textGenerationModelSelection: adoptedModel,
},
},
};
yield* settings.updateSettings(adoptedSettings);
assert.deepEqual(yield* stalled(), []);
assert.deepInclude((yield* stalled(adoptedModelKey))[0], {
threadId,
runId: freshRunId,
retry: 1,
});
yield* sql`
UPDATE conversation_summary_passes
SET payload_json = json_set(payload_json, '$.retries', 6) WHERE thread_id = ${threadId}
`;
yield* settings.updateSettings({
projectSettingsOverrides: {
...adoptedSettings.projectSettingsOverrides,
[adoptedProjectId]: { enableConversationSummaries: false },
},
});
assert.deepEqual(yield* stalled(adoptedModelKey), []);
yield* settings.updateSettings(adoptedSettings);
assert.deepInclude((yield* stalled(adoptedModelKey))[0], {
threadId,
runId: freshRunId,
retry: 1,
});
}).pipe(Effect.provide(makeLayer(model.generate, optedIn)));
},
);
Expand Down Expand Up @@ -1344,26 +1464,60 @@ it.effect(
},
);

it.effect(
"keeps scrubbed summaries stale after a source reverts and regenerates their text",
() => {
it.effect.each([false, true])(
"keeps scrubbed summaries stale after a source reverts and regenerates their text (legacy: %s)",
(legacy) => {
const model = citing();
let sourceRead:
| { entered: Deferred.Deferred<void>; release: Deferred.Deferred<void> }
| undefined;
return Effect.gen(function* () {
yield* seed;
yield* summarize;
const summary = yield* onlySummary;
if (legacy) {
const sql = yield* SqlClient.SqlClient;
yield* sql`UPDATE conversation_summaries
SET payload_json = json_remove(payload_json, '$._revision')
WHERE summary_id = ${summary.id}`;
}
const service = yield* ConversationSummaries.ConversationSummaries;
const projections = yield* ProjectionStore.ProjectionStoreV2;
yield* projections.apply(messageEvent(0, "Changed source"));
assert.equal((yield* service.describe({ ...scope, summaryId: summary.id })).state, "stale");
yield* projections.apply(messageEvent(0, rawText(0)));
assert.equal((yield* service.describe({ ...scope, summaryId: summary.id })).state, "stale");
yield* summarize;
assert.equal(model.calls.length, 2);
const regenerated = yield* onlySummary;
assert.equal(regenerated.statements[0]!.text, summary.statements[0]!.text);
assert.notInclude(regenerated.statements[0]!.text, "Source unavailable");
}).pipe(Effect.provide(makeLayer(model.generate, optedIn)));
const gate = { entered: yield* Deferred.make<void>(), release: yield* Deferred.make<void>() };
sourceRead = gate;
const oldRead = yield* service
.describe({ ...scope, summaryId: summary.id })
.pipe(Effect.forkChild({ startImmediately: true }));
yield* Deferred.await(gate.entered);
yield* Effect.gen(function* () {
assert.equal((yield* service.describe({ ...scope, summaryId: summary.id })).state, "stale");
yield* projections.apply(messageEvent(0, rawText(0)));
assert.equal((yield* service.describe({ ...scope, summaryId: summary.id })).state, "stale");
yield* summarize;
assert.equal(model.calls.length, 2);
const regenerated = yield* onlySummary;
// A source revert can reproduce the entire public payload, even createdAt on this clock.
assert.deepEqual(regenerated, summary);
assert.notInclude(regenerated.statements[0]!.text, "Source unavailable");
}).pipe(Effect.ensuring(Deferred.succeed(gate.release, undefined)));
assert.equal((yield* Fiber.join(oldRead)).state, "stale");
assert.equal(
(yield* service.describe({ ...scope, summaryId: summary.id })).state,
"available",
);
}).pipe(
Effect.provide(
makeLayer(model.generate, optedIn, () => {
if (sourceRead === undefined) return Effect.void;
const gate = sourceRead;
sourceRead = undefined;
return Deferred.succeed(gate.entered, undefined).pipe(
Effect.andThen(Deferred.await(gate.release)),
);
}),
),
);
},
);

Expand Down Expand Up @@ -2321,6 +2475,58 @@ it.effect("hands off almost all omitted history of a 600-item thread as summarie
rawText(index),
"the six newest messages arrive word for word",
);

const sql = yield* SqlClient.SqlClient;
const originalIds = yield* sql<{ id: string }>`SELECT summary_id AS id
FROM conversation_summaries WHERE thread_id = ${threadId} ORDER BY summary_id`;
const adoptedProjectId = yield* adoptThreadProject();
for (let pass = 0, hasMore = true; hasMore; pass++) {
assert.isBelow(pass, 60, "the adopted thread converges");
hasMore = (yield* summarize).hasMore;
}
const stored = yield* sql<{ id: string; projectId: string; payloadProjectId: string }>`
SELECT summary_id AS id, project_id AS "projectId",
json_extract(payload_json, '$.projectId') AS "payloadProjectId"
FROM conversation_summaries WHERE thread_id = ${threadId} ORDER BY summary_id`;
assert.deepEqual(
stored.map((row) => row.id),
originalIds.map((row) => row.id),
);
assert.isTrue(
stored.every(
(row) => row.projectId === adoptedProjectId && row.payloadProjectId === adoptedProjectId,
),
);
const adoptedScope = { projectId: adoptedProjectId, threadId };
const adopted = yield* service.list(adoptedScope);
assert.isTrue(adopted.summaries.every((read) => read.state === "available"));
const first = adopted.summaries[0];
if (first?.state !== "available") throw new Error("Expected an adopted root summary");
let hop = first.summary;
assert.equal(hop.sources[0]?.kind, "summary");
while (hop.sources[0]?.kind === "summary") {
const page = yield* service.expand({ ...adoptedScope, summaryId: hop.id, limit: 1 });
assert.equal(page.sources[0]?.result.state, "available");
const child = yield* service.describe({
...adoptedScope,
summaryId: hop.sources[0].summaryId,
});
if (child.state !== "available") throw new Error("Expected an adopted child summary");
hop = child.summary;
}
const exact = yield* service.expand({ ...adoptedScope, summaryId: hop.id, limit: 1 });
assert.equal(
exact.sources[0]?.result.state === "available" ? exact.sources[0].result.text : null,
rawText(0),
);
assert.isAbove(
(yield* service.search({ ...adoptedScope, query: "Statement" })).summaries.length,
0,
);
assert.deepEqual((yield* service.search({ ...scope, query: "Statement" })).summaries, []);
const adoptedSpent = model.calls.length;
yield* summarize;
assert.equal(model.calls.length, adoptedSpent);
}).pipe(Effect.provide(makeLayer(model.generate, optedIn)));
});

Expand Down
Loading
Loading