@etiquekit/etq 1.0.14 → 1.0.16

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

@@ -1,284 +0,0 @@
-import type {
-  ApprovedNextTurnPayload,
-  ProjectionPolicy,
-  SupervisionCommandRecord,
-  SupervisionDeps,
-  SupervisionSession,
-  SupervisionTurn,
-} from '../../../protocol/src/index';
-import {
-  authorizeTurnForSeat,
-  turnMatchesApproval,
-  validateTurnBounds,
-  type TurnBoundsProposal,
-} from './action-classes';
-import { SupervisionRuntimeError } from './errors';
-import { appendSupervisionEvent, buildEvent } from './events';
-import { loadSeatManifest } from './manifest';
-import { supervisionRuntimePaths } from './paths';
-import { renderProjection, writeLatestState } from './projection';
-import { applySupervisionSchema } from './sqlite';
-import { withSupervisionTransaction } from './sqlite-impl';
-import {
-  clearSessionApproval,
-  insertCommandRow,
-  insertEventRow,
-  insertTurnRow,
-  loadPendingCommands,
-  loadSession,
-  updateSessionCurrentTurn,
-  updateSessionStatus,
-} from './store-rows';
-
-export interface TurnOpenArgs extends TurnBoundsProposal {
-  sessionId: string;
-  campaignRoot: string;
-  ownerSeat: string;
-  projectionPolicy: ProjectionPolicy;
-  seatManifestOverride?: string;
-}
-
-/**
- * Open a new turn for a supervision session.
- *
- * Enforces (in order): seat-manifest identity match, `human_only` short-
- * circuit, bounds validation, seat-capability authorization, session-running
- * gate, single-open-turn rule, approve-next-turn exact match,
- * bounded_product_mutation-requires-approval, turn-cap.
- *
- * Canonical ordering: events.jsonl first, then SQLite txn, then artifacts.
- */
-export async function openSupervisionTurn(
-  args: TurnOpenArgs,
-  deps: SupervisionDeps,
-): Promise<SupervisionTurn> {
-  const paths = supervisionRuntimePaths(args.campaignRoot);
-  const seat = await loadSeatManifest(args.seatManifestOverride);
-  if (seat.seatId !== args.ownerSeat) {
-    throw new SupervisionRuntimeError(
-      `seat manifest seatId (${seat.seatId}) does not match turn owner (${args.ownerSeat}); ` +
-        `each seat must load its own manifest`,
-      'SEAT_MISMATCH',
-    );
-  }
-
-  // human_only short-circuit: set session awaiting_human, record rejection.
-  if (args.allowedActionClass === 'human_only') {
-    await rejectHumanOnlyTurn(paths, deps, args.sessionId, args.ownerSeat);
-    throw new SupervisionRuntimeError(
-      `human_only turns may not be opened by automation`,
-      'HUMAN_ONLY',
-    );
-  }
-
-  validateTurnBounds(args);
-  authorizeTurnForSeat(args, seat);
-
-  const db = deps.openSqlite(paths.sqlitePath);
-  try {
-    applySupervisionSchema(db);
-    const session = loadSession(db, args.sessionId);
-
-    if (session.status !== 'running') {
-      throw new SupervisionRuntimeError(
-        `cannot open turn while session status is ${session.status}`,
-        'SESSION_NOT_RUNNING',
-      );
-    }
-
-    const openTurn = db.get<{ turn_id: string }>(
-      'SELECT turn_id FROM turns WHERE session_id = ? AND status = ?',
-      [args.sessionId, 'open'],
-    );
-    if (openTurn) {
-      throw new SupervisionRuntimeError(
-        `session ${args.sessionId} already has an open turn (${openTurn.turn_id})`,
-        'TURN_ALREADY_OPEN',
-      );
-    }
-
-    // If an approval blob exists, the requested turn MUST match exactly.
-    let consumedApproval = false;
-    if (session.approvedNextTurnJson) {
-      let approval: ApprovedNextTurnPayload;
-      try {
-        approval = JSON.parse(session.approvedNextTurnJson) as ApprovedNextTurnPayload;
-      } catch (err) {
-        throw new SupervisionRuntimeError(
-          `stored approvedNextTurnJson is not valid JSON: ${String(err)}`,
-          'APPROVAL_CORRUPT',
-        );
-      }
-      const cmp = turnMatchesApproval(
-        { ...args, projectionPolicy: args.projectionPolicy },
-        approval,
-      );
-      if (!cmp.matches) {
-        throw new SupervisionRuntimeError(
-          `requested turn does not match approved_next_turn: ${cmp.diffs.join('; ')}`,
-          'APPROVAL_MISMATCH',
-        );
-      }
-      consumedApproval = true;
-    } else if (args.allowedActionClass === 'bounded_product_mutation') {
-      throw new SupervisionRuntimeError(
-        `bounded_product_mutation requires a prior approve_next_turn; none is present`,
-        'APPROVAL_REQUIRED',
-      );
-    }
-
-    const nextSeq = db.get<{ max_seq: number | null }>(
-      'SELECT MAX(sequence_no) AS max_seq FROM turns WHERE session_id = ?',
-      [args.sessionId],
-    )?.max_seq;
-    const sequenceNo = (nextSeq ?? 0) + 1;
-
-    if (sequenceNo > session.turnCap) {
-      throw new SupervisionRuntimeError(
-        `turn cap exceeded: session allows ${session.turnCap}, this would be turn ${sequenceNo}`,
-        'TURN_CAP',
-      );
-    }
-
-    const now = deps.now().toISOString();
-    const turn: SupervisionTurn = {
-      turnId: deps.randomId(),
-      sessionId: args.sessionId,
-      sequenceNo,
-      status: 'open',
-      ownerSeat: args.ownerSeat,
-      allowedActionClass: args.allowedActionClass,
-      maxDurationMinutes: args.maxDurationMinutes,
-      allowedCommands: [...args.allowedCommands],
-      repoRoots: [...args.repoRoots],
-      ownedPaths: [...args.ownedPaths],
-      forbiddenPaths: [...args.forbiddenPaths],
-      verifyCommands: [...args.verifyCommands],
-      requiresHumanApproval: args.requiresHumanApproval,
-      projectionPolicy: args.projectionPolicy,
-      startedAt: now,
-      endedAt: null,
-      result: null,
-      summary: null,
-      evidenceRefs: [],
-    };
-
-    const event = buildEvent(deps, {
-      eventType: 'turn.opened',
-      sessionId: session.sessionId,
-      turnId: turn.turnId,
-      commandId: null,
-      actor: args.ownerSeat,
-      audience: 'all',
-      at: now,
-      payload: turn,
-    });
-    await appendSupervisionEvent(paths.eventsPath, event);
-
-    withSupervisionTransaction(db, () => {
-      insertTurnRow(db, turn);
-      updateSessionCurrentTurn(db, session.sessionId, turn.turnId, now);
-      if (consumedApproval) {
-        clearSessionApproval(db, session.sessionId, now);
-      }
-      insertEventRow(db, event);
-    });
-
-    const updated: SupervisionSession = {
-      ...session,
-      currentTurnId: turn.turnId,
-      approvedNextTurnJson: consumedApproval ? null : session.approvedNextTurnJson,
-      updatedAt: now,
-    };
-    await writeLatestState(paths.latestStatePath, updated, turn);
-    await renderProjection(deps, paths, updated, turn, loadPendingCommands(db, session.sessionId));
-
-    return turn;
-  } finally {
-    db.close();
-  }
-}
-
-/**
- * Side-effect path invoked when `openSupervisionTurn` receives an
- * `allowedActionClass: 'human_only'` request. Flips the session to
- * `awaiting_human` (if not already), records a rejected
- * `escalate_to_human` command, renders the updated projection, and returns.
- * The caller throws `SupervisionRuntimeError('HUMAN_ONLY')` after this
- * returns.
- */
-async function rejectHumanOnlyTurn(
-  paths: ReturnType<typeof supervisionRuntimePaths>,
-  deps: SupervisionDeps,
-  sessionId: string,
-  actor: string,
-): Promise<void> {
-  const db = deps.openSqlite(paths.sqlitePath);
-  try {
-    applySupervisionSchema(db);
-    const session = loadSession(db, sessionId);
-    const now = deps.now().toISOString();
-
-    const needsStatusFlip = session.status !== 'awaiting_human';
-    const statusEvent = needsStatusFlip
-      ? buildEvent(deps, {
-          eventType: 'session.status_changed',
-          sessionId,
-          turnId: null,
-          commandId: null,
-          actor: 'system',
-          audience: 'all',
-          at: now,
-          payload: { from: session.status, to: 'awaiting_human', reason: 'human_only_turn_attempted' },
-        })
-      : null;
-
-    const commandRecord: SupervisionCommandRecord = {
-      commandId: deps.randomId(),
-      sessionId,
-      turnId: null,
-      issuedBy: actor,
-      command: 'escalate_to_human',
-      payloadJson: JSON.stringify({ reason: 'human_only_turn_attempted' }),
-      status: 'rejected',
-      issuedAt: now,
-      appliedAt: now,
-      rejectionReason: 'human_only turns may not be opened by automation',
-    };
-    const rejectedEvent = buildEvent(deps, {
-      eventType: 'command.rejected',
-      sessionId,
-      turnId: null,
-      commandId: commandRecord.commandId,
-      actor: 'system',
-      audience: 'all',
-      at: now,
-      payload: {
-        command: 'turn-open:human_only',
-        rejectedAt: now,
-        reason: commandRecord.rejectionReason,
-      },
-    });
-
-    // Events first (canonical), then SQLite mirror in a single transaction.
-    if (statusEvent) {
-      await appendSupervisionEvent(paths.eventsPath, statusEvent);
-    }
-    await appendSupervisionEvent(paths.eventsPath, rejectedEvent);
-
-    withSupervisionTransaction(db, () => {
-      if (statusEvent) {
-        updateSessionStatus(db, sessionId, 'awaiting_human', now);
-        insertEventRow(db, statusEvent);
-      }
-      insertCommandRow(db, commandRecord);
-      insertEventRow(db, rejectedEvent);
-    });
-
-    const updated: SupervisionSession = { ...session, status: 'awaiting_human', updatedAt: now };
-    await writeLatestState(paths.latestStatePath, updated, null);
-    await renderProjection(deps, paths, updated, null, loadPendingCommands(db, sessionId));
-  } finally {
-    db.close();
-  }
-}

package/packages/control/src/sync/event-log-merge-driver.ts

@@ -1,263 +0,0 @@
-import { spawnSync } from 'node:child_process';
-import { readFileSync, writeFileSync } from 'node:fs';
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import { dirname, join, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-export const EVENT_LOG_MERGE_DRIVER_SCHEMA = 'event-log-merge-driver-install.v0' as const;
-export const EVENT_LOG_MERGE_DRIVER_STATUS_SCHEMA = 'event-log-merge-driver-status.v0' as const;
-export const DEFAULT_EVENT_LOG_MERGE_DRIVER = 'etqseq';
-export const EVENT_LOG_ATTRIBUTE_PATTERN = '.etiquette/events/*.ndjson';
-
-export interface EventLogMergeDriverInstallResult {
-  schema: typeof EVENT_LOG_MERGE_DRIVER_SCHEMA;
-  driver_name: string;
-  attributes_ref: '.gitattributes';
-  attributes_rule: string;
-  gitattributes_updated: boolean;
-  git_config_updated: boolean;
-  git_config_present: boolean;
-  warnings: string[];
-  authority_boundary: EventLogMergeDriverAuthorityBoundary;
-}
-
-export interface EventLogMergeDriverStatus {
-  schema: typeof EVENT_LOG_MERGE_DRIVER_STATUS_SCHEMA;
-  driver_name: string;
-  attributes_ref: '.gitattributes';
-  attributes_configured: boolean;
-  git_config_present: boolean;
-  git_config_configured: boolean;
-  ready: boolean;
-  warnings: string[];
-  authority_boundary: EventLogMergeDriverAuthorityBoundary;
-}
-
-interface EventLogMergeDriverAuthorityBoundary {
-  can_authorize_work: false;
-  can_execute_work: false;
-  can_grant: false;
-  can_close_work: false;
-  can_merge_product_code: false;
-  configures_git_merge_driver_only: true;
-}
-
-export interface InstallEventLogMergeDriverOptions {
-  projectRoot: string;
-  driverName?: string;
-  configureGit?: boolean;
-  driverCommand?: string;
-}
-
-export interface EventLogMergeDriverStatusOptions {
-  projectRoot: string;
-  driverName?: string;
-}
-
-export interface MergeAppendOnlyEventLogsOptions {
-  ancestorPath: string;
-  currentPath: string;
-  otherPath: string;
-}
-
-function authorityBoundary(): EventLogMergeDriverAuthorityBoundary {
-  return {
-    can_authorize_work: false,
-    can_execute_work: false,
-    can_grant: false,
-    can_close_work: false,
-    can_merge_product_code: false,
-    configures_git_merge_driver_only: true,
-  };
-}
-
-function assertDriverName(value: string): string {
-  if (!/^[A-Za-z0-9][A-Za-z0-9_-]{0,31}$/.test(value)) {
-    throw new Error('--driver-name must be an opaque Git merge driver name');
-  }
-  return value;
-}
-
-function attributesRule(driverName: string): string {
-  return `${EVENT_LOG_ATTRIBUTE_PATTERN} merge=${driverName}`;
-}
-
-async function readTextIfExists(path: string): Promise<string> {
-  try {
-    return await readFile(path, 'utf8');
-  } catch (err) {
-    const code = (err as NodeJS.ErrnoException).code;
-    if (code === 'ENOENT') return '';
-    throw err;
-  }
-}
-
-function shellQuote(value: string): string {
-  return `'${value.replace(/'/g, "'\\''")}'`;
-}
-
-function defaultDriverCommand(): string {
-  const cliPath = resolve(dirname(fileURLToPath(import.meta.url)), '..', 'cli.ts');
-  return `bun ${shellQuote(cliPath)} sync event-log-merge-driver %O %A %B`;
-}
-
-function gitConfigGet(projectRoot: string, key: string): string | null {
-  const result = spawnSync('git', ['-C', projectRoot, 'config', '--get', key], { encoding: 'utf8' });
-  if (result.status !== 0) return null;
-  return result.stdout.trim() || null;
-}
-
-function gitConfigSet(projectRoot: string, key: string, value: string): boolean {
-  const result = spawnSync('git', ['-C', projectRoot, 'config', key, value], { encoding: 'utf8' });
-  if (result.status !== 0) {
-    throw new Error(`git config failed for ${key}: ${result.stderr.trim() || result.status}`);
-  }
-  return true;
-}
-
-function isGitWorktree(projectRoot: string): boolean {
-  return spawnSync('git', ['-C', projectRoot, 'rev-parse', '--is-inside-work-tree'], {
-    encoding: 'utf8',
-  }).status === 0;
-}
-
-function attributesConfigured(text: string, driverName: string): boolean {
-  return text
-    .split(/\r?\n/)
-    .map((line) => line.trim())
-    .some((line) => line === attributesRule(driverName));
-}
-
-function gitConfigConfigured(projectRoot: string, driverName: string): boolean {
-  const command = gitConfigGet(projectRoot, `merge.${driverName}.driver`);
-  return Boolean(command?.includes('sync event-log-merge-driver'));
-}
-
-export async function installEventLogMergeDriver(
-  options: InstallEventLogMergeDriverOptions,
-): Promise<EventLogMergeDriverInstallResult> {
-  const projectRoot = resolve(options.projectRoot);
-  const driverName = assertDriverName(options.driverName ?? DEFAULT_EVENT_LOG_MERGE_DRIVER);
-  const rule = attributesRule(driverName);
-  const attributesPath = join(projectRoot, '.gitattributes');
-  const previous = await readTextIfExists(attributesPath);
-  const hadRule = attributesConfigured(previous, driverName);
-  let gitattributesUpdated = false;
-
-  if (!hadRule) {
-    const next = previous.trim().length === 0
-      ? `${rule}\n`
-      : `${previous.replace(/\n*$/, '\n')}${rule}\n`;
-    await mkdir(dirname(attributesPath), { recursive: true });
-    await writeFile(attributesPath, next);
-    gitattributesUpdated = true;
-  }
-
-  const warnings: string[] = [];
-  let gitConfigUpdated = false;
-  const gitConfigPresent = isGitWorktree(projectRoot);
-  if (!gitConfigPresent) {
-    warnings.push('project is not a Git worktree; local merge driver config was not written');
-  } else if (options.configureGit !== false) {
-    gitConfigSet(projectRoot, `merge.${driverName}.name`, 'Etiquette event log seq resequencer');
-    gitConfigSet(projectRoot, `merge.${driverName}.driver`, options.driverCommand ?? defaultDriverCommand());
-    gitConfigUpdated = true;
-  }
-
-  return {
-    schema: EVENT_LOG_MERGE_DRIVER_SCHEMA,
-    driver_name: driverName,
-    attributes_ref: '.gitattributes',
-    attributes_rule: rule,
-    gitattributes_updated: gitattributesUpdated,
-    git_config_updated: gitConfigUpdated,
-    git_config_present: gitConfigPresent,
-    warnings,
-    authority_boundary: authorityBoundary(),
-  };
-}
-
-export async function inspectEventLogMergeDriver(
-  options: EventLogMergeDriverStatusOptions,
-): Promise<EventLogMergeDriverStatus> {
-  const projectRoot = resolve(options.projectRoot);
-  const driverName = assertDriverName(options.driverName ?? DEFAULT_EVENT_LOG_MERGE_DRIVER);
-  const attributes = await readTextIfExists(join(projectRoot, '.gitattributes'));
-  const attrReady = attributesConfigured(attributes, driverName);
-  const gitReady = isGitWorktree(projectRoot);
-  const gitConfigured = gitReady ? gitConfigConfigured(projectRoot, driverName) : false;
-  const warnings: string[] = [];
-  if (!attrReady) warnings.push('missing .gitattributes event-log merge rule');
-  if (!gitReady) warnings.push('project is not a Git worktree');
-  else if (!gitConfigured) warnings.push('missing local git merge driver config');
-
-  return {
-    schema: EVENT_LOG_MERGE_DRIVER_STATUS_SCHEMA,
-    driver_name: driverName,
-    attributes_ref: '.gitattributes',
-    attributes_configured: attrReady,
-    git_config_present: gitReady,
-    git_config_configured: gitConfigured,
-    ready: attrReady && gitConfigured,
-    warnings,
-    authority_boundary: authorityBoundary(),
-  };
-}
-
-function readLines(path: string): string[] {
-  const text = readFileSync(path, 'utf8');
-  if (text === '') return [];
-  return text.replace(/\n+$/, '').split('\n');
-}
-
-function beginsWith(full: string[], prefix: string[]): boolean {
-  return prefix.length <= full.length && prefix.every((line, index) => full[index] === line);
-}
-
-function parseLine(line: string, label: string, index: number): Record<string, unknown> {
-  try {
-    const event = JSON.parse(line) as Record<string, unknown>;
-    if (!Number.isInteger(event.seq)) {
-      throw new Error('seq is not an integer');
-    }
-    return event;
-  } catch (err) {
-    throw new Error(`${label} appended line ${index + 1} is not a valid event: ${(err as Error).message}`);
-  }
-}
-
-function seqOfExisting(line: string): number | null {
-  try {
-    const event = JSON.parse(line) as { seq?: unknown };
-    return typeof event.seq === 'number' && Number.isInteger(event.seq) ? event.seq : null;
-  } catch {
-    return null;
-  }
-}
-
-export function mergeAppendOnlyEventLogs(options: MergeAppendOnlyEventLogsOptions): void {
-  const ancestor = readLines(options.ancestorPath);
-  const current = readLines(options.currentPath);
-  const other = readLines(options.otherPath);
-
-  if (!beginsWith(current, ancestor) || !beginsWith(other, ancestor)) {
-    throw new Error('non-append edit detected; refusing automatic event-log merge');
-  }
-
-  const currentAppend = current.slice(ancestor.length);
-  const otherAppend = other.slice(ancestor.length);
-  currentAppend.forEach((line, index) => parseLine(line, 'current', index));
-
-  const kept = [...ancestor, ...currentAppend];
-  const keptSeqs = kept.map(seqOfExisting).filter((seq): seq is number => seq !== null);
-  let nextSeq = (keptSeqs.length ? Math.max(...keptSeqs) : 0) + 1;
-
-  const resequenced = otherAppend.map((line, index) => {
-    const event = parseLine(line, 'other', index);
-    event.seq = nextSeq;
-    nextSeq += 1;
-    return JSON.stringify(event);
-  });
-
-  writeFileSync(options.currentPath, `${[...kept, ...resequenced].join('\n')}\n`);
-}