session-orchestrator 3.16.0

package/scripts/lib/owner-config/validate.mjs

@@ -0,0 +1,259 @@
+/**
+ * owner-config/validate.mjs — Pure schema validator for the owner persona config.
+ * Never throws — returns {ok, value, errors}. Unknown top-level sections dropped.
+ */
+
+import {
+  CURRENT_OWNER_SCHEMA_VERSION,
+  VALID_TONE_STYLES,
+  VALID_OUTPUT_LEVELS,
+  VALID_PREAMBLE_LEVELS,
+  VALID_COMMENTS_LEVELS,
+} from './constants.mjs';
+
+// Internal constants
+const NAME_MAX = 100;
+const TONALITY_MAX = 200;
+const TEST_COMMAND_MAX = 200;
+const EDITOR_MAX = 50;
+const HEX64_RE = /^[a-f0-9]{64}$/i;
+const ISO_639_1_RE = /^[a-z]{2}(-[A-Z]{2})?$/;
+
+// Private helpers
+const isPlainObject = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
+const isNonEmptyString = (v, max) => typeof v === 'string' && v.length > 0 && (max === undefined || v.length <= max);
+
+// Section validators (module-private)
+function _validateSchemaVersionSection(raw, errors) {
+  const schemaVersion = raw['schema-version'];
+  if (schemaVersion === undefined || schemaVersion === null) {
+    errors.push('schema-version is required');
+  } else if (schemaVersion !== CURRENT_OWNER_SCHEMA_VERSION) {
+    errors.push(
+      `schema-version must be ${CURRENT_OWNER_SCHEMA_VERSION}, got: ${JSON.stringify(schemaVersion)}`
+    );
+  }
+}
+
+function _validateOwnerSection(raw, errors, ownerOut) {
+  const owner = raw.owner;
+  if (!isPlainObject(owner)) {
+    errors.push('owner must be an object');
+    return;
+  }
+  if (!isNonEmptyString(owner.name, NAME_MAX)) {
+    errors.push(`owner.name must be a non-empty string (max ${NAME_MAX} chars)`);
+  } else {
+    ownerOut.name = owner.name;
+  }
+  if (owner['email-hash'] !== undefined && owner['email-hash'] !== null) {
+    if (typeof owner['email-hash'] !== 'string' || !HEX64_RE.test(owner['email-hash'])) {
+      errors.push('owner.email-hash must be a 64-char hex string (sha256) or null');
+    } else {
+      ownerOut['email-hash'] = owner['email-hash'].toLowerCase();
+    }
+  }
+  if (!isNonEmptyString(owner.language, 10) || !ISO_639_1_RE.test(owner.language)) {
+    errors.push('owner.language must be an ISO-639-1 code (e.g. "de", "en", "en-US")');
+  } else {
+    ownerOut.language = owner.language;
+  }
+}
+
+function _validateToneSection(raw, errors, toneOut) {
+  if (raw.tone === undefined) return;
+  if (!isPlainObject(raw.tone)) {
+    errors.push('tone must be an object');
+    return;
+  }
+  if (raw.tone.style !== undefined) {
+    if (!VALID_TONE_STYLES.includes(raw.tone.style)) {
+      errors.push(`tone.style must be one of ${VALID_TONE_STYLES.join('|')}, got: ${raw.tone.style}`);
+    } else {
+      toneOut.style = raw.tone.style;
+    }
+  }
+  if (raw.tone.tonality !== undefined && raw.tone.tonality !== null) {
+    if (typeof raw.tone.tonality !== 'string' || raw.tone.tonality.length > TONALITY_MAX) {
+      errors.push(`tone.tonality must be a string (max ${TONALITY_MAX} chars) or null`);
+    } else {
+      toneOut.tonality = raw.tone.tonality;
+    }
+  }
+}
+
+function _validateEfficiencySection(raw, errors, efficiencyOut) {
+  if (raw.efficiency === undefined) return;
+  if (!isPlainObject(raw.efficiency)) {
+    errors.push('efficiency must be an object');
+    return;
+  }
+  if (raw.efficiency['output-level'] !== undefined) {
+    if (!VALID_OUTPUT_LEVELS.includes(raw.efficiency['output-level'])) {
+      errors.push(
+        `efficiency.output-level must be one of ${VALID_OUTPUT_LEVELS.join('|')}, got: ${raw.efficiency['output-level']}`
+      );
+    } else {
+      efficiencyOut['output-level'] = raw.efficiency['output-level'];
+    }
+  }
+  if (raw.efficiency.preamble !== undefined) {
+    if (!VALID_PREAMBLE_LEVELS.includes(raw.efficiency.preamble)) {
+      errors.push(
+        `efficiency.preamble must be one of ${VALID_PREAMBLE_LEVELS.join('|')}, got: ${raw.efficiency.preamble}`
+      );
+    } else {
+      efficiencyOut.preamble = raw.efficiency.preamble;
+    }
+  }
+  if (raw.efficiency['comments-in-code'] !== undefined) {
+    if (!VALID_COMMENTS_LEVELS.includes(raw.efficiency['comments-in-code'])) {
+      errors.push(
+        `efficiency.comments-in-code must be one of ${VALID_COMMENTS_LEVELS.join('|')}, got: ${raw.efficiency['comments-in-code']}`
+      );
+    } else {
+      efficiencyOut['comments-in-code'] = raw.efficiency['comments-in-code'];
+    }
+  }
+}
+
+function _validateHardwareSharingSection(raw, errors, hwOut) {
+  if (raw['hardware-sharing'] === undefined) return;
+  const hw = raw['hardware-sharing'];
+  if (!isPlainObject(hw)) {
+    errors.push('hardware-sharing must be an object');
+    return;
+  }
+  if (hw.enabled !== undefined) {
+    if (typeof hw.enabled !== 'boolean') {
+      errors.push(`hardware-sharing.enabled must be boolean, got: ${typeof hw.enabled}`);
+    } else {
+      hwOut.enabled = hw.enabled;
+    }
+  }
+  if (hw['hash-salt'] !== undefined && hw['hash-salt'] !== null) {
+    if (typeof hw['hash-salt'] !== 'string' || !HEX64_RE.test(hw['hash-salt'])) {
+      errors.push('hardware-sharing.hash-salt must be a 64-char hex string (32 bytes) or null');
+    } else {
+      hwOut['hash-salt'] = hw['hash-salt'].toLowerCase();
+    }
+  }
+  // Privacy contract: enabled=true requires hash-salt to be set.
+  if (hwOut.enabled && hwOut['hash-salt'] === null) {
+    errors.push('hardware-sharing.enabled=true requires hash-salt to be set (D4 consent contract)');
+  }
+}
+
+function _validateDefaultsSection(raw, errors, defaultsOut) {
+  if (raw.defaults === undefined) return;
+  if (!isPlainObject(raw.defaults)) {
+    errors.push('defaults must be an object');
+    return;
+  }
+  const ptc = raw.defaults['preferred-test-command'];
+  if (ptc !== undefined && ptc !== null) {
+    if (typeof ptc !== 'string' || ptc.length > TEST_COMMAND_MAX) {
+      errors.push(`defaults.preferred-test-command must be a string (max ${TEST_COMMAND_MAX} chars) or null`);
+    } else {
+      defaultsOut['preferred-test-command'] = ptc;
+    }
+  }
+  const pe = raw.defaults['preferred-editor'];
+  if (pe !== undefined && pe !== null) {
+    if (typeof pe !== 'string' || pe.length > EDITOR_MAX) {
+      errors.push(`defaults.preferred-editor must be a string (max ${EDITOR_MAX} chars) or null`);
+    } else {
+      defaultsOut['preferred-editor'] = pe;
+    }
+  }
+}
+
+function _validateMetadataSection(raw, errors, metadataOut) {
+  if (raw.metadata === undefined) return;
+  if (!isPlainObject(raw.metadata)) {
+    errors.push('metadata must be an object');
+    return;
+  }
+  if (raw.metadata.created_at !== undefined && raw.metadata.created_at !== null) {
+    if (typeof raw.metadata.created_at !== 'string' || Number.isNaN(Date.parse(raw.metadata.created_at))) {
+      errors.push('metadata.created_at must be an ISO 8601 timestamp string or null');
+    } else {
+      metadataOut.created_at = raw.metadata.created_at;
+    }
+  }
+  if (raw.metadata.updated_at !== undefined && raw.metadata.updated_at !== null) {
+    if (typeof raw.metadata.updated_at !== 'string' || Number.isNaN(Date.parse(raw.metadata.updated_at))) {
+      errors.push('metadata.updated_at must be an ISO 8601 timestamp string or null');
+    } else {
+      metadataOut.updated_at = raw.metadata.updated_at;
+    }
+  }
+}
+
+// Public API
+
+/**
+ * Validate a raw owner config object. Defensive — never throws. Returns
+ * `{ok, value, errors}` where `value` is the normalized (default-filled)
+ * config when ok=true. When ok=false, `value` is null and `errors` is a
+ * non-empty array of human-readable messages.
+ *
+ * @param {unknown} raw
+ * @returns {{ok: boolean, value: object|null, errors: string[]}}
+ */
+export function validate(raw) {
+  const errors = [];
+
+  if (!isPlainObject(raw)) {
+    return { ok: false, value: null, errors: ['owner config must be an object'] };
+  }
+
+  // schema-version (required, must be 1)
+  _validateSchemaVersionSection(raw, errors);
+
+  // owner (required)
+  const ownerOut = { name: '', 'email-hash': null, language: '' };
+  _validateOwnerSection(raw, errors, ownerOut);
+
+  // tone (optional; defaults applied)
+  const toneOut = { style: 'neutral', tonality: null };
+  _validateToneSection(raw, errors, toneOut);
+
+  // efficiency (optional; defaults applied)
+  const efficiencyOut = {
+    'output-level': 'full',
+    preamble: 'minimal',
+    'comments-in-code': 'minimal',
+  };
+  _validateEfficiencySection(raw, errors, efficiencyOut);
+
+  // hardware-sharing (optional; defaults applied)
+  const hwOut = { enabled: false, 'hash-salt': null };
+  _validateHardwareSharingSection(raw, errors, hwOut);
+
+  // defaults (optional)
+  const defaultsOut = { 'preferred-test-command': null, 'preferred-editor': null };
+  _validateDefaultsSection(raw, errors, defaultsOut);
+
+  // metadata (optional, auto-managed by writer)
+  const metadataOut = { created_at: null, updated_at: null };
+  _validateMetadataSection(raw, errors, metadataOut);
+
+  if (errors.length > 0) {
+    return { ok: false, value: null, errors };
+  }
+
+  return {
+    ok: true,
+    errors: [],
+    value: {
+      'schema-version': CURRENT_OWNER_SCHEMA_VERSION,
+      owner: ownerOut,
+      tone: toneOut,
+      efficiency: efficiencyOut,
+      'hardware-sharing': hwOut,
+      defaults: defaultsOut,
+      metadata: metadataOut,
+    },
+  };
+}

package/scripts/lib/owner-config-banner.mjs

@@ -0,0 +1,126 @@
+/**
+ * owner-config-banner.mjs — #820
+ *
+ * Session-start Phase 4 readiness probe for the Owner Persona Layer's
+ * owner.yaml. Complements the per-section tolerance behaviour added to
+ * `loadOwnerConfig` (scripts/lib/owner-yaml.mjs, #820) by surfacing what
+ * would otherwise be a silent-failure class: a malformed OPTIONAL section
+ * silently replaced by defaults, or the whole file silently discarded
+ * because a REQUIRED section is invalid.
+ *
+ * Three findings, combined into a single null-or-warn result:
+ *
+ *  1. `droppedSections` present — an OPTIONAL object section (`paths`,
+ *     `dispatcher`) was malformed and replaced by its default value.
+ *  2. Whole-file discard — a REQUIRED section (`owner`, `tone`,
+ *     `efficiency`, `hardware-sharing`) was invalid, so `loadOwnerConfig`
+ *     fell back to `source: 'defaults'` with `errors` populated (legacy
+ *     behaviour, unchanged since #161).
+ *  3. `sectionWarnings` present (and nothing dropped) — an OPTIONAL list
+ *     section (`vaults`, `baselines`) has invalid entries that lenient
+ *     consumers will drop at point-of-use.
+ *
+ * Plain-JS — no Zod dependency. Never throws. Returns null (silent no-op)
+ * when the load was clean (`source: 'file'`, nothing dropped/warned) or the
+ * file is simply absent (`source: 'defaults'`, no errors).
+ *
+ * Mirrors the contract used by other Phase 4 banners
+ * (`scripts/lib/loop-readiness-banner.mjs`, `scripts/lib/vault-staleness-banner.mjs`,
+ * `scripts/lib/ci-status-banner.mjs`): a single `checkXxx()` entry point that
+ * returns `null` or `{ severity, message, ... }`.
+ *
+ * Cross-references:
+ *  - `scripts/lib/owner-yaml.mjs` — loadOwnerConfig, validateOwnerSections.
+ *  - `.claude/rules/owner-persona.md` — owner.yaml schema + privacy contract.
+ *  - `skills/session-start/SKILL.md` Phase 4 — banner render site (wired separately).
+ *  - Issue #820.
+ */
+
+import { loadOwnerConfig, OWNER_YAML_PATH } from './owner-yaml.mjs';
+
+/**
+ * Format a `{ section, errors }` entry into a short `"name" (first error)` tag.
+ * @param {{ section: string, errors?: string[] }} entry
+ * @returns {string}
+ */
+function formatSectionTag(entry) {
+  const firstError = Array.isArray(entry?.errors) && entry.errors.length > 0 ? entry.errors[0] : 'invalid';
+  return `"${entry?.section}" (${firstError})`;
+}
+
+/**
+ * Check owner.yaml load health and produce a session-start banner.
+ *
+ * @param {{ loader?: (opts?: object) => {
+ *   source: 'file'|'defaults'|'partial',
+ *   errors: string[],
+ *   droppedSections?: Array<{ section: string, errors: string[] }>,
+ *   sectionWarnings?: Array<{ section: string, errors: string[] }>,
+ * } }} [opts]
+ *   - `loader`: defaults to `loadOwnerConfig`; injectable for tests (fake loader).
+ * @returns {null | {
+ *   severity: 'warn',
+ *   message: string,
+ *   droppedSections?: Array<{ section: string, errors: string[] }>,
+ *   sectionWarnings?: Array<{ section: string, errors: string[] }>,
+ *   discarded?: boolean,
+ * }}
+ */
+export function checkOwnerConfig({ loader = loadOwnerConfig } = {}) {
+  try {
+    const result = loader();
+    if (!result || typeof result !== 'object') return null;
+
+    const errors = Array.isArray(result.errors) ? result.errors : [];
+    const droppedSections = Array.isArray(result.droppedSections) ? result.droppedSections : [];
+    const sectionWarnings = Array.isArray(result.sectionWarnings) ? result.sectionWarnings : [];
+
+    // Clean load (source 'file', nothing dropped/warned) — silent no-op.
+    if (result.source === 'file' && droppedSections.length === 0 && sectionWarnings.length === 0) {
+      return null;
+    }
+
+    // File simply absent (or unreadable with no schema errors) — silent no-op.
+    if (result.source === 'defaults' && errors.length === 0) {
+      return null;
+    }
+
+    // Whole-file discard: a REQUIRED section was invalid (legacy behaviour).
+    if (result.source === 'defaults' && errors.length > 0) {
+      const firstError = errors[0];
+      return {
+        severity: 'warn',
+        message:
+          `⚠ owner-config: ${OWNER_YAML_PATH} is invalid (${firstError}) — the entire file was ` +
+          'discarded and defaults are in effect. Fix the file (see .claude/rules/owner-persona.md) ' +
+          'to restore your settings.',
+        discarded: true,
+      };
+    }
+
+    // Per-section tolerance findings (#820): dropped OPTIONAL object
+    // section(s) and/or invalid OPTIONAL list section(s).
+    const parts = [];
+    if (droppedSections.length > 0) {
+      parts.push(`section(s) replaced by defaults: ${droppedSections.map(formatSectionTag).join(', ')}`);
+    }
+    if (sectionWarnings.length > 0) {
+      parts.push(
+        `section(s) with invalid entries (lenient consumers will drop bad entries): ` +
+          sectionWarnings.map(formatSectionTag).join(', '),
+      );
+    }
+
+    if (parts.length === 0) return null;
+
+    return {
+      severity: 'warn',
+      message: `⚠ owner-config: ${OWNER_YAML_PATH} — ${parts.join('; ')} — fix the file to restore full config.`,
+      ...(droppedSections.length > 0 ? { droppedSections } : {}),
+      ...(sectionWarnings.length > 0 ? { sectionWarnings } : {}),
+    };
+  } catch {
+    // Defensive catch-all — banner must never throw.
+    return null;
+  }
+}

package/scripts/lib/owner-config-loader.mjs

@@ -0,0 +1,159 @@
+/**
+ * owner-config-loader.mjs — File-system loader for owner.yaml (Issue #174).
+ *
+ * Companion to the pure schema/validator in `owner-config.mjs`. Resolves the
+ * canonical config path (XDG-spec aware), reads the YAML, parses it, runs it
+ * through the validator, and returns a `{ok, value, errors, source, path}`
+ * envelope.
+ *
+ * ── PATH RESOLUTION ──────────────────────────────────────────────────────
+ *
+ *   Default path: `${XDG_CONFIG_HOME ?? ${HOME}/.config}/session-orchestrator/owner.yaml`
+ *   - macOS / Linux: `~/.config/session-orchestrator/owner.yaml`
+ *   - Windows:       `%APPDATA%\session-orchestrator\owner.yaml` when
+ *                    APPDATA is set and XDG_CONFIG_HOME is not (Node uses
+ *                    USERPROFILE for os.homedir() — falls back gracefully).
+ *
+ *   Callers may pass an explicit `{path}` override (used by tests + D4
+ *   baseline-propagation when the canonical path is overridden by env).
+ *
+ * ── RETURN SHAPE ─────────────────────────────────────────────────────────
+ *
+ *   {
+ *     ok: boolean,                    // false on any failure
+ *     value: object|null,             // normalized config when ok=true
+ *     errors: string[],               // populated on any failure
+ *     source: 'file'|'missing'|'parse-error'|'validation-error',
+ *     path: string,                   // resolved absolute path
+ *   }
+ *
+ *   `source: 'missing'` is NOT an error — owner.yaml is opt-in (the bootstrap
+ *   interview in D2 creates it). Callers should treat `source: 'missing'` as
+ *   "no owner persona configured; fall back to plugin defaults".
+ *
+ * ── PLATFORM PORTABILITY ─────────────────────────────────────────────────
+ *
+ *   - Uses `os.homedir()` (Node-stdlib, OS-aware) rather than $HOME so the
+ *     Windows path resolves correctly even when only USERPROFILE is set.
+ *   - File reads are UTF-8 only. Owner.yaml is ASCII-safe by spec; non-UTF-8
+ *     content yields `source: 'parse-error'`.
+ *   - YAML parsing via `js-yaml` (devDep already pulled in by W2 quality-fix).
+ */
+
+import { readFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import yaml from 'js-yaml';
+
+import { validate } from './owner-config.mjs';
+
+// ---------------------------------------------------------------------------
+// Path resolution
+// ---------------------------------------------------------------------------
+
+const APP_DIR = 'session-orchestrator';
+const CONFIG_FILE = 'owner.yaml';
+
+/**
+ * Resolve the canonical owner.yaml path on disk. Honours XDG_CONFIG_HOME
+ * when set (Linux convention), otherwise falls back to `${HOME}/.config`.
+ * Returns an absolute path string. Does NOT touch the filesystem.
+ *
+ * @returns {string} absolute path to owner.yaml
+ */
+export function resolveOwnerConfigPath() {
+  const xdg = process.env.XDG_CONFIG_HOME;
+  const base = xdg && xdg.length > 0 ? xdg : join(homedir(), '.config');
+  return join(base, APP_DIR, CONFIG_FILE);
+}
+
+// ---------------------------------------------------------------------------
+// Loader
+// ---------------------------------------------------------------------------
+
+/**
+ * Load and validate the owner.yaml config from disk.
+ *
+ * Defensive — never throws. Distinguishes four outcomes via the `source`
+ * field so callers can react differently to "missing file" (opt-in feature
+ * not yet enabled by the user) vs "malformed YAML" (broken state, surface
+ * to user).
+ *
+ * @param {{path?: string}} [opts]
+ * @returns {Promise<{ok: boolean, value: object|null, errors: string[], source: string, path: string}>}
+ */
+export async function loadOwnerConfig(opts = {}) {
+  const path = opts.path ?? resolveOwnerConfigPath();
+
+  if (!existsSync(path)) {
+    return {
+      ok: false,
+      value: null,
+      errors: [],
+      source: 'missing',
+      path,
+    };
+  }
+
+  let raw;
+  try {
+    raw = await readFile(path, 'utf8');
+  } catch (err) {
+    return {
+      ok: false,
+      value: null,
+      errors: [`failed to read owner config: ${err.message}`],
+      source: 'parse-error',
+      path,
+    };
+  }
+
+  let parsed;
+  try {
+    // js-yaml's default schema (CORE_SCHEMA) is safe — it explicitly excludes
+    // the !!js/function and !!js/regexp tags from the legacy DEFAULT_SCHEMA
+    // that would let a malicious YAML file execute code or pollute prototypes.
+    parsed = yaml.load(raw);
+  } catch (err) {
+    return {
+      ok: false,
+      value: null,
+      errors: [`YAML parse error: ${err.message}`],
+      source: 'parse-error',
+      path,
+    };
+  }
+
+  // Empty file or YAML "null" → treat as parse-error so the caller knows
+  // there's nothing to merge (vs a missing file which opts the user out
+  // entirely).
+  if (parsed === null || parsed === undefined) {
+    return {
+      ok: false,
+      value: null,
+      errors: ['owner config is empty'],
+      source: 'parse-error',
+      path,
+    };
+  }
+
+  const validation = validate(parsed);
+  if (!validation.ok) {
+    return {
+      ok: false,
+      value: null,
+      errors: validation.errors,
+      source: 'validation-error',
+      path,
+    };
+  }
+
+  return {
+    ok: true,
+    value: validation.value,
+    errors: [],
+    source: 'file',
+    path,
+  };
+}

package/scripts/lib/owner-config.example.yaml

@@ -0,0 +1,72 @@
+# ~/.config/session-orchestrator/owner.yaml
+#
+# Per-user persona for the session-orchestrator plugin. Copy this file to
+# ~/.config/session-orchestrator/owner.yaml (or $XDG_CONFIG_HOME/...) and
+# fill in your values. NEVER commit this file to a project repo.
+#
+# Issue #174 (Sub-Epic #161 — Owner Persona Layer). Schema reference:
+# docs/owner-config-schema.md.
+
+# Schema version. MUST be 1. The plugin refuses to load mismatched versions.
+schema-version: 1
+
+owner:
+  # Required. Display name. 1-100 characters.
+  name: Your Name
+
+  # Optional. SHA256 hex digest of your email address. Used for cross-host
+  # identity correlation when sharing learnings (D4/C4). 64 hex chars exactly,
+  # or null to opt out. Plugin can compute this for you on first bootstrap.
+  email-hash: null
+
+  # Required. ISO-639-1 language code (e.g. "de", "en"). Optionally with a
+  # region tag like "en-US". Drives default response language in soul.md.
+  language: en
+
+tone:
+  # How direct should responses be. One of: direct | neutral | friendly.
+  # Default: neutral.
+  style: direct
+
+  # Optional free-form descriptor. Up to 200 chars. Examples:
+  # "austrian-pragmatic", "british-dry", "minimal-comments".
+  tonality: austrian-pragmatic
+
+efficiency:
+  # Caveman-inspired output dial. One of: lite | full | ultra.
+  #   lite  — minimum tokens, telegram style, why-use-many-token-when-few-do-trick.
+  #   full  — default, sentence-style narration.
+  #   ultra — full + extra context, narrative tone (ECC/teaching mode).
+  output-level: full
+
+  # Pre-tool-call narration intensity. One of: minimal | verbose.
+  preamble: minimal
+
+  # Inline code comments. One of: minimal | full.
+  comments-in-code: minimal
+
+hardware-sharing:
+  # Consent gate for sharing hardware-pattern learnings (Sub-Epic C+E).
+  # When true, the plugin may export anonymized hardware patterns (e.g.
+  # "Mac M1 16GB freezes at 8 parallel agents"). Default: false (off).
+  enabled: false
+
+  # 32-byte hex salt (64 chars), per-host. Used to derive a stable but
+  # anonymous host-class identifier. Generated on first bootstrap when
+  # hardware-sharing.enabled is set to true.
+  hash-salt: null
+
+defaults:
+  # Optional. Override the project's `test-command` from CLAUDE.md (or
+  # AGENTS.md on Codex CLI) when no repo-local override exists. Up to 200
+  # chars. See skills/_shared/instruction-file-resolution.md for the alias rule.
+  preferred-test-command: null
+
+  # Optional. Editor command for "open in editor" actions. Up to 50 chars.
+  preferred-editor: null
+
+metadata:
+  # Auto-set by the writer on first save (D2 bootstrap).
+  created_at: null
+  # Auto-bumped on every successful save.
+  updated_at: null

package/scripts/lib/owner-config.mjs

@@ -0,0 +1,28 @@
+/**
+ * owner-config.mjs — Owner Persona schema + validator (Issue #174, Sub-Epic #161).
+ *
+ * Thin re-export wrapper. All logic lives in `./owner-config/` submodules:
+ *   constants.mjs  — frozen enum arrays + schema version
+ *   error.mjs      — OwnerConfigError class
+ *   defaults.mjs   — defaults() factory
+ *   validate.mjs   — validate() + 7 section helpers
+ *   coerce.mjs     — coerce() strict-mode wrapper
+ *   merge.mjs      — merge() deep-merge
+ *   index.mjs      — re-export hub (aggregates all 10 public symbols)
+ *
+ * For the full schema contract and module DAG see `./owner-config/index.mjs`.
+ * The loader (which does touch the disk) lives in `owner-config-loader.mjs`.
+ */
+
+export {
+  CURRENT_OWNER_SCHEMA_VERSION,
+  VALID_TONE_STYLES,
+  VALID_OUTPUT_LEVELS,
+  VALID_PREAMBLE_LEVELS,
+  VALID_COMMENTS_LEVELS,
+  OwnerConfigError,
+  defaults,
+  validate,
+  coerce,
+  merge,
+} from './owner-config/index.mjs';