session-orchestrator 3.16.0

package/scripts/lib/peer-cards/reader.mjs

@@ -0,0 +1,125 @@
+/**
+ * reader.mjs — Read peer cards (USER.md / AGENT.md) from `.orchestrator/peers/`
+ * for issue #503 (Wave 2 I6).
+ *
+ * Consumers:
+ *   - session-start Phase 4 staleness banner (Wave 3)
+ *   - /evolve --dialectic (future #506 — out of scope here)
+ *
+ * Design notes
+ * ────────────
+ *  • Reuses the canonical YAML-subset parser at `scripts/lib/state-md/yaml-parser.mjs`
+ *    (`parseStateMd`). It returns `{ frontmatter, body }`, handles flow arrays
+ *    (`[a, b, c]`), strings, booleans, integers, nulls — the same superset peer-cards
+ *    need. "STATE.md" in the function name is incidental; the grammar is just
+ *    "markdown with `---` YAML frontmatter".
+ *  • Schema validation is delegated to `./schema.mjs` (I5). This module never
+ *    decides what a valid peer card looks like; it just hands the parsed
+ *    frontmatter to the validator and reports the verdict.
+ *  • Read-only by contract. Never writes, never throws on missing files /
+ *    malformed frontmatter — graceful degradation lets the banner caller
+ *    decide UX (warn vs. silent).
+ *  • Clock is injectable (`opts.now`) so staleness tests are deterministic.
+ */
+
+import { readFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { parseStateMd } from '../state-md/yaml-parser.mjs';
+import {
+  validatePeerCardFrontmatter,
+  computeStalenessDays,
+  STALENESS_THRESHOLD_DAYS,
+} from './schema.mjs';
+
+/**
+ * @typedef {Object} PeerCard
+ * @property {Record<string, unknown> | null} frontmatter — parsed YAML frontmatter, or null when missing/malformed
+ * @property {string} body — markdown body after the closing `---` (empty string if none)
+ * @property {number} stalenessDays — whole days since `frontmatter.updated`; `Infinity` if no `updated` field
+ * @property {boolean} isStale — `stalenessDays > STALENESS_THRESHOLD_DAYS`
+ * @property {{ ok: boolean, errors: string[] }} validation — schema verdict from `validatePeerCardFrontmatter`
+ */
+
+/**
+ * @typedef {Object} PeerCardsResult
+ * @property {PeerCard | null} user — USER.md card; null if file missing
+ * @property {PeerCard | null} agent — AGENT.md card; null if file missing
+ * @property {string} peersDir — absolute path to `.orchestrator/peers/`
+ * @property {boolean} exists — whether peersDir exists on disk
+ */
+
+/**
+ * Read peer cards from `<repoRoot>/.orchestrator/peers/`.
+ *
+ * @param {string} repoRoot — REQUIRED, absolute path to repo root
+ * @param {{ now?: Date }} [opts]
+ * @returns {Promise<PeerCardsResult>}
+ */
+export async function readPeerCards(repoRoot, opts = {}) {
+  if (!repoRoot || typeof repoRoot !== 'string') {
+    throw new Error(`readPeerCards: repoRoot is required (got ${typeof repoRoot}).`);
+  }
+
+  const peersDir = join(repoRoot, '.orchestrator', 'peers');
+
+  if (!existsSync(peersDir)) {
+    return { user: null, agent: null, peersDir, exists: false };
+  }
+
+  const now = opts.now ?? new Date();
+  const userPath = join(peersDir, 'USER.md');
+  const agentPath = join(peersDir, 'AGENT.md');
+
+  const [user, agent] = await Promise.all([
+    readOneCard(userPath, now),
+    readOneCard(agentPath, now),
+  ]);
+
+  return { user, agent, peersDir, exists: true };
+}
+
+/**
+ * Read and parse a single peer-card file. Returns null if the file is missing.
+ * Never throws — degrades to a card with `validation.ok === false`.
+ *
+ * @param {string} absPath
+ * @param {Date} now
+ * @returns {Promise<PeerCard | null>}
+ */
+async function readOneCard(absPath, now) {
+  if (!existsSync(absPath)) return null;
+
+  let content;
+  try {
+    content = await readFile(absPath, 'utf8');
+  } catch (err) {
+    return {
+      frontmatter: null,
+      body: '',
+      stalenessDays: Infinity,
+      isStale: true,
+      validation: { ok: false, errors: [`read failed: ${err.message}`] },
+    };
+  }
+
+  const parsed = parseStateMd(content);
+  if (parsed === null) {
+    return {
+      frontmatter: null,
+      body: content,
+      stalenessDays: Infinity,
+      isStale: true,
+      validation: { ok: false, errors: ['no frontmatter or malformed YAML'] },
+    };
+  }
+
+  const { frontmatter, body } = parsed;
+  const validation = validatePeerCardFrontmatter(frontmatter);
+  const updatedIso = typeof frontmatter.updated === 'string' ? frontmatter.updated : null;
+  const stalenessDays = updatedIso ? computeStalenessDays(updatedIso, now) : Infinity;
+  const isStale = stalenessDays > STALENESS_THRESHOLD_DAYS;
+
+  return { frontmatter, body, stalenessDays, isStale, validation };
+}

package/scripts/lib/peer-cards/schema.mjs

@@ -0,0 +1,230 @@
+/**
+ * scripts/lib/peer-cards/schema.mjs — Peer-card frontmatter validator (issue #503).
+ *
+ * Pure ESM, no I/O, no external dependencies. Used by reader.mjs / writer.mjs /
+ * merger.mjs (siblings under scripts/lib/peer-cards/) to validate peer-card
+ * YAML frontmatter on read and before write.
+ *
+ * Design notes:
+ *   - Follows the `mission-status-schema.mjs` convention (pure regex/checks)
+ *     rather than `skills/vault-sync/validator.mjs` (zod). The repo root has
+ *     no `zod` dependency — only `skills/vault-sync/` does, scoped to that
+ *     skill's own `node_modules`. Keeping this validator dependency-free lets
+ *     callers from anywhere under `scripts/lib/` use it without extra setup.
+ *   - The shape mirrors the canonical `vaultFrontmatterSchema` in
+ *     `skills/vault-sync/validator.mjs` (slug regex, ISO date regex, optional
+ *     title/tags) and extends it with the peer-card specific `target` enum and
+ *     `source_sessions` array.
+ *   - The `'peer-card'` discriminator is added to the vault-sync enum via the
+ *     vendored-edit + sync-script-baseline path (see scripts/sync-vault-schema.mjs
+ *     and the BEGIN/END GENERATED SCHEMA sentinel block in validator.mjs).
+ *
+ * Required frontmatter fields (per #503 AC1):
+ *   id              : kebab-case slug, 2..128 chars
+ *   type            : literal 'peer-card'
+ *   target          : 'user' | 'agent'
+ *   created         : ISO-8601 timestamp
+ *   updated         : ISO-8601 timestamp
+ *   source_sessions : string[] (may be empty; defaults to [] when absent)
+ *
+ * Optional fields:
+ *   title : 1..200 chars
+ *   tags  : string[]
+ *
+ * Unknown fields pass through (mirrors the .passthrough() behaviour of the
+ * canonical vault schema).
+ */
+
+// ── Constants ───────────────────────────────────────────────────────────────
+
+/** Canonical kebab-case slug regex (mirrors vault-sync slugRegex). */
+const SLUG_REGEX = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+
+/**
+ * Strict ISO 8601 datetime regex with UTC Z suffix, matching the AC1 example
+ * `2026-05-23T12:30:00Z`. Optional millisecond precision is accepted.
+ * Note: the canonical vault schema accepts date-only and offsets too; peer-cards
+ * deliberately require the full timestamp form for reproducible ordering.
+ */
+const ISO_DATETIME_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{1,3})?Z$/;
+
+/** Permitted peer-card target values. */
+export const PEER_CARD_TARGETS = Object.freeze(['user', 'agent']);
+
+/** Staleness threshold in days — used by merger / discovery probes. */
+export const STALENESS_THRESHOLD_DAYS = 30;
+
+/** Inclusive bounds for the `id` field. */
+const ID_MIN_LEN = 2;
+const ID_MAX_LEN = 128;
+
+/** Inclusive bounds for the optional `title` field. */
+const TITLE_MIN_LEN = 1;
+const TITLE_MAX_LEN = 200;
+
+// ── Type guards ─────────────────────────────────────────────────────────────
+
+function _isString(v) {
+  return typeof v === 'string';
+}
+
+function _isStringArray(v) {
+  return Array.isArray(v) && v.every(_isString);
+}
+
+// ── Public predicates ──────────────────────────────────────────────────────
+
+/**
+ * Returns true when `value` is one of the canonical peer-card target strings.
+ *
+ * @param {unknown} value
+ * @returns {boolean}
+ */
+function isValidPeerCardTarget(value) {
+  return typeof value === 'string' && PEER_CARD_TARGETS.includes(value);
+}
+
+/**
+ * Returns true when `value` is a valid kebab-case slug within the id length
+ * bounds (2..128).
+ *
+ * @param {unknown} value
+ * @returns {boolean}
+ */
+function isValidPeerCardId(value) {
+  if (typeof value !== 'string') return false;
+  if (value.length < ID_MIN_LEN || value.length > ID_MAX_LEN) return false;
+  return SLUG_REGEX.test(value);
+}
+
+/**
+ * Returns true when `value` is a strict ISO 8601 datetime ending in `Z`.
+ *
+ * @param {unknown} value
+ * @returns {boolean}
+ */
+function isValidIsoTimestamp(value) {
+  return typeof value === 'string' && ISO_DATETIME_REGEX.test(value);
+}
+
+// ── Validator ──────────────────────────────────────────────────────────────
+
+/**
+ * Validate a parsed peer-card frontmatter object against the #503 AC1 shape.
+ *
+ * Returns a discriminated result object:
+ *   - { ok: true, data: object }   — input is valid; `data` is the input with
+ *                                    `source_sessions` defaulted to `[]` when
+ *                                    absent (mirrors AC1 default). Unknown
+ *                                    fields are preserved (passthrough).
+ *   - { ok: false, errors: string[] } — one entry per failed field, formatted
+ *                                       as `"<path>: <message>"`.
+ *
+ * Never throws.
+ *
+ * @param {unknown} input - parsed YAML frontmatter object
+ * @returns {{ ok: true, data: object } | { ok: false, errors: string[] }}
+ */
+export function validatePeerCardFrontmatter(input) {
+  const errors = [];
+
+  if (input === null || typeof input !== 'object' || Array.isArray(input)) {
+    return { ok: false, errors: ['<root>: frontmatter must be a plain object'] };
+  }
+
+  // ── id ──────────────────────────────────────────────────────────────────
+  if (!('id' in input)) {
+    errors.push('id: required field missing');
+  } else if (!isValidPeerCardId(input.id)) {
+    errors.push(
+      `id: must be a kebab-case slug of ${ID_MIN_LEN}..${ID_MAX_LEN} chars (matching ${SLUG_REGEX.source})`,
+    );
+  }
+
+  // ── type ────────────────────────────────────────────────────────────────
+  if (!('type' in input)) {
+    errors.push('type: required field missing');
+  } else if (input.type !== 'peer-card') {
+    errors.push(`type: must be literal "peer-card" (got ${JSON.stringify(input.type)})`);
+  }
+
+  // ── target ──────────────────────────────────────────────────────────────
+  if (!('target' in input)) {
+    errors.push('target: required field missing');
+  } else if (!isValidPeerCardTarget(input.target)) {
+    errors.push(
+      `target: must be one of ${JSON.stringify(PEER_CARD_TARGETS)} (got ${JSON.stringify(input.target)})`,
+    );
+  }
+
+  // ── created ─────────────────────────────────────────────────────────────
+  if (!('created' in input)) {
+    errors.push('created: required field missing');
+  } else if (!isValidIsoTimestamp(input.created)) {
+    errors.push('created: must be an ISO 8601 timestamp ending in Z (e.g. 2026-05-23T12:30:00Z)');
+  }
+
+  // ── updated ─────────────────────────────────────────────────────────────
+  if (!('updated' in input)) {
+    errors.push('updated: required field missing');
+  } else if (!isValidIsoTimestamp(input.updated)) {
+    errors.push('updated: must be an ISO 8601 timestamp ending in Z (e.g. 2026-05-23T12:30:00Z)');
+  }
+
+  // ── source_sessions (default: []) ───────────────────────────────────────
+  let sourceSessions;
+  if (!('source_sessions' in input) || input.source_sessions === undefined) {
+    sourceSessions = [];
+  } else if (!_isStringArray(input.source_sessions)) {
+    errors.push('source_sessions: must be an array of strings');
+    sourceSessions = undefined;
+  } else {
+    sourceSessions = input.source_sessions;
+  }
+
+  // ── Optional: title ────────────────────────────────────────────────────
+  if ('title' in input && input.title !== undefined) {
+    if (!_isString(input.title)) {
+      errors.push('title: must be a string when provided');
+    } else if (input.title.length < TITLE_MIN_LEN || input.title.length > TITLE_MAX_LEN) {
+      errors.push(`title: length must be ${TITLE_MIN_LEN}..${TITLE_MAX_LEN} chars`);
+    }
+  }
+
+  // ── Optional: tags ─────────────────────────────────────────────────────
+  if ('tags' in input && input.tags !== undefined) {
+    if (!_isStringArray(input.tags)) {
+      errors.push('tags: must be an array of strings when provided');
+    }
+  }
+
+  if (errors.length > 0) {
+    return { ok: false, errors };
+  }
+
+  // Spread input first so passthrough fields are preserved, then overwrite
+  // source_sessions with the defaulted value.
+  return { ok: true, data: { ...input, source_sessions: sourceSessions } };
+}
+
+// ── Staleness helpers ──────────────────────────────────────────────────────
+
+/**
+ * Compute staleness in whole days between `updatedIso` and `now`.
+ *
+ * Returns `Infinity` when `updatedIso` cannot be parsed by `Date`. The result
+ * floors toward zero so a card updated 29 hours ago reads as `1` day stale.
+ *
+ * @param {string} updatedIso - ISO 8601 timestamp from peer-card frontmatter
+ * @param {Date} [now=new Date()] - injectable clock for tests
+ * @returns {number} whole days since `updatedIso`; `Infinity` on parse failure
+ */
+export function computeStalenessDays(updatedIso, now = new Date()) {
+  if (typeof updatedIso !== 'string') return Infinity;
+  const updated = new Date(updatedIso);
+  const t = updated.getTime();
+  if (Number.isNaN(t)) return Infinity;
+  const nowMs = now instanceof Date ? now.getTime() : Number(now);
+  if (!Number.isFinite(nowMs)) return Infinity;
+  return Math.floor((nowMs - t) / 86_400_000);
+}

package/scripts/lib/peer-cards/staleness-banner.mjs

@@ -0,0 +1,86 @@
+/**
+ * staleness-banner.mjs — Session-start banner for #503 peer-card staleness.
+ *
+ * Surfaces a `warn` banner during session-start Phase 4 when peer cards
+ * (USER.md / AGENT.md under `.orchestrator/peers/`) have an `updated:`
+ * frontmatter older than `STALENESS_THRESHOLD_DAYS` (30) days.
+ *
+ * Design notes:
+ *  - Mirrors the contract used by other Phase 4 banners
+ *    (`scripts/lib/vault-staleness-banner.mjs`, `scripts/lib/ci-status-banner.mjs`,
+ *    `scripts/lib/qg-command-drift-banner.mjs`): a single `checkXxx()` entry
+ *    point that returns `null` (silent no-op) or `{ severity, message, ... }`.
+ *  - Never throws. The banner is informational — the session-start renderer
+ *    must not be derailed by reader errors, missing files, or schema mismatches.
+ *    Defensive `try/catch` wraps every potentially-throwing call.
+ *  - Clock is injectable (`opts.now`) to keep tests deterministic. Propagates
+ *    through to `readPeerCards()` so staleness computations agree across the
+ *    reader and the banner.
+ *
+ * Cross-references:
+ *  - `scripts/lib/peer-cards/reader.mjs` — produces the `PeerCardsResult`
+ *    consumed here.
+ *  - `scripts/lib/peer-cards/schema.mjs` — `STALENESS_THRESHOLD_DAYS = 30`.
+ *  - `.claude/rules/owner-persona.md` — host-wide `owner.yaml`; peer cards
+ *    are the per-repo behavioural complement.
+ *  - `skills/session-start/SKILL.md` Phase 4 — banner render site.
+ */
+
+import { readPeerCards } from './reader.mjs';
+
+/**
+ * Check peer-card staleness and produce a session-start banner.
+ *
+ * @param {object} opts
+ * @param {string} opts.repoRoot - REQUIRED absolute path to repo root
+ * @param {Date} [opts.now] - injectable clock for tests
+ * @returns {Promise<null | { severity: 'warn', message: string, stale: Array<{target: string, days: number}> }>}
+ */
+export async function checkPeerCardsStaleness({ repoRoot, now } = {}) {
+  // Silent no-op on bad input (consistent with other Phase 4 banners).
+  if (!repoRoot || typeof repoRoot !== 'string') return null;
+
+  let result;
+  try {
+    result = await readPeerCards(repoRoot, { now });
+  } catch {
+    // Never throw — banner is informational only.
+    return null;
+  }
+
+  if (!result || !result.exists) return null;
+
+  const stale = [];
+
+  // Only count cards that are (a) present, (b) have valid frontmatter so the
+  // `updated:` date could be parsed, and (c) flagged stale by the reader.
+  // A card without parseable frontmatter still has `isStale: true` because
+  // `stalenessDays === Infinity`, but in that case the corrective action is
+  // "fix the frontmatter", not "run /evolve --dialectic" — so we exclude it
+  // from this banner.
+  if (
+    result.user &&
+    result.user.isStale &&
+    result.user.frontmatter &&
+    Number.isFinite(result.user.stalenessDays)
+  ) {
+    stale.push({ target: 'USER.md', days: result.user.stalenessDays });
+  }
+  if (
+    result.agent &&
+    result.agent.isStale &&
+    result.agent.frontmatter &&
+    Number.isFinite(result.agent.stalenessDays)
+  ) {
+    stale.push({ target: 'AGENT.md', days: result.agent.stalenessDays });
+  }
+
+  if (stale.length === 0) return null;
+
+  const parts = stale.map((s) => `${s.target} (${s.days}d)`).join(', ');
+  const message =
+    `⚠ peer-cards: ${parts} stale (>30 days) — ` +
+    `consider running /evolve --dialectic to refresh.`;
+
+  return { severity: 'warn', message, stale };
+}

package/scripts/lib/peer-cards/writer.mjs

@@ -0,0 +1,138 @@
+/**
+ * writer.mjs — Atomic writer for peer-card markdown files.
+ *
+ * Peer cards live at `.orchestrator/peers/{USER,AGENT}.md` and carry a frontmatter
+ * block followed by markdown body. Writes are crash-safe via tmp + rename (POSIX
+ * atomic same-filesystem rename), and the writer ENFORCES the EARS unwanted-behaviour
+ * rule from #503: a peer-card missing the required `id` field fails with
+ * `peer-card missing required field: id` and writes nothing.
+ *
+ * Full frontmatter validation is delegated to schema.mjs (`validatePeerCardFrontmatter`);
+ * if validation fails for any reason (missing fields, wrong types, etc.) the writer
+ * returns `{ ok: false, errors }` and leaves the target file untouched.
+ *
+ * Auto-fill semantics (only when caller omits the field):
+ *   - type            → 'peer-card'
+ *   - target          → from the function argument
+ *   - updated         → current ISO timestamp
+ *   - created         → mirrors `updated` if absent
+ *   - source_sessions → []
+ *   - `id` is NEVER auto-filled — callers must provide it (EARS gate).
+ *
+ * Part of #503 (Wave 2; sibling to schema.mjs / reader.mjs / merger.mjs).
+ */
+
+import { writeFile, rename, mkdir, unlink } from 'node:fs/promises';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+
+import { validatePeerCardFrontmatter } from './schema.mjs';
+
+// Frontmatter keys serialized in this order. Anything else is appended.
+const ORDERED_KEYS = ['id', 'type', 'target', 'created', 'updated', 'source_sessions', 'title', 'tags'];
+
+// YAML special chars that force quoting of scalar string values.
+const YAML_SPECIAL = /[:#&*!|>'"%@`,[\]{}]/;
+
+/**
+ * Serialize a flat frontmatter object to a YAML `---` block.
+ *
+ * Peer-card frontmatter is intentionally flat (no nested objects per schema), so this
+ * helper handles scalars, string arrays, and string-keyed booleans/numbers. Strings
+ * containing YAML-special characters are quoted via JSON.stringify (safe superset of
+ * YAML double-quoted scalar).
+ *
+ * @param {Record<string, unknown>} fm
+ * @returns {string}  YAML block including the opening and closing `---` markers.
+ */
+function serializeFrontmatter(fm) {
+  const lines = ['---'];
+
+  const writeKey = (key, value) => {
+    if (Array.isArray(value)) {
+      lines.push(`${key}: [${value.map((v) => JSON.stringify(v)).join(', ')}]`);
+    } else if (typeof value === 'string') {
+      const needsQuoting = YAML_SPECIAL.test(value);
+      lines.push(`${key}: ${needsQuoting ? JSON.stringify(value) : value}`);
+    } else {
+      lines.push(`${key}: ${JSON.stringify(value)}`);
+    }
+  };
+
+  for (const key of ORDERED_KEYS) {
+    if (key in fm) writeKey(key, fm[key]);
+  }
+  for (const key of Object.keys(fm)) {
+    if (!ORDERED_KEYS.includes(key)) writeKey(key, fm[key]);
+  }
+
+  lines.push('---');
+  return lines.join('\n');
+}
+
+/**
+ * Atomically write a peer card to `.orchestrator/peers/{USER,AGENT}.md`.
+ *
+ * @param {string} repoRoot              Absolute path to the repo root (required).
+ * @param {'user'|'agent'} target        Which peer card to write.
+ * @param {{ frontmatter: object, body: string }} card  Card content.
+ * @returns {Promise<{ ok: true, path: string } | { ok: false, errors: string[] }>}
+ * @throws {Error} On invalid input (bad repoRoot, bad target, bad card).
+ */
+export async function writePeerCard(repoRoot, target, card) {
+  if (!repoRoot || typeof repoRoot !== 'string') {
+    throw new Error(`writePeerCard: repoRoot is required (got ${typeof repoRoot}).`);
+  }
+  if (target !== 'user' && target !== 'agent') {
+    throw new Error(`writePeerCard: target must be 'user' or 'agent' (got ${JSON.stringify(target)}).`);
+  }
+  if (!card || typeof card !== 'object') {
+    throw new Error('writePeerCard: card must be an object.');
+  }
+
+  // Build the effective frontmatter with auto-filled derived fields.
+  // Note: `id` is INTENTIONALLY not auto-filled — the EARS gate below depends on this.
+  const fm = { ...card.frontmatter };
+  fm.type = 'peer-card';
+  fm.target = target;
+  fm.updated = fm.updated || new Date().toISOString();
+  fm.created = fm.created || fm.updated;
+  fm.source_sessions = fm.source_sessions || [];
+
+  // EARS unwanted-behaviour gate (#503): refuse to write without id.
+  if (!fm.id) {
+    return { ok: false, errors: ['peer-card missing required field: id'] };
+  }
+
+  // Full schema validation — schema.mjs is the source of truth for valid shapes.
+  const validation = validatePeerCardFrontmatter(fm);
+  if (!validation.ok) {
+    return { ok: false, errors: validation.errors };
+  }
+
+  const filename = target === 'user' ? 'USER.md' : 'AGENT.md';
+  const peersDir = join(repoRoot, '.orchestrator', 'peers');
+  const finalPath = join(peersDir, filename);
+
+  await mkdir(peersDir, { recursive: true });
+
+  const bodyStr = typeof card.body === 'string' ? card.body : '';
+  const content = `${serializeFrontmatter(fm)}\n\n${bodyStr.trimStart()}`;
+  const tmpPath = `${finalPath}.${randomUUID().slice(0, 8)}.tmp`;
+
+  try {
+    await writeFile(tmpPath, content, 'utf8');
+    await rename(tmpPath, finalPath);
+    return { ok: true, path: finalPath };
+  } catch (err) {
+    // Best-effort cleanup of orphaned tmp file. Swallow secondary failures —
+    // the primary error is what the caller needs to see.
+    try {
+      await unlink(tmpPath);
+    } catch {
+      /* tmp file may not exist if writeFile failed before creating it */
+    }
+    throw err;
+  }
+}
+