@cleocode/core 2026.3.58 → 2026.3.60

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/scaffold.ts

@@ -14,6 +14,7 @@ import { execFile } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
 import { existsSync, constants as fsConstants, readFileSync, statSync } from 'node:fs';
 import { access, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { homedir as getHomedir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { promisify } from 'node:util';
@@ -1278,12 +1279,33 @@ export function checkGlobalTemplates(): CheckResult {
     };
   }
 
+  // Check version sync between XDG and legacy paths
+  const xdgContent = readFileSync(injectionPath, 'utf-8');
+  const xdgVersion = xdgContent.match(/^Version:\s*(.+)$/m)?.[1]?.trim();
+  const home = getHomedir();
+  const legacyPath = join(home, '.cleo', 'templates', 'CLEO-INJECTION.md');
+
+  if (existsSync(legacyPath)) {
+    const legacyContent = readFileSync(legacyPath, 'utf-8');
+    const legacyVersion = legacyContent.match(/^Version:\s*(.+)$/m)?.[1]?.trim();
+    if (legacyVersion && xdgVersion && legacyVersion !== xdgVersion) {
+      return {
+        id: 'global_templates',
+        category: 'global',
+        status: 'warning',
+        message: `Legacy template version (${legacyVersion}) out of sync with XDG (${xdgVersion})`,
+        details: { path: injectionPath, exists: true, xdgVersion, legacyVersion, legacyPath },
+        fix: 'npm install -g @cleocode/cleo (reinstall syncs both paths)',
+      };
+    }
+  }
+
   return {
     id: 'global_templates',
     category: 'global',
     status: 'passed',
-    message: 'Global injection template present',
-    details: { path: injectionPath, exists: true },
+    message: `Global injection template present (v${xdgVersion ?? 'unknown'})`,
+    details: { path: injectionPath, exists: true, version: xdgVersion },
     fix: null,
   };
 }

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;

package/src/tasks/__tests__/update.test.ts

@@ -231,11 +231,11 @@ describe('updateTask', () => {
       await writeFile(
         join(env.cleoDir, 'config.json'),
         JSON.stringify({
-        enforcement: { session: { requiredForMutate: false } },
-        lifecycle: { mode: 'off' },
-        verification: { enabled: false },
-        hierarchy: { maxDepth: 3, maxSiblings: 20 },
-      }),
+          enforcement: { session: { requiredForMutate: false } },
+          lifecycle: { mode: 'off' },
+          verification: { enabled: false },
+          hierarchy: { maxDepth: 3, maxSiblings: 20 },
+        }),
       );
 
       const result = await updateTask({ taskId: 'T002', parentId: 'T001' }, env.tempDir, accessor);
@@ -266,11 +266,11 @@ describe('updateTask', () => {
       await writeFile(
         join(env.cleoDir, 'config.json'),
         JSON.stringify({
-        enforcement: { session: { requiredForMutate: false } },
-        lifecycle: { mode: 'off' },
-        verification: { enabled: false },
-        hierarchy: { maxDepth: 3, maxSiblings: 20 },
-      }),
+          enforcement: { session: { requiredForMutate: false } },
+          lifecycle: { mode: 'off' },
+          verification: { enabled: false },
+          hierarchy: { maxDepth: 3, maxSiblings: 20 },
+        }),
       );
 
       const result = await updateTask({ taskId: 'T002', parentId: null }, env.tempDir, accessor);
@@ -301,11 +301,11 @@ describe('updateTask', () => {
       await writeFile(
         join(env.cleoDir, 'config.json'),
         JSON.stringify({
-        enforcement: { session: { requiredForMutate: false } },
-        lifecycle: { mode: 'off' },
-        verification: { enabled: false },
-        hierarchy: { maxDepth: 3, maxSiblings: 20 },
-      }),
+          enforcement: { session: { requiredForMutate: false } },
+          lifecycle: { mode: 'off' },
+          verification: { enabled: false },
+          hierarchy: { maxDepth: 3, maxSiblings: 20 },
+        }),
       );
 
       const result = await updateTask({ taskId: 'T002', parentId: '' }, env.tempDir, accessor);
@@ -336,11 +336,11 @@ describe('updateTask', () => {
       await writeFile(
         join(env.cleoDir, 'config.json'),
         JSON.stringify({
-        enforcement: { session: { requiredForMutate: false } },
-        lifecycle: { mode: 'off' },
-        verification: { enabled: false },
-        hierarchy: { maxDepth: 3, maxSiblings: 20 },
-      }),
+          enforcement: { session: { requiredForMutate: false } },
+          lifecycle: { mode: 'off' },
+          verification: { enabled: false },
+          hierarchy: { maxDepth: 3, maxSiblings: 20 },
+        }),
       );
 
       await expect(
@@ -370,11 +370,11 @@ describe('updateTask', () => {
       await writeFile(
         join(env.cleoDir, 'config.json'),
         JSON.stringify({
-        enforcement: { session: { requiredForMutate: false } },
-        lifecycle: { mode: 'off' },
-        verification: { enabled: false },
-        hierarchy: { maxDepth: 3, maxSiblings: 20 },
-      }),
+          enforcement: { session: { requiredForMutate: false } },
+          lifecycle: { mode: 'off' },
+          verification: { enabled: false },
+          hierarchy: { maxDepth: 3, maxSiblings: 20 },
+        }),
       );
 
       const result = await updateTask(

package/src/tasks/complete.ts

@@ -76,15 +76,18 @@ async function loadCompletionEnforcement(cwd?: string): Promise<CompletionEnforc
   const acceptanceMode =
     modeRaw === 'off' || modeRaw === 'warn' || modeRaw === 'block'
       ? modeRaw
-      : isTest ? 'off' : 'block';
+      : isTest
+        ? 'off'
+        : 'block';
 
   const acceptanceRequiredForPriorities = Array.isArray(prioritiesRaw)
     ? prioritiesRaw.filter((p): p is string => typeof p === 'string')
-    : isTest ? [] : ['critical', 'high', 'medium', 'low'];
+    : isTest
+      ? []
+      : ['critical', 'high', 'medium', 'low'];
 
-  const verificationEnabled = verificationEnabledRaw === true ? true
-    : verificationEnabledRaw === false ? false
-    : !isTest;
+  const verificationEnabled =
+    verificationEnabledRaw === true ? true : verificationEnabledRaw === false ? false : !isTest;
 
   const verificationRequiredGates = Array.isArray(verificationRequiredGatesRaw)
     ? verificationRequiredGatesRaw
@@ -104,7 +107,9 @@ async function loadCompletionEnforcement(cwd?: string): Promise<CompletionEnforc
     lifecycleModeRaw === 'none' ||
     lifecycleModeRaw === 'off'
       ? lifecycleModeRaw
-      : isTest ? 'off' : 'strict';
+      : isTest
+        ? 'off'
+        : 'strict';
 
   return {
     acceptanceMode,

package/src/tasks/enforcement.ts

@@ -41,9 +41,12 @@ export async function createAcceptanceEnforcement(cwd?: string): Promise<Accepta
   const minCriteriaRaw = await getRawConfigValue('enforcement.acceptance.minimumCriteria', cwd);
   const defaultPriorityRaw = await getRawConfigValue('defaults.priority', cwd);
 
-  const mode = modeRaw === 'off' || modeRaw === 'warn' || modeRaw === 'block'
-    ? modeRaw
-    : isTest ? 'off' : 'block';
+  const mode =
+    modeRaw === 'off' || modeRaw === 'warn' || modeRaw === 'block'
+      ? modeRaw
+      : isTest
+        ? 'off'
+        : 'block';
 
   const requiredForPriorities = Array.isArray(prioritiesRaw)
     ? prioritiesRaw.filter((p): p is string => typeof p === 'string')