@etiquekit/etq 1.0.13 → 1.0.15

package/packages/protocol/src/incident.ts

@@ -1,251 +0,0 @@
-import { z } from 'zod';
-
-export const INCIDENT_SEVERITIES = ['sev0', 'sev1', 'sev2', 'sev3', 'sev4'] as const;
-export const INCIDENT_STATUSES = ['detected', 'acknowledged', 'mitigating', 'resolved', 'closed'] as const;
-export const INCIDENT_BUSINESS_CONTEXT_STATUSES = ['absent', 'partial', 'provided'] as const;
-export const INCIDENT_ROOT_CAUSE_STATUSES = ['unknown', 'suspected', 'confirmed'] as const;
-export const INCIDENT_FOLLOW_UP_STATUSES = ['open', 'deferred', 'done'] as const;
-
-export type IncidentSeverity = (typeof INCIDENT_SEVERITIES)[number];
-export type IncidentStatus = (typeof INCIDENT_STATUSES)[number];
-export type IncidentBusinessContextStatus = (typeof INCIDENT_BUSINESS_CONTEXT_STATUSES)[number];
-export type IncidentRootCauseStatus = (typeof INCIDENT_ROOT_CAUSE_STATUSES)[number];
-export type IncidentFollowUpStatus = (typeof INCIDENT_FOLLOW_UP_STATUSES)[number];
-
-const nonEmptyString = z.string().trim().min(1);
-const stringList = z.array(nonEmptyString);
-
-function looksLikeChatMemoryPath(value: string): boolean {
-  const normalized = value.toLowerCase();
-  return (
-    normalized.includes('chat-history') ||
-    normalized.includes('chat_history') ||
-    normalized.includes('chatlog') ||
-    normalized.includes('chat-memory') ||
-    normalized.includes('conversation-log') ||
-    normalized.includes('transcript')
-  );
-}
-
-function addEvidenceRefIssues(refs: string[], path: (string | number)[], ctx: z.RefinementCtx): void {
-  for (const [index, ref] of refs.entries()) {
-    if (looksLikeChatMemoryPath(ref)) {
-      ctx.addIssue({
-        code: 'custom',
-        path: [...path, index],
-        message: 'incident evidence_refs must point to durable proof, not chat logs or transcripts',
-      });
-    }
-  }
-}
-
-const IncidentBusinessContextV1Schema = z.object({
-  customer_impact: nonEmptyString.optional(),
-  sla_tier: nonEmptyString.optional(),
-  revenue_exposure: nonEmptyString.optional(),
-  compliance_implication: nonEmptyString.optional(),
-}).default({});
-
-const IncidentTimelineEventV1Schema = z.object({
-  at: nonEmptyString,
-  actor: nonEmptyString,
-  action: nonEmptyString,
-  evidence_refs: z.array(nonEmptyString).default([]),
-});
-
-const IncidentDecisionV1Schema = z.object({
-  at: nonEmptyString,
-  actor: nonEmptyString,
-  decision: nonEmptyString,
-  rationale: nonEmptyString,
-  evidence_refs: z.array(nonEmptyString).default([]),
-});
-
-const IncidentFollowUpV1Schema = z.object({
-  id: nonEmptyString,
-  title: nonEmptyString,
-  owner: nonEmptyString,
-  status: z.enum(INCIDENT_FOLLOW_UP_STATUSES),
-  evidence_refs: z.array(nonEmptyString).default([]),
-});
-
-export const IncidentReceiptV1Schema = z.object({
-  schema_version: z.literal('incident-receipt.v1'),
-  incident_id: nonEmptyString,
-  title: nonEmptyString,
-  severity: z.enum(INCIDENT_SEVERITIES),
-  severity_rationale: nonEmptyString.optional(),
-  status: z.enum(INCIDENT_STATUSES),
-  incident_class: nonEmptyString.optional(),
-  started_at: nonEmptyString,
-  detected_at: nonEmptyString,
-  acknowledged_at: nonEmptyString.optional(),
-  resolved_at: nonEmptyString.optional(),
-  acknowledged_by: nonEmptyString.optional(),
-  resolved_by: nonEmptyString.optional(),
-  detection_source: nonEmptyString.optional(),
-  notification_chain: z.array(nonEmptyString).default([]),
-  affected_systems: stringList.min(1),
-  symptoms: stringList.min(1),
-  timeline: z.array(IncidentTimelineEventV1Schema).min(1),
-  decisions: z.array(IncidentDecisionV1Schema).default([]),
-  evidence_refs: stringList.min(1),
-  mitigation: nonEmptyString.optional(),
-  rollback_or_fix_refs: z.array(nonEmptyString).default([]),
-  validation_refs: z.array(nonEmptyString).default([]),
-  follow_ups: z.array(IncidentFollowUpV1Schema).default([]),
-  business_context_status: z.enum(INCIDENT_BUSINESS_CONTEXT_STATUSES),
-  business_context: IncidentBusinessContextV1Schema,
-  root_cause_status: z.enum(INCIDENT_ROOT_CAUSE_STATUSES).default('unknown'),
-  root_cause_evidence_refs: z.array(nonEmptyString).default([]),
-  runbook_executed_ref: nonEmptyString.optional(),
-}).superRefine((receipt, ctx) => {
-  addEvidenceRefIssues(receipt.evidence_refs, ['evidence_refs'], ctx);
-  addEvidenceRefIssues(receipt.rollback_or_fix_refs, ['rollback_or_fix_refs'], ctx);
-  addEvidenceRefIssues(receipt.validation_refs, ['validation_refs'], ctx);
-  addEvidenceRefIssues(receipt.root_cause_evidence_refs, ['root_cause_evidence_refs'], ctx);
-
-  for (const [index, event] of receipt.timeline.entries()) {
-    addEvidenceRefIssues(event.evidence_refs, ['timeline', index, 'evidence_refs'], ctx);
-  }
-  for (const [index, decision] of receipt.decisions.entries()) {
-    addEvidenceRefIssues(decision.evidence_refs, ['decisions', index, 'evidence_refs'], ctx);
-  }
-  for (const [index, followUp] of receipt.follow_ups.entries()) {
-    addEvidenceRefIssues(followUp.evidence_refs, ['follow_ups', index, 'evidence_refs'], ctx);
-  }
-
-  if (receipt.runbook_executed_ref && looksLikeChatMemoryPath(receipt.runbook_executed_ref)) {
-    ctx.addIssue({
-      code: 'custom',
-      path: ['runbook_executed_ref'],
-      message: 'runbook_executed_ref must point to a durable runbook receipt or proof ref',
-    });
-  }
-
-  if (['resolved', 'closed'].includes(receipt.status)) {
-    if (!receipt.resolved_at) {
-      ctx.addIssue({
-        code: 'custom',
-        path: ['resolved_at'],
-        message: 'resolved or closed incidents must include resolved_at',
-      });
-    }
-    if (!receipt.resolved_by) {
-      ctx.addIssue({
-        code: 'custom',
-        path: ['resolved_by'],
-        message: 'resolved or closed incidents must include resolved_by',
-      });
-    }
-  }
-
-  if (receipt.root_cause_status === 'confirmed' && receipt.root_cause_evidence_refs.length === 0) {
-    ctx.addIssue({
-      code: 'custom',
-      path: ['root_cause_evidence_refs'],
-      message: 'confirmed root cause requires at least one root_cause_evidence_ref',
-    });
-  }
-
-  const context = receipt.business_context;
-  const contextValues = [
-    context.customer_impact,
-    context.sla_tier,
-    context.revenue_exposure,
-    context.compliance_implication,
-  ].filter(Boolean);
-
-  if (receipt.business_context_status === 'absent' && contextValues.length > 0) {
-    ctx.addIssue({
-      code: 'custom',
-      path: ['business_context_status'],
-      message: 'business_context_status absent cannot carry incident business context fields',
-    });
-  }
-
-  if (receipt.business_context_status === 'provided' && contextValues.length < 4) {
-    ctx.addIssue({
-      code: 'custom',
-      path: ['business_context'],
-      message: 'provided business context requires customer_impact, sla_tier, revenue_exposure, and compliance_implication',
-    });
-  }
-});
-
-export type IncidentReceiptV1 = z.infer<typeof IncidentReceiptV1Schema>;
-
-export const IncidentSummaryV1Schema = z.object({
-  schema_version: z.literal('incident-summary.v1'),
-  incident_id: nonEmptyString,
-  status: z.enum(INCIDENT_STATUSES),
-  severity: z.enum(INCIDENT_SEVERITIES),
-  started_at: nonEmptyString,
-  resolved_at: nonEmptyString.optional(),
-  duration_minutes: z.number().int().min(0).optional(),
-  affected_systems: stringList.min(1),
-  primary_symptom: nonEmptyString,
-  mitigation_summary: nonEmptyString.optional(),
-  evidence_refs: stringList.min(1),
-  follow_up_count: z.number().int().min(0),
-  business_context_status: z.enum(INCIDENT_BUSINESS_CONTEXT_STATUSES),
-  root_cause_status: z.enum(INCIDENT_ROOT_CAUSE_STATUSES),
-}).superRefine((summary, ctx) => {
-  addEvidenceRefIssues(summary.evidence_refs, ['evidence_refs'], ctx);
-});
-
-export type IncidentSummaryV1 = z.infer<typeof IncidentSummaryV1Schema>;
-
-export function parseIncidentReceiptV1(value: unknown): IncidentReceiptV1 {
-  return IncidentReceiptV1Schema.parse(value);
-}
-
-export function validateIncidentReceiptV1(value: unknown): void {
-  IncidentReceiptV1Schema.parse(value);
-}
-
-export function parseIncidentSummaryV1(value: unknown): IncidentSummaryV1 {
-  return IncidentSummaryV1Schema.parse(value);
-}
-
-export function validateIncidentSummaryV1(value: unknown): void {
-  IncidentSummaryV1Schema.parse(value);
-}
-
-function durationMinutes(startedAt: string, resolvedAt?: string): number | undefined {
-  if (!resolvedAt) return undefined;
-
-  const startMs = Date.parse(startedAt);
-  const resolvedMs = Date.parse(resolvedAt);
-  if (!Number.isFinite(startMs) || !Number.isFinite(resolvedMs) || resolvedMs < startMs) {
-    return undefined;
-  }
-
-  return Math.round((resolvedMs - startMs) / 60000);
-}
-
-export function toIncidentSummaryV1(receipt: IncidentReceiptV1): IncidentSummaryV1 {
-  const parsed = IncidentReceiptV1Schema.parse(receipt);
-
-  return IncidentSummaryV1Schema.parse({
-    schema_version: 'incident-summary.v1',
-    incident_id: parsed.incident_id,
-    status: parsed.status,
-    severity: parsed.severity,
-    started_at: parsed.started_at,
-    resolved_at: parsed.resolved_at,
-    duration_minutes: durationMinutes(parsed.started_at, parsed.resolved_at),
-    affected_systems: parsed.affected_systems,
-    primary_symptom: parsed.symptoms[0],
-    mitigation_summary: parsed.mitigation,
-    evidence_refs: [
-      ...parsed.evidence_refs,
-      ...parsed.rollback_or_fix_refs,
-      ...parsed.validation_refs,
-      ...parsed.root_cause_evidence_refs,
-    ],
-    follow_up_count: parsed.follow_ups.length,
-    business_context_status: parsed.business_context_status,
-    root_cause_status: parsed.root_cause_status,
-  });
-}

package/packages/protocol/src/index.ts

@@ -1,8 +0,0 @@
-export * from './types';
-export * from './guards';
-export * from './state';
-export * from './interfaces';
-export * from './huddle';
-export * from './huddle-board';
-export * from './incident';
-export * from './packet-profile';

package/packages/protocol/src/interfaces.ts

@@ -1,107 +0,0 @@
-import type {
-  EvidenceBundle,
-  ProjectManifest,
-  Slice,
-  SliceStatusSnapshot,
-  ScrutinyKind,
-  SliceTask,
-  ScrutinyState,
-  TaskPacketSpec,
-  TaskState,
-  Verdict,
-  SupervisionSession,
-  SupervisionTurn,
-  SupervisionCommandRecord,
-  SupervisionEvent,
-  SupervisionProjection,
-} from './types';
-
-export interface ScrutinyLink {
-  scrutinyId: string;
-  path: string;
-  state: ScrutinyState;
-  kind?: ScrutinyKind;
-  blockedBy?: string[];
-  dependsOn?: string[];
-  readinessQuestion?: string;
-  readyForRevisit?: boolean;
-}
-
-export interface ScrutinyAdapter {
-  openOrLinkSlice(project: ProjectManifest, slice: Slice): Promise<ScrutinyLink>;
-  readSliceState(project: ProjectManifest, scrutinyId: string): Promise<ScrutinyLink>;
-  appendEvidence(project: ProjectManifest, scrutinyId: string, evidence: EvidenceBundle): Promise<void>;
-  renderArtifacts(project: ProjectManifest): Promise<void>;
-}
-
-export interface HandshakeAdapter {
-  ensureStore(project: ProjectManifest): Promise<void>;
-  newPacket(spec: TaskPacketSpec): Promise<{ packetPath: string; taskFile: string }>;
-  respondPacket(project: ProjectManifest, packetId: string, status: 'ACCEPTED' | 'COUNTER', counterRound?: number): Promise<void>;
-  lockPacket(project: ProjectManifest, packetId: string): Promise<void>;
-  provisionPacket(project: ProjectManifest, packetId: string): Promise<void>;
-  syncTasks(project: ProjectManifest, args?: string[]): Promise<string>;
-  claimTask(project: ProjectManifest, taskId: string, owner: string): Promise<void>;
-  resolveTask(project: ProjectManifest, taskId: string, owner: string, note?: string): Promise<void>;
-  watchInbox(project: ProjectManifest): Promise<string[]>;
-  readPacketStates(project: ProjectManifest): Promise<Record<string, 'PROPOSED' | 'ACCEPTED' | 'LOCKED' | 'PROVISIONED'>>;
-  readTaskStates(project: ProjectManifest): Promise<Record<string, TaskState>>;
-}
-
-export interface LogixAdapter {
-  createDecisionContext(project: ProjectManifest, slice: Slice): Promise<string>;
-  requestVerdict(project: ProjectManifest, slice: Slice, contextId: string): Promise<string>;
-  recordVerdict(project: ProjectManifest, verdict: Verdict): Promise<string>;
-  recordWaiver(project: ProjectManifest, sliceId: string, note: string): Promise<string>;
-}
-
-export interface AgentRuntimeAdapter {
-  spawnWorker(project: ProjectManifest, task: SliceTask): Promise<string>;
-  bindWorktree(project: ProjectManifest, task: SliceTask, worktreePath: string, owner: string): Promise<string>;
-  captureReceipt(project: ProjectManifest, taskId: string, summary: string, evidencePaths: string[]): Promise<string>;
-  reportTaskState(project: ProjectManifest, taskId: string, state: TaskState, summary: string): Promise<string>;
-}
-
-export interface ControlDeps {
-  scrutiny: ScrutinyAdapter;
-  handshake: HandshakeAdapter;
-  logix: LogixAdapter;
-  agent: AgentRuntimeAdapter;
-}
-
-export interface ControlDeps {
-  scrutiny: ScrutinyAdapter;
-  handshake: HandshakeAdapter;
-  logix: LogixAdapter;
-  agent: AgentRuntimeAdapter;
-}
-
-// ============================================================================
-// Supervision (Phase 1)
-// Authority: etiquette/internal/docs/supervision/PHASE1.md
-// Doctrine: llm-substrate/governance/shared-live-supervision.md
-// ============================================================================
-
-export interface SupervisionSqliteHandle {
-  run(sql: string, params?: unknown[]): void;
-  all<T = unknown>(sql: string, params?: unknown[]): T[];
-  get<T = unknown>(sql: string, params?: unknown[]): T | undefined;
-  close(): void;
-}
-
-export interface SupervisionProjectionAdapter {
-  renderStatusBoard(projection: SupervisionProjection): Promise<void>;
-  renderSeatChannel(projection: SupervisionProjection, seatId: string): Promise<void>;
-  writeLatestProjection(projectionPath: string, projection: SupervisionProjection): Promise<void>;
-}
-
-export interface SupervisionDeps {
-  now(): Date;
-  randomId(): string;
-  readFile(path: string): Promise<string>;
-  writeFile(path: string, contents: string): Promise<void>;
-  appendFile(path: string, contents: string): Promise<void>;
-  mkdirp(path: string): Promise<void>;
-  openSqlite(path: string): SupervisionSqliteHandle;
-  projectionAdapter: SupervisionProjectionAdapter;
-}

package/packages/protocol/src/packet-profile.ts

@@ -1,195 +0,0 @@
-import { stringify as stringifyYaml } from 'yaml';
-import { z } from 'zod';
-
-const nonEmptyString = z.string().trim().min(1);
-const profileKey = z.string().regex(/^[A-Za-z][A-Za-z0-9_-]*$/);
-const PacketProfileScalarV0Schema = z.union([z.string(), z.number(), z.boolean()]);
-const PacketProfileValueV0Schema = z.union([
-  PacketProfileScalarV0Schema,
-  z.array(PacketProfileScalarV0Schema),
-]);
-
-const PacketProfileFieldV0Schema = z.object({
-  key: profileKey,
-  required: z.boolean().default(false),
-  default: PacketProfileValueV0Schema.optional(),
-  derive: nonEmptyString.optional(),
-}).strict().superRefine((field, ctx) => {
-  if (field.default !== undefined && field.derive !== undefined) {
-    ctx.addIssue({
-      code: 'custom',
-      message: 'packet profile field cannot declare both default and derive',
-    });
-  }
-});
-
-const PacketProfileSectionV0Schema = z.object({
-  key: profileKey,
-  heading: nonEmptyString,
-  required: z.boolean().default(false),
-  default: nonEmptyString.optional(),
-  derive: nonEmptyString.optional(),
-}).strict().superRefine((section, ctx) => {
-  if (section.default !== undefined && section.derive !== undefined) {
-    ctx.addIssue({
-      code: 'custom',
-      message: 'packet profile section cannot declare both default and derive',
-    });
-  }
-});
-
-export const PacketProfileV0Schema = z.object({
-  schema: z.literal('packet-profile.v0'),
-  format: z.literal('markdown-frontmatter'),
-  filename: z.object({
-    pattern: nonEmptyString,
-    extension: z.string().regex(/^\.[A-Za-z0-9]+$/).default('.md'),
-  }).strict(),
-  frontmatter: z.object({
-    fields: z.array(PacketProfileFieldV0Schema).min(1),
-  }).strict(),
-  title: z.object({
-    derive: nonEmptyString,
-  }).strict().optional(),
-  sections: z.array(PacketProfileSectionV0Schema).min(1),
-}).strict().superRefine((profile, ctx) => {
-  const fieldKeys = new Set<string>();
-  for (const [index, field] of profile.frontmatter.fields.entries()) {
-    if (fieldKeys.has(field.key)) {
-      ctx.addIssue({
-        code: 'custom',
-        path: ['frontmatter', 'fields', index, 'key'],
-        message: `duplicate packet profile field: ${field.key}`,
-      });
-    }
-    fieldKeys.add(field.key);
-  }
-
-  const sectionKeys = new Set<string>();
-  for (const [index, section] of profile.sections.entries()) {
-    if (sectionKeys.has(section.key)) {
-      ctx.addIssue({
-        code: 'custom',
-        path: ['sections', index, 'key'],
-        message: `duplicate packet profile section: ${section.key}`,
-      });
-    }
-    sectionKeys.add(section.key);
-  }
-});
-
-export type PacketProfileV0 = z.infer<typeof PacketProfileV0Schema>;
-export type PacketProfileValueV0 = z.infer<typeof PacketProfileValueV0Schema>;
-
-export interface RenderedPacketProfileV0 {
-  filename: string;
-  markdown: string;
-  frontmatter: Record<string, PacketProfileValueV0>;
-  sections: Array<{ key: string; heading: string; body: string }>;
-}
-
-function isMissing(value: PacketProfileValueV0 | undefined): boolean {
-  return value === undefined || value === '';
-}
-
-function renderTemplate(
-  template: string,
-  values: Record<string, PacketProfileValueV0>,
-): string {
-  const rendered = template.replace(/\{\{\s*([A-Za-z][A-Za-z0-9_-]*)\s*\}\}/g, (_match, key: string) => {
-    const value = values[key];
-    if (isMissing(value)) {
-      throw new Error(`packet profile template value is missing: ${key}`);
-    }
-    return Array.isArray(value) ? value.join(',') : String(value);
-  });
-  if (rendered.includes('{{') || rendered.includes('}}')) {
-    throw new Error(`invalid packet profile template: ${template}`);
-  }
-  return rendered;
-}
-
-function valueFor(
-  key: string,
-  input: Record<string, PacketProfileValueV0>,
-  context: Record<string, PacketProfileValueV0>,
-  fallback?: PacketProfileValueV0,
-  derive?: string,
-): PacketProfileValueV0 | undefined {
-  if (derive !== undefined) return renderTemplate(derive, context);
-  if (input[key] !== undefined) return input[key];
-  if (fallback !== undefined) return fallback;
-  return undefined;
-}
-
-function packetFilename(
-  profile: PacketProfileV0,
-  context: Record<string, PacketProfileValueV0>,
-): string {
-  const renderedStem = renderTemplate(profile.filename.pattern, context);
-  const stem = renderedStem
-    .replace(/[^A-Za-z0-9._-]+/g, '-')
-    .replace(/^-+|-+$/g, '');
-  if (!stem || stem === '.' || stem === '..') {
-    throw new Error(`packet profile produced an unsafe filename: ${renderedStem}`);
-  }
-  const filename = stem.endsWith(profile.filename.extension)
-    ? stem
-    : `${stem}${profile.filename.extension}`;
-  if (!/^[A-Za-z0-9._-]+$/.test(filename) || filename === '.' || filename === '..') {
-    throw new Error(`packet profile produced an unsafe filename: ${filename}`);
-  }
-  return filename;
-}
-
-export function parsePacketProfileV0(value: unknown): PacketProfileV0 {
-  return PacketProfileV0Schema.parse(value);
-}
-
-export function renderPacketProfileV0(
-  profileInput: PacketProfileV0,
-  input: Record<string, PacketProfileValueV0>,
-): RenderedPacketProfileV0 {
-  const profile = PacketProfileV0Schema.parse(profileInput);
-  const context: Record<string, PacketProfileValueV0> = { ...input };
-  const frontmatter: Record<string, PacketProfileValueV0> = {};
-
-  for (const field of profile.frontmatter.fields) {
-    const value = valueFor(field.key, input, context, field.default, field.derive);
-    if (field.required && isMissing(value)) {
-      throw new Error(`required packet profile field is missing: ${field.key}`);
-    }
-    if (value !== undefined) {
-      frontmatter[field.key] = value;
-      context[field.key] = value;
-    }
-  }
-
-  const sections: RenderedPacketProfileV0['sections'] = [];
-  for (const section of profile.sections) {
-    const value = valueFor(section.key, input, context, section.default, section.derive);
-    if (section.required && isMissing(value)) {
-      throw new Error(`required packet profile section is missing: ${section.key}`);
-    }
-    if (value !== undefined) {
-      const body = Array.isArray(value) ? value.join('\n') : String(value);
-      sections.push({ key: section.key, heading: section.heading, body });
-      context[section.key] = value;
-    }
-  }
-
-  const title = profile.title ? renderTemplate(profile.title.derive, context) : undefined;
-  const yaml = stringifyYaml(frontmatter, { lineWidth: 0 }).trimEnd();
-  const lines = ['---', yaml, '---', ''];
-  if (title) lines.push(`# ${title}`, '');
-  for (const section of sections) {
-    lines.push(`## ${section.heading}`, '', section.body, '');
-  }
-
-  return {
-    filename: packetFilename(profile, context),
-    markdown: `${lines.join('\n').trimEnd()}\n`,
-    frontmatter,
-    sections,
-  };
-}

package/packages/protocol/src/state.ts

@@ -1,81 +0,0 @@
-import {
-  PACKET_STATES,
-  SCRUTINY_STATES,
-  TASK_STATES,
-  type PacketState,
-  type ScrutinyState,
-  type Slice,
-  type SliceStatusSnapshot,
-  type TaskState,
-} from './types';
-import { assertScrutinyState, validateSlice } from './guards';
-
-function emptyCounts<T extends readonly string[]>(values: T): Record<T[number], number> {
-  return Object.fromEntries(values.map((value) => [value, 0])) as Record<T[number], number>;
-}
-
-export function aggregateSliceStatus(
-  slice: Slice,
-  scrutinyState: ScrutinyState,
-  packetStates: Record<string, PacketState>,
-): SliceStatusSnapshot {
-  validateSlice(slice);
-  assertScrutinyState(scrutinyState);
-
-  const taskCounts = emptyCounts(TASK_STATES);
-  const packetCounts = emptyCounts(PACKET_STATES);
-  const unresolvedTasks: string[] = [];
-  const blockers: string[] = [];
-
-  for (const task of slice.tasks) {
-    taskCounts[task.state] += 1;
-    if (task.state !== 'resolved') {
-      unresolvedTasks.push(task.taskId);
-    }
-    if (task.state === 'blocked' || task.state === 'countered') {
-      blockers.push(task.taskId);
-    }
-    const packetState = task.packetId ? packetStates[task.packetId] : undefined;
-    if (packetState) {
-      packetCounts[packetState] += 1;
-      if (packetState !== 'PROVISIONED' && task.state === 'resolved') {
-        blockers.push(`${task.taskId}:packet-not-provisioned`);
-      }
-    }
-  }
-
-  const scrutinyBlocksClose = scrutinyState === 'DEFERRED' || scrutinyState === 'BLOCKED';
-  const readyToClose = unresolvedTasks.length === 0 && !scrutinyBlocksClose && blockers.length === 0;
-
-  return {
-    sliceId: slice.sliceId,
-    sliceState: slice.state,
-    scrutinyState,
-    packetStates: packetCounts,
-    taskStates: taskCounts,
-    unresolvedTasks,
-    readyToClose,
-    blockers,
-  };
-}
-
-export function deriveTaskStateFromLedger(value: string): TaskState {
-  switch (value) {
-    case 'incoming':
-      return 'incoming';
-    case 'pending':
-      return 'claimed';
-    case 'resolved':
-      return 'resolved';
-    default:
-      return 'incoming';
-  }
-}
-
-export function isTerminalScrutinyState(value: string): value is Extract<ScrutinyState, 'RESOLVED' | 'VERIFIED' | 'WONT_FIX'> {
-  return value === 'RESOLVED' || value === 'VERIFIED' || value === 'WONT_FIX';
-}
-
-export function isKnownScrutinyState(value: string): value is ScrutinyState {
-  return (SCRUTINY_STATES as readonly string[]).includes(value);
-}