@etiquekit/etq 1.0.14 → 1.0.16

package/packages/control/src/supervision/store-rows.ts

@@ -1,371 +0,0 @@
-/**
- * SQLite row mapping for the supervision hot store.
- *
- * Holds every `INSERT` / `UPDATE` / `SELECT` helper plus the row interfaces
- * and the `row → domain object` mappers. No I/O beyond the single `db.run` /
- * `db.get` / `db.all` calls. Transaction scoping is the caller's concern
- * (see `sqlite-impl.ts :: withSupervisionTransaction`).
- */
-import type {
-  ActionClass,
-  AllowedCommandId,
-  ProjectionPolicy,
-  SessionStatus,
-  SupervisionCommand,
-  SupervisionCommandRecord,
-  SupervisionDeps,
-  SupervisionEvent,
-  SupervisionSession,
-  SupervisionTurn,
-  TurnResult,
-} from '../../../protocol/src/index';
-import { SupervisionRuntimeError } from './errors';
-
-// ---------------------------------------------------------------------------
-// INSERT helpers
-// ---------------------------------------------------------------------------
-
-export function insertSessionRow(
-  db: ReturnType<SupervisionDeps['openSqlite']>,
-  s: SupervisionSession,
-): void {
-  db.run(
-    `INSERT INTO sessions (
-      session_id, campaign_root, topic, objective, status,
-      lead_seat, responder_seat, escalation_owner,
-      time_cap_minutes, turn_cap,
-      current_turn_id, next_owner_hint, approved_next_turn_json, last_blocker_json,
-      source_refs_json, created_at, updated_at
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-    [
-      s.sessionId, s.campaignRoot, s.topic, s.objective, s.status,
-      s.leadSeat, s.responderSeat, s.escalationOwner,
-      s.timeCapMinutes, s.turnCap,
-      s.currentTurnId, s.nextOwnerHint, s.approvedNextTurnJson, s.lastBlockerJson,
-      JSON.stringify(s.sourceRefs), s.createdAt, s.updatedAt,
-    ],
-  );
-}
-
-export function insertTurnRow(
-  db: ReturnType<SupervisionDeps['openSqlite']>,
-  t: SupervisionTurn,
-): void {
-  db.run(
-    `INSERT INTO turns (
-      turn_id, session_id, sequence_no, status, owner_seat,
-      allowed_action_class, max_duration_minutes, allowed_commands_json,
-      repo_roots_json, owned_paths_json, forbidden_paths_json, verify_commands_json,
-      requires_human_approval, projection_policy,
-      started_at, ended_at, result, summary, evidence_refs_json
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-    [
-      t.turnId, t.sessionId, t.sequenceNo, t.status, t.ownerSeat,
-      t.allowedActionClass, t.maxDurationMinutes, JSON.stringify(t.allowedCommands),
-      JSON.stringify(t.repoRoots), JSON.stringify(t.ownedPaths),
-      JSON.stringify(t.forbiddenPaths), JSON.stringify(t.verifyCommands),
-      t.requiresHumanApproval ? 1 : 0, t.projectionPolicy,
-      t.startedAt, t.endedAt, t.result, t.summary, JSON.stringify(t.evidenceRefs),
-    ],
-  );
-}
-
-export function insertCommandRow(
-  db: ReturnType<SupervisionDeps['openSqlite']>,
-  c: SupervisionCommandRecord,
-): void {
-  db.run(
-    `INSERT INTO commands (
-      command_id, session_id, turn_id, issued_by, command, payload_json,
-      status, issued_at, applied_at, rejection_reason
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-    [
-      c.commandId, c.sessionId, c.turnId, c.issuedBy, c.command, c.payloadJson,
-      c.status, c.issuedAt, c.appliedAt, c.rejectionReason,
-    ],
-  );
-}
-
-export function insertEventRow(
-  db: ReturnType<SupervisionDeps['openSqlite']>,
-  event: SupervisionEvent,
-): void {
-  db.run(
-    `INSERT INTO events (
-      event_id, session_id, turn_id, command_id, event_type,
-      actor, audience, at, payload_json
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-    [
-      event.eventId, event.sessionId, event.turnId, event.commandId, event.eventType,
-      event.actor, event.audience, event.at, JSON.stringify(event.payload ?? null),
-    ],
-  );
-}
-
-// ---------------------------------------------------------------------------
-// UPDATE helpers
-// ---------------------------------------------------------------------------
-
-export function updateSessionStatus(
-  db: ReturnType<SupervisionDeps['openSqlite']>,
-  sessionId: string,
-  status: SessionStatus,
-  at: string,
-): void {
-  db.run('UPDATE sessions SET status = ?, updated_at = ? WHERE session_id = ?', [status, at, sessionId]);
-}
-
-export function updateSessionNextOwner(
-  db: ReturnType<SupervisionDeps['openSqlite']>,
-  sessionId: string,
-  nextOwner: string | null,
-  at: string,
-): void {
-  db.run('UPDATE sessions SET next_owner_hint = ?, updated_at = ? WHERE session_id = ?', [
-    nextOwner, at, sessionId,
-  ]);
-}
-
-export function updateSessionApproval(
-  db: ReturnType<SupervisionDeps['openSqlite']>,
-  sessionId: string,
-  approvalJson: string | null,
-  at: string,
-): void {
-  db.run('UPDATE sessions SET approved_next_turn_json = ?, updated_at = ? WHERE session_id = ?', [
-    approvalJson, at, sessionId,
-  ]);
-}
-
-export function updateSessionBlocker(
-  db: ReturnType<SupervisionDeps['openSqlite']>,
-  sessionId: string,
-  blockerJson: string | null,
-  at: string,
-): void {
-  db.run('UPDATE sessions SET last_blocker_json = ?, updated_at = ? WHERE session_id = ?', [
-    blockerJson, at, sessionId,
-  ]);
-}
-
-export function updateSessionCurrentTurn(
-  db: ReturnType<SupervisionDeps['openSqlite']>,
-  sessionId: string,
-  turnId: string,
-  at: string,
-): void {
-  db.run('UPDATE sessions SET current_turn_id = ?, updated_at = ? WHERE session_id = ?', [
-    turnId, at, sessionId,
-  ]);
-}
-
-export function clearSessionCurrentTurn(
-  db: ReturnType<SupervisionDeps['openSqlite']>,
-  sessionId: string,
-  at: string,
-): void {
-  db.run('UPDATE sessions SET current_turn_id = NULL, updated_at = ? WHERE session_id = ?', [at, sessionId]);
-}
-
-export function clearSessionApproval(
-  db: ReturnType<SupervisionDeps['openSqlite']>,
-  sessionId: string,
-  at: string,
-): void {
-  db.run('UPDATE sessions SET approved_next_turn_json = NULL, updated_at = ? WHERE session_id = ?', [at, sessionId]);
-}
-
-export function updateTurnOnClose(
-  db: ReturnType<SupervisionDeps['openSqlite']>,
-  t: SupervisionTurn,
-): void {
-  db.run(
-    `UPDATE turns SET status = ?, ended_at = ?, result = ?, summary = ?, evidence_refs_json = ? WHERE turn_id = ?`,
-    [t.status, t.endedAt, t.result, t.summary, JSON.stringify(t.evidenceRefs), t.turnId],
-  );
-}
-
-export function updateCommandApplied(
-  db: ReturnType<SupervisionDeps['openSqlite']>,
-  commandId: string,
-  at: string,
-): void {
-  db.run(
-    `UPDATE commands SET status = 'applied', applied_at = ? WHERE command_id = ?`,
-    [at, commandId],
-  );
-}
-
-export function updateCommandRejected(
-  db: ReturnType<SupervisionDeps['openSqlite']>,
-  commandId: string,
-  at: string,
-  reason: string,
-): void {
-  db.run(
-    `UPDATE commands SET status = 'rejected', applied_at = ?, rejection_reason = ? WHERE command_id = ?`,
-    [at, reason, commandId],
-  );
-}
-
-// ---------------------------------------------------------------------------
-// SELECT / row → domain mappers
-// ---------------------------------------------------------------------------
-
-interface SessionRow {
-  session_id: string;
-  campaign_root: string;
-  topic: string;
-  objective: string;
-  status: SessionStatus;
-  lead_seat: string;
-  responder_seat: string;
-  escalation_owner: string;
-  time_cap_minutes: number;
-  turn_cap: number;
-  current_turn_id: string | null;
-  next_owner_hint: string | null;
-  approved_next_turn_json: string | null;
-  last_blocker_json: string | null;
-  source_refs_json: string;
-  created_at: string;
-  updated_at: string;
-}
-
-export function loadSession(
-  db: ReturnType<SupervisionDeps['openSqlite']>,
-  sessionId: string,
-): SupervisionSession {
-  const row = db.get<SessionRow>('SELECT * FROM sessions WHERE session_id = ?', [sessionId]);
-  if (!row) {
-    throw new SupervisionRuntimeError(`session ${sessionId} not found`, 'SESSION_NOT_FOUND');
-  }
-  return rowToSession(row);
-}
-
-function rowToSession(row: SessionRow): SupervisionSession {
-  return {
-    sessionId: row.session_id,
-    campaignRoot: row.campaign_root,
-    topic: row.topic,
-    objective: row.objective,
-    status: row.status,
-    leadSeat: row.lead_seat,
-    responderSeat: row.responder_seat,
-    escalationOwner: row.escalation_owner,
-    timeCapMinutes: row.time_cap_minutes,
-    turnCap: row.turn_cap,
-    currentTurnId: row.current_turn_id,
-    nextOwnerHint: row.next_owner_hint,
-    approvedNextTurnJson: row.approved_next_turn_json,
-    lastBlockerJson: row.last_blocker_json,
-    sourceRefs: JSON.parse(row.source_refs_json) as string[],
-    createdAt: row.created_at,
-    updatedAt: row.updated_at,
-  };
-}
-
-interface TurnRow {
-  turn_id: string;
-  session_id: string;
-  sequence_no: number;
-  status: 'open' | 'closed';
-  owner_seat: string;
-  allowed_action_class: ActionClass;
-  max_duration_minutes: number;
-  allowed_commands_json: string;
-  repo_roots_json: string;
-  owned_paths_json: string;
-  forbidden_paths_json: string;
-  verify_commands_json: string;
-  requires_human_approval: number;
-  projection_policy: ProjectionPolicy;
-  started_at: string;
-  ended_at: string | null;
-  result: TurnResult | null;
-  summary: string | null;
-  evidence_refs_json: string;
-}
-
-export function loadTurn(
-  db: ReturnType<SupervisionDeps['openSqlite']>,
-  turnId: string,
-): SupervisionTurn {
-  const row = db.get<TurnRow>('SELECT * FROM turns WHERE turn_id = ?', [turnId]);
-  if (!row) {
-    throw new SupervisionRuntimeError(`turn ${turnId} not found`, 'TURN_NOT_FOUND');
-  }
-  return rowToTurn(row);
-}
-
-export function loadCurrentTurn(
-  db: ReturnType<SupervisionDeps['openSqlite']>,
-  session: SupervisionSession,
-): SupervisionTurn | null {
-  if (!session.currentTurnId) return null;
-  const row = db.get<TurnRow>('SELECT * FROM turns WHERE turn_id = ?', [session.currentTurnId]);
-  return row ? rowToTurn(row) : null;
-}
-
-function rowToTurn(row: TurnRow): SupervisionTurn {
-  return {
-    turnId: row.turn_id,
-    sessionId: row.session_id,
-    sequenceNo: row.sequence_no,
-    status: row.status,
-    ownerSeat: row.owner_seat,
-    allowedActionClass: row.allowed_action_class,
-    maxDurationMinutes: row.max_duration_minutes,
-    allowedCommands: JSON.parse(row.allowed_commands_json) as AllowedCommandId[],
-    repoRoots: JSON.parse(row.repo_roots_json) as string[],
-    ownedPaths: JSON.parse(row.owned_paths_json) as string[],
-    forbiddenPaths: JSON.parse(row.forbidden_paths_json) as string[],
-    verifyCommands: JSON.parse(row.verify_commands_json) as string[],
-    requiresHumanApproval: row.requires_human_approval === 1,
-    projectionPolicy: row.projection_policy,
-    startedAt: row.started_at,
-    endedAt: row.ended_at,
-    result: row.result,
-    summary: row.summary,
-    evidenceRefs: JSON.parse(row.evidence_refs_json) as string[],
-  };
-}
-
-interface CommandRow {
-  command_id: string;
-  session_id: string;
-  turn_id: string | null;
-  issued_by: string;
-  command: SupervisionCommand;
-  payload_json: string;
-  status: SupervisionCommandRecord['status'];
-  issued_at: string;
-  applied_at: string | null;
-  rejection_reason: string | null;
-}
-
-export function loadPendingCommands(
-  db: ReturnType<SupervisionDeps['openSqlite']>,
-  sessionId: string,
-): SupervisionCommandRecord[] {
-  const rows = db.all<CommandRow>(
-    'SELECT * FROM commands WHERE session_id = ? AND status = ? ORDER BY issued_at ASC',
-    [sessionId, 'queued'],
-  );
-  return rows.map(rowToCommand);
-}
-
-function rowToCommand(row: CommandRow): SupervisionCommandRecord {
-  return {
-    commandId: row.command_id,
-    sessionId: row.session_id,
-    turnId: row.turn_id,
-    issuedBy: row.issued_by,
-    command: row.command,
-    payloadJson: row.payload_json,
-    status: row.status,
-    issuedAt: row.issued_at,
-    appliedAt: row.applied_at,
-    rejectionReason: row.rejection_reason,
-  };
-}

package/packages/control/src/supervision/turn-close.ts

@@ -1,154 +0,0 @@
-import type {
-  SessionStatus,
-  SupervisionDeps,
-  SupervisionSession,
-  SupervisionTurn,
-  TurnResult,
-} from '../../../protocol/src/index';
-import { SupervisionRuntimeError } from './errors';
-import { appendSupervisionEvent, buildEvent } from './events';
-import { supervisionRuntimePaths } from './paths';
-import { renderProjection, writeLatestState } from './projection';
-import { applySupervisionSchema } from './sqlite';
-import { withSupervisionTransaction } from './sqlite-impl';
-import {
-  clearSessionApproval,
-  clearSessionCurrentTurn,
-  insertEventRow,
-  loadPendingCommands,
-  loadSession,
-  loadTurn,
-  updateSessionStatus,
-  updateTurnOnClose,
-} from './store-rows';
-
-export interface TurnCloseArgs {
-  sessionId: string;
-  campaignRoot: string;
-  turnId: string;
-  result: TurnResult;
-  summary: string;
-  evidenceRefs: string[];
-}
-
-/**
- * Close an open turn with the given result. Derives the next session status
- * from the result per PHASE1.md § Turn semantics:
- *   - done / handed_off → running
- *   - blocked          → blocked
- *   - stopped / timed_out → awaiting_human (also clears any stored approval)
- *
- * Canonical ordering: events.jsonl first (turn.closed + optional
- * session.status_changed), then one SQLite txn, then artifacts.
- */
-export async function closeSupervisionTurn(
-  args: TurnCloseArgs,
-  deps: SupervisionDeps,
-): Promise<SupervisionTurn> {
-  const paths = supervisionRuntimePaths(args.campaignRoot);
-  const db = deps.openSqlite(paths.sqlitePath);
-  try {
-    applySupervisionSchema(db);
-    const session = loadSession(db, args.sessionId);
-    const turn = loadTurn(db, args.turnId);
-    if (turn.sessionId !== args.sessionId) {
-      throw new SupervisionRuntimeError(
-        `turn ${args.turnId} does not belong to session ${args.sessionId}`,
-        'TURN_SESSION_MISMATCH',
-      );
-    }
-    if (turn.status !== 'open') {
-      throw new SupervisionRuntimeError(
-        `turn ${args.turnId} is not open (status=${turn.status})`,
-        'TURN_NOT_OPEN',
-      );
-    }
-
-    const now = deps.now().toISOString();
-    const updatedTurn: SupervisionTurn = {
-      ...turn,
-      status: 'closed',
-      endedAt: now,
-      result: args.result,
-      summary: args.summary,
-      evidenceRefs: [...args.evidenceRefs],
-    };
-
-    // Derive next session status from result.
-    const nextStatus: SessionStatus =
-      args.result === 'done' || args.result === 'handed_off'
-        ? 'running'
-        : args.result === 'blocked'
-          ? 'blocked'
-          : 'awaiting_human';
-    const statusChanged = nextStatus !== session.status;
-    const clearApproval = nextStatus === 'awaiting_human' && !!session.approvedNextTurnJson;
-
-    const turnEvent = buildEvent(deps, {
-      eventType: 'turn.closed',
-      sessionId: args.sessionId,
-      turnId: turn.turnId,
-      commandId: null,
-      actor: turn.ownerSeat,
-      audience: 'all',
-      at: now,
-      payload: {
-        endedAt: now,
-        result: args.result,
-        summary: args.summary,
-        evidenceRefs: [...args.evidenceRefs],
-      },
-    });
-    const statusEvent = statusChanged
-      ? buildEvent(deps, {
-          eventType: 'session.status_changed',
-          sessionId: session.sessionId,
-          turnId: null,
-          commandId: null,
-          actor: 'system',
-          audience: 'all',
-          at: now,
-          payload: { from: session.status, to: nextStatus, reason: `turn_closed:${args.result}` },
-        })
-      : null;
-
-    // Events first (canonical), then SQLite mirror in a single transaction.
-    await appendSupervisionEvent(paths.eventsPath, turnEvent);
-    if (statusEvent) {
-      await appendSupervisionEvent(paths.eventsPath, statusEvent);
-    }
-
-    withSupervisionTransaction(db, () => {
-      updateTurnOnClose(db, updatedTurn);
-      clearSessionCurrentTurn(db, session.sessionId, now);
-      insertEventRow(db, turnEvent);
-      if (statusEvent) {
-        updateSessionStatus(db, session.sessionId, nextStatus, now);
-        insertEventRow(db, statusEvent);
-      }
-      if (clearApproval) {
-        clearSessionApproval(db, session.sessionId, now);
-      }
-    });
-
-    const sessionForOutputs: SupervisionSession = {
-      ...session,
-      currentTurnId: null,
-      status: nextStatus,
-      approvedNextTurnJson: clearApproval ? null : session.approvedNextTurnJson,
-      updatedAt: now,
-    };
-
-    await writeLatestState(paths.latestStatePath, sessionForOutputs, null);
-    await renderProjection(
-      deps,
-      paths,
-      sessionForOutputs,
-      null,
-      loadPendingCommands(db, session.sessionId),
-    );
-    return updatedTurn;
-  } finally {
-    db.close();
-  }
-}