@cleocode/core 2026.3.58 → 2026.3.59

package/src/lib/retry.ts

@@ -0,0 +1,224 @@
+/**
+ * General-purpose retry utility with exponential backoff.
+ *
+ * This module provides a shared, dependency-free retry primitive for use
+ * anywhere in the CLEO core. Unlike the agent-specific retry in
+ * `agents/retry.ts`, this utility has no database coupling and is safe to
+ * import from any layer.
+ *
+ * Default schedule (3 attempts, task T040 spec):
+ * - Attempt 1: immediate (0 ms delay before retry)
+ * - Attempt 2: 2 000 ms delay before retry
+ * - Attempt 3: 4 000 ms delay before retry
+ * - After attempt 3: throw last error
+ *
+ * @module lib/retry
+ */
+
+// ============================================================================
+// Types
+// ============================================================================
+
+/**
+ * A predicate or pattern used to decide whether an error is retryable.
+ *
+ * - `RegExp` — matched against `error.message` (or `String(error)`)
+ * - `(error: unknown) => boolean` — arbitrary predicate function
+ */
+export type RetryablePredicate = RegExp | ((error: unknown) => boolean);
+
+/**
+ * Options that control retry behavior for {@link withRetry}.
+ */
+export interface RetryOptions {
+  /**
+   * Maximum total number of attempts (initial + retries).
+   *
+   * @default 3
+   */
+  maxAttempts?: number;
+
+  /**
+   * Delay before the second attempt in milliseconds.
+   * Each subsequent delay is `baseDelayMs * 2^(attempt - 1)`.
+   *
+   * @default 2000
+   */
+  baseDelayMs?: number;
+
+  /**
+   * Upper bound on computed delay in milliseconds.
+   * Prevents unbounded growth with many retries.
+   *
+   * @default 30000
+   */
+  maxDelayMs?: number;
+
+  /**
+   * Explicit list of patterns or predicates that identify retryable errors.
+   *
+   * When provided, ONLY errors matching at least one entry are retried.
+   * Errors that match none of the entries cause immediate failure.
+   *
+   * When omitted, all errors are treated as retryable (up to `maxAttempts`).
+   */
+  retryableErrors?: ReadonlyArray<RetryablePredicate>;
+}
+
+/**
+ * Metadata attached to errors thrown after all retry attempts are exhausted.
+ *
+ * The last error from the final attempt is augmented with these fields so
+ * callers can distinguish a retry-exhausted failure from a first-attempt one.
+ */
+export interface RetryContext {
+  /** Total number of attempts made (always equal to `maxAttempts`). */
+  attempts: number;
+  /** Cumulative delay applied across all retry waits in milliseconds. */
+  totalDelayMs: number;
+}
+
+// ============================================================================
+// Public API
+// ============================================================================
+
+/**
+ * Execute an async function with automatic retry and exponential backoff.
+ *
+ * @remarks
+ * The function is called up to `maxAttempts` times. After the first failure,
+ * the utility waits `baseDelayMs` milliseconds, then retries. Each subsequent
+ * wait doubles: `baseDelayMs * 2^(attempt - 1)`, capped at `maxDelayMs`.
+ *
+ * If `retryableErrors` is supplied, only errors matching at least one entry
+ * are retried; other errors cause immediate re-throw.
+ *
+ * On final failure the original error is re-thrown. Use {@link RetryContext}
+ * fields (attached to the error) to inspect retry metadata.
+ *
+ * @example
+ * ```ts
+ * // Basic usage — 3 attempts with 0 ms / 2 000 ms / 4 000 ms delays
+ * const data = await withRetry(() => fetchFromApi());
+ *
+ * // Custom retry window — only on network errors
+ * const result = await withRetry(
+ *   () => db.query(sql),
+ *   {
+ *     maxAttempts: 5,
+ *     baseDelayMs: 500,
+ *     retryableErrors: [/SQLITE_BUSY/, /database is locked/i],
+ *   },
+ * );
+ * ```
+ *
+ * @typeParam T - The resolved type of the async function
+ * @param fn - Async factory that is called on each attempt.
+ * @param options - Optional retry configuration.
+ * @returns Resolved value of `fn` on success.
+ * @throws The last error thrown by `fn`, augmented with {@link RetryContext}
+ *   fields (`attempts`, `totalDelayMs`).
+ */
+export async function withRetry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T> {
+  const maxAttempts = options?.maxAttempts ?? 3;
+  const baseDelayMs = options?.baseDelayMs ?? 2_000;
+  const maxDelayMs = options?.maxDelayMs ?? 30_000;
+  const retryableErrors = options?.retryableErrors;
+
+  let lastError: unknown;
+  let totalDelayMs = 0;
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+
+      const isLastAttempt = attempt === maxAttempts;
+      if (isLastAttempt) break;
+
+      // If a filter list is provided, only retry matching errors.
+      if (retryableErrors !== undefined && !isRetryable(err, retryableErrors)) break;
+
+      const delay = computeDelay(attempt, baseDelayMs, maxDelayMs);
+      totalDelayMs += delay;
+      await sleep(delay);
+    }
+  }
+
+  // Augment last error with retry context before re-throwing.
+  const context: RetryContext = { attempts: maxAttempts, totalDelayMs };
+  augmentError(lastError, context);
+  throw lastError;
+}
+
+// ============================================================================
+// Delay helpers (exported for unit testing)
+// ============================================================================
+
+/**
+ * Compute the wait time before the next attempt.
+ *
+ * @remarks
+ * Formula: `min(baseDelayMs * 2^(attempt - 1), maxDelayMs)`.
+ * On the first retry (`attempt === 1`) the delay is `baseDelayMs * 1 = baseDelayMs`.
+ *
+ * @example
+ * ```ts
+ * computeDelay(1, 2000, 30000); // 2000
+ * computeDelay(2, 2000, 30000); // 4000
+ * computeDelay(3, 2000, 30000); // 8000
+ * ```
+ *
+ * @param attempt - The 1-based attempt number that just failed.
+ * @param baseDelayMs - Base delay in milliseconds.
+ * @param maxDelayMs - Maximum allowed delay in milliseconds.
+ * @returns Delay in milliseconds before the next attempt.
+ */
+export function computeDelay(attempt: number, baseDelayMs: number, maxDelayMs: number): number {
+  const exponential = baseDelayMs * 2 ** (attempt - 1);
+  return Math.min(exponential, maxDelayMs);
+}
+
+// ============================================================================
+// Internal helpers
+// ============================================================================
+
+/**
+ * Test whether an error matches at least one retryable predicate.
+ *
+ * @param err - The caught error.
+ * @param predicates - List of `RegExp` or predicate functions.
+ * @returns `true` if the error is retryable.
+ */
+function isRetryable(err: unknown, predicates: ReadonlyArray<RetryablePredicate>): boolean {
+  const message = err instanceof Error ? err.message : String(err);
+  return predicates.some((predicate) => {
+    if (predicate instanceof RegExp) return predicate.test(message);
+    return predicate(err);
+  });
+}
+
+/**
+ * Attach `RetryContext` fields to an error value in-place when possible.
+ * Falls back gracefully for non-Error thrown values.
+ *
+ * @param err - The value to augment.
+ * @param context - Retry metadata to attach.
+ */
+function augmentError(err: unknown, context: RetryContext): void {
+  if (err instanceof Error) {
+    const mutableErr = err as Error & Partial<RetryContext>;
+    mutableErr.attempts = context.attempts;
+    mutableErr.totalDelayMs = context.totalDelayMs;
+  }
+}
+
+/**
+ * Promisified `setTimeout` for testability.
+ *
+ * @param ms - Duration in milliseconds.
+ */
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/src/nexus/sharing/index.ts

@@ -14,14 +14,42 @@ import { join, relative } from 'node:path';
 import type { SharingConfig } from '@cleocode/contracts';
 import { loadConfig } from '../../config.js';
 import { getCleoDirAbsolute, getProjectRoot } from '../../paths.js';
+import { cleoGitCommand, isCleoGitInitialized } from '../../store/git-checkpoint.js';
 
-/** Result of a sharing status check. */
+/**
+ * Result of a sharing status check.
+ *
+ * @remarks
+ * Provides a complete view of which `.cleo/` files are tracked vs ignored under
+ * the current sharing config, plus git sync state for Nexus multi-project visibility.
+ * The `hasGit`, `remotes`, `pendingChanges`, and `lastSync` fields are populated
+ * only when a `.cleo/.git` repo exists; otherwise they carry safe defaults.
+ *
+ * @example
+ * ```typescript
+ * const status = await getSharingStatus();
+ * if (status.hasGit && status.pendingChanges) {
+ *   console.log('Uncommitted changes in .cleo/ — run: cleo checkpoint');
+ * }
+ * ```
+ */
 export interface SharingStatus {
   mode: string;
   allowlist: string[];
   denylist: string[];
   tracked: string[];
   ignored: string[];
+  /** Whether the `.cleo/.git` isolated repo exists and is initialized. */
+  hasGit: boolean;
+  /** Git remote names configured in `.cleo/.git` (e.g. `['origin']`). */
+  remotes: string[];
+  /** Whether the `.cleo/.git` working tree has uncommitted changes. */
+  pendingChanges: boolean;
+  /**
+   * ISO 8601 timestamp of the last push or pull to/from a remote, or `null`
+   * if no remote sync has ever occurred.
+   */
+  lastSync: string | null;
 }
 
 /** Markers for the managed section in .gitignore. */
@@ -104,8 +132,102 @@ function collectCleoFiles(cleoDir: string): string[] {
 }
 
 /**
- * Get the sharing status: which .cleo/ files are tracked vs ignored.
+ * Retrieve the names of git remotes configured in the `.cleo/.git` repo.
+ *
+ * @remarks
+ * Returns an empty array if the repo is not initialized or has no remotes.
+ * Errors are suppressed — callers should treat an empty array as "no remotes known".
+ *
+ * @example
+ * ```typescript
+ * const remotes = await getCleoGitRemotes('/path/to/project/.cleo');
+ * // ['origin']
+ * ```
+ */
+async function getCleoGitRemotes(cleoDir: string): Promise<string[]> {
+  const result = await cleoGitCommand(['remote'], cleoDir);
+  if (!result.success || !result.stdout) return [];
+  return result.stdout
+    .split('\n')
+    .map((r) => r.trim())
+    .filter(Boolean);
+}
+
+/**
+ * Determine whether the `.cleo/.git` working tree has any uncommitted changes.
+ *
+ * @remarks
+ * Uses `git status --porcelain`. A non-empty output means pending changes exist.
+ * Returns `false` if the repo is not initialized or the command fails.
+ *
+ * @example
+ * ```typescript
+ * const dirty = await hasCleoGitPendingChanges('/path/to/project/.cleo');
+ * // true if any files are modified/untracked
+ * ```
+ */
+async function hasCleoGitPendingChanges(cleoDir: string): Promise<boolean> {
+  const result = await cleoGitCommand(['status', '--porcelain'], cleoDir);
+  if (!result.success) return false;
+  return result.stdout.length > 0;
+}
+
+/**
+ * Read the ISO 8601 timestamp of the last push or pull recorded in the reflog.
+ *
+ * @remarks
+ * Scans the git reflog for `fetch` or `push` entries and returns the committer
+ * date of the most recent one. Returns `null` if no push/pull has occurred or
+ * if the repo has no commits yet.
+ *
+ * @example
+ * ```typescript
+ * const lastSync = await getLastSyncTimestamp('/path/to/project/.cleo');
+ * // '2026-03-21T18:00:00.000Z' or null
+ * ```
+ */
+async function getLastSyncTimestamp(cleoDir: string): Promise<string | null> {
+  // The reflog format: `%gd %gs %ci` — reflog selector, subject, committer ISO date
+  const result = await cleoGitCommand(['reflog', '--format=%gs %ci', 'HEAD'], cleoDir);
+  if (!result.success || !result.stdout) return null;
+
+  for (const line of result.stdout.split('\n')) {
+    const trimmed = line.trim();
+    // Match lines describing a fetch or push action (e.g. "fetch origin: fast-forward")
+    if (/^(fetch|push|pull)\b/i.test(trimmed)) {
+      // The date is everything after the action description — last ISO-like token
+      const isoMatch = trimmed.match(/(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} [+-]\d{4})$/);
+      if (isoMatch?.[1]) {
+        return new Date(isoMatch[1]).toISOString();
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Get the sharing status: which .cleo/ files are tracked vs ignored,
+ * plus git sync state for Nexus multi-project visibility.
+ *
+ * @remarks
+ * Populates `hasGit`, `remotes`, `pendingChanges`, and `lastSync` by inspecting
+ * the `.cleo/.git` isolated repo when it exists. All git operations are
+ * non-fatal — if the repo is absent or a command fails, the fields carry safe
+ * defaults (`false`, `[]`, `null`).
+ *
+ * @example
+ * ```typescript
+ * const status = await getSharingStatus('/path/to/project');
+ * console.log(status.mode);           // 'project'
+ * console.log(status.hasGit);         // true
+ * console.log(status.remotes);        // ['origin']
+ * console.log(status.pendingChanges); // false
+ * console.log(status.lastSync);       // '2026-03-21T18:00:00.000Z'
+ * ```
+ *
  * @task T4883
+ * @task T110
  */
 export async function getSharingStatus(cwd?: string): Promise<SharingStatus> {
   const config = await loadConfig(cwd);
@@ -126,12 +248,30 @@ export async function getSharingStatus(cwd?: string): Promise<SharingStatus> {
     }
   }
 
+  // Populate git sync fields
+  const hasGit = isCleoGitInitialized(cleoDir);
+  let remotes: string[] = [];
+  let pendingChanges = false;
+  let lastSync: string | null = null;
+
+  if (hasGit) {
+    [remotes, pendingChanges, lastSync] = await Promise.all([
+      getCleoGitRemotes(cleoDir),
+      hasCleoGitPendingChanges(cleoDir),
+      getLastSyncTimestamp(cleoDir),
+    ]);
+  }
+
   return {
     mode: sharing.mode,
     allowlist: sharing.commitAllowlist,
     denylist: sharing.denylist,
     tracked,
     ignored,
+    hasGit,
+    remotes,
+    pendingChanges,
+    lastSync,
   };
 }
 

package/src/stats/workflow-telemetry.ts

@@ -229,6 +229,21 @@ function gradeFromScore(score: number): string {
  *   WF-003: Completed tasks SHOULD have verification gates set (T061)
  *   WF-004: Tasks with verification SHOULD have all 3 gates set
  *   WF-005: Tasks MUST have session binding on creation (non-epic)
+ *
+ * @remarks
+ * Derives all metrics from existing audit_log and tasks tables — no new
+ * tracking infrastructure is required.
+ *
+ * @param opts - Report options
+ * @param opts.since - ISO 8601 date string to filter metrics from
+ * @param opts.cwd - Working directory for database resolution
+ * @returns Compliance report with per-rule pass/fail counts and overall rate
+ *
+ * @example
+ * ```ts
+ * const report = await getWorkflowComplianceReport({ cwd: '/my/project' });
+ * console.log(report.overall.passRate); // e.g. 0.85
+ * ```
  */
 export async function getWorkflowComplianceReport(opts: {
   since?: string;

package/src/store/__tests__/session-store.test.ts

@@ -8,7 +8,7 @@
  * @epic T4638
  */
 
-import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import type { Session } from '@cleocode/contracts';
@@ -404,9 +404,27 @@ describe('SQLite session-store', () => {
       const db = await getDb();
       db.insert(tasksTable)
         .values([
-          { id: 'T001', title: 'Task T001', status: 'pending', priority: 'medium', createdAt: new Date().toISOString() },
-          { id: 'T002', title: 'Task T002', status: 'pending', priority: 'medium', createdAt: new Date().toISOString() },
-          { id: 'T003', title: 'Task T003', status: 'pending', priority: 'medium', createdAt: new Date().toISOString() },
+          {
+            id: 'T001',
+            title: 'Task T001',
+            status: 'pending',
+            priority: 'medium',
+            createdAt: new Date().toISOString(),
+          },
+          {
+            id: 'T002',
+            title: 'Task T002',
+            status: 'pending',
+            priority: 'medium',
+            createdAt: new Date().toISOString(),
+          },
+          {
+            id: 'T003',
+            title: 'Task T003',
+            status: 'pending',
+            priority: 'medium',
+            createdAt: new Date().toISOString(),
+          },
         ])
         .run();
       await createSession(makeSession({ id: 'sess-001' }));
@@ -430,9 +448,27 @@ describe('SQLite session-store', () => {
       const db = await getDb();
       db.insert(tasksTable)
         .values([
-          { id: 'T001', title: 'Task T001', status: 'pending', priority: 'medium', createdAt: new Date().toISOString() },
-          { id: 'T002', title: 'Task T002', status: 'pending', priority: 'medium', createdAt: new Date().toISOString() },
-          { id: 'T003', title: 'Task T003', status: 'pending', priority: 'medium', createdAt: new Date().toISOString() },
+          {
+            id: 'T001',
+            title: 'Task T001',
+            status: 'pending',
+            priority: 'medium',
+            createdAt: new Date().toISOString(),
+          },
+          {
+            id: 'T002',
+            title: 'Task T002',
+            status: 'pending',
+            priority: 'medium',
+            createdAt: new Date().toISOString(),
+          },
+          {
+            id: 'T003',
+            title: 'Task T003',
+            status: 'pending',
+            priority: 'medium',
+            createdAt: new Date().toISOString(),
+          },
         ])
         .run();
       await createSession(makeSession({ id: 'sess-001' }));

package/src/store/__tests__/task-store.test.ts

@@ -8,7 +8,7 @@
  * @epic T4638
  */
 
-import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import type { Task } from '@cleocode/contracts';

package/src/store/__tests__/test-db-helper.ts

@@ -8,7 +8,7 @@
  * @task T5244
  */
 
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import type { Task } from '@cleocode/contracts';
@@ -57,7 +57,9 @@ export async function createTestDb(): Promise<TestDbEnv> {
   const { readdirSync } = await import('node:fs');
   const contents = readdirSync(cleoDir);
   if (!contents.includes('config.json')) {
-    throw new Error(`createTestDb: config.json not found in ${cleoDir} after write (contents: ${JSON.stringify(contents)})`);
+    throw new Error(
+      `createTestDb: config.json not found in ${cleoDir} after write (contents: ${JSON.stringify(contents)})`,
+    );
   }
 
   const accessor = await createSqliteDataAccessor(tempDir);
@@ -66,7 +68,9 @@ export async function createTestDb(): Promise<TestDbEnv> {
   const { readdirSync: readdirSync2 } = await import('node:fs');
   const contentsAfterDb = readdirSync2(cleoDir);
   if (!contentsAfterDb.includes('config.json')) {
-    throw new Error(`createTestDb: config.json DELETED by createSqliteDataAccessor! ${cleoDir}: ${JSON.stringify(contentsAfterDb)}`);
+    throw new Error(
+      `createTestDb: config.json DELETED by createSqliteDataAccessor! ${cleoDir}: ${JSON.stringify(contentsAfterDb)}`,
+    );
   }
 
   return {

package/src/store/cross-db-cleanup.ts

@@ -26,8 +26,17 @@ import { getBrainDb } from './brain-sqlite.js';
  * This is a best-effort cleanup — brain.db is a cognitive store and minor
  * staleness is preferable to failing task deletions due to brain.db errors.
  *
+ * @remarks
+ * Best-effort: failures in brain.db cleanup do not propagate to the caller.
+ * A background reconciliation pass can clean up any residual stale refs.
+ *
  * @param taskId - The ID of the task being deleted from tasks.db
  * @param cwd - Optional working directory
+ *
+ * @example
+ * ```ts
+ * await cleanupBrainRefsOnTaskDelete('T042');
+ * ```
  */
 export async function cleanupBrainRefsOnTaskDelete(taskId: string, cwd?: string): Promise<void> {
   let brainDb: Awaited<ReturnType<typeof getBrainDb>> | null = null;
@@ -84,8 +93,16 @@ export async function cleanupBrainRefsOnTaskDelete(taskId: string, cwd?: string)
  * Handles:
  * - XFKB-004: Nullify brain_observations.source_session_id where it matches
  *
+ * @remarks
+ * Best-effort: failures do not propagate. brain.db may not be initialised.
+ *
  * @param sessionId - The ID of the session being deleted from tasks.db
  * @param cwd - Optional working directory
+ *
+ * @example
+ * ```ts
+ * await cleanupBrainRefsOnSessionDelete('ses_20260321_abc');
+ * ```
  */
 export async function cleanupBrainRefsOnSessionDelete(
   sessionId: string,
@@ -116,8 +133,17 @@ export async function cleanupBrainRefsOnSessionDelete(
  *
  * Provides write-guard for XFKB-001/002/003 on brain.db insert.
  *
+ * @remarks
+ * Used as a write-guard before inserting cross-DB references into brain.db.
+ *
  * @param taskId - Task ID to verify
  * @param tasksDb - The tasks.db drizzle instance
+ * @returns True if the task exists in tasks.db
+ *
+ * @example
+ * ```ts
+ * if (await taskExistsInTasksDb('T042', db)) { /* safe to reference *\/ }
+ * ```
  */
 export async function taskExistsInTasksDb(
   taskId: string,
@@ -139,8 +165,17 @@ export async function taskExistsInTasksDb(
  *
  * Provides write-guard for XFKB-004 on brain.db insert.
  *
+ * @remarks
+ * Used as a write-guard before inserting cross-DB references into brain.db.
+ *
  * @param sessionId - Session ID to verify
  * @param tasksDb - The tasks.db drizzle instance
+ * @returns True if the session exists in tasks.db
+ *
+ * @example
+ * ```ts
+ * if (await sessionExistsInTasksDb('ses_abc', db)) { /* safe to reference *\/ }
+ * ```
  */
 export async function sessionExistsInTasksDb(
   sessionId: string,

package/src/tasks/__tests__/epic-enforcement.test.ts

@@ -19,8 +19,13 @@ import { createTestDb, type TestDbEnv } from '../../store/__tests__/test-db-help
 
 // Epic enforcement tests NEED enforcement active — temporarily clear VITEST
 const savedVitest = process.env.VITEST;
-beforeAll(() => { delete process.env.VITEST; });
-afterAll(() => { if (savedVitest) process.env.VITEST = savedVitest; });
+beforeAll(() => {
+  delete process.env.VITEST;
+});
+afterAll(() => {
+  if (savedVitest) process.env.VITEST = savedVitest;
+});
+
 import type { DataAccessor } from '../../store/data-accessor.js';
 import { addTask } from '../add.js';
 import {
@@ -380,7 +385,7 @@ describe('validateEpicStageAdvancement (strict)', () => {
       id: 'T002',
       title: 'Child',
       description: 'Child',
-      status: 'in-progress',
+      status: 'active',
       priority: 'medium',
       type: 'task',
       parentId: 'T001',
@@ -416,7 +421,7 @@ describe('validateEpicStageAdvancement (strict)', () => {
       id: 'T002',
       title: 'Child',
       description: 'Child',
-      status: 'in-progress',
+      status: 'active',
       priority: 'medium',
       type: 'task',
       parentId: 'T001',

package/src/tasks/__tests__/minimal-test.test.ts

@@ -1,7 +1,7 @@
-import { mkdtempSync, mkdirSync, writeFileSync, existsSync, readdirSync } from 'node:fs';
+import { existsSync, mkdirSync, mkdtempSync, readdirSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { beforeEach, afterEach, describe, it, expect } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 
 describe('minimal repro', () => {
   let tempDir: string;