@etiquekit/etq 1.0.14 → 1.0.16

package/packages/control/src/sync/outbox.ts

@@ -1,492 +0,0 @@
-import { createHash } from 'node:crypto';
-import { mkdir, readdir, readFile, writeFile } from 'node:fs/promises';
-import { existsSync } from 'node:fs';
-import { dirname, join, relative, resolve } from 'node:path';
-import { parse as parseYaml } from 'yaml';
-import { assertSharedMemoryScopeId, assertSharedMemoryText, detectMemoryRiskFlags } from '../memory/sanitize';
-import { defaultSeatReadinessEventsPath, defaultSeatReadinessPath, type SeatReadinessRecord } from '../seat/readiness';
-
-export const SYNC_ARTIFACT_KINDS = [
-  'ledger_entry',
-  'event_summary',
-  'receipt_metadata',
-  'dispatch_record',
-  'readiness_snapshot',
-  'memory_capsule',
-  'playback_summary',
-  'grant_ref',
-  'audit_ref',
-  'compaction_capsule',
-] as const;
-
-export type SyncArtifactKind = (typeof SYNC_ARTIFACT_KINDS)[number];
-export type SyncScope = 'seat_local' | 'workspace_local' | 'org_projected' | 'subscriber_targeted';
-
-export interface SyncEnvelope {
-  schema: 'sync-envelope.v0';
-  envelope_id: string;
-  created_at: string;
-  source: {
-    scope: 'seat_local' | 'workspace_local';
-    org_id?: string;
-    workspace_id: string;
-    seat_id?: string;
-    session_id?: string;
-  };
-  target: {
-    scope: 'workspace_local' | 'org_projected' | 'subscriber_targeted';
-    org_id?: string;
-    workspace_id?: string;
-    subscriber_refs: string[];
-  };
-  artifact: {
-    kind: SyncArtifactKind;
-    schema_ref: string;
-    artifact_ref: string;
-    summary: string;
-    evidence_refs: Array<{
-      type: 'ledger' | 'receipt' | 'event' | 'memory' | 'playback' | 'grant' | 'audit' | 'doc';
-      ref: string;
-    }>;
-  };
-  projection_policy_ref: string;
-  visibility: 'workspace_local' | 'org_projected' | 'subscriber_targeted';
-  content_boundary: {
-    metadata_only: true;
-    raw_ledger_body_included: false;
-    raw_event_body_included: false;
-    raw_prompt_included: false;
-    raw_tool_output_included: false;
-    source_snippets_included: false;
-    local_paths_included: false;
-  };
-  authority_boundary: {
-    can_authorize_work: false;
-    can_execute_work: false;
-    can_attach_grant: false;
-    can_replace_local_ledger: false;
-    remote_is_execution_truth: false;
-  };
-}
-
-export interface SyncStageIssue {
-  artifact_ref: string;
-  kind: SyncArtifactKind | 'unknown';
-  reason: string;
-}
-
-export interface SyncStageResult {
-  schema: 'sync-stage-result.v0';
-  project_ref: string;
-  outbox_ref: string;
-  staged: number;
-  rejected: SyncStageIssue[];
-  local_only: SyncStageIssue[];
-  envelopes: Array<{
-    envelope_id: string;
-    kind: SyncArtifactKind;
-    artifact_ref: string;
-    outbox_ref: string;
-    target_scope: SyncEnvelope['target']['scope'];
-    projection_policy_ref: string;
-  }>;
-  authority_boundary: {
-    can_authorize_work: false;
-    can_execute_work: false;
-    can_attach_grant: false;
-    can_replace_local_ledger: false;
-    hosted_plane_is_source_of_truth: false;
-  };
-}
-
-interface Candidate {
-  kind: SyncArtifactKind;
-  sourceScope: 'seat_local' | 'workspace_local';
-  targetScope: 'workspace_local' | 'org_projected' | 'subscriber_targeted';
-  projectionPolicyRef: string;
-  schemaRef: string;
-  artifactRef: string;
-  summary: string;
-  evidenceType: SyncEnvelope['artifact']['evidence_refs'][number]['type'];
-  rawForPolicy?: string;
-  seatId?: string;
-}
-
-export interface StageSyncOutboxOptions {
-  projectRoot: string;
-  outboxDir?: string;
-  workspaceId?: string;
-  orgId?: string;
-  seatId?: string;
-  at?: string;
-}
-
-const DEFAULT_WORKSPACE_ID = 'workspace-local';
-const DEFAULT_OUTBOX_REF = '.etiquette/outbox/sync';
-
-function isoNow(at?: string): string {
-  const value = at ?? new Date().toISOString();
-  if (!Number.isFinite(Date.parse(value))) {
-    throw new Error('--at must be an ISO-8601 timestamp');
-  }
-  return new Date(value).toISOString();
-}
-
-function stableHash(value: unknown): string {
-  return createHash('sha256').update(JSON.stringify(value)).digest('hex').slice(0, 16);
-}
-
-function assertNoRestrictedContent(value: string, field: string): void {
-  const flags: string[] = detectMemoryRiskFlags(value).filter((flag) => flag !== 'contains_credential');
-  if (/\b(?:ANTHROPIC_API_KEY|OPENAI_API_KEY|GEMINI_API_KEY|api[_-]?key|token|secret|credential)\b\s*[:=]/i.test(value)
-    || /(?:^|[\s:=])sk-[A-Za-z0-9_-]{12,}/.test(value)) {
-    flags.push('contains_credential');
-  }
-  if (flags.length > 0) {
-    throw new Error(`${field} contains restricted shared-sync content: ${flags.join(', ')}`);
-  }
-}
-
-function assertNoRestrictedRefContent(value: string, field: string): void {
-  const flags: string[] = detectMemoryRiskFlags(value).filter((flag) => flag !== 'contains_credential');
-  if (/(?:^|[/:=_-])(?:api[_-]?key|token|secret|credential)(?:[/:=_-]|$)/i.test(value)
-    || /(?:^|[/:=_-])sk-[A-Za-z0-9_-]{12,}/.test(value)) {
-    flags.push('contains_credential');
-  }
-  if (flags.length > 0) {
-    throw new Error(`${field} contains restricted shared-sync content: ${flags.join(', ')}`);
-  }
-}
-
-function assertRepoRelative(value: string, field: string): string {
-  if (value.length === 0 || value.length > 256) {
-    throw new Error(`${field} must be a non-empty repo-relative ref <= 256 chars`);
-  }
-  if (value.startsWith('/') || value.startsWith('\\') || /^[A-Za-z]:[\\/]/.test(value)) {
-    throw new Error(`${field} must be repo-relative`);
-  }
-  assertNoRestrictedRefContent(value, field);
-  return value;
-}
-
-function assertSummary(value: string, field: string): string {
-  const summary = value.trim().replace(/\s+/g, ' ').slice(0, 200);
-  if (!summary) throw new Error(`${field} must not be empty`);
-  assertSharedMemoryText(summary, field);
-  return summary;
-}
-
-function projectRelative(projectRoot: string, path: string): string {
-  const rel = relative(resolve(projectRoot), resolve(path));
-  if (rel.length === 0 || rel.startsWith('..') || rel.includes('\\')) {
-    throw new Error(`path must stay inside project root: ${path}`);
-  }
-  return assertRepoRelative(rel, 'artifact_ref');
-}
-
-function outboxRelative(projectRoot: string, path: string): string {
-  const rel = relative(resolve(projectRoot), resolve(path));
-  if (rel.length === 0 || rel.startsWith('..') || rel.includes('\\')) {
-    throw new Error(`outbox path must stay inside project root: ${path}`);
-  }
-  return assertRepoRelative(rel, 'outbox_ref');
-}
-
-function resolveOutboxDir(projectRoot: string, outboxDir?: string): string {
-  const outbox = resolve(projectRoot, outboxDir ?? DEFAULT_OUTBOX_REF);
-  outboxRelative(projectRoot, outbox);
-  return outbox;
-}
-
-async function readTextIfExists(path: string): Promise<string | null> {
-  try {
-    return await readFile(path, 'utf-8');
-  } catch (err) {
-    if ((err as NodeJS.ErrnoException).code === 'ENOENT') return null;
-    throw err;
-  }
-}
-
-async function walkFiles(dir: string): Promise<string[]> {
-  if (!existsSync(dir)) return [];
-  const entries = await readdir(dir, { withFileTypes: true });
-  const files = await Promise.all(entries.map(async (entry) => {
-    const path = join(dir, entry.name);
-    if (entry.isDirectory()) return walkFiles(path);
-    if (entry.isFile()) return [path];
-    return [];
-  }));
-  return files.flat().sort();
-}
-
-function parseObject(raw: string, path: string): Record<string, unknown> {
-  const parsed = parseYaml(raw);
-  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-    throw new Error(`${path} must parse as an object`);
-  }
-  return parsed as Record<string, unknown>;
-}
-
-function schemaRef(value: unknown, fallback: string): string {
-  if (typeof value !== 'string' || value.length === 0) return fallback;
-  assertNoRestrictedContent(value, 'schema_ref');
-  return value;
-}
-
-function asString(value: unknown): string | undefined {
-  return typeof value === 'string' && value.length > 0 ? value : undefined;
-}
-
-function policyFor(targetScope: Candidate['targetScope']): string {
-  if (targetScope === 'workspace_local') return 'projection-policy:local-to-workspace';
-  if (targetScope === 'subscriber_targeted') return 'projection-policy:workspace-to-subscriber';
-  return 'projection-policy:workspace-to-org';
-}
-
-function buildEnvelope(options: {
-  candidate: Candidate;
-  createdAt: string;
-  orgId?: string;
-  workspaceId: string;
-  defaultSeatId?: string;
-}): SyncEnvelope {
-  const artifactRef = assertRepoRelative(options.candidate.artifactRef, 'artifact_ref');
-  const schema = schemaRef(options.candidate.schemaRef, `${options.candidate.kind}.v0`);
-  const summary = assertSummary(options.candidate.summary, 'summary');
-  const evidenceRef = assertRepoRelative(artifactRef, 'evidence_ref');
-  const seatId = options.candidate.seatId ?? options.defaultSeatId;
-  if (options.orgId) assertSharedMemoryScopeId(options.orgId, 'source.org_id');
-  assertSharedMemoryScopeId(options.workspaceId, 'source.workspace_id');
-  if (seatId) assertSharedMemoryScopeId(seatId, 'source.seat_id');
-  if (options.candidate.rawForPolicy) {
-    assertNoRestrictedContent(options.candidate.rawForPolicy, artifactRef);
-  }
-  const basis = {
-    kind: options.candidate.kind,
-    schema,
-    artifactRef,
-    summary,
-    targetScope: options.candidate.targetScope,
-    policy: options.candidate.projectionPolicyRef,
-  };
-  return {
-    schema: 'sync-envelope.v0',
-    envelope_id: `sync:${stableHash(basis)}`,
-    created_at: options.createdAt,
-    source: {
-      scope: options.candidate.sourceScope,
-      ...(options.orgId ? { org_id: options.orgId } : {}),
-      workspace_id: options.workspaceId,
-      ...(seatId ? { seat_id: seatId } : {}),
-    },
-    target: {
-      scope: options.candidate.targetScope,
-      ...(options.orgId ? { org_id: options.orgId } : {}),
-      workspace_id: options.workspaceId,
-      subscriber_refs: [],
-    },
-    artifact: {
-      kind: options.candidate.kind,
-      schema_ref: schema,
-      artifact_ref: artifactRef,
-      summary,
-      evidence_refs: [{ type: options.candidate.evidenceType, ref: evidenceRef }],
-    },
-    projection_policy_ref: options.candidate.projectionPolicyRef,
-    visibility: options.candidate.targetScope,
-    content_boundary: {
-      metadata_only: true,
-      raw_ledger_body_included: false,
-      raw_event_body_included: false,
-      raw_prompt_included: false,
-      raw_tool_output_included: false,
-      source_snippets_included: false,
-      local_paths_included: false,
-    },
-    authority_boundary: {
-      can_authorize_work: false,
-      can_execute_work: false,
-      can_attach_grant: false,
-      can_replace_local_ledger: false,
-      remote_is_execution_truth: false,
-    },
-  };
-}
-
-async function collectCandidates(projectRoot: string): Promise<{ candidates: Candidate[]; defaultSeatId?: string }> {
-  const candidates: Candidate[] = [];
-  let defaultSeatId: string | undefined;
-
-  const readinessPath = defaultSeatReadinessPath(projectRoot);
-  const readinessRaw = await readTextIfExists(readinessPath);
-  if (readinessRaw) {
-    const record = JSON.parse(readinessRaw) as SeatReadinessRecord;
-    defaultSeatId = record.seat;
-    candidates.push({
-      kind: 'readiness_snapshot',
-      sourceScope: 'seat_local',
-      targetScope: 'org_projected',
-      projectionPolicyRef: policyFor('org_projected'),
-      schemaRef: record.schema_version,
-      artifactRef: projectRelative(projectRoot, readinessPath),
-      summary: `seat=${record.seat} status=${record.operational_status} model_tier=${record.model_tier}`,
-      evidenceType: 'event',
-      rawForPolicy: readinessRaw,
-      seatId: record.seat,
-    });
-  }
-
-  const readinessEventsPath = defaultSeatReadinessEventsPath(projectRoot);
-  const readinessEventsRaw = await readTextIfExists(readinessEventsPath);
-  if (readinessEventsRaw?.trim()) {
-    const count = readinessEventsRaw.trim().split('\n').length;
-    candidates.push({
-      kind: 'event_summary',
-      sourceScope: 'seat_local',
-      targetScope: 'org_projected',
-      projectionPolicyRef: policyFor('org_projected'),
-      schemaRef: 'seat-readiness-event.v0.1',
-      artifactRef: projectRelative(projectRoot, readinessEventsPath),
-      summary: `seat readiness event summary count=${count}`,
-      evidenceType: 'event',
-      rawForPolicy: readinessEventsRaw,
-      seatId: defaultSeatId,
-    });
-  }
-
-  const ledgerPath = join(projectRoot, 'docs', 'work', 'ledger', 'LEDGER.md');
-  const ledgerRaw = await readTextIfExists(ledgerPath);
-  if (ledgerRaw?.trim()) {
-    candidates.push({
-      kind: 'ledger_entry',
-      sourceScope: 'seat_local',
-      targetScope: 'workspace_local',
-      projectionPolicyRef: policyFor('workspace_local'),
-      schemaRef: 'local-ledger.v0',
-      artifactRef: projectRelative(projectRoot, ledgerPath),
-      summary: 'local ledger available for workspace aggregation',
-      evidenceType: 'ledger',
-      rawForPolicy: ledgerRaw,
-      seatId: defaultSeatId,
-    });
-  }
-
-  for (const receiptPath of await walkFiles(join(projectRoot, 'docs', 'work', 'receipts'))) {
-    if (!/\.(ya?ml|json)$/i.test(receiptPath)) continue;
-    const raw = await readFile(receiptPath, 'utf-8');
-    const parsed = parseObject(raw, receiptPath);
-    const ref = projectRelative(projectRoot, receiptPath);
-    const schema = schemaRef(parsed.schema, 'receipt.v0');
-    const taskRef = asString(parsed.task_ref) ?? asString(parsed.receipt_id) ?? asString(parsed.record_id) ?? 'unknown';
-    candidates.push({
-      kind: 'receipt_metadata',
-      sourceScope: 'workspace_local',
-      targetScope: 'org_projected',
-      projectionPolicyRef: policyFor('org_projected'),
-      schemaRef: schema,
-      artifactRef: ref,
-      summary: `receipt metadata schema=${schema} task=${taskRef}`,
-      evidenceType: 'receipt',
-      rawForPolicy: raw,
-      seatId: asString(parsed.seat) ?? defaultSeatId,
-    });
-    if (parsed.schema === 'operational-dispatch-record.v0') {
-      candidates.push({
-        kind: 'dispatch_record',
-        sourceScope: 'workspace_local',
-        targetScope: 'org_projected',
-        projectionPolicyRef: policyFor('org_projected'),
-        schemaRef: 'operational-dispatch-record.v0',
-        artifactRef: ref,
-        summary: `dispatch record decision=${asString(parsed.decision) ?? 'unknown'} task=${taskRef}`,
-        evidenceType: 'receipt',
-        rawForPolicy: raw,
-        seatId: asString(parsed.seat) ?? defaultSeatId,
-      });
-    }
-  }
-
-  for (const capsulePath of await walkFiles(join(projectRoot, '.etiquette', 'exports'))) {
-    if (!/\.json$/i.test(capsulePath)) continue;
-    const raw = await readFile(capsulePath, 'utf-8');
-    const parsed = JSON.parse(raw) as Record<string, unknown>;
-    if (parsed.schema !== 'recall-capsule.v0') continue;
-    const title = asString(parsed.title) ?? 'recall capsule';
-    candidates.push({
-      kind: 'memory_capsule',
-      sourceScope: 'workspace_local',
-      targetScope: 'org_projected',
-      projectionPolicyRef: policyFor('org_projected'),
-      schemaRef: 'recall-capsule.v0',
-      artifactRef: projectRelative(projectRoot, capsulePath),
-      summary: `memory capsule title=${title}`,
-      evidenceType: 'memory',
-      rawForPolicy: raw,
-      seatId: defaultSeatId,
-    });
-  }
-
-  return { candidates, defaultSeatId };
-}
-
-export async function stageSyncOutbox(options: StageSyncOutboxOptions): Promise<SyncStageResult> {
-  const projectRoot = resolve(options.projectRoot);
-  const createdAt = isoNow(options.at);
-  const workspaceId = options.workspaceId ?? DEFAULT_WORKSPACE_ID;
-  assertSharedMemoryScopeId(workspaceId, '--workspace-id');
-  if (options.orgId) assertSharedMemoryScopeId(options.orgId, '--org-id');
-  if (options.seatId) assertSharedMemoryScopeId(options.seatId, '--seat-id');
-  const outboxDir = resolveOutboxDir(projectRoot, options.outboxDir);
-  const { candidates, defaultSeatId } = await collectCandidates(projectRoot);
-
-  await mkdir(outboxDir, { recursive: true });
-  const result: SyncStageResult = {
-    schema: 'sync-stage-result.v0',
-    project_ref: '.',
-    outbox_ref: outboxRelative(projectRoot, outboxDir),
-    staged: 0,
-    rejected: [],
-    local_only: [],
-    envelopes: [],
-    authority_boundary: {
-      can_authorize_work: false,
-      can_execute_work: false,
-      can_attach_grant: false,
-      can_replace_local_ledger: false,
-      hosted_plane_is_source_of_truth: false,
-    },
-  };
-
-  for (const candidate of candidates) {
-    try {
-      const envelope = buildEnvelope({
-        candidate,
-        createdAt,
-        orgId: options.orgId,
-        workspaceId,
-        defaultSeatId: options.seatId ?? defaultSeatId,
-      });
-      const fileName = `${envelope.envelope_id.replace(/[^A-Za-z0-9_-]+/g, '-')}.json`;
-      const outPath = join(outboxDir, fileName);
-      await mkdir(dirname(outPath), { recursive: true });
-      await writeFile(outPath, `${JSON.stringify(envelope, null, 2)}\n`);
-      result.staged += 1;
-      result.envelopes.push({
-        envelope_id: envelope.envelope_id,
-        kind: envelope.artifact.kind,
-        artifact_ref: envelope.artifact.artifact_ref,
-        outbox_ref: outboxRelative(projectRoot, outPath),
-        target_scope: envelope.target.scope,
-        projection_policy_ref: envelope.projection_policy_ref,
-      });
-    } catch (err) {
-      result.rejected.push({
-        artifact_ref: candidate.artifactRef,
-        kind: candidate.kind,
-        reason: (err as Error).message,
-      });
-    }
-  }
-
-  return result;
-}

package/packages/control/src/workflow/evaluator.ts

@@ -1,140 +0,0 @@
-import type {
-  WorkflowCheckEnvelope,
-  WorkflowCheckResult,
-  WorkflowMode,
-  WorkflowModeType,
-  WorkflowRecommendation,
-} from './types';
-
-function modeRefMatches(mode: WorkflowMode, ref: string): boolean {
-  return ref === mode.mode_id || ref === `workflow-mode:${mode.mode_id}`;
-}
-
-function check(status: WorkflowRecommendation, check_id: string, summary: string): WorkflowCheckResult['checks'][number] {
-  return { check_id, status, summary };
-}
-
-function recommendationFor(missing: string[], warnings: string[]): WorkflowRecommendation {
-  if (missing.length > 0) return 'block';
-  if (warnings.length > 0) return 'warn';
-  return 'pass';
-}
-
-export function explainWorkflowMode(modeType: WorkflowModeType): {
-  mode_type: WorkflowModeType;
-  summary: string;
-  use_when: string[];
-  boundary: string[];
-} {
-  if (modeType === 'deliberative') {
-    return {
-      mode_type: modeType,
-      summary: 'Slow, human-reviewed, grant-heavy workflow posture.',
-      use_when: ['doctrine', 'architecture', 'security posture', 'subjective tradeoffs'],
-      boundary: ['consensus recommends only', 'explicit grant required before mutation', 'dissent must be preserved'],
-    };
-  }
-  if (modeType === 'expedient') {
-    return {
-      mode_type: modeType,
-      summary: 'Fast, bounded, rubric-heavy, evidence-first workflow posture.',
-      use_when: ['health checks', 'fixture runs', 'known-safe mechanical work', 'local status probes'],
-      boundary: ['not a shortcut', 'not lower safety', 'requires bounded scope, validation, and receipt proof'],
-    };
-  }
-  return {
-    mode_type: modeType,
-    summary: 'Slow upstream drafting, explicit grant hinge, fast local execution, receipt proof.',
-    use_when: ['current v3/Etiquette implementation lanes', 'reviewed doctrine feeding bounded local execution'],
-    boundary: ['grant_ref is the phase boundary', 'execution cannot begin before the grant hinge when mutating state'],
-  };
-}
-
-export function evaluateWorkflowCheck(mode: WorkflowMode, envelope: WorkflowCheckEnvelope): WorkflowCheckResult {
-  const missing: string[] = [];
-  const warnings: string[] = [];
-  const checks: WorkflowCheckResult['checks'] = [];
-
-  if (!modeRefMatches(mode, envelope.workflow_mode_ref)) {
-    warnings.push('workflow_mode_ref_mismatch');
-    checks.push(check('warn', 'workflow_mode_ref_matches', 'Envelope workflow_mode_ref does not match the loaded mode id.'));
-  } else {
-    checks.push(check('pass', 'workflow_mode_ref_matches', 'Envelope references the loaded workflow mode.'));
-  }
-
-  if (envelope.requested_mode_type !== mode.mode_type) {
-    missing.push('requested_mode_type');
-    checks.push(check('block', 'requested_mode_type_matches', 'Envelope requested mode type does not match loaded mode.'));
-  } else {
-    checks.push(check('pass', 'requested_mode_type_matches', 'Envelope requested mode type matches loaded mode.'));
-  }
-
-  if (envelope.advisory_consensus_claims_authority) {
-    missing.push('advisory_consensus_claims_authority_false');
-    checks.push(check('block', 'advisory_consensus_not_authority', 'Advisory consensus cannot authorize work.'));
-  } else {
-    checks.push(check('pass', 'advisory_consensus_not_authority', 'No advisory consensus authority claim present.'));
-  }
-
-  if (envelope.mutates_state && mode.grant.required && !envelope.grant_ref) {
-    missing.push('grant_ref');
-    checks.push(check('block', 'grant_hinge_satisfied', 'Mutating execution under this mode requires grant_ref.'));
-  } else {
-    checks.push(check('pass', 'grant_hinge_satisfied', 'Grant hinge is satisfied or not required for this envelope.'));
-  }
-
-  if (envelope.mutates_state && mode.proof.receipt_required && !envelope.receipt_ref) {
-    missing.push('receipt_ref');
-    checks.push(check('block', 'receipt_proof_declared', 'Mutating execution requires a receipt_ref or receipt plan.'));
-  } else {
-    checks.push(check('pass', 'receipt_proof_declared', 'Receipt proof is declared or not required.'));
-  }
-
-  if (mode.proof.validation_required && envelope.validation_refs.length === 0) {
-    missing.push('validation_refs');
-    checks.push(check('block', 'validation_evidence_present', 'Mode requires validation evidence refs.'));
-  } else {
-    checks.push(check('pass', 'validation_evidence_present', 'Validation evidence is present or not required.'));
-  }
-
-  if (mode.mode_type === 'expedient') {
-    if (!envelope.bounded) missing.push('bounded');
-    if (!envelope.preauthorized) missing.push('preauthorized');
-    if (envelope.risk === 'high') missing.push('risk_not_high');
-    checks.push(check(
-      envelope.bounded && envelope.preauthorized && envelope.risk !== 'high' ? 'pass' : 'block',
-      'expedient_claim_is_valid',
-      'Expedient mode requires bounded scope, preauthorization, non-high risk, validation, and receipt proof.',
-    ));
-  }
-
-  if (mode.mode_type === 'deliberative' && mode.drafting.requires_review && !envelope.consensus_ref) {
-    warnings.push('deliberative_without_consensus_ref');
-    checks.push(check('warn', 'deliberative_review_visible', 'Deliberative mode should cite consensus or review state.'));
-  }
-
-  if (mode.mode_type === 'mixed' && mode.execution.dispatch === 'immediate_after_grant' && envelope.mutates_state && !envelope.grant_ref) {
-    if (!missing.includes('grant_ref')) missing.push('grant_ref');
-    checks.push(check('block', 'mixed_grant_before_execution', 'Mixed mode cannot execute mutating work before grant_ref.'));
-  } else if (mode.mode_type === 'mixed') {
-    checks.push(check('pass', 'mixed_grant_before_execution', 'Mixed grant hinge is satisfied or work is non-mutating.'));
-  }
-
-  return {
-    schema: 'workflow-check-receipt.v0',
-    task_ref: envelope.task_ref,
-    mode_id: mode.mode_id,
-    mode_type: mode.mode_type,
-    recommendation: recommendationFor([...new Set(missing)], [...new Set(warnings)]),
-    missing: [...new Set(missing)],
-    warnings: [...new Set(warnings)],
-    checks,
-    authority_boundary: {
-      can_authorize: false,
-      can_attach_grant: false,
-      consensus_can_authorize: false,
-      mode_is_engine: false,
-      requires_grant: mode.grant.required,
-    },
-  };
-}