@sigrun/sigrun 0.1.6 → 0.2.0

package/dist/server/blocks/summaries.js

@@ -0,0 +1,328 @@
+/**
+ * Change-record summaries (UI-blocks U5 Task 2, spec §8.3): core writes
+ * each `ChangeRecord.summary` from the TREE, using the labels the user
+ * saw — the item's `title` slot value, its 1-based position, the
+ * group's (or the enclosing section's) title, and the form field's
+ * `label`.
+ *
+ * The pinned strings (the spec's own examples):
+ * - `moved 'Clair de Lune' from 4th to 1st in 'Ranking'`
+ * - `checked 'milk' in 'Shopping'` (and `unchecked …`)
+ * - `set 'Notes' to '…'` (a `turn: false` submit writes the form's
+ *   values at its `bind`; one `set` per field, joined by `"; "`;
+ *   values over {@link SUMMARY_VALUE_MAX} characters truncate with `…`)
+ *
+ * Never throws: every lookup is optional-typed (a missing binding, a
+ * payload shape the walk does not know) and falls back to the plainest
+ * label available — a summary is a human-read string, not a write path.
+ */
+import { resolvePointer } from "@sigrun/shared/blocks";
+/** The value-render cap (the brief): values over 80 characters truncate with `…`. */
+export const SUMMARY_VALUE_MAX = 80;
+/** Render one value: plain JSON form, capped at 80 characters (`…`). */
+function renderValue(value) {
+    const text = typeof value === "string" ? value : JSON.stringify(value);
+    if (text.length <= SUMMARY_VALUE_MAX)
+        return text;
+    return `${text.slice(0, SUMMARY_VALUE_MAX)}…`;
+}
+/** The 1-based ordinal the position line reads ("1st", "2nd", "11th"). */
+export function ordinal(index) {
+    const oneBased = index + 1;
+    const tail100 = oneBased % 100;
+    if (tail100 >= 11 && tail100 <= 13)
+        return `${oneBased}th`;
+    switch (oneBased % 10) {
+        case 1:
+            return `${oneBased}st`;
+        case 2:
+            return `${oneBased}nd`;
+        case 3:
+            return `${oneBased}rd`;
+        default:
+            return `${oneBased}th`;
+    }
+}
+/** A `move`/`edit` payload endpoint (the `{group?, index}` shape §6.3 sends). */
+function readSpot(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return undefined;
+    }
+    const record = value;
+    return {
+        ...(typeof record.group === "string" ? { group: record.group } : {}),
+        ...(typeof record.index === "number" ? { index: record.index } : {}),
+    };
+}
+/** Resolve a bindable against `data` (`item` scopes `./` bindings). */
+function bound(value, data, item) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value === "string")
+        return value;
+    const resolved = resolvePointer(data, value.$, item);
+    return typeof resolved === "string" ? resolved : undefined;
+}
+/** A plain-record check (the tree walk's node shape). */
+function isRec(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Yield every node of a tree, structurally (the service.ts walk). */
+function* walkNodes(root) {
+    yield root;
+    const childLists = [
+        root.root,
+        root.children,
+        root.fields,
+        root.main,
+        root.sidebar,
+        root.detail,
+    ];
+    for (const list of childLists) {
+        if (Array.isArray(list)) {
+            for (const child of list) {
+                if (isRec(child)) {
+                    if (isRec(child.block)) {
+                        yield* walkNodes(child.block);
+                    }
+                    else {
+                        yield* walkNodes(child);
+                    }
+                }
+            }
+        }
+        else if (isRec(list)) {
+            yield* walkNodes(list);
+        }
+    }
+    if (isRec(root.item))
+        yield* walkNodes(root.item);
+}
+/** The label the user saw above one block: the nearest enclosing section title. */
+function sectionTitleAround(tree, inner, data) {
+    const wanted = inner;
+    const visit = (node, title) => {
+        const nextTitle = node.type === "section" && node.title !== undefined
+            ? bound(node.title, data, undefined)
+            : title;
+        if (node === wanted)
+            return nextTitle;
+        const childLists = [node.root, node.children, node.fields, node.main, node.sidebar, node.detail];
+        for (const list of childLists) {
+            if (Array.isArray(list)) {
+                for (const child of list) {
+                    if (!isRec(child))
+                        continue;
+                    const hit = isRec(child.block)
+                        ? visit(child.block, nextTitle)
+                        : visit(child, nextTitle);
+                    if (hit !== undefined)
+                        return hit;
+                }
+            }
+            else if (isRec(list)) {
+                const hit = visit(list, nextTitle);
+                if (hit !== undefined)
+                    return hit;
+            }
+        }
+        if (isRec(node.item)) {
+            const hit = visit(node.item, nextTitle);
+            if (hit !== undefined)
+                return hit;
+        }
+        return undefined;
+    };
+    // SAFETY: the walk reads only structural record fields (type/children/
+    // item/…) — the wire `Tree` and the loose `JsonObject` view agree on
+    // those, and every read is typeof-guarded below.
+    const found = visit(tree.root, undefined);
+    return found;
+}
+/** The group's display title: the declared group's `title` (a binding resolves
+ *  against the surface data the actor saw), else its id. */
+function groupTitleOf(collection, groupId, data) {
+    const declared = (collection.groups ?? []).find((candidate) => candidate.id === groupId);
+    if (declared === undefined)
+        return groupId;
+    return (bound(declared.title, data, undefined) ?? declared.id);
+}
+/** One summary line, quoted and labelled; empty when nothing was found. */
+function moveSummary(tree, data, payload) {
+    const itemId = payload.itemId;
+    if (typeof itemId !== "string")
+        return undefined;
+    const from = readSpot(payload.from);
+    const to = readSpot(payload.to);
+    if (from === undefined || to === undefined)
+        return undefined;
+    // The collection owning this move: the one whose items array holds
+    // the item (multiple collections may bind the same name handler;
+    // the first holding the item wins).
+    // SAFETY: the walk reads only structural record fields (children/items/
+    // type names) the wire Tree and the loose JsonObject view agree on;
+    // every field read below is typeof-guarded.
+    for (const node of walkNodes(tree.root)) {
+        if (node.type !== "collection")
+            continue;
+        const itemsPath = node.items;
+        if (typeof itemsPath !== "object" || itemsPath === null)
+            continue;
+        const pointer = itemsPath.$;
+        if (typeof pointer !== "string")
+            continue;
+        const items = resolvePointer(data, pointer);
+        if (!Array.isArray(items))
+            continue;
+        const at = items.findIndex((candidate) => isRec(candidate) && candidate.id === itemId);
+        if (at < 0)
+            continue;
+        const item = items[at];
+        const card = isRec(node.item) ? node.item : undefined;
+        const title = card === undefined
+            ? undefined
+            : bound(card.title, data, item);
+        if (title === undefined)
+            continue;
+        // SAFETY: the walk narrowed `node` to a collection record with an
+        // items binding and an item template; the remaining props are read
+        // only through the declared-block type's own names.
+        const collection = node;
+        // A grouped collection labels by the GROUP's title (the label the
+        // user saw over the row); an ungrouped one by the section's.
+        const scope = collection.groupBy === undefined
+            ? (sectionTitleAround(tree, node, data) ?? "")
+            : groupTitleOf(collection, to.group ?? from.group ?? "", data);
+        const where = scope === "" ? "" : ` in '${scope}'`;
+        // The `from` position names the item's located (current) index —
+        // the payload's from.index is only a hint: an interleaved edit
+        // may have moved the row before this action's commit ran, and
+        // the summary must name the positions at APPLY time. A grouped
+        // collection renders WITHIN-GROUP positions (the client's
+        // to.index is the drop index inside the lane), so the "from"
+        // ordinal counts only the item's own lane members — the raw
+        // array index would name a position the user never saw.
+        let fromIndex = at;
+        const groupBy = collection.groupBy;
+        if (groupBy !== undefined && isRec(item)) {
+            const groupValue = item[groupBy];
+            let before = 0;
+            for (let earlier = 0; earlier < at; earlier++) {
+                const candidate = items[earlier];
+                if (isRec(candidate) && candidate[groupBy] === groupValue) {
+                    before += 1;
+                }
+            }
+            fromIndex = before;
+        }
+        return `moved '${title}' from ${ordinal(fromIndex)} to ${ordinal(to.index ?? fromIndex)}${where}`;
+    }
+    return undefined;
+}
+/** The check summary: `checked 'milk' in 'Shopping'`. */
+function checkSummary(tree, data, payload) {
+    const itemId = payload.itemId;
+    if (typeof itemId !== "string")
+        return undefined;
+    // SAFETY: the walk reads only structural record fields the wire Tree
+    // and the loose JsonObject view agree on; every read is guarded.
+    for (const node of walkNodes(tree.root)) {
+        if (node.type !== "collection" || typeof node.checkable !== "string")
+            continue;
+        const itemsPath = node.items;
+        if (typeof itemsPath !== "object" || itemsPath === null)
+            continue;
+        const pointer = itemsPath.$;
+        if (typeof pointer !== "string")
+            continue;
+        const items = resolvePointer(data, pointer);
+        if (!Array.isArray(items))
+            continue;
+        const at = items.findIndex((candidate) => isRec(candidate) && candidate.id === itemId);
+        if (at < 0)
+            continue;
+        const item = items[at];
+        const card = isRec(node.item) ? node.item : undefined;
+        const title = card === undefined
+            ? undefined
+            : bound(card.title, data, item);
+        if (title === undefined)
+            continue;
+        const scope = sectionTitleAround(tree, node, data) ?? "";
+        const where = scope === "" ? "" : ` in '${scope}'`;
+        // `value` omitted means the plain toggle-on the client sends for a
+        // check (planAction defaults true): the verb must agree with the
+        // written value.
+        const verb = payload.value === false ? "unchecked" : "checked";
+        return `${verb} '${title}'${where}`;
+    }
+    return undefined;
+}
+/** A form field's declared label (a binding resolves against `data`). */
+function fieldLabel(field, data) {
+    const label = bound(field.label, data, undefined);
+    return label ?? field.name;
+}
+/** The submit summary: one `set 'Label' to 'value'` per field, `"; "`-joined. */
+function submitSummary(tree, data, payload) {
+    const values = payload.values;
+    if (!isRec(values))
+        return undefined;
+    const parts = [];
+    // SAFETY: the walk reads only structural record fields the wire Tree
+    // and the loose JsonObject view agree on; every read is guarded.
+    for (const node of walkNodes(tree.root)) {
+        if (node.type !== "form" || !Array.isArray(node.children))
+            continue;
+        const fields = [];
+        for (const child of node.children) {
+            if (!isRec(child))
+                continue;
+            if (typeof child.name === "string" && "label" in child) {
+                // SAFETY: the record passed the field shape check (a `name` +
+                // a `label` member); Field's own members are read only through
+                // `fieldLabel`'s guarded accessors.
+                fields.push(child);
+            }
+            else if (child.type === "section" && Array.isArray(child.children)) {
+                for (const grandchild of child.children) {
+                    if (isRec(grandchild) && typeof grandchild.name === "string") {
+                        // SAFETY: same field-shape check as above.
+                        fields.push(grandchild);
+                    }
+                }
+            }
+        }
+        // Only the form(s) whose declared fields appear in the payload.
+        const named = fields.filter((field) => field.name in values);
+        if (named.length === 0)
+            continue;
+        for (const field of named) {
+            const value = values[field.name];
+            parts.push(`set '${fieldLabel(field, data)}' to '${renderValue(value ?? null)}'`);
+        }
+    }
+    if (parts.length === 0)
+        return undefined;
+    return parts.join("; ");
+}
+/**
+ * The summary for one action (spec §8.3). `data` is the surface's data
+ * BEFORE the edit applies — the positions and titles the user saw.
+ */
+export function summarizeAction(tree, data, action, payload) {
+    const record = isRec(payload) ? payload : {};
+    const fallback = "name" in action && typeof action.name === "string"
+        ? `${action.type} ${action.name}`
+        : action.type;
+    if (action.type === "move") {
+        return moveSummary(tree, data, record) ?? fallback;
+    }
+    if (action.type === "edit") {
+        return checkSummary(tree, data, record) ?? fallback;
+    }
+    if (action.type === "submit") {
+        return submitSummary(tree, data, record) ?? fallback;
+    }
+    return fallback;
+}

package/dist/server/commands.js

@@ -101,6 +101,11 @@ export const SLASH_COMMANDS = new Map([
         description: "List jobs (name, next run, last outcome)",
         endpoint: { method: "GET", path: "/v1/jobs" },
     },
+    {
+        name: "settings",
+        description: "Open the settings panel (sections + search)",
+        endpoint: { method: "GET", path: "/v1/settings/sections" },
+    },
 ].map((command) => [command.name, command]));
 /**
  * Merge the core slash-command table with every extension's `commands`

package/dist/server/content-parts-lazy.js

@@ -0,0 +1,13 @@
+/** Resolve parts against a lazily-available env: text parts never touch it. */
+import { resolveParts, } from "./content-parts.js";
+/**
+ * The lazy-env resolve: text parts (the whole answer-projection case)
+ * resolve without the env; the first file/image part awaits it. A sandbox
+ * host that cannot build the env therefore still admits answers.
+ */
+export async function resolvePartsLazy(parts, envPromise, context) {
+    if (parts.every((part) => part.type === "text")) {
+        return resolveParts(parts, {}, context);
+    }
+    return resolveParts(parts, await envPromise, context);
+}

package/dist/server/conversation-handler.js

@@ -22,7 +22,7 @@
  */
 import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
 import { accessOf } from "@sigrun/shared/access";
-import { isSuperuser } from "./auth/principal.js";
+import { accessPrincipalOf } from "./auth/access-principal.js";
 import { conversationId } from "./helpers.js";
 import { SessionMetaDoc } from "./session-meta.js";
 /**
@@ -43,10 +43,7 @@ export function loadConversation(ctx, need = "read") {
                 .send({ error: "conversation_not_found" });
         }
         const meta = await ctx.opened.harness.snapshot(SessionMetaDoc, conversation.id, BACKGROUND_CONTEXT);
-        const access = accessOf({
-            user: request.principal.user,
-            superuser: isSuperuser(request.principal),
-        }, meta ?? {});
+        const access = accessOf(accessPrincipalOf(request.principal, ctx.opened.identity.users), meta ?? {});
         if (access === "none") {
             // Hidden is 404 on every :id route (spec §5.9).
             return await reply

package/dist/server/conversation-ops.js

@@ -16,14 +16,17 @@
  * caller) to map — the same split the inline route bodies had.
  */
 import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
+import { AgentDoc, configure } from "@earendil-works/pi-durable";
 import { accessOf, isSharing, } from "@sigrun/shared/access";
 import { extname } from "node:path";
 import { touchActivity } from "../harness/activity.js";
 import { resolveServedModelRefreshing } from "../harness/providers/refresh.js";
 import { isSuperuser } from "./auth/principal.js";
-import { isConfinedPath, parseSubmissionInput, resolveParts } from "./content-parts.js";
+import { isConfinedPath, parseSubmissionInput } from "./content-parts.js";
+import { resolvePartsLazy } from "./content-parts-lazy.js";
 import { CommandUsageError, expandInput, EXPANDED_ENTRY_KIND, } from "../commands/expand.js";
 import { conversationEnv, readView, SCAN_PAGE_SIZE, storeAgentChange, THINKING_LEVELS, WHEN_BUSY_MODES, } from "./helpers.js";
+import { writePendingNote } from "./blocks/notes.js";
 import { applySessionMetaPatch, DEFAULT_SESSION_META, SessionMetaDoc, validateSessionMetaPatch, } from "./session-meta.js";
 /**
  * One client error from a conversation op: the exact body the routes
@@ -165,6 +168,15 @@ export async function createConversationOp(ctx, input = {}) {
                 });
             }
         }
+        for (const name of input.agent.extensions ?? []) {
+            const at = name.indexOf("@");
+            if (at > 0 && name.slice(at + 1) !== input.owner) {
+                throw new ConversationOpError({
+                    error: "invalid_field",
+                    field: "agent.extensions",
+                });
+            }
+        }
     }
     const selection = input.agent === undefined
         ? undefined
@@ -198,13 +210,16 @@ export async function createConversationOp(ctx, input = {}) {
         if (input.owner !== undefined)
             draft.owner = input.owner;
         // Copy-on-assignment (the tracker requires alias-free roots):
-        // the people-scope array is cloned; the closed scopes spread.
+        // the people-scope arrays are cloned; the closed scopes spread.
         if (input.sharing !== undefined) {
             draft.sharing =
                 input.sharing.scope === "people"
                     ? {
                         scope: "people",
                         users: [...input.sharing.users],
+                        ...(input.sharing.groups === undefined
+                            ? {}
+                            : { groups: [...input.sharing.groups] }),
                         level: input.sharing.level,
                     }
                     : { ...input.sharing };
@@ -213,6 +228,7 @@ export async function createConversationOp(ctx, input = {}) {
             draft.name = input.name;
         if (input.source !== undefined)
             draft.source = input.source;
+        await opened.rewriteUserSelection(tx, conversation.id, undefined, input.owner);
     }, BACKGROUND_CONTEXT);
     const view = await readView(conversation);
     return { id: conversation.id, view };
@@ -264,6 +280,11 @@ export async function submitOp(ctx, conversation, input, opts = {}) {
         (typeof whenBusy !== "string" || !WHEN_BUSY_MODES.includes(whenBusy))) {
         throw new ConversationOpError({ error: "invalid_field", field: "whenBusy" });
     }
+    // The §8.3 change note precedes EVERY turn admission (the note write
+    // precedes `expandInput`: an expansion failure — `invalid_input` —
+    // never strands unnoted edits without at least the note decision
+    // point). A block answer's surface is excluded (§8.4 folded it).
+    await writePendingNote(opened.harness, conversation, opts.skipNoteFor, BACKGROUND_CONTEXT);
     // Resolve path-parts to inline content NOW, against the live
     // workspace: missing paths become explicit error parts; other
     // workspace failures throw — fail-loud. Command expansion (Task 2c)
@@ -277,36 +298,67 @@ export async function submitOp(ctx, conversation, input, opts = {}) {
     // ordinary user input: it maps to the same `invalid_input` 400 shape
     // `parseSubmissionInput` uses, never a 500. Anything else expansion
     // throws is a genuine bug and still falls through as one.
-    const env = await conversationEnv(opened, conversation);
+    // The workspace env resolves lazily (a promise, awaited only by
+    // resolvePartsLazy's file/image parts): an answer submission (opts.entry)
+    // never needs the filesystem, and on a host where the sandbox helper is
+    // unavailable the env would throw — the answer must not depend on it.
+    // A THUNK, not an eager promise: conversationEnv throws (not rejects)
+    // on hosts where the sandbox helper is unavailable, and an eager
+    // creation would fail the ANSWER path too (opts.entry never needs the
+    // filesystem). The thunk is invoked only by the expansion branch.
+    const envThunk = () => conversationEnv(opened, conversation);
     let expansion;
-    try {
-        expansion = await expandInput(parsed.parts, opened.commandExpansion, env, BACKGROUND_CONTEXT);
+    if (opts.entry !== undefined) {
+        // A server-built entry (a block answer) skips expansion entirely:
+        // its content is a projection that never starts with `/`.
+        expansion = { parts: parsed.parts };
+    }
+    else {
+        try {
+            const env = await envThunk();
+            expansion = await expandInput(parsed.parts, opened.commandExpansion, env, BACKGROUND_CONTEXT);
+        }
+        catch (error) {
+            if (error instanceof CommandUsageError) {
+                throw new ConversationOpError({ error: "invalid_input" });
+            }
+            throw error;
+        }
     }
-    catch (error) {
-        if (error instanceof CommandUsageError) {
-            throw new ConversationOpError({ error: "invalid_input" });
+    // The entry disjunction (the brief's enforced invariant): `opts.entry`
+    // and expansion are mutually exclusive BY CONSTRUCTION — the answer's
+    // content is a server-built projection that never starts with `/`. A
+    // state where both would be set (an entry-carrying call whose input
+    // expansion claims) is a programming error, never a silent overwrite,
+    // and throws BEFORE any submission is admitted.
+    if (opts.entry !== undefined) {
+        const first = parsed.parts[0];
+        if (first !== undefined &&
+            first.type === "text" &&
+            first.text.startsWith("/")) {
+            throw new Error("submitOp: opts.entry with an expandable input is a programming error (entry and the expanded entry are mutually exclusive)");
         }
-        throw error;
     }
-    const content = await resolveParts(expansion.parts, env, BACKGROUND_CONTEXT);
+    const content = await resolvePartsLazy(expansion.parts, envThunk(), BACKGROUND_CONTEXT);
+    const entry = opts.entry !== undefined
+        ? opts.entry
+        : expansion.typed === undefined
+            ? undefined
+            : {
+                kind: EXPANDED_ENTRY_KIND,
+                data: {
+                    typed: expansion.typed,
+                    ...(expansion.command === undefined
+                        ? {}
+                        : { command: expansion.command }),
+                },
+            };
     const draft = {
         type: "input",
         content,
         ...(opts.requestId === undefined ? {} : { requestId: opts.requestId }),
         ...(whenBusy === undefined ? {} : { whenBusy: whenBusy }),
-        ...(expansion.typed === undefined
-            ? {}
-            : {
-                entry: {
-                    kind: EXPANDED_ENTRY_KIND,
-                    data: {
-                        typed: expansion.typed,
-                        ...(expansion.command === undefined
-                            ? {}
-                            : { command: expansion.command }),
-                    },
-                },
-            }),
+        ...(entry === undefined ? {} : { entry }),
     };
     // The submit pass-through is retired (§6.7): the memory seam's
     // runSettled owns capture, so submissions admit directly.
@@ -419,7 +471,7 @@ export async function configureOp(ctx, conversation, body) {
         throw new ConversationOpError({ error: "invalid_body" });
     }
     const record = body;
-    const unknownKey = Object.keys(record).find((key) => key !== "model" && key !== "thinking");
+    const unknownKey = Object.keys(record).find((key) => key !== "model" && key !== "thinking" && key !== "extensions");
     if (unknownKey !== undefined) {
         throw new ConversationOpError({
             error: "invalid_field",
@@ -428,7 +480,21 @@ export async function configureOp(ctx, conversation, body) {
     }
     const model = record.model;
     const thinking = record.thinking;
-    if (model === undefined && thinking === undefined) {
+    const extensions = record.extensions;
+    if (extensions !== undefined) {
+        if (!Array.isArray(extensions) ||
+            extensions.some((name) => typeof name !== "string")) {
+            throw new ConversationOpError({ error: "invalid_field", field: "extensions" });
+        }
+        const owner = (await opened.harness.snapshot(SessionMetaDoc, conversation.id, BACKGROUND_CONTEXT))?.owner;
+        for (const name of extensions) {
+            const at = name.indexOf("@");
+            if (at > 0 && name.slice(at + 1) !== owner) {
+                throw new ConversationOpError({ error: "invalid_field", field: "extensions" });
+            }
+        }
+    }
+    if (model === undefined && thinking === undefined && extensions === undefined) {
         // A configure that changes nothing is a client error, not a no-op.
         throw new ConversationOpError({ error: "invalid_body" });
     }
@@ -455,6 +521,13 @@ export async function configureOp(ctx, conversation, body) {
     const storeThinking = storeThinkingFor(opened, parsedModel);
     await conversation.configure({
         ...(parsedModel === undefined ? {} : { model: parsedModel }),
+        ...(extensions === undefined
+            ? {}
+            : {
+                extensions: extensions.map((name) => ({
+                    name,
+                })),
+            }),
         ...(thinking !== undefined
             ? { thinkingLevel: thinking }
             : storeThinking === undefined
@@ -481,10 +554,9 @@ function storeThinkingFor(opened, model) {
  * run inputs and queued inbox items (all conversations); filtered to
  * this conversation, the LOWEST id is the active one — anything queued
  * behind a busy conversation was admitted later and has a higher id.
- * Nothing active is the 404 `no_active_submission`; a `not_found` abort
- * result (the record vanished between inspect and abort) is the same
- * honest answer. `already_placed`/`settled` still report which state
- * the submission was found in (abort is idempotent).
+ * Nothing active is the 404 `no_active_submission`. The 200 result
+ * reports the pre-abort state: queued input withdraws as `aborted`,
+ * while a placed run reports `already_placed` and is genuinely stopped.
  */
 export async function abortOp(ctx, conversation) {
     const { opened } = ctx;
@@ -499,13 +571,15 @@ export async function abortOp(ctx, conversation) {
     if (active === undefined) {
         throw new ConversationOpError({ error: "no_active_submission" }, 404);
     }
-    const result = await opened.harness.abortSubmission(active.id, BACKGROUND_CONTEXT, conversation.id);
-    // `not_found` means the submission's record vanished between `inspect`
-    // and `abort` — the conversation is no longer busy, so the honest answer
-    // is the same as nothing-active.
-    if (result === "not_found") {
-        throw new ConversationOpError({ error: "no_active_submission" }, 404);
-    }
+    // inspect() returns only queued/placed records, so those are the only
+    // reachable result values. AbortResponse still permits "settled" for
+    // compatibility, but this op cannot honestly derive it from inspect.
+    const result = active.status === "queued" ? "aborted" : "already_placed";
+    // The old abortSubmission-only path WITHDREW queued inputs but could
+    // not stop a placed generation. Conversation.abort subsumes both: it
+    // withdraws queued inputs, marks and signals every live non-background
+    // task, then resolves once the conversation scope is idle (C4 /stop).
+    await conversation.abort(BACKGROUND_CONTEXT);
     return { result, submissionId: active.id };
 }
 /**
@@ -577,9 +651,30 @@ export async function forkOp(ctx, conversation, opts = {}) {
     // The fork inherits the parent's agent model — read the resolved
     // agent, fall back to the boot default like create.
     const agent = await conversation.agent(BACKGROUND_CONTEXT);
+    const inheritedSelection = (await opened.harness.snapshot(AgentDoc, conversation.id, BACKGROUND_CONTEXT))?.extensions;
+    // Preserve the stored selection VERBATIM here. `AgentChange` wants
+    // Extension-shaped names and maps them back to strings; looking names
+    // up in the registry would silently drop unresolved/late-install names.
+    const inheritedExtensions = Array.isArray(inheritedSelection)
+        ? inheritedSelection.map((name) => ({ name }))
+        : inheritedSelection === undefined
+            ? undefined
+            : {
+                ...(inheritedSelection.add === undefined
+                    ? {}
+                    : { add: inheritedSelection.add.map((name) => ({ name })) }),
+                ...(inheritedSelection.remove === undefined
+                    ? {}
+                    : { remove: inheritedSelection.remove.map((name) => ({ name })) }),
+            };
     const fork = await conversation.fork(at, {
         ownership: { kind: "ownerless" },
-        agent: { model: agent.model ?? opened.defaultModel },
+        agent: {
+            model: agent.model ?? opened.defaultModel,
+            ...(inheritedExtensions === undefined
+                ? {}
+                : { extensions: inheritedExtensions }),
+        },
     }, BACKGROUND_CONTEXT);
     // The fork's sidebar identity: the copied meta doc carries the
     // source's name/autoName and the namer's attempt count; ONE commit
@@ -596,6 +691,11 @@ export async function forkOp(ctx, conversation, opts = {}) {
     const sourceMeta = await opened.harness.snapshot(SessionMetaDoc, conversation.id, BACKGROUND_CONTEXT);
     const sourceName = sourceMeta?.name ?? sourceMeta?.autoName;
     await fork.commit(async (tx) => {
+        // A relative source cwd belongs to the source owner's workspace.
+        // Do not let a fork by someone else silently retarget it into theirs.
+        if (sourceMeta?.owner !== opts.owner) {
+            await configure(tx, fork.id, { cwd: null });
+        }
         const draft = await tx.doc(SessionMetaDoc, fork.id);
         delete draft.name;
         delete draft.autoName;
@@ -608,6 +708,7 @@ export async function forkOp(ctx, conversation, opts = {}) {
         if (sourceName !== undefined)
             draft.autoName = `${sourceName} (fork)`;
         draft.lastActivityAt = opened.now().toISOString();
+        await opened.rewriteUserSelection(tx, fork.id, sourceMeta?.owner, opts.owner);
     }, BACKGROUND_CONTEXT);
     const view = await readView(fork);
     return { id: fork.id, view };