@erclx/aitk 1.2.0 → 1.4.0

package/src/commands/transcripts.ts

@@ -1,12 +1,7 @@
 import { resolve } from 'node:path'
 import type { Command } from 'commander'
 import { ensureYtDlp, fetchOne } from '@/transcripts/fetch'
-
-const GREY = '\x1b[0;90m'
-const WHITE = '\x1b[1;37m'
-const RED = '\x1b[0;31m'
-const GREEN = '\x1b[0;32m'
-const NC = '\x1b[0m'
+import { palette } from '@/ui'
 
 interface TranscriptOptions {
   out: string
@@ -24,6 +19,7 @@ export function register(program: Command): void {
     )
     .action(async (url: string, opts: TranscriptOptions) => {
       const outDir = resolve(process.cwd(), opts.out)
+      const { GREEN, GREY, NC, RED, WHITE } = palette(process.stderr)
       process.stderr.write(
         `${GREY}┌${NC}\n${GREY}│${NC} ${WHITE}aitk transcripts${NC}\n`,
       )

package/src/commands/wiki.ts

@@ -9,6 +9,7 @@ import {
   logStep,
   logWarn,
   outro,
+  palette,
   select,
 } from '@/ui'
 import {
@@ -20,9 +21,6 @@ import {
   WIKI_INDEX_REL,
 } from '@/wiki/init'
 
-const GREEN = '\x1b[0;32m'
-const NC = '\x1b[0m'
-
 export function register(program: Command): void {
   const wiki = program
     .command('wiki')
@@ -59,6 +57,7 @@ async function runInit(target: string): Promise<number> {
   }
 
   const plan = planWikiInit(resolved)
+  const { GREEN, NC } = palette(process.stderr)
 
   logStep(`Scanning ${WIKI_DIR_REL}`)
   if (plan.changes.includes('dir')) logAdd(WIKI_DIR_REL)

package/src/design/parse.ts

@@ -1,6 +1,19 @@
 import { readFileSync } from 'node:fs'
 
-export type Row = Record<string, string>
+/**
+ * One table cell, split into the value a renderer emits and whether the record
+ * marked it as unsourced.
+ *
+ * The marker sits inside the cell rather than in a trailing column, because a
+ * trailing marker breaks the table parse. Splitting it out here is what keeps a
+ * swatch or a font sample built from the value alone.
+ */
+export interface Cell {
+  value: string
+  tagged: boolean
+}
+
+export type Row = Record<string, Cell>
 
 export interface DesignDoc {
   personality: string
@@ -12,6 +25,11 @@ export interface DesignDoc {
   iconography: string
 }
 
+const VERIFY_TAG = /\s*\?\s*verify\s*$/
+
+/** A cell whose whole content is one balanced code span and nothing else. */
+const CODE_SPAN = /^`([^`]*)`$/
+
 export function parseDesignDoc(path: string): DesignDoc {
   const raw = readFileSync(path, 'utf8')
   const sections = splitSections(raw)
@@ -58,22 +76,41 @@ function table(body: string | undefined): Row[] {
   if (!body) return []
   const rows = body.split('\n').filter((l) => l.trim().startsWith('|'))
   if (rows.length < 2) return []
-  const headers = splitRow(rows[0])
+  const headers = splitRow(rows[0]).map((c) => c.value)
   const data = rows.slice(2)
   return data.map((line) => {
     const cells = splitRow(line)
     const row: Row = {}
     headers.forEach((h, i) => {
-      row[h] = (cells[i] ?? '').trim()
+      row[h] = cells[i] ?? emptyCell()
     })
     return row
   })
 }
 
-function splitRow(line: string): string[] {
+function emptyCell(): Cell {
+  return { value: '', tagged: false }
+}
+
+function splitRow(line: string): Cell[] {
   return line
     .replace(/^\s*\|/, '')
     .replace(/\|\s*$/, '')
     .split('|')
-    .map((c) => c.trim().replace(/\s*\?\s*verify\s*$/, ''))
+    .map(parseCell)
+}
+
+/**
+ * The tag is tested against the cell with any surrounding code span removed,
+ * since a value wrapping itself in backticks puts one after the tag and an
+ * end-anchored test misses it there. The span is restored around the clean
+ * value so an untagged cell and a tagged one carry the same formatting.
+ */
+function parseCell(raw: string): Cell {
+  const trimmed = raw.trim()
+  const span = trimmed.match(CODE_SPAN)
+  const inner = span ? span[1] : trimmed
+  if (!VERIFY_TAG.test(inner)) return { value: trimmed, tagged: false }
+  const value = inner.replace(VERIFY_TAG, '')
+  return { value: span ? `\`${value}\`` : value, tagged: true }
 }

package/src/design/render.ts

@@ -1,6 +1,6 @@
 import { mkdirSync, writeFileSync } from 'node:fs'
 import { join } from 'node:path'
-import type { DesignDoc, Row } from '@/design/parse'
+import type { Cell, DesignDoc, Row } from '@/design/parse'
 import { parseDesignDoc } from '@/design/parse'
 
 export interface RenderResult {
@@ -28,29 +28,99 @@ function slug(s: string): string {
     .replace(/(^-|-$)/g, '')
 }
 
+function cell(row: Row, key: string): Cell {
+  return row[key] ?? { value: '', tagged: false }
+}
+
+/** The value alone. Every swatch, sample, and custom property is built from it. */
+function val(row: Row, key: string): string {
+  return cell(row, key).value
+}
+
+/** The marker, rendered beside a value rather than inside it. */
+function mark(row: Row, key: string): string {
+  return cell(row, key).tagged
+    ? ' <span class="verify" title="No source anchors this value">? verify</span>'
+    : ''
+}
+
+/** A displayed cell: its escaped text, then its marker when it carries one. */
+function cellText(row: Row, key: string): string {
+  return escape(val(row, key)) + mark(row, key)
+}
+
+interface Confidence {
+  tagged: number
+  total: number
+}
+
+/**
+ * The columns the confidence ratio reads, fixed by `standards/design.md`. The
+ * first column of each table names its row, and `Multiplier` and `When used`
+ * restate what the row already carries, so none of them is something a source
+ * could anchor and none belongs in the denominator.
+ */
+const ANCHORABLE = {
+  borders: ['Radius', 'Width'],
+  color: ['Intent', 'Value'],
+  spacing: ['Value'],
+  typography: ['Family', 'Weight', 'Size', 'Line height'],
+} as const
+
+/**
+ * A cell counts when it carries a tag, or when it holds a value in a column a
+ * source could anchor. A blank the record left unfilled is neither, and so is a
+ * row name. Counting a tagged cell whichever column it sits in is what keeps a
+ * marker the preview draws from sitting outside the ratio printed beside it.
+ */
+function confidence(doc: DesignDoc): Confidence {
+  const tables: ReadonlyArray<readonly [Row[], readonly string[]]> = [
+    [doc.color, ANCHORABLE.color],
+    [doc.typography, ANCHORABLE.typography],
+    [doc.spacing, ANCHORABLE.spacing],
+    [doc.borders, ANCHORABLE.borders],
+  ]
+  let tagged = 0
+  let total = 0
+  for (const [rows, columns] of tables) {
+    for (const row of rows) {
+      for (const [key, c] of Object.entries(row)) {
+        if (!c.tagged && (!c.value || !columns.includes(key))) continue
+        total += 1
+        if (c.tagged) tagged += 1
+      }
+    }
+  }
+  return { tagged, total }
+}
+
 function buildCss(doc: DesignDoc): string {
   const lines: string[] = [':root {']
   for (const row of doc.color) {
-    if (row['Value']) {
-      lines.push(`  --color-${slug(row['Role'])}: ${row['Value']};`)
+    if (val(row, 'Value')) {
+      lines.push(`  --color-${slug(val(row, 'Role'))}: ${val(row, 'Value')};`)
     }
   }
   for (const row of doc.spacing) {
-    if (row['Value']) {
-      lines.push(`  --space-${slug(row['Step'])}: ${row['Value']};`)
+    if (val(row, 'Value')) {
+      lines.push(`  --space-${slug(val(row, 'Step'))}: ${val(row, 'Value')};`)
     }
   }
   for (const row of doc.typography) {
-    if (row['Size']) {
-      lines.push(`  --type-${slug(row['Role'])}-size: ${row['Size']};`)
+    if (val(row, 'Size')) {
+      lines.push(
+        `  --type-${slug(val(row, 'Role'))}-size: ${val(row, 'Size')};`,
+      )
     }
-    if (row['Line height']) {
-      lines.push(`  --type-${slug(row['Role'])}-lh: ${row['Line height']};`)
+    if (val(row, 'Line height')) {
+      lines.push(
+        `  --type-${slug(val(row, 'Role'))}-lh: ${val(row, 'Line height')};`,
+      )
     }
   }
   for (const row of doc.borders) {
-    if (row['Radius']) {
-      lines.push(`  --radius-${slug(row['Role'])}: ${row['Radius']};`)
+    if (val(row, 'Radius')) {
+      lines.push(`  --radius-${slug(val(row, 'Role'))}: ${val(row, 'Radius')};`)
     }
   }
   lines.push('}')
@@ -75,6 +145,14 @@ function buildHtml(doc: DesignDoc): string {
     sectionLine('Motion', doc.motion),
     sectionLine('Iconography', doc.iconography),
   ]
+  const { tagged, total } = confidence(doc)
+  const verifyStyle = tagged
+    ? '\n  .verify { color: #a4471c; font-size: 12px; font-weight: 600; margin-left: 0.35rem; white-space: nowrap; }'
+    : ''
+  const verb = tagged === 1 ? 'carries' : 'carry'
+  const summary = tagged
+    ? `\n<p class="note">${total - tagged} of ${total} cells are anchored to a source. The other ${tagged} ${verb} <code>? verify</code>, so nothing anchors them yet.</p>`
+    : ''
   return `<!doctype html>
 <html lang="en">
 <head>
@@ -91,12 +169,12 @@ function buildHtml(doc: DesignDoc): string {
   .swatch { display: inline-block; width: 1.5rem; height: 1.5rem; border-radius: 4px; border: 1px solid #ddd; vertical-align: middle; margin-right: 0.5rem; }
   .bar { display: inline-block; height: 1rem; background: #888; border-radius: 2px; vertical-align: middle; }
   .note { color: #666; font-size: 13px; margin-top: 0.5rem; }
-  .empty { color: #999; font-style: italic; }
+  .empty { color: #999; font-style: italic; }${verifyStyle}
 </style>
 </head>
 <body>
 <h1>Design tokens</h1>
-<p class="note">Generated from <code>.claude/DESIGN.md</code> by <code>aitk design render</code>. Token preview only, not a screen mock.</p>
+<p class="note">Generated from <code>.claude/DESIGN.md</code> by <code>aitk design render</code>. Token preview only, not a screen mock.</p>${summary}
 ${sections.join('\n')}
 </body>
 </html>
@@ -112,11 +190,12 @@ function sectionColor(rows: Row[]): string {
   if (!rows.length) return ''
   const body = rows
     .map((r) => {
-      const swatch = r['Value']
-        ? `<span class="swatch" style="background:${escape(r['Value'])}"></span>`
+      const value = val(r, 'Value')
+      const swatch = value
+        ? `<span class="swatch" style="background:${escape(value)}"></span>`
         : '<span class="swatch"></span>'
-      const value = r['Value'] || '<span class="empty">unset</span>'
-      return `<tr><td>${swatch}${escape(r['Role'] ?? '')}</td><td>${escape(r['Intent'] ?? '')}</td><td><code>${value}</code></td></tr>`
+      const shown = value ? escape(value) : '<span class="empty">unset</span>'
+      return `<tr><td>${swatch}${cellText(r, 'Role')}</td><td>${cellText(r, 'Intent')}</td><td><code>${shown}</code>${mark(r, 'Value')}</td></tr>`
     })
     .join('\n')
   return `<h2>Color</h2>\n<table><thead><tr><th>Role</th><th>Intent</th><th>Value</th></tr></thead><tbody>${body}</tbody></table>`
@@ -126,12 +205,12 @@ function sectionTypography(rows: Row[]): string {
   if (!rows.length) return ''
   const body = rows
     .map((r) => {
-      const family = r['Family'] || 'system-ui'
-      const weight = r['Weight'] || '400'
-      const size = r['Size'] || '16px'
-      const lh = r['Line height'] || '1.4'
+      const family = val(r, 'Family') || 'system-ui'
+      const weight = val(r, 'Weight') || '400'
+      const size = val(r, 'Size') || '16px'
+      const lh = val(r, 'Line height') || '1.4'
       const sample = `<span style="font-family:${escape(family)};font-weight:${escape(weight)};font-size:${escape(size)};line-height:${escape(lh)}">The quick brown fox</span>`
-      return `<tr><td>${escape(r['Role'] ?? '')}</td><td>${escape(family)}</td><td>${escape(weight)}</td><td>${escape(size)}</td><td>${escape(lh)}</td><td>${sample}</td></tr>`
+      return `<tr><td>${cellText(r, 'Role')}</td><td>${escape(family)}${mark(r, 'Family')}</td><td>${escape(weight)}${mark(r, 'Weight')}</td><td>${escape(size)}${mark(r, 'Size')}</td><td>${escape(lh)}${mark(r, 'Line height')}</td><td>${sample}</td></tr>`
     })
     .join('\n')
   return `<h2>Typography</h2>\n<table><thead><tr><th>Role</th><th>Family</th><th>Weight</th><th>Size</th><th>Line height</th><th>Sample</th></tr></thead><tbody>${body}</tbody></table>`
@@ -141,11 +220,11 @@ function sectionSpacing(rows: Row[]): string {
   if (!rows.length) return ''
   const body = rows
     .map((r) => {
-      const value = r['Value'] || ''
+      const value = val(r, 'Value')
       const bar = value
         ? `<span class="bar" style="width:${escape(value)}"></span>`
         : '<span class="empty">unset</span>'
-      return `<tr><td>${escape(r['Step'] ?? '')}</td><td>${escape(r['Multiplier'] ?? '')}</td><td><code>${escape(value || 'unset')}</code></td><td>${bar}</td></tr>`
+      return `<tr><td>${cellText(r, 'Step')}</td><td>${cellText(r, 'Multiplier')}</td><td><code>${escape(value || 'unset')}</code>${mark(r, 'Value')}</td><td>${bar}</td></tr>`
     })
     .join('\n')
   return `<h2>Spacing</h2>\n<table><thead><tr><th>Step</th><th>Multiplier</th><th>Value</th><th>Sample</th></tr></thead><tbody>${body}</tbody></table>`
@@ -155,10 +234,10 @@ function sectionBorders(rows: Row[]): string {
   if (!rows.length) return ''
   const body = rows
     .map((r) => {
-      const radius = r['Radius'] || '0'
-      const width = r['Width'] || '1px'
+      const radius = val(r, 'Radius') || '0'
+      const width = val(r, 'Width') || '1px'
       const sample = `<span style="display:inline-block;width:2rem;height:1.5rem;background:#eee;border:${escape(width)} solid #888;border-radius:${escape(radius)};vertical-align:middle"></span>`
-      return `<tr><td>${escape(r['Role'] ?? '')}</td><td><code>${escape(radius)}</code></td><td><code>${escape(width)}</code></td><td>${escape(r['When used'] ?? '')}</td><td>${sample}</td></tr>`
+      return `<tr><td>${cellText(r, 'Role')}</td><td><code>${escape(radius)}</code>${mark(r, 'Radius')}</td><td><code>${escape(width)}</code>${mark(r, 'Width')}</td><td>${cellText(r, 'When used')}</td><td>${sample}</td></tr>`
     })
     .join('\n')
   return `<h2>Borders</h2>\n<table><thead><tr><th>Role</th><th>Radius</th><th>Width</th><th>When used</th><th>Sample</th></tr></thead><tbody>${body}</tbody></table>`

package/src/records/size.ts

@@ -0,0 +1,260 @@
+import { existsSync, type Stats } from 'node:fs'
+import { readdir, stat } from 'node:fs/promises'
+import { join } from 'node:path'
+import { BACKED_FOLDERS } from '@/records/backup'
+
+/**
+ * The folders a size reading covers, relative to `.claude/`.
+ *
+ * It is the backed set plus `.tmp`, which a backup skips because it is
+ * deletable without loss and a reading covers because deletable is not the same
+ * as empty: the routing handoffs and the memory archive both sit there and both
+ * accumulate. `.records.git` stays out because it is the backup history rather
+ * than a record, and `worktrees/` stays out because each entry there is a
+ * checkout of the enclosing repository with its own removal verb, and one of
+ * them outweighs every record folder combined.
+ */
+export const SIZED_FOLDERS = [...BACKED_FOLDERS, '.tmp'] as const
+
+/**
+ * The windows a reading reports, in days.
+ *
+ * There are two rather than one, because a single window cannot separate a
+ * folder that grows steadily from one that took a single batch. A folder whose
+ * 7-day count is most of its 30-day count moved in one pass, and one where the
+ * two are proportional is growing at a rate.
+ */
+export const GROWTH_WINDOWS = [7, 30] as const
+
+const DAY_MS = 24 * 60 * 60 * 1000
+
+export interface WindowCount {
+  readonly days: number
+  readonly files: number
+}
+
+export interface FolderSize {
+  /** Relative to `.claude/`, which is the name a reader opens. */
+  readonly folder: string
+  readonly present: boolean
+  readonly files: number
+  readonly bytes: number
+  /** `YYYY-MM-DD` of the least and most recently modified file, absent when the folder holds none. */
+  readonly oldest?: string
+  readonly newest?: string
+  readonly touched: readonly WindowCount[]
+}
+
+export interface SizeReport {
+  readonly ok: true
+  readonly root: string
+  readonly folders: readonly FolderSize[]
+  readonly files: number
+  readonly bytes: number
+}
+
+export const SIZE_REFUSALS = ['no-folder'] as const
+
+export type SizeRefusal = (typeof SIZE_REFUSALS)[number]
+
+export interface SizeRefused {
+  readonly ok: false
+  readonly reason: SizeRefusal
+  readonly message: string
+}
+
+export type SizeOutcome = SizeReport | SizeRefused
+
+interface Walked {
+  files: number
+  bytes: number
+  oldest?: number
+  newest?: number
+  touched: number[]
+}
+
+/**
+ * Renders the calendar date the writer saw, which is the local one.
+ *
+ * `toISOString` renders in UTC, so a file written after 17:00 at `-0700` dates
+ * to the following day and a reader comparing the column against their own
+ * memory of writing it finds the two disagree. The reading is per-machine
+ * already, since these folders are gitignored and hold whatever that disk holds,
+ * so a local date is the answer consistent with the rest of the report.
+ */
+function day(ms: number): string {
+  const at = new Date(ms)
+  const month = String(at.getMonth() + 1).padStart(2, '0')
+  const date = String(at.getDate()).padStart(2, '0')
+  return `${at.getFullYear()}-${month}-${date}`
+}
+
+/**
+ * Adds one file to the running totals.
+ *
+ * The window counts read `mtime`, so what they report is a file written inside
+ * the window rather than one created there. An entry edited long after it
+ * landed counts as recent, which overstates growth and never understates it.
+ * That is the safe direction for a number whose whole job is to be noticed, and
+ * these folders are append-mostly, so the two readings agree on nearly every
+ * file.
+ *
+ * The one reading that is wrong rather than early is a machine restored by
+ * `aitk records pull`, which resets the work tree hard and re-dates every file
+ * it writes. A window taken there counts the restore. Nothing separates the two
+ * from the filesystem, since a restored file is new by every stamp it carries,
+ * so the caveat is published rather than corrected.
+ */
+function absorb(into: Walked, bytes: number, mtime: number, now: number): void {
+  into.files += 1
+  into.bytes += bytes
+  into.oldest = into.oldest === undefined ? mtime : Math.min(into.oldest, mtime)
+  into.newest = into.newest === undefined ? mtime : Math.max(into.newest, mtime)
+
+  GROWTH_WINDOWS.forEach((days, index) => {
+    if (now - mtime <= days * DAY_MS) into.touched[index] += 1
+  })
+}
+
+/**
+ * Reads one entry, or undefined when it left between the listing and the read.
+ *
+ * These folders are written by whatever sessions are running, so a path listed
+ * a moment ago can be gone by the time it is read. A vanished file is a file
+ * the folder no longer holds, which is the answer the count wants, and letting
+ * `ENOENT` out would fail the whole reading over one deleted scratch file.
+ * Every other error propagates, since a permission or IO failure would
+ * undercount with nothing said.
+ */
+async function readSize(path: string): Promise<Stats | undefined> {
+  try {
+    return await stat(path)
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return undefined
+    throw error
+  }
+}
+
+/**
+ * Walks one folder, counting files and never following a symlink.
+ *
+ * `isFile()` answers false for a link, so a folder holding one reports it
+ * nowhere rather than counting whatever sits behind it. The corpus symlinks
+ * point out of `.claude/` and into the authoring roots, where a second reading
+ * of the same bytes would be the wrong answer twice over.
+ */
+async function walk(dir: string, into: Walked, now: number): Promise<void> {
+  const entries = await readdir(dir, { withFileTypes: true }).catch(
+    (error: NodeJS.ErrnoException) => {
+      if (error.code === 'ENOENT') return []
+      throw error
+    },
+  )
+
+  for (const entry of entries) {
+    const path = join(dir, entry.name)
+
+    if (entry.isDirectory()) {
+      await walk(path, into, now)
+      continue
+    }
+    if (!entry.isFile()) continue
+
+    const info = await readSize(path)
+    if (info) absorb(into, info.size, info.mtimeMs, now)
+  }
+}
+
+async function measure(
+  root: string,
+  folder: string,
+  now: number,
+): Promise<FolderSize> {
+  const path = join(root, '.claude', folder)
+  const empty = GROWTH_WINDOWS.map((days) => ({ days, files: 0 }))
+
+  if (!existsSync(path)) {
+    return { folder, present: false, files: 0, bytes: 0, touched: empty }
+  }
+
+  const walked: Walked = {
+    files: 0,
+    bytes: 0,
+    touched: GROWTH_WINDOWS.map(() => 0),
+  }
+  await walk(path, walked, now)
+
+  return {
+    folder,
+    present: true,
+    files: walked.files,
+    bytes: walked.bytes,
+    oldest: walked.oldest === undefined ? undefined : day(walked.oldest),
+    newest: walked.newest === undefined ? undefined : day(walked.newest),
+    touched: GROWTH_WINDOWS.map((days, index) => ({
+      days,
+      files: walked.touched[index],
+    })),
+  }
+}
+
+/**
+ * Reports what each record folder holds and how much of it is recent.
+ *
+ * Every folder is reported whether or not it exists, since a caller reading the
+ * record wants a stable set of keys, and a folder absent from the output is
+ * indistinguishable from one the reading skipped.
+ *
+ * `now` is a parameter rather than a call inside the walk so a test can pin the
+ * windows against fixture timestamps.
+ */
+export async function sizeRecords(
+  root: string,
+  now: number = Date.now(),
+): Promise<SizeOutcome> {
+  if (!existsSync(join(root, '.claude'))) {
+    return {
+      ok: false,
+      reason: 'no-folder',
+      message: `No .claude directory at ${root}, so there are no record folders to read.`,
+    }
+  }
+
+  // Each folder is walked independently, and the report is ordered by the
+  // caller rather than by arrival, so `Promise.all` keeps the input order while
+  // the ten walks overlap.
+  const folders = await Promise.all(
+    SIZED_FOLDERS.map((folder) => measure(root, folder, now)),
+  )
+
+  return {
+    ok: true,
+    root,
+    folders,
+    files: folders.reduce((total, entry) => total + entry.files, 0),
+    bytes: folders.reduce((total, entry) => total + entry.bytes, 0),
+  }
+}
+
+const UNITS = ['B', 'K', 'M', 'G'] as const
+
+/**
+ * Renders a byte count at three significant figures or fewer.
+ *
+ * The reading is a prompt to go and look rather than an accounting figure, so
+ * an exact byte count buys nothing and costs a reader the comparison between
+ * two rows.
+ */
+export function formatBytes(bytes: number): string {
+  let value = bytes
+  let unit = 0
+
+  while (value >= 1024 && unit < UNITS.length - 1) {
+    value /= 1024
+    unit += 1
+  }
+
+  const rendered =
+    unit === 0 || value >= 10 ? Math.round(value) : value.toFixed(1)
+  return `${rendered}${UNITS[unit]}`
+}

package/src/sync/engine.ts

@@ -22,12 +22,10 @@ import {
   logStep,
   logWarn,
   outro,
+  palette,
   select,
 } from '@/ui'
 
-const GREEN = '\x1b[0;32m'
-const NC = '\x1b[0m'
-
 /**
  * One installed file in three path flavours: absolute, relative to the
  * domain's installed root, and relative to the target. Adapters match on
@@ -304,6 +302,7 @@ export async function runDomainSync(
   }
 
   const plan = planSync(adapter, resolved)
+  const { GREEN, GREY, NC } = palette(process.stderr)
 
   if (
     !existsSync(adapter.installedRoot(resolved)) &&
@@ -358,7 +357,7 @@ export async function runDomainSync(
 
   outro()
   process.stderr.write(
-    `${GREEN}✓ Sync complete${NC} \x1b[0;90m(${count} ${adapter.unit})${NC}\n`,
+    `${GREEN}✓ Sync complete${NC} ${GREY}(${count} ${adapter.unit})${NC}\n`,
   )
   return 0
 }

package/src/sync/workflow.ts

@@ -19,13 +19,11 @@ import {
   logStep,
   logWarn,
   outro,
+  palette,
   pipeOutput,
   select,
 } from '@/ui'
 
-const GREEN = '\x1b[0;32m'
-const NC = '\x1b[0m'
-
 const PROTECTED_BRANCHES: readonly string[] = ['main', 'master']
 
 export type WorkflowChoice = 'pr' | 'commit' | 'cancel'
@@ -195,6 +193,7 @@ function promptChoice(canOpenPullRequest: boolean): Promise<WorkflowChoice> {
 }
 
 function succeed(message: string): number {
+  const { GREEN, NC } = palette(process.stderr)
   outro()
   process.stderr.write(`\n${GREEN}✓ ${message}${NC}\n`)
   return 0