fraim-framework 2.0.196 → 2.0.197

package/dist/src/ai-hub/brand-store.js

@@ -0,0 +1,232 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_LOGO_BYTES = exports.ORG_BRAND_FILENAME = void 0;
+exports.resolveBrandColor = resolveBrandColor;
+exports.relativeLuminance = relativeLuminance;
+exports.contrastRatio = contrastRatio;
+exports.hasSufficientContrast = hasSufficientContrast;
+exports.sanitizeSvg = sanitizeSvg;
+exports.sanitizeLogo = sanitizeLogo;
+exports.normalizeBrand = normalizeBrand;
+exports.serializeBrand = serializeBrand;
+exports.parseBrand = parseBrand;
+exports.readBrandFromDir = readBrandFromDir;
+exports.writeBrandToDir = writeBrandToDir;
+/**
+ * Org brand store — Issue #744 (Hub cobranding).
+ *
+ * Deterministic, dependency-free, AI-free logic (architecture-standards §1/§3):
+ * the org brand descriptor (company name, color, logo) is stored ALONGSIDE
+ * company info, in the same org context storage as `org_context.md`
+ * (manager directive, spec R7.4), as a single `org_brand.json` file.
+ *
+ * Security: a manager-supplied logo is a stored-XSS vector. `sanitizeSvg` uses a
+ * strict element/attribute allowlist (not a denylist) and drops scripts, event
+ * handlers, external references, styles, and any non-graphical element, so the
+ * stored logo is safe to inline in the Hub (spec Compliance: SOC2/ISO27001).
+ */
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/** File name of the brand descriptor, stored next to org_context.md. */
+exports.ORG_BRAND_FILENAME = 'org_brand.json';
+/** Max stored logo size (sanitized SVG markup or data: URI), in bytes. */
+exports.MAX_LOGO_BYTES = 512 * 1024;
+// ── Color ───────────────────────────────────────────────────────────────────
+/**
+ * Normalize a hex color to lowercase `#rrggbb`, expanding `#rgb`. Returns null
+ * for anything that is not a valid 3- or 6-digit hex (named colors, functions,
+ * and injection attempts are rejected).
+ */
+function resolveBrandColor(input) {
+    if (typeof input !== 'string')
+        return null;
+    const raw = input.trim().replace(/^#/, '').toLowerCase();
+    if (/^[0-9a-f]{3}$/.test(raw)) {
+        return '#' + raw.split('').map((c) => c + c).join('');
+    }
+    if (/^[0-9a-f]{6}$/.test(raw)) {
+        return '#' + raw;
+    }
+    return null;
+}
+function hexToRgb(hex) {
+    const norm = resolveBrandColor(hex);
+    if (!norm)
+        return null;
+    const n = norm.slice(1);
+    return [parseInt(n.slice(0, 2), 16), parseInt(n.slice(2, 4), 16), parseInt(n.slice(4, 6), 16)];
+}
+/** WCAG relative luminance of an sRGB color. */
+function relativeLuminance(hex) {
+    const rgb = hexToRgb(hex);
+    if (!rgb)
+        return 0;
+    const [r, g, b] = rgb.map((v) => {
+        const s = v / 255;
+        return s <= 0.03928 ? s / 12.92 : Math.pow((s + 0.055) / 1.055, 2.4);
+    });
+    return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+}
+/** WCAG contrast ratio between two colors (1..21). */
+function contrastRatio(a, b) {
+    const la = relativeLuminance(a);
+    const lb = relativeLuminance(b);
+    const lighter = Math.max(la, lb);
+    const darker = Math.min(la, lb);
+    return (lighter + 0.05) / (darker + 0.05);
+}
+/**
+ * True when `color` is readable as a UI accent against `background`. Uses the
+ * WCAG 3:1 threshold for graphical/large UI objects (the accent is used on
+ * filled buttons and tab underlines, not as body text). Guards R2.3 so an
+ * unreadable brand color never ships; callers fall back to the FRAIM accent.
+ */
+function hasSufficientContrast(color, background, min = 3.0) {
+    if (!resolveBrandColor(color) || !resolveBrandColor(background))
+        return false;
+    return contrastRatio(color, background) >= min;
+}
+// ── SVG sanitization (allowlist) ──────────────────────────────────────────────
+/** Only these elements survive sanitization. */
+const ALLOWED_SVG_TAGS = new Set([
+    'svg', 'g', 'path', 'rect', 'circle', 'ellipse', 'line', 'polyline', 'polygon',
+    'text', 'tspan', 'defs', 'lineargradient', 'radialgradient', 'stop', 'title', 'desc',
+]);
+/** Only these attributes survive; everything else (incl. on*, href, style) is dropped. */
+const ALLOWED_SVG_ATTRS = new Set([
+    'viewbox', 'xmlns', 'width', 'height', 'fill', 'fill-rule', 'fill-opacity', 'stroke',
+    'stroke-width', 'stroke-linecap', 'stroke-linejoin', 'stroke-dasharray', 'stroke-opacity',
+    'opacity', 'd', 'points', 'x', 'y', 'x1', 'y1', 'x2', 'y2', 'cx', 'cy', 'r', 'rx', 'ry',
+    'transform', 'offset', 'stop-color', 'stop-opacity', 'gradientunits', 'gradienttransform',
+    'font-family', 'font-size', 'font-weight', 'text-anchor', 'letter-spacing',
+]);
+/**
+ * Sanitize an SVG string via a strict allowlist. Returns safe SVG markup, or ''
+ * if the input is not an <svg> document. Removes: <script>, <foreignObject>,
+ * <image>, <use>, <a>, comments/PIs/DOCTYPE, all event handlers, all href /
+ * xlink:href, inline styles, and any element or attribute not on the allowlist.
+ */
+function sanitizeSvg(input) {
+    if (typeof input !== 'string')
+        return '';
+    // Bound the work up front so a pathological logo can't drive the tag-walk
+    // regex into catastrophic backtracking (DoS guard).
+    if (input.length > exports.MAX_LOGO_BYTES)
+        return '';
+    let s = input.trim();
+    if (!/^<svg[\s>]/i.test(s))
+        return '';
+    // Drop comments, CDATA, processing instructions, and DOCTYPE outright.
+    s = s.replace(/<!--[\s\S]*?-->/g, '');
+    s = s.replace(/<!\[CDATA\[[\s\S]*?\]\]>/g, '');
+    s = s.replace(/<\?[\s\S]*?\?>/g, '');
+    s = s.replace(/<!DOCTYPE[\s\S]*?>/gi, '');
+    // Drop dangerous elements and their entire content.
+    s = s.replace(/<(script|style|foreignObject|iframe|use|image|a)\b[\s\S]*?<\/\1\s*>/gi, '');
+    // Drop self-closing / unclosed variants of the same dangerous elements.
+    s = s.replace(/<(script|style|foreignObject|iframe|use|image|a)\b[^>]*\/?>/gi, '');
+    // Walk every remaining tag; drop non-allowlisted elements and attributes.
+    s = s.replace(/<\/?([a-zA-Z][\w:-]*)((?:[^>"']|"[^"]*"|'[^']*')*)>/g, (full, rawName, rawAttrs) => {
+        const name = rawName.toLowerCase().replace(/^svg:/, '');
+        if (!ALLOWED_SVG_TAGS.has(name))
+            return '';
+        const isClose = /^<\//.test(full);
+        if (isClose)
+            return `</${name}>`;
+        const selfClose = /\/>$/.test(full);
+        const attrs = [];
+        const attrRe = /([a-zA-Z_:][\w:.-]*)\s*=\s*("([^"]*)"|'([^']*)')/g;
+        let m;
+        while ((m = attrRe.exec(rawAttrs)) !== null) {
+            const attr = m[1].toLowerCase().replace(/^xml:/, '');
+            const value = m[3] !== undefined ? m[3] : m[4] || '';
+            if (!ALLOWED_SVG_ATTRS.has(attr))
+                continue;
+            // Defense in depth: never allow url()/javascript:/data: sneaking through a value.
+            if (/javascript:|url\s*\(|data:|expression\s*\(|<|>/i.test(value))
+                continue;
+            attrs.push(`${attr}="${value.replace(/"/g, '&quot;')}"`);
+        }
+        const attrStr = attrs.length ? ' ' + attrs.join(' ') : '';
+        return `<${name}${attrStr}${selfClose ? '/' : ''}>`;
+    });
+    // If sanitization emptied the root, treat as invalid.
+    if (!/^<svg[\s>]/i.test(s.trim()))
+        return '';
+    return s.trim();
+}
+/** Accept only png/jpeg data URIs (sanitized SVG is handled separately). */
+function isSafeRasterDataUri(s) {
+    return /^data:image\/(png|jpe?g);base64,[a-z0-9+/=\s]+$/i.test(s);
+}
+/** Sanitize a logo value: SVG markup -> sanitized SVG; png/jpeg data URI -> kept; else ''. */
+function sanitizeLogo(input) {
+    if (typeof input !== 'string' || !input.trim())
+        return '';
+    const s = input.trim();
+    if (/^<svg[\s>]/i.test(s)) {
+        const clean = sanitizeSvg(s);
+        return clean.length <= exports.MAX_LOGO_BYTES ? clean : '';
+    }
+    if (isSafeRasterDataUri(s)) {
+        return s.length <= exports.MAX_LOGO_BYTES ? s : '';
+    }
+    return '';
+}
+// ── Serialize / parse ─────────────────────────────────────────────────────────
+/** Normalize + sanitize a brand into its safe stored form. */
+function normalizeBrand(brand) {
+    const out = {};
+    if (typeof brand.name === 'string' && brand.name.trim()) {
+        out.name = brand.name.trim().slice(0, 120);
+    }
+    const color = resolveBrandColor(brand.color);
+    if (color)
+        out.color = color;
+    const logo = sanitizeLogo(brand.logo);
+    if (logo)
+        out.logo = logo;
+    return out;
+}
+function serializeBrand(brand) {
+    return JSON.stringify(normalizeBrand(brand), null, 2);
+}
+/** Parse a brand JSON string into a normalized OrgBrand, or null on any error. */
+function parseBrand(json) {
+    if (typeof json !== 'string' || !json.trim())
+        return null;
+    let obj;
+    try {
+        obj = JSON.parse(json);
+    }
+    catch {
+        return null;
+    }
+    if (!obj || typeof obj !== 'object')
+        return null;
+    const norm = normalizeBrand(obj);
+    return Object.keys(norm).length ? norm : null;
+}
+// ── Directory read / write ─────────────────────────────────────────────────────
+/** Read + normalize the brand from `<dir>/org_brand.json`, or null when absent/invalid. */
+function readBrandFromDir(dir) {
+    try {
+        const file = path_1.default.join(dir, exports.ORG_BRAND_FILENAME);
+        if (!fs_1.default.existsSync(file))
+            return null;
+        return parseBrand(fs_1.default.readFileSync(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+/** Sanitize + normalize a brand and write it to `<dir>/org_brand.json`. Returns the stored brand. */
+function writeBrandToDir(dir, brand) {
+    const normalized = normalizeBrand(brand);
+    fs_1.default.mkdirSync(dir, { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(dir, exports.ORG_BRAND_FILENAME), JSON.stringify(normalized, null, 2), 'utf8');
+    return normalized;
+}

package/dist/src/ai-hub/server.js

@@ -49,6 +49,7 @@ const child_process_1 = require("child_process");
 const https_1 = __importDefault(require("https"));
 const types_1 = require("../first-run/types");
 const learning_context_builder_1 = require("../local-mcp-server/learning-context-builder");
+const brand_store_1 = require("./brand-store");
 const project_fraim_paths_1 = require("../core/utils/project-fraim-paths");
 const catalog_1 = require("./catalog");
 const agent_token_prices_1 = require("../local-mcp-server/agent-token-prices");
@@ -1447,6 +1448,9 @@ class AiHubServer {
             // #533: the resolved account email, so the profile card shows the real
             // identity (not a hardcoded placeholder) and the client can display it.
             userEmail: getHubUserEmail(),
+            // #744: the org cobrand identity (name/color/logo) from the org context
+            // storage, or null when unset so the Hub falls back to FRAIM identity.
+            orgBrand: (0, learning_context_builder_1.readOrgBrand)(normalizedProjectPath),
             assignments: { byProject: {}, source: 'client-localStorage' },
             // Issue #538 — source of truth for the "Hire a human manager" UI. Lazy-required
             // (not a top-level import) so the lightweight client CLI paths that import this
@@ -2302,7 +2306,15 @@ class AiHubServer {
                 ? path_1.default.resolve(req.query.projectPath)
                 : this.projectPath;
             const known = this.knownProjects(projectPath);
-            const entry = known.find((project) => project.id === req.params.id);
+            // Match by id, falling back to the canonical folderPath. The client and server
+            // hash a path to an id with different algorithms, and the client mints its own id
+            // for the CURRENT project (tfEnsureCurrentProject), so a delete-by-id can carry an
+            // id the server never assigned — the folderPath is the true project identity (#726).
+            const requestedFolderPath = typeof req.query.folderPath === 'string' && req.query.folderPath.length > 0
+                ? req.query.folderPath
+                : null;
+            const entry = known.find((project) => project.id === req.params.id)
+                || (requestedFolderPath ? known.find((project) => sameDirectoryPath(project.folderPath, requestedFolderPath)) : undefined);
             if (!entry)
                 return res.status(404).json({ error: 'Project not found.' });
             // The current projectPath is unconditionally re-injected on every load, so
@@ -2443,6 +2455,45 @@ class AiHubServer {
             // Re-read so the client gets the canonical post-write state (present flips).
             return res.json(readContextFile(projectPath, body.key));
         });
+        // Issue #744 — Hub cobranding.
+        // GET  /api/ai-hub/brand  → { brand: OrgBrand | null } resolved from the org
+        //   context storage (same layering as org_context.md).
+        // POST /api/ai-hub/brand  { name?, color?, logo?, projectPath? }  → sanitizes
+        //   + normalizes (SVG allowlist, hex normalize) and persists org_brand.json to
+        //   the org context write location. Loopback-only; write is constrained under
+        //   a personalized-employee/ directory (same path-traversal guard as context).
+        this.app.get('/api/ai-hub/brand', (req, res) => {
+            const projectPath = typeof req.query.projectPath === 'string' && req.query.projectPath.length > 0
+                ? path_1.default.resolve(req.query.projectPath)
+                : this.projectPath;
+            return res.json({ brand: (0, learning_context_builder_1.readOrgBrand)(projectPath) });
+        });
+        this.app.post('/api/ai-hub/brand', (req, res) => {
+            const body = (req.body ?? {});
+            const projectPath = typeof body.projectPath === 'string' && body.projectPath.length > 0
+                ? path_1.default.resolve(body.projectPath)
+                : this.projectPath;
+            const input = {
+                name: typeof body.name === 'string' ? body.name : undefined,
+                color: typeof body.color === 'string' ? body.color : undefined,
+                logo: typeof body.logo === 'string' ? body.logo : undefined,
+            };
+            const dest = path_1.default.resolve((0, learning_context_builder_1.resolveOrgBrandWriteDir)(projectPath));
+            // Path-traversal guard: the write dir must live under a personalized-employee
+            // directory (matches the context write guard; never the managed org cache).
+            if (!dest.split(path_1.default.sep).includes('personalized-employee')) {
+                return res.status(403).json({ error: 'Brand write destination outside personalized-employee.' });
+            }
+            try {
+                // writeBrandToDir sanitizes the logo (SVG allowlist) and normalizes the
+                // color before persisting, so unsafe input never reaches disk.
+                const stored = (0, brand_store_1.writeBrandToDir)(dest, input);
+                return res.json({ brand: stored });
+            }
+            catch (err) {
+                return res.status(500).json({ error: err instanceof Error ? err.message : 'Brand write failed.' });
+            }
+        });
         this.app.post('/api/ai-hub/artifact/open', async (req, res) => {
             const rawPath = typeof req.body?.path === 'string' ? req.body.path : '';
             const projectPath = typeof req.body?.projectPath === 'string' && req.body.projectPath.length > 0

package/dist/src/cli/utils/org-pack-sync.js

@@ -4,6 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ORG_CACHE_MANAGED_HEADER = exports.ORG_SYNC_METADATA_FILE = exports.ORG_CACHE_DIRNAME = void 0;
+exports.isSafePackPath = isSafePackPath;
+exports.shouldDecorateAsMarkdown = shouldDecorateAsMarkdown;
 exports.getOrgCacheDir = getOrgCacheDir;
 exports.readOrgCacheMetadata = readOrgCacheMetadata;
 exports.getOrgCacheAgeHours = getOrgCacheAgeHours;
@@ -37,6 +39,28 @@ const ORG_PACK_DIRS = ['context', 'rules', 'learnings'];
  * backend response can never write outside the cache directory.
  */
 const SAFE_PACK_RELATIVE_PATH = /^(context|rules|learnings)\/[\w.-]+\.md$/;
+/**
+ * Issue #744: the org brand descriptor is stored ALONGSIDE company info, in the
+ * same org context scope as org_context.md, as a single JSON file. Allow exactly
+ * that path (not arbitrary JSON) so cobranding syncs like org context.
+ */
+const ORG_BRAND_PACK_PATH = 'context/org_brand.json';
+/**
+ * True when a pack-relative path is safe to materialize: a markdown file inside
+ * one of the three org pack dirs, or the org brand descriptor. A single guard
+ * shared by the git and cloud paths.
+ */
+function isSafePackPath(relativePath) {
+    return SAFE_PACK_RELATIVE_PATH.test(relativePath) || relativePath === ORG_BRAND_PACK_PATH;
+}
+/**
+ * Managed-content decoration prepends a markdown "synced from your org" header.
+ * It must only touch markdown — prepending it to org_brand.json would corrupt
+ * the JSON (#744).
+ */
+function shouldDecorateAsMarkdown(relativePath) {
+    return relativePath.toLowerCase().endsWith('.md');
+}
 function getOrgCacheDir() {
     return path_1.default.join((0, project_fraim_paths_1.getUserFraimDirPath)(), exports.ORG_CACHE_DIRNAME);
 }
@@ -83,10 +107,12 @@ function collectGitPackFiles(snapshotDir) {
         if (!fs_1.default.existsSync(dirPath))
             continue;
         for (const entry of fs_1.default.readdirSync(dirPath, { withFileTypes: true })) {
-            if (!entry.isFile() || !entry.name.endsWith('.md'))
+            const relativePath = `${dirName}/${entry.name}`;
+            // Markdown in any pack dir, plus the org brand descriptor (#744).
+            if (!entry.isFile() || !isSafePackPath(relativePath))
                 continue;
             files.push({
-                relativePath: `${dirName}/${entry.name}`,
+                relativePath,
                 content: fs_1.default.readFileSync(path_1.default.join(dirPath, entry.name), 'utf8')
             });
         }
@@ -101,7 +127,7 @@ async function fetchCloudPack(remoteUrl, apiKey) {
     const files = Array.isArray(response.data?.files) ? response.data.files : [];
     return {
         files: files.filter((f) => typeof f?.relativePath === 'string' &&
-            SAFE_PACK_RELATIVE_PATH.test(f.relativePath) &&
+            isSafePackPath(f.relativePath) &&
             typeof f?.content === 'string'),
         version: String(response.data?.version ?? '0')
     };
@@ -113,11 +139,15 @@ function materializeCache(files, metadata) {
     fs_1.default.rmSync(stagingDir, { recursive: true, force: true });
     fs_1.default.mkdirSync(stagingDir, { recursive: true });
     for (const file of files) {
-        if (!SAFE_PACK_RELATIVE_PATH.test(file.relativePath))
+        if (!isSafePackPath(file.relativePath))
             continue;
         const destination = path_1.default.join(stagingDir, file.relativePath);
         fs_1.default.mkdirSync(path_1.default.dirname(destination), { recursive: true });
-        fs_1.default.writeFileSync(destination, decorateManagedOrgFile(file.content, metadata.backend));
+        // #744: only markdown gets the managed-content header; JSON is written verbatim.
+        const content = shouldDecorateAsMarkdown(file.relativePath)
+            ? decorateManagedOrgFile(file.content, metadata.backend)
+            : file.content;
+        fs_1.default.writeFileSync(destination, content);
     }
     fs_1.default.writeFileSync(path_1.default.join(stagingDir, exports.ORG_SYNC_METADATA_FILE), JSON.stringify(metadata, null, 2));
     fs_1.default.rmSync(cacheDir, { recursive: true, force: true });

package/dist/src/first-run/types.js

@@ -52,7 +52,7 @@ exports.FIRST_RUN_AGENT_OPTIONS = [
     },
     {
         id: 'copilot-cli',
-        label: 'GitHub Copilot',
+        label: 'GitHub Copilot CLI',
         detectAliases: ['copilot', 'copilot-cli', 'github copilot cli'],
         loginCommand: 'copilot login',
         launchCommand: 'copilot',

package/dist/src/local-mcp-server/learning-context-builder.js

@@ -14,6 +14,8 @@ exports.buildTeamContextSection = buildTeamContextSection;
 exports.resolveTeamContextFiles = resolveTeamContextFiles;
 exports.isTeamContextKey = isTeamContextKey;
 exports.resolveTeamContextFile = resolveTeamContextFile;
+exports.readOrgBrand = readOrgBrand;
+exports.resolveOrgBrandWriteDir = resolveOrgBrandWriteDir;
 exports.countPreservedLearnings = countPreservedLearnings;
 exports.readPreservedLearnings = readPreservedLearnings;
 exports.applyLearningEntryChange = applyLearningEntryChange;
@@ -21,6 +23,7 @@ exports.isTruthyFlag = isTruthyFlag;
 const fs_1 = require("fs");
 const path_1 = require("path");
 const project_fraim_paths_1 = require("../core/utils/project-fraim-paths");
+const brand_store_1 = require("../ai-hub/brand-store");
 const REPO_LEARNINGS_REL = (0, project_fraim_paths_1.getWorkspaceFraimDisplayPath)('personalized-employee/learnings').replace(/\/$/, '');
 const DEFAULT_THRESHOLD = 3.0;
 const AGING_HORIZON_DAYS = 7;
@@ -695,6 +698,44 @@ function resolveTeamContextFile(workspaceRoot, key) {
         scope
     };
 }
+// ---------------------------------------------------------------------------
+// Issue #744 — Org brand (Hub cobranding).
+//
+// The brand descriptor (company name/logo/color) is stored ALONGSIDE company
+// info, in the SAME org context storage as org_context.md (manager directive,
+// spec R7.4), as `context/org_brand.json`. Read resolves with the same org-scope
+// layering as org context (repo-local override → synced org cache → user-level);
+// writes target the same writable location org context edits use.
+// ---------------------------------------------------------------------------
+/** Ordered directories to look for org_brand.json, mirroring org-context layering. */
+function orgBrandCandidateDirs(workspaceRoot) {
+    return [
+        (0, path_1.join)((0, project_fraim_paths_1.getWorkspaceFraimDir)(workspaceRoot), 'personalized-employee', 'context'),
+        (0, path_1.join)((0, project_fraim_paths_1.getUserFraimDirPath)(), 'org', 'context'),
+        (0, path_1.join)((0, project_fraim_paths_1.getUserFraimDirPath)(), 'personalized-employee', 'context'),
+    ];
+}
+/** Read the resolved org brand, or null when none is set on this machine. */
+function readOrgBrand(workspaceRoot) {
+    for (const dir of orgBrandCandidateDirs(workspaceRoot)) {
+        const brand = (0, brand_store_1.readBrandFromDir)(dir);
+        if (brand)
+            return brand;
+    }
+    return null;
+}
+/**
+ * Directory an org-brand edit should be written to. Mirrors org-context write
+ * resolution: the repo-local override dir when the repo carries its own org
+ * context, otherwise the portable user-level context dir (where org onboarding
+ * writes). Never the synced org cache (managed, overwritten on sync).
+ */
+function resolveOrgBrandWriteDir(workspaceRoot) {
+    const loc = resolveTeamContextFile(workspaceRoot, 'org');
+    if (loc.writePath)
+        return (0, path_1.dirname)(loc.writePath);
+    return (0, path_1.join)((0, project_fraim_paths_1.getUserFraimDirPath)(), 'personalized-employee', 'context');
+}
 /**
  * Count the number of `## [P-...]`-style entries inside a preserved learning
  * file. Returns 0 when the file is absent or unreadable. Counts ALL entries

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fraim-framework",
-  "version": "2.0.196",
+  "version": "2.0.197",
   "description": "FRAIM: AI Workforce Infrastructure — the organizational capability that turns AI agents into an accountable workforce, their operators into capable AI managers, and executives into leaders with clear optics on AI proficiency.",
   "main": "index.js",
   "bin": {

package/public/ai-hub/index.html

@@ -12,6 +12,9 @@
     // #700: set the theme pre-paint (no flash). Explicit choice in
     // localStorage wins; otherwise follow the OS preference.
     try{var t=localStorage.getItem('fraim-theme');if(t!=='light'&&t!=='dark'){t=(window.matchMedia&&window.matchMedia('(prefers-color-scheme: dark)').matches)?'dark':'light';}h.setAttribute('data-theme',t);}catch(e){h.setAttribute('data-theme','light');}
+    // #744: apply the cached org brand pre-paint (no flash of FRAIM identity
+    // before company branding). script.js refines the per-theme accent on load.
+    try{var b=JSON.parse(localStorage.getItem('fraim-org-brand')||'null');if(b){if(typeof b.color==='string'&&/^#[0-9a-f]{6}$/i.test(b.color)){h.style.setProperty('--accent',b.color);h.style.setProperty('--accent-strong',b.color);}if(typeof b.name==='string'&&b.name){document.title=b.name+' Hub';}}}catch(e){}
   })();</script>
   <link rel="stylesheet" href="./styles.css?v=conv-panels-20260611b">
   <link rel="stylesheet" href="./review.css">
@@ -20,10 +23,15 @@
 
   <!-- Issue #512: three-area top nav + account menu (surface=hub only). -->
   <nav class="hub-tabs" id="hub-tabs" hidden>
+    <!-- #744: company brand lockup (logo + name), populated from bootstrap.orgBrand. -->
+    <span class="hub-brand" id="hub-brand" hidden></span>
+    <span class="hub-brand-divider" id="hub-brand-divider" hidden></span>
     <button class="hub-tab" type="button" data-area="company">Company</button>
     <button class="hub-tab" type="button" data-area="manager">Manager</button>
     <button class="hub-tab on" type="button" data-area="projects">Projects</button>
     <div class="nav-right">
+      <!-- #744: FRAIM co-mark (co-branding, not white-label) shown when a brand is set. -->
+      <span class="hub-cobrand" id="hub-cobrand" hidden></span>
       <button class="avatar-btn" id="avatar-btn" type="button" title="Account &amp; settings">SM</button>
       <div id="account-menu" class="account-menu">
         <div class="am-header">
@@ -68,6 +76,12 @@
             <div class="area-h1">Company</div>
             <p class="area-lede">Your organization's identity — what you do, how you operate, and the guardrails every employee follows on every job.</p>
             <div id="company-push-banner"></div>
+            <!-- #744: Brand editor — company identity across the Hub. -->
+            <details class="ctx-acc" id="company-brand-acc">
+              <summary><span class="ca-chev">▸</span> <span>🎨 Brand</span>
+                <span class="ca-note">— your company's identity across the Hub, applied for every teammate</span></summary>
+              <div class="ctx-acc-body"><div class="card area-profile" id="company-brand-editor"></div></div>
+            </details>
             <details class="ctx-acc" id="company-ctx-acc">
               <summary><span class="ca-chev">▸</span> <span>🏢 Context &amp; rules</span></summary>
               <div class="ctx-acc-body"><div class="card area-profile" id="company-profile"></div></div>
@@ -199,6 +213,7 @@
           <!-- Onboarding state banner lives ABOVE the accordions so it shows even
                when the Brief is collapsed (so the conversation keeps its height). -->
           <div id="proj-onboarding-banner"></div>
+          <div id="hub-agent-setup-panel" class="hub-agent-setup-panel" data-testid="hub-cli-setup-panel" hidden></div>
           <details class="ctx-acc" id="proj-brief-acc">
             <summary><span class="ca-chev">▸</span> <span>📋 Brief</span>
               <span class="ca-note">— this project's context and rules, captured by Project Onboarding</span></summary>
@@ -839,6 +854,7 @@
         <span class="cp-agent-label">Run with:</span>
         <span id="cp-agent-picker" class="cp-agent-pills"></span>
       </div>
+      <div id="cp-agent-install-panel" class="cp-agent-install-panel" data-testid="cp-cli-setup-panel" hidden></div>
     </div>
   </div>
 
@@ -868,6 +884,6 @@
     </div>
   </div>
 
-  <script src="./script.js?v=conv-persist-20260705"></script>
+  <script src="./script.js?v=persona-mgr-del-20260707"></script>
 </body>
 </html>