mockpit 1.3.0 → 3.0.0

package/dist/server/feedbackBatch.d.ts

@@ -1,5 +1,6 @@
 import { type Decisions } from "./decisions.ts";
-import { type AskOption, type Comment, type CommentAnchor, type Mock, OTHER_ID, type PartComment, type Post, type Reaction, type Reply, type Store } from "./types.ts";
+import { type StandingView } from "./standings.ts";
+import { type AskOption, type Comment, type CommentAnchor, type Design, type DesignEdit, OTHER_ID, type PartComment, type Post, type Reaction, type Reply, type Store } from "./types.ts";
 export interface VariantRef {
     state: string | null;
     variant: string;
@@ -7,7 +8,7 @@ export interface VariantRef {
 export interface InUseRef extends VariantRef {
     version: number;
 }
-export interface FeedbackComment {
+export interface FeedbackMessage {
     seq: number;
     text: string;
     state: string | null;
@@ -27,14 +28,40 @@ export interface OtherChoice {
     other: true;
     images?: ImageRef[];
 }
-export interface AnsweredAsk {
+export interface AnsweredAsk extends StandingView {
     ask: string;
     text: string;
     chosen: (AskOption | OtherChoice)[];
+    comment?: string;
+    commentImages?: ImageRef[];
+}
+export interface MoreAnswers {
+    ask: string;
+    text: string;
+    existing: string[];
     note?: string;
-    noteImages?: ImageRef[];
+    like?: string;
+    kept?: string[];
+    hidden?: {
+        label: string;
+        why?: string;
+    }[];
+    answered: {
+        ask: string;
+        text: string;
+        chosen: string[];
+        comment?: string;
+    }[];
 }
-export interface FeedbackReply extends Omit<Reply, "others" | "notes" | "otherImages" | "noteImages"> {
+export interface UpdateRequest {
+    ask: string;
+    text: string;
+    kept: AskOption;
+    inUse: AskOption[];
+}
+export interface FeedbackReply extends Omit<Reply, "others" | "askComments" | "otherImages" | "askCommentImages" | "more" | "standings" | "update"> {
+    more?: MoreAnswers;
+    update?: UpdateRequest;
     seq: number;
     at: string;
     asks: AnsweredAsk[];
@@ -42,25 +69,20 @@ export interface FeedbackReply extends Omit<Reply, "others" | "notes" | "otherIm
     decisions?: Decisions;
 }
 export interface FeedbackBatch {
-    mockId: string | null;
+    designId: string | null;
     project: string | null;
-    mock: string | null;
+    design: string | null;
     title: string | null;
     reply: FeedbackReply | null;
-    comments: FeedbackComment[];
-    accepted: InUseRef[];
+    messages: FeedbackMessage[];
+    inUse: InUseRef[];
     archived: VariantRef[];
-    dropped: VariantRef[];
     handoff?: string;
-    resolved?: true;
-    dismissed?: {
-        ask: string;
-        text: string;
-    }[];
+    edited?: DesignEdit;
 }
 export declare function reactionLine(c: PartComment & {
     reaction: Reaction;
 }): string;
-export declare function groupFeedback(comments: Comment[], mocks: Map<string, Mock>, posts: Map<string, Post[]>, base?: string): FeedbackBatch[];
+export declare function groupFeedback(comments: Comment[], designs: Map<string, Design>, posts: Map<string, Post[]>, base?: string): FeedbackBatch[];
 export declare function buildFeedbackBatches(store: Store, comments: Comment[], base: string): Promise<FeedbackBatch[]>;
 export declare function feedbackImages(batches: FeedbackBatch[]): ImageRef[];

package/dist/server/feedbackBatch.js

@@ -1,10 +1,60 @@
-// The agent-facing shape of feedback: one batch per mock, in delivery order.
+// The agent-facing shape of feedback: one batch per design, in delivery order.
 // The `feedback` verb, the watch long-poll and the write piggyback all return this,
-// so an agent reads one grouped object instead of re-deriving which mock a flat
+// so an agent reads one grouped object instead of re-deriving which design a flat
 // comment list belongs to. Runtime-agnostic (no node imports).
 import { decisionsFor } from "./decisions.js";
+import { ROUTED_NOTE } from "./handoff.js";
+import { standingOf, standingView } from "./standings.js";
 import { builtinAsk, inUseVersion, DEFAULT_VARIANT, OTHER_ID, } from "./types.js";
 const ref = (p) => ({ state: p.state, variant: p.variant });
+function moreAnswers(design, more, sent) {
+    const ask = design.asks.find((a) => a.id === more.ask);
+    if (!ask)
+        return undefined;
+    const st = sent ?? standingOf(design, ask.id);
+    const view = standingView(ask, st);
+    const like = more.like ? ask.options.find((o) => o.id === more.like)?.label : undefined;
+    const labels = (a) => {
+        const ids = a.answer === undefined ? [] : Array.isArray(a.answer) ? a.answer : [a.answer];
+        return [
+            ...ids.map((id) => a.options.find((o) => o.id === id)?.label ?? id),
+            ...(a.other === undefined ? [] : [a.other]),
+        ];
+    };
+    return {
+        ask: ask.id,
+        text: ask.text,
+        // Hidden ones are out: asked again, they'd only fold away.
+        existing: ask.options.filter((o) => !st.hidden.some((h) => h.id === o.id)).map((o) => o.label),
+        ...(more.note ? { note: more.note } : {}),
+        ...(like ? { like } : {}),
+        ...(view?.kept ? { kept: view.kept.map((k) => k.label) } : {}),
+        ...(view?.hidden
+            ? { hidden: view.hidden.map((h) => ({ label: h.label, ...(h.why ? { why: h.why } : {}) })) }
+            : {}),
+        answered: design.asks
+            .filter((a) => a.id !== ask.id && labels(a).length > 0)
+            .map((a) => ({
+            ask: a.id,
+            text: a.text,
+            chosen: labels(a),
+            ...(a.comment ? { comment: a.comment } : {}),
+        })),
+    };
+}
+function updateRequest(design, wanted) {
+    const ask = design.asks.find((a) => a.id === wanted.ask);
+    const kept = ask?.options.find((o) => o.id === wanted.option);
+    if (!ask || !kept)
+        return undefined;
+    const ids = ask.answer === undefined ? [] : [ask.answer].flat();
+    return {
+        ask: ask.id,
+        text: ask.text,
+        kept,
+        inUse: ask.options.filter((o) => ids.includes(o.id)),
+    };
+}
 const REACTION_LEAD = {
     up: "👍",
     down: "👎",
@@ -12,8 +62,11 @@ const REACTION_LEAD = {
 };
 // `👍 part "hero" (variant B, state Mobile)`, `👎 variant B`, `more like this: the page`.
 export function reactionLine(c) {
-    // A mock published without variant names has only "default": naming it is noise.
-    const variant = c.variant && c.variant !== DEFAULT_VARIANT ? c.variant : null;
+    // A design published without variant names has only "default": naming it is noise.
+    const named = c.variant && c.variant !== DEFAULT_VARIANT ? c.variant : null;
+    // A version is written as agents write it, dark@2.
+    const at = c.version ? `@${c.version}` : "";
+    const variant = named ? `${named}${at}` : at ? `${DEFAULT_VARIANT}${at}` : null;
     const where = [
         c.part !== null && variant ? `variant ${variant}` : "",
         c.state ? `state ${c.state}` : "",
@@ -28,21 +81,32 @@ export function reactionLine(c) {
     return `${REACTION_LEAD[c.reaction]} ${target}${tail}${note}`;
 }
 const isReaction = (c) => !!c.reaction;
-function answered(reply, mock, posts, base) {
+function answered(reply, design, posts, base) {
     const others = reply.others ?? {};
-    const notes = reply.notes ?? {};
+    const comments = reply.askComments ?? {};
     const refs = (ids) => (ids ?? []).map((id) => ({ id, url: `${base}/a/${encodeURIComponent(id)}` }));
+    const standings = reply.standings ?? {};
     const askIds = new Set([
         ...Object.keys(reply.answers),
         ...Object.keys(others),
-        ...Object.keys(notes),
+        ...Object.keys(comments),
+        // A question whose answers the user only kept or hid is still news: more answers
+        // should follow the kept ones and avoid the hidden.
+        ...Object.keys(standings).filter((id) => id !== reply.more?.ask),
     ]);
     const out = [];
     for (const askId of askIds) {
-        const ask = mock?.asks.find((a) => a.id === askId) ?? (mock && builtinAsk(mock, posts, askId));
+        const ask = design?.asks.find((a) => a.id === askId) ?? (design && builtinAsk(design, posts, askId));
         const answer = reply.answers[askId];
         const ids = answer === undefined ? [] : Array.isArray(answer) ? answer : [answer];
-        const chosen = ids.map((id) => ask?.options.find((o) => o.id === id) ?? { id, label: id });
+        const chosen = ids.map((id) => {
+            const option = ask?.options.find((o) => o.id === id);
+            if (!option)
+                return { id, label: id };
+            // What it brought isn't in any version yet: an agent folding it in needs it here.
+            const brought = design?.answerAdditions.find((a) => Object.entries(option.set ?? {}).some(([k, v]) => a.knob === k && a.value === v));
+            return brought ? { ...option, brought } : option;
+        });
         const otherImages = refs(reply.otherImages?.[askId]);
         if (others[askId] !== undefined)
             chosen.push({
@@ -51,77 +115,84 @@ function answered(reply, mock, posts, base) {
                 other: true,
                 ...(otherImages.length ? { images: otherImages } : {}),
             });
-        const noteImages = refs(reply.noteImages?.[askId]);
+        const commentImages = refs(reply.askCommentImages?.[askId]);
+        const st = standings[askId];
         out.push({
             ask: askId,
             text: ask?.text ?? "",
             chosen,
-            ...(notes[askId] !== undefined ? { note: notes[askId] } : {}),
-            ...(noteImages.length ? { noteImages } : {}),
+            ...(ask && st ? standingView({ ...ask, answer }, st) : {}),
+            ...(comments[askId] !== undefined ? { comment: comments[askId] } : {}),
+            ...(commentImages.length ? { commentImages } : {}),
         });
     }
     return out;
 }
 // Comments arrive in seq order; keep that order both between batches and inside
-// one. A mock gets a fresh batch whenever a second reply arrives for it, so a
+// one. A design gets a fresh batch whenever a second reply arrives for it, so a
 // batch carries at most one reply and nothing is merged away. A comment whose
-// mock is unknown still gets a batch — feedback is never dropped for want of
+// design is unknown still gets a batch — feedback is never dropped for want of
 // context. `base` (origin + base path) makes image URLs absolute.
-export function groupFeedback(comments, mocks, posts, base = "") {
+export function groupFeedback(comments, designs, posts, base = "") {
     const batches = [];
     const open = new Map();
     for (const c of comments) {
-        const key = c.mockId ?? "";
-        const mock = c.mockId ? mocks.get(c.mockId) : undefined;
-        const mockPosts = (c.mockId && posts.get(c.mockId)) || [];
+        // Stored from when a close wrote to this stream. Ending something tells the agent
+        // nothing, so one still ahead of the cursor stays unsaid.
+        if (c.kind === "reply" && c.payload?.archived)
+            continue;
+        const key = c.designId ?? "";
+        const design = c.designId ? designs.get(c.designId) : undefined;
+        const designPosts = (c.designId && posts.get(c.designId)) || [];
         let batch = open.get(key);
-        if (!batch || (c.kind === "reply" && (batch.reply || batch.resolved))) {
+        // An edit says where the design is now, so it joins whatever batch is open.
+        const edit = c.kind === "reply" ? c.payload?.edited : undefined;
+        if (!batch || (c.kind === "reply" && !edit && batch.reply)) {
             batch = {
-                mockId: c.mockId,
-                project: mock?.project ?? null,
-                mock: mock?.slug ?? null,
-                title: mock?.title ?? null,
+                designId: c.designId,
+                project: design?.project ?? null,
+                design: design?.slug ?? null,
+                title: design?.title ?? null,
                 reply: null,
-                comments: [],
-                accepted: [],
+                messages: [],
+                inUse: [],
                 archived: [],
-                dropped: [],
             };
             open.set(key, batch);
             batches.push(batch);
         }
-        if (c.kind === "reply" && c.payload?.resolved) {
-            batch.resolved = true;
-            batch.dismissed = c.payload.resolved.dismissed.map((id) => ({
-                ask: id,
-                text: (mock?.asks.find((a) => a.id === id) ?? (mock && builtinAsk(mock, mockPosts, id)))
-                    ?.text ?? "",
-            }));
+        if (edit) {
+            batch.edited = { ...batch.edited, ...edit };
             continue;
         }
         if (c.kind === "reply" && c.payload) {
-            const { others: _others, notes: _notes, otherImages: _otherImages, noteImages: _noteImages, ...payload } = c.payload;
+            const { others: _others, askComments: _askComments, otherImages: _otherImages, askCommentImages: _askCommentImages, routed, more: asked, standings: _standings, update: wanted, ...payload } = c.payload;
+            const more = asked && design ? moreAnswers(design, asked, c.payload.standings?.[asked.ask]) : undefined;
+            const update = wanted && design ? updateRequest(design, wanted) : undefined;
+            if (routed)
+                batch.handoff = ROUTED_NOTE;
             const reactions = (payload.comments ?? []).filter(isReaction).map(reactionLine);
             batch.reply = {
                 ...payload,
                 comments: (payload.comments ?? []).filter((x) => !x.reaction),
                 seq: c.seq,
                 at: c.createdAt,
-                asks: answered(c.payload, mock, mockPosts, base),
+                asks: answered(c.payload, design, designPosts, base),
                 ...(reactions.length ? { reactions } : {}),
+                ...(more ? { more } : {}),
+                ...(update ? { update } : {}),
             };
-            const decisions = mock ? decisionsFor(mock, mockPosts, c.payload) : null;
+            const decisions = design ? decisionsFor(design, designPosts, c.payload) : null;
             if (decisions)
                 batch.reply.decisions = decisions;
-            batch.accepted = mockPosts
+            batch.inUse = designPosts
                 .filter((p) => p.status === "accepted")
                 .map((p) => ({ ...ref(p), version: inUseVersion(p) }));
-            batch.archived = mockPosts.filter((p) => p.status === "archived").map(ref);
-            batch.dropped = mockPosts.filter((p) => p.status === "dropped").map(ref);
+            batch.archived = designPosts.filter((p) => p.status === "archived").map(ref);
             continue;
         }
-        const post = c.postId ? mockPosts.find((p) => p.id === c.postId) : undefined;
-        batch.comments.push({
+        const post = c.postId ? designPosts.find((p) => p.id === c.postId) : undefined;
+        batch.messages.push({
             seq: c.seq,
             text: c.text,
             state: post?.state ?? null,
@@ -135,18 +206,18 @@ export function groupFeedback(comments, mocks, posts, base = "") {
     return batches;
 }
 export async function buildFeedbackBatches(store, comments, base) {
-    const mocks = new Map();
+    const designs = new Map();
     const posts = new Map();
     for (const c of comments) {
-        if (!c.mockId || mocks.has(c.mockId))
+        if (!c.designId || designs.has(c.designId))
             continue;
-        const mock = await store.getMock(c.mockId);
-        if (!mock)
+        const design = await store.getDesign(c.designId);
+        if (!design)
             continue;
-        mocks.set(c.mockId, mock);
-        posts.set(c.mockId, await store.listPosts({ mockId: c.mockId }));
+        designs.set(c.designId, design);
+        posts.set(c.designId, await store.listPosts({ designId: c.designId }));
     }
-    return groupFeedback(comments, mocks, posts, base);
+    return groupFeedback(comments, designs, posts, base);
 }
 // Every image a list of batches carries, in order — what the MCP tiers attach
 // as image content so the model sees what the user attached.
@@ -157,8 +228,8 @@ export function feedbackImages(batches) {
             for (const c of a.chosen)
                 if ("other" in c && c.images)
                     out.push(...c.images);
-            if (a.noteImages)
-                out.push(...a.noteImages);
+            if (a.commentImages)
+                out.push(...a.commentImages);
         }
     }
     return out;

package/dist/server/fills.d.ts

@@ -26,9 +26,13 @@ export interface FillScan {
 }
 export declare function scanFills(html: string): FillScan;
 export declare function slotKnobs(slots: SlotInfo[]): Knobs;
+export declare const cssString: (s: string) => string;
 export declare function slotCss(slots: SlotInfo[]): string;
 export declare function composeFills(html: string, chosen: Record<string, string>): string;
 export declare function slotsInSurfaces(surfaces: Surface[]): SlotInfo[];
+export declare const AS_IS_FILL = "as-is";
+export declare function partOccurrences(html: string, part: string): number;
+export declare function addFill(html: string, part: string, fill: string, markup: string): string;
 export type FillSplice = {
     ok: true;
     surfaces: Surface[];

package/dist/server/fills.js

@@ -165,7 +165,7 @@ export function slotKnobs(slots) {
     }
     return out;
 }
-const cssString = (s) => `"${s.replace(/[\\"]/g, (c) => `\\${c}`).replace(/[\n\r<>]/g, (c) => `\\${c.charCodeAt(0).toString(16)} `)}"`;
+export const cssString = (s) => `"${s.replace(/[\\"]/g, (c) => `\\${c}`).replace(/[\n\r<>]/g, (c) => `\\${c.charCodeAt(0).toString(16)} `)}"`;
 // Shows only the chosen fill of each slot, keyed on the `data-k-<part>`
 // attribute the knob runtime keeps on <html>. The chosen fill is never styled:
 // only the others are hidden, so a fill keeps whatever display the agent gave it.
@@ -254,6 +254,60 @@ function markFill(html, part, fill) {
     const at = m.index + m[0].indexOf("<") + 1 + m[1].length;
     return html.slice(0, at) + add + html.slice(at);
 }
+// The name a plain part's own markup goes by once an answer adds a fill to it.
+export const AS_IS_FILL = "as-is";
+// How many elements declare this part, fills counted once each. A fill can only be
+// added to a part that is one thing or already has fills.
+export function partOccurrences(html, part) {
+    if (scanAll(html).ranges.some((r) => r.part === part))
+        return 1;
+    let n = 0;
+    walkOpenTags(html, (attrs) => {
+        if (attrs["data-part"] === part)
+            n++;
+    });
+    return n;
+}
+function walkOpenTags(html, visit) {
+    TOKEN.lastIndex = 0;
+    let m;
+    while ((m = TOKEN.exec(html))) {
+        if (m[0].startsWith("<!--") || m[1])
+            continue;
+        const tag = m[2].toLowerCase();
+        const end = TOKEN.lastIndex;
+        visit(attributes(m[3] ?? ""), m.index + 1 + m[2].length);
+        TOKEN.lastIndex = end;
+        if (RAW.has(tag)) {
+            const endTag = new RegExp(`</${tag}\\s*>`, "gi");
+            endTag.lastIndex = end;
+            const e = endTag.exec(html);
+            TOKEN.lastIndex = e ? endTag.lastIndex : html.length;
+        }
+    }
+}
+// Adds a fill at render time, leaving the html as it was when it can't: a version
+// without this part has nothing to fill, and one with its own fill of this name
+// already says what that value means.
+export function addFill(html, part, fill, markup) {
+    const ranges = scanAll(html).ranges.filter((r) => r.part === part);
+    if (ranges.some((r) => r.fill === fill))
+        return html;
+    let base = html;
+    if (ranges.length === 0) {
+        const at = [];
+        walkOpenTags(html, (attrs, tagNameEnd) => {
+            if (attrs["data-part"] === part)
+                at.push(tagNameEnd);
+        });
+        if (at.length !== 1)
+            return html;
+        base = `${html.slice(0, at[0])} data-fill="${AS_IS_FILL}" data-fill-default${html.slice(at[0])}`;
+    }
+    const spliced = spliceFills([{ kind: "html", html: base }], { [`${part}#${fill}`]: markup });
+    const surface = spliced.ok ? spliced.surfaces[0] : undefined;
+    return surface?.kind === "html" ? surface.html : html;
+}
 // Replace one fill of a slot, or add it after the slot's last fill, keyed
 // "part#fill". Like spliceParts, every target is located in the original
 // markup and overlapping edits are refused.

package/dist/server/guidance.d.ts

@@ -0,0 +1,23 @@
+export declare const GUIDE_PACKS: readonly ["design-craft"];
+export type GuidePack = (typeof GUIDE_PACKS)[number];
+export declare const RULES_SETTING = "rules";
+export declare const USER_RULES_SETTING = "userRules";
+export declare const MAX_RULES_CHARS = 6000;
+export interface RulesFile {
+    packs: string[];
+    body: string;
+}
+export declare function parseRulesFile(text: string): RulesFile;
+export interface GuidanceInput {
+    packs: Partial<Record<GuidePack, string>>;
+    user: string | null;
+    project: string | null;
+}
+/**
+ * The guidance line and sections for the brief, or "" when only core is on:
+ * a workspace that never wrote a rules file gets the brief it always had.
+ */
+export declare function guidanceSections(input: GuidanceInput): {
+    line: string;
+    body: string;
+};

package/dist/server/guidance.js

@@ -0,0 +1,71 @@
+// Guidance layers on top of the core brief: packs that ship with mockpit (off
+// until a rules file names them), the user's own rules and the project's.
+// Higher wins: project, then the user's, then packs, then core. The brief
+// prints them in that order from the bottom up, so the last word an agent
+// reads is the one that wins.
+//
+// Runtime-agnostic (no node imports): the Worker builds the brief too.
+export const GUIDE_PACKS = ["design-craft"];
+const isGuidePack = (id) => GUIDE_PACKS.includes(id);
+// `rules:<project>` sits beside `design:<project>` and moves with a project
+// rename. The user's own rules are not a project, so their key has no colon:
+// a project named "user" can't collide with it.
+export const RULES_SETTING = "rules";
+export const USER_RULES_SETTING = "userRules";
+// A rules file is read whole into every brief, so it stays a page, not a book.
+export const MAX_RULES_CHARS = 6_000;
+// `---\npacks: [design-craft]\n---` (or `packs: a, b`, or a `- a` list), then
+// markdown. Anything else in the frontmatter is ignored rather than refused:
+// the file is the user's, and a stray key must not cost them their rules.
+export function parseRulesFile(text) {
+    const src = text.replace(/\r\n?/g, "\n");
+    const m = /^---\n([\s\S]*?)\n---[ \t]*(?:\n|$)/.exec(src);
+    if (!m)
+        return { packs: [], body: src.trim() };
+    const packs = [];
+    const lines = m[1].split("\n");
+    for (let i = 0; i < lines.length; i++) {
+        const kv = /^packs\s*:\s*(.*)$/.exec(lines[i].trim());
+        if (!kv)
+            continue;
+        const inline = kv[1].trim().replace(/^\[|\]$/g, "");
+        if (inline)
+            packs.push(...inline.split(","));
+        for (let j = i + 1; j < lines.length && /^\s*-\s+/.test(lines[j]); j++) {
+            packs.push(lines[j].replace(/^\s*-\s+/, ""));
+        }
+    }
+    const names = packs.map((p) => p.trim().replace(/^["']|["']$/g, "")).filter(Boolean);
+    return { packs: [...new Set(names)], body: src.slice(m[0].length).trim() };
+}
+// The layer files' own `## Rules` / `## Suggestions` sit one level under the
+// layer's heading in the brief.
+const demote = (md) => md.replace(/^(#{1,5}) /gm, "#$1 ");
+/**
+ * The guidance line and sections for the brief, or "" when only core is on:
+ * a workspace that never wrote a rules file gets the brief it always had.
+ */
+export function guidanceSections(input) {
+    const user = input.user ? parseRulesFile(input.user) : null;
+    const project = input.project ? parseRulesFile(input.project) : null;
+    const named = [...new Set([...(user?.packs ?? []), ...(project?.packs ?? [])])];
+    const on = named.filter((p) => isGuidePack(p) && !!input.packs[p]);
+    const unknown = named.filter((p) => !on.includes(p));
+    const layers = [
+        ...on.map((p) => ({ label: p, heading: `Pack: ${p}`, text: input.packs[p].trim() })),
+        ...(user?.body ? [{ label: "your rules", heading: "Your rules", text: user.body }] : []),
+        ...(project?.body
+            ? [{ label: "project", heading: "This project's rules", text: project.body }]
+            : []),
+    ];
+    if (layers.length === 0 && unknown.length === 0)
+        return { line: "", body: "" };
+    const missing = unknown.length
+        ? ` (unknown pack ${unknown.map((p) => `"${p}"`).join(", ")}; packs: ${GUIDE_PACKS.join(", ")})`
+        : "";
+    const line = `Guidance: ${["core", ...layers.map((l) => l.label)].join(" · ")}${missing}. ` +
+        "Higher wins: project, then yours, then packs, then core; the user's own words beat " +
+        "all of them. **Rules** are always followed; **Suggestions** are aimed for.";
+    const body = layers.map((l) => `## ${l.heading}\n\n${demote(l.text)}`).join("\n\n");
+    return { line, body };
+}

package/dist/server/handoff.d.ts

@@ -1,6 +1,9 @@
 import type { Comment, Session } from "./types.ts";
 export declare const HANDOFF_GRACE_MS: number;
-export declare const HANDOFF_NOTE = "Sent to an earlier agent session in this project that has gone quiet; it is yours now. Read the mock before acting.";
+export declare const HANDOFF_NOTE = "Sent to an earlier agent session in this project that has gone quiet; it is yours now. Read the design before acting.";
+export declare const ROUTED_NOTE = "The agent that asked this wasn't listening, so the user sent it to you; it is yours now. Read the design before acting.";
+export declare const OWNER_BUSY_MS: number;
 export declare const ownerActiveAt: (s: Session) => string;
+export declare const sessionName: (s: Session) => string;
 export declare function supersedes(taker: Session, owner: Session, listening: boolean): boolean;
 export declare function handoffReady(comment: Comment, owner: Session, taker: Session, now: number): boolean;

package/dist/server/handoff.js

@@ -1,4 +1,4 @@
-// Orphaned replies: a Send lands on the session that owns the mock, and when
+// Orphaned replies: a Send lands on the session that owns the design, and when
 // that agent restarts into a new session (a new conversation, /clear, a crash)
 // nobody would ever read it. The rule below decides when a newer session may
 // take such a reply instead. Runtime-agnostic (no node imports).
@@ -20,8 +20,14 @@
 // it got before the taker existed goes at once — the user answered, then
 // restarted. A keyed owner always gets the grace: its conversation may resume.
 export const HANDOFF_GRACE_MS = 2 * 60_000;
-export const HANDOFF_NOTE = "Sent to an earlier agent session in this project that has gone quiet; it is yours now. Read the mock before acting.";
+export const HANDOFF_NOTE = "Sent to an earlier agent session in this project that has gone quiet; it is yours now. Read the design before acting.";
+export const ROUTED_NOTE = "The agent that asked this wasn't listening, so the user sent it to you; it is yours now. Read the design before acting.";
+// A waiter stops between a wake and the end of that turn, so an owner that called
+// this recently is working, not gone, and keeps its replies. Same span as "Agent working".
+export const OWNER_BUSY_MS = 5 * 60_000;
 export const ownerActiveAt = (s) => s.agentActiveAt ?? s.lastActiveAt;
+// All the user can recognise a session by: most have no title, and ids mean nothing.
+export const sessionName = (s) => s.cwd?.split(/[\\/]/).filter(Boolean).pop() ?? s.agent;
 export function supersedes(taker, owner, listening) {
     return (owner.id !== taker.id &&
         owner.project !== null &&

package/dist/server/icons.js

@@ -4,7 +4,7 @@
 // imports): it runs inside renderHtmlPage on the Worker too.
 // Served with the server rather than installed per project: lucide (ISC) is
 // what agents reach for by default, mage (Apache-2.0) is what `mockpit init`
-// used to upload as a sprite, so mocks written against it keep rendering.
+// used to upload as a sprite, so designs written against it keep rendering.
 export const BUNDLED_ICON_PREFIXES = ["lucide", "mage"];
 const NAME_RE = /^[a-z0-9][a-z0-9-]*$/;
 export const isIconName = (s) => typeof s === "string" && NAME_RE.test(s);