claude-bot/EJClaw
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
4e05f60400696c541e61cac19a77890494d4106d
EJClaw/src/db/schema.ts

3288 lines
108 KiB
TypeScript
Raw Blame History

import { Database } from 'bun:sqlite';
import { SERVICE_SESSION_SCOPE, normalizeServiceId } from '../config.js';
import {
inferAgentTypeFromServiceShadow,
resolveRoleServiceShadow,
} from '../role-service-shadow.js';
import {
canonicalizeChannelOwnerLeaseMetadata,
canonicalizePairedTaskMetadata,
canonicalizeServiceHandoffMetadata,
inferExecutionLeaseServiceIdFromCanonicalMetadata,
} from './canonical-role-metadata.js';
import {
backfillPairedTurnAttemptsFromTurns,
buildPairedTurnAttemptId,
} from './paired-turn-attempts.js';
import { normalizeStoredAgentType } from './room-registration.js';
import {
backfillLegacyServiceSessions,
dropLegacyServiceSessionsTable,
migrateSessionsTableToCompositePk,
} from './sessions.js';
function getTableColumns(database: Database, tableName: string): string[] {
return (
database.prepare(`PRAGMA table_info(${tableName})`).all() as Array<{
name: string;
}>
).map((column) => column.name);
}
export function tableHasColumn(
database: Database,
tableName: string,
columnName: string,
): boolean {
return getTableColumns(database, tableName).includes(columnName);
}
function getTableSql(database: Database, tableName: string): string | null {
const row = database
.prepare(
`
SELECT sql
FROM sqlite_master
WHERE type = 'table'
AND name = ?
`,
)
.get(tableName) as { sql?: string | null } | undefined;
return row?.sql ?? null;
}
function tryExecMigration(database: Database, sql: string): void {
try {
database.exec(sql);
} catch {
/* column already exists */
}
}
function buildPairedTurnAttemptIdSql(
turnIdExpr: string,
attemptNoExpr: string,
): string {
return `${turnIdExpr} || ':attempt:' || CAST(${attemptNoExpr} AS TEXT)`;
}
function buildPairedTurnAttemptParentIdSql(
turnIdExpr: string,
attemptNoExpr: string,
): string {
return `CASE
WHEN ${attemptNoExpr} <= 1 THEN NULL
ELSE ${buildPairedTurnAttemptIdSql(turnIdExpr, `(${attemptNoExpr}) - 1`)}
END`;
}
function buildPairedTurnAttemptParentHandoffMatchSql(args: {
parentHandoffIdExpr: string;
turnIdExpr: string;
parentAttemptIdExpr: string;
attemptNoExpr: string;
}): string {
return `EXISTS (
SELECT 1
FROM service_handoffs
WHERE service_handoffs.id = ${args.parentHandoffIdExpr}
AND service_handoffs.turn_id = ${args.turnIdExpr}
AND service_handoffs.status = 'failed'
AND (
service_handoffs.turn_attempt_id = ${args.parentAttemptIdExpr}
OR (
service_handoffs.turn_attempt_id IS NULL
AND service_handoffs.turn_attempt_no = (${args.attemptNoExpr}) - 1
)
)
)`;
}
function buildPairedTurnAttemptContinuationHandoffMatchSql(args: {
continuationHandoffIdExpr: string;
turnIdExpr: string;
attemptIdExpr: string;
attemptNoExpr: string;
}): string {
return `EXISTS (
SELECT 1
FROM service_handoffs
WHERE service_handoffs.id = ${args.continuationHandoffIdExpr}
AND service_handoffs.turn_id = ${args.turnIdExpr}
AND (
service_handoffs.turn_attempt_id = ${args.attemptIdExpr}
OR (
service_handoffs.turn_attempt_id IS NULL
AND service_handoffs.turn_attempt_no = ${args.attemptNoExpr}
)
)
)`;
}
function tableHasForeignKey(
database: Database,
args: {
tableName: string;
referencedTable: string;
fromColumns: string[];
toColumns: string[];
onDelete?: string;
},
): boolean {
const rows = database
.prepare(`PRAGMA foreign_key_list(${args.tableName})`)
.all() as Array<{
id: number;
seq: number;
table: string;
from: string;
to: string;
on_delete: string;
}>;
if (rows.length === 0) {
return false;
}
const byId = new Map<number, typeof rows>();
for (const row of rows) {
const group = byId.get(row.id) ?? [];
group.push(row);
byId.set(row.id, group);
}
for (const group of byId.values()) {
const sorted = [...group].sort((left, right) => left.seq - right.seq);
if (sorted.length !== args.fromColumns.length) {
continue;
}
if (sorted[0]!.table !== args.referencedTable) {
continue;
}
if (
args.onDelete &&
sorted[0]!.on_delete.toUpperCase() !== args.onDelete.toUpperCase()
) {
continue;
}
const matches = sorted.every((row, index) => {
return (
row.from === args.fromColumns[index] && row.to === args.toColumns[index]
);
});
if (matches) {
return true;
}
}
return false;
}
function backfillMessageSeq(database: Database): void {
const rows = database
.prepare(
`SELECT rowid, seq
FROM messages
ORDER BY CASE WHEN seq IS NULL THEN 1 ELSE 0 END, seq, timestamp, rowid`,
)
.all() as Array<{ rowid: number; seq: number | null }>;
if (rows.length === 0) {
return;
}
let nextSeq = 1;
const assignSeq = database.prepare(
'UPDATE messages SET seq = ? WHERE rowid = ? AND seq IS NULL',
);
const tx = database.transaction(() => {
for (const row of rows) {
if (row.seq === null) {
assignSeq.run(nextSeq, row.rowid);
}
nextSeq = Math.max(nextSeq, (row.seq ?? nextSeq) + 1);
}
});
tx();
const maxSeqRow = database
.prepare('SELECT MAX(seq) AS maxSeq FROM messages')
.get() as { maxSeq: number | null };
const maxSeq = maxSeqRow.maxSeq ?? 0;
if (maxSeq > 0) {
database
.prepare('INSERT OR IGNORE INTO message_sequence (id) VALUES (?)')
.run(maxSeq);
}
}
interface LegacyExecutionLeaseServiceRow {
rowid: number;
role: string;
owner_service_id?: string | null;
reviewer_service_id?: string | null;
arbiter_service_id?: string | null;
owner_agent_type?: string | null;
reviewer_agent_type?: string | null;
arbiter_agent_type?: string | null;
}
interface StoredPairedTaskServiceRow {
rowid: number;
id: string;
chat_jid: string;
group_folder: string;
owner_service_id?: string | null;
reviewer_service_id?: string | null;
owner_agent_type?: string | null;
reviewer_agent_type?: string | null;
arbiter_agent_type?: string | null;
}
interface StoredChannelOwnerLeaseServiceRow {
rowid: number;
chat_jid: string;
owner_service_id?: string | null;
reviewer_service_id?: string | null;
arbiter_service_id?: string | null;
owner_agent_type?: string | null;
reviewer_agent_type?: string | null;
arbiter_agent_type?: string | null;
}
interface StoredServiceHandoffServiceRow {
id: number;
chat_jid: string;
group_folder: string;
source_service_id?: string | null;
target_service_id?: string | null;
source_role?: string | null;
target_role?: string | null;
source_agent_type?: string | null;
target_agent_type?: string | null;
intended_role?: string | null;
}
interface PairedTurnAttemptTimingRow {
turn_id: string;
attempt_no: number;
created_at: string;
}
interface PairedTurnAttemptTiming {
attemptNo: number;
createdAtMs: number;
}
function parseBackfillTimestampMs(
value: string | null | undefined,
): number | null {
if (!value) {
return null;
}
const trimmed = value.trim();
if (trimmed.length === 0) {
return null;
}
let normalized = trimmed.includes('T') ? trimmed : trimmed.replace(' ', 'T');
if (!/[zZ]|[+-]\d{2}:\d{2}$/.test(normalized)) {
normalized = `${normalized}Z`;
}
const parsed = Date.parse(normalized);
return Number.isNaN(parsed) ? null : parsed;
}
function getPairedTurnAttemptTimingsByTurnId(
database: Database,
): Map<string, PairedTurnAttemptTiming[]> {
const rows = database
.prepare(
`
SELECT turn_id, attempt_no, created_at
FROM paired_turn_attempts
WHERE attempt_no >= 1
ORDER BY turn_id ASC, attempt_no ASC
`,
)
.all() as PairedTurnAttemptTimingRow[];
const timingsByTurnId = new Map<string, PairedTurnAttemptTiming[]>();
for (const row of rows) {
const createdAtMs = parseBackfillTimestampMs(row.created_at);
if (createdAtMs === null) {
throw new Error(
`paired_turn_attempts(${row.turn_id}, attempt=${row.attempt_no}) has an invalid created_at timestamp`,
);
}
const timings = timingsByTurnId.get(row.turn_id) ?? [];
timings.push({
attemptNo: row.attempt_no,
createdAtMs,
});
timingsByTurnId.set(row.turn_id, timings);
}
return timingsByTurnId;
}
function resolveAttemptNoForBackfill(
args: {
turnId: string;
eventTimestamp: string | null | undefined;
rowLabel: string;
},
timingsByTurnId: Map<string, PairedTurnAttemptTiming[]>,
): number | null {
const attemptTimings = timingsByTurnId.get(args.turnId) ?? [];
if (attemptTimings.length === 0) {
return null;
}
if (attemptTimings.length === 1) {
return attemptTimings[0]!.attemptNo;
}
const eventAtMs = parseBackfillTimestampMs(args.eventTimestamp);
if (eventAtMs === null) {
throw new Error(
`${args.rowLabel} has turn_id=${args.turnId} but no timestamp that can be mapped to a specific attempt`,
);
}
const exactMatches = attemptTimings.filter((timing, index) => {
const nextTiming = attemptTimings[index + 1];
return (
eventAtMs >= timing.createdAtMs &&
(nextTiming === undefined || eventAtMs < nextTiming.createdAtMs)
);
});
if (exactMatches.length === 1) {
return exactMatches[0]!.attemptNo;
}
if (exactMatches.length > 1) {
throw new Error(
`${args.rowLabel} has an ambiguous exact timestamp match for turn_id=${args.turnId}`,
);
}
const eventAtSecond = Math.floor(eventAtMs / 1000);
const secondPrecisionMatches = attemptTimings.filter((timing, index) => {
const nextTiming = attemptTimings[index + 1];
const timingSecond = Math.floor(timing.createdAtMs / 1000);
const nextTimingSecond =
nextTiming === undefined
? null
: Math.floor(nextTiming.createdAtMs / 1000);
return (
eventAtSecond >= timingSecond &&
(nextTimingSecond === null || eventAtSecond < nextTimingSecond)
);
});
if (secondPrecisionMatches.length === 1) {
return secondPrecisionMatches[0]!.attemptNo;
}
if (secondPrecisionMatches.length > 1) {
throw new Error(
`${args.rowLabel} has an ambiguous second-precision timestamp match for turn_id=${args.turnId}`,
);
}
throw new Error(
`${args.rowLabel} could not be mapped to a specific attempt for turn_id=${args.turnId}`,
);
}
function backfillPairedTurnAttemptIds(database: Database): void {
if (!tableHasColumn(database, 'paired_turn_attempts', 'attempt_id')) {
return;
}
database.exec(`
UPDATE paired_turn_attempts
SET attempt_id = ${buildPairedTurnAttemptIdSql('turn_id', 'attempt_no')}
WHERE attempt_id IS NULL
OR TRIM(attempt_id) = ''
`);
}
function backfillPairedTurnAttemptParentIds(database: Database): void {
if (!tableHasColumn(database, 'paired_turn_attempts', 'parent_attempt_id')) {
return;
}
database.exec(`
UPDATE paired_turn_attempts
SET parent_attempt_id = ${buildPairedTurnAttemptParentIdSql('turn_id', 'attempt_no')}
WHERE attempt_no > 1
AND EXISTS (
SELECT 1
FROM paired_turn_attempts previous_attempt
WHERE previous_attempt.turn_id = paired_turn_attempts.turn_id
AND previous_attempt.attempt_no = paired_turn_attempts.attempt_no - 1
)
AND (
parent_attempt_id IS NULL
OR TRIM(parent_attempt_id) = ''
OR parent_attempt_id != ${buildPairedTurnAttemptParentIdSql('turn_id', 'attempt_no')}
)
`);
database.exec(`
UPDATE paired_turn_attempts
SET parent_attempt_id = NULL
WHERE attempt_no <= 1
AND parent_attempt_id IS NOT NULL
`);
}
function backfillPairedTurnAttemptActiveRunIds(database: Database): void {
if (!tableHasColumn(database, 'paired_turn_attempts', 'active_run_id')) {
return;
}
const pairedTurnsActiveRunIdExists = tableHasColumn(
database,
'paired_turns',
'active_run_id',
);
const leaseTurnIdExists = tableHasColumn(
database,
'paired_task_execution_leases',
'turn_id',
);
const leaseTurnAttemptNoExists = tableHasColumn(
database,
'paired_task_execution_leases',
'turn_attempt_no',
);
const leaseActiveRunIdSql = leaseTurnIdExists
? leaseTurnAttemptNoExists
? `COALESCE(
(
SELECT paired_task_execution_leases.claimed_run_id
FROM paired_task_execution_leases
WHERE paired_task_execution_leases.turn_id = paired_turn_attempts.turn_id
AND paired_task_execution_leases.turn_attempt_no = paired_turn_attempts.attempt_no
ORDER BY paired_task_execution_leases.updated_at DESC,
paired_task_execution_leases.claimed_at DESC
LIMIT 1
),
(
SELECT paired_task_execution_leases.claimed_run_id
FROM paired_task_execution_leases
WHERE paired_task_execution_leases.turn_id = paired_turn_attempts.turn_id
AND paired_task_execution_leases.turn_attempt_no IS NULL
ORDER BY paired_task_execution_leases.updated_at DESC,
paired_task_execution_leases.claimed_at DESC
LIMIT 1
)
)`
: `(
SELECT paired_task_execution_leases.claimed_run_id
FROM paired_task_execution_leases
WHERE paired_task_execution_leases.turn_id = paired_turn_attempts.turn_id
ORDER BY paired_task_execution_leases.updated_at DESC,
paired_task_execution_leases.claimed_at DESC
LIMIT 1
)`
: 'NULL';
const legacyTurnActiveRunIdSql = pairedTurnsActiveRunIdExists
? `(
SELECT paired_turns.active_run_id
FROM paired_turns
WHERE paired_turns.turn_id = paired_turn_attempts.turn_id
)`
: 'NULL';
database.exec(`
UPDATE paired_turn_attempts
SET active_run_id = COALESCE(
active_run_id,
CASE
WHEN state = 'running'
THEN COALESCE(
${leaseActiveRunIdSql},
${legacyTurnActiveRunIdSql}
)
ELSE NULL
END
)
WHERE state = 'running'
AND (active_run_id IS NULL OR TRIM(active_run_id) = '')
`);
database.exec(`
UPDATE paired_turn_attempts
SET active_run_id = NULL
WHERE state != 'running'
AND active_run_id IS NOT NULL
`);
}
function backfillPairedTurnAttemptEntityIds(database: Database): void {
if (
tableHasColumn(database, 'paired_turn_reservations', 'turn_attempt_id') &&
tableHasColumn(database, 'paired_turn_reservations', 'turn_attempt_no')
) {
database.exec(`
UPDATE paired_turn_reservations
SET turn_attempt_id = (
SELECT paired_turn_attempts.attempt_id
FROM paired_turn_attempts
WHERE paired_turn_attempts.turn_id = paired_turn_reservations.turn_id
AND paired_turn_attempts.attempt_no = paired_turn_reservations.turn_attempt_no
)
WHERE turn_attempt_no IS NOT NULL
AND (turn_attempt_id IS NULL OR TRIM(turn_attempt_id) = '')
`);
}
if (
tableHasColumn(
database,
'paired_task_execution_leases',
'turn_attempt_id',
) &&
tableHasColumn(database, 'paired_task_execution_leases', 'turn_attempt_no')
) {
database.exec(`
UPDATE paired_task_execution_leases
SET turn_attempt_id = (
SELECT paired_turn_attempts.attempt_id
FROM paired_turn_attempts
WHERE paired_turn_attempts.turn_id = paired_task_execution_leases.turn_id
AND paired_turn_attempts.attempt_no = paired_task_execution_leases.turn_attempt_no
)
WHERE turn_attempt_no IS NOT NULL
AND (turn_attempt_id IS NULL OR TRIM(turn_attempt_id) = '')
`);
}
if (
tableHasColumn(database, 'service_handoffs', 'turn_attempt_id') &&
tableHasColumn(database, 'service_handoffs', 'turn_attempt_no')
) {
database.exec(`
UPDATE service_handoffs
SET turn_attempt_id = (
SELECT paired_turn_attempts.attempt_id
FROM paired_turn_attempts
WHERE paired_turn_attempts.turn_id = service_handoffs.turn_id
AND paired_turn_attempts.attempt_no = service_handoffs.turn_attempt_no
)
WHERE turn_attempt_no IS NOT NULL
AND (turn_attempt_id IS NULL OR TRIM(turn_attempt_id) = '')
`);
}
}
function backfillPairedTurnAttemptProvenance(database: Database): void {
const timingsByTurnId = getPairedTurnAttemptTimingsByTurnId(database);
if (tableHasColumn(database, 'paired_turn_reservations', 'turn_attempt_no')) {
const hasTurnAttemptIdColumn = tableHasColumn(
database,
'paired_turn_reservations',
'turn_attempt_id',
);
const rows = database
.prepare(
`
SELECT rowid, turn_id, status, created_at, updated_at, consumed_at
FROM paired_turn_reservations
WHERE turn_id IS NOT NULL
AND turn_attempt_no IS NULL
`,
)
.all() as Array<{
rowid: number;
turn_id: string;
status: string;
created_at: string | null;
updated_at: string | null;
consumed_at: string | null;
}>;
const update = hasTurnAttemptIdColumn
? database.prepare(
'UPDATE paired_turn_reservations SET turn_attempt_id = ?, turn_attempt_no = ? WHERE rowid = ?',
)
: database.prepare(
'UPDATE paired_turn_reservations SET turn_attempt_no = ? WHERE rowid = ?',
);
for (const row of rows) {
if (row.status !== 'completed') {
continue;
}
const attemptNo = resolveAttemptNoForBackfill(
{
turnId: row.turn_id,
eventTimestamp: row.consumed_at ?? row.updated_at ?? row.created_at,
rowLabel: `paired_turn_reservations(rowid=${row.rowid})`,
},
timingsByTurnId,
);
if (attemptNo !== null) {
const attemptId = buildPairedTurnAttemptId(row.turn_id, attemptNo);
if (hasTurnAttemptIdColumn) {
update.run(attemptId, attemptNo, row.rowid);
} else {
update.run(attemptNo, row.rowid);
}
}
}
}
if (
tableHasColumn(database, 'paired_task_execution_leases', 'turn_attempt_no')
) {
const hasTurnAttemptIdColumn = tableHasColumn(
database,
'paired_task_execution_leases',
'turn_attempt_id',
);
const rows = database
.prepare(
`
SELECT rowid, turn_id, claimed_at, updated_at
FROM paired_task_execution_leases
WHERE turn_id IS NOT NULL
AND turn_attempt_no IS NULL
`,
)
.all() as Array<{
rowid: number;
turn_id: string;
claimed_at: string | null;
updated_at: string | null;
}>;
const update = hasTurnAttemptIdColumn
? database.prepare(
'UPDATE paired_task_execution_leases SET turn_attempt_id = ?, turn_attempt_no = ? WHERE rowid = ?',
)
: database.prepare(
'UPDATE paired_task_execution_leases SET turn_attempt_no = ? WHERE rowid = ?',
);
for (const row of rows) {
const attemptNo = resolveAttemptNoForBackfill(
{
turnId: row.turn_id,
eventTimestamp: row.updated_at ?? row.claimed_at,
rowLabel: `paired_task_execution_leases(rowid=${row.rowid})`,
},
timingsByTurnId,
);
if (attemptNo !== null) {
const attemptId = buildPairedTurnAttemptId(row.turn_id, attemptNo);
if (hasTurnAttemptIdColumn) {
update.run(attemptId, attemptNo, row.rowid);
} else {
update.run(attemptNo, row.rowid);
}
}
}
}
if (tableHasColumn(database, 'service_handoffs', 'turn_attempt_no')) {
const hasTurnAttemptIdColumn = tableHasColumn(
database,
'service_handoffs',
'turn_attempt_id',
);
const rows = database
.prepare(
`
SELECT id, turn_id, created_at, claimed_at, completed_at
FROM service_handoffs
WHERE turn_id IS NOT NULL
AND turn_attempt_no IS NULL
`,
)
.all() as Array<{
id: number;
turn_id: string;
created_at: string | null;
claimed_at: string | null;
completed_at: string | null;
}>;
const update = hasTurnAttemptIdColumn
? database.prepare(
'UPDATE service_handoffs SET turn_attempt_id = ?, turn_attempt_no = ? WHERE id = ?',
)
: database.prepare(
'UPDATE service_handoffs SET turn_attempt_no = ? WHERE id = ?',
);
for (const row of rows) {
const attemptNo = resolveAttemptNoForBackfill(
{
turnId: row.turn_id,
eventTimestamp: row.completed_at ?? row.claimed_at ?? row.created_at,
rowLabel: `service_handoffs(id=${row.id})`,
},
timingsByTurnId,
);
if (attemptNo !== null) {
const attemptId = buildPairedTurnAttemptId(row.turn_id, attemptNo);
if (hasTurnAttemptIdColumn) {
update.run(attemptId, attemptNo, row.id);
} else {
update.run(attemptNo, row.id);
}
}
}
}
}
function assertPairedTurnAttemptProvenanceIntegrity(database: Database): void {
if (tableHasColumn(database, 'paired_turn_attempts', 'attempt_id')) {
const invalidAttemptIdRow = database
.prepare(
`
SELECT turn_id, attempt_no, attempt_id
FROM paired_turn_attempts
WHERE attempt_id IS NULL
OR attempt_id != ${buildPairedTurnAttemptIdSql('turn_id', 'attempt_no')}
LIMIT 1
`,
)
.get() as
| {
turn_id: string;
attempt_no: number;
attempt_id: string | null;
}
| undefined;
if (invalidAttemptIdRow) {
throw new Error(
`paired_turn_attempts(${invalidAttemptIdRow.turn_id}, attempt=${invalidAttemptIdRow.attempt_no}) has invalid attempt_id provenance`,
);
}
}
if (tableHasColumn(database, 'paired_turn_attempts', 'parent_attempt_id')) {
const invalidParentAttemptRow = database
.prepare(
`
SELECT turn_id, attempt_no, parent_attempt_id
FROM paired_turn_attempts
WHERE (
attempt_no <= 1
AND parent_attempt_id IS NOT NULL
)
OR (
attempt_no > 1
AND NOT EXISTS (
SELECT 1
FROM paired_turn_attempts previous_attempt
WHERE previous_attempt.turn_id = paired_turn_attempts.turn_id
AND previous_attempt.attempt_no = paired_turn_attempts.attempt_no - 1
)
)
OR (
attempt_no > 1
AND (
parent_attempt_id IS NULL
OR parent_attempt_id != ${buildPairedTurnAttemptParentIdSql('turn_id', 'attempt_no')}
OR NOT EXISTS (
SELECT 1
FROM paired_turn_attempts previous_attempt
WHERE COALESCE(
previous_attempt.attempt_id,
${buildPairedTurnAttemptIdSql(
'previous_attempt.turn_id',
'previous_attempt.attempt_no',
)}
) = paired_turn_attempts.parent_attempt_id
AND previous_attempt.turn_id = paired_turn_attempts.turn_id
AND previous_attempt.attempt_no = paired_turn_attempts.attempt_no - 1
)
)
)
LIMIT 1
`,
)
.get() as
| {
turn_id: string;
attempt_no: number;
parent_attempt_id: string | null;
}
| undefined;
if (invalidParentAttemptRow) {
throw new Error(
`paired_turn_attempts(${invalidParentAttemptRow.turn_id}, attempt=${invalidParentAttemptRow.attempt_no}) has invalid parent_attempt_id provenance`,
);
}
}
if (tableHasColumn(database, 'paired_turn_attempts', 'parent_handoff_id')) {
const invalidParentHandoffRow = database
.prepare(
`
SELECT turn_id, attempt_no, parent_handoff_id
FROM paired_turn_attempts
WHERE parent_handoff_id IS NOT NULL
AND (
attempt_no <= 1
OR NOT ${buildPairedTurnAttemptParentHandoffMatchSql({
parentHandoffIdExpr: 'paired_turn_attempts.parent_handoff_id',
turnIdExpr: 'paired_turn_attempts.turn_id',
parentAttemptIdExpr: 'paired_turn_attempts.parent_attempt_id',
attemptNoExpr: 'paired_turn_attempts.attempt_no',
})}
)
LIMIT 1
`,
)
.get() as
| {
turn_id: string;
attempt_no: number;
parent_handoff_id: number | null;
}
| undefined;
if (invalidParentHandoffRow) {
throw new Error(
`paired_turn_attempts(${invalidParentHandoffRow.turn_id}, attempt=${invalidParentHandoffRow.attempt_no}) has invalid parent_handoff_id provenance`,
);
}
}
if (
tableHasColumn(database, 'paired_turn_attempts', 'continuation_handoff_id')
) {
const invalidContinuationHandoffRow = database
.prepare(
`
SELECT turn_id, attempt_no, continuation_handoff_id
FROM paired_turn_attempts
WHERE continuation_handoff_id IS NOT NULL
AND NOT ${buildPairedTurnAttemptContinuationHandoffMatchSql({
continuationHandoffIdExpr:
'paired_turn_attempts.continuation_handoff_id',
turnIdExpr: 'paired_turn_attempts.turn_id',
attemptIdExpr:
"COALESCE(paired_turn_attempts.attempt_id, paired_turn_attempts.turn_id || ':attempt:' || CAST(paired_turn_attempts.attempt_no AS TEXT))",
attemptNoExpr: 'paired_turn_attempts.attempt_no',
})}
LIMIT 1
`,
)
.get() as
| {
turn_id: string;
attempt_no: number;
continuation_handoff_id: number | null;
}
| undefined;
if (invalidContinuationHandoffRow) {
throw new Error(
`paired_turn_attempts(${invalidContinuationHandoffRow.turn_id}, attempt=${invalidContinuationHandoffRow.attempt_no}) has invalid continuation_handoff_id provenance`,
);
}
}
const invalidAttemptRow = database
.prepare(
`
SELECT turn_id, attempt_no
FROM paired_turn_attempts
WHERE NOT EXISTS (
SELECT 1
FROM paired_turns
WHERE paired_turns.turn_id = paired_turn_attempts.turn_id
AND paired_turns.task_id = paired_turn_attempts.task_id
AND paired_turns.task_updated_at = paired_turn_attempts.task_updated_at
AND paired_turns.role = paired_turn_attempts.role
AND paired_turns.intent_kind = paired_turn_attempts.intent_kind
)
LIMIT 1
`,
)
.get() as
| {
turn_id: string;
attempt_no: number;
}
| undefined;
if (invalidAttemptRow) {
throw new Error(
`paired_turn_attempts(${invalidAttemptRow.turn_id}, attempt=${invalidAttemptRow.attempt_no}) does not match its paired_turns identity`,
);
}
if (tableHasColumn(database, 'paired_turn_attempts', 'active_run_id')) {
const invalidAttemptActiveRunRow = database
.prepare(
`
SELECT turn_id, attempt_no
FROM paired_turn_attempts
WHERE (
state = 'running'
AND (
active_run_id IS NULL
OR TRIM(active_run_id) = ''
)
)
OR (
state != 'running'
AND active_run_id IS NOT NULL
)
LIMIT 1
`,
)
.get() as
| {
turn_id: string;
attempt_no: number;
}
| undefined;
if (invalidAttemptActiveRunRow) {
throw new Error(
`paired_turn_attempts(${invalidAttemptActiveRunRow.turn_id}, attempt=${invalidAttemptActiveRunRow.attempt_no}) has invalid active_run_id provenance`,
);
}
}
if (tableHasColumn(database, 'paired_turn_reservations', 'turn_attempt_no')) {
const invalidReservation = database
.prepare(
`
SELECT rowid
FROM paired_turn_reservations
WHERE turn_attempt_no IS NOT NULL
AND (
turn_id IS NULL
OR (turn_attempt_id IS NULL AND ${tableHasColumn(database, 'paired_turn_reservations', 'turn_attempt_id') ? '1 = 1' : '0 = 1'})
OR NOT EXISTS (
SELECT 1
FROM paired_turn_attempts
WHERE paired_turn_attempts.turn_id = paired_turn_reservations.turn_id
AND paired_turn_attempts.attempt_no = paired_turn_reservations.turn_attempt_no
${
tableHasColumn(
database,
'paired_turn_reservations',
'turn_attempt_id',
)
? 'AND paired_turn_attempts.attempt_id = paired_turn_reservations.turn_attempt_id'
: ''
}
AND paired_turn_attempts.task_id = paired_turn_reservations.task_id
AND paired_turn_attempts.task_updated_at = paired_turn_reservations.task_updated_at
AND paired_turn_attempts.role = paired_turn_reservations.turn_role
AND paired_turn_attempts.intent_kind = paired_turn_reservations.intent_kind
)
)
LIMIT 1
`,
)
.get() as { rowid: number } | undefined;
if (invalidReservation) {
throw new Error(
`paired_turn_reservations(rowid=${invalidReservation.rowid}) has invalid paired_turn_attempt provenance`,
);
}
}
if (
tableHasColumn(database, 'paired_task_execution_leases', 'turn_attempt_no')
) {
const invalidLease = database
.prepare(
`
SELECT rowid
FROM paired_task_execution_leases
WHERE turn_attempt_no IS NOT NULL
AND (
turn_id IS NULL
OR (turn_attempt_id IS NULL AND ${tableHasColumn(database, 'paired_task_execution_leases', 'turn_attempt_id') ? '1 = 1' : '0 = 1'})
OR NOT EXISTS (
SELECT 1
FROM paired_turn_attempts
WHERE paired_turn_attempts.turn_id = paired_task_execution_leases.turn_id
AND paired_turn_attempts.attempt_no = paired_task_execution_leases.turn_attempt_no
${
tableHasColumn(
database,
'paired_task_execution_leases',
'turn_attempt_id',
)
? 'AND paired_turn_attempts.attempt_id = paired_task_execution_leases.turn_attempt_id'
: ''
}
AND paired_turn_attempts.task_id = paired_task_execution_leases.task_id
AND paired_turn_attempts.task_updated_at = paired_task_execution_leases.task_updated_at
AND paired_turn_attempts.role = paired_task_execution_leases.role
AND paired_turn_attempts.intent_kind = paired_task_execution_leases.intent_kind
)
)
LIMIT 1
`,
)
.get() as { rowid: number } | undefined;
if (invalidLease) {
throw new Error(
`paired_task_execution_leases(rowid=${invalidLease.rowid}) has invalid paired_turn_attempt provenance`,
);
}
}
if (tableHasColumn(database, 'service_handoffs', 'turn_attempt_no')) {
const invalidHandoff = database
.prepare(
`
SELECT id
FROM service_handoffs
WHERE turn_attempt_no IS NOT NULL
AND (
turn_id IS NULL
OR (turn_attempt_id IS NULL AND ${tableHasColumn(database, 'service_handoffs', 'turn_attempt_id') ? '1 = 1' : '0 = 1'})
OR paired_task_id IS NULL
OR paired_task_updated_at IS NULL
OR turn_role IS NULL
OR turn_intent_kind IS NULL
OR NOT EXISTS (
SELECT 1
FROM paired_turn_attempts
WHERE paired_turn_attempts.turn_id = service_handoffs.turn_id
AND paired_turn_attempts.attempt_no = service_handoffs.turn_attempt_no
${
tableHasColumn(
database,
'service_handoffs',
'turn_attempt_id',
)
? 'AND paired_turn_attempts.attempt_id = service_handoffs.turn_attempt_id'
: ''
}
AND paired_turn_attempts.task_id = service_handoffs.paired_task_id
AND paired_turn_attempts.task_updated_at = service_handoffs.paired_task_updated_at
AND paired_turn_attempts.role = service_handoffs.turn_role
AND paired_turn_attempts.intent_kind = service_handoffs.turn_intent_kind
)
)
LIMIT 1
`,
)
.get() as { id: number } | undefined;
if (invalidHandoff) {
throw new Error(
`service_handoffs(id=${invalidHandoff.id}) has invalid paired_turn_attempt provenance`,
);
}
}
}
function rebuildPairedTurnAttemptsWithForeignKeys(database: Database): void {
const tableSql = getTableSql(database, 'paired_turn_attempts') ?? '';
if (
tableHasColumn(database, 'paired_turn_attempts', 'attempt_id') &&
tableHasColumn(database, 'paired_turn_attempts', 'parent_attempt_id') &&
tableHasColumn(database, 'paired_turn_attempts', 'parent_handoff_id') &&
tableHasColumn(
database,
'paired_turn_attempts',
'continuation_handoff_id',
) &&
tableSql.includes('attempt_id TEXT NOT NULL PRIMARY KEY') &&
tableSql.includes('parent_attempt_id TEXT') &&
tableSql.includes('parent_handoff_id INTEGER') &&
tableSql.includes('continuation_handoff_id INTEGER') &&
tableSql.includes('UNIQUE (turn_id, attempt_no)') &&
tableHasForeignKey(database, {
tableName: 'paired_turn_attempts',
referencedTable: 'paired_turn_attempts',
fromColumns: ['parent_attempt_id'],
toColumns: ['attempt_id'],
onDelete: 'CASCADE',
}) &&
tableHasForeignKey(database, {
tableName: 'paired_turn_attempts',
referencedTable: 'service_handoffs',
fromColumns: ['parent_handoff_id'],
toColumns: ['id'],
onDelete: 'SET NULL',
}) &&
tableHasForeignKey(database, {
tableName: 'paired_turn_attempts',
referencedTable: 'service_handoffs',
fromColumns: ['continuation_handoff_id'],
toColumns: ['id'],
onDelete: 'SET NULL',
}) &&
tableHasForeignKey(database, {
tableName: 'paired_turn_attempts',
referencedTable: 'paired_turns',
fromColumns: ['turn_id'],
toColumns: ['turn_id'],
onDelete: 'CASCADE',
})
) {
return;
}
const parentAttemptIdSelectSql = tableHasColumn(
database,
'paired_turn_attempts',
'parent_attempt_id',
)
? `COALESCE(
parent_attempt_id,
CASE
WHEN attempt_no > 1
AND EXISTS (
SELECT 1
FROM paired_turn_attempts previous_attempt
WHERE previous_attempt.turn_id = paired_turn_attempts.turn_id
AND previous_attempt.attempt_no = paired_turn_attempts.attempt_no - 1
)
THEN ${buildPairedTurnAttemptParentIdSql('turn_id', 'attempt_no')}
ELSE NULL
END
)`
: `CASE
WHEN attempt_no > 1
AND EXISTS (
SELECT 1
FROM paired_turn_attempts previous_attempt
WHERE previous_attempt.turn_id = paired_turn_attempts.turn_id
AND previous_attempt.attempt_no = paired_turn_attempts.attempt_no - 1
)
THEN ${buildPairedTurnAttemptParentIdSql('turn_id', 'attempt_no')}
ELSE NULL
END`;
const parentHandoffIdSelectSql = tableHasColumn(
database,
'paired_turn_attempts',
'parent_handoff_id',
)
? 'parent_handoff_id'
: 'NULL';
const continuationHandoffIdSelectSql = tableHasColumn(
database,
'paired_turn_attempts',
'continuation_handoff_id',
)
? 'continuation_handoff_id'
: 'NULL';
const activeRunIdSelectSql = tableHasColumn(
database,
'paired_turn_attempts',
'active_run_id',
)
? `CASE
WHEN state = 'running' THEN active_run_id
ELSE NULL
END`
: `CASE
WHEN state = 'running'
THEN ${
tableHasColumn(database, 'paired_turns', 'active_run_id')
? `COALESCE(
${
tableHasColumn(
database,
'paired_task_execution_leases',
'turn_attempt_no',
)
? `COALESCE(
(
SELECT paired_task_execution_leases.claimed_run_id
FROM paired_task_execution_leases
WHERE paired_task_execution_leases.turn_id = paired_turn_attempts.turn_id
AND paired_task_execution_leases.turn_attempt_no = paired_turn_attempts.attempt_no
ORDER BY paired_task_execution_leases.updated_at DESC,
paired_task_execution_leases.claimed_at DESC
LIMIT 1
),
(
SELECT paired_task_execution_leases.claimed_run_id
FROM paired_task_execution_leases
WHERE paired_task_execution_leases.turn_id = paired_turn_attempts.turn_id
AND paired_task_execution_leases.turn_attempt_no IS NULL
ORDER BY paired_task_execution_leases.updated_at DESC,
paired_task_execution_leases.claimed_at DESC
LIMIT 1
)
)`
: `(
SELECT paired_task_execution_leases.claimed_run_id
FROM paired_task_execution_leases
WHERE paired_task_execution_leases.turn_id = paired_turn_attempts.turn_id
ORDER BY paired_task_execution_leases.updated_at DESC,
paired_task_execution_leases.claimed_at DESC
LIMIT 1
)`
},
(
SELECT paired_turns.active_run_id
FROM paired_turns
WHERE paired_turns.turn_id = paired_turn_attempts.turn_id
)
)`
: `(
${
tableHasColumn(
database,
'paired_task_execution_leases',
'turn_attempt_no',
)
? `COALESCE(
(
SELECT paired_task_execution_leases.claimed_run_id
FROM paired_task_execution_leases
WHERE paired_task_execution_leases.turn_id = paired_turn_attempts.turn_id
AND paired_task_execution_leases.turn_attempt_no = paired_turn_attempts.attempt_no
ORDER BY paired_task_execution_leases.updated_at DESC,
paired_task_execution_leases.claimed_at DESC
LIMIT 1
),
(
SELECT paired_task_execution_leases.claimed_run_id
FROM paired_task_execution_leases
WHERE paired_task_execution_leases.turn_id = paired_turn_attempts.turn_id
AND paired_task_execution_leases.turn_attempt_no IS NULL
ORDER BY paired_task_execution_leases.updated_at DESC,
paired_task_execution_leases.claimed_at DESC
LIMIT 1
)
)`
: `(
SELECT paired_task_execution_leases.claimed_run_id
FROM paired_task_execution_leases
WHERE paired_task_execution_leases.turn_id = paired_turn_attempts.turn_id
ORDER BY paired_task_execution_leases.updated_at DESC,
paired_task_execution_leases.claimed_at DESC
LIMIT 1
)`
}`
}
ELSE NULL
END`;
database.transaction(() => {
database.exec(`
CREATE TABLE paired_turn_attempts_new (
attempt_id TEXT NOT NULL PRIMARY KEY,
parent_attempt_id TEXT,
parent_handoff_id INTEGER,
continuation_handoff_id INTEGER,
turn_id TEXT NOT NULL,
attempt_no INTEGER NOT NULL,
task_id TEXT NOT NULL,
task_updated_at TEXT NOT NULL,
role TEXT NOT NULL,
intent_kind TEXT NOT NULL,
state TEXT NOT NULL,
executor_service_id TEXT,
executor_agent_type TEXT,
active_run_id TEXT,
created_at TEXT NOT NULL,
updated_at TEXT NOT NULL,
completed_at TEXT,
last_error TEXT,
UNIQUE (turn_id, attempt_no),
FOREIGN KEY (parent_attempt_id)
REFERENCES paired_turn_attempts_new(attempt_id)
ON DELETE CASCADE,
FOREIGN KEY (parent_handoff_id)
REFERENCES service_handoffs(id)
ON DELETE SET NULL,
FOREIGN KEY (continuation_handoff_id)
REFERENCES service_handoffs(id)
ON DELETE SET NULL,
FOREIGN KEY (turn_id) REFERENCES paired_turns(turn_id) ON DELETE CASCADE,
CHECK (role IN ('owner', 'reviewer', 'arbiter')),
CHECK (
intent_kind IN (
'owner-turn',
'reviewer-turn',
'arbiter-turn',
'owner-follow-up',
'finalize-owner-turn'
)
),
CHECK (
state IN (
'running',
'delegated',
'completed',
'failed',
'cancelled'
)
),
CHECK (executor_agent_type IN ('claude-code', 'codex') OR executor_agent_type IS NULL)
);
INSERT INTO paired_turn_attempts_new (
attempt_id,
parent_attempt_id,
parent_handoff_id,
continuation_handoff_id,
turn_id,
attempt_no,
task_id,
task_updated_at,
role,
intent_kind,
state,
executor_service_id,
executor_agent_type,
active_run_id,
created_at,
updated_at,
completed_at,
last_error
)
SELECT
COALESCE(attempt_id, ${buildPairedTurnAttemptIdSql('turn_id', 'attempt_no')}),
${parentAttemptIdSelectSql},
${parentHandoffIdSelectSql},
${continuationHandoffIdSelectSql},
turn_id,
attempt_no,
task_id,
task_updated_at,
role,
intent_kind,
state,
executor_service_id,
executor_agent_type,
${activeRunIdSelectSql},
created_at,
updated_at,
completed_at,
last_error
FROM paired_turn_attempts
ORDER BY turn_id ASC, attempt_no ASC;
DROP TABLE paired_turn_attempts;
ALTER TABLE paired_turn_attempts_new RENAME TO paired_turn_attempts;
CREATE INDEX IF NOT EXISTS idx_paired_turn_attempts_attempt_id
ON paired_turn_attempts(attempt_id);
CREATE INDEX IF NOT EXISTS idx_paired_turn_attempts_parent_attempt_id
ON paired_turn_attempts(parent_attempt_id);
CREATE INDEX IF NOT EXISTS idx_paired_turn_attempts_parent_handoff_id
ON paired_turn_attempts(parent_handoff_id);
CREATE INDEX IF NOT EXISTS idx_paired_turn_attempts_continuation_handoff_id
ON paired_turn_attempts(continuation_handoff_id);
CREATE INDEX IF NOT EXISTS idx_paired_turn_attempts_turn
ON paired_turn_attempts(turn_id, attempt_no);
CREATE INDEX IF NOT EXISTS idx_paired_turn_attempts_task
ON paired_turn_attempts(task_id, task_updated_at, attempt_no);
`);
})();
}
function rebuildPairedTurnsWithoutLegacyScratchColumns(
database: Database,
): void {
if (
!tableHasColumn(database, 'paired_turns', 'next_parent_handoff_id') &&
!tableHasColumn(database, 'paired_turns', 'active_run_id') &&
!tableHasColumn(database, 'paired_turns', 'state') &&
!tableHasColumn(database, 'paired_turns', 'executor_service_id') &&
!tableHasColumn(database, 'paired_turns', 'executor_agent_type') &&
!tableHasColumn(database, 'paired_turns', 'attempt_no') &&
!tableHasColumn(database, 'paired_turns', 'completed_at') &&
!tableHasColumn(database, 'paired_turns', 'last_error')
) {
return;
}
database.transaction(() => {
database.exec(`
CREATE TABLE paired_turns_new (
turn_id TEXT PRIMARY KEY,
task_id TEXT NOT NULL,
task_updated_at TEXT NOT NULL,
role TEXT NOT NULL,
intent_kind TEXT NOT NULL,
created_at TEXT NOT NULL,
updated_at TEXT NOT NULL,
CHECK (role IN ('owner', 'reviewer', 'arbiter')),
CHECK (
intent_kind IN (
'owner-turn',
'reviewer-turn',
'arbiter-turn',
'owner-follow-up',
'finalize-owner-turn'
)
)
);
INSERT INTO paired_turns_new (
turn_id,
task_id,
task_updated_at,
role,
intent_kind,
created_at,
updated_at
)
SELECT
turn_id,
task_id,
task_updated_at,
role,
intent_kind,
created_at,
updated_at
FROM paired_turns
ORDER BY created_at ASC, turn_id ASC;
DROP TABLE paired_turns;
ALTER TABLE paired_turns_new RENAME TO paired_turns;
CREATE INDEX IF NOT EXISTS idx_paired_turns_task
ON paired_turns(task_id, task_updated_at, updated_at);
`);
})();
}
function rebuildPairedTurnReservationsWithForeignKeys(
database: Database,
): void {
if (
!tableHasColumn(database, 'paired_turn_reservations', 'turn_attempt_no') ||
(tableHasForeignKey(database, {
tableName: 'paired_turn_reservations',
referencedTable: 'paired_turn_attempts',
fromColumns: ['turn_id', 'turn_attempt_no'],
toColumns: ['turn_id', 'attempt_no'],
onDelete: 'CASCADE',
}) &&
tableHasColumn(database, 'paired_turn_reservations', 'turn_attempt_id') &&
tableHasForeignKey(database, {
tableName: 'paired_turn_reservations',
referencedTable: 'paired_turn_attempts',
fromColumns: ['turn_attempt_id'],
toColumns: ['attempt_id'],
onDelete: 'CASCADE',
}))
) {
return;
}
database.transaction(() => {
database.exec(`
CREATE TABLE paired_turn_reservations_new (
chat_jid TEXT NOT NULL,
task_id TEXT NOT NULL,
task_status TEXT NOT NULL,
round_trip_count INTEGER NOT NULL DEFAULT 0,
task_updated_at TEXT NOT NULL,
turn_id TEXT NOT NULL,
turn_attempt_id TEXT,
turn_attempt_no INTEGER,
turn_role TEXT NOT NULL,
intent_kind TEXT NOT NULL,
status TEXT NOT NULL DEFAULT 'pending',
scheduled_run_id TEXT,
consumed_run_id TEXT,
created_at TEXT NOT NULL,
updated_at TEXT NOT NULL,
consumed_at TEXT,
PRIMARY KEY (chat_jid, task_id, task_updated_at, intent_kind),
FOREIGN KEY (turn_attempt_id)
REFERENCES paired_turn_attempts(attempt_id)
ON DELETE CASCADE,
FOREIGN KEY (turn_id, turn_attempt_no)
REFERENCES paired_turn_attempts(turn_id, attempt_no)
ON DELETE CASCADE,
CHECK (status IN ('pending', 'completed')),
CHECK (turn_role IN ('owner', 'reviewer', 'arbiter')),
CHECK (
intent_kind IN (
'owner-turn',
'reviewer-turn',
'arbiter-turn',
'owner-follow-up',
'finalize-owner-turn'
)
)
);
INSERT INTO paired_turn_reservations_new (
chat_jid,
task_id,
task_status,
round_trip_count,
task_updated_at,
turn_id,
turn_attempt_id,
turn_attempt_no,
turn_role,
intent_kind,
status,
scheduled_run_id,
consumed_run_id,
created_at,
updated_at,
consumed_at
)
SELECT
chat_jid,
task_id,
task_status,
round_trip_count,
task_updated_at,
turn_id,
COALESCE(
turn_attempt_id,
CASE
WHEN turn_attempt_no IS NOT NULL
THEN ${buildPairedTurnAttemptIdSql('turn_id', 'turn_attempt_no')}
ELSE NULL
END
),
turn_attempt_no,
turn_role,
intent_kind,
status,
scheduled_run_id,
consumed_run_id,
created_at,
updated_at,
consumed_at
FROM paired_turn_reservations;
DROP TABLE paired_turn_reservations;
ALTER TABLE paired_turn_reservations_new RENAME TO paired_turn_reservations;
CREATE INDEX IF NOT EXISTS idx_paired_turn_reservations_task
ON paired_turn_reservations(task_id, task_updated_at, status);
`);
})();
}
function rebuildPairedTaskExecutionLeasesWithForeignKeys(
database: Database,
): void {
if (
!tableHasColumn(
database,
'paired_task_execution_leases',
'turn_attempt_no',
) ||
(tableHasForeignKey(database, {
tableName: 'paired_task_execution_leases',
referencedTable: 'paired_turn_attempts',
fromColumns: ['turn_id', 'turn_attempt_no'],
toColumns: ['turn_id', 'attempt_no'],
onDelete: 'CASCADE',
}) &&
tableHasColumn(
database,
'paired_task_execution_leases',
'turn_attempt_id',
) &&
tableHasForeignKey(database, {
tableName: 'paired_task_execution_leases',
referencedTable: 'paired_turn_attempts',
fromColumns: ['turn_attempt_id'],
toColumns: ['attempt_id'],
onDelete: 'CASCADE',
}))
) {
return;
}
database.transaction(() => {
database.exec(`
CREATE TABLE paired_task_execution_leases_new (
task_id TEXT PRIMARY KEY,
chat_jid TEXT NOT NULL,
role TEXT NOT NULL,
turn_id TEXT NOT NULL,
turn_attempt_id TEXT,
turn_attempt_no INTEGER,
intent_kind TEXT NOT NULL,
claimed_run_id TEXT NOT NULL,
claimed_service_id TEXT NOT NULL,
task_status TEXT NOT NULL,
task_updated_at TEXT NOT NULL,
claimed_at TEXT NOT NULL,
updated_at TEXT NOT NULL,
expires_at TEXT NOT NULL,
FOREIGN KEY (turn_attempt_id)
REFERENCES paired_turn_attempts(attempt_id)
ON DELETE CASCADE,
FOREIGN KEY (turn_id, turn_attempt_no)
REFERENCES paired_turn_attempts(turn_id, attempt_no)
ON DELETE CASCADE,
CHECK (role IN ('owner', 'reviewer', 'arbiter')),
CHECK (
intent_kind IN (
'owner-turn',
'reviewer-turn',
'arbiter-turn',
'owner-follow-up',
'finalize-owner-turn'
)
)
);
INSERT INTO paired_task_execution_leases_new (
task_id,
chat_jid,
role,
turn_id,
turn_attempt_id,
turn_attempt_no,
intent_kind,
claimed_run_id,
claimed_service_id,
task_status,
task_updated_at,
claimed_at,
updated_at,
expires_at
)
SELECT
task_id,
chat_jid,
role,
turn_id,
COALESCE(
turn_attempt_id,
CASE
WHEN turn_attempt_no IS NOT NULL
THEN ${buildPairedTurnAttemptIdSql('turn_id', 'turn_attempt_no')}
ELSE NULL
END
),
turn_attempt_no,
intent_kind,
claimed_run_id,
claimed_service_id,
task_status,
task_updated_at,
claimed_at,
updated_at,
expires_at
FROM paired_task_execution_leases;
DROP TABLE paired_task_execution_leases;
ALTER TABLE paired_task_execution_leases_new RENAME TO paired_task_execution_leases;
CREATE INDEX IF NOT EXISTS idx_paired_task_execution_leases_expires_at
ON paired_task_execution_leases(expires_at);
`);
})();
}
function rebuildServiceHandoffsWithForeignKeys(database: Database): void {
if (
!tableHasColumn(database, 'service_handoffs', 'turn_attempt_no') ||
(tableHasForeignKey(database, {
tableName: 'service_handoffs',
referencedTable: 'paired_turn_attempts',
fromColumns: ['turn_id', 'turn_attempt_no'],
toColumns: ['turn_id', 'attempt_no'],
onDelete: 'CASCADE',
}) &&
tableHasColumn(database, 'service_handoffs', 'turn_attempt_id') &&
tableHasForeignKey(database, {
tableName: 'service_handoffs',
referencedTable: 'paired_turn_attempts',
fromColumns: ['turn_attempt_id'],
toColumns: ['attempt_id'],
onDelete: 'CASCADE',
}))
) {
return;
}
database.transaction(() => {
database.exec(`
CREATE TABLE service_handoffs_new (
id INTEGER PRIMARY KEY AUTOINCREMENT,
chat_jid TEXT NOT NULL,
group_folder TEXT NOT NULL,
source_service_id TEXT NOT NULL,
target_service_id TEXT NOT NULL,
paired_task_id TEXT,
paired_task_updated_at TEXT,
turn_id TEXT,
turn_attempt_id TEXT,
turn_attempt_no INTEGER,
turn_intent_kind TEXT,
turn_role TEXT,
source_role TEXT,
source_agent_type TEXT,
target_role TEXT,
target_agent_type TEXT NOT NULL,
prompt TEXT NOT NULL,
status TEXT NOT NULL DEFAULT 'pending',
start_seq INTEGER,
end_seq INTEGER,
reason TEXT,
intended_role TEXT,
created_at TEXT NOT NULL DEFAULT (datetime('now')),
claimed_at TEXT,
completed_at TEXT,
last_error TEXT,
FOREIGN KEY (turn_attempt_id)
REFERENCES paired_turn_attempts(attempt_id)
ON DELETE CASCADE,
FOREIGN KEY (turn_id, turn_attempt_no)
REFERENCES paired_turn_attempts(turn_id, attempt_no)
ON DELETE CASCADE,
CHECK (status IN ('pending', 'claimed', 'completed', 'failed')),
CHECK (intended_role IN ('owner', 'reviewer', 'arbiter') OR intended_role IS NULL),
CHECK (
turn_intent_kind IN (
'owner-turn',
'reviewer-turn',
'arbiter-turn',
'owner-follow-up',
'finalize-owner-turn'
) OR turn_intent_kind IS NULL
),
CHECK (turn_role IN ('owner', 'reviewer', 'arbiter') OR turn_role IS NULL),
CHECK (source_role IN ('owner', 'reviewer', 'arbiter') OR source_role IS NULL),
CHECK (target_role IN ('owner', 'reviewer', 'arbiter') OR target_role IS NULL)
);
INSERT INTO service_handoffs_new (
id,
chat_jid,
group_folder,
source_service_id,
target_service_id,
paired_task_id,
paired_task_updated_at,
turn_id,
turn_attempt_id,
turn_attempt_no,
turn_intent_kind,
turn_role,
source_role,
source_agent_type,
target_role,
target_agent_type,
prompt,
status,
start_seq,
end_seq,
reason,
intended_role,
created_at,
claimed_at,
completed_at,
last_error
)
SELECT
id,
chat_jid,
group_folder,
source_service_id,
target_service_id,
paired_task_id,
paired_task_updated_at,
turn_id,
COALESCE(
turn_attempt_id,
CASE
WHEN turn_attempt_no IS NOT NULL
THEN ${buildPairedTurnAttemptIdSql('turn_id', 'turn_attempt_no')}
ELSE NULL
END
),
turn_attempt_no,
turn_intent_kind,
turn_role,
source_role,
source_agent_type,
target_role,
target_agent_type,
prompt,
status,
start_seq,
end_seq,
reason,
intended_role,
created_at,
claimed_at,
completed_at,
last_error
FROM service_handoffs;
DROP TABLE service_handoffs;
ALTER TABLE service_handoffs_new RENAME TO service_handoffs;
CREATE INDEX IF NOT EXISTS idx_service_handoffs_target
ON service_handoffs(status, target_role, target_agent_type, created_at);
`);
})();
}
function rebuildPairedTurnAttemptForeignKeyTables(database: Database): void {
rebuildPairedTurnAttemptsWithForeignKeys(database);
rebuildPairedTurnReservationsWithForeignKeys(database);
rebuildPairedTaskExecutionLeasesWithForeignKeys(database);
rebuildServiceHandoffsWithForeignKeys(database);
}
function dropPairedTurnAttemptProvenanceConstraints(database: Database): void {
database.exec(`
DROP TRIGGER IF EXISTS paired_turn_attempts_validate_insert;
DROP TRIGGER IF EXISTS paired_turn_attempts_validate_update;
DROP TRIGGER IF EXISTS paired_turn_reservations_validate_attempt_insert;
DROP TRIGGER IF EXISTS paired_turn_reservations_validate_attempt_update;
DROP TRIGGER IF EXISTS paired_task_execution_leases_validate_attempt_insert;
DROP TRIGGER IF EXISTS paired_task_execution_leases_validate_attempt_update;
DROP TRIGGER IF EXISTS service_handoffs_validate_attempt_insert;
DROP TRIGGER IF EXISTS service_handoffs_validate_attempt_update;
`);
}
function applyPairedTurnAttemptProvenanceConstraints(database: Database): void {
database.exec(`
CREATE TRIGGER IF NOT EXISTS paired_turn_attempts_validate_insert
BEFORE INSERT ON paired_turn_attempts
BEGIN
SELECT RAISE(ABORT, 'paired_turn_attempts attempt_id must match turn_id/attempt_no')
WHERE NEW.attempt_id IS NULL
OR NEW.attempt_id != ${buildPairedTurnAttemptIdSql('NEW.turn_id', 'NEW.attempt_no')};
SELECT RAISE(ABORT, 'paired_turn_attempts attempt 1 cannot declare parent_attempt_id')
WHERE NEW.attempt_no <= 1
AND NEW.parent_attempt_id IS NOT NULL;
SELECT RAISE(ABORT, 'paired_turn_attempts must preserve contiguous parent lineage')
WHERE NEW.attempt_no > 1
AND NOT EXISTS (
SELECT 1
FROM paired_turn_attempts previous_attempt
WHERE previous_attempt.turn_id = NEW.turn_id
AND previous_attempt.attempt_no = NEW.attempt_no - 1
);
SELECT RAISE(ABORT, 'paired_turn_attempts must keep parent_attempt_id lineage')
WHERE NEW.attempt_no > 1
AND (
NEW.parent_attempt_id IS NULL
OR NEW.parent_attempt_id != ${buildPairedTurnAttemptParentIdSql('NEW.turn_id', 'NEW.attempt_no')}
);
SELECT RAISE(ABORT, 'paired_turn_attempts parent_attempt_id must point to the previous attempt of the same turn')
WHERE NEW.parent_attempt_id IS NOT NULL
AND NOT EXISTS (
SELECT 1
FROM paired_turn_attempts previous_attempt
WHERE COALESCE(
previous_attempt.attempt_id,
${buildPairedTurnAttemptIdSql(
'previous_attempt.turn_id',
'previous_attempt.attempt_no',
)}
) = NEW.parent_attempt_id
AND previous_attempt.turn_id = NEW.turn_id
AND previous_attempt.attempt_no = NEW.attempt_no - 1
);
SELECT RAISE(ABORT, 'paired_turn_attempts attempt 1 cannot declare parent_handoff_id')
WHERE NEW.attempt_no <= 1
AND NEW.parent_handoff_id IS NOT NULL;
SELECT RAISE(ABORT, 'paired_turn_attempts parent_handoff_id must reference the previous attempt handoff of the same turn')
WHERE NEW.parent_handoff_id IS NOT NULL
AND NOT ${buildPairedTurnAttemptParentHandoffMatchSql({
parentHandoffIdExpr: 'NEW.parent_handoff_id',
turnIdExpr: 'NEW.turn_id',
parentAttemptIdExpr: 'NEW.parent_attempt_id',
attemptNoExpr: 'NEW.attempt_no',
})};
SELECT RAISE(ABORT, 'paired_turn_attempts continuation_handoff_id must reference a handoff of the same attempt')
WHERE NEW.continuation_handoff_id IS NOT NULL
AND NOT ${buildPairedTurnAttemptContinuationHandoffMatchSql({
continuationHandoffIdExpr: 'NEW.continuation_handoff_id',
turnIdExpr: 'NEW.turn_id',
attemptIdExpr: 'NEW.attempt_id',
attemptNoExpr: 'NEW.attempt_no',
})};
SELECT RAISE(ABORT, 'paired_turn_attempts running attempts must declare active_run_id')
WHERE NEW.state = 'running'
AND (
NEW.active_run_id IS NULL
OR TRIM(NEW.active_run_id) = ''
);
SELECT RAISE(ABORT, 'paired_turn_attempts only running attempts may declare active_run_id')
WHERE NEW.state != 'running'
AND NEW.active_run_id IS NOT NULL;
SELECT RAISE(ABORT, 'paired_turn_attempts must reference a matching paired_turns row')
WHERE NOT EXISTS (
SELECT 1
FROM paired_turns
WHERE paired_turns.turn_id = NEW.turn_id
AND paired_turns.task_id = NEW.task_id
AND paired_turns.task_updated_at = NEW.task_updated_at
AND paired_turns.role = NEW.role
AND paired_turns.intent_kind = NEW.intent_kind
);
END;
CREATE TRIGGER IF NOT EXISTS paired_turn_attempts_validate_update
BEFORE UPDATE OF attempt_id, parent_attempt_id, parent_handoff_id, continuation_handoff_id, turn_id, attempt_no, task_id, task_updated_at, role, intent_kind, state, executor_service_id, executor_agent_type, active_run_id
ON paired_turn_attempts
BEGIN
SELECT RAISE(ABORT, 'paired_turn_attempts attempt_id must match turn_id/attempt_no')
WHERE NEW.attempt_id IS NULL
OR NEW.attempt_id != ${buildPairedTurnAttemptIdSql('NEW.turn_id', 'NEW.attempt_no')};
SELECT RAISE(ABORT, 'paired_turn_attempts attempt 1 cannot declare parent_attempt_id')
WHERE NEW.attempt_no <= 1
AND NEW.parent_attempt_id IS NOT NULL;
SELECT RAISE(ABORT, 'paired_turn_attempts must preserve contiguous parent lineage')
WHERE NEW.attempt_no > 1
AND NOT EXISTS (
SELECT 1
FROM paired_turn_attempts previous_attempt
WHERE previous_attempt.turn_id = NEW.turn_id
AND previous_attempt.attempt_no = NEW.attempt_no - 1
);
SELECT RAISE(ABORT, 'paired_turn_attempts must keep parent_attempt_id lineage')
WHERE NEW.attempt_no > 1
AND (
NEW.parent_attempt_id IS NULL
OR NEW.parent_attempt_id != ${buildPairedTurnAttemptParentIdSql('NEW.turn_id', 'NEW.attempt_no')}
);
SELECT RAISE(ABORT, 'paired_turn_attempts parent_attempt_id must point to the previous attempt of the same turn')
WHERE NEW.parent_attempt_id IS NOT NULL
AND NOT EXISTS (
SELECT 1
FROM paired_turn_attempts previous_attempt
WHERE COALESCE(
previous_attempt.attempt_id,
${buildPairedTurnAttemptIdSql(
'previous_attempt.turn_id',
'previous_attempt.attempt_no',
)}
) = NEW.parent_attempt_id
AND previous_attempt.turn_id = NEW.turn_id
AND previous_attempt.attempt_no = NEW.attempt_no - 1
);
SELECT RAISE(ABORT, 'paired_turn_attempts attempt 1 cannot declare parent_handoff_id')
WHERE NEW.attempt_no <= 1
AND NEW.parent_handoff_id IS NOT NULL;
SELECT RAISE(ABORT, 'paired_turn_attempts parent_handoff_id must reference the previous attempt handoff of the same turn')
WHERE NEW.parent_handoff_id IS NOT NULL
AND NOT ${buildPairedTurnAttemptParentHandoffMatchSql({
parentHandoffIdExpr: 'NEW.parent_handoff_id',
turnIdExpr: 'NEW.turn_id',
parentAttemptIdExpr: 'NEW.parent_attempt_id',
attemptNoExpr: 'NEW.attempt_no',
})};
SELECT RAISE(ABORT, 'paired_turn_attempts continuation_handoff_id must reference a handoff of the same attempt')
WHERE NEW.continuation_handoff_id IS NOT NULL
AND NOT ${buildPairedTurnAttemptContinuationHandoffMatchSql({
continuationHandoffIdExpr: 'NEW.continuation_handoff_id',
turnIdExpr: 'NEW.turn_id',
attemptIdExpr: 'NEW.attempt_id',
attemptNoExpr: 'NEW.attempt_no',
})};
SELECT RAISE(ABORT, 'paired_turn_attempts running attempts must declare active_run_id')
WHERE NEW.state = 'running'
AND (
NEW.active_run_id IS NULL
OR TRIM(NEW.active_run_id) = ''
);
SELECT RAISE(ABORT, 'paired_turn_attempts only running attempts may declare active_run_id')
WHERE NEW.state != 'running'
AND NEW.active_run_id IS NOT NULL;
SELECT RAISE(ABORT, 'paired_turn_attempts must reference a matching paired_turns row')
WHERE NOT EXISTS (
SELECT 1
FROM paired_turns
WHERE paired_turns.turn_id = NEW.turn_id
AND paired_turns.task_id = NEW.task_id
AND paired_turns.task_updated_at = NEW.task_updated_at
AND paired_turns.role = NEW.role
AND paired_turns.intent_kind = NEW.intent_kind
);
END;
`);
if (tableHasColumn(database, 'paired_turn_reservations', 'turn_attempt_no')) {
database.exec(`
CREATE INDEX IF NOT EXISTS idx_paired_turn_reservations_turn_attempt
ON paired_turn_reservations(turn_id, turn_attempt_no);
CREATE INDEX IF NOT EXISTS idx_paired_turn_reservations_turn_attempt_id
ON paired_turn_reservations(turn_attempt_id);
CREATE TRIGGER IF NOT EXISTS paired_turn_reservations_validate_attempt_insert
BEFORE INSERT ON paired_turn_reservations
BEGIN
SELECT RAISE(ABORT, 'paired_turn_reservations.turn_attempt_no requires turn_id')
WHERE NEW.turn_attempt_no IS NOT NULL
AND NEW.turn_id IS NULL;
SELECT RAISE(ABORT, 'paired_turn_reservations.turn_attempt provenance must keep attempt_id and attempt_no in sync')
WHERE (NEW.turn_attempt_id IS NULL) != (NEW.turn_attempt_no IS NULL);
SELECT RAISE(ABORT, 'paired_turn_reservations turn_attempt_no must reference a matching paired_turn_attempts row')
WHERE NEW.turn_attempt_id IS NOT NULL
AND NOT EXISTS (
SELECT 1
FROM paired_turn_attempts
WHERE paired_turn_attempts.attempt_id = NEW.turn_attempt_id
AND paired_turn_attempts.turn_id = NEW.turn_id
AND paired_turn_attempts.attempt_no = NEW.turn_attempt_no
AND paired_turn_attempts.task_id = NEW.task_id
AND paired_turn_attempts.task_updated_at = NEW.task_updated_at
AND paired_turn_attempts.role = NEW.turn_role
AND paired_turn_attempts.intent_kind = NEW.intent_kind
);
END;
CREATE TRIGGER IF NOT EXISTS paired_turn_reservations_validate_attempt_update
BEFORE UPDATE OF turn_id, turn_attempt_id, turn_attempt_no, task_id, task_updated_at, turn_role, intent_kind
ON paired_turn_reservations
BEGIN
SELECT RAISE(ABORT, 'paired_turn_reservations.turn_attempt_no requires turn_id')
WHERE NEW.turn_attempt_no IS NOT NULL
AND NEW.turn_id IS NULL;
SELECT RAISE(ABORT, 'paired_turn_reservations.turn_attempt provenance must keep attempt_id and attempt_no in sync')
WHERE (NEW.turn_attempt_id IS NULL) != (NEW.turn_attempt_no IS NULL);
SELECT RAISE(ABORT, 'paired_turn_reservations turn_attempt_no must reference a matching paired_turn_attempts row')
WHERE NEW.turn_attempt_id IS NOT NULL
AND NOT EXISTS (
SELECT 1
FROM paired_turn_attempts
WHERE paired_turn_attempts.attempt_id = NEW.turn_attempt_id
AND paired_turn_attempts.turn_id = NEW.turn_id
AND paired_turn_attempts.attempt_no = NEW.turn_attempt_no
AND paired_turn_attempts.task_id = NEW.task_id
AND paired_turn_attempts.task_updated_at = NEW.task_updated_at
AND paired_turn_attempts.role = NEW.turn_role
AND paired_turn_attempts.intent_kind = NEW.intent_kind
);
END;
`);
}
if (
tableHasColumn(database, 'paired_task_execution_leases', 'turn_attempt_no')
) {
database.exec(`
CREATE INDEX IF NOT EXISTS idx_paired_task_execution_leases_turn_attempt
ON paired_task_execution_leases(turn_id, turn_attempt_no);
CREATE INDEX IF NOT EXISTS idx_paired_task_execution_leases_turn_attempt_id
ON paired_task_execution_leases(turn_attempt_id);
CREATE TRIGGER IF NOT EXISTS paired_task_execution_leases_validate_attempt_insert
BEFORE INSERT ON paired_task_execution_leases
BEGIN
SELECT RAISE(ABORT, 'paired_task_execution_leases.turn_attempt_no requires turn_id')
WHERE NEW.turn_attempt_no IS NOT NULL
AND NEW.turn_id IS NULL;
SELECT RAISE(ABORT, 'paired_task_execution_leases turn_attempt provenance must keep attempt_id and attempt_no in sync')
WHERE (NEW.turn_attempt_id IS NULL) != (NEW.turn_attempt_no IS NULL);
SELECT RAISE(ABORT, 'paired_task_execution_leases turn_attempt_no must reference a matching paired_turn_attempts row')
WHERE NEW.turn_attempt_id IS NOT NULL
AND NOT EXISTS (
SELECT 1
FROM paired_turn_attempts
WHERE paired_turn_attempts.attempt_id = NEW.turn_attempt_id
AND paired_turn_attempts.turn_id = NEW.turn_id
AND paired_turn_attempts.attempt_no = NEW.turn_attempt_no
AND paired_turn_attempts.task_id = NEW.task_id
AND paired_turn_attempts.task_updated_at = NEW.task_updated_at
AND paired_turn_attempts.role = NEW.role
AND paired_turn_attempts.intent_kind = NEW.intent_kind
);
END;
CREATE TRIGGER IF NOT EXISTS paired_task_execution_leases_validate_attempt_update
BEFORE UPDATE OF turn_id, turn_attempt_id, turn_attempt_no, task_id, task_updated_at, role, intent_kind
ON paired_task_execution_leases
BEGIN
SELECT RAISE(ABORT, 'paired_task_execution_leases.turn_attempt_no requires turn_id')
WHERE NEW.turn_attempt_no IS NOT NULL
AND NEW.turn_id IS NULL;
SELECT RAISE(ABORT, 'paired_task_execution_leases turn_attempt provenance must keep attempt_id and attempt_no in sync')
WHERE (NEW.turn_attempt_id IS NULL) != (NEW.turn_attempt_no IS NULL);
SELECT RAISE(ABORT, 'paired_task_execution_leases turn_attempt_no must reference a matching paired_turn_attempts row')
WHERE NEW.turn_attempt_id IS NOT NULL
AND NOT EXISTS (
SELECT 1
FROM paired_turn_attempts
WHERE paired_turn_attempts.attempt_id = NEW.turn_attempt_id
AND paired_turn_attempts.turn_id = NEW.turn_id
AND paired_turn_attempts.attempt_no = NEW.turn_attempt_no
AND paired_turn_attempts.task_id = NEW.task_id
AND paired_turn_attempts.task_updated_at = NEW.task_updated_at
AND paired_turn_attempts.role = NEW.role
AND paired_turn_attempts.intent_kind = NEW.intent_kind
);
END;
`);
}
if (
tableHasColumn(database, 'service_handoffs', 'turn_attempt_no') &&
tableHasColumn(database, 'service_handoffs', 'paired_task_id') &&
tableHasColumn(database, 'service_handoffs', 'paired_task_updated_at') &&
tableHasColumn(database, 'service_handoffs', 'turn_role') &&
tableHasColumn(database, 'service_handoffs', 'turn_intent_kind')
) {
database.exec(`
CREATE INDEX IF NOT EXISTS idx_service_handoffs_turn_attempt
ON service_handoffs(turn_id, turn_attempt_no);
CREATE INDEX IF NOT EXISTS idx_service_handoffs_turn_attempt_id
ON service_handoffs(turn_attempt_id);
CREATE TRIGGER IF NOT EXISTS service_handoffs_validate_attempt_insert
BEFORE INSERT ON service_handoffs
BEGIN
SELECT RAISE(ABORT, 'service_handoffs.turn_attempt_no requires paired turn identity')
WHERE NEW.turn_attempt_no IS NOT NULL
AND (
NEW.turn_id IS NULL
OR NEW.paired_task_id IS NULL
OR NEW.paired_task_updated_at IS NULL
OR NEW.turn_role IS NULL
OR NEW.turn_intent_kind IS NULL
);
SELECT RAISE(ABORT, 'service_handoffs turn_attempt provenance must keep attempt_id and attempt_no in sync')
WHERE (NEW.turn_attempt_id IS NULL) != (NEW.turn_attempt_no IS NULL);
SELECT RAISE(ABORT, 'service_handoffs turn_attempt_no must reference a matching paired_turn_attempts row')
WHERE NEW.turn_attempt_id IS NOT NULL
AND NOT EXISTS (
SELECT 1
FROM paired_turn_attempts
WHERE paired_turn_attempts.attempt_id = NEW.turn_attempt_id
AND paired_turn_attempts.turn_id = NEW.turn_id
AND paired_turn_attempts.attempt_no = NEW.turn_attempt_no
AND paired_turn_attempts.task_id = NEW.paired_task_id
AND paired_turn_attempts.task_updated_at = NEW.paired_task_updated_at
AND paired_turn_attempts.role = NEW.turn_role
AND paired_turn_attempts.intent_kind = NEW.turn_intent_kind
);
END;
CREATE TRIGGER IF NOT EXISTS service_handoffs_validate_attempt_update
BEFORE UPDATE OF turn_id, turn_attempt_id, turn_attempt_no, paired_task_id, paired_task_updated_at, turn_role, turn_intent_kind
ON service_handoffs
BEGIN
SELECT RAISE(ABORT, 'service_handoffs.turn_attempt_no requires paired turn identity')
WHERE NEW.turn_attempt_no IS NOT NULL
AND (
NEW.turn_id IS NULL
OR NEW.paired_task_id IS NULL
OR NEW.paired_task_updated_at IS NULL
OR NEW.turn_role IS NULL
OR NEW.turn_intent_kind IS NULL
);
SELECT RAISE(ABORT, 'service_handoffs turn_attempt provenance must keep attempt_id and attempt_no in sync')
WHERE (NEW.turn_attempt_id IS NULL) != (NEW.turn_attempt_no IS NULL);
SELECT RAISE(ABORT, 'service_handoffs turn_attempt_no must reference a matching paired_turn_attempts row')
WHERE NEW.turn_attempt_id IS NOT NULL
AND NOT EXISTS (
SELECT 1
FROM paired_turn_attempts
WHERE paired_turn_attempts.attempt_id = NEW.turn_attempt_id
AND paired_turn_attempts.turn_id = NEW.turn_id
AND paired_turn_attempts.attempt_no = NEW.turn_attempt_no
AND paired_turn_attempts.task_id = NEW.paired_task_id
AND paired_turn_attempts.task_updated_at = NEW.paired_task_updated_at
AND paired_turn_attempts.role = NEW.turn_role
AND paired_turn_attempts.intent_kind = NEW.turn_intent_kind
);
END;
`);
}
}
interface StoredWorkItemServiceRow {
id: number;
agent_type?: string | null;
service_id?: string | null;
delivery_role?: string | null;
}
function normalizePairedRole(
role: string | null | undefined,
): 'owner' | 'reviewer' | 'arbiter' | null {
return role === 'owner' || role === 'reviewer' || role === 'arbiter'
? role
: null;
}
function inferLegacyExecutionLeaseServiceId(
row: LegacyExecutionLeaseServiceRow,
): string | null {
return inferExecutionLeaseServiceIdFromCanonicalMetadata(row);
}
function backfillLegacyExecutionLeaseServiceShadows(database: Database): void {
if (
!tableHasColumn(
database,
'paired_task_execution_leases',
'claimed_service_id',
)
) {
return;
}
const pairedTasksTable = database
.prepare(
`
SELECT 1
FROM sqlite_master
WHERE type = 'table'
AND name = 'paired_tasks'
`,
)
.get();
if (!pairedTasksTable) {
return;
}
const pairedTaskColumns = getTableColumns(database, 'paired_tasks');
const selectPairedTaskColumn = (columnName: string): string =>
pairedTaskColumns.includes(columnName)
? `paired_tasks.${columnName} AS ${columnName}`
: `NULL AS ${columnName}`;
const rows = database
.prepare(
`
SELECT
paired_task_execution_leases.rowid AS rowid,
paired_task_execution_leases.role AS role,
${selectPairedTaskColumn('owner_service_id')},
${selectPairedTaskColumn('reviewer_service_id')},
${selectPairedTaskColumn('arbiter_service_id')},
${selectPairedTaskColumn('owner_agent_type')},
${selectPairedTaskColumn('reviewer_agent_type')},
${selectPairedTaskColumn('arbiter_agent_type')}
FROM paired_task_execution_leases
LEFT JOIN paired_tasks
ON paired_tasks.id = paired_task_execution_leases.task_id
WHERE paired_task_execution_leases.claimed_service_id IS NULL
`,
)
.all() as LegacyExecutionLeaseServiceRow[];
if (rows.length === 0) {
return;
}
const update = database.prepare(
`
UPDATE paired_task_execution_leases
SET claimed_service_id = ?
WHERE rowid = ?
AND claimed_service_id IS NULL
`,
);
const tx = database.transaction(
(leaseRows: LegacyExecutionLeaseServiceRow[]) => {
for (const row of leaseRows) {
const claimedServiceId = inferLegacyExecutionLeaseServiceId(row);
if (!claimedServiceId) {
continue;
}
update.run(claimedServiceId, row.rowid);
}
},
);
tx(rows);
}
function backfillCanonicalPairedTaskServiceIds(database: Database): void {
if (
!tableHasColumn(database, 'paired_tasks', 'owner_service_id') ||
!tableHasColumn(database, 'paired_tasks', 'reviewer_service_id')
) {
return;
}
const rows = database
.prepare(
`
SELECT
rowid,
id,
chat_jid,
group_folder,
owner_service_id,
reviewer_service_id,
owner_agent_type,
reviewer_agent_type,
arbiter_agent_type
FROM paired_tasks
`,
)
.all() as StoredPairedTaskServiceRow[];
if (rows.length === 0) {
return;
}
const update = database.prepare(
`
UPDATE paired_tasks
SET owner_service_id = ?,
reviewer_service_id = ?,
owner_agent_type = ?,
reviewer_agent_type = ?,
arbiter_agent_type = ?
WHERE rowid = ?
`,
);
const tx = database.transaction((taskRows: StoredPairedTaskServiceRow[]) => {
for (const row of taskRows) {
const {
ownerAgentType,
reviewerAgentType,
arbiterAgentType,
ownerServiceId,
reviewerServiceId,
} = canonicalizePairedTaskMetadata({
id: row.id,
owner_service_id: row.owner_service_id,
reviewer_service_id: row.reviewer_service_id,
owner_agent_type: row.owner_agent_type,
reviewer_agent_type: row.reviewer_agent_type,
arbiter_agent_type: row.arbiter_agent_type,
});
if (
row.owner_service_id === ownerServiceId &&
row.reviewer_service_id === reviewerServiceId &&
row.owner_agent_type === ownerAgentType &&
row.reviewer_agent_type === reviewerAgentType &&
row.arbiter_agent_type === arbiterAgentType
) {
continue;
}
update.run(
ownerServiceId,
reviewerServiceId,
ownerAgentType,
reviewerAgentType,
arbiterAgentType,
row.rowid,
);
}
});
tx(rows);
}
function backfillCanonicalChannelOwnerServiceIds(database: Database): void {
if (!tableHasColumn(database, 'channel_owner', 'owner_service_id')) {
return;
}
const rows = database
.prepare(
`
SELECT
rowid,
chat_jid,
owner_service_id,
reviewer_service_id,
arbiter_service_id,
owner_agent_type,
reviewer_agent_type,
arbiter_agent_type
FROM channel_owner
`,
)
.all() as StoredChannelOwnerLeaseServiceRow[];
if (rows.length === 0) {
return;
}
const update = database.prepare(
`
UPDATE channel_owner
SET owner_service_id = ?,
reviewer_service_id = ?,
arbiter_service_id = ?,
owner_agent_type = ?,
reviewer_agent_type = ?,
arbiter_agent_type = ?
WHERE rowid = ?
`,
);
const tx = database.transaction(
(leaseRows: StoredChannelOwnerLeaseServiceRow[]) => {
for (const row of leaseRows) {
const {
ownerAgentType,
reviewerAgentType,
arbiterAgentType,
ownerServiceId,
reviewerServiceId,
arbiterServiceId,
} = canonicalizeChannelOwnerLeaseMetadata({
chat_jid: row.chat_jid,
owner_service_id: row.owner_service_id,
reviewer_service_id: row.reviewer_service_id,
arbiter_service_id: row.arbiter_service_id,
owner_agent_type: row.owner_agent_type,
reviewer_agent_type: row.reviewer_agent_type,
arbiter_agent_type: row.arbiter_agent_type,
});
if (
row.owner_service_id === ownerServiceId &&
row.reviewer_service_id === reviewerServiceId &&
row.arbiter_service_id === arbiterServiceId &&
row.owner_agent_type === ownerAgentType &&
row.reviewer_agent_type === reviewerAgentType &&
row.arbiter_agent_type === arbiterAgentType
) {
continue;
}
update.run(
ownerServiceId,
reviewerServiceId,
arbiterServiceId,
ownerAgentType,
reviewerAgentType,
arbiterAgentType,
row.rowid,
);
}
},
);
tx(rows);
}
function backfillCanonicalServiceHandoffServiceIds(database: Database): void {
if (!tableHasColumn(database, 'service_handoffs', 'source_service_id')) {
return;
}
const rows = database
.prepare(
`
SELECT
id,
chat_jid,
group_folder,
source_service_id,
target_service_id,
source_role,
target_role,
source_agent_type,
target_agent_type,
intended_role
FROM service_handoffs
`,
)
.all() as StoredServiceHandoffServiceRow[];
if (rows.length === 0) {
return;
}
const update = database.prepare(
`
UPDATE service_handoffs
SET source_service_id = ?,
target_service_id = ?,
source_agent_type = ?,
target_agent_type = ?,
source_role = ?,
target_role = ?
WHERE id = ?
`,
);
const tx = database.transaction(
(handoffRows: StoredServiceHandoffServiceRow[]) => {
for (const row of handoffRows) {
const {
sourceRole,
targetRole,
sourceAgentType,
targetAgentType,
sourceServiceId,
targetServiceId,
} = canonicalizeServiceHandoffMetadata({
id: row.id,
chat_jid: row.chat_jid,
source_service_id: row.source_service_id,
target_service_id: row.target_service_id,
source_role: row.source_role,
target_role: row.target_role,
intended_role: row.intended_role,
source_agent_type: row.source_agent_type,
target_agent_type: row.target_agent_type,
});
if (
row.source_service_id === sourceServiceId &&
row.target_service_id === targetServiceId &&
row.source_agent_type === (sourceAgentType ?? null) &&
row.target_agent_type === targetAgentType &&
row.source_role === sourceRole &&
row.target_role === targetRole
) {
continue;
}
update.run(
sourceServiceId,
targetServiceId,
sourceAgentType,
targetAgentType,
sourceRole,
targetRole,
row.id,
);
}
},
);
tx(rows);
}
function backfillCanonicalWorkItemServiceIds(database: Database): void {
if (!tableHasColumn(database, 'work_items', 'service_id')) {
return;
}
const rows = database
.prepare(
`SELECT id, agent_type, service_id, delivery_role
FROM work_items`,
)
.all() as StoredWorkItemServiceRow[];
if (rows.length === 0) {
return;
}
const update = database.prepare(
`UPDATE work_items
SET service_id = ?
WHERE id = ?`,
);
const tx = database.transaction(
(workItemRows: StoredWorkItemServiceRow[]) => {
for (const row of workItemRows) {
const agentType =
normalizeStoredAgentType(row.agent_type) ?? 'claude-code';
const deliveryRole = normalizePairedRole(row.delivery_role) ?? 'owner';
const serviceId =
(row.service_id ? normalizeServiceId(row.service_id) : null) ??
resolveRoleServiceShadow(deliveryRole, agentType) ??
SERVICE_SESSION_SCOPE;
if (row.service_id === serviceId) {
continue;
}
update.run(serviceId, row.id);
}
},
);
tx(rows);
}
export function applySchemaMigrations(
database: Database,
args: {
assistantName: string;
},
): void {
const { assistantName } = args;
tryExecMigration(
database,
`ALTER TABLE scheduled_tasks ADD COLUMN context_mode TEXT DEFAULT 'isolated'`,
);
tryExecMigration(
database,
`ALTER TABLE scheduled_tasks ADD COLUMN agent_type TEXT`,
);
tryExecMigration(
database,
`ALTER TABLE scheduled_tasks ADD COLUMN ci_provider TEXT`,
);
tryExecMigration(
database,
`ALTER TABLE scheduled_tasks ADD COLUMN ci_metadata TEXT`,
);
tryExecMigration(
database,
`ALTER TABLE scheduled_tasks ADD COLUMN max_duration_ms INTEGER`,
);
tryExecMigration(
database,
`ALTER TABLE scheduled_tasks ADD COLUMN status_message_id TEXT`,
);
tryExecMigration(
database,
`ALTER TABLE scheduled_tasks ADD COLUMN status_started_at TEXT`,
);
tryExecMigration(
database,
`ALTER TABLE scheduled_tasks ADD COLUMN suspended_until TEXT`,
);
tryExecMigration(
database,
`ALTER TABLE room_settings ADD COLUMN mode_source TEXT NOT NULL DEFAULT 'explicit'`,
);
tryExecMigration(database, `ALTER TABLE room_settings ADD COLUMN name TEXT`);
tryExecMigration(
database,
`ALTER TABLE room_settings ADD COLUMN folder TEXT`,
);
tryExecMigration(
database,
`ALTER TABLE room_settings ADD COLUMN trigger_pattern TEXT`,
);
tryExecMigration(
database,
`ALTER TABLE room_settings ADD COLUMN requires_trigger INTEGER DEFAULT 1`,
);
tryExecMigration(
database,
`ALTER TABLE room_settings ADD COLUMN is_main INTEGER DEFAULT 0`,
);
tryExecMigration(
database,
`ALTER TABLE room_settings ADD COLUMN owner_agent_type TEXT`,
);
tryExecMigration(
database,
`ALTER TABLE room_settings ADD COLUMN work_dir TEXT`,
);
tryExecMigration(
database,
`ALTER TABLE room_settings ADD COLUMN created_at TEXT`,
);
if (tableHasColumn(database, 'room_settings', 'created_at')) {
database.exec(`
UPDATE room_settings
SET created_at = COALESCE(created_at, updated_at, CURRENT_TIMESTAMP)
`);
}
database.exec(`
CREATE TABLE IF NOT EXISTS room_role_overrides (
chat_jid TEXT NOT NULL,
role TEXT NOT NULL,
agent_type TEXT NOT NULL,
agent_config_json TEXT,
created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
PRIMARY KEY (chat_jid, role),
CHECK (role IN ('owner', 'reviewer', 'arbiter')),
CHECK (agent_type IN ('claude-code', 'codex'))
)
`);
tryExecMigration(
database,
`ALTER TABLE service_handoffs ADD COLUMN intended_role TEXT`,
);
tryExecMigration(
database,
`ALTER TABLE service_handoffs ADD COLUMN source_role TEXT`,
);
tryExecMigration(
database,
`ALTER TABLE service_handoffs ADD COLUMN target_role TEXT`,
);
tryExecMigration(
database,
`ALTER TABLE service_handoffs ADD COLUMN source_agent_type TEXT`,
);
tryExecMigration(
database,
`ALTER TABLE service_handoffs ADD COLUMN source_service_id TEXT`,
);
tryExecMigration(
database,
`ALTER TABLE service_handoffs ADD COLUMN target_service_id TEXT`,
);
tryExecMigration(
database,
`ALTER TABLE service_handoffs ADD COLUMN paired_task_id TEXT`,
);
tryExecMigration(
database,
`ALTER TABLE service_handoffs ADD COLUMN paired_task_updated_at TEXT`,
);
tryExecMigration(
database,
`ALTER TABLE service_handoffs ADD COLUMN turn_id TEXT`,
);
tryExecMigration(
database,
`ALTER TABLE service_handoffs ADD COLUMN turn_attempt_id TEXT`,
);
tryExecMigration(
database,
`ALTER TABLE service_handoffs ADD COLUMN turn_attempt_no INTEGER`,
);
tryExecMigration(
database,
`ALTER TABLE service_handoffs ADD COLUMN turn_intent_kind TEXT`,
);
tryExecMigration(
database,
`ALTER TABLE service_handoffs ADD COLUMN turn_role TEXT`,
);
tryExecMigration(
database,
`ALTER TABLE paired_tasks ADD COLUMN owner_agent_type TEXT`,
);
tryExecMigration(
database,
`ALTER TABLE paired_tasks ADD COLUMN reviewer_agent_type TEXT`,
);
tryExecMigration(
database,
`ALTER TABLE paired_tasks ADD COLUMN arbiter_agent_type TEXT`,
);
tryExecMigration(
database,
`ALTER TABLE paired_tasks ADD COLUMN owner_service_id TEXT`,
);
tryExecMigration(
database,
`ALTER TABLE paired_tasks ADD COLUMN reviewer_service_id TEXT`,
);
tryExecMigration(
database,
`ALTER TABLE paired_task_execution_leases ADD COLUMN expires_at TEXT`,
);
tryExecMigration(
database,
`ALTER TABLE paired_task_execution_leases ADD COLUMN claimed_service_id TEXT`,
);
tryExecMigration(
database,
`ALTER TABLE paired_task_execution_leases ADD COLUMN turn_id TEXT`,
);
tryExecMigration(
database,
`ALTER TABLE paired_task_execution_leases ADD COLUMN turn_attempt_id TEXT`,
);
tryExecMigration(
database,
`ALTER TABLE paired_task_execution_leases ADD COLUMN turn_attempt_no INTEGER`,
);
tryExecMigration(
database,
`ALTER TABLE paired_turn_attempts ADD COLUMN attempt_id TEXT`,
);
tryExecMigration(
database,
`ALTER TABLE paired_turn_attempts ADD COLUMN parent_attempt_id TEXT`,
);
tryExecMigration(
database,
`ALTER TABLE paired_turn_attempts ADD COLUMN parent_handoff_id INTEGER`,
);
tryExecMigration(
database,
`ALTER TABLE paired_turn_attempts ADD COLUMN continuation_handoff_id INTEGER`,
);
tryExecMigration(
database,
`ALTER TABLE paired_turn_attempts ADD COLUMN active_run_id TEXT`,
);
database.exec(`
CREATE INDEX IF NOT EXISTS idx_paired_turn_attempts_parent_handoff_id
ON paired_turn_attempts(parent_handoff_id)
`);
database.exec(`
CREATE INDEX IF NOT EXISTS idx_paired_turn_attempts_continuation_handoff_id
ON paired_turn_attempts(continuation_handoff_id)
`);
database.exec(`
UPDATE paired_task_execution_leases
SET expires_at = COALESCE(
expires_at,
strftime('%Y-%m-%dT%H:%M:%fZ', 'now', '+10 minutes')
)
`);
// Legacy lease rows predate claimed_service_id. Infer the original service
// from paired-task role metadata when possible instead of blanket-marking
// everything as the current service, which would let startup cleanup delete
// leases that belong to another runtime.
backfillLegacyExecutionLeaseServiceShadows(database);
database.exec(`
CREATE INDEX IF NOT EXISTS idx_paired_task_execution_leases_expires_at
ON paired_task_execution_leases(expires_at)
`);
tryExecMigration(
database,
`ALTER TABLE work_items ADD COLUMN delivery_role TEXT`,
);
tryExecMigration(
database,
`ALTER TABLE work_items ADD COLUMN service_id TEXT`,
);
tryExecMigration(
database,
`ALTER TABLE paired_turn_reservations ADD COLUMN turn_id TEXT`,
);
tryExecMigration(
database,
`ALTER TABLE paired_turn_reservations ADD COLUMN turn_attempt_id TEXT`,
);
tryExecMigration(
database,
`ALTER TABLE paired_turn_reservations ADD COLUMN turn_attempt_no INTEGER`,
);
tryExecMigration(
database,
`ALTER TABLE paired_turn_reservations ADD COLUMN turn_role TEXT`,
);
database.exec(`
UPDATE paired_turn_reservations
SET turn_id = COALESCE(
turn_id,
task_id || ':' || task_updated_at || ':' || intent_kind
)
`);
database.exec(`
UPDATE paired_turn_reservations
SET turn_role = COALESCE(
turn_role,
CASE
WHEN intent_kind = 'reviewer-turn' THEN 'reviewer'
WHEN intent_kind = 'arbiter-turn' THEN 'arbiter'
ELSE 'owner'
END
)
`);
database.exec(`
UPDATE paired_task_execution_leases
SET turn_id = COALESCE(
turn_id,
task_id || ':' || task_updated_at || ':' || intent_kind
)
`);
database.exec(
`UPDATE service_handoffs
SET target_role = COALESCE(
target_role,
intended_role,
CASE
WHEN reason LIKE 'reviewer-%' THEN 'reviewer'
WHEN reason LIKE 'arbiter-%' THEN 'arbiter'
WHEN reason IS NOT NULL THEN 'owner'
ELSE NULL
END
)
WHERE target_role IS NULL`,
);
database.exec(
`UPDATE service_handoffs
SET source_role = COALESCE(source_role, target_role, intended_role)
WHERE source_role IS NULL`,
);
database.exec(
`UPDATE service_handoffs
SET turn_role = COALESCE(turn_role, target_role, intended_role)
WHERE turn_role IS NULL`,
);
database.exec(
`UPDATE service_handoffs
SET turn_intent_kind = COALESCE(
turn_intent_kind,
CASE
WHEN turn_role = 'reviewer' THEN 'reviewer-turn'
WHEN turn_role = 'arbiter' THEN 'arbiter-turn'
ELSE turn_intent_kind
END
)`,
);
database.exec(
`UPDATE service_handoffs
SET turn_id = COALESCE(
turn_id,
CASE
WHEN paired_task_id IS NOT NULL
AND paired_task_updated_at IS NOT NULL
AND turn_intent_kind IS NOT NULL
THEN paired_task_id || ':' || paired_task_updated_at || ':' || turn_intent_kind
ELSE turn_id
END
)`,
);
backfillPairedTurnAttemptsFromTurns(database);
backfillPairedTurnAttemptIds(database);
backfillPairedTurnAttemptParentIds(database);
backfillPairedTurnAttemptActiveRunIds(database);
backfillPairedTurnAttemptProvenance(database);
backfillPairedTurnAttemptEntityIds(database);
assertPairedTurnAttemptProvenanceIntegrity(database);
dropPairedTurnAttemptProvenanceConstraints(database);
rebuildPairedTurnsWithoutLegacyScratchColumns(database);
rebuildPairedTurnAttemptForeignKeyTables(database);
applyPairedTurnAttemptProvenanceConstraints(database);
for (const column of [
'owner_service_id',
'reviewer_service_id',
'arbiter_service_id',
'owner_agent_type',
'reviewer_agent_type',
'arbiter_agent_type',
]) {
tryExecMigration(
database,
`ALTER TABLE channel_owner ADD COLUMN ${column} TEXT`,
);
}
backfillCanonicalPairedTaskServiceIds(database);
backfillCanonicalChannelOwnerServiceIds(database);
backfillCanonicalServiceHandoffServiceIds(database);
backfillCanonicalWorkItemServiceIds(database);
database.exec(
`UPDATE room_settings
SET mode_source = 'explicit'
WHERE COALESCE(mode_source, '') NOT IN ('explicit', 'inferred')`,
);
database.exec(`
UPDATE scheduled_tasks
SET agent_type = COALESCE(
(
SELECT CASE WHEN COUNT(*) = 1 THEN MIN(agent_type) ELSE NULL END
FROM registered_groups
WHERE jid = scheduled_tasks.chat_jid
AND folder = scheduled_tasks.group_folder
),
(
SELECT CASE WHEN COUNT(*) = 1 THEN MIN(agent_type) ELSE NULL END
FROM registered_groups
WHERE jid = scheduled_tasks.chat_jid
),
(
SELECT CASE WHEN COUNT(*) = 1 THEN MIN(agent_type) ELSE NULL END
FROM registered_groups
WHERE folder = scheduled_tasks.group_folder
)
)
WHERE agent_type IS NULL;
`);
try {
database.exec(
`ALTER TABLE messages ADD COLUMN is_bot_message INTEGER DEFAULT 0`,
);
database
.prepare(`UPDATE messages SET is_bot_message = 1 WHERE content LIKE ?`)
.run(`${assistantName}:%`);
} catch {
/* column already exists */
}
tryExecMigration(database, `ALTER TABLE messages ADD COLUMN seq INTEGER`);
backfillMessageSeq(database);
database.exec(`
CREATE UNIQUE INDEX IF NOT EXISTS idx_messages_seq ON messages(seq);
CREATE INDEX IF NOT EXISTS idx_messages_chat_jid_seq ON messages(chat_jid, seq);
`);
database.exec(`DROP INDEX IF EXISTS idx_work_items_group_agent;`);
database.exec(`DROP INDEX IF EXISTS idx_work_items_open;`);
database.exec(`
CREATE INDEX IF NOT EXISTS idx_work_items_group_agent
ON work_items(chat_jid, agent_type, service_id, delivery_role, status);
CREATE UNIQUE INDEX IF NOT EXISTS idx_work_items_open
ON work_items(chat_jid, agent_type, IFNULL(service_id, ''), IFNULL(delivery_role, ''))
WHERE status IN ('produced', 'delivery_retry');
`);
const roomBindingsSql = (
database
.prepare(
`SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'registered_groups'`,
)
.get() as { sql?: string } | undefined
)?.sql;
if (
roomBindingsSql &&
!roomBindingsSql.includes('PRIMARY KEY (jid, agent_type)')
) {
const registeredGroupCols = database
.prepare('PRAGMA table_info(registered_groups)')
.all() as Array<{ name: string }>;
const hasIsMain = registeredGroupCols.some((col) => col.name === 'is_main');
const hasAgentType = registeredGroupCols.some(
(col) => col.name === 'agent_type',
);
const hasWorkDir = registeredGroupCols.some(
(col) => col.name === 'work_dir',
);
const hasAgentConfig = registeredGroupCols.some(
(col) => col.name === 'agent_config',
);
const hasContainerConfig = registeredGroupCols.some(
(col) => col.name === 'container_config',
);
database.exec(`
CREATE TABLE registered_groups_new (
jid TEXT NOT NULL,
name TEXT NOT NULL,
folder TEXT NOT NULL,
trigger_pattern TEXT NOT NULL,
added_at TEXT NOT NULL,
agent_config TEXT,
requires_trigger INTEGER DEFAULT 1,
is_main INTEGER DEFAULT 0,
agent_type TEXT NOT NULL DEFAULT 'claude-code',
work_dir TEXT,
PRIMARY KEY (jid, agent_type),
UNIQUE (folder, agent_type)
);
`);
database.exec(`
INSERT INTO registered_groups_new (
jid,
name,
folder,
trigger_pattern,
added_at,
agent_config,
requires_trigger,
is_main,
agent_type,
work_dir
)
SELECT
jid,
name,
folder,
trigger_pattern,
added_at,
${
hasAgentConfig
? 'agent_config'
: hasContainerConfig
? 'container_config'
: 'NULL'
},
requires_trigger,
${hasIsMain ? 'COALESCE(is_main, 0)' : "CASE WHEN folder = 'main' THEN 1 ELSE 0 END"},
${hasAgentType ? "COALESCE(agent_type, 'claude-code')" : "'claude-code'"},
${hasWorkDir ? 'work_dir' : 'NULL'}
FROM registered_groups;
`);
database.exec(`
DROP TABLE registered_groups;
ALTER TABLE registered_groups_new RENAME TO registered_groups;
`);
} else {
database.exec(
`UPDATE registered_groups SET is_main = 1 WHERE folder = 'main' AND COALESCE(is_main, 0) = 0`,
);
}
const registeredGroupCols = database
.prepare('PRAGMA table_info(registered_groups)')
.all() as Array<{ name: string }>;
const hasAgentConfig = registeredGroupCols.some(
(col) => col.name === 'agent_config',
);
const hasContainerConfig = registeredGroupCols.some(
(col) => col.name === 'container_config',
);
if (!hasAgentConfig) {
database.exec(`ALTER TABLE registered_groups ADD COLUMN agent_config TEXT`);
}
if (hasContainerConfig) {
database.exec(
`UPDATE registered_groups
SET agent_config = COALESCE(agent_config, container_config)
WHERE container_config IS NOT NULL`,
);
}
const pairedTasksSqlRow = database
.prepare(
`SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'paired_tasks'`,
)
.get() as { sql?: string } | undefined;
const pairedTasksSql = pairedTasksSqlRow?.sql || '';
const pairedTasksNeedsRebuild =
pairedTasksSql &&
(pairedTasksSql.includes('task_policy') ||
!pairedTasksSql.includes('round_trip_count'));
if (pairedTasksNeedsRebuild) {
database.exec(`DROP TABLE IF EXISTS paired_tasks`);
database.exec(`
CREATE TABLE IF NOT EXISTS paired_tasks (
id TEXT PRIMARY KEY,
chat_jid TEXT NOT NULL,
group_folder TEXT NOT NULL,
owner_service_id TEXT NOT NULL,
reviewer_service_id TEXT NOT NULL,
owner_agent_type TEXT,
reviewer_agent_type TEXT,
arbiter_agent_type TEXT,
title TEXT,
source_ref TEXT,
plan_notes TEXT,
review_requested_at TEXT,
round_trip_count INTEGER NOT NULL DEFAULT 0,
status TEXT NOT NULL DEFAULT 'active',
arbiter_verdict TEXT,
arbiter_requested_at TEXT,
completion_reason TEXT,
created_at TEXT NOT NULL,
updated_at TEXT NOT NULL,
CHECK (status IN ('active', 'review_ready', 'in_review', 'merge_ready', 'completed', 'arbiter_requested', 'in_arbitration')),
CHECK (owner_agent_type IN ('claude-code', 'codex') OR owner_agent_type IS NULL),
CHECK (reviewer_agent_type IN ('claude-code', 'codex') OR reviewer_agent_type IS NULL),
CHECK (arbiter_agent_type IN ('claude-code', 'codex') OR arbiter_agent_type IS NULL)
);
CREATE INDEX IF NOT EXISTS idx_paired_tasks_chat_status
ON paired_tasks(chat_jid, status, updated_at);
`);
}
{
const ptSqlRow = database
.prepare(
`SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'paired_tasks'`,
)
.get() as { sql?: string } | undefined;
const ptSql = ptSqlRow?.sql || '';
if (ptSql && !ptSql.includes('arbiter_requested')) {
const pairedTaskCols = getTableColumns(database, 'paired_tasks');
const selectPairedTaskColumn = (columnName: string): string =>
pairedTaskCols.includes(columnName)
? columnName
: `NULL AS ${columnName}`;
database.exec(`
CREATE TABLE paired_tasks_new (
id TEXT PRIMARY KEY,
chat_jid TEXT NOT NULL,
group_folder TEXT NOT NULL,
owner_service_id TEXT,
reviewer_service_id TEXT,
owner_agent_type TEXT,
reviewer_agent_type TEXT,
arbiter_agent_type TEXT,
title TEXT,
source_ref TEXT,
plan_notes TEXT,
review_requested_at TEXT,
round_trip_count INTEGER NOT NULL DEFAULT 0,
status TEXT NOT NULL DEFAULT 'active',
arbiter_verdict TEXT,
arbiter_requested_at TEXT,
completion_reason TEXT,
created_at TEXT NOT NULL,
updated_at TEXT NOT NULL,
CHECK (status IN ('active', 'review_ready', 'in_review', 'merge_ready', 'completed', 'arbiter_requested', 'in_arbitration')),
CHECK (owner_agent_type IN ('claude-code', 'codex') OR owner_agent_type IS NULL),
CHECK (reviewer_agent_type IN ('claude-code', 'codex') OR reviewer_agent_type IS NULL),
CHECK (arbiter_agent_type IN ('claude-code', 'codex') OR arbiter_agent_type IS NULL)
);
INSERT INTO paired_tasks_new (
id, chat_jid, group_folder, owner_service_id, reviewer_service_id,
owner_agent_type, reviewer_agent_type,
arbiter_agent_type, title, source_ref, plan_notes, review_requested_at,
round_trip_count, status, created_at, updated_at
)
SELECT
id, chat_jid, group_folder,
${selectPairedTaskColumn('owner_service_id')},
${selectPairedTaskColumn('reviewer_service_id')},
owner_agent_type, reviewer_agent_type,
arbiter_agent_type, title, source_ref, plan_notes, review_requested_at,
round_trip_count, status, created_at, updated_at
FROM paired_tasks;
DROP TABLE paired_tasks;
ALTER TABLE paired_tasks_new RENAME TO paired_tasks;
CREATE INDEX IF NOT EXISTS idx_paired_tasks_chat_status
ON paired_tasks(chat_jid, status, updated_at);
`);
}
}
tryExecMigration(
database,
`ALTER TABLE paired_tasks ADD COLUMN completion_reason TEXT`,
);
for (const table of [
'paired_executions',
'paired_approvals',
'paired_artifacts',
'paired_events',
]) {
database.exec(`DROP TABLE IF EXISTS ${table}`);
}
const pairedWsSqlRow = database
.prepare(
`SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'paired_workspaces'`,
)
.get() as { sql?: string } | undefined;
const pairedWsSql = pairedWsSqlRow?.sql || '';
if (pairedWsSql && pairedWsSql.includes('snapshot_source_fingerprint')) {
database.exec(`DROP TABLE IF EXISTS paired_workspaces`);
database.exec(`
CREATE TABLE IF NOT EXISTS paired_workspaces (
id TEXT PRIMARY KEY,
task_id TEXT NOT NULL,
role TEXT NOT NULL,
workspace_dir TEXT NOT NULL,
snapshot_source_dir TEXT,
snapshot_ref TEXT,
status TEXT NOT NULL DEFAULT 'ready',
snapshot_refreshed_at TEXT,
created_at TEXT NOT NULL,
updated_at TEXT NOT NULL,
CHECK (role IN ('owner', 'reviewer')),
CHECK (status IN ('ready', 'stale'))
);
CREATE UNIQUE INDEX IF NOT EXISTS idx_paired_workspaces_task_role
ON paired_workspaces(task_id, role);
`);
}
const pairedProjSqlRow = database
.prepare(
`SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'paired_projects'`,
)
.get() as { sql?: string } | undefined;
const pairedProjSql = pairedProjSqlRow?.sql || '';
if (pairedProjSql && pairedProjSql.includes('workspace_topology')) {
database.exec(`DROP TABLE IF EXISTS paired_projects`);
database.exec(`
CREATE TABLE IF NOT EXISTS paired_projects (
chat_jid TEXT PRIMARY KEY,
group_folder TEXT NOT NULL,
canonical_work_dir TEXT NOT NULL,
created_at TEXT NOT NULL,
updated_at TEXT NOT NULL
);
`);
}
migrateSessionsTableToCompositePk(database, 'claude-code');
backfillLegacyServiceSessions(database, inferAgentTypeFromServiceShadow);
dropLegacyServiceSessionsTable(database);
try {
database.exec(`ALTER TABLE chats ADD COLUMN channel TEXT`);
database.exec(`ALTER TABLE chats ADD COLUMN is_group INTEGER DEFAULT 0`);
database.exec(
`UPDATE chats SET channel = 'whatsapp', is_group = 1 WHERE jid LIKE '%@g.us'`,
);
database.exec(
`UPDATE chats SET channel = 'whatsapp', is_group = 0 WHERE jid LIKE '%@s.whatsapp.net'`,
);
database.exec(
`UPDATE chats SET channel = 'discord', is_group = 1 WHERE jid LIKE 'dc:%'`,
);
database.exec(
`UPDATE chats SET channel = 'telegram', is_group = 1 WHERE jid LIKE 'tg:%'`,
);
} catch {
/* columns already exist */
}
}
Reference in New Issue View Git Blame Copy Permalink