@vortex-os/base 0.5.0 → 0.7.0

package/README.md

@@ -14,18 +14,26 @@ Base entry point for **VortEX** — a Multi-Agent Personal AI Work OS framework.
 
 ## Install
 
+Install the framework, plus the optional `@vortex-os/memory-extended` add-on for semantic recall (drop it if you don't want search):
+
 ```bash
-npm install @vortex-os/base
+npm install @vortex-os/base @vortex-os/memory-extended
 ```
 
-## Quick start — one install, then `init`
+> **On Windows PowerShell?** If `npm` fails with a script-execution / `UnauthorizedAccess` error, that's PowerShell's default policy blocking npm's wrapper script — not a VortEX problem (it blocks *every* npm command). Fix it one of these ways: run `npm.cmd install …` instead of `npm install …`, or use `cmd.exe`, or enable scripts once with `Set-ExecutionPolicy -Scope CurrentUser RemoteSigned -Force` and retry.
+
+## Quick start
+
+`@vortex-os/base` ships a `vortex` CLI. Two ways to a working instance:
+
+**Easiest — let your agent do it.** In a new folder, open your coding agent (Claude Code, Codex, …) and tell it — **keep the literal `vortex init`, don't translate or paraphrase it**: *"install `@vortex-os/base` and `@vortex-os/memory-extended`, then run `vortex init`."* (Before the rule files exist the agent has no VortEX context, so a paraphrase like "initialize vortex" can be misread as a generic project setup; the exact `vortex init` avoids that.) The agent installs the packages and runs `init` (which asks for your name and role; what you're working on is optional). **Then restart the agent in that folder** so it loads the freshly created rule files (`CLAUDE.md`, `AGENTS.md`, …) and session hooks — agents read those only at startup. Bonus: the agent runs npm in its own shell, so the Windows PowerShell issue above never comes up.
 
-`@vortex-os/base` ships a `vortex` CLI, so a working instance is three steps:
+**Manual — three steps:**
 
 ```bash
-npm install @vortex-os/base     # install the framework into a new folder
-npx vortex init                 # scaffold the instance (asks for name / role / task)
-# then open your agent (e.g. `claude`) in that folder
+npm install @vortex-os/base @vortex-os/memory-extended   # framework + semantic-recall add-on
+npx vortex init                                          # scaffold the instance (asks name + role; task optional)
+# then open your agent (e.g. `claude`) in that folder — a fresh start loads the rules init just created
 ```
 
 `npx vortex init` is non-destructive and creates, in the current folder:

package/dist/index.d.ts

@@ -303,12 +303,20 @@ interface CommandArg {
  * - `rest` — the unparsed trailing portion of the input (everything after
  *   the command name), provided as-is for commands that prefer to handle
  *   their own parsing.
+ * - `argv` — pre-split argument tokens (everything after the command name),
+ *   present only when the caller already holds the shell-split argv (e.g. the
+ *   `vortex` CLI). A command that does its own quote-aware tokenization should
+ *   prefer this over re-parsing `rest`: it avoids the lossy
+ *   string-join-then-re-tokenize round-trip, so quotes/spaces/empty values in a
+ *   token can never shift the boundaries of later tokens. Absent for the
+ *   typed-slash path, where the command falls back to tokenizing `rest`.
  * - `context` — resolved repository paths from `@vortex-os/core.makeContext`.
  */
 interface CommandInput {
     readonly raw: string;
     readonly args: Readonly<Record<string, string>>;
     readonly rest: string;
+    readonly argv?: readonly string[];
     readonly context: ModuleContext;
 }
 /**
@@ -360,6 +368,18 @@ declare class CommandNotFoundError extends Error {
  * Returns whatever the command's handler returns (awaited if it is async).
  */
 declare function runSlash(input: string, { registry, context }: RunOptions): Promise<unknown>;
+/**
+ * Dispatch a command by name with pre-split argument tokens, skipping the
+ * whitespace split `runSlash` does on a raw string. Use this when the caller
+ * already holds clean tokens (e.g. the shell-split `vortex` CLI argv): the
+ * tokens reach the handler verbatim via `CommandInput.argv`, so quotes, spaces,
+ * or empty values inside a token can never shift the boundaries of later tokens
+ * (the lossy hazard of joining argv into a string and re-tokenizing it).
+ *
+ * `argv` is the tokens AFTER the command name. `rest`/`args` are still derived
+ * for handlers that read them, but a quote-aware command should prefer `argv`.
+ */
+declare function runSlashArgv(name: string, argv: readonly string[], { registry, context }: RunOptions): Promise<unknown>;
 
 //# sourceMappingURL=index.d.ts.map
 
@@ -372,8 +392,9 @@ type index_d$c_CommandRegistry = CommandRegistry;
 declare const index_d$c_CommandRegistry: typeof CommandRegistry;
 type index_d$c_RunOptions = RunOptions;
 declare const index_d$c_runSlash: typeof runSlash;
+declare const index_d$c_runSlashArgv: typeof runSlashArgv;
 declare namespace index_d$c {
-  export { type index_d$c_Command as Command, type index_d$c_CommandArg as CommandArg, type index_d$c_CommandInput as CommandInput, index_d$c_CommandNotFoundError as CommandNotFoundError, index_d$c_CommandRegistry as CommandRegistry, type index_d$c_RunOptions as RunOptions, index_d$c_runSlash as runSlash };
+  export { type index_d$c_Command as Command, type index_d$c_CommandArg as CommandArg, type index_d$c_CommandInput as CommandInput, index_d$c_CommandNotFoundError as CommandNotFoundError, index_d$c_CommandRegistry as CommandRegistry, type index_d$c_RunOptions as RunOptions, index_d$c_runSlash as runSlash, index_d$c_runSlashArgv as runSlashArgv };
 }
 
 /**
@@ -2583,14 +2604,196 @@ interface CliIo {
  * `curate` is intentionally NOT wired here — it is agent-mediated.
  */
 declare function buildRegistry(): Promise<CommandRegistry>;
-/** Resolve the repo root the same way every entry point should: env override, else cwd. */
+/**
+ * Resolve the repo root every entry point should use. Precedence:
+ *   1. `VORTEX_REPO_ROOT` env — explicit override always wins.
+ *   2. cwd, if cwd is itself an initialized instance — running inside an instance
+ *      uses that instance (so multiple instances on one machine still work).
+ *   3. the global pointer (`~/.claude/vortex-global.json`), set by
+ *      `vortex global-setup` — so commands run from any other folder record to
+ *      the one central instance.
+ *   4. cwd — the original fallback.
+ * Until global-setup runs (no pointer), this is identical to the old behavior:
+ * env override, else cwd.
+ */
 declare function resolveRepoRoot(): string;
+/**
+ * Reassemble shell-split argv into the `/`-command string `runSlash` expects,
+ * for every command EXCEPT `/vortex`. Whitespace-containing values are wrapped by
+ * `requote` so they stay visible as a quoted span, and empty tokens are dropped.
+ * `runSlash` then splits this on whitespace only (it is NOT quote-aware), so this
+ * path preserves the long-standing behavior of those commands rather than
+ * guaranteeing perfect token reunification.
+ *
+ * `/vortex` deliberately bypasses this: the CLI threads its tokens straight to
+ * the handler (`runSlashArgv` in runVortexCli), which is what fixes the
+ * quoted/empty-value boundary bug — no lossy join-then-resplit round-trip.
+ */
+declare function argvToSlash(argv: readonly string[]): string;
 /**
  * Run the `vortex` CLI for the given argv (already sliced past `node script`).
  * Returns the process exit code (0 success, 1 on error) instead of calling
  * `process.exit`, so callers/tests stay in control.
  */
 declare function runVortexCli(argv: readonly string[], io?: CliIo): Promise<number>;
+/**
+ * Detect an interrupted git operation — a near-certain crashed-session signal:
+ * a merge / rebase / cherry-pick / revert / bisect left mid-flight, or a stray
+ * index lock. Uses `git rev-parse --git-path` so the marker resolves correctly
+ * even when `.git` is a FILE (a linked worktree or submodule), not a directory.
+ * Returns the FIRST matching marker name, or null when the tree is clean / not a
+ * git repo. Exported for tests. (Tier-1 carryover; decision-log 2026-06-04.)
+ */
+declare function detectInterruptedGitOp(repoRoot: string): string | null;
+/**
+ * Assemble the Tier-1 carryover signal for the session-start report. The
+ * interrupted-op check and the uncommitted count are computed INDEPENDENTLY: a
+ * held/stale `index.lock` can make `git status` fail, and that must NOT suppress
+ * the interrupted-op signal — the very case we most want to surface. Returns
+ * null when there is nothing to report (clean tree / not a git repo). Exported
+ * for tests. (decision-log 2026-06-04-session-recovery-two-tier.)
+ */
+declare function collectCarryover(repoRoot: string): {
+    uncommitted: number;
+    interrupted: string | null;
+} | null;
+
+/**
+ * Hook wiring for `/vortex init`: make sure the instance's
+ * `.claude/settings.json` registers the VortEX SessionStart / SessionEnd hooks,
+ * so the boot report + worklog-net fire automatically without the user knowing
+ * any command. NON-DESTRUCTIVE — like the MCP install merge, this preserves
+ * every other hook and top-level field and only adds our two entries if absent.
+ *
+ * Pure functions here (parse / merge / detect); the command does the actual
+ * file read/write around them. Keeping them pure makes the merge unit-testable
+ * and the "writes only what's missing" guarantee verifiable.
+ */
+declare const SESSION_START_COMMAND = "npx --no-install -p @vortex-os/base vortex session-start || exit 0";
+declare const SESSION_END_COMMAND = "npx --no-install -p @vortex-os/base vortex session-end || exit 0";
+interface HookCommand {
+    readonly type: "command";
+    readonly command: string;
+}
+interface HookGroup {
+    readonly hooks: readonly HookCommand[];
+    readonly matcher?: string;
+}
+interface ClaudeSettings {
+    hooks?: {
+        SessionStart?: HookGroup[];
+        SessionEnd?: HookGroup[];
+        [event: string]: HookGroup[] | undefined;
+    };
+    [key: string]: unknown;
+}
+interface EnsureHooksResult {
+    readonly settings: ClaudeSettings;
+    /**
+     * Hook events that CHANGED — a VortEX entry was added, or a legacy one was
+     * migrated/de-duplicated in place (empty when nothing changed). Callers should
+     * key "did we need to write?" off `alreadyWired`, not the name "added".
+     */
+    readonly added: readonly ("SessionStart" | "SessionEnd")[];
+    /** True when nothing changed — every VortEX hook was already present. */
+    readonly alreadyWired: boolean;
+}
+/**
+ * Parse existing settings.json text. Empty/whitespace → `{}` (fresh). Throws on
+ * malformed JSON so the caller aborts rather than clobbering a hand-edited file.
+ */
+declare function parseSettings(text: string | null | undefined): ClaudeSettings;
+/**
+ * Merge the VortEX hooks into an existing settings object WITHOUT mutating the
+ * input. A hook event is left untouched if it already references our command
+ * (idempotent); otherwise our group is appended alongside any existing groups.
+ */
+declare function ensureVortexHooks(existing: ClaudeSettings | null | undefined): EnsureHooksResult;
+/** Serialize settings the way Claude writes them (2-space, trailing newline). */
+declare function serializeSettings(settings: ClaudeSettings): string;
+
+/**
+ * Global usage setup — make a VortEX instance reachable from ANY folder, not
+ * just the instance directory. The lever is the user's GLOBAL Claude config
+ * (`~/.claude/`), which Claude Code reads in every project:
+ *
+ *   1. `~/.claude/settings.json`     — global SessionStart/SessionEnd hooks, so
+ *      the boot report + worklog-net fire in every folder. SAME command string
+ *      as the per-instance hook, so Claude Code's identical-hook dedup means the
+ *      instance folder never double-fires.
+ *   2. `~/.claude/vortex-global.json` — a small pointer file recording the
+ *      instance path (and a decline marker). `resolveRepoRoot()` reads
+ *      `instanceRoot` so commands run from any folder record to the one instance
+ *      WITHOUT needing an env var baked into the hook command (which would be
+ *      shell-dependent and would break hook dedup).
+ *   3. `~/.claude/CLAUDE.md`         — a small, marker-delimited pointer block
+ *      telling the agent where the instance is and to read its `AI-RULES.md` for
+ *      VortEX work. Regenerated in place; the user's other CLAUDE.md content is
+ *      preserved.
+ *
+ * Every write is merge-safe and idempotent. Pure helpers (block upsert, state
+ * read) are separated from the thin fs wrappers so the merge is unit-testable.
+ * All functions take an explicit `home` (default `os.homedir()`) so tests can
+ * point at a fake home without touching the real `~/.claude`.
+ */
+
+declare function globalSettingsPath(home?: string): string;
+/** The pointer/state file: `{ instanceRoot?, declinedAt? }`. */
+declare function globalStatePath(home?: string): string;
+declare function globalMemoryPath(home?: string): string;
+/**
+ * The instance root recorded by a prior `vortex global-setup`, or null. Read by
+ * `resolveRepoRoot()` so any-folder commands target the central instance.
+ */
+declare function readGlobalInstancePointer(home?: string): string | null;
+/**
+ * Does `dir` look like an initialized VortEX instance? Used by
+ * `resolveRepoRoot()` so that running INSIDE any instance uses that instance,
+ * and only falls back to the global pointer elsewhere.
+ */
+declare function isInstanceRoot(dir: string): boolean;
+/** True if the global settings.json already carries BOTH our session hooks. */
+declare function globalSettingsHasHook(home?: string): boolean;
+/**
+ * State of global usage on this machine. `done` = pointer set AND global hook
+ * wired (and, if `instanceRoot` given, the pointer matches it). `declined` = the
+ * user dismissed the offer. The session-start offer shows only when neither.
+ */
+declare function inspectGlobalSetup(home?: string, instanceRoot?: string): {
+    readonly done: boolean;
+    readonly declined: boolean;
+};
+/** The marker-delimited pointer block written into the global CLAUDE.md. */
+declare function renderGlobalBlock(instanceRoot: string): string;
+/**
+ * Insert or replace the VortEX block in an existing CLAUDE.md, preserving all
+ * other content. Idempotent: a second call with the same instanceRoot returns
+ * identical text.
+ */
+declare function upsertGlobalBlock(existing: string, instanceRoot: string): string;
+interface GlobalSetupWrite {
+    readonly created: readonly string[];
+    readonly modified: readonly string[];
+    readonly skipped: readonly string[];
+}
+/**
+ * Apply global usage setup for `instanceRoot`: merge global hooks, write the
+ * pointer, and upsert the CLAUDE.md block. Non-destructive and idempotent —
+ * re-running with the same instance is a no-op (everything reported `skipped`).
+ */
+declare function applyGlobalSetup(opts: {
+    readonly instanceRoot: string;
+    readonly home?: string;
+}): Promise<GlobalSetupWrite>;
+/**
+ * Record that the user declined the global-usage offer, so the session-start
+ * report stops offering it. Preserves any existing pointer. Returns the path
+ * written.
+ */
+declare function recordGlobalSetupDecline(opts?: {
+    readonly home?: string;
+    readonly now?: Date;
+}): Promise<string>;
 
 /** The two document actions the v1 value loop supports. */
 type CurateActionKind = "create-file" | "append-section";
@@ -2841,6 +3044,19 @@ interface SessionStartHookReport {
     }[];
     /** Always-on memories dropped because the count exceeded the cap (0 = none). */
     readonly alwaysOnOverflow: number;
+    /**
+     * The on-demand **action-trigger catalog**: behavioral memories (`scope !=
+     * always`, classified action-trigger) surfaced as compact `slug — description`
+     * HINTS so the agent knows they exist and opens the full memory when its next
+     * action matches. NOT the rule bodies (those stay on `/recall`); capped tight
+     * (row + total + per-row) so it never grows into a context tax.
+     */
+    readonly actionTriggers: readonly {
+        readonly slug: string;
+        readonly description: string;
+    }[];
+    /** Action-trigger rows dropped by the row/total-char cap (0 = none). */
+    readonly actionTriggerOverflow: number;
     /**
      * The on-demand index looks stale — suggest `reindex`. True when memories
      * exist but `_INDEX.md` is missing, or a `_memory/*.md` is newer than it.
@@ -2863,6 +3079,13 @@ declare function collectSessionStartReport(ctx: ModuleContext, opts?: {
  * hook supplies `commitDays` from git; the report supplies the present dates.
  */
 declare function detectWorklogGaps(commitDays: readonly string[], presentDates: readonly string[]): string[];
+/**
+ * Count changed paths in `git status --porcelain` output — one path per
+ * non-empty line. Pure: the hook runs git; this turns its stdout into the
+ * Tier-1 carryover count. (`--porcelain` emits exactly one line per changed
+ * path, including untracked, so a line count is the change count.)
+ */
+declare function countUncommitted(porcelain: string): number;
 /**
  * Render a session-start report as a compact markdown block for a host hook
  * to inject as session context. A pull conflict and any worklog gaps are
@@ -2909,6 +3132,24 @@ declare function renderSessionStartReport(report: SessionStartHookReport, extras
         readonly command: string | null;
         readonly registry: string;
     };
+    /**
+     * One-time offer: this machine has not enabled "VortEX from any folder" and
+     * the user hasn't declined. The agent asks once; on yes → `vortex
+     * global-setup`, on no → `vortex global-setup --decline` (so it stops asking).
+     */
+    readonly globalSetupOffer?: boolean;
+    /**
+     * Tier-1 session-resume signals (cheap, git-only; computed by the hook):
+     * work carried over from a prior session. `interrupted` names an in-progress
+     * git op (MERGE_HEAD / rebase / lock) — a near-certain crash signal, surfaced
+     * as ⚠️. `uncommitted` counts changed paths present at session start — common
+     * in normal WIP, so surfaced as a quiet informational line only. Both point at
+     * `/resume` (Tier 2). See decision-log 2026-06-04-session-recovery-two-tier.
+     */
+    readonly carryover?: {
+        readonly uncommitted: number;
+        readonly interrupted: string | null;
+    };
 }): string;
 
 /**
@@ -2980,56 +3221,6 @@ interface CatchUpOptions {
 }
 declare function catchUpSessions(ctx: ModuleContext, opts?: CatchUpOptions): Promise<CatchUpResult>;
 
-/**
- * Hook wiring for `/vortex init`: make sure the instance's
- * `.claude/settings.json` registers the VortEX SessionStart / SessionEnd hooks,
- * so the boot report + worklog-net fire automatically without the user knowing
- * any command. NON-DESTRUCTIVE — like the MCP install merge, this preserves
- * every other hook and top-level field and only adds our two entries if absent.
- *
- * Pure functions here (parse / merge / detect); the command does the actual
- * file read/write around them. Keeping them pure makes the merge unit-testable
- * and the "writes only what's missing" guarantee verifiable.
- */
-declare const SESSION_START_COMMAND = "npx --no-install -p @vortex-os/base vortex session-start";
-declare const SESSION_END_COMMAND = "npx --no-install -p @vortex-os/base vortex session-end";
-interface HookCommand {
-    readonly type: "command";
-    readonly command: string;
-}
-interface HookGroup {
-    readonly hooks: readonly HookCommand[];
-    readonly matcher?: string;
-}
-interface ClaudeSettings {
-    hooks?: {
-        SessionStart?: HookGroup[];
-        SessionEnd?: HookGroup[];
-        [event: string]: HookGroup[] | undefined;
-    };
-    [key: string]: unknown;
-}
-interface EnsureHooksResult {
-    readonly settings: ClaudeSettings;
-    /** Which hook events we added a VortEX entry to (empty if already wired). */
-    readonly added: readonly ("SessionStart" | "SessionEnd")[];
-    /** True when nothing changed — every VortEX hook was already present. */
-    readonly alreadyWired: boolean;
-}
-/**
- * Parse existing settings.json text. Empty/whitespace → `{}` (fresh). Throws on
- * malformed JSON so the caller aborts rather than clobbering a hand-edited file.
- */
-declare function parseSettings(text: string | null | undefined): ClaudeSettings;
-/**
- * Merge the VortEX hooks into an existing settings object WITHOUT mutating the
- * input. A hook event is left untouched if it already references our command
- * (idempotent); otherwise our group is appended alongside any existing groups.
- */
-declare function ensureVortexHooks(existing: ClaudeSettings | null | undefined): EnsureHooksResult;
-/** Serialize settings the way Claude writes them (2-space, trailing newline). */
-declare function serializeSettings(settings: ClaudeSettings): string;
-
 interface ReindexResult {
     readonly dir: string;
     readonly status: "written" | "unchanged" | "missing";
@@ -3180,8 +3371,12 @@ declare function renderAgenda(report: AgendaReport): string;
  */
 declare const agendaCommand: Command<AgendaReport>;
 
-/** Schema tag for the ownership manifest; bump on a breaking shape change. */
-declare const OWNERSHIP_SCHEMA = "vortex-ownership/1";
+/**
+ * Schema tag for the ownership manifest; bump on a breaking shape change.
+ * v2: hashes are EOL-normalized (LF) content hashes, not raw bytes — a pre-v2
+ * (raw-byte) manifest is migrated in memory on read (see `migrateOwnershipToV2`).
+ */
+declare const OWNERSHIP_SCHEMA = "vortex-ownership/2";
 /** A single framework-owned file the instance tracks for updates. */
 interface OwnershipEntry {
     /** Stable id across path moves — currently the template-relative path. */
@@ -3207,7 +3402,7 @@ interface OwnershipManifest {
     readonly generatedAt: string;
     readonly files: readonly OwnershipEntry[];
 }
-type UpdateFileActionKind = "replace" | "restore" | "install" | "conflict" | "locally-modified" | "unmanaged" | "removed-upstream" | "unchanged";
+type UpdateFileActionKind = "replace" | "restore" | "install" | "conflict" | "locally-modified" | "unmanaged" | "adopt" | "removed-upstream" | "unchanged";
 interface UpdateFileAction {
     readonly path: string;
     readonly templateId: string;
@@ -3237,6 +3432,8 @@ interface VortexUpdateResult {
         readonly conflicts: number;
         readonly unchanged: number;
         readonly unmanaged: number;
+        /** Files force-refreshed to the template via `--adopt` (prior bytes backed up). */
+        readonly adopted: number;
         readonly locallyModified: number;
         readonly removedUpstream: number;
         /** Files whose apply threw (left unchanged) — surfaces a partial run. */
@@ -3302,7 +3499,7 @@ interface OwnershipDiagnosis {
  * files are stock, user-edited, missing, or foreign. No template index needed
  * (it compares disk to the recorded `installedSha256`, not to a new template).
  */
-declare function inspectOwnership(ctx: ModuleContext): Promise<OwnershipDiagnosis>;
+declare function inspectOwnership(ctx: ModuleContext, templatesDir?: string | null): Promise<OwnershipDiagnosis>;
 /**
  * Adopt / repair the ownership manifest for an instance that lacks one (e.g.
  * created before the update lifecycle existed). Conservative by design: it does
@@ -3326,6 +3523,7 @@ declare function repairOwnershipManifest(ctx: ModuleContext, templatesDir: strin
  */
 declare function runTemplatesUpdate(ctx: ModuleContext, templatesDir: string | null, options?: {
     dryRun?: boolean;
+    adopt?: ReadonlySet<string>;
 }): Promise<VortexUpdateResult>;
 
 /**
@@ -3488,8 +3686,23 @@ interface VortexSyncResult {
     readonly failedAt?: VortexSyncStepId;
     readonly nextActions: readonly string[];
 }
-type VortexResult = VortexInitResult | VortexStatusResult | VortexImportResult | VortexDoctorResult | VortexSyncResult | VortexUpdateResult | VortexPlannedResult | VortexHelpResult;
+interface VortexGlobalSetupResult {
+    readonly subcommand: "global-setup";
+    readonly status: "completed" | "declined" | "error";
+    readonly created: readonly string[];
+    readonly modified: readonly string[];
+    readonly skipped: readonly string[];
+    readonly nextActions: readonly string[];
+}
+type VortexResult = VortexInitResult | VortexStatusResult | VortexImportResult | VortexDoctorResult | VortexSyncResult | VortexUpdateResult | VortexGlobalSetupResult | VortexPlannedResult | VortexHelpResult;
 declare const vortexCommand: Command<VortexResult>;
+/**
+ * Parse `--adopt <path>` (repeatable) tokens into the POSIX, repoRoot-relative
+ * dest paths the ownership manifest uses, so a Windows-style argument
+ * (`.claude\commands\recall.md` or a leading `./`) still matches a slot. The
+ * value is the dest path shown in the update report. Exported for tests.
+ */
+declare function parseAdoptArgs(tokens: readonly string[]): Set<string>;
 
 interface UpdateCheckResult {
     readonly package: string;
@@ -3607,35 +3820,50 @@ type index_d_VortexSyncStepStatus = VortexSyncStepStatus;
 type index_d_VortexUpdateResult = VortexUpdateResult;
 type index_d_WorklogAppendResult = WorklogAppendResult;
 declare const index_d_agendaCommand: typeof agendaCommand;
+declare const index_d_applyGlobalSetup: typeof applyGlobalSetup;
+declare const index_d_argvToSlash: typeof argvToSlash;
 declare const index_d_buildInstallCommand: typeof buildInstallCommand;
 declare const index_d_buildOwnershipManifest: typeof buildOwnershipManifest;
 declare const index_d_buildRegistry: typeof buildRegistry;
 declare const index_d_catchUpSessions: typeof catchUpSessions;
 declare const index_d_checkBaseUpdate: typeof checkBaseUpdate;
 declare const index_d_collectAgenda: typeof collectAgenda;
+declare const index_d_collectCarryover: typeof collectCarryover;
 declare const index_d_collectSessionStartReport: typeof collectSessionStartReport;
 declare const index_d_compareSemver: typeof compareSemver;
 declare const index_d_computeCurateFingerprint: typeof computeCurateFingerprint;
+declare const index_d_countUncommitted: typeof countUncommitted;
 declare const index_d_createAmbientRecaller: typeof createAmbientRecaller;
 declare const index_d_createRitualRegistry: typeof createRitualRegistry;
 declare const index_d_curateCommand: typeof curateCommand;
 declare const index_d_decisionCommand: typeof decisionCommand;
+declare const index_d_detectInterruptedGitOp: typeof detectInterruptedGitOp;
 declare const index_d_detectWorklogGaps: typeof detectWorklogGaps;
 declare const index_d_ensureVortexHooks: typeof ensureVortexHooks;
 declare const index_d_ensureWorklogEntry: typeof ensureWorklogEntry;
 declare const index_d_extractNextUp: typeof extractNextUp;
 declare const index_d_extractOpenTasks: typeof extractOpenTasks;
+declare const index_d_globalMemoryPath: typeof globalMemoryPath;
+declare const index_d_globalSettingsHasHook: typeof globalSettingsHasHook;
+declare const index_d_globalSettingsPath: typeof globalSettingsPath;
+declare const index_d_globalStatePath: typeof globalStatePath;
+declare const index_d_inspectGlobalSetup: typeof inspectGlobalSetup;
 declare const index_d_inspectOwnership: typeof inspectOwnership;
+declare const index_d_isInstanceRoot: typeof isInstanceRoot;
 declare const index_d_isNewer: typeof isNewer;
 declare const index_d_isStableUpdate: typeof isStableUpdate;
 declare const index_d_logCommand: typeof logCommand;
 declare const index_d_ownershipManifestPath: typeof ownershipManifestPath;
+declare const index_d_parseAdoptArgs: typeof parseAdoptArgs;
 declare const index_d_parseSettings: typeof parseSettings;
 declare const index_d_queryNpmLatest: typeof queryNpmLatest;
+declare const index_d_readGlobalInstancePointer: typeof readGlobalInstancePointer;
 declare const index_d_readInstalledBaseVersion: typeof readInstalledBaseVersion;
 declare const index_d_recallCommand: typeof recallCommand;
+declare const index_d_recordGlobalSetupDecline: typeof recordGlobalSetupDecline;
 declare const index_d_reindexCommand: typeof reindexCommand;
 declare const index_d_renderAgenda: typeof renderAgenda;
+declare const index_d_renderGlobalBlock: typeof renderGlobalBlock;
 declare const index_d_renderSessionStartReport: typeof renderSessionStartReport;
 declare const index_d_repairOwnershipManifest: typeof repairOwnershipManifest;
 declare const index_d_resolveRepoRoot: typeof resolveRepoRoot;
@@ -3648,11 +3876,12 @@ declare const index_d_runVortexCli: typeof runVortexCli;
 declare const index_d_serializeSettings: typeof serializeSettings;
 declare const index_d_sessionStartCommand: typeof sessionStartCommand;
 declare const index_d_templateDestRelPath: typeof templateDestRelPath;
+declare const index_d_upsertGlobalBlock: typeof upsertGlobalBlock;
 declare const index_d_validateCuratePayload: typeof validateCuratePayload;
 declare const index_d_vortexCommand: typeof vortexCommand;
 declare const index_d_writeOwnershipManifest: typeof writeOwnershipManifest;
 declare namespace index_d {
-  export { type index_d_AgendaReport as AgendaReport, type index_d_AmbientRecallFactoryOptions as AmbientRecallFactoryOptions, type index_d_CatchUpOptions as CatchUpOptions, type index_d_CatchUpResult as CatchUpResult, type index_d_ClaudeSettings as ClaudeSettings, type index_d_CliIo as CliIo, type index_d_CollectAgendaOptions as CollectAgendaOptions, type index_d_CurateAcceptResult as CurateAcceptResult, type index_d_CurateActionKind as CurateActionKind, type index_d_CurateAnyProposal as CurateAnyProposal, type index_d_CurateCandidate as CurateCandidate, type index_d_CurateCandidatesResult as CurateCandidatesResult, type index_d_CurateDeclineResult as CurateDeclineResult, type index_d_CurateOptions as CurateOptions, type index_d_CuratePayload as CuratePayload, type index_d_CuratePayloadValidation as CuratePayloadValidation, type index_d_CuratePreviewResult as CuratePreviewResult, type index_d_CurateResult as CurateResult, type index_d_EnsureHooksResult as EnsureHooksResult, type index_d_EnsureWorklogResult as EnsureWorklogResult, type index_d_GitPullResult as GitPullResult, type index_d_NewDecisionResult as NewDecisionResult, index_d_OWNERSHIP_SCHEMA as OWNERSHIP_SCHEMA, type index_d_OpenDecision as OpenDecision, type index_d_OpenTask as OpenTask, type index_d_OwnershipDiagnosis as OwnershipDiagnosis, type index_d_OwnershipEntry as OwnershipEntry, type index_d_OwnershipManifest as OwnershipManifest, type index_d_RecallOptions as RecallOptions, type index_d_RecentWorklog as RecentWorklog, type index_d_ReindexResult as ReindexResult, type index_d_RitualRegistryOptions as RitualRegistryOptions, index_d_SESSION_END_COMMAND as SESSION_END_COMMAND, index_d_SESSION_START_COMMAND as SESSION_START_COMMAND, type index_d_SessionStartHookReport as SessionStartHookReport, type index_d_SessionStartReport as SessionStartReport, type index_d_UpdateCheckResult as UpdateCheckResult, type index_d_UpdateFileAction as UpdateFileAction, type index_d_UpdateFileActionKind as UpdateFileActionKind, type index_d_VortexHelpResult as VortexHelpResult, type index_d_VortexInitResult as VortexInitResult, type index_d_VortexPlannedResult as VortexPlannedResult, type index_d_VortexResult as VortexResult, type index_d_VortexSyncResult as VortexSyncResult, type index_d_VortexSyncStep as VortexSyncStep, type index_d_VortexSyncStepId as VortexSyncStepId, type index_d_VortexSyncStepStatus as VortexSyncStepStatus, type index_d_VortexUpdateResult as VortexUpdateResult, type index_d_WorklogAppendResult as WorklogAppendResult, index_d_agendaCommand as agendaCommand, index_d_buildInstallCommand as buildInstallCommand, index_d_buildOwnershipManifest as buildOwnershipManifest, index_d_buildRegistry as buildRegistry, index_d_catchUpSessions as catchUpSessions, index_d_checkBaseUpdate as checkBaseUpdate, index_d_collectAgenda as collectAgenda, index_d_collectSessionStartReport as collectSessionStartReport, index_d_compareSemver as compareSemver, index_d_computeCurateFingerprint as computeCurateFingerprint, index_d_createAmbientRecaller as createAmbientRecaller, index_d_createRitualRegistry as createRitualRegistry, index_d_curateCommand as curateCommand, index_d_decisionCommand as decisionCommand, index_d_detectWorklogGaps as detectWorklogGaps, index_d_ensureVortexHooks as ensureVortexHooks, index_d_ensureWorklogEntry as ensureWorklogEntry, index_d_extractNextUp as extractNextUp, index_d_extractOpenTasks as extractOpenTasks, index_d_inspectOwnership as inspectOwnership, index_d_isNewer as isNewer, index_d_isStableUpdate as isStableUpdate, index_d_logCommand as logCommand, index_d_ownershipManifestPath as ownershipManifestPath, index_d_parseSettings as parseSettings, index_d_queryNpmLatest as queryNpmLatest, index_d_readInstalledBaseVersion as readInstalledBaseVersion, index_d_recallCommand as recallCommand, index_d_reindexCommand as reindexCommand, index_d_renderAgenda as renderAgenda, index_d_renderSessionStartReport as renderSessionStartReport, index_d_repairOwnershipManifest as repairOwnershipManifest, index_d_resolveRepoRoot as resolveRepoRoot, index_d_runCurateAccept as runCurateAccept, index_d_runCurateCandidates as runCurateCandidates, index_d_runCurateDecline as runCurateDecline, index_d_runCuratePreview as runCuratePreview, index_d_runTemplatesUpdate as runTemplatesUpdate, index_d_runVortexCli as runVortexCli, index_d_serializeSettings as serializeSettings, index_d_sessionStartCommand as sessionStartCommand, index_d_templateDestRelPath as templateDestRelPath, index_d_validateCuratePayload as validateCuratePayload, index_d_vortexCommand as vortexCommand, index_d_writeOwnershipManifest as writeOwnershipManifest };
+  export { type index_d_AgendaReport as AgendaReport, type index_d_AmbientRecallFactoryOptions as AmbientRecallFactoryOptions, type index_d_CatchUpOptions as CatchUpOptions, type index_d_CatchUpResult as CatchUpResult, type index_d_ClaudeSettings as ClaudeSettings, type index_d_CliIo as CliIo, type index_d_CollectAgendaOptions as CollectAgendaOptions, type index_d_CurateAcceptResult as CurateAcceptResult, type index_d_CurateActionKind as CurateActionKind, type index_d_CurateAnyProposal as CurateAnyProposal, type index_d_CurateCandidate as CurateCandidate, type index_d_CurateCandidatesResult as CurateCandidatesResult, type index_d_CurateDeclineResult as CurateDeclineResult, type index_d_CurateOptions as CurateOptions, type index_d_CuratePayload as CuratePayload, type index_d_CuratePayloadValidation as CuratePayloadValidation, type index_d_CuratePreviewResult as CuratePreviewResult, type index_d_CurateResult as CurateResult, type index_d_EnsureHooksResult as EnsureHooksResult, type index_d_EnsureWorklogResult as EnsureWorklogResult, type index_d_GitPullResult as GitPullResult, type index_d_NewDecisionResult as NewDecisionResult, index_d_OWNERSHIP_SCHEMA as OWNERSHIP_SCHEMA, type index_d_OpenDecision as OpenDecision, type index_d_OpenTask as OpenTask, type index_d_OwnershipDiagnosis as OwnershipDiagnosis, type index_d_OwnershipEntry as OwnershipEntry, type index_d_OwnershipManifest as OwnershipManifest, type index_d_RecallOptions as RecallOptions, type index_d_RecentWorklog as RecentWorklog, type index_d_ReindexResult as ReindexResult, type index_d_RitualRegistryOptions as RitualRegistryOptions, index_d_SESSION_END_COMMAND as SESSION_END_COMMAND, index_d_SESSION_START_COMMAND as SESSION_START_COMMAND, type index_d_SessionStartHookReport as SessionStartHookReport, type index_d_SessionStartReport as SessionStartReport, type index_d_UpdateCheckResult as UpdateCheckResult, type index_d_UpdateFileAction as UpdateFileAction, type index_d_UpdateFileActionKind as UpdateFileActionKind, type index_d_VortexHelpResult as VortexHelpResult, type index_d_VortexInitResult as VortexInitResult, type index_d_VortexPlannedResult as VortexPlannedResult, type index_d_VortexResult as VortexResult, type index_d_VortexSyncResult as VortexSyncResult, type index_d_VortexSyncStep as VortexSyncStep, type index_d_VortexSyncStepId as VortexSyncStepId, type index_d_VortexSyncStepStatus as VortexSyncStepStatus, type index_d_VortexUpdateResult as VortexUpdateResult, type index_d_WorklogAppendResult as WorklogAppendResult, index_d_agendaCommand as agendaCommand, index_d_applyGlobalSetup as applyGlobalSetup, index_d_argvToSlash as argvToSlash, index_d_buildInstallCommand as buildInstallCommand, index_d_buildOwnershipManifest as buildOwnershipManifest, index_d_buildRegistry as buildRegistry, index_d_catchUpSessions as catchUpSessions, index_d_checkBaseUpdate as checkBaseUpdate, index_d_collectAgenda as collectAgenda, index_d_collectCarryover as collectCarryover, index_d_collectSessionStartReport as collectSessionStartReport, index_d_compareSemver as compareSemver, index_d_computeCurateFingerprint as computeCurateFingerprint, index_d_countUncommitted as countUncommitted, index_d_createAmbientRecaller as createAmbientRecaller, index_d_createRitualRegistry as createRitualRegistry, index_d_curateCommand as curateCommand, index_d_decisionCommand as decisionCommand, index_d_detectInterruptedGitOp as detectInterruptedGitOp, index_d_detectWorklogGaps as detectWorklogGaps, index_d_ensureVortexHooks as ensureVortexHooks, index_d_ensureWorklogEntry as ensureWorklogEntry, index_d_extractNextUp as extractNextUp, index_d_extractOpenTasks as extractOpenTasks, index_d_globalMemoryPath as globalMemoryPath, index_d_globalSettingsHasHook as globalSettingsHasHook, index_d_globalSettingsPath as globalSettingsPath, index_d_globalStatePath as globalStatePath, index_d_inspectGlobalSetup as inspectGlobalSetup, index_d_inspectOwnership as inspectOwnership, index_d_isInstanceRoot as isInstanceRoot, index_d_isNewer as isNewer, index_d_isStableUpdate as isStableUpdate, index_d_logCommand as logCommand, index_d_ownershipManifestPath as ownershipManifestPath, index_d_parseAdoptArgs as parseAdoptArgs, index_d_parseSettings as parseSettings, index_d_queryNpmLatest as queryNpmLatest, index_d_readGlobalInstancePointer as readGlobalInstancePointer, index_d_readInstalledBaseVersion as readInstalledBaseVersion, index_d_recallCommand as recallCommand, index_d_recordGlobalSetupDecline as recordGlobalSetupDecline, index_d_reindexCommand as reindexCommand, index_d_renderAgenda as renderAgenda, index_d_renderGlobalBlock as renderGlobalBlock, index_d_renderSessionStartReport as renderSessionStartReport, index_d_repairOwnershipManifest as repairOwnershipManifest, index_d_resolveRepoRoot as resolveRepoRoot, index_d_runCurateAccept as runCurateAccept, index_d_runCurateCandidates as runCurateCandidates, index_d_runCurateDecline as runCurateDecline, index_d_runCuratePreview as runCuratePreview, index_d_runTemplatesUpdate as runTemplatesUpdate, index_d_runVortexCli as runVortexCli, index_d_serializeSettings as serializeSettings, index_d_sessionStartCommand as sessionStartCommand, index_d_templateDestRelPath as templateDestRelPath, index_d_upsertGlobalBlock as upsertGlobalBlock, index_d_validateCuratePayload as validateCuratePayload, index_d_vortexCommand as vortexCommand, index_d_writeOwnershipManifest as writeOwnershipManifest };
 }
 
 export { index_d$9 as aiCodingPitfalls, index_d$d as core, index_d$a as dataLint, index_d$5 as decisionLog, index_d$4 as indexGenerator, index_d$2 as linkRewriter, index_d$b as memorySystem, index_d$1 as proactiveCurator, index_d$7 as reportGenerator, index_d$3 as runbooks, index_d as sessionRituals, index_d$c as slashCommands, index_d$8 as toolRules, index_d$6 as worklog };