@nonbot/mcp 0.2.4 → 0.3.1

package/dist/core/satellites.js

@@ -0,0 +1,89 @@
+export const INNER_LOOP_GAP = 16;
+export const INNER_LOOP_Y_OFFSET = 40;
+export const INNER_LOOP_COLLAPSED_HEIGHT = 44;
+export const INNER_LOOP_FIELDS = [
+    'epicColor', 'nodeDisplay', 'artifact', 'whyGraph', 'description', 'hypothesisStatement', 'acceptanceCriteria', 'bluf',
+    'lbcProblem', 'lbcBenefitHypothesis', 'lbcLeadingIndicators', 'lbcNfrs', 'mvpDefinition', 'outcomeMetrics', 'owner',
+    'tags', 'confidenceVote', 'approvalRating', 'mockupSvg', 'character', 'location',
+];
+export const SATELLITE_FIELDS = {
+    epicColor: { label: 'Color', width: 120, height: 100, retired: true },
+    nodeDisplay: { label: 'Display', width: 520, height: 180 },
+    artifact: { label: 'Statement', width: 300, height: 260 },
+    whyGraph: { label: 'WhyGraph', width: 260, height: 120, levels: ['epic', 'feature', 'story', 'enabler', 'objective', 'key-result'] },
+    description: { label: 'Description', width: 180, height: 120 },
+    hypothesisStatement: { label: 'Hypothesis', width: 180, height: 120, levels: ['epic', 'objective'] },
+    acceptanceCriteria: { label: 'Acceptance Criteria', width: 180, height: 120 },
+    bluf: { label: 'BLUF', width: 160, height: 110 },
+    lbcProblem: { label: 'LBC: Problem', width: 170, height: 120, levels: ['epic'] },
+    lbcBenefitHypothesis: { label: 'Benefit Hypothesis', width: 170, height: 120, levels: ['epic'] },
+    lbcLeadingIndicators: { label: 'Leading Indicators', width: 170, height: 120, levels: ['epic'] },
+    lbcNfrs: { label: 'NFRs', width: 150, height: 110, levels: ['epic'] },
+    mvpDefinition: { label: 'MVP Definition', width: 170, height: 120, levels: ['epic'] },
+    outcomeMetrics: { label: 'Outcome Metrics', width: 170, height: 120, levels: ['epic', 'objective', 'key-result'] },
+    owner: { label: 'Owner', width: 130, height: 80 },
+    tags: { label: 'Tags', width: 140, height: 80 },
+    confidenceVote: { label: 'Confidence', width: 120, height: 80 },
+    approvalRating: { label: 'Approval', width: 120, height: 80 },
+    mockupSvg: { label: 'Wireframe', width: 200, height: 160 },
+    character: { label: 'Character', width: 150, height: 160, levels: ['epic'] },
+    location: { label: 'Location', width: 150, height: 160, levels: ['epic'] },
+};
+const DEFAULT_FIELDS = ['nodeDisplay', 'artifact', 'description'];
+const DEFAULT_FIELDS_BY_LEVEL = {
+    enabler: ['nodeDisplay', 'artifact', 'description', 'owner'],
+    milestone: ['nodeDisplay', 'artifact', 'description', 'owner', 'tags'],
+    objective: ['nodeDisplay', 'artifact', 'description', 'outcomeMetrics', 'owner'],
+    'key-result': ['nodeDisplay', 'artifact', 'outcomeMetrics', 'description', 'owner'],
+};
+export const HOST_DEFAULT_HEIGHT = { epic: 120, feature: 110, story: 100, enabler: 100, milestone: 120, objective: 130, 'key-result': 110 };
+const HOST_LEVELS = new Set(Object.keys(HOST_DEFAULT_HEIGHT));
+export const canHostInnerLoop = (d) => !!d && !d.childCardType && HOST_LEVELS.has(String(d.hierarchyLevel ?? ''));
+const allowed = (f, level) => {
+    const cfg = SATELLITE_FIELDS[f];
+    if (!cfg || cfg.retired)
+        return false;
+    return !cfg.levels || cfg.levels.includes(level);
+};
+export function activeSatelliteFields(d) {
+    if (!d || !canHostInnerLoop(d))
+        return [];
+    const level = String(d.hierarchyLevel);
+    const removed = new Set(Array.isArray(d.innerLoopRemovedFields) ? d.innerLoopRemovedFields : []);
+    const extras = Array.isArray(d.innerLoopExtraFields) ? d.innerLoopExtraFields : [];
+    const out = [];
+    for (const f of [...(DEFAULT_FIELDS_BY_LEVEL[level] ?? DEFAULT_FIELDS), ...extras]) {
+        if (!allowed(f, level) || removed.has(f) || out.includes(f))
+            continue;
+        out.push(f);
+    }
+    return out;
+}
+export function satelliteItems(d) {
+    const sizes = d?.innerLoopSizes ?? {};
+    return activeSatelliteFields(d).map(f => ({
+        field: f,
+        width: sizes[f]?.width || SATELLITE_FIELDS[f].width,
+        height: d?.subnodeCollapsed?.[f] ? INNER_LOOP_COLLAPSED_HEIGHT : sizes[f]?.height || SATELLITE_FIELDS[f].height,
+    }));
+}
+export const openSatellites = (d) => (d?.innerLoopExpanded === true ? satelliteItems(d) : []);
+export function satelliteRowWidth(d) {
+    const items = openSatellites(d);
+    return items.length ? items.reduce((s, i) => s + i.width, 0) + (items.length - 1) * INNER_LOOP_GAP : 0;
+}
+export function satelliteBandHeight(d, hostHeight) {
+    const items = openSatellites(d);
+    if (!items.length)
+        return 0;
+    const h = hostHeight && hostHeight > 0 ? hostHeight : HOST_DEFAULT_HEIGHT[String(d?.hierarchyLevel)] ?? 120;
+    return h + INNER_LOOP_Y_OFFSET + Math.max(...items.map(i => i.height));
+}
+export function satellitePositions(d, host) {
+    const items = openSatellites(d);
+    if (!items.length)
+        return [];
+    let x = host.x + host.width / 2 - satelliteRowWidth(d) / 2;
+    const y = host.y + host.height + INNER_LOOP_Y_OFFSET;
+    return items.map(i => { const p = { field: i.field, x, y, width: i.width, height: i.height }; x += i.width + INNER_LOOP_GAP; return p; });
+}

package/dist/core/server.d.ts

@@ -1,7 +1,7 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { ApiContext } from './config.js';
 export declare const SERVER_NAME = "nonbot-mcp";
-export declare const SERVER_VERSION = "0.2.4";
+export declare const SERVER_VERSION = "0.3.1";
 export declare const INSTRUCTIONS: string;
 export declare function registerAll(server: McpServer, ctx: ApiContext): void;
 export declare function createNonbotMcpServer(ctx: ApiContext): McpServer;

package/dist/core/server.js

@@ -2,6 +2,7 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { registerPortfolioTools } from './toolsets/portfolio.js';
 import { registerIpTools } from './toolsets/ip.js';
 import { registerBuildTools } from './toolsets/build.js';
+import { registerReleaseTools } from './toolsets/release.js';
 import { registerWhygraphTools } from './toolsets/whygraph.js';
 import { registerRunTools } from './toolsets/run.js';
 import { registerMonitorTools } from './toolsets/monitor.js';
@@ -9,16 +10,20 @@ import { registerRadbugsTools } from './toolsets/radbugs.js';
 import { registerResources } from './resources.js';
 import { registerPrompts } from './prompts.js';
 export const SERVER_NAME = 'nonbot-mcp';
-export const SERVER_VERSION = '0.2.4';
+export const SERVER_VERSION = '0.3.1';
 export const INSTRUCTIONS = [
     'non.bot MCP — work against the caller’s real product-management data, not a copy.',
     'Two domains: PORTFOLIOS (the SAFe portfolio canvas — epics → features → stories) and',
     'WHYGRAPH (the PM decision graph — the rules and decisions the team has committed to).',
     'Read before you write: call the *_list / *_get / *_search tools first.',
     'BUILDING: portfolio_create makes an empty portfolio; portfolio_add_items adds items of any level',
-    '(parents / OKR links / dependencies by id or by a key from the same call) and lays the Timeline out;',
-    'portfolio_patch_item changes one item; portfolio_layout re-lays everything; portfolio_set_meta sets',
+    '(parents / OKR links / dependencies by id or by a key from the same call) and lays it out in the Full Stack rows;',
+    'portfolio_patch_item changes one item; portfolio_layout re-lays everything (style packed / fullstack, or lane',
+    'for the releases); portfolio_set_meta sets',
     'context text and palette; portfolio_asset_upload stores an image; ip_create adds an IP node over its sources.',
+    'OWNERS: give every feature, story, enabler and milestone an owner so the human can see what is theirs —',
+    'the human’s name for work only a person can do (review or approve a plan, decide, buy, sign in, hand over a key,',
+    'test on a real device), owner "AI" for work an agent delivers (code, tests, migrations, docs, research).',
     'Whole-graph rewrites (restructures, deletes): portfolio_get for the graph + version, then portfolio_update',
     '(pass expectedVersion for safe concurrent editing).',
     'Before a non-trivial decision, call whygraph_context to surface the LAWs and prior',
@@ -29,11 +34,17 @@ export const INSTRUCTIONS = [
     'tokens with the explicit runs:respond scope only).',
     'IP NODES: ip_list / ip_get read a patent or trademark disclosure; ip_update edits it (op list + expected_version);',
     'ip_evidence_add adds evidence the SERVER hashes, timestamps and numbers — never send a hash or a time.',
-    'RADBUGS: radbug_file files a bug into the non.bot radBUGS inbox (needs the radbugs:write scope).',
+    'RELEASES: portfolio_completed_work says what got done in a window (rolled up, each date naming its clock);',
+    'portfolio_rebuild_done_work finds pointers (commits, closed radBUGS, comments) for done cards with no clock;',
+    'portfolio_propose_releases writes DRAFT releases (files nothing) and portfolio_release_approve files a draft\u2019s cards;',
+    'portfolio_release_create / _file / _unfile / _list manage releases directly. Filing never moves a card.',
+    'RADBUGS: radbug_file files a bug into the non.bot radBUGS inbox (needs the radbugs:write scope); radbug_list reads',
+    'them (site owner only).',
 ].join(' ');
 export function registerAll(server, ctx) {
     registerPortfolioTools(server, ctx);
     registerBuildTools(server, ctx);
+    registerReleaseTools(server, ctx);
     registerIpTools(server, ctx);
     registerWhygraphTools(server, ctx);
     registerRunTools(server, ctx);

package/dist/core/style.d.ts

@@ -0,0 +1,34 @@
+import { type Level, type LayoutNode } from './layout.js';
+import type { InnerLoopField } from './satellites.js';
+export declare const CARD_STYLES: readonly ["plain", "poster", "split", "image-top", "cover", "grid-2", "grid-4"];
+export declare const TITLE_SIZES: readonly ["sm", "md", "lg"];
+export declare const ACCENTS: readonly ["tint", "bar", "plain"];
+export declare const SHOW_KEYS: readonly ["bluf", "description", "acceptanceCriteria", "tags", "dates", "wsjf"];
+export declare const STATES: readonly ["funnel", "reviewing", "analyzing", "ready", "implementing", "done"];
+export interface StyleRule {
+    levels?: Level[];
+    states?: string[];
+    ids?: string[];
+    hasImage?: boolean;
+    artifacts?: boolean;
+    display?: {
+        cardStyle?: (typeof CARD_STYLES)[number];
+        titleSize?: (typeof TITLE_SIZES)[number];
+        accent?: (typeof ACCENTS)[number];
+        show?: Partial<Record<(typeof SHOW_KEYS)[number], boolean>>;
+    };
+    size?: {
+        width: number;
+        height: number;
+    } | 'auto';
+    satellites?: 'open' | 'close';
+    innerLoopRemovedFields?: InnerLoopField[];
+    epicColor?: string | null;
+}
+export interface StyleResult<T> {
+    nodes: T[];
+    matched: number;
+    changed: number;
+    perRule: number[];
+}
+export declare function applyStyleRules<T extends LayoutNode>(nodes: T[], rules: StyleRule[]): StyleResult<T>;

package/dist/core/style.js

@@ -0,0 +1,76 @@
+import { LEVELS } from './layout.js';
+export const CARD_STYLES = ['plain', 'poster', 'split', 'image-top', 'cover', 'grid-2', 'grid-4'];
+export const TITLE_SIZES = ['sm', 'md', 'lg'];
+export const ACCENTS = ['tint', 'bar', 'plain'];
+export const SHOW_KEYS = ['bluf', 'description', 'acceptanceCriteria', 'tags', 'dates', 'wsjf'];
+export const STATES = ['funnel', 'reviewing', 'analyzing', 'ready', 'implementing', 'done'];
+const hasImage = (n) => Array.isArray(n.data?.pastedImages) && n.data.pastedImages.length > 0;
+function matches(rule, n) {
+    if (n.type !== 'portfolio-item')
+        return false;
+    if (n.data?.childCardType && !rule.artifacts)
+        return false;
+    const level = LEVELS.includes(n.data?.hierarchyLevel) ? n.data.hierarchyLevel : 'story';
+    if (rule.levels && !rule.levels.includes(level))
+        return false;
+    if (rule.states && !rule.states.includes(String(n.data?.state ?? 'funnel')))
+        return false;
+    if (rule.ids && !rule.ids.includes(n.id))
+        return false;
+    if (rule.hasImage !== undefined && hasImage(n) !== rule.hasImage)
+        return false;
+    return true;
+}
+export function applyStyleRules(nodes, rules) {
+    const perRule = rules.map(() => 0);
+    const touched = new Set();
+    let changed = 0;
+    const out = nodes.map(n => {
+        let data = null;
+        rules.forEach((rule, i) => {
+            if (!matches(rule, n))
+                return;
+            perRule[i]++;
+            touched.add(n.id);
+            data ??= { ...(n.data ?? {}) };
+            if (rule.display) {
+                const prev = (data.nodeDisplay && typeof data.nodeDisplay === 'object') ? data.nodeDisplay : {};
+                const next = { ...prev };
+                if (rule.display.cardStyle)
+                    next.cardStyle = rule.display.cardStyle;
+                if (rule.display.titleSize)
+                    next.titleSize = rule.display.titleSize;
+                if (rule.display.accent)
+                    next.accent = rule.display.accent;
+                if (rule.display.show)
+                    next.show = { ...(prev.show ?? {}), ...rule.display.show };
+                data.nodeDisplay = next;
+            }
+            if (rule.size === 'auto')
+                delete data.canvasSize;
+            else if (rule.size)
+                data.canvasSize = { width: Math.round(rule.size.width), height: Math.round(rule.size.height) };
+            if (rule.satellites === 'close')
+                data.innerLoopExpanded = false;
+            else if (rule.satellites === 'open')
+                data.innerLoopExpanded = true;
+            if (rule.innerLoopRemovedFields)
+                data.innerLoopRemovedFields = [...new Set(rule.innerLoopRemovedFields)];
+            if (rule.epicColor === null) {
+                delete data.epicColor;
+                delete data.epicColorRef;
+            }
+            else if (rule.epicColor) {
+                data.epicColor = rule.epicColor.toUpperCase();
+                delete data.epicColorRef;
+            }
+        });
+        if (!data)
+            return n;
+        if (JSON.stringify(data) === JSON.stringify(n.data ?? {}))
+            return n;
+        changed++;
+        return { ...n, data };
+    });
+    return { nodes: out, matched: touched.size, changed, perRule };
+}

package/dist/core/toolsets/build.d.ts

@@ -2,18 +2,19 @@ import { z } from 'zod';
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { ApiContext } from '../config.js';
 import { type LayoutNode } from '../layout.js';
-type Node = LayoutNode & {
+import { type InnerLoopField } from '../satellites.js';
+export type Node = LayoutNode & {
     id: string;
     type?: string;
     data?: Record<string, any>;
 };
-type Edge = {
+export type Edge = {
     id: string;
     source: string;
     target: string;
     [k: string]: unknown;
 };
-interface Graph {
+export interface Graph {
     name: string;
     description: string;
     nodes: Node[];
@@ -23,15 +24,23 @@ interface Graph {
 }
 export declare const toHtml: (s: string) => string;
 export declare function newItemId(now?: number): string;
+export declare function loadGraph(ctx: ApiContext, id: string): Promise<Graph>;
+export declare function saveGraph(ctx: ApiContext, id: string, before: Graph, after: Graph, expectedVersion?: number): Promise<{
+    ok: true;
+    version?: number;
+} | {
+    ok: false;
+    message: string;
+}>;
 declare const itemSpec: z.ZodObject<{
     key: z.ZodOptional<z.ZodString>;
     level: z.ZodEnum<{
         epic: "epic";
-        objective: "objective";
-        "key-result": "key-result";
         feature: "feature";
         story: "story";
         enabler: "enabler";
+        objective: "objective";
+        "key-result": "key-result";
         milestone: "milestone";
     }>;
     title: z.ZodString;
@@ -67,7 +76,15 @@ declare const itemSpec: z.ZodObject<{
     fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>;
 type ItemSpec = z.infer<typeof itemSpec>;
-export declare function buildItems(g: Graph, specs: ItemSpec[], now?: Date): {
+export declare const AI_OWNER = "AI";
+export declare function ownerReport(specs: Array<Pick<ItemSpec, 'key' | 'level' | 'title' | 'owner'>>): {
+    owners: Record<string, number>;
+    unassigned: string[];
+};
+export declare const ADD_ITEMS_DEFAULT_LAYOUT: "fullstack";
+export type AddLayout = 'fullstack' | 'timeline' | 'none';
+export declare const FULLSTACK_FEATURE_REMOVED: InnerLoopField[];
+export declare function buildItems(g: Graph, specs: ItemSpec[], now?: Date, layout?: AddLayout): {
     nodes: Node[];
     edges: Edge[];
     ids: Record<string, string>;

package/dist/core/toolsets/build.js

@@ -1,8 +1,13 @@
 import { z } from 'zod';
 import { api, expectJson } from '../http.js';
 import { validateGraph } from '../validate.js';
-import { LEVELS, applyLayout, layoutTimeline, scheduleFields, todayColumn, columnOf, isItem, PX_PER_WEEK } from '../layout.js';
+import { LEVELS, applyLayout, layoutTimeline, layoutMapDetailed, applyMapLayout, layoutFullStack, applyFullStackTimeline, timelineRowOverlaps, mapBoxes, scheduleFields, todayColumn, columnOf, isItem, PX_PER_WEEK } from '../layout.js';
+import { INNER_LOOP_FIELDS } from '../satellites.js';
+import { layoutReleaseLane } from '../releases.js';
 import { emptyIp, IP_KINDS, IP_NODE_SIZE } from '../ipShape.js';
+import { withMapHeaders } from '../mapHeaders.js';
+import { renderPreviewSvg } from '../preview.js';
+import { applyStyleRules, CARD_STYLES, TITLE_SIZES, ACCENTS, SHOW_KEYS, STATES as STYLE_STATES } from '../style.js';
 const STATES = ['funnel', 'reviewing', 'analyzing', 'ready', 'implementing', 'done'];
 const OKR_STATUSES = ['on-track', 'at-risk', 'behind'];
 const RESERVED = new Set(['hierarchyLevel', 'parentItemId', 'linkedEpicIds', 'id', '__proto__', 'constructor', 'prototype']);
@@ -13,7 +18,7 @@ const fail = (msg) => ({ content: [{ type: 'text', text: msg }], isError: true }
 const escHtml = (s) => s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
 export const toHtml = (s) => /^\s*</.test(s) ? s : s.split(/\n{2,}/).map(p => `<p>${escHtml(p.trim()).replace(/\n/g, '<br>')}</p>`).join('');
 export function newItemId(now = Date.now()) { return `pf-${now}-${Math.random().toString(36).slice(2, 11)}`; }
-async function loadGraph(ctx, id) {
+export async function loadGraph(ctx, id) {
     const data = await expectJson(await api(ctx, `/api/portfolio/graph?id=${encodeURIComponent(id)}`), 'load portfolio');
     const g = (data.graph ?? data);
     return {
@@ -25,7 +30,7 @@ async function loadGraph(ctx, id) {
         version: typeof g.version === 'number' ? g.version : undefined,
     };
 }
-async function saveGraph(ctx, id, before, after, expectedVersion) {
+export async function saveGraph(ctx, id, before, after, expectedVersion) {
     const problems = validateGraph(after.nodes, after.edges);
     if (problems.length)
         return { ok: false, message: `Refusing to write — ${problems.length} problem(s):\n` + problems.map(p => `  - ${p}`).join('\n') };
@@ -63,7 +68,7 @@ const itemSpec = z.object({
     duration_weeks: z.number().min(0).max(156).optional().describe('Default: epic 8, feature 4, story 1, enabler 2, milestone 0, objective / key-result 12.'),
     tags: z.array(z.string().max(40)).max(20).optional(),
     wsjf: z.tuple([z.number(), z.number(), z.number(), z.number()]).optional().describe('[business value, time criticality, risk reduction, job size].'),
-    owner: z.string().max(80).optional(),
+    owner: z.string().max(80).optional().describe(`Who does this item — the Program view's lanes group by it. Set it on every feature / story / enabler / milestone: the human's name (as they appear in the portfolio, e.g. "Conrad") for work only a person can do — review or approve a plan, decide, buy, sign up, sign in, hand over a key, test on a real device, talk to a customer; "AI" for work an agent delivers — code, tests, migrations, docs, research, drafts. Spell it exactly "AI" so all agent work shares one lane.`),
     kr_target: z.string().max(200).optional(),
     kr_current: z.string().max(200).optional(),
     okr_status: z.enum(OKR_STATUSES).optional(),
@@ -74,7 +79,23 @@ const DEFAULT_WEEKS = { epic: 8, feature: 4, story: 1, enabler: 2, milestone: 0,
 const LEGAL_PARENT = {
     epic: [], objective: [], 'key-result': ['objective'], feature: ['epic'], story: ['feature', 'epic'], enabler: ['epic', 'feature'], milestone: ['epic', 'feature'],
 };
-export function buildItems(g, specs, now = new Date()) {
+export const AI_OWNER = 'AI';
+const WORK_LEVELS = new Set(['feature', 'story', 'enabler', 'milestone']);
+export function ownerReport(specs) {
+    const owners = {};
+    const unassigned = [];
+    for (const s of specs) {
+        const who = s.owner?.trim();
+        if (who)
+            owners[who] = (owners[who] ?? 0) + 1;
+        else if (WORK_LEVELS.has(s.level))
+            unassigned.push(s.key ?? s.title);
+    }
+    return { owners, unassigned };
+}
+export const ADD_ITEMS_DEFAULT_LAYOUT = 'fullstack';
+export const FULLSTACK_FEATURE_REMOVED = ['description', 'acceptanceCriteria'];
+export function buildItems(g, specs, now = new Date(), layout = ADD_ITEMS_DEFAULT_LAYOUT) {
     const errors = [];
     const ids = {};
     const t0 = now.getTime();
@@ -112,8 +133,8 @@ export function buildItems(g, specs, now = new Date()) {
             d.hypothesisStatement = s.hypothesis;
         if (s.tags)
             d.tags = s.tags;
-        if (s.owner)
-            d.owner = s.owner;
+        if (s.owner?.trim())
+            d.owner = s.owner.trim();
         if (s.wsjf)
             Object.assign(d, { wsjfBusinessValue: s.wsjf[0], wsjfTimeCriticality: s.wsjf[1], wsjfRiskReduction: s.wsjf[2], wsjfJobSize: s.wsjf[3] });
         if (s.kr_target)
@@ -124,7 +145,13 @@ export function buildItems(g, specs, now = new Date()) {
             d.okrStatus = s.okr_status;
         if (s.images?.length)
             d.pastedImages = s.images;
-        if (s.level === 'epic')
+        if (layout === 'fullstack') {
+            if (s.level === 'epic' || s.level === 'feature')
+                d.innerLoopExpanded = true;
+            if (s.level === 'feature')
+                d.innerLoopRemovedFields = [...FULLSTACK_FEATURE_REMOVED];
+        }
+        else if (s.level === 'epic')
             d.innerLoopExpanded = false;
         for (const [k, v] of Object.entries(s.fields ?? {})) {
             if (RESERVED.has(k))
@@ -166,6 +193,21 @@ export function buildItems(g, specs, now = new Date()) {
     return { nodes, edges, ids, errors, patched };
 }
 export function registerBuildTools(server, ctx) {
+    server.registerTool('portfolio_preview', {
+        title: 'Picture a portfolio layout',
+        description: 'Draw the portfolio as an SVG schematic — every card at its stored Map (default) or Timeline position and size, with its level, state and title (done cards pale green), section-header notes as headings — so you can LOOK at a layout before calling it done. Returns the SVG text plus the card count and extent. `sizes` (px per id) overrides the stored / estimated card sizes; `width` sets the output width. A card whose inner loop is open draws its satellite band under it at the app\'s satellite sizes, so the picture shows the real height.',
+        inputSchema: {
+            portfolio_id: z.string(),
+            view: z.enum(['map', 'timeline']).optional(),
+            sizes: z.record(z.string(), z.object({ width: z.number().min(1).max(8000), height: z.number().min(1).max(8000) })).optional(),
+            width: z.number().int().min(200).max(8000).optional(),
+        },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, async (a) => {
+        const g = await loadGraph(ctx, a.portfolio_id);
+        const r = renderPreviewSvg(g.nodes, { view: a.view, sizes: a.sizes, width: a.width });
+        return { content: [{ type: 'text', text: JSON.stringify({ cards: r.cards, satellites: r.satellites, extent: r.extent }) }, { type: 'text', text: r.svg }] };
+    });
     if (ctx.readonly)
         return;
     server.registerTool('portfolio_create', {
@@ -193,11 +235,11 @@ export function registerBuildTools(server, ctx) {
     });
     server.registerTool('portfolio_add_items', {
         title: 'Add items to a portfolio',
-        description: 'Add up to 200 items of any level (objective, key-result, epic, feature, story, enabler, milestone) in one versioned write. Parents, OKR links and dependencies may name existing ids OR `key`s of other items in the same call, so a whole tree goes in at once. The tool makes the ids, the hierarchy / okr-link / finish-to-start edges, the dates and sprint labels from start_week + duration_weeks, and (unless layout is "none") re-lays the whole portfolio on the Timeline so nothing overlaps. Returns key → id. Rich text fields accept plain text or HTML.',
+        description: 'Add up to 200 items of any level (objective, key-result, epic, feature, story, enabler, milestone) in one versioned write. Parents, OKR links and dependencies may name existing ids OR `key`s of other items in the same call, so a whole tree goes in at once. The tool makes the ids, the hierarchy / okr-link / finish-to-start edges, the dates and sprint labels from start_week + duration_weeks, and lays the whole portfolio out — by default in the Full Stack shape (five rows: objectives, key results, epics, features, milestones + stories; each key result above its epic; new epics and features open their satellites). Returns key → id. Rich text fields accept plain text or HTML.',
         inputSchema: {
             portfolio_id: z.string(),
             items: z.array(itemSpec).min(1).max(MAX_ITEMS),
-            layout: z.enum(['timeline', 'none']).optional().describe('Default timeline: re-lay every item after adding. "none": new items get their date x and y 0.'),
+            layout: z.enum(['fullstack', 'timeline', 'none']).optional().describe('Default "fullstack": every item gets its Full Stack row (Timeline y — x stays its date) and Map position (x and y); new epics + features open their satellites, a feature showing Display + Statement. "timeline": the packed Timeline lanes (epics closed). "none": new items get their date x and y 0.'),
             expected_version: z.number().int().optional().describe('Optional OCC guard; default = the version read at call time.'),
         },
         annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
@@ -206,22 +248,32 @@ export function registerBuildTools(server, ctx) {
         const keys = a.items.map(s => s.key).filter(Boolean);
         if (new Set(keys).size !== keys.length)
             return fail('Two items share a key — keys must be unique within one call.');
-        const built = buildItems(g, a.items);
+        const layout = a.layout ?? ADD_ITEMS_DEFAULT_LAYOUT;
+        const built = buildItems(g, a.items, new Date(), layout);
         if (built.errors.length)
             return fail(`Nothing was written — ${built.errors.length} problem(s):\n` + built.errors.map(e => `  - ${e}`).join('\n'));
         let nodes = [...g.nodes.map(n => built.patched.has(n.id) ? { ...n, data: built.patched.get(n.id) } : n), ...built.nodes];
-        if ((a.layout ?? 'timeline') === 'timeline')
+        const edges = [...g.edges, ...built.edges];
+        if (layout === 'timeline')
             nodes = applyLayout(nodes, layoutTimeline(nodes));
-        const after = { ...g, nodes, edges: [...g.edges, ...built.edges] };
+        else if (layout === 'fullstack') {
+            const fs = layoutFullStack(nodes, { edges: edges });
+            nodes = applyMapLayout(applyFullStackTimeline(nodes, fs), fs);
+        }
+        const after = { ...g, nodes, edges };
         const r = await saveGraph(ctx, a.portfolio_id, g, after, a.expected_version);
         if (!r.ok)
             return fail(r.message);
-        const structured = { ok: true, added: built.nodes.length, edges: built.edges.length, ids: built.ids, ...(r.version !== undefined ? { version: r.version } : {}) };
-        return { content: [text(structured)], structuredContent: structured };
+        const who = ownerReport(a.items);
+        const structured = { ok: true, added: built.nodes.length, edges: built.edges.length, ids: built.ids, layout, owners: who.owners, unassigned: who.unassigned, ...(r.version !== undefined ? { version: r.version } : {}) };
+        const content = [text(structured)];
+        if (who.unassigned.length)
+            content.push({ type: 'text', text: `${who.unassigned.length} work item(s) have no owner: ${who.unassigned.join(', ')}. Give each one with portfolio_patch_item (set: { owner }) — the human's name for work only a person can do (review, approve, decide, buy, sign in, test on a device), "${AI_OWNER}" for work an agent delivers — so the human can see at a glance what is theirs.` });
+        return { content, structuredContent: structured };
     });
     server.registerTool('portfolio_patch_item', {
         title: 'Patch one item',
-        description: 'Change fields of ONE portfolio item without rewriting the graph (PATCH /api/portfolio/graph/node): `set` writes allowlisted PortfolioItemData fields (title, description, bluf, acceptanceCriteria, hypothesisStatement, state, tags, wsjf*, krTarget, pastedImages, durationWeeks, startDate, …), `unset` deletes them. Rich text is stored as given (pass HTML, or plain text which is wrapped in <p>). A stale version answers 409 — nothing is written.',
+        description: 'Change fields of ONE portfolio item without rewriting the graph (PATCH /api/portfolio/graph/node): `set` writes allowlisted PortfolioItemData fields (title, description, bluf, acceptanceCriteria, hypothesisStatement, state, owner — the human\'s name or "AI", tags, wsjf*, krTarget, pastedImages, durationWeeks, startDate, …), `unset` deletes them. Rich text is stored as given (pass HTML, or plain text which is wrapped in <p>). A stale version answers 409 — nothing is written.',
         inputSchema: {
             portfolio_id: z.string(),
             item_id: z.string(),
@@ -247,23 +299,129 @@ export function registerBuildTools(server, ctx) {
         return { content: [text(structured)], structuredContent: structured };
     });
     server.registerTool('portfolio_layout', {
-        title: 'Lay out a portfolio on the Timeline',
-        description: 'Re-position every item so the Timeline reads cleanly: x from each item\'s start date (the canvas reads dates off x), y top-down — objectives, key results, then one block per epic (epic, features, stories + enablers, milestones), each row lane-packed so overlapping items stack, IP nodes directly above their first source. Short items get a minimum painted width so titles fit. Content is untouched. `heights` overrides the estimated card height per id (px) when a card measures taller on screen.',
+        title: 'Lay out a portfolio',
+        description: 'Re-position every item so the Timeline reads cleanly: x from each item\'s start date (the canvas reads dates off x), y top-down — objectives, key results, then one block per epic (epic, features, stories + enablers, milestones), each row lane-packed so overlapping items stack, IP nodes directly above their first source. Short items get a minimum painted width so titles fit. Content is untouched. `heights` overrides the estimated card height per id (px) when a card measures taller on screen. `group: "objective"` reads top-down by goal instead: each objective, its key results, then the blocks of the epics those key results link to, before the next objective (`objective_order` lists objective ids to put first); unlinked epics follow. Grouping changes rows only, never x or dates. `view: "map"` lays out the Map instead (the free layout, `freePosition` only — the Timeline positions and dates are untouched): one band per objective (`objective_order` first), the objective + key results leading it, then one column per linked epic with its features and a 3-wide grid of stories; unlinked epics, loose items and modules follow. `style` picks the shape (default "packed" = everything above): "fullstack" = the owner\'s Full Stack reference, five rows whatever the size — objective 0 · key result 400 · epic 600 · feature 1040 · milestone 1320 · stories + enablers 1480; each key result above its epic, each epic column at least as wide as its open satellite row, the layout widening right, never taller — on the Timeline it sets y ONLY (x is the date, and dates never move; the result counts `timeline_overlaps`, cards sharing a row in the same weeks), with view "map" it sets x and y; "lane" = every release left → right by its from date, evenly spaced, the same gap between neighbours, in one Map row below the lowest card (satellites included) — Map positions (`freePosition`) only, never a date or a member.',
         inputSchema: {
             portfolio_id: z.string(),
+            style: z.enum(['packed', 'fullstack', 'lane']).optional().describe('Default "packed". "fullstack": the five Full Stack rows (Timeline: y only; view "map": x and y). "lane": the releases in one evenly spaced Map row, ordered by from date.'),
             heights: z.record(z.string(), z.number().min(20).max(2000)).optional(),
+            sizes: z.record(z.string(), z.object({ width: z.number().min(1).max(8000), height: z.number().min(1).max(8000) })).optional().describe('With view "map" (or style "fullstack"): measured card sizes (px) per id — Map cards are as wide as their content.'),
+            column_height: z.number().min(400).max(20000).optional().describe('With view "map": an epic column taller than this (px) wraps into another column beside it, at feature boundaries.'),
+            pack: z.enum(['stack', 'grid']).optional().describe('With view "map": "grid" packs the objective bands into rows shaped like a screen (default "stack": top to bottom).'),
+            headers: z.boolean().optional().describe('With view "map": a section-header note above each objective band (title + epics + % done). Re-running updates the same notes; notes you wrote are never touched.'),
+            view: z.enum(['timeline', 'map']).optional().describe('Default timeline. "map": write the Map (free) positions only, grouped by objective.'),
+            group: z.enum(['objective']).optional().describe('"objective": group epic blocks under the objective whose key results link to them.'),
+            objective_order: z.array(z.string()).max(100).optional().describe('With group "objective" or style "fullstack": objective ids to place first, in this order.'),
             expected_version: z.number().int().optional(),
         },
         annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
     }, async (a) => {
+        const style = a.style ?? 'packed';
+        if (style !== 'packed') {
+            const stray = ['heights', 'sizes', 'column_height', 'pack', 'headers', 'group', 'objective_order']
+                .filter(k => a[k] !== undefined && !(style === 'fullstack' && (k === 'sizes' || k === 'objective_order')));
+            if (stray.length)
+                return fail(`style "${style}" does not take ${stray.join(', ')} — nothing was written.`);
+            if (style === 'lane' && a.view === 'timeline')
+                return fail('style "lane" lays out the Map only (on the Timeline a release\'s x is its date) — omit view or pass "map". Nothing was written.');
+        }
         const g = await loadGraph(ctx, a.portfolio_id);
-        const res = layoutTimeline(g.nodes, { heights: a.heights });
+        if (style === 'lane') {
+            const lane = layoutReleaseLane(g.nodes, mapBoxes);
+            if (!lane.positions.size) {
+                const structured = { ok: true, style, releases: 0 };
+                return { content: [text(structured)], structuredContent: structured };
+            }
+            const r = await saveGraph(ctx, a.portfolio_id, g, { ...g, nodes: applyMapLayout(g.nodes, lane.positions) }, a.expected_version);
+            if (!r.ok)
+                return fail(r.message);
+            const structured = { ok: true, style, releases: lane.positions.size, y: lane.y, ...(r.version !== undefined ? { version: r.version } : {}) };
+            return { content: [text(structured)], structuredContent: structured };
+        }
+        if (style === 'fullstack') {
+            const fs = layoutFullStack(g.nodes, { edges: g.edges, objectiveOrder: a.objective_order, sizes: a.sizes });
+            const map = a.view === 'map';
+            const nodes = map ? applyMapLayout(g.nodes, fs) : applyFullStackTimeline(g.nodes, fs);
+            const r = await saveGraph(ctx, a.portfolio_id, g, { ...g, nodes }, a.expected_version);
+            if (!r.ok)
+                return fail(r.message);
+            const structured = { ok: true, style, view: map ? 'map' : 'timeline', positioned: fs.size, ...(map ? {} : { timeline_overlaps: timelineRowOverlaps(nodes) }), ...(r.version !== undefined ? { version: r.version } : {}) };
+            return { content: [text(structured)], structuredContent: structured };
+        }
+        if (a.view === 'map') {
+            const HEADER_H = 220;
+            const cards = g.nodes.filter(n => !(n.type === 'rad-module' && n.data?.moduleData?.__layoutHeader));
+            const d = layoutMapDetailed(cards, { edges: g.edges, objectiveOrder: a.objective_order, heights: a.heights, sizes: a.sizes, pack: a.pack, columnHeight: a.column_height, headerHeight: a.headers ? HEADER_H : 0 });
+            let nodes = applyMapLayout(g.nodes, d.positions);
+            let headers = { added: 0, updated: 0, removed: 0 };
+            if (a.headers !== undefined) {
+                const h = withMapHeaders(nodes, a.headers ? d.bands : [], HEADER_H);
+                nodes = h.nodes;
+                headers = { added: h.added, updated: h.updated, removed: h.removed };
+            }
+            const r = await saveGraph(ctx, a.portfolio_id, g, { ...g, nodes }, a.expected_version);
+            if (!r.ok)
+                return fail(r.message);
+            const structured = { ok: true, view: 'map', positioned: d.positions.size, bands: d.bands.length, headers, ...(r.version !== undefined ? { version: r.version } : {}) };
+            return { content: [text(structured)], structuredContent: structured };
+        }
+        const res = layoutTimeline(g.nodes, { heights: a.heights, ...(a.group ? { group: a.group, edges: g.edges, objectiveOrder: a.objective_order } : {}) });
         const r = await saveGraph(ctx, a.portfolio_id, g, { ...g, nodes: applyLayout(g.nodes, res) }, a.expected_version);
         if (!r.ok)
             return fail(r.message);
         const structured = { ok: true, positioned: res.positions.size, ...(r.version !== undefined ? { version: r.version } : {}) };
         return { content: [text(structured)], structuredContent: structured };
     });
+    server.registerTool('portfolio_style', {
+        title: 'Restyle many cards at once',
+        description: 'Give a portfolio one consistent look in ONE versioned write: rules, applied in order, each matching cards by levels / states / ids / hasImage and setting how they are drawn — display (card_style plain|poster|split|image-top|cover|grid-2|grid-4, title_size sm|md|lg, accent tint|bar|plain, show {bluf, description, acceptanceCriteria, tags, dates, wsjf}), size (Map width × height, or "auto" to size to content), satellites "open" | "close" (show or fold the card\'s inner-loop panels), inner_loop_removed_fields (the satellites an open loop leaves out — replaces the list; [] = the level\'s full row) and epic_color (#RRGGBB, or null to drop the override). Content is untouched. Artifact child cards (hypothesis, NFR…) are skipped unless a rule sets artifacts: true.',
+        inputSchema: {
+            portfolio_id: z.string(),
+            rules: z.array(z.object({
+                levels: z.array(z.enum(LEVELS)).optional(),
+                states: z.array(z.enum(STYLE_STATES)).optional(),
+                ids: z.array(z.string()).max(1000).optional(),
+                has_image: z.boolean().optional(),
+                artifacts: z.boolean().optional(),
+                display: z.object({
+                    card_style: z.enum(CARD_STYLES).optional(),
+                    title_size: z.enum(TITLE_SIZES).optional(),
+                    accent: z.enum(ACCENTS).optional(),
+                    show: z.object(Object.fromEntries(SHOW_KEYS.map(k => [k, z.boolean().optional()]))).optional(),
+                }).optional(),
+                size: z.union([z.object({ width: z.number().min(60).max(4000), height: z.number().min(40).max(4000) }), z.literal('auto')]).optional(),
+                satellites: z.enum(['open', 'close']).optional(),
+                inner_loop_removed_fields: z.array(z.enum(INNER_LOOP_FIELDS)).max(INNER_LOOP_FIELDS.length).optional().describe('Satellites the open loop leaves out, e.g. ["description","acceptanceCriteria"] (a Full Stack feature: Display + Statement only). Replaces the stored list.'),
+                epic_color: z.union([z.string().regex(/^#[0-9a-fA-F]{6}$/), z.null()]).optional().describe('The card colour as #RRGGBB (stored as epicColor on any level; clears a palette ref so the hex shows). null removes it.'),
+            })).min(1).max(40),
+            expected_version: z.number().int().optional(),
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (a) => {
+        const g = await loadGraph(ctx, a.portfolio_id);
+        const rules = a.rules.map(r => ({
+            ...(r.levels ? { levels: r.levels } : {}),
+            ...(r.states ? { states: r.states } : {}),
+            ...(r.ids ? { ids: r.ids } : {}),
+            ...(r.has_image !== undefined ? { hasImage: r.has_image } : {}),
+            ...(r.artifacts ? { artifacts: true } : {}),
+            ...(r.display ? { display: { cardStyle: r.display.card_style, titleSize: r.display.title_size, accent: r.display.accent, show: r.display.show } } : {}),
+            ...(r.size ? { size: r.size } : {}),
+            ...(r.satellites ? { satellites: r.satellites } : {}),
+            ...(r.inner_loop_removed_fields ? { innerLoopRemovedFields: r.inner_loop_removed_fields } : {}),
+            ...(r.epic_color !== undefined ? { epicColor: r.epic_color } : {}),
+        }));
+        const res = applyStyleRules(g.nodes, rules);
+        if (res.changed === 0) {
+            const structured = { ok: true, matched: res.matched, changed: 0, perRule: res.perRule };
+            return { content: [text(structured)], structuredContent: structured };
+        }
+        const r = await saveGraph(ctx, a.portfolio_id, g, { ...g, nodes: res.nodes }, a.expected_version);
+        if (!r.ok)
+            return fail(r.message);
+        const structured = { ok: true, matched: res.matched, changed: res.changed, perRule: res.perRule, ...(r.version !== undefined ? { version: r.version } : {}) };
+        return { content: [text(structured)], structuredContent: structured };
+    });
     server.registerTool('portfolio_set_meta', {
         title: 'Set portfolio settings',
         description: 'Graph-level settings that travel with the portfolio (the `__graph_meta__` record): `context_text` (the portfolio\'s context notes — what a newcomer reads first), `palette` ({ id, name, swatches: [{hex, label?}] ≤ 10, roles?: {epic, feature, story, …: hex | "p:N"} }), `canvas_style`, `sprint_settings`. Only the keys you pass change; everything else in the record is kept.',