pi-simocracy 0.1.1 → 0.2.0

package/src/index.ts

@@ -1,19 +1,71 @@
 /**
- * pi-simocracy — load a Simocracy sim into your pi chat.
+ * pi-simocracy — load a Simocracy sim into your pi chat, train its
+ * constitution, and write it back to your ATProto PDS.
  *
- *  - `/sim <name>`   Load a sim by name (fuzzy search on the indexer).
- *                    Renders the sim's sprite as colored ANSI art directly
- *                    in the chat and pushes its constitution + speaking
- *                    style into the system prompt so pi roleplays as the
- *                    sim.
- *  - `/sim unload`   Drop the loaded sim and stop roleplaying.
- *  - `/sim status`   Show the currently loaded sim, if any.
+ * Sim commands:
+ *  - `/sim <name>`        Load a sim by name (fuzzy search on the indexer).
+ *                         Renders the sprite inline as colored ANSI art and
+ *                         pushes the sim's constitution + style into the
+ *                         system prompt so pi roleplays as the sim.
+ *  - `/sim unload`        Drop the loaded sim and stop roleplaying.
+ *  - `/sim status`        Show the currently loaded sim, if any.
+ *
+ * Constitution training (works on the loaded sim):
+ *  - `/sim interview [name] [--apply]`
+ *        Adaptive AI interview that derives a sim's constitution +
+ *        speaking style from your answers. With `--apply` writes them
+ *        back to your PDS (requires `/sim login`).
+ *  - `/sim train baseline`
+ *        Vote yes/no/abstain on sample proposals (5+ recommended).
+ *  - `/sim train chat`
+ *        Conversational training round — the sim asks targeted
+ *        questions about gaps it sees in the baseline votes.
+ *  - `/sim train profile`
+ *        Distill the baseline + chat transcript into a structured
+ *        TrainingProfile (priorities, red lines, tradeoffs).
+ *  - `/sim train alignment`
+ *        Score the sim against your hidden baseline and report match%.
+ *  - `/sim train apply [--apply]`
+ *        Merge the profile into the constitution. Without `--apply`
+ *        copies the merged markdown to clipboard. With `--apply`
+ *        writes to your PDS (requires `/sim login`).
+ *  - `/sim train feedback`, `status`, `reset`
+ *        Free-form feedback chat, status, and clear local state.
+ *
+ * ATProto sign-in ("sign in with Bluesky / ATProto", NOT Anthropic):
+ *  - `/sim login [handle]`
+ *        Loopback OAuth flow — opens your PDS's authorize page in the
+ *        browser, grants this CLI a DPoP-bound session, persists it to
+ *        ~/.config/pi-simocracy/auth.json. Required before `--apply`
+ *        writes records to your repo.
+ *  - `/sim logout`        Clear the local OAuth session.
+ *  - `/sim whoami`        Show the currently signed-in ATProto handle/DID.
+ *
+ * Browse your own sims (requires `/sim login`):
+ *  - `/sim my`            List the org.simocracy.sim records owned by
+ *                         the signed-in DID, newest first. Mirrors
+ *                         simocracy.org's My Sims page in terminal form.
+ *  - `/sim my <n>`        Load sim #n from that list (1-indexed).
+ *  - `/sim my <name>`     Fuzzy-load by name within your own sims.
  *
  * Tools (LLM-callable):
- *  - `simocracy_load_sim`    Same as /sim <name>.
- *  - `simocracy_unload_sim`  Same as /sim unload.
- *  - `simocracy_chat`        One-shot chat with a sim via OpenRouter (does
- *                            not change the active session persona).
+ *  - `simocracy_load_sim`           Same as /sim <name>.
+ *  - `simocracy_unload_sim`         Same as /sim unload.
+ *  - `simocracy_chat`               One-shot chat with a sim via
+ *                                   OpenRouter (does not change the
+ *                                   active session persona).
+ *  - `simocracy_run_interview`      Run /sim interview programmatically.
+ *  - `simocracy_derive_constitution`
+ *                                   Given interview answers, return the
+ *                                   derived constitution + style.
+ *  - `simocracy_training_profile`   Distill baseline + transcript into
+ *                                   a TrainingProfile.
+ *  - `simocracy_alignment_test`     Score a profile against a baseline.
+ *
+ * Note on /login: pi itself ships a built-in `/login` for Anthropic OAuth.
+ * To avoid the collision (and to make it explicit you're signing into
+ * ATProto, not Anthropic), all auth commands here are namespaced under
+ * `/sim`.
  */
 
 import type {
@@ -26,6 +78,7 @@ import { Type } from "typebox";
 
 import {
   searchSimsByName,
+  fetchSimsForDid,
   fetchAgentsForSim,
   fetchStyleForSim,
   fetchBlob,
@@ -43,24 +96,34 @@ import {
   downscaleRgbaNearest,
 } from "./png-to-ansi.ts";
 import { openRouterComplete, type ChatMessage } from "./openrouter.ts";
+import { buildSimPrompt, type LoadedSim } from "./persona.ts";
+import { runTrainCommand } from "./training/index.ts";
+import {
+  runInterviewFlow,
+  snapshotInterviewTemplate,
+  deriveFromInterview,
+} from "./interview.ts";
+import { deriveProfile, printProfile } from "./training/profile.ts";
+import {
+  loadTrainingLabState,
+  saveTrainingLabState,
+} from "./training/storage.ts";
+import { scoreAlignment, printAlignment } from "./training/alignment.ts";
+import type {
+  AlignmentResult,
+  BaselineProposal,
+  BaselineVote,
+  InterviewTurn,
+  TrainingProfile,
+  Vote,
+} from "./training/types.ts";
+import { runLogin, runLogout, runWhoami } from "./auth/commands.ts";
+import { readAuth } from "./auth/storage.ts";
 
 // ---------------------------------------------------------------------------
 // State
 // ---------------------------------------------------------------------------
 
-interface LoadedSim {
-  uri: string;
-  did: string;
-  rkey: string;
-  name: string;
-  handle: string | null;
-  shortDescription?: string;
-  description?: string;
-  style?: string;
-  /** Pre-rendered colored ANSI art of the sim's sprite (4 walk frames). */
-  spriteAnsi?: string;
-}
-
 let loadedSim: LoadedSim | null = null;
 /**
  * Name of the most recently unloaded sim, if any. Cleared after the next
@@ -147,41 +210,6 @@ async function renderSpriteAnsi(sim: SimMatch): Promise<string | null> {
   return null;
 }
 
-function buildSimPrompt(sim: LoadedSim): string {
-  const lines: string[] = [];
-  lines.push(`# Simocracy roleplay`);
-  lines.push(
-    `You are now roleplaying as **${sim.name}**, a Simocracy sim — a simulated political agent in a decentralized governance simulation built on the AT Protocol.`,
-  );
-  lines.push(
-    `Stay in character at all times. Respond as ${sim.name} would — with their beliefs, values, and personality. Use first person. Don't break character or mention that you are an AI.`,
-  );
-  if (sim.handle) lines.push(`The sim's owner on ATProto is @${sim.handle} (${sim.did}).`);
-  if (sim.shortDescription) {
-    lines.push(``);
-    lines.push(`## ${sim.name}'s identity`);
-    lines.push(sim.shortDescription);
-  }
-  if (sim.description) {
-    lines.push(``);
-    lines.push(`## ${sim.name}'s constitution`);
-    lines.push(sim.description);
-  }
-  if (sim.style) {
-    lines.push(``);
-    lines.push(`## ${sim.name}'s speaking style`);
-    lines.push(sim.style);
-  }
-  lines.push(``);
-  lines.push(
-    `When the user asks you to use any of pi's tools (read, edit, bash, etc.), you should still use them — you're ${sim.name} *with access to a developer's terminal*. Just narrate tool use the way ${sim.name} would talk about it.`,
-  );
-  lines.push(
-    `Keep replies conversational unless the user explicitly asks for code or a long answer.`,
-  );
-  return lines.join("\n");
-}
-
 async function loadSimByName(query: string): Promise<{
   matches: SimMatch[];
   loaded?: LoadedSim;
@@ -275,6 +303,96 @@ const ChatToolParams = Type.Object({
 
 const UnloadToolParams = Type.Object({});
 
+const RunInterviewToolParams = Type.Object({
+  sim: Type.Optional(
+    Type.String({
+      description:
+        "Sim name or AT-URI to interview. Defaults to the currently loaded sim if omitted.",
+    }),
+  ),
+  templateUri: Type.Optional(
+    Type.String({
+      description:
+        "AT-URI of an `org.simocracy.interviewTemplate` to use. Skips the picker.",
+    }),
+  ),
+});
+
+const OpenAnswerSchema = Type.Object({
+  question: Type.String(),
+  answer: Type.String(),
+});
+const YesNoAnswerSchema = Type.Object({
+  statement: Type.String(),
+  answer: Type.Boolean(),
+});
+
+const DeriveConstitutionToolParams = Type.Object({
+  openAnswers: Type.Optional(Type.Array(OpenAnswerSchema)),
+  yesNoAnswers: Type.Optional(Type.Array(YesNoAnswerSchema)),
+});
+
+const BaselineProposalSchema = Type.Object({
+  id: Type.String(),
+  title: Type.String(),
+  summary: Type.String(),
+  topic: Type.String(),
+});
+const BaselineVoteSchema = Type.Object({
+  proposalId: Type.String(),
+  vote: Type.Union([Type.Literal("yes"), Type.Literal("no"), Type.Literal("abstain")]),
+  importance: Type.Number(),
+  reasoning: Type.String(),
+});
+const InterviewTurnSchema = Type.Object({
+  role: Type.Union([Type.Literal("assistant"), Type.Literal("user")]),
+  content: Type.String(),
+  target: Type.Optional(Type.String()),
+});
+const IssuePrioritySchema = Type.Object({
+  issue: Type.String(),
+  stance: Type.String(),
+  importance: Type.Number(),
+  negotiability: Type.Number(),
+  confidence: Type.Number(),
+});
+const TrainingProfileSchema = Type.Object({
+  summary: Type.String(),
+  coreValues: Type.Array(Type.String()),
+  issuePriorities: Type.Array(IssuePrioritySchema),
+  redLines: Type.Array(Type.String()),
+  acceptableTradeoffs: Type.Array(Type.String()),
+  uncertaintyAreas: Type.Array(Type.String()),
+  representationRules: Type.Array(Type.String()),
+});
+
+const TrainingProfileToolParams = Type.Object({
+  simName: Type.String({ description: "The sim's display name." }),
+  existingConstitution: Type.Optional(Type.String()),
+  baselineVotes: Type.Array(BaselineVoteSchema),
+  baselineProposals: Type.Array(BaselineProposalSchema),
+  transcript: Type.Array(InterviewTurnSchema),
+});
+
+const AlignmentProposalSchema = Type.Object({
+  id: Type.String(),
+  title: Type.String(),
+  summary: Type.String(),
+  topic: Type.String(),
+  userVote: Type.Union([
+    Type.Literal("yes"),
+    Type.Literal("no"),
+    Type.Literal("abstain"),
+  ]),
+});
+
+const AlignmentTestToolParams = Type.Object({
+  simName: Type.String({ description: "The sim's display name." }),
+  existingConstitution: Type.Optional(Type.String()),
+  profile: TrainingProfileSchema,
+  proposals: Type.Array(AlignmentProposalSchema),
+});
+
 export default async function simocracy(pi: ExtensionAPI) {
   // -------------------------------------------------------------------------
   // System prompt injection — every turn the loaded sim's persona is appended.
@@ -316,20 +434,70 @@ export default async function simocracy(pi: ExtensionAPI) {
 
   // -------------------------------------------------------------------------
   // Slash command: /sim
+  //
+  // All extension commands are namespaced under /sim to avoid colliding
+  // with pi's built-in slash commands (notably `/login` for Anthropic
+  // OAuth and `/logout`). That namespacing also makes it unambiguous to
+  // users that `/sim login` signs them into their ATProto / Bluesky
+  // account, NOT into Anthropic.
   // -------------------------------------------------------------------------
   pi.registerCommand("sim", {
-    description: "Load a Simocracy sim into your chat (or `/sim unload`, `/sim status`).",
+    description:
+      "Simocracy: load/train sims, sign into ATProto. `/sim help` for the full list.",
     handler: async (args, ctx) => {
       const arg = args.trim();
       if (!arg || arg === "help" || arg === "--help") {
         ctx.ui.notify(
-          "Usage: /sim <name>            load a sim (e.g. /sim mr meow)\n" +
-            "       /sim unload            stop roleplaying\n" +
-            "       /sim status            show currently loaded sim",
+          "Sim:\n" +
+            "  /sim <name>            load a sim (e.g. /sim mr meow)\n" +
+            "  /sim unload            stop roleplaying\n" +
+            "  /sim status            show currently loaded sim\n" +
+            "\n" +
+            "Constitution training (operates on the loaded sim):\n" +
+            "  /sim interview [name]  adaptive interview → derive constitution\n" +
+            "  /sim train baseline    vote on sample proposals\n" +
+            "  /sim train chat        conversational training round\n" +
+            "  /sim train profile     distill votes + chat → TrainingProfile\n" +
+            "  /sim train alignment   score sim against your baseline\n" +
+            "  /sim train apply       merge profile into constitution\n" +
+            "  /sim train status|reset|feedback\n" +
+            "\n" +
+            "Sign in with ATProto / Bluesky (not Anthropic — pi's built-in /login\n" +
+            "does that). Required before `--apply` writes to your PDS:\n" +
+            "  /sim login [handle]    OAuth loopback flow (e.g. /sim login alice.bsky.social)\n" +
+            "  /sim logout            clear local session\n" +
+            "  /sim whoami            show signed-in handle/DID\n" +
+            "\n" +
+            "Browse your own sims (requires /sim login):\n" +
+            "  /sim my                list sims you own on your PDS\n" +
+            "  /sim my <n>            load sim #n from that list\n" +
+            "  /sim my <name>         fuzzy-load by name within your sims",
           "info",
         );
         return;
       }
+      // ATProto auth subcommands — must come BEFORE the sim-name
+      // fallthrough (`runLoadFlow`) so we don't accidentally treat
+      // "login" as a sim name to load from the indexer.
+      if (arg === "login" || arg.startsWith("login ") || arg.startsWith("login\t")) {
+        const rest = arg.slice("login".length).trim();
+        await runLogin(ctx, rest);
+        return;
+      }
+      if (arg === "logout") {
+        await runLogout(ctx);
+        return;
+      }
+      if (arg === "whoami") {
+        await runWhoami(ctx);
+        return;
+      }
+      if (arg === "my" || arg === "mine" || arg.startsWith("my ") || arg.startsWith("my\t") || arg.startsWith("mine ") || arg.startsWith("mine\t")) {
+        const headLen = arg.startsWith("mine") ? 4 : 2;
+        const rest = arg.slice(headLen).trim();
+        await runMySimsCommand(pi, ctx, rest);
+        return;
+      }
       if (arg === "unload" || arg === "clear") {
         if (!loadedSim) {
           ctx.ui.notify("No sim loaded.", "info");
@@ -351,10 +519,56 @@ export default async function simocracy(pi: ExtensionAPI) {
         await postSimToChat(pi, ctx, loadedSim, /*reload=*/ false);
         return;
       }
+      if (arg === "interview" || arg.startsWith("interview ") || arg.startsWith("interview\t")) {
+        const rest = arg.slice("interview".length).trim();
+        // Strip recognised flags (--apply) and use the rest as a sim name.
+        const tokens = rest.split(/\s+/).filter(Boolean);
+        const apply = tokens.includes("--apply");
+        const nameTokens = tokens.filter((t) => !t.startsWith("--"));
+        const simName = nameTokens.join(" ").trim();
+        if (simName && !loadedSim) {
+          const sim = await tryLoadFromQuery(simName);
+          if (!sim) {
+            ctx.ui.notify(`No sim found matching "${simName}".`, "error");
+            return;
+          }
+          loadedSim = sim;
+          await postSimToChat(pi, ctx, sim, /*reload=*/ true);
+        }
+        if (!loadedSim) {
+          ctx.ui.notify("No sim loaded. Use `/sim <name>` first or pass a name to `/sim interview <name>`.", "error");
+          return;
+        }
+        await runInterviewFlow(pi, ctx, loadedSim, { apply });
+        return;
+      }
+      if (arg === "train" || arg.startsWith("train ") || arg.startsWith("train\t")) {
+        const rest = arg.slice("train".length).trim();
+        await runTrainCommand(ctx, rest, loadedSim);
+        return;
+      }
       await runLoadFlow(pi, ctx, arg);
     },
   });
 
+  // -------------------------------------------------------------------------
+  // (Removed) top-level /login, /logout, /whoami slash commands.
+  //
+  // These collided with pi's own built-in `/login` (Anthropic OAuth) and
+  // `/logout`, which made pi emit "Skipping in autocomplete" warnings on
+  // every boot and silently degraded discoverability of these handlers.
+  // The auth flow now lives under `/sim login`, `/sim logout`,
+  // `/sim whoami` — no collision, and the namespacing makes it explicit
+  // to users that they're signing into their ATProto / Bluesky account,
+  // not Anthropic. See the dispatcher in the `/sim` registerCommand
+  // above.
+  //
+  // The `runLogin` / `runLogout` / `runWhoami` helpers in src/auth/
+  // commands.ts are unchanged — only the slash-command surface moved.
+  // -------------------------------------------------------------------------
+  // (no top-level registration — the auth helpers `runLogin`, `runLogout`,
+  // `runWhoami` are dispatched from inside the `/sim` handler above.)
+
   // -------------------------------------------------------------------------
   // Tool: simocracy_load_sim
   // -------------------------------------------------------------------------
@@ -457,12 +671,380 @@ export default async function simocracy(pi: ExtensionAPI) {
       };
     },
   });
+
+  // -------------------------------------------------------------------------
+  // Tool: simocracy_run_interview — run the interview questionnaire.
+  // -------------------------------------------------------------------------
+  pi.registerTool({
+    name: "simocracy_run_interview",
+    label: "Run Simocracy interview",
+    description:
+      "Run the Simocracy interview questionnaire on the loaded sim and return the captured open + yes/no answers. With UI, drives the user through the questions interactively. Without UI, returns the structure of the chosen template as a planning aid (no answers).",
+    parameters: RunInterviewToolParams,
+    async execute(_id, { sim, templateUri }, _signal, _onUpdate, ctx) {
+      if (ctx.hasUI) {
+        let target: LoadedSim | null = loadedSim;
+        if (sim) {
+          const loaded = await tryLoadFromQuery(sim);
+          if (!loaded) throw new Error(`No sim found matching "${sim}".`);
+          loadedSim = loaded;
+          target = loaded;
+          await postSimToChat(pi, ctx, loaded, true);
+        }
+        if (!target) throw new Error("No sim loaded. Pass `sim` or call simocracy_load_sim first.");
+        const out = await runInterviewFlow(pi, ctx as ExtensionCommandContext, target, {
+          templateUri,
+        });
+        if (!out) {
+          return {
+            content: [{ type: "text" as const, text: "Interview cancelled." }],
+            details: { cancelled: true },
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: `Captured ${out.result.openAnswers.length} open answers and ${out.result.yesNoAnswers.length} value positions.`,
+            },
+          ],
+          details: out.result,
+        };
+      }
+      // No UI: return the template snapshot as a planning aid.
+      const snapshot = await snapshotInterviewTemplate(templateUri);
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text:
+              `Interview template "${snapshot.name}" — ${snapshot.questions.length} questions. ` +
+              `Run from a UI session to capture answers.`,
+          },
+        ],
+        details: { template: snapshot, openAnswers: [], yesNoAnswers: [] },
+      };
+    },
+  });
+
+  // -------------------------------------------------------------------------
+  // Tool: simocracy_derive_constitution — turn answers into constitution+style.
+  // -------------------------------------------------------------------------
+  pi.registerTool({
+    name: "simocracy_derive_constitution",
+    label: "Derive Simocracy constitution",
+    description:
+      "Given an interview's open + yes/no answers, derive a sim constitution (short description + markdown body) and a speaking style. Returns plain markdown — no PDS write happens here.",
+    parameters: DeriveConstitutionToolParams,
+    async execute(_id, { openAnswers, yesNoAnswers }) {
+      const sim: LoadedSim = loadedSim ?? {
+        uri: "",
+        did: "",
+        rkey: "",
+        name: "Sim",
+        handle: null,
+      };
+      const derived = await deriveFromInterview(sim, {
+        openAnswers: openAnswers ?? [],
+        yesNoAnswers: yesNoAnswers ?? [],
+      });
+      if (!derived) {
+        throw new Error("Could not parse derive-from-interview model output.");
+      }
+      const summary = [
+        `Short description:`,
+        derived.constitution.shortDescription,
+        ``,
+        `Constitution:`,
+        derived.constitution.description,
+        ``,
+        `Speaking style:`,
+        derived.style.description,
+      ].join("\n");
+      return {
+        content: [{ type: "text" as const, text: summary }],
+        details: derived,
+      };
+    },
+  });
+
+  // -------------------------------------------------------------------------
+  // Tool: simocracy_training_profile — distill into a TrainingProfile.
+  // -------------------------------------------------------------------------
+  pi.registerTool({
+    name: "simocracy_training_profile",
+    label: "Distill Simocracy training profile",
+    description:
+      "Distill a baseline questionnaire + interview transcript into a structured TrainingProfile (summary, core values, issue priorities, red lines, etc.). Read-only — does not write to the sim.",
+    parameters: TrainingProfileToolParams,
+    async execute(_id, params) {
+      const sim: LoadedSim = loadedSim ?? {
+        uri: "",
+        did: "",
+        rkey: "",
+        name: params.simName,
+        handle: null,
+        description: params.existingConstitution,
+      };
+      const stateSnapshot = {
+        baselineVotes: params.baselineVotes as BaselineVote[],
+        interviewTurns: params.transcript as InterviewTurn[],
+        feedbackTurns: [] as never[],
+        profile: null as TrainingProfile | null,
+        alignment: null as AlignmentResult | null,
+        updatedAt: new Date().toISOString(),
+      };
+      const profile = await deriveProfile(
+        { ...sim, description: params.existingConstitution ?? sim.description },
+        stateSnapshot,
+        params.baselineProposals as BaselineProposal[],
+      );
+      if (!profile) throw new Error("Could not parse training profile from model output.");
+      if (loadedSim && loadedSim.rkey) {
+        const persisted = loadTrainingLabState(loadedSim.rkey);
+        saveTrainingLabState(loadedSim.rkey, { ...persisted, profile, alignment: null });
+      }
+      try {
+        printProfile(profile);
+      } catch {
+        /* best effort */
+      }
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: `Distilled profile: ${profile.coreValues.length} core values, ${profile.issuePriorities.length} issue priorities, ${profile.redLines.length} red lines.`,
+          },
+        ],
+        details: profile,
+      };
+    },
+  });
+
+  // -------------------------------------------------------------------------
+  // Tool: simocracy_alignment_test — score the sim against baseline votes.
+  // -------------------------------------------------------------------------
+  pi.registerTool({
+    name: "simocracy_alignment_test",
+    label: "Run Simocracy alignment test",
+    description:
+      "Run the loaded sim's training profile against a list of proposals (each with the user's hidden vote) and return per-proposal match/mismatch + an overall match percentage. Calls the alignment prompt once per proposal at concurrency 4.",
+    parameters: AlignmentTestToolParams,
+    async execute(_id, params) {
+      const sim: LoadedSim = loadedSim ?? {
+        uri: "",
+        did: "",
+        rkey: "",
+        name: params.simName,
+        handle: null,
+        description: params.existingConstitution,
+      };
+      const aligned = (params.proposals as Array<BaselineProposal & { userVote: Vote }>).map(
+        (p) => ({
+          proposal: { id: p.id, title: p.title, summary: p.summary, topic: p.topic },
+          userVote: p.userVote,
+        }),
+      );
+      const alignment = await scoreAlignment(
+        { ...sim, description: params.existingConstitution ?? sim.description },
+        params.profile as TrainingProfile,
+        aligned,
+      );
+      if (loadedSim && loadedSim.rkey) {
+        const persisted = loadTrainingLabState(loadedSim.rkey);
+        saveTrainingLabState(loadedSim.rkey, { ...persisted, alignment });
+      }
+      try {
+        printAlignment(alignment, aligned);
+      } catch {
+        /* not in UI mode — printing is best-effort */
+      }
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: `Alignment: ${alignment.matchedCount}/${alignment.totalCount} matched. Weak areas: ${
+              alignment.weakAreas.length ? alignment.weakAreas.join(", ") : "none"
+            }.`,
+          },
+        ],
+        details: alignment,
+      };
+    },
+  });
 }
 
+
 // ---------------------------------------------------------------------------
 // Slash-command flow
 // ---------------------------------------------------------------------------
 
+/**
+ * `/sim my [arg]` — list (and optionally load) sims owned by the
+ * currently signed-in DID. Three calling conventions, picked by
+ * cheapest-first:
+ *
+ *   - bare `/sim my`           →  print a numbered list, no load
+ *   - `/sim my <n>` (digits)   →  load the n-th sim from the list
+ *   - `/sim my <text>`         →  fuzzy-match by name within the user's
+ *                                sims (uses the same scoring as the
+ *                                global indexer search), load the best.
+ *                                If two of the user's sims share a name
+ *                                we prompt with a select. AT-URIs are
+ *                                not allowed here — use `/sim <at-uri>`
+ *                                directly for that.
+ *
+ * Reads the user's sims from their PDS via `com.atproto.repo.listRecords`
+ * (no DPoP needed for reads of the public collection), so this works
+ * even if the OAuth session has expired — it only needs the DID, which
+ * the auth.json keeps after `lastLogin` is stale.
+ */
+async function runMySimsCommand(
+  pi: ExtensionAPI,
+  ctx: ExtensionCommandContext,
+  arg: string,
+): Promise<void> {
+  const auth = readAuth();
+  if (!auth) {
+    ctx.ui.notify(
+      "Not signed into ATProto. Run `/sim login <handle>` first (e.g. `/sim login alice.bsky.social`) so /sim my knows which DID's repo to list.",
+      "error",
+    );
+    return;
+  }
+
+  ctx.ui.notify(`Listing sims owned by ${auth.handle ? `@${auth.handle}` : auth.did}\u2026`, "info");
+
+  let mySims: SimMatch[];
+  try {
+    mySims = await fetchSimsForDid(auth.did);
+  } catch (err) {
+    ctx.ui.notify(
+      `Could not list sims from your PDS: ${(err as Error).message}. Is the DID document still resolvable?`,
+      "error",
+    );
+    return;
+  }
+
+  if (mySims.length === 0) {
+    ctx.ui.notify(
+      auth.handle
+        ? `@${auth.handle} doesn't own any sims yet. Visit https://simocracy.org/my-sims to create one, then come back and try /sim my again.`
+        : `No sims found on this PDS. Create one at https://simocracy.org/my-sims and try again.`,
+      "info",
+    );
+    return;
+  }
+
+  // Bare `/sim my` — just list. Indented so the chat treats this as
+  // a content message (notify is best for short feedback; for the
+  // list we want fixed-width alignment so we go through the registered
+  // message renderer that the load flow already uses for sim summaries).
+  if (!arg) {
+    const lines: string[] = [];
+    lines.push(`📁 ${mySims.length} sim${mySims.length === 1 ? "" : "s"} owned by ${auth.handle ? `@${auth.handle}` : auth.did}:`);
+    lines.push("");
+    const maxNameLen = Math.min(
+      32,
+      mySims.reduce((m, s) => Math.max(m, s.sim.name.length), 0),
+    );
+    mySims.forEach((s, i) => {
+      const idx = String(i + 1).padStart(2, " ");
+      const name = s.sim.name.length > maxNameLen ? s.sim.name.slice(0, maxNameLen - 1) + "…" : s.sim.name.padEnd(maxNameLen, " ");
+      const created = (s.sim.createdAt || "").slice(0, 10);
+      lines.push(`  ${idx}. ${name}  ${created}  at://…/${s.rkey}`);
+    });
+    lines.push("");
+    lines.push("Load one with `/sim my <n>` (e.g. `/sim my 1`) or `/sim my <name>`.");
+    ctx.ui.notify(lines.join("\n"), "info");
+    return;
+  }
+
+  // `/sim my <n>` — numeric index into the list above.
+  if (/^\d+$/.test(arg)) {
+    const n = parseInt(arg, 10);
+    if (n < 1 || n > mySims.length) {
+      ctx.ui.notify(
+        `No sim #${n} — you have ${mySims.length}. Run /sim my (no args) to see the list.`,
+        "error",
+      );
+      return;
+    }
+    await loadAndPostMySim(pi, ctx, mySims[n - 1]);
+    return;
+  }
+
+  // `/sim my <name>` — fuzzy-match within the user's own sims.
+  const matches = fuzzyMatchOwnedSims(mySims, arg);
+  if (matches.length === 0) {
+    ctx.ui.notify(
+      `No sim matching "${arg}" in your ${mySims.length} sim${mySims.length === 1 ? "" : "s"}. Run /sim my (no args) to see them.`,
+      "error",
+    );
+    return;
+  }
+  let chosen = matches[0];
+  if (matches.length > 1 && matches[0].score > 0) {
+    // Multiple non-exact matches — ask. Skip the prompt for an exact match.
+    const labels = matches.map((m) => `${m.sim.sim.name}  —  at://…/${m.sim.rkey}`);
+    const picked = await ctx.ui.select(`Multiple matches for "${arg}" in your sims`, labels);
+    if (!picked) {
+      ctx.ui.notify("Cancelled.", "info");
+      return;
+    }
+    chosen = matches[labels.indexOf(picked)];
+  }
+  await loadAndPostMySim(pi, ctx, chosen.sim);
+}
+
+async function loadAndPostMySim(
+  pi: ExtensionAPI,
+  ctx: ExtensionCommandContext,
+  match: SimMatch,
+): Promise<void> {
+  ctx.ui.notify(`Loading ${match.sim.name}…`, "info");
+  let sim: LoadedSim;
+  try {
+    sim = await hydrateLoadedSim(match);
+  } catch (err) {
+    ctx.ui.notify(`Failed to load sim: ${(err as Error).message}`, "error");
+    return;
+  }
+  loadedSim = sim;
+  await postSimToChat(pi, ctx, sim, true);
+}
+
+/**
+ * Score user-owned sims against a query string. Returns matches sorted
+ * best-first. Score 0 = exact name match (prompt-suppressing), higher =
+ * worse. Mirrors the heuristic the indexer search uses but constrained
+ * to the already-fetched list, so this is purely client-side and no
+ * extra HTTP calls are issued.
+ */
+function fuzzyMatchOwnedSims(
+  sims: SimMatch[],
+  query: string,
+): Array<{ sim: SimMatch; score: number }> {
+  const q = query.toLowerCase().trim();
+  const out: Array<{ sim: SimMatch; score: number }> = [];
+  for (const sim of sims) {
+    const name = sim.sim.name.toLowerCase().trim();
+    let score = Number.POSITIVE_INFINITY;
+    if (name === q) score = 0;
+    else if (name.replace(/\s+/g, "") === q.replace(/\s+/g, "")) score = 1;
+    else if (name.startsWith(q)) score = 2;
+    else if (name.includes(q)) score = 3 + (name.length - q.length);
+    else {
+      const tokens = q.split(/\s+/).filter(Boolean);
+      const matched = tokens.filter((t) => name.includes(t)).length;
+      if (matched > 0) score = 100 - matched;
+    }
+    if (Number.isFinite(score)) out.push({ sim, score });
+  }
+  out.sort((a, b) => a.score - b.score);
+  return out;
+}
+
 async function runLoadFlow(
   pi: ExtensionAPI,
   ctx: ExtensionCommandContext,