@nonbot/mcp 0.3.0 → 0.3.1

package/README.md

@@ -258,6 +258,7 @@ Safety rails on writes: `portfolio_update` pre-fetches the live version, backs t
 - `core/server.ts` — `registerAll(server, ctx)` (the transport-agnostic heart) + `createNonbotMcpServer(ctx)`
 - `core/toolsets/{portfolio,build,release,ip,whygraph,run,monitor,radbugs}.ts`, `core/resources.ts`, `core/prompts.ts`
 - `core/releases.ts` — the Release node's membership + chain rules, restated from the app (`apps/web/src/modules/portfolio/lib/releases.ts`, `src/modules/release/lib/releaseChain.ts`) and parity-tested against it; `core/completedWork.ts` — done work, draft proposals and evidence matching
+- `core/layout.ts` — the Timeline (packed), Map and Full Stack layouts (`portfolio_layout` / `portfolio_add_items`; Full Stack's five rows restate the app's `FULL_STACK_TEMPLATE` and set y only on the Timeline, where x is the date); `core/satellites.ts` — inner-loop satellite sizes and rosters, restated from the app (`lib/innerLoopLayout.ts`, `theme/portfolio-theme.ts`) and parity-tested against it, for the Full Stack epic columns and the preview's satellite bands
 - `src/stdio.ts` — the `nonbot-mcp` bin: env/CLI-auth token + filesystem backup hook + the `git log` hook (`src/gitLog.ts`: execFile with an argv array, absolute `repo_path` only) used by `portfolio_rebuild_done_work`
 - `scripts/gen-tool-table.mjs` — prints the tool tables above from the live definitions (`--portfolio-mcp` does the same for the legacy server)
 

package/dist/core/layout.d.ts

@@ -87,3 +87,37 @@ export declare function applyMapLayout<T extends LayoutNode>(nodes: T[], positio
     x: number;
     y: number;
 }>): T[];
+export declare const FS_ROW: Record<Level, number>;
+export declare const FS_EPIC_STAGGER = 20;
+export declare const FS_LEAF_PITCH = 240;
+export declare const FS_MILESTONE_LIFT_GAP = 20;
+export declare const FS_FEATURE_MIN_WIDTH = 600;
+export declare const FS_GROUP_GAP = 240;
+export interface FullStackOptions {
+    edges?: LayoutEdge[];
+    objectiveOrder?: string[];
+    sizes?: Record<string, {
+        width: number;
+        height: number;
+    }>;
+}
+export declare function layoutFullStack(nodes: LayoutNode[], opts?: FullStackOptions): Map<string, {
+    x: number;
+    y: number;
+}>;
+export declare function applyFullStackTimeline<T extends LayoutNode>(nodes: T[], positions: Map<string, {
+    x: number;
+    y: number;
+}>): T[];
+export declare function timelineRowOverlaps(nodes: LayoutNode[]): number;
+export declare function mapBoxes(n: LayoutNode & {
+    freePosition?: {
+        x: number;
+        y: number;
+    };
+}): Array<{
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}>;

package/dist/core/layout.js

@@ -1,4 +1,5 @@
 import { IP_NODE_SIZE } from './ipShape.js';
+import { satelliteRowWidth, satellitePositions, satelliteBandHeight, INNER_LOOP_GAP, INNER_LOOP_Y_OFFSET, HOST_DEFAULT_HEIGHT } from './satellites.js';
 export const PX_PER_WEEK = 120;
 const WEEK_MS = 7 * 24 * 60 * 60 * 1000;
 const ITEM_TOP_HANDLE_X = 8;
@@ -510,3 +511,201 @@ export function applyMapLayout(nodes, positions) {
         return p ? { ...n, freePosition: { x: Math.round(p.x), y: Math.round(p.y) } } : n;
     });
 }
+export const FS_ROW = { objective: 0, 'key-result': 400, epic: 600, feature: 1040, milestone: 1320, story: 1480, enabler: 1480 };
+export const FS_EPIC_STAGGER = 20;
+export const FS_LEAF_PITCH = 240;
+export const FS_MILESTONE_LIFT_GAP = 20;
+export const FS_FEATURE_MIN_WIDTH = 600;
+export const FS_GROUP_GAP = 240;
+export function layoutFullStack(nodes, opts = {}) {
+    const sizes = opts.sizes ?? {};
+    const items = nodes.filter(isItem);
+    const byId = new Map(items.map(n => [n.id, n]));
+    const out = new Map();
+    const w = (n) => {
+        const z = sizes[n.id];
+        if (z && z.width > 0)
+            return z.width;
+        const cs = n.data?.canvasSize;
+        return cs && Number.isFinite(cs.width) && cs.width > 0 ? cs.width : MAP_WIDTH[levelOf(n)];
+    };
+    const tx = (n) => n.position?.x ?? 0;
+    const order = new Map(items.map((n, i) => [n.id, i]));
+    const byTime = (a, b) => tx(a) - tx(b) || order.get(a.id) - order.get(b.id);
+    const kids = new Map();
+    for (const n of items) {
+        const p = n.data?.parentItemId;
+        if (p && byId.has(p) && p !== n.id)
+            kids.set(p, [...(kids.get(p) ?? []), n]);
+    }
+    const put = (n, x, y) => out.set(n.id, { x, y });
+    const open = (list) => list.filter(n => !out.has(n.id)).sort(byTime);
+    const childrenOf = (id) => open(kids.get(id) ?? []);
+    const isMs = (n) => levelOf(n) === 'milestone';
+    const msH = (n) => {
+        const z = sizes[n.id];
+        if (z && z.height > 0)
+            return z.height;
+        const cs = n.data?.canvasSize;
+        return cs && Number.isFinite(cs.height) && cs.height > 0 ? cs.height : HEIGHT.milestone;
+    };
+    let x = 0;
+    let epicIndex = 0;
+    let epicBandRight = -Infinity;
+    let featureBandRight = -Infinity;
+    const clear = (cx, card, row, right) => (row > 0 && Number.isFinite(right) ? Math.max(cx, right + INNER_LOOP_GAP - card / 2 + row / 2) : cx);
+    const featureColumn = (f, fx0, stagger, under, epicBand) => {
+        const row = f ? satelliteRowWidth(f.data) : 0;
+        const fx = f ? clear(fx0, w(f), row, featureBandRight) : fx0;
+        if (f)
+            put(f, fx, FS_ROW.feature);
+        let lx = fx;
+        for (const l of under.filter(n => !isMs(n))) {
+            put(l, lx, FS_ROW.story);
+            lx += Math.max(FS_LEAF_PITCH, w(l));
+        }
+        const ms = under.filter(isMs);
+        const msW = ms.reduce((s, m) => s + w(m), 0);
+        let width = Math.max(lx - fx + msW, f ? Math.max(FS_FEATURE_MIN_WIDTH, w(f), row) : 0);
+        const raised = row > 0 && ms.length > 0;
+        const msY = raised ? FS_ROW.feature - Math.max(...ms.map(msH)) - FS_MILESTONE_LIFT_GAP : FS_ROW.milestone + stagger;
+        if (raised && epicBand && msY < epicBand.bottom && msY + Math.max(...ms.map(msH)) > epicBand.top) {
+            const left = fx + width - msW;
+            if (left < epicBand.right + INNER_LOOP_GAP && left + msW > epicBand.left - INNER_LOOP_GAP)
+                width = epicBand.right + INNER_LOOP_GAP + msW - fx;
+        }
+        let mx = fx + width - msW;
+        for (const m of ms) {
+            put(m, mx, msY);
+            mx += w(m);
+        }
+        if (f && row > 0)
+            featureBandRight = Math.max(featureBandRight, fx + w(f) / 2 + row / 2);
+        if (ms.length) {
+            if (raised)
+                epicBandRight = Math.max(epicBandRight, mx);
+            else
+                featureBandRight = Math.max(featureBandRight, mx);
+        }
+        return fx + width - fx0;
+    };
+    const epicColumn = (ep) => {
+        const stagger = FS_EPIC_STAGGER * (epicIndex++ % 2);
+        const row = satelliteRowWidth(ep.data);
+        const ex = clear(x, w(ep), row, epicBandRight);
+        const ey = FS_ROW.epic + stagger;
+        put(ep, ex, ey);
+        const band = row > 0
+            ? { left: ex + w(ep) / 2 - row / 2, right: ex + w(ep) / 2 + row / 2, top: ey + HOST_DEFAULT_HEIGHT.epic + INNER_LOOP_Y_OFFSET, bottom: ey + satelliteBandHeight(ep.data) }
+            : null;
+        if (band)
+            epicBandRight = Math.max(epicBandRight, band.right);
+        let cx = ex;
+        const ch = childrenOf(ep.id);
+        for (const f of ch.filter(n => levelOf(n) === 'feature'))
+            cx += featureColumn(f, cx, stagger, childrenOf(f.id), band);
+        const direct = ch.filter(n => levelOf(n) !== 'feature');
+        if (direct.length)
+            cx += featureColumn(null, cx, stagger, direct, band);
+        x = ex + Math.max(cx - ex, w(ep), row);
+        return ex;
+    };
+    const objectives = items.filter(n => levelOf(n) === 'objective');
+    const krs = items.filter(n => levelOf(n) === 'key-result').sort(byTime);
+    const epics = items.filter(n => levelOf(n) === 'epic').sort(byTime);
+    const epicIds = new Set(epics.map(e => e.id));
+    const linked = new Map();
+    const link = (kr, ep) => { if (epicIds.has(ep) && !(linked.get(kr) ?? []).includes(ep))
+        linked.set(kr, [...(linked.get(kr) ?? []), ep]); };
+    for (const e of opts.edges ?? [])
+        if (e.dependencyType === 'okr-link')
+            link(e.source, e.target);
+    for (const kr of krs)
+        for (const ep of (Array.isArray(kr.data?.linkedEpicIds) ? kr.data.linkedEpicIds : []))
+            link(kr.id, ep);
+    const rank = new Map((opts.objectiveOrder ?? []).map((id, i) => [id, i]));
+    const ordered = objectives.slice().sort((a, b) => (rank.get(a.id) ?? Infinity) - (rank.get(b.id) ?? Infinity) || byTime(a, b));
+    let started = false;
+    const group = (fn) => {
+        const before = out.size;
+        const at = x;
+        if (started)
+            x += FS_GROUP_GAP;
+        fn();
+        if (out.size === before)
+            x = at;
+        else
+            started = true;
+    };
+    const krColumn = (kr) => {
+        const own = open((linked.get(kr.id) ?? []).map(id => byId.get(id)));
+        if (!own.length) {
+            put(kr, x, FS_ROW['key-result']);
+            x += w(kr) + MAP_GAP;
+            return;
+        }
+        let first = null;
+        for (const ep of own) {
+            const ex = epicColumn(ep);
+            first ??= ex;
+        }
+        put(kr, first, FS_ROW['key-result']);
+    };
+    for (const o of ordered)
+        group(() => {
+            const ox = x;
+            put(o, ox, FS_ROW.objective);
+            for (const kr of krs.filter(k => k.data?.parentItemId === o.id))
+                krColumn(kr);
+            x = Math.max(x, ox + w(o));
+        });
+    const objectiveIds = new Set(objectives.map(o => o.id));
+    group(() => { for (const kr of krs.filter(k => !objectiveIds.has(k.data?.parentItemId)))
+        krColumn(kr); });
+    group(() => { for (const ep of open(epics))
+        epicColumn(ep); });
+    group(() => {
+        for (const f of open(items.filter(n => levelOf(n) === 'feature')))
+            x += featureColumn(f, x, 0, childrenOf(f.id), null);
+        const loose = open(items.filter(n => !byId.has(n.data?.parentItemId) && ['story', 'enabler', 'milestone'].includes(levelOf(n))));
+        if (loose.length)
+            x += featureColumn(null, x, 0, loose, null);
+        for (const n of open(items)) {
+            put(n, x, FS_ROW[levelOf(n)]);
+            x += Math.max(FS_LEAF_PITCH, w(n));
+        }
+    });
+    return out;
+}
+export function applyFullStackTimeline(nodes, positions) {
+    return nodes.map(n => {
+        const p = positions.get(n.id);
+        return p ? { ...n, position: { ...(n.position ?? { x: 0 }), y: Math.round(p.y) } } : n;
+    });
+}
+export function timelineRowOverlaps(nodes) {
+    const cards = nodes.filter(isItem).map(n => {
+        const lv = levelOf(n);
+        const weeks = typeof n.data?.durationWeeks === 'number' ? n.data.durationWeeks : DEFAULT_DURATION[lv];
+        const width = Number(n.data?.manualWidthOverride) || (weeks > 0 ? weeks * PX_PER_WEEK : DEFAULT_WIDTH[lv]);
+        return { x: n.position?.x ?? 0, y: n.position?.y ?? 0, width };
+    });
+    let count = 0;
+    for (let i = 0; i < cards.length; i++)
+        for (let j = i + 1; j < cards.length; j++) {
+            const a = cards[i], b = cards[j];
+            if (Math.abs(a.y - b.y) < 100 && a.x < b.x + b.width && b.x < a.x + a.width)
+                count++;
+        }
+    return count;
+}
+export function mapBoxes(n) {
+    const at = n.freePosition ?? n.position ?? { x: 0, y: 0 };
+    if (n.type === 'rad-module')
+        return [{ x: at.x, y: at.y, width: Number(n.data?.width) || 400, height: Number(n.data?.height) || 300 }];
+    const cs = n.data?.canvasSize;
+    const width = cs && Number.isFinite(cs.width) && cs.width > 0 ? cs.width : MAP_WIDTH[levelOf(n)];
+    const height = cs && Number.isFinite(cs.height) && cs.height > 0 ? cs.height : HEIGHT[levelOf(n)] + (Array.isArray(n.data?.pastedImages) && n.data.pastedImages.length ? MAP_HERO_EXTRA : 0);
+    const card = { x: at.x, y: at.y, width, height };
+    return [card, ...satellitePositions(n.data, card).map(({ x, y, width: w, height: h }) => ({ x, y, width: w, height: h }))];
+}

package/dist/core/preview.d.ts

@@ -10,6 +10,7 @@ export interface PreviewOptions {
 export declare function renderPreviewSvg(nodes: LayoutNode[], opts?: PreviewOptions): {
     svg: string;
     cards: number;
+    satellites: number;
     extent: {
         width: number;
         height: number;

package/dist/core/preview.js

@@ -1,4 +1,5 @@
 import { MAP_WIDTH, levelOf, isItem } from './layout.js';
+import { satellitePositions, SATELLITE_FIELDS } from './satellites.js';
 const HEIGHT = { epic: 120, feature: 100, story: 96, enabler: 96, milestone: 44, objective: 120, 'key-result': 100 };
 const esc = (s) => s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
 const strip = (s) => s.replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim();
@@ -24,21 +25,27 @@ export function renderPreviewSvg(nodes, opts = {}) {
     };
     const drawn = nodes.filter(n => isItem(n) || n.type === 'rad-module');
     if (!drawn.length)
-        return { svg: '<svg xmlns="http://www.w3.org/2000/svg" width="10" height="10"/>', cards: 0, extent: { width: 0, height: 0 } };
+        return { svg: '<svg xmlns="http://www.w3.org/2000/svg" width="10" height="10"/>', cards: 0, satellites: 0, extent: { width: 0, height: 0 } };
+    const bands = drawn.filter(isItem).flatMap(n => { const p = pos(n); const s = size(n); return satellitePositions(n.data, { x: p.x, y: p.y, width: s.width, height: s.height }); });
     let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+    const grow = (x, y, w, h) => { x0 = Math.min(x0, x); y0 = Math.min(y0, y); x1 = Math.max(x1, x + w); y1 = Math.max(y1, y + h); };
     for (const n of drawn) {
         const p = pos(n);
         const s = size(n);
-        x0 = Math.min(x0, p.x);
-        y0 = Math.min(y0, p.y);
-        x1 = Math.max(x1, p.x + s.width);
-        y1 = Math.max(y1, p.y + s.height);
+        grow(p.x, p.y, s.width, s.height);
     }
+    for (const b of bands)
+        grow(b.x, b.y, b.width, b.height);
     const pad = 80;
     const W = x1 - x0 + 2 * pad;
     const H = y1 - y0 + 2 * pad;
     const outW = opts.width ?? 1600;
     const parts = [];
+    for (const b of bands) {
+        const x = b.x - x0 + pad, y = b.y - y0 + pad;
+        parts.push(`<rect x="${x}" y="${y}" width="${b.width}" height="${b.height}" rx="8" fill="#17142A" stroke="#4A4566" stroke-width="1.5" stroke-dasharray="6 4"/>`);
+        parts.push(`<text x="${x + 10}" y="${y + 20}" font-size="12" fill="#8F87B5">${esc(fit(SATELLITE_FIELDS[b.field].label, b.width - 20, 12))}</text>`);
+    }
     for (const n of drawn) {
         const p = pos(n);
         const s = size(n);
@@ -70,5 +77,5 @@ export function renderPreviewSvg(nodes, opts = {}) {
         parts.push(`<text x="${x + 14}" y="${y + 28 + fs * 1.3}" font-size="${fs}" font-weight="${big ? 700 : 500}" fill="${ink}">${esc(fit(String(n.data?.title ?? '').trim(), s.width - 28, fs))}</text>`);
     }
     const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="${outW}" height="${Math.round((outW * H) / W)}" viewBox="0 0 ${Math.round(W)} ${Math.round(H)}" font-family="Public Sans, Helvetica, Arial, sans-serif"><rect width="100%" height="100%" fill="#120F1E"/>${parts.join('')}</svg>`;
-    return { svg, cards: drawn.length, extent: { width: Math.round(W), height: Math.round(H) } };
+    return { svg, cards: drawn.length, satellites: bands.length, extent: { width: Math.round(W), height: Math.round(H) } };
 }

package/dist/core/releases.d.ts

@@ -125,3 +125,35 @@ export declare function releaseNode(id: string, md: ReleaseData, place: {
         y: number;
     };
 }): GraphNode;
+export interface LaneBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface LaneRelease {
+    id: string;
+    x: number;
+    y: number;
+    width: number;
+    data: Record<string, unknown>;
+}
+export interface LanePlace {
+    id: string;
+    x: number;
+    y: number;
+}
+export declare const LANE_GAP_X = 48;
+export declare const LANE_GAP_Y = 120;
+export declare function laneOrder<R extends {
+    id: string;
+    data: Record<string, unknown>;
+}>(releases: readonly R[]): R[];
+export declare function releaseLane(releases: readonly LaneRelease[], boxes: readonly LaneBox[]): LanePlace[];
+export declare function layoutReleaseLane(nodes: ReadonlyArray<GraphNode>, boxesOf: (n: GraphNode) => LaneBox[]): {
+    positions: Map<string, {
+        x: number;
+        y: number;
+    }>;
+    y: number | null;
+};

package/dist/core/releases.js

@@ -278,3 +278,36 @@ export function releaseNode(id, md, place) {
         data: { subtype: RELEASE_SUBTYPE, moduleData: { ...md }, width: RELEASE_SIZE.width, height: RELEASE_SIZE.height },
     };
 }
+export const LANE_GAP_X = 48;
+export const LANE_GAP_Y = 120;
+export function laneOrder(releases) {
+    return [...releases].sort((a, b) => str(a.data.from).localeCompare(str(b.data.from))
+        || str(a.data.to).localeCompare(str(b.data.to))
+        || a.id.localeCompare(b.id));
+}
+export function releaseLane(releases, boxes) {
+    if (!releases.length)
+        return [];
+    const live = boxes.filter(b => [b.x, b.y, b.width, b.height].every(Number.isFinite));
+    const left = live.length ? Math.min(...live.map(b => b.x)) : Math.min(...releases.map(r => r.x));
+    const top = live.length ? Math.max(...live.map(b => b.y + b.height)) + LANE_GAP_Y : Math.min(...releases.map(r => r.y));
+    const out = [];
+    let x = Math.round(left);
+    const y = Math.round(top);
+    for (const r of laneOrder(releases)) {
+        out.push({ id: r.id, x, y });
+        x += Math.round(Math.max(r.width, 1)) + LANE_GAP_X;
+    }
+    return out;
+}
+export function layoutReleaseLane(nodes, boxesOf) {
+    const isRel = (n) => n.type === 'rad-module' && n.data?.subtype === RELEASE_SUBTYPE;
+    const at = (n) => n.freePosition ?? n.position ?? { x: 0, y: 0 };
+    const releases = nodes.filter(isRel).map(n => ({
+        id: n.id, ...at(n), width: Number(n.data?.width) || RELEASE_SIZE.width,
+        data: n.data?.moduleData && typeof n.data.moduleData === 'object' ? n.data.moduleData : {},
+    }));
+    const boxes = nodes.filter(n => !isRel(n) && (n.type === 'portfolio-item' || n.type === 'rad-module')).flatMap(boxesOf);
+    const places = releaseLane(releases, boxes);
+    return { positions: new Map(places.map(p => [p.id, { x: p.x, y: p.y }])), y: places[0]?.y ?? null };
+}

package/dist/core/satellites.d.ts

@@ -0,0 +1,54 @@
+export declare const INNER_LOOP_GAP = 16;
+export declare const INNER_LOOP_Y_OFFSET = 40;
+export declare const INNER_LOOP_COLLAPSED_HEIGHT = 44;
+export declare const INNER_LOOP_FIELDS: readonly ["epicColor", "nodeDisplay", "artifact", "whyGraph", "description", "hypothesisStatement", "acceptanceCriteria", "bluf", "lbcProblem", "lbcBenefitHypothesis", "lbcLeadingIndicators", "lbcNfrs", "mvpDefinition", "outcomeMetrics", "owner", "tags", "confidenceVote", "approvalRating", "mockupSvg", "character", "location"];
+export type InnerLoopField = (typeof INNER_LOOP_FIELDS)[number];
+type FieldConfig = {
+    label: string;
+    width: number;
+    height: number;
+    levels?: readonly string[];
+    retired?: true;
+};
+export declare const SATELLITE_FIELDS: Record<InnerLoopField, FieldConfig>;
+export declare const HOST_DEFAULT_HEIGHT: Record<string, number>;
+export interface SatelliteHost {
+    hierarchyLevel?: string;
+    childCardType?: string;
+    innerLoopExpanded?: boolean;
+    innerLoopExtraFields?: string[];
+    innerLoopRemovedFields?: string[];
+    innerLoopSizes?: Record<string, {
+        width?: number;
+        height?: number;
+    }>;
+    subnodeCollapsed?: Record<string, boolean>;
+    [k: string]: unknown;
+}
+export declare const canHostInnerLoop: (d: SatelliteHost | undefined) => boolean;
+export declare function activeSatelliteFields(d: SatelliteHost | undefined): InnerLoopField[];
+export declare function satelliteItems(d: SatelliteHost | undefined): Array<{
+    field: InnerLoopField;
+    width: number;
+    height: number;
+}>;
+export declare const openSatellites: (d: SatelliteHost | undefined) => {
+    field: InnerLoopField;
+    width: number;
+    height: number;
+}[];
+export declare function satelliteRowWidth(d: SatelliteHost | undefined): number;
+export declare function satelliteBandHeight(d: SatelliteHost | undefined, hostHeight?: number): number;
+export declare function satellitePositions(d: SatelliteHost | undefined, host: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}): Array<{
+    field: InnerLoopField;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}>;
+export {};

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.3.0";
+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

@@ -10,15 +10,16 @@ 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.3.0';
+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,',

package/dist/core/style.d.ts

@@ -1,4 +1,5 @@
 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"];
@@ -20,7 +21,9 @@ export interface StyleRule {
         width: number;
         height: number;
     } | 'auto';
-    satellites?: 'close';
+    satellites?: 'open' | 'close';
+    innerLoopRemovedFields?: InnerLoopField[];
+    epicColor?: string | null;
 }
 export interface StyleResult<T> {
     nodes: T[];

package/dist/core/style.js

@@ -52,6 +52,18 @@ export function applyStyleRules(nodes, rules) {
                 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;

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

@@ -2,6 +2,7 @@ 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';
+import { type InnerLoopField } from '../satellites.js';
 export type Node = LayoutNode & {
     id: string;
     type?: string;
@@ -35,11 +36,11 @@ 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;
@@ -80,7 +81,10 @@ export declare function ownerReport(specs: Array<Pick<ItemSpec, 'key' | 'level'
     owners: Record<string, number>;
     unassigned: string[];
 };
-export declare function buildItems(g: Graph, specs: ItemSpec[], now?: Date): {
+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,7 +1,9 @@
 import { z } from 'zod';
 import { api, expectJson } from '../http.js';
 import { validateGraph } from '../validate.js';
-import { LEVELS, applyLayout, layoutTimeline, layoutMapDetailed, applyMapLayout, 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';
@@ -91,7 +93,9 @@ export function ownerReport(specs) {
     }
     return { owners, unassigned };
 }
-export function buildItems(g, specs, now = new Date()) {
+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();
@@ -141,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))
@@ -185,7 +195,7 @@ export function buildItems(g, specs, now = new Date()) {
 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.',
+        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(),
@@ -196,7 +206,7 @@ export function registerBuildTools(server, ctx) {
     }, 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, extent: r.extent }) }, { type: 'text', text: r.svg }] };
+        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;
@@ -225,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 },
@@ -238,18 +248,24 @@ 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 who = ownerReport(a.items);
-        const structured = { ok: true, added: built.nodes.length, edges: built.edges.length, ids: built.ids, owners: who.owners, unassigned: who.unassigned, ...(r.version !== undefined ? { version: r.version } : {}) };
+        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.` });
@@ -283,23 +299,55 @@ 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. `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.',
+        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": measured card sizes (px) per id — Map cards are as wide as their content.'),
+            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": objective ids to place first, in this order.'),
+            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);
+        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));
@@ -326,7 +374,7 @@ export function registerBuildTools(server, ctx) {
     });
     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) and satellites "close" (fold the card\'s inner-loop panels). Content is untouched. Artifact child cards (hypothesis, NFR…) are skipped unless a rule sets artifacts: true.',
+        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({
@@ -342,7 +390,9 @@ export function registerBuildTools(server, ctx) {
                     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.literal('close').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(),
         },
@@ -358,6 +408,8 @@ export function registerBuildTools(server, ctx) {
             ...(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) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nonbot/mcp",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "type": "module",
   "description": "The non.bot MCP server — one server for your portfolios, decision graph, and Runs. Runs over stdio (Claude Code, Cursor, VS Code) with a pat_ token. Built on MCP protocol 2025-11-25.",
   "keywords": [