@sigrun/ext-curator 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -5,6 +5,28 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.0] - 2026-11-03
+### Changed
+- The curator view follows core Skills: the learned-skills and overlays
+  sections are gone (the core `core/skills` view owns them), replaced by
+  a "Skills" page action that navigates to the Skills tab. The view keeps
+  the review feed, the pause switch, and the memory targets.
+- The feed is git-backed: entry ids are commit SHAs, `actor` includes
+  `outside` (rendered "outside sigrun"), undo groups key on the newest
+  commit of a review, and a deep-linked `review` param filters the feed
+  (paging up to three feed pages to find older reviews). Undo resolves
+  the group sha back to the review id before dispatching; a failing undo
+  is a named action error, never a thrown action.
+
+## [0.1.1] - 2026-11-03
+### Fixed
+- Curator questions about your skill notes now open their own conversation
+  instead of landing in your latest one; unanswered questions no longer
+  accumulate. Questions asked before this version stay answerable where they
+  were asked.
+- A review in flight is no longer cancelled by a re-rendered conversation
+  view; only genuinely new activity on the parent aborts it.
+
 ## [0.1.0] - 2026-11-02
 ### Added
 - Scaffold: the `createCurator` factory (the loader contract) declaring the

package/dist/loop1.js

@@ -163,12 +163,24 @@ export function createLoop1(deps) {
             allow,
             ...(focus === undefined ? {} : { focus }),
         });
-        // The parent abort: any activity on the parent while the review
-        // runs fires the signal — the review reviews the conversation it
-        // saw (the host-side driver re-checks the same state itself).
+        // The parent abort: CHURN on the parent while the review runs
+        // fires the signal — the review reviews the conversation it saw
+        // (the host-side driver re-checks the same state itself). The
+        // watch's first frame is the acquisition snapshot (the baseline),
+        // never churn; only a frame carrying MORE model entries than the
+        // baseline means the parent actually moved. A re-rendered view
+        // (a status refresh at the same entry count) is not churn and
+        // must not kill an in-flight review (the coarse-abort ruling).
         const abort = new AbortController();
-        const stopWatch = await deps.host.conversations.watch(id, () => {
-            abort.abort();
+        let baseline;
+        const stopWatch = await deps.host.conversations.watch(id, (view) => {
+            const count = view.entries.length;
+            if (baseline === undefined) {
+                baseline = count; // the snapshot is the baseline, never churn
+                return;
+            }
+            if (count > baseline)
+                abort.abort();
         });
         let result;
         try {

package/dist/steps/overlays.d.ts

@@ -27,9 +27,9 @@
  * step) drains the queue, one `digestRun` per drifted key, and applies
  * the run's verdict — keep (re-anchor the same text on the new hash),
  * drop (remove), rewrite (put the verdict's new text), or unsure (ONE
- * `curator.overlay-question` interaction in the user's most recent
- * owned conversation, applied by `overlayQuestionHandler` from
- * `interactionSettled`). An unparseable verdict changes nothing.
+ * `curator.overlay-question` interaction per skill in ONE new
+ * user-owned conversation per pass, applied by `overlayQuestionHandler`
+ * from `interactionSettled`). An unparseable verdict changes nothing.
  */
 import type { CurationOverlayKey, SigrunHost, SigrunLifecycleHandlers } from "@sigrun/sigrun/extension";
 import { type ModelStepDeps } from "./run.js";
@@ -79,10 +79,14 @@ export declare function detectOverlayDrift(host: SigrunHost, user: string): Prom
 export declare function recheckOverlays(deps: ModelStepDeps): Promise<boolean>;
 /**
  * The `interactionSettled` half: apply a settled overlay question's
- * answer. Only ANSWERED records with a `verdict` of keep/drop apply;
- * every other terminal status (skipped, expired, cancelled) changes
- * nothing. `keep` re-anchors the remembered overlay text on the
- * remembered hash; `drop` removes the overlay. Idempotent per callId
- * (an applied question leaves the pending file).
+ * answer. EVERY terminal status (answered, skipped, cancelled, expired)
+ * drops the entry from the pending file — the file is bounded by
+ * terminal statuses (one open entry per skill key). Only ANSWERED
+ * records with a `verdict` of keep/drop apply; `keep` re-anchors the
+ * remembered overlay text on the remembered hash; `drop` removes the
+ * overlay. The callId is looked up in BOTH the v2 `questions` map and
+ * the migrated `legacy` list, so pre-v2 questions stay answerable
+ * where they were asked. Idempotent per callId (an applied question
+ * leaves the pending file).
  */
 export declare function overlayQuestionHandler(host: SigrunHost): Pick<SigrunLifecycleHandlers, "interactionSettled">;

package/dist/steps/overlays.js

@@ -27,9 +27,9 @@
  * step) drains the queue, one `digestRun` per drifted key, and applies
  * the run's verdict — keep (re-anchor the same text on the new hash),
  * drop (remove), rewrite (put the verdict's new text), or unsure (ONE
- * `curator.overlay-question` interaction in the user's most recent
- * owned conversation, applied by `overlayQuestionHandler` from
- * `interactionSettled`). An unparseable verdict changes nothing.
+ * `curator.overlay-question` interaction per skill in ONE new
+ * user-owned conversation per pass, applied by `overlayQuestionHandler`
+ * from `interactionSettled`). An unparseable verdict changes nothing.
  */
 import { randomUUID } from "node:crypto";
 import { join } from "node:path";
@@ -115,12 +115,9 @@ export async function detectOverlayDrift(host, user) {
 const RECHECK_ALLOW = ["skill_manage"];
 /** The pending questions file under the user's state dir. */
 const PENDING_QUESTIONS_FILE = "overlay-questions.json";
-/** Read the user's pending overlay questions; absent/malformed → []. */
-async function readPendingQuestions(host, user) {
-    const parsed = await readStateJson(join(host.stores.user(user).paths.state, PENDING_QUESTIONS_FILE), []);
-    if (!Array.isArray(parsed))
-        return [];
-    return parsed.filter((entry) => typeof entry === "object" &&
+/** Structural check: one parsed entry is a QuestionDetails. */
+function isQuestion(entry) {
+    return (typeof entry === "object" &&
         entry !== null &&
         typeof entry.user === "string" &&
         typeof entry.key?.root === "string" &&
@@ -129,9 +126,38 @@ async function readPendingQuestions(host, user) {
         typeof entry.overlayText === "string" &&
         typeof entry.callId === "string");
 }
-/** Write the user's pending overlay questions. */
-async function writePendingQuestions(host, user, questions) {
-    await writeStateJson(host.stores.user(user).paths.state, PENDING_QUESTIONS_FILE, questions);
+/** Read the user's pending overlay questions (absent/malformed → empty;
+ *  a legacy top-level ARRAY reads as v1: every entry lands in `legacy`
+ *  unchanged). The write shape is always v2. */
+async function readPendingQuestions(host, user) {
+    const parsed = await readStateJson(join(host.stores.user(user).paths.state, PENDING_QUESTIONS_FILE), { v: 2, questions: {}, legacy: [] });
+    if (Array.isArray(parsed)) {
+        return { questions: {}, legacy: parsed.filter(isQuestion) };
+    }
+    if (typeof parsed !== "object" || parsed === null) {
+        return { questions: {}, legacy: [] };
+    }
+    const raw = parsed;
+    const questions = {};
+    if (typeof raw.questions === "object" &&
+        raw.questions !== null &&
+        !Array.isArray(raw.questions)) {
+        for (const [id, entry] of Object.entries(raw.questions)) {
+            if (isQuestion(entry) &&
+                typeof entry.conversationId === "number") {
+                questions[id] = entry;
+            }
+        }
+    }
+    const legacy = Array.isArray(raw.legacy)
+        ? raw.legacy.filter(isQuestion)
+        : [];
+    return { questions, legacy };
+}
+/** Write the user's pending overlay questions (the v2 shape — legacy
+ *  questions keep their entries but the file is v2 from here on). */
+async function writePendingQuestions(host, user, file) {
+    await writeStateJson(host.stores.user(user).paths.state, PENDING_QUESTIONS_FILE, { v: 2, questions: file.questions, legacy: file.legacy });
 }
 /**
  * The overlay-recheck step (loop 2 step `overlay-recheck`): drain the
@@ -155,10 +181,13 @@ export async function recheckOverlays(deps) {
     if (deps.budget.left() < 1)
         return false; // the day is spent: stop the pass
     const keys = [...(await new OverlayRecheckQueue(host, user).take())];
+    // ONE lazily created question conversation for the whole pass (spec
+    // §5.6: one conversation per recheck call, not one per question).
+    const conversation = { promised: undefined, seeded: 0 };
     for (const key of keys) {
         if (deps.now().getTime() >= deps.deadlineAt)
             return false;
-        const applied = await recheckOne(deps, key).catch((error) => {
+        const applied = await recheckOne(deps, key, conversation).catch((error) => {
             log(`loop 2: ${user} overlay re-check of ${key.skill} failed: ${error instanceof Error ? error.message : String(error)}`);
             return true;
         });
@@ -168,7 +197,7 @@ export async function recheckOverlays(deps) {
     return true;
 }
 /** Re-check one key: run, parse the verdict, apply it. */
-async function recheckOne(deps, key) {
+async function recheckOne(deps, key, conversation) {
     const { host, user } = deps;
     const store = host.curation.overlays(user);
     const overlay = await store.get(key);
@@ -204,7 +233,7 @@ async function recheckOne(deps, key) {
             await store.put(key, verdict.text, upstream.hash, meta);
             return true;
         case "unsure":
-            await askOverlayQuestion(deps, key, overlay.text, upstream.hash);
+            await askOverlayQuestion(deps, key, overlay.text, upstream.hash, conversation);
             return true;
         default:
             return true; // unknown verdict word: no change
@@ -233,22 +262,66 @@ function recheckInput(overlayText, oldHash, newBody, newHash) {
 /** The zero-signal context the seed call runs under (a tick has no
  *  caller signal — the job's deadline is the bound that matters). */
 const SEED_CONTEXT = { abortSignal: undefined };
+/** The conversation's title: named for what it holds. */
+function questionConversationTitle(seeded, skill) {
+    return seeded === 1 && skill !== undefined
+        ? `Your notes on "${skill}"`
+        : `Your notes on ${seeded} skills`;
+}
+/** The id of the pass's question conversation, creating it on the
+ *  first question (owned by the user, titled for what it holds). */
+async function questionConversation(deps, conversation, skill) {
+    if (conversation.promised === undefined) {
+        conversation.seeded = 1;
+        conversation.promised = deps.host.conversations.create({
+            owner: deps.user,
+            name: questionConversationTitle(1, skill),
+        });
+        return conversation.promised;
+    }
+    const id = await conversation.promised;
+    conversation.seeded += 1;
+    // A second question renames the conversation to cover what it now
+    // holds; a failed rename never loses the question (logged only).
+    try {
+        await deps.host.conversations.patchMeta(id, {
+            name: questionConversationTitle(conversation.seeded),
+        });
+    }
+    catch (error) {
+        stepLog(deps)(`loop 2: renaming the overlay-question conversation failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return id;
+}
 /**
- * Seed ONE `curator.overlay-question` in the user's MOST RECENT owned
- * conversation and remember it durably (the settled handler needs the
- * overlay text and hash — the interaction's `details` carry them, and
- * the pending-questions file is the crash-safe copy: an answered
- * question whose apply crashed re-applies on the next handler fire).
+ * Ask ONE `curator.overlay-question` for a drifted overlay: the pass's
+ * shared NEW conversation (created lazily, owned by the user) gets the
+ * question, and the pending file keeps one open question per skill —
+ * the bounding rule (spec §5.5, ruling 8: no timers, no auto-expiry;
+ * keying and terminal statuses bound the file, never age).
+ *
+ * Order per question: create the conversation if needed, cancel the
+ * skill's old open question (a re-ask replaces it; a GONE old
+ * conversation — settle resolves false or rejects — still lets the new
+ * question be asked), seed, write the file. Only then, for the first
+ * question of the pass, send the owner a notice linking to the
+ * conversation; a FAILED notice never loses the question (try/catch-log).
  */
-async function askOverlayQuestion(deps, key, overlayText, upstreamHash) {
+async function askOverlayQuestion(deps, key, overlayText, upstreamHash, conversation) {
     const { host, user } = deps;
-    const owned = await host.conversations.list({ owner: user });
-    const withActivity = owned
-        .filter((row) => row.lastActivityAt !== undefined)
-        .sort((a, b) => Date.parse(b.lastActivityAt) - Date.parse(a.lastActivityAt));
-    const target = withActivity[0] ?? owned[owned.length - 1];
-    if (target === undefined)
-        return; // no owned conversation to ask in
+    const log = stepLog(deps);
+    const file = await readPendingQuestions(host, user);
+    const id = keyId(key);
+    const old = file.questions[id];
+    const conversationId = await questionConversation(deps, conversation, key.skill);
+    if (old !== undefined) {
+        try {
+            await host.settleInteraction(old.conversationId, old.callId, "cancelled", SEED_CONTEXT);
+        }
+        catch (error) {
+            log(`loop 2: cancelling the previous overlay question for ${key.skill} failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
     const callId = `overlay-question-${randomUUID()}`;
     const details = {
         user,
@@ -267,8 +340,28 @@ async function askOverlayQuestion(deps, key, overlayText, upstreamHash) {
         // contract; the structural QuestionDetails shape is JSON-safe.
         details: details,
     };
-    await host.seedInteraction(target.id, record, SEED_CONTEXT);
-    await writePendingQuestions(host, user, [...(await readPendingQuestions(host, user)).filter((q) => q.callId !== callId), details]);
+    await host.seedInteraction(conversationId, record, SEED_CONTEXT);
+    await writePendingQuestions(host, user, {
+        questions: {
+            ...file.questions,
+            [id]: { ...details, conversationId: conversationId },
+        },
+        legacy: file.legacy,
+    });
+    if (conversation.seeded !== 1)
+        return; // only the first question notifies
+    try {
+        await host.notify({
+            user,
+            title: "Notes to review",
+            body: `The curator has a question about your notes on "${key.skill}".`,
+            kind: CURATOR_OVERLAY_QUESTION_KIND,
+            target: { conversation: conversationId },
+        });
+    }
+    catch (error) {
+        log(`loop 2: the overlay-question notice for ${user} failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
 }
 /** The question's form body: exactly keep / drop. The overlay text
  *  rides a section (a form's children are fields and sections only;
@@ -305,54 +398,79 @@ function questionBody(key, overlayText) {
 }
 /**
  * The `interactionSettled` half: apply a settled overlay question's
- * answer. Only ANSWERED records with a `verdict` of keep/drop apply;
- * every other terminal status (skipped, expired, cancelled) changes
- * nothing. `keep` re-anchors the remembered overlay text on the
- * remembered hash; `drop` removes the overlay. Idempotent per callId
- * (an applied question leaves the pending file).
+ * answer. EVERY terminal status (answered, skipped, cancelled, expired)
+ * drops the entry from the pending file — the file is bounded by
+ * terminal statuses (one open entry per skill key). Only ANSWERED
+ * records with a `verdict` of keep/drop apply; `keep` re-anchors the
+ * remembered overlay text on the remembered hash; `drop` removes the
+ * overlay. The callId is looked up in BOTH the v2 `questions` map and
+ * the migrated `legacy` list, so pre-v2 questions stay answerable
+ * where they were asked. Idempotent per callId (an applied question
+ * leaves the pending file).
  */
 export function overlayQuestionHandler(host) {
     return {
         interactionSettled: async (event, _api, _context) => {
             if (event.kind !== CURATOR_OVERLAY_QUESTION_KIND)
                 return;
-            if (event.status !== "answered")
+            if (event.status !== "answered" &&
+                event.status !== "skipped" &&
+                event.status !== "cancelled" &&
+                event.status !== "expired")
                 return;
-            const verdict = event.answer?.["verdict"];
-            if (verdict !== "keep" && verdict !== "drop")
+            const found = await findQuestion(host, event.callId);
+            if (found === undefined)
                 return;
-            const questions = await readQuestionsFor(host, event.callId);
-            for (const question of questions) {
-                const store = host.curation.overlays(question.user);
-                const meta = {
-                    actor: "curator",
-                    reason: `user chose to ${verdict} the overlay`,
-                };
-                if (verdict === "keep") {
-                    await store.put(question.key, question.overlayText, question.upstreamHash, meta);
+            const { user, question } = found;
+            if (event.status === "answered") {
+                const verdict = event.answer?.["verdict"];
+                if (verdict === "keep" || verdict === "drop") {
+                    const store = host.curation.overlays(user);
+                    const meta = {
+                        actor: "curator",
+                        reason: `user chose to ${verdict} the overlay`,
+                    };
+                    if (verdict === "keep") {
+                        await store.put(question.key, question.overlayText, question.upstreamHash, meta);
+                    }
+                    else {
+                        await store.remove(question.key, meta);
+                    }
                 }
-                else {
-                    await store.remove(question.key, meta);
-                }
-                await dropQuestion(host, question.user, question.callId);
             }
+            await dropQuestion(host, user, question.callId);
         },
     };
 }
-/** Read one user's pending questions — the handler scans every user's
- *  file (the event names the callId, not the user). */
-async function readQuestionsFor(host, callId) {
-    const found = [];
+/** Find one pending question by callId — the handler scans every user's
+ *  file (the event names the callId, not the user), both the v2
+ *  `questions` map and the migrated `legacy` list. */
+async function findQuestion(host, callId) {
     for (const row of await host.users.list()) {
-        for (const question of await readPendingQuestions(host, row.user)) {
+        const file = await readPendingQuestions(host, row.user);
+        for (const question of Object.values(file.questions)) {
             if (question.callId === callId)
-                found.push(question);
+                return { user: row.user, question };
+        }
+        for (const question of file.legacy) {
+            if (question.callId === callId)
+                return { user: row.user, question };
         }
     }
-    return found;
+    return undefined;
 }
-/** Remove an applied question from its user's pending file. */
+/** Remove a question from its user's pending file — from BOTH the v2
+ *  map (by matching callId, in case the file drifted) and the legacy
+ *  list. */
 async function dropQuestion(host, user, callId) {
-    const remaining = (await readPendingQuestions(host, user)).filter((question) => question.callId !== callId);
-    await writePendingQuestions(host, user, remaining);
+    const file = await readPendingQuestions(host, user);
+    const questions = {};
+    for (const [id, question] of Object.entries(file.questions)) {
+        if (question.callId !== callId)
+            questions[id] = question;
+    }
+    await writePendingQuestions(host, user, {
+        questions,
+        legacy: file.legacy.filter((question) => question.callId !== callId),
+    });
 }

package/dist/view.d.ts

@@ -1,9 +1,23 @@
 /**
- * The curator view (`src/view.ts`, Task B5): the per-user surface the
- * notice navigates to — learned skills (name, description, last used,
- * pin toggle, archive/restore), overlays (orphaned flag), the change
- * feed (newest 50) grouped by review with an **Undo review** action,
- * and a pause switch.
+ * The curator view (`src/view.ts`, tabs+skills Task 13): the per-user
+ * surface the notice and the core Skills history link navigate to —
+ * the change FEED (newest 50) with an **Undo review** action per
+ * review, and a pause switch. Skill management (list, pin,
+ * archive/restore, overlays) moved to the core Skills view when it
+ * landed (core-views/skills.ts): this view lists no learned skills and
+ * no overlays any more, and its **Skills** page action navigates
+ * `{target:{view:{extension:"core", id:"skills"}}}`.
+ *
+ * A `review` param filters the feed to that review's commits (the core
+ * skills history's curator-commit link and the notice both navigate
+ * here with it). Feed entry ids are commit SHAs in the user's curation
+ * history repo (tabs+skills Task 9), so the undo groups key on the
+ * SHA, never on the review id: a review reverted through
+ * `host.curation.undoReview` needs every commit the review authored,
+ * and grouping by review id would merge two interleaved reviews into
+ * one undo. Actors render as their names — `curator`, `agent`, the
+ * user, and `outside sigrun` for catch-up commits the store itself
+ * did not author (the git trailer's actor name).
  *
  * Access follows `accessOf` (spec P8: "the user, plus the superuser as
  * with conversations"): the resource is the caller's OWN curation data,
@@ -17,19 +31,16 @@
  *
  * The actions (what an ambient record can never carry — a view's action
  * routes DO reach the extension). Per-item actions ride the block
- * set's item-scoped dispatches, which carry `{itemId}` (a card action
- * button's submit dispatches a `null` payload — it cannot name an
- * item, `onCheck`/`onActivate` can):
+ * set's item-scoped dispatches, which carry `{itemId}`:
  *
- * - `pin` — the skills collection's `checkable`/`onCheck`:
- *   `{itemId: skill, value}` → the skill store's `pin`;
- * - `toggleArchive` — the skills collection's `onActivate`
- *   (`{itemId: skill}`): reads the store's current state and archives
- *   or restores through `apply` (feed-recorded, undoable);
  * - `undoReview` — the feed collection's `onActivate`
- *   (`{itemId: reviewId}`): `host.curation.undoReview`, then
- *   `host.clearAmbient` on the notice conversation's `curator.notice`
- *   slot (the notice ledger in `src/notices.ts` remembers it);
+ *   (`{itemId: groupId}` where the group id is `review-<newest sha>`):
+ *   resolves the sha back to the entry's review id through the feed
+ *   (core's `undoReview` matches `entry.reviewId`, never the group
+ *   key), then `host.curation.undoReview`, then `host.clearAmbient` on
+ *   the notice conversation's `curator.notice` slot (the notice ledger
+ *   in `src/notices.ts` remembers it); a commit with no review id
+ *   answers "Nothing to undo" without calling the host;
  * - `setPaused` — the page header's pause button (a submit dispatching
  *   `{}`): toggles the user's `paused` setting, read live by both
  *   loops — pausing takes effect on the next event, restart-free.
@@ -43,6 +54,11 @@ import type { CurationFeedEntry, Principal, SigrunHost, SurfaceDef } from "@sigr
 import type { Access } from "@sigrun/shared/access";
 /** How many feed entries the view lists (the brief: newest 50). */
 export declare const VIEW_FEED_LIMIT = 50;
+/** How many pages a `review` deep-link walks before giving up (the
+ *  link arrives from the core skills history at ANY depth; core's
+ *  own `feedOf` walks until the entries run out — this view bounds
+ *  the walk and says so when the bound elapses). */
+export declare const VIEW_FEED_MAX_PAGES = 3;
 /** One grouped review block in the feed (newest first). */
 export interface ReviewGroup {
     readonly id: string;
@@ -52,6 +68,7 @@ export interface ReviewGroup {
         readonly skill: string;
         readonly action: string;
         readonly at: string;
+        readonly actor: string;
         readonly reason?: string;
     }[];
 }
@@ -59,21 +76,11 @@ export interface ReviewGroup {
 export interface CuratorViewData {
     readonly user: string;
     readonly paused: boolean;
-    readonly skills: readonly {
-        readonly id: string;
-        readonly name: string;
-        readonly description: string;
-        readonly archived: boolean;
-        readonly pinned: boolean;
-        readonly lastUsedLabel: string;
-    }[];
-    readonly overlays: readonly {
-        readonly id: string;
-        readonly skill: string;
-        readonly root: string;
-        readonly orphaned: boolean;
-    }[];
     readonly reviews: readonly ReviewGroup[];
+    /** True when a `review` deep-link missed after the bounded walk
+     *  (the empty state is then "older than the recent changes", never
+     *  the false "Nothing learned yet"). */
+    readonly reviewMissed: boolean;
 }
 /**
  * Resolve one principal's access to their per-user view instance (spec
@@ -84,9 +91,15 @@ export interface CuratorViewData {
  * rule would widen to household write, so anonymous is none BY HAND.
  */
 export declare function viewAccess(principal: Principal, user: string): Access;
-/** Group a feed by review: entries sharing a reviewId form one group
- *  (the feed's newest-first order preserved, outside and inside). An
- *  entry with no reviewId (user pins, direct edits) groups alone. */
+/** One actor's display name (the git trailer's name: outside
+ *  catch-up commits render as "outside sigrun"). */
+export declare function actorLabel(entry: CurationFeedEntry): string;
+/** Group a feed for undo: entries SHARING A REVIEW ID AND ADJACENT in
+ *  the newest-first feed form one group — the group's id is its newest
+ *  commit sha (`review-<sha>`). Keying on the sha (never the review
+ *  id) keeps two interleaved reviews apart: undoing one must revert
+ *  exactly the commits it authored. An entry with no reviewId groups
+ *  alone (a lone commit is never undoable as a review). */
 export declare function groupFeed(feed: readonly CurationFeedEntry[]): readonly ReviewGroup[];
 /** The view surface (`SurfaceDef<"view">`), built over the host. */
 export declare function createCuratorView(host: SigrunHost): SurfaceDef<"view">;

package/dist/view.js

@@ -1,9 +1,23 @@
 /**
- * The curator view (`src/view.ts`, Task B5): the per-user surface the
- * notice navigates to — learned skills (name, description, last used,
- * pin toggle, archive/restore), overlays (orphaned flag), the change
- * feed (newest 50) grouped by review with an **Undo review** action,
- * and a pause switch.
+ * The curator view (`src/view.ts`, tabs+skills Task 13): the per-user
+ * surface the notice and the core Skills history link navigate to —
+ * the change FEED (newest 50) with an **Undo review** action per
+ * review, and a pause switch. Skill management (list, pin,
+ * archive/restore, overlays) moved to the core Skills view when it
+ * landed (core-views/skills.ts): this view lists no learned skills and
+ * no overlays any more, and its **Skills** page action navigates
+ * `{target:{view:{extension:"core", id:"skills"}}}`.
+ *
+ * A `review` param filters the feed to that review's commits (the core
+ * skills history's curator-commit link and the notice both navigate
+ * here with it). Feed entry ids are commit SHAs in the user's curation
+ * history repo (tabs+skills Task 9), so the undo groups key on the
+ * SHA, never on the review id: a review reverted through
+ * `host.curation.undoReview` needs every commit the review authored,
+ * and grouping by review id would merge two interleaved reviews into
+ * one undo. Actors render as their names — `curator`, `agent`, the
+ * user, and `outside sigrun` for catch-up commits the store itself
+ * did not author (the git trailer's actor name).
  *
  * Access follows `accessOf` (spec P8: "the user, plus the superuser as
  * with conversations"): the resource is the caller's OWN curation data,
@@ -17,19 +31,16 @@
  *
  * The actions (what an ambient record can never carry — a view's action
  * routes DO reach the extension). Per-item actions ride the block
- * set's item-scoped dispatches, which carry `{itemId}` (a card action
- * button's submit dispatches a `null` payload — it cannot name an
- * item, `onCheck`/`onActivate` can):
+ * set's item-scoped dispatches, which carry `{itemId}`:
  *
- * - `pin` — the skills collection's `checkable`/`onCheck`:
- *   `{itemId: skill, value}` → the skill store's `pin`;
- * - `toggleArchive` — the skills collection's `onActivate`
- *   (`{itemId: skill}`): reads the store's current state and archives
- *   or restores through `apply` (feed-recorded, undoable);
  * - `undoReview` — the feed collection's `onActivate`
- *   (`{itemId: reviewId}`): `host.curation.undoReview`, then
- *   `host.clearAmbient` on the notice conversation's `curator.notice`
- *   slot (the notice ledger in `src/notices.ts` remembers it);
+ *   (`{itemId: groupId}` where the group id is `review-<newest sha>`):
+ *   resolves the sha back to the entry's review id through the feed
+ *   (core's `undoReview` matches `entry.reviewId`, never the group
+ *   key), then `host.curation.undoReview`, then `host.clearAmbient` on
+ *   the notice conversation's `curator.notice` slot (the notice ledger
+ *   in `src/notices.ts` remembers it); a commit with no review id
+ *   answers "Nothing to undo" without calling the host;
  * - `setPaused` — the page header's pause button (a submit dispatching
  *   `{}`): toggles the user's `paused` setting, read live by both
  *   loops — pausing takes effect on the next event, restart-free.
@@ -45,6 +56,11 @@ import { CURATOR_NOTICE_KIND } from "./notices.js";
 import { parseCuratorSettings } from "./settings.js";
 /** How many feed entries the view lists (the brief: newest 50). */
 export const VIEW_FEED_LIMIT = 50;
+/** How many pages a `review` deep-link walks before giving up (the
+ *  link arrives from the core skills history at ANY depth; core's
+ *  own `feedOf` walks until the entries run out — this view bounds
+ *  the walk and says so when the bound elapses). */
+export const VIEW_FEED_MAX_PAGES = 3;
 /** The zero-signal context the ambient clear runs under. */
 const CONTEXT = { abortSignal: undefined };
 /**
@@ -60,84 +76,98 @@ export function viewAccess(principal, user) {
         return "none";
     return accessOf({ user: principal.user, superuser: principal.service }, { owner: user });
 }
-/** Group a feed by review: entries sharing a reviewId form one group
- *  (the feed's newest-first order preserved, outside and inside). An
- *  entry with no reviewId (user pins, direct edits) groups alone. */
+/** One actor's display name (the git trailer's name: outside
+ *  catch-up commits render as "outside sigrun"). */
+export function actorLabel(entry) {
+    return entry.actor === "outside" ? "outside sigrun" : entry.actor;
+}
+/** Group a feed for undo: entries SHARING A REVIEW ID AND ADJACENT in
+ *  the newest-first feed form one group — the group's id is its newest
+ *  commit sha (`review-<sha>`). Keying on the sha (never the review
+ *  id) keeps two interleaved reviews apart: undoing one must revert
+ *  exactly the commits it authored. An entry with no reviewId groups
+ *  alone (a lone commit is never undoable as a review). */
 export function groupFeed(feed) {
-    const groups = new Map();
+    const groups = [];
+    let current;
+    let currentReview;
     for (const entry of feed) {
-        const key = entry.reviewId ?? entry.id;
         const row = {
             id: entry.id,
             skill: entry.skill,
             action: entry.action,
             at: entry.at,
+            actor: actorLabel(entry),
             ...(entry.reason === undefined ? {} : { reason: entry.reason }),
         };
-        const existing = groups.get(key);
-        if (existing === undefined) {
-            groups.set(key, { id: key, at: entry.at, entries: [row] });
+        if (entry.reviewId !== undefined &&
+            current !== undefined &&
+            currentReview === entry.reviewId) {
+            current = { ...current, entries: [...current.entries, row] };
+            groups[groups.length - 1] = current;
         }
         else {
-            groups.set(key, { ...existing, entries: [...existing.entries, row] });
+            current = {
+                id: `review-${entry.id}`,
+                at: entry.at,
+                entries: [row],
+            };
+            groups.push(current);
         }
+        currentReview = entry.reviewId;
     }
-    return [...groups.values()];
+    return groups;
+}
+/** The `review` param a render was anchored at (the core skills
+ *  history link and the notice navigate with it), or undefined. */
+function reviewParam(ctx) {
+    const review = ctx.params.review;
+    return typeof review === "string" && review !== "" ? review : undefined;
 }
-/** A human label for one skill's last-used stamp ("never" or the date). */
-function lastUsedLabel(at) {
-    if (at === undefined)
-        return "never";
-    const date = new Date(at);
-    return Number.isNaN(date.getTime()) ? "never" : date.toISOString().slice(0, 10);
+/** Read the feed: the plain view is the newest VIEW_FEED_LIMIT only
+ *  (the section's "newest 50" contract — every rendered group's sha
+ *  resolves for undo from that same page). A `review` deep-link pages
+ *  on (last sha as the cursor, core's feedOf shape, bounded) until
+ *  the review's entries appear or the walk elapses; a miss on ANY
+ *  exit path — short page or bound — is reported, never rendered as
+ *  the false "Nothing learned yet". */
+async function feedFor(host, user, review) {
+    const store = host.curation.skills(user);
+    const collected = [];
+    let before;
+    do {
+        const rows = await store.feed(VIEW_FEED_LIMIT, before);
+        collected.push(...rows);
+        if (rows.length < VIEW_FEED_LIMIT)
+            break; // the last page
+        if (review !== undefined &&
+            rows.some((entry) => entry.reviewId === review))
+            break; // the deep-link found its review
+        before = rows[rows.length - 1]?.id;
+    } while (review !== undefined && collected.length < VIEW_FEED_LIMIT * VIEW_FEED_MAX_PAGES);
+    return {
+        feed: collected,
+        reviewMissed: review !== undefined &&
+            !collected.some((entry) => entry.reviewId === review),
+    };
 }
 /** Build the view's data document for one user (the render's model). */
-async function readData(host, user) {
+async function readData(host, user, review) {
     const settings = parseCuratorSettings(await host.stores.user(user).settings.get());
-    const usage = await host.curation.usage(user);
-    const skills = await host.curation.skills(user).list();
-    const overlays = await host.curation.overlays(user).list();
-    const feed = await host.curation.skills(user).feed(VIEW_FEED_LIMIT);
+    const { feed, reviewMissed } = await feedFor(host, user, review);
     return {
         user,
         paused: settings.paused,
-        skills: [...skills]
-            .sort((a, b) => a.name.localeCompare(b.name))
-            .map((row) => ({
-            id: row.name,
-            name: row.name,
-            description: row.description,
-            archived: row.archived,
-            pinned: row.pinned,
-            lastUsedLabel: lastUsedLabel(usage[row.name]),
-        })),
-        overlays: [...overlays]
-            .map((row) => ({
-            id: row.key.skill,
-            skill: row.key.skill,
-            root: row.key.root,
-            orphaned: row.orphanedSince !== undefined,
-        }))
-            .sort((a, b) => a.skill.localeCompare(b.skill)),
-        reviews: groupFeed(feed),
+        reviews: groupFeed(review === undefined
+            ? feed
+            : feed.filter((entry) => entry.reviewId === review)),
+        reviewMissed,
     };
 }
 /** Whether `payload` (an action's JSON argument) is a plain object. */
 function isObject(payload) {
     return typeof payload === "object" && payload !== null && !Array.isArray(payload);
 }
-/** The `{itemId, value}` dispatch an `onCheck` toggle carries. */
-function itemToggle(payload) {
-    if (!isObject(payload))
-        return undefined;
-    const itemId = payload.itemId;
-    const value = payload.value;
-    if (typeof itemId !== "string" || itemId === "")
-        return undefined;
-    if (typeof value !== "boolean")
-        return undefined;
-    return { itemId, value };
-}
 /** The `{itemId}` dispatch an `onActivate` click carries. */
 function itemIdOf(payload) {
     if (!isObject(payload))
@@ -174,7 +204,7 @@ export function createCuratorView(host) {
             if ("reject" in who) {
                 return { tree: emptyTree(), data: {}, access: "none" };
             }
-            const data = await readData(host, who.user);
+            const data = await readData(host, who.user, reviewParam(ctx));
             return {
                 tree: viewTree(data),
                 // SAFETY: the data document is a JSON mirror (every field a
@@ -190,7 +220,7 @@ export function createCuratorView(host) {
                 return { data: {}, access: "none" };
             return {
                 // SAFETY: same JSON-mirror cast as `render`'s (the comment there).
-                data: (await readData(host, who.user)),
+                data: (await readData(host, who.user, reviewParam(ctx))),
                 access: "write",
             };
         },
@@ -199,11 +229,65 @@ export function createCuratorView(host) {
                 const who = callerOf(ctx);
                 if ("reject" in who)
                     return who.reject;
-                const reviewId = itemIdOf(payload);
-                if (reviewId === undefined) {
+                const itemId = itemIdOf(payload);
+                if (itemId === undefined) {
                     return { ok: false, error: { message: "undoReview expects {itemId}" } };
                 }
-                const reverted = await host.curation.undoReview(who.user, reviewId);
+                // A failing undo (the store's report, or a host error) is a
+                // named action error — never a thrown action the surface
+                // layer renders generically (main's 774c660 semantics,
+                // kept through the git-history rework).
+                const fail = (cause) => ({
+                    ok: false,
+                    error: { message: cause instanceof Error ? cause.message : String(cause) },
+                });
+                // On a deep-link the param already names the review — and
+                // the group's sha may sit past page 1 of the feed, where
+                // the single-page lookup below cannot see it. Dispatch the
+                // param's review id directly.
+                const anchored = reviewParam(ctx);
+                if (anchored !== undefined) {
+                    let reverted;
+                    try {
+                        reverted = await host.curation.undoReview(who.user, anchored);
+                    }
+                    catch (cause) {
+                        return fail(cause);
+                    }
+                    const anchoredNotice = (await readNotices(host, who.user)).find((entry) => entry.reviewId === anchored);
+                    if (anchoredNotice !== undefined) {
+                        await host.clearAmbient(anchoredNotice.conversationId, CURATOR_NOTICE_KIND, CONTEXT).catch(() => undefined);
+                    }
+                    return {
+                        ok: true,
+                        toast: reverted > 0 ? `Undid ${reverted} change(s)` : "Nothing to undo",
+                    };
+                }
+                // The dispatch carries the GROUP key (`review-<sha>`, minted
+                // by groupFeed); core's undoReview matches entry.reviewId.
+                // Resolve the sha back to the review id through the feed — a
+                // verbatim dispatch would match nothing and silently revert 0.
+                // A bare review id (the pre-upgrade coordinate, and digest
+                // ids like "digest-<date>" that already carry the prefix) is
+                // the fallback when no entry's sha matches.
+                const sha = itemId.startsWith("review-")
+                    ? itemId.slice("review-".length)
+                    : itemId;
+                const feed = await host.curation.skills(who.user).feed(VIEW_FEED_LIMIT);
+                const reviewId = feed.find((entry) => entry.id === sha)?.reviewId ??
+                    (feed.some((entry) => entry.reviewId === itemId)
+                        ? itemId
+                        : undefined);
+                if (reviewId === undefined) {
+                    return { ok: true, toast: "Nothing to undo" };
+                }
+                let reverted;
+                try {
+                    reverted = await host.curation.undoReview(who.user, reviewId);
+                }
+                catch (cause) {
+                    return fail(cause);
+                }
                 // Clear the notice this review set, when the ledger remembers
                 // one (a digest review with no notice clears nothing).
                 const notice = (await readNotices(host, who.user)).find((entry) => entry.reviewId === reviewId);
@@ -218,45 +302,6 @@ export function createCuratorView(host) {
                     toast: reverted > 0 ? `Undid ${reverted} change(s)` : "Nothing to undo",
                 };
             },
-            pin: async (ctx, payload) => {
-                const who = callerOf(ctx);
-                if ("reject" in who)
-                    return who.reject;
-                const toggle = itemToggle(payload);
-                if (toggle === undefined) {
-                    return { ok: false, error: { message: "pin expects {itemId, value}" } };
-                }
-                await host.curation.skills(who.user).pin(toggle.itemId, toggle.value);
-                return {
-                    ok: true,
-                    toast: toggle.value ? `Pinned ${toggle.itemId}` : `Unpinned ${toggle.itemId}`,
-                };
-            },
-            toggleArchive: async (ctx, payload) => {
-                const who = callerOf(ctx);
-                if ("reject" in who)
-                    return who.reject;
-                const name = itemIdOf(payload);
-                if (name === undefined) {
-                    return { ok: false, error: { message: "toggleArchive expects {itemId}" } };
-                }
-                // The current store state decides the direction: click an
-                // active skill → archive; click an archived one → restore.
-                const row = (await host.curation.skills(who.user).list()).find((skill) => skill.name === name);
-                if (row === undefined) {
-                    return { ok: false, error: { message: `unknown skill: ${name}` } };
-                }
-                const change = row.archived
-                    ? { kind: "restore" }
-                    : { kind: "archive" };
-                await host.curation
-                    .skills(who.user)
-                    .apply(name, change, { reason: `${change.kind === "archive" ? "archived" : "restored"} from the curator view` });
-                return {
-                    ok: true,
-                    toast: change.kind === "archive" ? `Archived ${name}` : `Restored ${name}`,
-                };
-            },
             setPaused: async (ctx, payload) => {
                 const who = callerOf(ctx);
                 if ("reject" in who)
@@ -295,7 +340,8 @@ function emptyTree() {
         },
     };
 }
-/** The view tree: header with the pause switch, skills, overlays, feed. */
+/** The view tree: header actions (pause switch + the Skills
+ *  link to the core view), then the feed grouped for undo. */
 function viewTree(data) {
     return {
         v: 1,
@@ -311,60 +357,19 @@ function viewTree(data) {
                     icon: data.paused ? "sun" : "moon",
                     action: { type: "submit", name: "setPaused" },
                 },
-            ],
-            main: [
                 {
-                    type: "section",
-                    id: "skills-section",
-                    title: "Learned skills",
-                    children: [
-                        {
-                            type: "markdown",
-                            text: "Toggle the checkbox to pin or unpin. Click a skill to archive it; click an archived one to restore.",
+                    id: "open-skills",
+                    label: "Skills",
+                    icon: "book",
+                    action: {
+                        type: "navigate",
+                        target: {
+                            view: { extension: "core", id: "skills" },
                         },
-                        {
-                            type: "collection",
-                            id: "skills",
-                            display: "list",
-                            items: data.skills,
-                            checkable: "pinned",
-                            onCheck: "pin",
-                            onActivate: { type: "edit", name: "toggleArchive" },
-                            item: {
-                                title: { $: "./name" },
-                                subtitle: { $: "./description" },
-                                body: { $: "./lastUsedLabel" },
-                                badges: [
-                                    { text: "pinned", tone: "good" },
-                                    { text: "archived", tone: "neutral" },
-                                ],
-                            },
-                        },
-                    ],
-                },
-                {
-                    type: "section",
-                    id: "overlays-section",
-                    title: "Overlays",
-                    children: [
-                        data.overlays.length === 0
-                            ? {
-                                type: "markdown",
-                                text: "No overlays on upstream skills.",
-                            }
-                            : {
-                                type: "collection",
-                                id: "overlays",
-                                display: "list",
-                                items: data.overlays,
-                                item: {
-                                    title: { $: "./skill" },
-                                    subtitle: { $: "./root" },
-                                    badges: [{ text: "orphaned", tone: "warn" }],
-                                },
-                            },
-                    ],
+                    },
                 },
+            ],
+            main: [
                 {
                     type: "section",
                     id: "feed-section",
@@ -372,12 +377,14 @@ function viewTree(data) {
                     children: [
                         {
                             type: "markdown",
-                            text: "Click a review to undo every change it made.",
+                            text: "Click a review to undo every change it made. Outside sigrun marks catch-up commits made outside sigrun.",
                         },
                         data.reviews.length === 0
                             ? {
                                 type: "markdown",
-                                text: "Nothing learned yet. Use /learn to ask for a review now.",
+                                text: data.reviewMissed
+                                    ? "This review is older than the recent changes."
+                                    : "Nothing learned yet. Use /learn to ask for a review now.",
                             }
                             : {
                                 type: "collection",
@@ -387,7 +394,7 @@ function viewTree(data) {
                                     id: group.id,
                                     at: group.at,
                                     summary: group.entries
-                                        .map((entry) => `${entry.action} ${entry.skill}`)
+                                        .map((entry) => `${entry.action} ${entry.skill} (${entry.actor})`)
                                         .join(", "),
                                 })),
                                 onActivate: { type: "edit", name: "undoReview" },

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sigrun/ext-curator",
-	"version": "0.1.0",
+	"version": "0.2.0",
 	"description": "Curator extension for sigrun (pi-durable): the per-user fork review and idle maintenance pass over learned skills and curation targets",
 	"type": "module",
 	"engines": {