pi-anchor 0.3.0 → 0.4.0

package/dist/extension.d.cts

@@ -1,20 +1,2 @@
-import { ExtensionAPI } from '@earendil-works/pi-coding-agent';
-import { A as AnchorStore } from './store-t2_TDhJn.cjs';
-
-/**
- * Parse inline `--due <date>` / `-d <date>` flags and `done`/`rm`/`close`/`settle` subcommands
- * for `/anchor` and `/pin` slash commands.
- */
-declare function parseAnchorCommandInput(raw: string, now?: number): {
-    mode: 'dashboard' | 'undo' | 'settle' | 'pin';
-    targetId?: string;
-    title?: string;
-    targetDate?: string;
-};
-/**
- * Resolve either an explicit anchor ID ('anc-2', '2') or a 1-based visual dashboard index ('01', '1')
- */
-declare function resolveAnchorTarget(store: AnchorStore, idOrIndex: string, cwd?: string): string | undefined;
-declare function export_default(pi: ExtensionAPI): void;
-
-export { export_default as default, parseAnchorCommandInput, resolveAnchorTarget };
+import '@earendil-works/pi-coding-agent';
+export { w as default, r as parseAnchorCommandInput, u as resolveAnchorTarget } from './extension-B1-fzCox.cjs';

package/dist/extension.d.ts

@@ -1,20 +1,2 @@
-import { ExtensionAPI } from '@earendil-works/pi-coding-agent';
-import { A as AnchorStore } from './store-t2_TDhJn.js';
-
-/**
- * Parse inline `--due <date>` / `-d <date>` flags and `done`/`rm`/`close`/`settle` subcommands
- * for `/anchor` and `/pin` slash commands.
- */
-declare function parseAnchorCommandInput(raw: string, now?: number): {
-    mode: 'dashboard' | 'undo' | 'settle' | 'pin';
-    targetId?: string;
-    title?: string;
-    targetDate?: string;
-};
-/**
- * Resolve either an explicit anchor ID ('anc-2', '2') or a 1-based visual dashboard index ('01', '1')
- */
-declare function resolveAnchorTarget(store: AnchorStore, idOrIndex: string, cwd?: string): string | undefined;
-declare function export_default(pi: ExtensionAPI): void;
-
-export { export_default as default, parseAnchorCommandInput, resolveAnchorTarget };
+import '@earendil-works/pi-coding-agent';
+export { w as default, r as parseAnchorCommandInput, u as resolveAnchorTarget } from './extension-B1-fzCox.js';

package/dist/extension.js

@@ -1,540 +1,8 @@
 import {
-  AnchorStore,
-  SessionTouchObserver,
-  detectTargetDate,
-  findMatchedAnchors,
-  generateSettlementProposals,
-  hasActiveUI,
-  isAnchorTargetingWorkspace,
-  isSameOrSubPath,
-  makeSafeTaskAnnotation,
-  normalizePath,
-  openAnchorDashboard,
-  renderColdStartAnchorsContext,
-  runPhysicalVerification,
-  sortAnchorsForDisplay,
-  sweepStore,
-  truncateToWidth,
-  tryRealtimeAutoSettle,
-  updateAnchorStatusBar,
-  updateStartupBanner
-} from "./chunk-Q7IILJFA.js";
-
-// src/extension.ts
-import { Type } from "@sinclair/typebox";
-import { execSync } from "child_process";
-import fs from "fs";
-import path from "path";
-var MUTATION_TOOLS = /* @__PURE__ */ new Set(["edit", "write", "patch", "apply_diff", "create_file", "modify"]);
-function parseAnchorCommandInput(raw, now = Date.now()) {
-  const trimmed = (raw || "").trim();
-  if (!trimmed || trimmed === "list" || trimmed === "ls") {
-    return { mode: "dashboard" };
-  }
-  if (trimmed === "undo") {
-    return { mode: "undo" };
-  }
-  const settleMatch = trimmed.match(/^(?:done|rm|close|settle)\s+(.+)$/i);
-  if (settleMatch) {
-    return {
-      mode: "settle",
-      targetId: settleMatch[1].trim().replace(/^#/, "")
-    };
-  }
-  let targetDate;
-  const tokens = trimmed.split(/\s+/);
-  const dueIdx = tokens.findIndex((t) => t === "--due" || t === "-d");
-  if (dueIdx !== -1 && tokens[dueIdx + 1]) {
-    const rawDue = tokens[dueIdx + 1];
-    targetDate = detectTargetDate(rawDue, now) || rawDue;
-    tokens.splice(dueIdx, 2);
-  }
-  const cleanTitle = tokens.join(" ").trim();
-  return {
-    mode: "pin",
-    title: cleanTitle || trimmed,
-    targetDate
-  };
-}
-function resolveAnchorTarget(store, idOrIndex, cwd) {
-  const clean = idOrIndex.trim().replace(/^#/, "");
-  if (/^\d+$/.test(clean)) {
-    const seqIndex = parseInt(clean, 10);
-    const visible = store.list({ cwd, all: true }).filter((a) => a.status === "active" || a.status === "sleeping");
-    const sorted = sortAnchorsForDisplay(visible, cwd);
-    if (seqIndex >= 1 && seqIndex <= sorted.length) {
-      return sorted[seqIndex - 1].id;
-    }
-  }
-  const direct = store.get(clean);
-  return direct?.id;
-}
-function extension_default(pi) {
-  const store = new AnchorStore();
-  const observer = new SessionTouchObserver();
-  const annotatedThisSession = /* @__PURE__ */ new Set();
-  const preflightFailures = /* @__PURE__ */ new Map();
-  pi.on("session_start", async (event, ctx) => {
-    observer.clear();
-    annotatedThisSession.clear();
-    preflightFailures.clear();
-    const sweep = sweepStore(store);
-    const sleepingForWorkspace = store.list({ status: "sleeping", all: true }).filter((a) => (a.files.length > 0 || a.project && a.project !== "global" || a.cwd) && isAnchorTargetingWorkspace(a, ctx.cwd));
-    for (const sa of sleepingForWorkspace) {
-      store.touch(sa.id);
-    }
-    if (sweep.transitionedToSleeping.length > 0 && sleepingForWorkspace.length === 0) {
-      ctx.ui.notify(`\u2316 Anchor: ${sweep.transitionedToSleeping.length} inactive task(s) moved to quiet mode (/anchor to view)`, "info");
-    }
-    const activeAnchors = store.list({ cwd: ctx.cwd }).filter((a) => a.status === "active");
-    for (const a of activeAnchors) {
-      if (a.verifyCommand && (!a.cwd || isSameOrSubPath(a.cwd, ctx.cwd))) {
-        try {
-          const res = runPhysicalVerification(a, ctx.cwd);
-          if (res.success) {
-            store.settle(a.id, {
-              settledBy: "verification-test",
-              summary: `Physical pre-flight test passed: ${a.verifyCommand}`
-            });
-            ctx.ui.notify(`\u2316 Verification passed! Auto-settled #${a.id}: "${a.title}"`, "info");
-          } else {
-            preflightFailures.set(a.id, res.output.slice(-250));
-          }
-        } catch (_) {
-        }
-      }
-    }
-    try {
-      const home = process.env.HOME || process.env.USERPROFILE || "";
-      const pendingPath = path.join(home, ".anchor", "pending_exit.json");
-      if (fs.existsSync(pendingPath)) {
-        const pending = JSON.parse(fs.readFileSync(pendingPath, "utf-8"));
-        const isExpired = Date.now() - pending.timestamp >= 24 * 60 * 60 * 1e3;
-        if (!isExpired && isSameOrSubPath(pending.cwd, ctx.cwd)) {
-          ctx.ui.notify(`\u2316 [Exit Guard] Detected ${pending.modifiedCount} uncommitted changes from previous session exit. Run /pin to record.`, "info");
-          fs.unlinkSync(pendingPath);
-        } else if (isExpired) {
-          fs.unlinkSync(pendingPath);
-        }
-      }
-    } catch (_) {
-    }
-    updateAnchorStatusBar(ctx, store);
-    if (event.reason !== "resume") {
-      updateStartupBanner(ctx, store);
-    } else if (hasActiveUI(ctx)) {
-      try {
-        ctx.ui.setWidget("anchor-startup", void 0);
-      } catch {
-      }
-    }
-  });
-  pi.on("agent_start", async (_event, ctx) => {
-    if (hasActiveUI(ctx)) {
-      try {
-        ctx.ui.setWidget("anchor-startup", void 0);
-      } catch {
-      }
-    }
-  });
-  pi.on("before_agent_start", async (event, ctx) => {
-    const entries = ctx.sessionManager?.getEntries() || [];
-    const messageTurns = entries.filter((e) => e.type === "message");
-    const isColdStart = messageTurns.length <= 1;
-    if (isColdStart) {
-      const contextSnippet = renderColdStartAnchorsContext(store, ctx.cwd, void 0, preflightFailures);
-      if (contextSnippet) {
-        return {
-          systemPrompt: `${event.systemPrompt}
-
-${contextSnippet}`
-        };
-      }
-    }
-  });
-  pi.on("tool_result", async (event, ctx) => {
-    const lowerTool = String(event.toolName || "").toLowerCase();
-    if (!event.isError) {
-      observer.recordToolCall(event.toolName, event.input || {});
-      if (lowerTool === "bash" || lowerTool === "powershell") {
-        const executedCmd = String(event.input?.command || "");
-        if (executedCmd.includes("git commit") || executedCmd.length > 0) {
-          const settledNow = tryRealtimeAutoSettle(store, observer, ctx.cwd, executedCmd);
-          if (settledNow.length > 0) {
-            updateAnchorStatusBar(ctx, store);
-            if (hasActiveUI(ctx)) {
-              for (const item of settledNow) {
-                try {
-                  ctx.ui.notify(`\u2316 Auto-settled #${item.anchor.id} ("${item.anchor.title}") via ${item.reason}`, "info");
-                } catch {
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-    const pathInput = event.input?.path;
-    if (typeof pathInput !== "string") return;
-    const touchedPath = normalizePath(pathInput, ctx.cwd);
-    const anchors = store.list({ cwd: ctx.cwd }).filter((a) => a.status === "active" || a.status === "sleeping");
-    const matches = findMatchedAnchors(anchors, [touchedPath]);
-    if (matches.length > 0) {
-      const isMutation = MUTATION_TOOLS.has((event.toolName || "").toLowerCase());
-      if (isMutation && !event.isError) {
-        for (const m of matches) {
-          store.touch(m.anchor.id);
-        }
-        updateAnchorStatusBar(ctx, store);
-      }
-      const a = matches[0].anchor;
-      if (!annotatedThisSession.has(a.id)) {
-        annotatedThisSession.add(a.id);
-        const alert = makeSafeTaskAnnotation(touchedPath, a);
-        if (alert) {
-          const contents = [...event.content || []];
-          for (let i = contents.length - 1; i >= 0; i--) {
-            const item = contents[i];
-            if (item && item.type === "text") {
-              contents[i] = { ...item, text: item.text + alert };
-              return { content: contents };
-            }
-          }
-        }
-      }
-    }
-  });
-  pi.on("session_shutdown", async (event, ctx) => {
-    let gitStatus = "";
-    try {
-      gitStatus = execSync("git status --porcelain", {
-        cwd: ctx.cwd,
-        encoding: "utf-8",
-        timeout: 2e3,
-        stdio: ["ignore", "pipe", "ignore"]
-      }).replace(/[\r\n]+$/, "");
-      const changed = gitStatus.split(/\r?\n/).filter(Boolean).map((l) => l.slice(3).replace(/^"(.*)"$/, "$1").trim()).filter(Boolean);
-      for (const f of changed) {
-        observer.addTouchedFile(f);
-      }
-    } catch {
-    }
-    if (event?.reason === "quit" && gitStatus) {
-      try {
-        const activeAnchors = store.list({ cwd: ctx.cwd }).filter((a) => a.status === "active");
-        if (activeAnchors.length === 0) {
-          const home = process.env.HOME || process.env.USERPROFILE || "";
-          const pendingPath = path.join(home, ".anchor", "pending_exit.json");
-          const data = {
-            cwd: ctx.cwd,
-            timestamp: Date.now(),
-            modifiedCount: gitStatus.split("\n").filter(Boolean).length
-          };
-          fs.writeFileSync(pendingPath, JSON.stringify(data, null, 2), "utf-8");
-        }
-      } catch {
-      }
-    }
-    const modified = observer.getModifiedFiles();
-    if (modified.length === 0 && !observer.hasCommitted()) return;
-    const proposals = generateSettlementProposals(store, modified, ctx.cwd, observer);
-    if (proposals.length === 0) return;
-    for (const prop of proposals) {
-      const a = prop.anchor;
-      const commitMatch = observer.matchesCommit(a);
-      if (commitMatch.matched) {
-        store.settle(a.id, {
-          settledBy: "verification-test",
-          summary: `Auto-settled via Git commit: ${commitMatch.message}`,
-          touchedFiles: prop.matchedFiles
-        });
-        if (hasActiveUI(ctx)) {
-          try {
-            ctx.ui.notify(`\u2316 Auto-settled #${a.id} via Git commit (run /anchor undo to revert)`, "info");
-          } catch {
-          }
-        }
-        continue;
-      }
-      if (a.verifyCommand) {
-        const verifyRes = runPhysicalVerification(a, ctx.cwd);
-        if (verifyRes.success) {
-          store.settle(a.id, {
-            settledBy: "verification-test",
-            summary: `Automated test passed: ${a.verifyCommand}`,
-            touchedFiles: prop.matchedFiles
-          });
-          if (hasActiveUI(ctx)) {
-            try {
-              ctx.ui.notify(`\u2316 Test passed (${a.verifyCommand}), auto-settled #${a.id}`, "info");
-            } catch {
-            }
-          }
-          continue;
-        }
-      }
-      if (!hasActiveUI(ctx)) continue;
-      try {
-        const ok = await ctx.ui.confirm(
-          "\u2316 Settle Anchor Task",
-          `Task #${a.id} [${a.title}] touched files (${prop.matchedFiles.slice(0, 2).join(", ")}).
-Mark as completed and archive?`
-        );
-        if (ok) {
-          store.settle(a.id, {
-            settledBy: "one-tap-settlement",
-            touchedFiles: prop.matchedFiles
-          });
-          ctx.ui.notify(`\u2316 Settled #${a.id}: "${a.title}"`, "info");
-        }
-      } catch {
-      }
-    }
-  });
-  pi.registerTool({
-    name: "anchor",
-    label: "Anchor (Cross-session Task Protocol)",
-    description: "Manage cross-session persistent tasks that survive terminal restarts and auto-evict upon code changes or settlement. Use when the user asks to retain, pin, remember, or track a multi-session goal across sessions, or when an ongoing commitment must not be forgotten. Actions: pin (create new cross-session anchor), list (view active and sleeping anchors), settle (close and archive a completed anchor), touch (refresh activity), sweep (run decay cleanup). Stored in ~/.anchor/ with zero project repository pollution.",
-    promptSnippet: "Anchor cross-session task contracts that survive terminal restarts and auto-evict",
-    promptGuidelines: [
-      'Use `anchor` when the user asks to retain a goal across sessions or record a reminder for later/tonight/tomorrow (e.g. "\u665A\u4E0A\u6E05\u7406\u5783\u573E", "\u660E\u5929\u4F18\u5316X", "\u4FDD\u7559\u4EFB\u52A1\u76F4\u5230\u5B8C\u6210").',
-      "BOUNDARY WITH TODO: `todo` is strictly for intra-session active work breakdown (step 1, step 2, step 3 right now). For future reminders or cross-session goals, ONLY use `anchor`. NEVER duplicate a cross-session reminder into both `todo` and `anchor`.",
-      "DO NOT over-engineer or assume automated scheduled tasks unless the user explicitly requests Windows Task Scheduler or cron.",
-      "Tasks are automatically scoped to the current project context without cluttering the project git repository.",
-      'When code for an anchor is completed and verified, call `anchor` with action "settle" to archive it and free context.',
-      "Active anchors are automatically injected into future sessions in an ultra-compact block."
-    ],
-    parameters: Type.Object({
-      action: Type.Union([
-        Type.Literal("pin"),
-        Type.Literal("list"),
-        Type.Literal("settle"),
-        Type.Literal("touch"),
-        Type.Literal("sweep")
-      ]),
-      title: Type.Optional(Type.String({ description: "Short imperative task title (for pin)" })),
-      description: Type.Optional(Type.String({ description: "Detailed context, acceptance criteria, or technical notes" })),
-      priority: Type.Optional(Type.Union([Type.Literal("p0"), Type.Literal("p1"), Type.Literal("p2")])),
-      project: Type.Optional(Type.String({ description: "Target project name or workspace (defaults to current directory if omitted)" })),
-      targetDate: Type.Optional(Type.String({ description: "Expected completion date (e.g. YYYY-MM-DD, today, tomorrow)" })),
-      files: Type.Optional(Type.Array(Type.String(), { description: "Associated file paths or directory prefixes" })),
-      tags: Type.Optional(Type.Array(Type.String(), { description: "Domain tags" })),
-      verifyCommand: Type.Optional(Type.String({ description: "Optional shell command for automated physical verification" })),
-      id: Type.Optional(Type.String({ description: "Anchor ID, e.g. anc-1 (for settle or touch)" }))
-    }),
-    renderCall(args, theme) {
-      const action = args.action || "list";
-      let title = theme.fg("toolTitle", theme.bold("\u2316 anchor ")) + theme.fg("accent", action);
-      if (action === "pin" && args.title) {
-        const due = args.targetDate ? ` ${theme.fg("dim", `[${args.targetDate}]`)}` : "";
-        const files = args.files && args.files.length > 0 ? ` ${theme.fg("muted", `(${args.files.slice(0, 2).join(", ")})`)}` : "";
-        title += ` "${args.title}"${due}${files}`;
-      } else if (action === "settle" && args.id) {
-        title += ` ${theme.fg("dim", `#${args.id}`)}`;
-      } else if (action === "touch" && args.id) {
-        title += ` ${theme.fg("dim", `#${args.id}`)}`;
-      } else if (action === "list") {
-        if (args.priority) title += ` ${theme.fg("muted", `[${args.priority}]`)}`;
-      }
-      return {
-        render: (width) => [truncateToWidth(title, width)],
-        invalidate: () => {
-        }
-      };
-    },
-    renderResult(result, _options, theme) {
-      if (result.isError) {
-        const errText = result.content?.[0]?.text || "Execution failed";
-        return {
-          render: (width) => [truncateToWidth(theme.fg("error", `\u2717 ${errText}`), width)],
-          invalidate: () => {
-          }
-        };
-      }
-      const text = result.content?.[0]?.text || "OK";
-      return {
-        render: (width) => [truncateToWidth(theme.fg("success", `\u2714 ${text}`), width)],
-        invalidate: () => {
-        }
-      };
-    },
-    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-      if (!ctx) return { content: [{ type: "text", text: "Error: context required" }], isError: true };
-      if (params.action === "pin") {
-        if (!params.title) {
-          return { content: [{ type: "text", text: "Error: title is required for pin action" }], isError: true };
-        }
-        const anc = store.create({
-          title: params.title,
-          description: params.description,
-          priority: params.priority || "p1",
-          project: params.project,
-          targetDate: params.targetDate,
-          cwd: ctx.cwd,
-          files: params.files || [],
-          tags: params.tags || [],
-          verifyCommand: params.verifyCommand
-        });
-        updateAnchorStatusBar(ctx, store);
-        return {
-          content: [{
-            type: "text",
-            text: `Successfully anchored task #${anc.id}: "${anc.title}" [${anc.project}]. Stored in ~/.anchor/.`
-          }],
-          isError: false
-        };
-      }
-      if (params.action === "list") {
-        const active = store.list({ status: "active", cwd: ctx.cwd });
-        const sleeping = store.list({ status: "sleeping", cwd: ctx.cwd });
-        return {
-          content: [{
-            type: "text",
-            text: JSON.stringify({ active, sleeping }, null, 2)
-          }],
-          isError: false
-        };
-      }
-      if (params.action === "settle") {
-        if (!params.id) {
-          return { content: [{ type: "text", text: "Error: id is required for settle action" }], isError: true };
-        }
-        try {
-          const settled = store.settle(params.id, { settledBy: "verification-test" });
-          updateAnchorStatusBar(ctx, store);
-          return {
-            content: [{
-              type: "text",
-              text: `Anchor #${settled.id} successfully settled and evicted from active context.`
-            }],
-            isError: false
-          };
-        } catch (err) {
-          return { content: [{ type: "text", text: err.message }], isError: true };
-        }
-      }
-      if (params.action === "touch") {
-        if (!params.id) {
-          return { content: [{ type: "text", text: "Error: id is required for touch action" }], isError: true };
-        }
-        try {
-          const touched = store.touch(params.id);
-          updateAnchorStatusBar(ctx, store);
-          return {
-            content: [{
-              type: "text",
-              text: `Anchor #${touched.id} touched and decay timer refreshed.`
-            }],
-            isError: false
-          };
-        } catch (err) {
-          return { content: [{ type: "text", text: err.message }], isError: true };
-        }
-      }
-      if (params.action === "sweep") {
-        const res = sweepStore(store);
-        updateAnchorStatusBar(ctx, store);
-        return {
-          content: [{
-            type: "text",
-            text: `Sweep complete: ${res.transitionedToSleeping.length} sleeping, ${res.evictedToGraveyard.length} evicted to graveyard.`
-          }],
-          isError: false
-        };
-      }
-      return { content: [{ type: "text", text: "Unknown action" }], isError: true };
-    }
-  });
-  pi.registerCommand("anchor", {
-    description: "Inspect, pin, or settle active anchors (e.g. /anchor, /anchor done 1, /anchor undo)",
-    handler: async (args, ctx) => {
-      const parsed = parseAnchorCommandInput(args);
-      if (parsed.mode === "dashboard") {
-        await openAnchorDashboard(ctx, store);
-        return;
-      }
-      if (parsed.mode === "undo") {
-        try {
-          const restored = store.undoSettle();
-          ctx.ui.notify(`\u2316 Restored #${restored.id}: "${restored.title}"`, "info");
-          updateAnchorStatusBar(ctx, store);
-        } catch (err) {
-          ctx.ui.notify(`Revert failed: ${err.message}`, "error");
-        }
-        return;
-      }
-      if (parsed.mode === "settle" && parsed.targetId) {
-        const resolvedId = resolveAnchorTarget(store, parsed.targetId, ctx.cwd);
-        if (!resolvedId) {
-          ctx.ui.notify(`\u2316 Anchor not found: ${parsed.targetId}`, "error");
-          return;
-        }
-        const settled = store.settle(resolvedId, { settledBy: "manual-command" });
-        ctx.ui.notify(`\u2316 Settled #${settled.id}: "${settled.title}" (/anchor undo to revert)`, "info");
-        updateAnchorStatusBar(ctx, store);
-        return;
-      }
-      const rawTrimmed = (args || "").trim();
-      if (/^(?:#?anc-\d+|#\d+)$/i.test(rawTrimmed)) {
-        const resolvedId = resolveAnchorTarget(store, rawTrimmed, ctx.cwd);
-        if (resolvedId) {
-          const settled = store.settle(resolvedId, { settledBy: "manual-command" });
-          ctx.ui.notify(`\u2316 Settled #${settled.id}: "${settled.title}" (/anchor undo to revert)`, "info");
-          updateAnchorStatusBar(ctx, store);
-          return;
-        }
-      }
-      const anc = store.create({
-        title: parsed.title || rawTrimmed,
-        targetDate: parsed.targetDate,
-        cwd: ctx.cwd
-      });
-      ctx.ui.notify(`\u2316 Pinned #${anc.id}: "${anc.title}"${anc.targetDate ? ` (due ${anc.targetDate})` : ""}`, "info");
-      updateAnchorStatusBar(ctx, store);
-    }
-  });
-  pi.registerCommand("pin", {
-    description: "Pin a task across sessions (e.g. /pin Refactor auth --due tomorrow)",
-    handler: async (args, ctx) => {
-      const parsed = parseAnchorCommandInput(args);
-      if (parsed.mode === "dashboard" || !parsed.title) {
-        await openAnchorDashboard(ctx, store);
-        return;
-      }
-      const anc = store.create({
-        title: parsed.title,
-        targetDate: parsed.targetDate,
-        cwd: ctx.cwd
-      });
-      ctx.ui.notify(`\u2316 Pinned #${anc.id}: "${anc.title}"${anc.targetDate ? ` (due ${anc.targetDate})` : ""}`, "info");
-      updateAnchorStatusBar(ctx, store);
-    }
-  });
-  pi.registerCommand("done", {
-    description: "Complete an active anchor by row number or ID (e.g. /done 1)",
-    handler: async (args, ctx) => {
-      const target = (args || "").trim();
-      if (!target) {
-        await openAnchorDashboard(ctx, store);
-        return;
-      }
-      const resolvedId = resolveAnchorTarget(store, target, ctx.cwd);
-      if (!resolvedId) {
-        ctx.ui.notify(`\u2316 Anchor not found: ${target}`, "error");
-        return;
-      }
-      const settled = store.settle(resolvedId, { settledBy: "manual-command" });
-      ctx.ui.notify(`\u2316 Settled #${settled.id}: "${settled.title}" (/anchor undo to revert)`, "info");
-      updateAnchorStatusBar(ctx, store);
-    }
-  });
-  pi.registerCommand("anchors", {
-    description: "Inspect and settle active anchors",
-    handler: async (_args, ctx) => {
-      await openAnchorDashboard(ctx, store);
-    }
-  });
-}
+  extension_default,
+  parseAnchorCommandInput,
+  resolveAnchorTarget
+} from "./chunk-LKY6WIKH.js";
 export {
   extension_default as default,
   parseAnchorCommandInput,