@aria_asi/cli 0.2.40 → 0.2.41

package/scripts/sync-owner-status-airtable.mjs

@@ -0,0 +1,1158 @@
+#!/usr/bin/env node
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import http from 'node:http';
+
+import { exportOwnerGoogleSheetsCsv } from './export-owner-status-sheets.mjs';
+
+const AIRTABLE_API = 'https://api.airtable.com';
+const DEFAULT_SECRETS_ENV = join(homedir(), '.aria', 'secrets', 'airtable.env');
+const DEFAULT_OWNER_AIRTABLE_DIR = join(homedir(), '.aria', 'owner-airtable');
+const DEFAULT_STATE_PATH = join(DEFAULT_OWNER_AIRTABLE_DIR, 'latest.json');
+const DEFAULT_ATLAS_SOCKET = join(homedir(), '.aria', 'atlas', 'atlas-server.sock');
+
+function parseArgs(argv = process.argv.slice(2)) {
+  const args = {
+    taskId: null,
+    taskDir: null,
+    runtimeStateDir: null,
+    actionLedgerDir: null,
+    outDir: null,
+    ownerAirtableDir: null,
+    secretsEnv: DEFAULT_SECRETS_ENV,
+    statePath: DEFAULT_STATE_PATH,
+    baseId: process.env.AIRTABLE_ARIA_BASE_ID || process.env.AIRTABLE_BASE_ID || null,
+    token: process.env.AIRTABLE_ACCESS_TOKEN || process.env.AIRTABLE_API_KEY || process.env.AIRTABLE_PAT || null,
+    atlasSocket: process.env.ATLAS_SERVER_SOCKET || DEFAULT_ATLAS_SOCKET,
+    dryRun: false,
+  };
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === '--task-id') args.taskId = argv[++index];
+    else if (arg === '--task-dir') args.taskDir = resolve(argv[++index]);
+    else if (arg === '--runtime-state-dir') args.runtimeStateDir = resolve(argv[++index]);
+    else if (arg === '--action-ledger-dir') args.actionLedgerDir = resolve(argv[++index]);
+    else if (arg === '--out-dir') args.outDir = resolve(argv[++index]);
+    else if (arg === '--owner-airtable-dir') args.ownerAirtableDir = resolve(argv[++index]);
+    else if (arg === '--secrets-env') args.secretsEnv = resolve(argv[++index]);
+    else if (arg === '--state-path') args.statePath = resolve(argv[++index]);
+    else if (arg === '--base-id') args.baseId = argv[++index];
+    else if (arg === '--atlas-socket') args.atlasSocket = resolve(argv[++index]);
+    else if (arg === '--dry-run') args.dryRun = true;
+    else if (arg === '--help' || arg === '-h') {
+      printHelp();
+      process.exit(0);
+    }
+  }
+  return args;
+}
+
+function printHelp() {
+  console.log(`
+  node scripts/sync-owner-status-airtable.mjs [options]
+
+  Syncs owner-visible Aria runtime ledger tables into Airtable.
+
+  Options:
+    --base-id ID              Defaults to AIRTABLE_ARIA_BASE_ID or AIRTABLE_BASE_ID.
+    --secrets-env PATH        Defaults to ~/.aria/secrets/airtable.env.
+    --state-path PATH         Defaults to ~/.aria/owner-airtable/latest.json.
+    --task-id ID              Export a specific Aria task.
+    --task-dir PATH           Defaults to ~/.aria/cli-tasks in the exporter.
+    --runtime-state-dir PATH  Defaults to ~/.aria/runtime/state in the exporter.
+    --action-ledger-dir PATH  Defaults to ~/.aria/action-ledger in the exporter.
+    --out-dir PATH            Defaults to ~/.aria/owner-google-sheets in the exporter.
+    --owner-airtable-dir PATH  Defaults to ~/.aria/owner-airtable.
+    --atlas-socket PATH       Defaults to ~/.aria/atlas/atlas-server.sock.
+    --dry-run                 Build rows and schema plan without writing Airtable.
+`);
+}
+
+function readEnvFile(path) {
+  if (!existsSync(path)) return {};
+  const env = {};
+  for (const line of readFileSync(path, 'utf8').split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const match = trimmed.match(/^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/);
+    if (!match) continue;
+    let value = match[2].trim();
+    if ((value.startsWith("'") && value.endsWith("'")) || (value.startsWith('"') && value.endsWith('"'))) {
+      value = value.slice(1, -1);
+    }
+    env[match[1]] = value;
+  }
+  return env;
+}
+
+function resolveAuth(options) {
+  const fileEnv = readEnvFile(options.secretsEnv || DEFAULT_SECRETS_ENV);
+  const token = options.token || fileEnv.AIRTABLE_ACCESS_TOKEN || fileEnv.AIRTABLE_API_KEY || fileEnv.AIRTABLE_PAT;
+  const baseId = options.baseId || fileEnv.AIRTABLE_ARIA_BASE_ID || fileEnv.AIRTABLE_BASE_ID;
+  if (!token) throw new Error(`Missing Airtable token. Set AIRTABLE_ACCESS_TOKEN or save ${options.secretsEnv || DEFAULT_SECRETS_ENV}.`);
+  if (!baseId) throw new Error(`Missing Airtable base id. Set AIRTABLE_ARIA_BASE_ID or save ${options.secretsEnv || DEFAULT_SECRETS_ENV}.`);
+  return { token, baseId };
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function airtableRequest({ token, method = 'GET', path, body = null, apiFetch = fetch, attempts = 3 }) {
+  let lastText = '';
+  let lastStatus = 0;
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    const response = await apiFetch(`${AIRTABLE_API}${path}`, {
+      method,
+      headers: {
+        authorization: `Bearer ${token}`,
+        'content-type': 'application/json',
+      },
+      body: body === null ? undefined : JSON.stringify(body),
+    });
+    const text = await response.text();
+    lastText = text;
+    lastStatus = response.status;
+    let parsed = {};
+    try { parsed = text ? JSON.parse(text) : {}; } catch { parsed = { raw: text.slice(0, 1000) }; }
+    if (response.ok) return parsed;
+    if (![429, 500, 502, 503, 504].includes(response.status) || attempt === attempts) {
+      throw new Error(`Airtable ${method} ${path} failed (${response.status}): ${text.slice(0, 1200)}`);
+    }
+    await sleep(250 * attempt);
+  }
+  throw new Error(`Airtable ${method} ${path} failed (${lastStatus}): ${lastText.slice(0, 1200)}`);
+}
+
+function csvToRows(csv) {
+  const rows = [];
+  let row = [];
+  let cell = '';
+  let quoted = false;
+  for (let index = 0; index < csv.length; index += 1) {
+    const char = csv[index];
+    const next = csv[index + 1];
+    if (quoted) {
+      if (char === '"' && next === '"') {
+        cell += '"';
+        index += 1;
+      } else if (char === '"') {
+        quoted = false;
+      } else {
+        cell += char;
+      }
+    } else if (char === '"') {
+      quoted = true;
+    } else if (char === ',') {
+      row.push(cell);
+      cell = '';
+    } else if (char === '\n') {
+      row.push(cell);
+      rows.push(row);
+      row = [];
+      cell = '';
+    } else if (char !== '\r') {
+      cell += char;
+    }
+  }
+  if (cell || row.length) {
+    row.push(cell);
+    rows.push(row);
+  }
+  return rows;
+}
+
+function tableToObjects(table) {
+  const rows = csvToRows(readFileSync(table.path, 'utf8'));
+  const headers = rows[0] || [];
+  return rows.slice(1)
+    .filter((row) => row.some(Boolean))
+    .map((row) => Object.fromEntries(headers.map((header, index) => [header, row[index] || ''])));
+}
+
+function field(name, type = 'multilineText', options = undefined) {
+  return options ? { name, type, options } : { name, type };
+}
+
+const NUMBER_FIELDS = new Set([
+  'sort_order',
+  'blockers',
+  'attempts',
+  'event_count',
+  'task_count',
+  'session_count',
+  'sentinel_findings',
+  'publish_outbox_count',
+  'replay_attempts',
+  'nodes',
+  'edges',
+  'active_gates',
+  'sentinel_high',
+  'priority_rank',
+  'queue_depth',
+  'queue_oldest_age_minutes',
+  'invalid_line_count',
+  'run_count',
+  'consumed',
+  'drained',
+  'remaining',
+]);
+
+const CHECKBOX_FIELDS = new Set([
+  'correction_required',
+  'last_sync_ok',
+  'sync_ok',
+]);
+
+const SINGLE_LINE_FIELDS = new Set([
+  'record_key',
+  'section',
+  'title',
+  'status',
+  'metric',
+  'source_table',
+  'updated_at',
+  'task_id',
+  'phase_id',
+  'receipt_type',
+  'event_type',
+  'project_id',
+  'event_id',
+  'action_id',
+  'surface',
+  'lifecycle_phase',
+  'latest_event_id',
+  'latest_surface',
+  'latest_phase',
+  'latest_status',
+  'latest_created_at',
+  'latest_atlas_status',
+  'latest_atlas_target',
+  'at',
+  'last_replay_at',
+  'source',
+  'snapshot_id',
+  'target',
+  'hash',
+  'source_sha256',
+  'lane',
+  'priority',
+  'owner',
+  'owner_label',
+  'card_title',
+  'readable_status',
+  'status_group',
+  'source_kind',
+  'source_id',
+  'deferred_id',
+  'target_surface',
+  'created_at',
+  'due',
+  'backfill_scope',
+  'sync_status',
+  'last_sync_at',
+  'last_drain_at',
+  'queue_oldest_at',
+  'drain_last_status',
+]);
+
+function fieldTypeFor(name) {
+  if (NUMBER_FIELDS.has(name)) return 'number';
+  if (CHECKBOX_FIELDS.has(name)) return 'checkbox';
+  if (SINGLE_LINE_FIELDS.has(name)) return 'singleLineText';
+  return 'multilineText';
+}
+
+function fieldForHeader(name) {
+  const type = fieldTypeFor(name);
+  if (type === 'number') return field(name, type, { precision: 0 });
+  if (type === 'checkbox') return field(name, type, { icon: 'check', color: 'greenBright' });
+  return field(name, type);
+}
+
+function fieldDefsForTable(tableName, headers = []) {
+  if (tableName === 'Dashboard') {
+    return [
+      field('record_key', 'singleLineText'),
+      field('sort_order', 'number', { precision: 0 }),
+      field('section', 'singleLineText'),
+      field('title', 'singleLineText'),
+      field('status', 'singleLineText'),
+      field('metric', 'singleLineText'),
+      field('summary'),
+      field('next_action'),
+      field('evidence'),
+      field('source_table', 'singleLineText'),
+      field('updated_at', 'singleLineText'),
+    ];
+  }
+  if (tableName === 'OwnerBoard') {
+    return [
+      field('record_key', 'singleLineText'),
+      field('priority_rank', 'number', { precision: 0 }),
+      field('lane', 'singleLineText'),
+      field('priority', 'singleLineText'),
+      field('owner', 'singleLineText'),
+      field('owner_label', 'singleLineText'),
+      field('card_title', 'singleLineText'),
+      field('readable_status', 'singleLineText'),
+      field('status_group', 'singleLineText'),
+      field('metric', 'singleLineText'),
+      field('summary'),
+      field('why_it_matters'),
+      field('next_action'),
+      field('evidence'),
+      field('source_table', 'singleLineText'),
+      field('source_kind', 'singleLineText'),
+      field('source_id', 'singleLineText'),
+      field('updated_at', 'singleLineText'),
+    ];
+  }
+  if (tableName === 'DeferredLedger') {
+    return [
+      field('record_key', 'singleLineText'),
+      field('deferred_id', 'singleLineText'),
+      field('priority_rank', 'number', { precision: 0 }),
+      field('priority', 'singleLineText'),
+      field('owner', 'singleLineText'),
+      field('target_surface', 'singleLineText'),
+      field('card_title', 'singleLineText'),
+      field('readable_status', 'singleLineText'),
+      field('summary'),
+      field('why_it_matters'),
+      field('next_action'),
+      field('evidence'),
+      field('created_at', 'singleLineText'),
+      field('due', 'singleLineText'),
+      field('backfill_scope', 'singleLineText'),
+      field('updated_at', 'singleLineText'),
+    ];
+  }
+  if (tableName === 'OwnerAirtableSync') {
+    return [
+      field('record_key', 'singleLineText'),
+      field('section', 'singleLineText'),
+      field('card_title', 'singleLineText'),
+      field('sync_status', 'singleLineText'),
+      field('last_sync_at', 'singleLineText'),
+      field('last_sync_ok', 'checkbox', { icon: 'check', color: 'greenBright' }),
+      field('last_sync_error'),
+      field('queue_depth', 'number', { precision: 0 }),
+      field('queue_oldest_at', 'singleLineText'),
+      field('queue_oldest_age_minutes', 'number', { precision: 0 }),
+      field('invalid_line_count', 'number', { precision: 0 }),
+      field('drain_last_status', 'singleLineText'),
+      field('last_drain_at', 'singleLineText'),
+      field('run_count', 'number', { precision: 0 }),
+      field('summary'),
+      field('next_owner_action'),
+      field('evidence'),
+      field('updated_at', 'singleLineText'),
+    ];
+  }
+  if (tableName === 'AtlasContext') {
+    return [
+      field('record_key', 'singleLineText'),
+      field('source', 'singleLineText'),
+      field('status', 'singleLineText'),
+      field('snapshot_id', 'singleLineText'),
+      field('target', 'singleLineText'),
+      field('nodes', 'number', { precision: 0 }),
+      field('edges', 'number', { precision: 0 }),
+      field('active_gates', 'number', { precision: 0 }),
+      field('sentinel_high', 'number', { precision: 0 }),
+      field('summary'),
+      field('updated_at', 'singleLineText'),
+    ];
+  }
+  return [
+    field('record_key', 'singleLineText'),
+    ...headers.filter((header) => header && header !== 'record_key').map((header) => fieldForHeader(header)),
+  ];
+}
+
+async function getMeta({ token, baseId, apiFetch }) {
+  return airtableRequest({ token, apiFetch, path: `/v0/meta/bases/${baseId}/tables` });
+}
+
+async function ensureTables({ token, baseId, tablePlans, apiFetch, dryRun = false }) {
+  const meta = await getMeta({ token, baseId, apiFetch });
+  const existing = new Map((meta.tables || []).map((table) => [table.name, table]));
+  const results = [];
+  for (const plan of tablePlans) {
+    const current = existing.get(plan.name);
+    if (!current) {
+      if (!dryRun) {
+        const created = await airtableRequest({
+          token,
+          apiFetch,
+          method: 'POST',
+          path: `/v0/meta/bases/${baseId}/tables`,
+          body: {
+            name: plan.name,
+            description: plan.description || 'Aria owner runtime ledger sync table',
+            fields: plan.fields,
+          },
+        });
+        existing.set(plan.name, created);
+        results.push({ table: plan.name, action: 'created', fieldCount: plan.fields.length });
+      } else {
+        results.push({ table: plan.name, action: 'would_create', fieldCount: plan.fields.length });
+      }
+      continue;
+    }
+    const fields = new Set((current.fields || []).map((entry) => entry.name));
+    const missing = plan.fields.filter((entry) => !fields.has(entry.name));
+    for (const missingField of missing) {
+      if (!dryRun) {
+        await airtableRequest({
+          token,
+          apiFetch,
+          method: 'POST',
+          path: `/v0/meta/bases/${baseId}/tables/${current.id}/fields`,
+          body: missingField,
+        });
+      }
+    }
+    results.push({ table: plan.name, action: missing.length ? (dryRun ? 'would_add_fields' : 'added_fields') : 'exists', missingFields: missing.map((entry) => entry.name) });
+  }
+  return results;
+}
+
+function recordKey(tableName, row, index) {
+  const get = (key) => row[key] || '';
+  if (tableName === 'Overview') return `overview:${get('task_id') || 'latest'}`;
+  if (tableName === 'Phases') return `phase:${get('task_id')}:${get('phase_id') || index}`;
+  if (tableName === 'Events') return `event:${get('task_id')}:${get('phase_id')}:${get('at')}:${get('event_type')}:${index}`;
+  if (tableName === 'Receipts') return `receipt:${get('task_id')}:${get('receipt_type')}:${get('at') || index}`;
+  if (tableName === 'Blockers') return `blocker:${get('task_id')}:${get('phase_id')}:${get('blocker')}:${index}`;
+  if (tableName === 'ActionLedger') return `action-ledger:${get('project_id')}`;
+  if (tableName === 'ActionLedgerPublishQueue') return `publish-queue:${get('project_id')}:${get('event_id') || index}`;
+  if (tableName === 'Dashboard') return `dashboard:${get('section')}:${get('title')}`;
+  if (tableName === 'OwnerBoard') return `owner-board:${get('source_table')}:${get('source_id') || get('card_title') || index}`;
+  if (tableName === 'DeferredLedger') return `deferred:${get('deferred_id') || get('card_title') || index}`;
+  if (tableName === 'OwnerAirtableSync') return `owner-sync:${get('section')}:${get('card_title') || index}`;
+  if (tableName === 'AtlasContext') return `atlas:${get('source')}:${get('target') || get('snapshot_id') || index}`;
+  return `${tableName}:${index}`;
+}
+
+function coerceValueForField(fieldName, value) {
+  if (value === null || value === undefined) return '';
+  if (NUMBER_FIELDS.has(fieldName)) {
+    if (value === '') return undefined;
+    const number = Number(value);
+    return Number.isFinite(number) ? number : undefined;
+  }
+  if (CHECKBOX_FIELDS.has(fieldName)) {
+    if (value === '' || value === 'false' || value === false || value === '0') return false;
+    return Boolean(value);
+  }
+  if (typeof value !== 'string') return JSON.stringify(value);
+  return value.slice(0, 95000);
+}
+
+function rowsForTable(tableName, rows) {
+  return rows.map((row, index) => ({
+    fields: Object.fromEntries(
+      Object.entries({
+        record_key: recordKey(tableName, row, index),
+        ...row,
+      })
+        .map(([key, value]) => [key, coerceValueForField(key, value)])
+        .filter(([, value]) => value !== undefined),
+    ),
+  }));
+}
+
+function numberFrom(value) {
+  const n = Number(value);
+  return Number.isFinite(n) ? n : 0;
+}
+
+function firstNonEmpty(...values) {
+  for (const value of values) {
+    if (value !== null && value !== undefined && String(value).trim()) return String(value).trim();
+  }
+  return '';
+}
+
+function readJsonFile(path) {
+  try {
+    if (!existsSync(path)) return null;
+    return JSON.parse(readFileSync(path, 'utf8'));
+  } catch (error) {
+    return { ok: false, parse_error: error.message, path };
+  }
+}
+
+function readJsonlFile(path) {
+  if (!existsSync(path)) return { path, lines: [], entries: [], invalid: [] };
+  const lines = readFileSync(path, 'utf8').split(/\r?\n/).filter(Boolean);
+  const entries = [];
+  const invalid = [];
+  for (const line of lines) {
+    try {
+      entries.push(JSON.parse(line));
+    } catch {
+      invalid.push(line.slice(0, 500));
+    }
+  }
+  return { path, lines, entries, invalid };
+}
+
+function minutesSince(value, nowMs = Date.now()) {
+  if (!value) return 0;
+  const time = Date.parse(value);
+  if (!Number.isFinite(time)) return 0;
+  return Math.max(0, Math.round((nowMs - time) / 60000));
+}
+
+function priorityRank(priority) {
+  const normalized = String(priority || '').toLowerCase();
+  if (normalized.includes('p0') || normalized.includes('critical')) return 0;
+  if (normalized.includes('p1') || normalized.includes('high')) return 1;
+  if (normalized.includes('p2') || normalized.includes('medium')) return 2;
+  if (normalized.includes('p3') || normalized.includes('low')) return 3;
+  return 4;
+}
+
+function statusGroup(status) {
+  const normalized = String(status || '').toLowerCase();
+  if (/(blocked|failed|needs|queued)/.test(normalized)) return 'needs-action';
+  if (/(verified|completed|clear|healthy|visible|synced)/.test(normalized)) return 'verified';
+  if (/(active|running|repaired)/.test(normalized)) return 'in-progress';
+  if (/(deferred|planned|pending)/.test(normalized)) return 'deferred';
+  return 'watch';
+}
+
+function ownerBoardRow({
+  priority = 'P2',
+  lane,
+  owner = 'Aria',
+  cardTitle,
+  readableStatus,
+  metric = '',
+  summary = '',
+  whyItMatters = '',
+  nextAction = '',
+  evidence = '',
+  sourceTable,
+  sourceKind,
+  sourceId,
+  updatedAt,
+}) {
+  const status = readableStatus || 'watch';
+  return {
+    priority_rank: priorityRank(priority),
+    lane,
+    priority,
+    owner,
+    owner_label: `${priority} - ${lane} - ${status}`,
+    card_title: cardTitle,
+    readable_status: status,
+    status_group: statusGroup(status),
+    metric,
+    summary,
+    why_it_matters: whyItMatters,
+    next_action: nextAction,
+    evidence,
+    source_table: sourceTable,
+    source_kind: sourceKind,
+    source_id: sourceId,
+    updated_at: updatedAt,
+  };
+}
+
+function buildDeferredLedgerRows({ generatedAt }) {
+  return [
+    {
+      deferred_id: 'atlas-github-mirror-owner',
+      priority_rank: 1,
+      priority: 'P1',
+      owner: 'Atlas',
+      target_surface: 'atlas-runtime-github-mirror',
+      card_title: 'Make Atlas own mirroring its runtime repo to GitHub',
+      readable_status: 'deferred',
+      summary: 'Atlas runtime changes currently live under ~/.aria/atlas with no remote configured, so fixes are local-only until an explicit mirror/publish path exists.',
+      why_it_matters: 'Atlas is the source of codebase substrate. If Atlas cannot mirror itself with evidence and secret-safe excludes, the substrate layer can drift from the repo-of-record.',
+      next_action: 'Add Atlas-owned mirror command plus QA: detect remote, redact secrets/build artifacts, commit only owned runtime changes, push to GitHub, and report mirror evidence into this ledger.',
+      evidence: '~/.aria/atlas has no remote configured; owner requested Atlas should be in charge of mirroring to GitHub.',
+      created_at: generatedAt,
+      due: 'deferred',
+      backfill_scope: 'future-atlas-runtime-mirroring',
+      updated_at: generatedAt,
+    },
+    {
+      deferred_id: 'action-ledger-publish-replay-controls',
+      priority_rank: 0,
+      priority: 'P0',
+      owner: 'Aria Runtime',
+      target_surface: 'action-ledger-hive-runtime-replay',
+      card_title: 'Build action-ledger publish replay controls and owner-visible status',
+      readable_status: 'open',
+      summary: 'ActionLedgerPublishQueue rows are visible in Airtable, but queued Hive/runtime publish failures are not yet owner-replayable or monitored end to end from the owner board.',
+      why_it_matters: 'The ledger is only first-class if a future session can drain queued runtime events, see expected vs observed publish results, and know whether Hive/runtime actually received the state.',
+      next_action: 'Implement owner-visible replay controls/status for ActionLedgerPublishQueue: run replayActionLedgerPublishOutbox by project id, persist replay attempts/results, update Airtable queue rows after replay, expose success/failure counts on OwnerBoard, and add QA proving queue count changes after a real or fake publish replay.',
+      evidence: 'Live Airtable readback after owner board work showed ActionLedgerPublishQueue=13; next first-class item named by owner session was replay plus monitoring so queued events are not just stored locally.',
+      created_at: generatedAt,
+      due: 'open',
+      backfill_scope: 'action-ledger-runtime-publish-replay',
+      updated_at: generatedAt,
+    },
+  ];
+}
+
+function buildOwnerBoardRows({ manifest, tableRows, atlasRows, deferredRows }) {
+  const generatedAt = new Date().toISOString();
+  const overview = tableRows.Overview?.[0] || {};
+  const blockerRows = tableRows.Blockers || [];
+  const queueRows = tableRows.ActionLedgerPublishQueue || [];
+  const actionRows = tableRows.ActionLedger || [];
+  const eventRows = tableRows.Events || [];
+  const ownerSyncRows = tableRows.OwnerAirtableSync || [];
+  const atlasHealth = atlasRows.find((row) => row.source === 'atlas-daemon') || {};
+  const rows = [];
+
+  rows.push(ownerBoardRow({
+    priority: overview.status === 'active' ? 'P1' : 'P2',
+    lane: 'Now',
+    owner: 'Codex',
+    cardTitle: 'Current owner task',
+    readableStatus: overview.status || manifest.taskStatus || 'unknown',
+    metric: overview.current_phase || '',
+    summary: firstNonEmpty(overview.goal, 'No active task summary exported.'),
+    whyItMatters: 'This is the top-level owner-visible work item; it should be understandable without opening raw JSON or logs.',
+    nextAction: overview.next_action || 'Keep action ledger, QA, and owner board in sync.',
+    evidence: manifest.taskFile || 'Overview',
+    sourceTable: 'Overview',
+    sourceKind: 'current-task',
+    sourceId: overview.task_id || manifest.taskId || 'latest',
+    updatedAt: generatedAt,
+  }));
+
+  rows.push(ownerBoardRow({
+    priority: blockerRows.length ? 'P0' : 'P3',
+    lane: 'Quality',
+    owner: 'QA',
+    cardTitle: 'Open blockers',
+    readableStatus: blockerRows.length ? 'needs-action' : 'clear',
+    metric: `${blockerRows.length} blockers`,
+    summary: blockerRows.slice(0, 5).map((row) => row.blocker).filter(Boolean).join(' | ') || 'No exported blockers.',
+    whyItMatters: 'Blockers are the fastest way for the owner to see what prevents a true completion claim.',
+    nextAction: blockerRows[0]?.action || overview.next_action || '',
+    evidence: 'Blockers',
+    sourceTable: 'Blockers',
+    sourceKind: 'quality-blockers',
+    sourceId: 'open-blockers',
+    updatedAt: generatedAt,
+  }));
+
+  rows.push(ownerBoardRow({
+    priority: queueRows.length ? 'P1' : 'P3',
+    lane: 'Replay',
+    owner: 'Hive',
+    cardTitle: 'Hive publish queue',
+    readableStatus: queueRows.length ? 'queued' : 'clear',
+    metric: `${queueRows.length} queued`,
+    summary: queueRows.slice(0, 5).map((row) => `${row.project_id || 'project'}:${row.error || row.recovery || 'queued'}`).join(' | ') || 'No queued publish failures.',
+    whyItMatters: 'Queued events mean local evidence exists but Hive/runtime may not yet have received the latest state.',
+    nextAction: queueRows.length ? 'Run action-ledger replay for queued project ids, then drain owner Airtable sync.' : '',
+    evidence: 'ActionLedgerPublishQueue',
+    sourceTable: 'ActionLedgerPublishQueue',
+    sourceKind: 'publish-queue',
+    sourceId: 'publish-queue',
+    updatedAt: generatedAt,
+  }));
+
+  rows.push(ownerBoardRow({
+    priority: atlasHealth.status === 'healthy' ? 'P2' : 'P1',
+    lane: 'Atlas',
+    owner: 'Atlas',
+    cardTitle: 'Atlas substrate freshness',
+    readableStatus: atlasHealth.status || 'unavailable',
+    metric: atlasHealth.snapshot_id ? `snapshot ${atlasHealth.snapshot_id}` : '',
+    summary: atlasHealth.summary || 'Atlas health row unavailable.',
+    whyItMatters: 'Atlas is the substrate source for architecture and runtime context; stale Atlas data weakens worker QA and future mirroring.',
+    nextAction: atlasHealth.status === 'healthy' ? 'Keep Atlas cache and owner sync timer healthy.' : 'Repair Atlas before relying on fresh dossiers.',
+    evidence: 'AtlasContext',
+    sourceTable: 'AtlasContext',
+    sourceKind: 'atlas-health',
+    sourceId: 'atlas-daemon',
+    updatedAt: generatedAt,
+  }));
+
+  for (const row of actionRows.slice(0, 25)) {
+    rows.push(ownerBoardRow({
+      priority: statusGroup(row.latest_status) === 'needs-action' ? 'P1' : 'P2',
+      lane: 'Projects',
+      owner: row.latest_surface || 'Aria',
+      cardTitle: `Project ${row.project_id || 'unknown'}`,
+      readableStatus: row.latest_status || 'unknown',
+      metric: `${row.event_count || 0} events`,
+      summary: `Latest phase ${row.latest_phase || 'unknown'} via ${row.latest_surface || 'unknown surface'}.`,
+      whyItMatters: 'Backfilled project rows make historical action-ledger state visible as cards instead of raw tables.',
+      nextAction: row.publish_outbox_count && row.publish_outbox_count !== '0' ? 'Replay queued runtime publish events.' : '',
+      evidence: 'ActionLedger',
+      sourceTable: 'ActionLedger',
+      sourceKind: 'action-project-backfill',
+      sourceId: row.project_id || 'unknown',
+      updatedAt: row.latest_created_at || generatedAt,
+    }));
+  }
+
+  for (const row of eventRows.slice(-25).reverse()) {
+    rows.push(ownerBoardRow({
+      priority: statusGroup(row.status) === 'needs-action' ? 'P1' : 'P3',
+      lane: 'Recent Events',
+      owner: row.surface || 'Aria',
+      cardTitle: `${row.event_type || 'event'} · ${row.phase_id || row.task_id || 'runtime'}`,
+      readableStatus: row.status || 'observed',
+      metric: row.at || '',
+      summary: firstNonEmpty(row.summary, row.intent, `${row.event_type || 'event'} from ${row.surface || 'unknown surface'}`),
+      whyItMatters: 'Recent backfilled events let the owner inspect what changed without decoding event JSON.',
+      nextAction: row.action || '',
+      evidence: 'Events',
+      sourceTable: 'Events',
+      sourceKind: 'recent-event-backfill',
+      sourceId: `${row.task_id || 'task'}:${row.phase_id || 'phase'}:${row.at || row.event_type || 'event'}`,
+      updatedAt: row.at || generatedAt,
+    }));
+  }
+
+  for (const row of ownerSyncRows) {
+    rows.push(ownerBoardRow({
+      priority: statusGroup(row.sync_status || row.drain_last_status) === 'needs-action' ? 'P1' : 'P2',
+      lane: 'Owner Sync',
+      owner: 'Aria',
+      cardTitle: row.card_title,
+      readableStatus: row.sync_status || row.drain_last_status || 'watch',
+      metric: row.queue_depth ? `${row.queue_depth} queued` : '',
+      summary: row.summary,
+      whyItMatters: 'This is the owner-visible health surface for the Airtable mirror itself; sync failures must show up as records, not disappear into local logs.',
+      nextAction: row.next_owner_action,
+      evidence: row.evidence,
+      sourceTable: 'OwnerAirtableSync',
+      sourceKind: 'sync-control',
+      sourceId: row.card_title,
+      updatedAt: row.updated_at,
+    }));
+  }
+
+  for (const row of deferredRows) {
+    rows.push(ownerBoardRow({
+      priority: row.priority,
+      lane: 'Deferred',
+      owner: row.owner,
+      cardTitle: row.card_title,
+      readableStatus: row.readable_status,
+      metric: row.target_surface,
+      summary: row.summary,
+      whyItMatters: row.why_it_matters,
+      nextAction: row.next_action,
+      evidence: row.evidence,
+      sourceTable: 'DeferredLedger',
+      sourceKind: 'deferred-ledger',
+      sourceId: row.deferred_id,
+      updatedAt: row.updated_at,
+    }));
+  }
+
+  return rows;
+}
+
+function buildOwnerAirtableSyncRows({ ownerAirtableDir, statePath, generatedAt }) {
+  const latestPath = resolve(statePath || join(ownerAirtableDir, 'latest.json'));
+  const drainLatestPath = join(ownerAirtableDir, 'drain-latest.json');
+  const historyPath = join(ownerAirtableDir, 'drain-run-history.jsonl');
+  const queuePath = join(ownerAirtableDir, 'sync-queue.jsonl');
+  const latest = readJsonFile(latestPath);
+  const drainLatest = readJsonFile(drainLatestPath);
+  const queue = readJsonlFile(queuePath);
+  const history = readJsonlFile(historyPath);
+  const nowMs = Date.parse(generatedAt) || Date.now();
+  const validQueueEntries = queue.entries.filter((entry) => entry?.schema === 'aria.owner_airtable_sync_needed.v1');
+  const oldestQueuedAt = validQueueEntries
+    .map((entry) => entry.at || entry.createdAt)
+    .filter(Boolean)
+    .sort()[0] || '';
+  const lastHistory = history.entries[history.entries.length - 1] || {};
+  const latestOk = latest?.ok === true;
+  const latestError = latest?.error || latest?.syncError || latest?.parse_error || '';
+  const drainStatus = drainLatest
+    ? (drainLatest.skipped ? `skipped:${drainLatest.reason || 'unknown'}` : (drainLatest.ok ? 'success' : 'failed'))
+    : 'no-run-recorded';
+
+  return [
+    {
+      section: 'Control',
+      card_title: 'Owner Airtable sync',
+      sync_status: latest ? (latestOk ? 'synced' : 'failed') : 'no-prior-sync',
+      last_sync_at: latest?.generatedAt || latest?.at || '',
+      last_sync_ok: latestOk,
+      last_sync_error: latestError,
+      queue_depth: queue.lines.length,
+      queue_oldest_at: oldestQueuedAt,
+      queue_oldest_age_minutes: minutesSince(oldestQueuedAt, nowMs),
+      invalid_line_count: queue.invalid.length,
+      drain_last_status: drainStatus,
+      last_drain_at: drainLatest?.at || lastHistory?.at || '',
+      run_count: history.entries.length,
+      summary: latest ? `Last sync ${latestOk ? 'succeeded' : 'did not succeed'} for base ${latest.baseId || 'unknown'}; queue has ${queue.lines.length} lines.` : 'No previous owner Airtable sync state file was found.',
+      next_owner_action: latestOk ? 'Use OwnerBoard as the visual first stop; investigate this table only if sync status changes.' : 'Inspect OwnerAirtableSync error fields and drain-run-history, then rerun owner:airtable-drain.',
+      evidence: `${latestPath}; ${queuePath}; ${drainLatestPath}`,
+      updated_at: generatedAt,
+    },
+    {
+      section: 'Queue',
+      card_title: 'Owner sync queue backlog',
+      sync_status: queue.lines.length ? 'queued' : 'clear',
+      last_sync_at: latest?.generatedAt || latest?.at || '',
+      last_sync_ok: latestOk,
+      last_sync_error: latestError,
+      queue_depth: queue.lines.length,
+      queue_oldest_at: oldestQueuedAt,
+      queue_oldest_age_minutes: minutesSince(oldestQueuedAt, nowMs),
+      invalid_line_count: queue.invalid.length,
+      drain_last_status: drainStatus,
+      last_drain_at: drainLatest?.at || lastHistory?.at || '',
+      run_count: history.entries.length,
+      summary: queue.lines.length ? `${queue.lines.length} sync requests waiting; ${queue.invalid.length} invalid queue lines.` : 'No pending owner Airtable sync queue entries.',
+      next_owner_action: queue.lines.length ? 'Let the user timer drain the queue or run owner:airtable-drain manually.' : 'No queue action needed.',
+      evidence: queuePath,
+      updated_at: generatedAt,
+    },
+    {
+      section: 'Drain',
+      card_title: 'Owner sync drain runner',
+      sync_status: drainStatus,
+      last_sync_at: latest?.generatedAt || latest?.at || '',
+      last_sync_ok: latestOk,
+      last_sync_error: drainLatest?.syncError || latestError,
+      queue_depth: queue.lines.length,
+      queue_oldest_at: oldestQueuedAt,
+      queue_oldest_age_minutes: minutesSince(oldestQueuedAt, nowMs),
+      invalid_line_count: queue.invalid.length,
+      drain_last_status: drainStatus,
+      last_drain_at: drainLatest?.at || lastHistory?.at || '',
+      run_count: history.entries.length,
+      summary: drainLatest ? `Last drain consumed ${drainLatest.consumed || 0}, drained ${drainLatest.drained || 0}, remaining ${drainLatest.remaining || 0}.` : 'No drain state file was found.',
+      next_owner_action: drainLatest?.ok === false ? 'Fix the recorded syncError before trusting automatic Airtable freshness.' : 'Keep the systemd timer active and monitor failure rows here.',
+      evidence: `${drainLatestPath}; ${historyPath}`,
+      updated_at: generatedAt,
+    },
+  ];
+}
+
+function buildDashboardRows({ manifest, tableRows, atlasRows, deferredRows }) {
+  const overview = tableRows.Overview?.[0] || {};
+  const actionLedgerRows = tableRows.ActionLedger || [];
+  const queueRows = tableRows.ActionLedgerPublishQueue || [];
+  const blockerRows = tableRows.Blockers || [];
+  const ownerSyncRows = tableRows.OwnerAirtableSync || [];
+  const ownerSync = ownerSyncRows.find((row) => row.section === 'Control') || {};
+  const ownerQueue = ownerSyncRows.find((row) => row.section === 'Queue') || {};
+  const drainSync = ownerSyncRows.find((row) => row.section === 'Drain') || {};
+  const deferred = deferredRows[0] || {};
+  const atlasHealth = atlasRows.find((row) => row.source === 'atlas-daemon') || {};
+  const generatedAt = new Date().toISOString();
+  return [
+    {
+      sort_order: 10,
+      section: 'Runtime',
+      title: 'Current task',
+      status: overview.status || manifest.taskStatus || 'unknown',
+      metric: overview.current_phase || '',
+      summary: overview.goal || '',
+      next_action: overview.next_action || '',
+      evidence: manifest.taskFile || '',
+      source_table: 'Overview',
+      updated_at: generatedAt,
+    },
+    {
+      sort_order: 20,
+      section: 'Quality',
+      title: 'Open blockers',
+      status: blockerRows.length ? 'needs-action' : 'clear',
+      metric: String(blockerRows.length),
+      summary: blockerRows.slice(0, 5).map((row) => row.blocker).filter(Boolean).join(' | '),
+      next_action: blockerRows[0]?.action || overview.next_action || '',
+      evidence: 'Blockers',
+      source_table: 'Blockers',
+      updated_at: generatedAt,
+    },
+    {
+      sort_order: 30,
+      section: 'Replay',
+      title: 'Publish queue',
+      status: queueRows.length ? 'queued' : 'empty',
+      metric: String(queueRows.length),
+      summary: queueRows.slice(0, 5).map((row) => `${row.surface || 'event'}:${row.error || row.recovery || 'queued'}`).join(' | '),
+      next_action: queueRows.length ? 'Run aria owner action-ledger-replay for queued project ids.' : '',
+      evidence: 'ActionLedgerPublishQueue',
+      source_table: 'ActionLedgerPublishQueue',
+      updated_at: generatedAt,
+    },
+    {
+      sort_order: 40,
+      section: 'Atlas',
+      title: 'Atlas substrate',
+      status: atlasHealth.status || (actionLedgerRows.some((row) => row.latest_atlas_status) ? 'ledger-observed' : 'unavailable'),
+      metric: atlasHealth.snapshot_id || '',
+      summary: atlasHealth.summary || actionLedgerRows.slice(0, 5).map((row) => `${row.project_id}:${row.latest_atlas_status || 'none'}`).join(' | '),
+      next_action: atlasHealth.status === 'unavailable' ? 'Check atlas-server health before relying on fresh dossiers.' : '',
+      evidence: 'AtlasContext',
+      source_table: 'AtlasContext',
+      updated_at: generatedAt,
+    },
+    {
+      sort_order: 50,
+      section: 'Coverage',
+      title: 'Action projects',
+      status: actionLedgerRows.length ? 'visible' : 'empty',
+      metric: String(actionLedgerRows.length),
+      summary: actionLedgerRows.slice(0, 5).map((row) => `${row.project_id}:${row.latest_status || 'unknown'}`).join(' | '),
+      next_action: '',
+      evidence: 'ActionLedger',
+      source_table: 'ActionLedger',
+      updated_at: generatedAt,
+    },
+    {
+      sort_order: 60,
+      section: 'Owner Sync',
+      title: 'Airtable sync control',
+      status: ownerSync.sync_status || 'unknown',
+      metric: ownerSync.last_sync_at || '',
+      summary: ownerSync.summary || '',
+      next_action: ownerSync.next_owner_action || '',
+      evidence: ownerSync.evidence || 'OwnerAirtableSync',
+      source_table: 'OwnerAirtableSync',
+      updated_at: generatedAt,
+    },
+    {
+      sort_order: 70,
+      section: 'Owner Sync',
+      title: 'Airtable queue backlog',
+      status: ownerQueue.sync_status || 'unknown',
+      metric: String(ownerQueue.queue_depth || 0),
+      summary: ownerQueue.summary || '',
+      next_action: ownerQueue.next_owner_action || '',
+      evidence: ownerQueue.evidence || 'OwnerAirtableSync',
+      source_table: 'OwnerAirtableSync',
+      updated_at: generatedAt,
+    },
+    {
+      sort_order: 80,
+      section: 'Deferred',
+      title: 'Atlas GitHub mirror',
+      status: deferred.readable_status || 'deferred',
+      metric: deferred.target_surface || '',
+      summary: deferred.summary || '',
+      next_action: deferred.next_action || '',
+      evidence: deferred.evidence || 'DeferredLedger',
+      source_table: 'DeferredLedger',
+      updated_at: generatedAt,
+    },
+    {
+      sort_order: 90,
+      section: 'Owner Sync',
+      title: 'Airtable drain runner',
+      status: drainSync.drain_last_status || drainSync.sync_status || 'unknown',
+      metric: drainSync.last_drain_at || '',
+      summary: drainSync.summary || '',
+      next_action: drainSync.next_owner_action || '',
+      evidence: drainSync.evidence || 'OwnerAirtableSync',
+      source_table: 'OwnerAirtableSync',
+      updated_at: generatedAt,
+    },
+  ];
+}
+
+function atlasSocketGet(socketPath, route, timeoutMs = 1500) {
+  return new Promise((resolve) => {
+    if (!existsSync(socketPath)) {
+      resolve({ ok: false, error: `atlas socket missing at ${socketPath}` });
+      return;
+    }
+    const req = http.request({
+      socketPath,
+      path: route,
+      method: 'GET',
+      timeout: timeoutMs,
+      headers: { host: 'atlas' },
+    }, (res) => {
+      let body = '';
+      res.setEncoding('utf8');
+      res.on('data', (chunk) => { body += chunk; });
+      res.on('end', () => {
+        try {
+          resolve({ ok: res.statusCode >= 200 && res.statusCode < 300, statusCode: res.statusCode, body: body ? JSON.parse(body) : {} });
+        } catch {
+          resolve({ ok: false, statusCode: res.statusCode, error: body.slice(0, 500) });
+        }
+      });
+    });
+    req.on('timeout', () => req.destroy(new Error(`atlas timeout ${timeoutMs}ms`)));
+    req.on('error', (error) => resolve({ ok: false, error: error.message }));
+    req.end();
+  });
+}
+
+async function buildAtlasRows({ actionLedgerRows, atlasSocket }) {
+  const rows = [];
+  const health = await atlasSocketGet(atlasSocket, '/healthz');
+  if (health.ok) {
+    const snapshot = health.body?.last_successful_snapshot || health.body?.last_snapshot || {};
+    rows.push({
+      source: 'atlas-daemon',
+      status: health.body?.ok === false ? 'unhealthy' : 'healthy',
+      snapshot_id: snapshot.id || '',
+      target: 'atlas-server',
+      nodes: numberFrom(snapshot.node_count),
+      edges: numberFrom(snapshot.edge_count),
+      active_gates: 0,
+      sentinel_high: 0,
+      summary: `schema=${health.body?.schema_version || ''} snapshot_status=${snapshot.status || ''}`,
+      updated_at: new Date().toISOString(),
+    });
+  } else {
+    rows.push({
+      source: 'atlas-daemon',
+      status: 'unavailable',
+      snapshot_id: '',
+      target: 'atlas-server',
+      nodes: 0,
+      edges: 0,
+      active_gates: 0,
+      sentinel_high: 0,
+      summary: health.error || `HTTP ${health.statusCode || 'unknown'}`,
+      updated_at: new Date().toISOString(),
+    });
+  }
+  for (const row of actionLedgerRows) {
+    if (!row.latest_atlas_status && !row.latest_atlas_target) continue;
+    rows.push({
+      source: 'action-ledger',
+      status: row.latest_atlas_status || 'observed',
+      snapshot_id: '',
+      target: row.latest_atlas_target || row.project_id,
+      nodes: 0,
+      edges: 0,
+      active_gates: 0,
+      sentinel_high: numberFrom(row.sentinel_findings),
+      summary: `project=${row.project_id} events=${row.event_count} latest=${row.latest_status}`,
+      updated_at: row.latest_created_at || new Date().toISOString(),
+    });
+  }
+  return rows;
+}
+
+async function upsertRecords({ token, baseId, tableName, records, apiFetch, dryRun = false }) {
+  if (dryRun) return { table: tableName, rows: records.length, upserted: 0, dryRun: true };
+  let upserted = 0;
+  for (let index = 0; index < records.length; index += 10) {
+    const batch = records.slice(index, index + 10);
+    if (!batch.length) continue;
+    const result = await airtableRequest({
+      token,
+      apiFetch,
+      method: 'PATCH',
+      path: `/v0/${baseId}/${encodeURIComponent(tableName)}`,
+      body: {
+        performUpsert: { fieldsToMergeOn: ['record_key'] },
+        records: batch,
+        typecast: true,
+      },
+    });
+    upserted += (result.records || []).length;
+  }
+  return { table: tableName, rows: records.length, upserted };
+}
+
+export async function syncOwnerStatusAirtable(options = {}) {
+  const auth = resolveAuth(options);
+  const apiFetch = options.apiFetch || fetch;
+  const manifest = exportOwnerGoogleSheetsCsv({
+    taskId: options.taskId || null,
+    taskDir: options.taskDir || undefined,
+    runtimeStateDir: options.runtimeStateDir || undefined,
+    actionLedgerDir: options.actionLedgerDir || undefined,
+    outDir: options.outDir || undefined,
+  });
+  const tableRows = Object.fromEntries(manifest.tables.map((table) => [table.name, tableToObjects(table)]));
+  const atlasRows = await buildAtlasRows({
+    actionLedgerRows: tableRows.ActionLedger || [],
+    atlasSocket: options.atlasSocket || DEFAULT_ATLAS_SOCKET,
+  });
+  const generatedAt = new Date().toISOString();
+  const statePath = resolve(options.statePath || DEFAULT_STATE_PATH);
+  const ownerAirtableDir = resolve(options.ownerAirtableDir || dirname(statePath));
+  const deferredRows = buildDeferredLedgerRows({ generatedAt });
+  tableRows.DeferredLedger = deferredRows;
+  tableRows.AtlasContext = atlasRows;
+  tableRows.OwnerAirtableSync = buildOwnerAirtableSyncRows({ ownerAirtableDir, statePath, generatedAt });
+  tableRows.Dashboard = buildDashboardRows({ manifest, tableRows, atlasRows, deferredRows });
+  tableRows.OwnerBoard = buildOwnerBoardRows({ manifest, tableRows, atlasRows, deferredRows });
+
+  const orderedNames = Array.from(new Set(['OwnerBoard', 'Dashboard', ...manifest.tables.map((table) => table.name), 'OwnerAirtableSync', 'DeferredLedger', 'AtlasContext']));
+  const sourceTablesByName = Object.fromEntries(manifest.tables.map((table) => [table.name, table]));
+  const tablePlans = orderedNames.map((name) => {
+    const headers = sourceTablesByName[name]
+      ? (csvToRows(readFileSync(sourceTablesByName[name].path, 'utf8'))[0] || [])
+      : Object.keys(tableRows[name]?.[0] || {});
+    return { name, fields: fieldDefsForTable(name, headers) };
+  });
+
+  const schemaResults = await ensureTables({
+    token: auth.token,
+    baseId: auth.baseId,
+    tablePlans,
+    apiFetch,
+    dryRun: options.dryRun === true,
+  });
+  const syncResults = [];
+  for (const name of orderedNames) {
+    const records = rowsForTable(name, tableRows[name] || []);
+    syncResults.push(await upsertRecords({
+      token: auth.token,
+      baseId: auth.baseId,
+      tableName: name,
+      records,
+      apiFetch,
+      dryRun: options.dryRun === true,
+    }));
+  }
+  const result = {
+    ok: true,
+    schema: 'aria.owner_airtable_sync.v1',
+    generatedAt,
+    baseId: auth.baseId,
+    baseUrl: `https://airtable.com/${auth.baseId}`,
+    taskId: manifest.taskId,
+    taskStatus: manifest.taskStatus,
+    manifestPath: join(manifest.outDir, 'manifest.json'),
+    outDir: manifest.outDir,
+    dryRun: options.dryRun === true,
+    schemaResults,
+    syncResults,
+    ownerBoardRows: tableRows.OwnerBoard.length,
+    dashboardRows: tableRows.Dashboard.length,
+    ownerSyncRows: tableRows.OwnerAirtableSync.length,
+    deferredRows: tableRows.DeferredLedger.length,
+    atlasRows: tableRows.AtlasContext.length,
+  };
+  mkdirSync(dirname(statePath), { recursive: true });
+  writeFileSync(statePath, `${JSON.stringify(result, null, 2)}\n`, { mode: 0o600 });
+  return result;
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  try {
+    const result = await syncOwnerStatusAirtable(parseArgs());
+    console.log(JSON.stringify(result, null, 2));
+  } catch (error) {
+    console.error(error && error.message ? error.message : String(error));
+    process.exit(1);
+  }
+}