rcf-lite 0.26.0 → 0.28.0

package/src/finalise/ship-without-eval.js

@@ -7,14 +7,20 @@
 // Landing shape mirrors ship-without-verified: an optional
 // `shipWithoutEval[]` array on the manifest, with monotonic ids
 // `swe-<fbsId>-<n>`, the operator's reason string, the declared AC
-// verdicts, the report path, and an ISO timestamp. rcf-schemas 0.6.0
-// does not yet declare this field on the manifest schema; consumers
-// treat its absence as "no acks" and its presence as data.
+// verdicts, the report path, and an ISO timestamp.
+//
+// Referee-guarantee train (REQ-165, docs claim C-33): rcf-schemas 0.6.3
+// declares the field on the manifest schema, so the write path validates
+// the composed manifest before writing it (mirrors the sister
+// ship-without-verified writer's discipline). The docs sentence
+// "--ship-without-eval records its acknowledgement as a valid manifest
+// field" holds against the shipped pin.
 
 import { mkdir, rename, unlink, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 
 import { rcfError } from '#core/errors';
+import { validateDocument } from '#core/store';
 
 /**
  * @typedef {object} ShipWithoutEvalDeclaredAc
@@ -84,9 +90,11 @@ export function composeShipWithoutEvalRecord({
 
 /**
  * Persist a ship-without-eval acknowledgement onto the manifest.
- * Manifest write is atomic (tmp + rename). rcf-schemas 0.6.0's manifest
- * schema does not declare this field, so the write path skips the
- * validator (spec section 9: extensions land at a later minor).
+ * Reads `tree.manifest` for the current state, appends the composed
+ * record to `manifest.shipWithoutEval[]`, validates the composed
+ * manifest against the rcf-schemas 0.6.3 schema, and writes it
+ * atomically. On validation failure the on-disk manifest is untouched
+ * (mirrors the sister ship-without-verified writer's discipline).
  *
  * @param {object} args
  * @param {string} args.projectRoot
@@ -100,6 +108,10 @@ export async function writeShipWithoutEvalRecord({ projectRoot, tree, record })
   const existing = Array.isArray(nextManifest.shipWithoutEval) ? nextManifest.shipWithoutEval : [];
   nextManifest.shipWithoutEval = [...existing, record];
 
+  const relPath = 'rcf/manifest.json';
+  const validation = validateDocument({ doc: nextManifest, kind: 'manifest', filePath: relPath });
+  if (validation) return validation;
+
   const absPath = join(projectRoot, 'rcf', 'manifest.json');
   try {
     await mkdir(dirname(absPath), { recursive: true });
@@ -115,7 +127,7 @@ export async function writeShipWithoutEvalRecord({ projectRoot, tree, record })
     return rcfError({
       kind: 'ioFailure',
       message: `finalise: ship-without-eval manifest write failed: ${err.message}`,
-      filePath: 'rcf/manifest.json',
+      filePath: relPath,
       stack: err.stack,
     });
   }

package/src/mcp/tools.js

@@ -477,7 +477,8 @@ const DEFINITIONS = [
       type: 'object',
       properties: {
         scopeId: { type: 'string', description: 'Optional PRD / REQ / US id to scope coverage; below-AC ids are refused' },
-        strict: { type: 'boolean', description: 'Per-AC-strict mode (every AC needs TC coverage); defaults to false (shallow-any)' },
+        mode: { type: 'string', enum: ['strict', 'shallow-any'], description: 'Coverage mode (referee-guarantee train REQ-164): strict (per-AC, default) or shallow-any (any AC covered by any resolving TC = REQ covered).' },
+        strict: { type: 'boolean', description: 'Legacy alias for mode; true = strict, false = shallow-any. Kept for backward compatibility. Prefer mode.' },
         withCode: { type: 'boolean', description: 'Phase 10: layer the code axis onto every AC (implemented-and-covered / implemented-uncovered / unimplemented) plus a codeNodeOrphans list. Informational only - never affects ok or the exit-code twin.' },
       },
       additionalProperties: false,
@@ -892,8 +893,13 @@ export function createToolRegistry({ projectRoot, log }) {
       // Phase 10 (D11): withCode layers the informational code axis on.
       // w-2026-07-28-005: pointer resolution gates "covered" - same rule
       // as the CLI, one resolution pass against the working tree.
+      // Referee-guarantee train (REQ-164 / US-16401): strict is the
+      // shipped default; pass `mode: 'shallow-any'` (or the legacy
+      // `strict: false`) to opt out. `strict: true` is honoured as-is
+      // for backward-compatible callers that still spell it out.
       const testPointers = await resolveTestPointers({ projectRoot, tree });
-      return okResult(computeCoverage(tree, { strict: Boolean(args.strict), scopeId, withCode: Boolean(args.withCode), testPointers }));
+      const strict = args.mode === 'shallow-any' ? false : (args.strict === false ? false : true);
+      return okResult(computeCoverage(tree, { strict, scopeId, withCode: Boolean(args.withCode), testPointers }));
     },
 
     rcf_trace: async (args) => {

package/src/setup/feedback-hooks.js

@@ -0,0 +1,397 @@
+// Feedback hook installer (ADR-4108). Slice 5 (FBS-184): rcf init
+// merges three feedback hook entries into the two committed harness
+// config files (`.claude/settings.json`, `.codex/hooks.json`); rcf
+// doctor detects and repairs missing entries, and refuses foreign
+// entries whose command names our binary with the wrong flags.
+//
+// Merge discipline mirrors `writeMcpConfig`:
+//   - parse; refuse on invalid JSON with the same message shape;
+//   - preserve every other server/hook verbatim;
+//   - add our entries only when an entry naming `rcf feedback hook`
+//     is absent for that event; otherwise leave the file alone.
+// A caller passing `binPath` gets the pinned-bin shape
+// (`{ command: 'node', args: [binPath, 'feedback', 'hook', ...] }`),
+// mirroring the `.mcp.json` entry pattern; the default is the
+// portable `npx rcf-lite feedback hook <event>` shape.
+
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+
+import { rcfError } from '#core/errors';
+
+/**
+ * Command-substring marker used across the estate to identify our
+ * hook commands. Matches both shapes we ship:
+ *   - `npx rcf-lite feedback hook <event> --harness ...`
+ *   - `node <binPath> feedback hook <event> --harness ...`
+ * so a foreign-shape entry that names our verbs is still detected as
+ * ours (and reported as foreign-hook) rather than treated as an
+ * unrelated command.
+ */
+export const FEEDBACK_HOOK_COMMAND_MARKER = 'feedback hook';
+
+/** Events the installer owns (per design 3.5). */
+export const FEEDBACK_HOOK_EVENTS = /** @type {const} */ ([
+  { event: 'Stop', subVerb: 'stop', timeout: 10, matcher: null, codexEvent: 'Stop' },
+  { event: 'SessionEnd', subVerb: 'session-end', timeout: 5, matcher: null, codexEvent: 'SessionEnd' },
+  { event: 'SessionStart', subVerb: 'session-start', timeout: 5, matcher: 'startup|resume', codexEvent: 'SessionStart' },
+]);
+
+/**
+ * Build the Claude Code hook command string for one event.
+ *
+ * @param {string} subVerb
+ * @param {'claude-code' | 'codex'} harness
+ * @param {string | undefined} binPath
+ * @returns {string}
+ */
+function buildCommand(subVerb, harness, binPath) {
+  const args = ['feedback', 'hook', subVerb, '--harness', harness];
+  if (typeof binPath === 'string' && binPath.length > 0) {
+    return `node ${binPath} ${args.join(' ')}`;
+  }
+  return `npx rcf-lite ${args.join(' ')}`;
+}
+
+/**
+ * Build the Claude Code hook entry a `.claude/settings.json` file
+ * carries for one event. Matches the shape Claude Code writes to a
+ * user-scope file via `/hooks add`: hooks arrays keyed by event,
+ * each element `{ matcher?, hooks: [{ type: 'command', command,
+ * timeout }] }`.
+ *
+ * @param {typeof FEEDBACK_HOOK_EVENTS[number]} spec
+ * @param {string | undefined} binPath
+ */
+export function claudeHookEntry(spec, binPath) {
+  const command = buildCommand(spec.subVerb, 'claude-code', binPath);
+  const inner = {
+    hooks: [
+      { type: 'command', command, timeout: spec.timeout },
+    ],
+  };
+  if (spec.matcher) inner.matcher = spec.matcher;
+  return inner;
+}
+
+/**
+ * Build the Codex hook entry a `.codex/hooks.json` file carries for
+ * one event. Codex's schema (0.153.4+) keys hooks by event name and
+ * takes an array of `{ command, timeout? }` shell entries; we mirror
+ * that shape so a Codex `hooks list` shows one entry per event.
+ *
+ * @param {typeof FEEDBACK_HOOK_EVENTS[number]} spec
+ * @param {string | undefined} binPath
+ */
+export function codexHookEntry(spec, binPath) {
+  const command = buildCommand(spec.subVerb, 'codex', binPath);
+  return { command, timeout: spec.timeout };
+}
+
+/**
+ * Merge the three feedback hook entries into a parsed Claude Code
+ * settings object; returns `{ next, added, foreign, kept }`. Pure
+ * over the input; the caller writes if `added.length > 0` or a
+ * `foreign` list on a settings file with no gating drift.
+ *
+ * @param {object | null} current
+ * @param {string | undefined} binPath
+ */
+export function mergeClaudeSettings(current, binPath) {
+  const base = current && typeof current === 'object' && !Array.isArray(current)
+    ? { ...current }
+    : {};
+  const hooks = base.hooks && typeof base.hooks === 'object' && !Array.isArray(base.hooks)
+    ? { ...base.hooks }
+    : {};
+  const added = [];
+  const foreign = [];
+  const kept = [];
+  for (const spec of FEEDBACK_HOOK_EVENTS) {
+    const bucketRaw = hooks[spec.event];
+    const bucket = Array.isArray(bucketRaw) ? bucketRaw.slice() : [];
+    const ours = bucket.filter((entry) => entryClaudeIsOurs(entry));
+    const expectedCommand = buildCommand(spec.subVerb, 'claude-code', binPath);
+    if (ours.length === 0) {
+      bucket.push(claudeHookEntry(spec, binPath));
+      hooks[spec.event] = bucket;
+      added.push(spec.event);
+      continue;
+    }
+    // Foreign detection: an entry that names our marker but whose
+    // command string (or timeout, or matcher for SessionStart) differs
+    // from the current install shape.
+    const drift = ours.filter((entry) => !entryClaudeMatches(entry, spec, expectedCommand));
+    if (drift.length > 0) {
+      for (const d of drift) {
+        foreign.push({ event: spec.event, command: firstClaudeCommand(d) ?? '(unknown)' });
+      }
+    } else {
+      kept.push(spec.event);
+    }
+    hooks[spec.event] = bucket;
+  }
+  return { next: { ...base, hooks }, added, foreign, kept };
+}
+
+/**
+ * Merge the three feedback hook entries into a parsed Codex hooks
+ * object; returns `{ next, added, foreign, kept }`. Pure over the
+ * input, same discipline as `mergeClaudeSettings`.
+ *
+ * @param {object | null} current
+ * @param {string | undefined} binPath
+ */
+export function mergeCodexHooks(current, binPath) {
+  const base = current && typeof current === 'object' && !Array.isArray(current)
+    ? { ...current }
+    : {};
+  const hooks = base.hooks && typeof base.hooks === 'object' && !Array.isArray(base.hooks)
+    ? { ...base.hooks }
+    : {};
+  const added = [];
+  const foreign = [];
+  const kept = [];
+  for (const spec of FEEDBACK_HOOK_EVENTS) {
+    const bucketRaw = hooks[spec.codexEvent];
+    const bucket = Array.isArray(bucketRaw) ? bucketRaw.slice() : [];
+    const ours = bucket.filter((entry) => entryCodexIsOurs(entry));
+    const expectedCommand = buildCommand(spec.subVerb, 'codex', binPath);
+    if (ours.length === 0) {
+      bucket.push(codexHookEntry(spec, binPath));
+      hooks[spec.codexEvent] = bucket;
+      added.push(spec.codexEvent);
+      continue;
+    }
+    const drift = ours.filter((entry) => !entryCodexMatches(entry, spec, expectedCommand));
+    if (drift.length > 0) {
+      for (const d of drift) {
+        foreign.push({ event: spec.codexEvent, command: d?.command ?? '(unknown)' });
+      }
+    } else {
+      kept.push(spec.codexEvent);
+    }
+    hooks[spec.codexEvent] = bucket;
+  }
+  return { next: { ...base, hooks }, added, foreign, kept };
+}
+
+function entryClaudeIsOurs(entry) {
+  const hooks = Array.isArray(entry?.hooks) ? entry.hooks : [];
+  return hooks.some((h) => typeof h?.command === 'string' && h.command.includes(FEEDBACK_HOOK_COMMAND_MARKER));
+}
+
+function firstClaudeCommand(entry) {
+  const hooks = Array.isArray(entry?.hooks) ? entry.hooks : [];
+  const hit = hooks.find((h) => typeof h?.command === 'string' && h.command.includes(FEEDBACK_HOOK_COMMAND_MARKER));
+  return hit?.command;
+}
+
+function entryClaudeMatches(entry, spec, expectedCommand) {
+  const hooks = Array.isArray(entry?.hooks) ? entry.hooks : [];
+  // Compare matcher through a null-normalising cast: both spec and
+  // entry may express the absence of a matcher as either null or
+  // undefined (the former is deliberate on our specs; the latter is
+  // what JSON round-trip drops).
+  const specMatcher = spec.matcher ?? null;
+  const entryMatcher = entry?.matcher ?? null;
+  if (specMatcher !== entryMatcher) return false;
+  const ourHooks = hooks.filter((h) => typeof h?.command === 'string' && h.command.includes(FEEDBACK_HOOK_COMMAND_MARKER));
+  if (ourHooks.length !== 1) return false;
+  const h = ourHooks[0];
+  if (h.type !== 'command') return false;
+  if (h.command !== expectedCommand) return false;
+  if (h.timeout !== spec.timeout) return false;
+  return true;
+}
+
+function entryCodexIsOurs(entry) {
+  return typeof entry?.command === 'string' && entry.command.includes(FEEDBACK_HOOK_COMMAND_MARKER);
+}
+
+function entryCodexMatches(entry, spec, expectedCommand) {
+  if (entry?.command !== expectedCommand) return false;
+  if (entry?.timeout !== spec.timeout) return false;
+  return true;
+}
+
+/**
+ * Write / merge `.claude/settings.json` with the three feedback hook
+ * entries. Returns an action summary the caller renders (or an
+ * rcfError on invalid JSON, mirroring `writeMcpConfig`).
+ *
+ * @param {object} args
+ * @param {string} args.projectRoot
+ * @param {string} [args.binPath]
+ */
+export async function writeClaudeFeedbackHooks({ projectRoot, binPath } = {}) {
+  const file = join(projectRoot, '.claude', 'settings.json');
+  const raw = await readIfExists(file);
+  let current = null;
+  let existed = raw !== null;
+  if (existed) {
+    try {
+      current = JSON.parse(raw);
+    } catch (err) {
+      return rcfError({
+        kind: 'parseFailure',
+        message: `.claude/settings.json exists but is not valid JSON (${err.message}); refusing to modify it. Fix it by hand, or add the feedback hook entries manually - see docs/feedback.md, section 'Slice 5 hooks'.`,
+        filePath: '.claude/settings.json',
+      });
+    }
+    if (current === null || typeof current !== 'object' || Array.isArray(current)) {
+      return rcfError({
+        kind: 'parseFailure',
+        message: '.claude/settings.json exists but is not a JSON object; refusing to modify it.',
+        filePath: '.claude/settings.json',
+      });
+    }
+  }
+  const merge = mergeClaudeSettings(current, binPath);
+  if (merge.foreign.length > 0) {
+    return {
+      file: '.claude/settings.json',
+      action: 'foreign',
+      foreign: merge.foreign,
+      added: [],
+    };
+  }
+  if (merge.added.length === 0) {
+    return {
+      file: '.claude/settings.json',
+      action: 'kept',
+      added: [],
+      foreign: [],
+    };
+  }
+  await mkdir(dirname(file), { recursive: true });
+  await writeFile(file, `${JSON.stringify(merge.next, null, 2)}\n`, 'utf8');
+  return {
+    file: '.claude/settings.json',
+    action: existed ? 'merged' : 'created',
+    added: merge.added,
+    foreign: [],
+  };
+}
+
+/**
+ * Write / merge `.codex/hooks.json` with the three feedback hook
+ * entries. Same discipline as `writeClaudeFeedbackHooks`.
+ *
+ * @param {object} args
+ * @param {string} args.projectRoot
+ * @param {string} [args.binPath]
+ */
+export async function writeCodexFeedbackHooks({ projectRoot, binPath } = {}) {
+  const file = join(projectRoot, '.codex', 'hooks.json');
+  const raw = await readIfExists(file);
+  let current = null;
+  let existed = raw !== null;
+  if (existed) {
+    try {
+      current = JSON.parse(raw);
+    } catch (err) {
+      return rcfError({
+        kind: 'parseFailure',
+        message: `.codex/hooks.json exists but is not valid JSON (${err.message}); refusing to modify it. Fix it by hand, or add the feedback hook entries manually - see docs/feedback.md, section 'Slice 5 hooks'.`,
+        filePath: '.codex/hooks.json',
+      });
+    }
+    if (current === null || typeof current !== 'object' || Array.isArray(current)) {
+      return rcfError({
+        kind: 'parseFailure',
+        message: '.codex/hooks.json exists but is not a JSON object; refusing to modify it.',
+        filePath: '.codex/hooks.json',
+      });
+    }
+  }
+  const merge = mergeCodexHooks(current, binPath);
+  if (merge.foreign.length > 0) {
+    return {
+      file: '.codex/hooks.json',
+      action: 'foreign',
+      foreign: merge.foreign,
+      added: [],
+    };
+  }
+  if (merge.added.length === 0) {
+    return {
+      file: '.codex/hooks.json',
+      action: 'kept',
+      added: [],
+      foreign: [],
+    };
+  }
+  await mkdir(dirname(file), { recursive: true });
+  await writeFile(file, `${JSON.stringify(merge.next, null, 2)}\n`, 'utf8');
+  return {
+    file: '.codex/hooks.json',
+    action: existed ? 'merged' : 'created',
+    added: merge.added,
+    foreign: [],
+  };
+}
+
+/**
+ * Diagnose one Claude Code settings file WITHOUT writing. Returns
+ * `{ missing: string[], foreign: Array<{event,command}> }` per event.
+ * Doctor consumes this to decide missing-hook (fixable) vs
+ * foreign-hook (refused) rows.
+ *
+ * @param {object} args
+ * @param {string} args.projectRoot
+ * @param {string} [args.binPath]
+ */
+export async function diagnoseClaudeFeedbackHooks({ projectRoot, binPath } = {}) {
+  const file = join(projectRoot, '.claude', 'settings.json');
+  const raw = await readIfExists(file);
+  if (raw === null) {
+    return { present: false, missing: FEEDBACK_HOOK_EVENTS.map((s) => s.event), foreign: [] };
+  }
+  let current;
+  try {
+    current = JSON.parse(raw);
+  } catch (err) {
+    return { present: true, parseError: err.message, missing: [], foreign: [] };
+  }
+  if (current === null || typeof current !== 'object' || Array.isArray(current)) {
+    return { present: true, parseError: 'not a JSON object', missing: [], foreign: [] };
+  }
+  const merge = mergeClaudeSettings(current, binPath);
+  return { present: true, missing: merge.added, foreign: merge.foreign };
+}
+
+/**
+ * Diagnose one Codex hooks file WITHOUT writing.
+ *
+ * @param {object} args
+ * @param {string} args.projectRoot
+ * @param {string} [args.binPath]
+ */
+export async function diagnoseCodexFeedbackHooks({ projectRoot, binPath } = {}) {
+  const file = join(projectRoot, '.codex', 'hooks.json');
+  const raw = await readIfExists(file);
+  if (raw === null) {
+    return { present: false, missing: FEEDBACK_HOOK_EVENTS.map((s) => s.codexEvent), foreign: [] };
+  }
+  let current;
+  try {
+    current = JSON.parse(raw);
+  } catch (err) {
+    return { present: true, parseError: err.message, missing: [], foreign: [] };
+  }
+  if (current === null || typeof current !== 'object' || Array.isArray(current)) {
+    return { present: true, parseError: 'not a JSON object', missing: [], foreign: [] };
+  }
+  const merge = mergeCodexHooks(current, binPath);
+  return { present: true, missing: merge.added, foreign: merge.foreign };
+}
+
+async function readIfExists(path) {
+  try {
+    return await readFile(path, 'utf8');
+  } catch (err) {
+    if (/** @type {NodeJS.ErrnoException} */ (err).code === 'ENOENT') return null;
+    throw err;
+  }
+}

package/src/setup/managed-gitignore.js

@@ -27,6 +27,8 @@ import { identityEntry } from './identity-seed.js';
 import { preflightEntry } from '../preflight/secrets.js';
 // Track C+D §9.3: gitignore the view-server pid file and supervisor log.
 import { viewServerGitignoreEntry, viewServerLogGitignoreEntry } from '../view-supervisor/manifest-writer.js';
+// FBS-180 slice 1: gitignore the local feedback log and outbox.
+import { feedbackGitignoreEntry } from '../feedback/store.js';
 
 /**
  * @typedef {object} GitignoreEntry
@@ -53,6 +55,7 @@ export function managedGitignoreEntries() {
     preflightEntry,
     viewServerGitignoreEntry,
     viewServerLogGitignoreEntry,
+    feedbackGitignoreEntry,
   ];
 }
 

package/src/view/html-page.js

@@ -28,12 +28,12 @@ import {
 import { detailsWrap, escapeHtml } from './doc-renderers/helpers.js';
 import { allRequirementSubdiagrams } from './mermaid-diagram.js';
 
-// Inline SVG favicon: the Stravica monogram (terracotta rounded-square with
-// cream serif S), pinched from stravica.ai/assets/brand/logo-monogram.svg
-// so the review surface shares brand identity with the marketing site.
-// Delivered as a data URL so no separate file has to ship.
+// Inline SVG favicon: the Stravica kit mark (deep-navy tile with the
+// ribbon symbol in Stravica blue), taken from the estate brand kit at
+// public/brand/assets/icons/favicon.svg so the review surface shares
+// identity with stravica.ai. Delivered as a data URL so no separate file has to ship.
 const FAVICON_HREF =
-  "data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 512 512'%3E%3Crect width='512' height='512' rx='64' fill='%23c14a3a'/%3E%3Ctext x='256' y='370' font-family='Georgia,serif' font-size='360' font-weight='600' text-anchor='middle' fill='%23f7f5f0'%3ES%3C/text%3E%3C/svg%3E";
+  "data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 64 64' width='64' height='64' role='img'%3E%3Ctitle%3EStravica favicon%3C/title%3E%3Cdesc%3E%3C/desc%3E%3Crect x='0' y='0' width='64' height='64' rx='14' fill='%23080F19'/%3E%3Cg fill='%237295FF'%3E%3Cpath d='M38 9L17 21V32L38 20Z'/%3E%3Cpath d='M30 27L46 36V46L30 37L23 33Z'/%3E%3Cpath d='M46 46L25 58V47L37 40Z'/%3E%3C/g%3E%3C/svg%3E";
 
 const LIVE_WRAPPER_OPEN = '<div id="rcf-live-content">';
 const LIVE_WRAPPER_CLOSE = '</div>';

package/src/view/style.css

@@ -99,7 +99,7 @@ header h1 {
   gap: 0.75rem;
 }
 
-/* Stravica monogram alongside the project name - shared identity with
+/* Stravica kit mark alongside the project name, shared identity with
  * the marketing site (stravica.ai). SVG is inlined as a data URL so no
  * separate asset has to ship. */
 header h1::before {
@@ -108,7 +108,7 @@ header h1::before {
   width: 2rem;
   height: 2rem;
   flex-shrink: 0;
-  background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 512 512'%3E%3Crect width='512' height='512' rx='64' fill='%23c14a3a'/%3E%3Ctext x='256' y='370' font-family='Georgia,serif' font-size='360' font-weight='600' text-anchor='middle' fill='%23f7f5f0'%3ES%3C/text%3E%3C/svg%3E");
+  background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 136 180' width='136' height='180' role='img'%3E%3Ctitle%3EStravica ribbon symbol%3C/title%3E%3Cdesc%3E%3C/desc%3E%3Cdefs%3E%3ClinearGradient id='ma' x1='0' y1='0' x2='1' y2='1'%3E%3Cstop stop-color='%23174CFF'/%3E%3Cstop offset='1' stop-color='%23263BFF'/%3E%3C/linearGradient%3E%3ClinearGradient id='mb' x1='0' y1='0' x2='1' y2='1'%3E%3Cstop stop-color='%231674FF'/%3E%3Cstop offset='1' stop-color='%232854FF'/%3E%3C/linearGradient%3E%3C/defs%3E%3Cg transform='translate(0 0) scale(1.0)'%3E%3Cpath fill='url(%23ma)' d='M86 4 L10 48 Q4 51 4 58 L4 81 Q4 87 10 84 L80 45 Q86 42 86 35 Z'/%3E%3Cpath fill='url(%23ma)' d='M88 108 L129 125 L47 172 Q41 176 41 170 L41 142 Q41 136 47 133 Z'/%3E%3Cpath fill='url(%23mb)' d='M41 84 L74 65 Q78 63 83 66 L124 88 Q130 91 130 98 L130 121 Q130 126 124 123 Z'/%3E%3C/g%3E%3C/svg%3E");
   background-repeat: no-repeat;
   background-position: center;
   background-size: contain;