@wrongstack/core 0.9.1 → 0.9.7

package/dist/infrastructure/index.d.ts

@@ -1,10 +1,10 @@
 export { D as DefaultLogger, a as DefaultLoggerOptions } from '../logger-bOzkF5LL.js';
 export { D as DefaultPathResolver, a as DefaultTokenCounter } from '../path-resolver-TcJfc29Y.js';
-export { C as ContextManagerAction, a as ContextManagerInput, b as ContextManagerResult, c as ContextManagerToolOptions, d as allServers, e as awsServer, f as blockServer, g as braveSearchServer, h as context7Server, i as contextManagerTool, j as createContextManagerTool, k as everArtServer, l as filesystemServer, m as githubServer, n as googleMapsServer, o as miniMaxVisionServer, s as sentinelServer, p as slackServer, z as zaiVisionServer } from '../mcp-servers-jEoMIBZv.js';
+export { C as ContextManagerAction, a as ContextManagerInput, b as ContextManagerResult, c as ContextManagerToolOptions, d as allServers, e as awsServer, f as blockServer, g as braveSearchServer, h as context7Server, i as contextManagerTool, j as createContextManagerTool, k as everArtServer, l as filesystemServer, m as githubServer, n as googleMapsServer, o as miniMaxVisionServer, s as sentinelServer, p as slackServer, z as zaiVisionServer } from '../mcp-servers-BouUWYW6.js';
 import '../logger-DDd5C--Z.js';
 import '../events-CiG9qUM_.js';
 import '../context-BRNbHmRM.js';
 import '../models-registry-BcYJDKLm.js';
 import '../path-resolver-CPRj4bFY.js';
 import '../compactor-DVTKL7XD.js';
-import '../config-DoUAEvXH.js';
+import '../config-SkMIDN9L.js';

package/dist/kernel/index.d.ts

@@ -1,9 +1,9 @@
 export { B as BindOptions, C as Container, D as Decorator, F as Factory, M as Middleware, b as MiddlewareHandler, N as NextFn, P as Pipeline, d as PipelineOptions, T as Token } from '../system-prompt-Bs-Wliab.js';
 export { E as EventBus, a as EventLogger, b as EventMap, c as EventName, L as Listener, S as ScopedEventBus } from '../events-CiG9qUM_.js';
-export { R as RunController, b as RunControllerOptions, T as TOKENS } from '../index-u2ROAV0F.js';
+export { R as RunController, b as RunControllerOptions, T as TOKENS } from '../index-Bsha5K4D.js';
 import '../context-BRNbHmRM.js';
 import '../compactor-DVTKL7XD.js';
-import '../config-DoUAEvXH.js';
+import '../config-SkMIDN9L.js';
 import '../models-registry-BcYJDKLm.js';
 import '../retry-policy-BYkq0ugs.js';
 import '../input-reader-E-ffP2ee.js';

package/dist/{mcp-servers-jEoMIBZv.d.ts → mcp-servers-BouUWYW6.d.ts}

@@ -1,6 +1,6 @@
 import { a as Compactor } from './compactor-DVTKL7XD.js';
 import { M as Message, Q as Tool } from './context-BRNbHmRM.js';
-import { M as MCPServerConfig } from './config-DoUAEvXH.js';
+import { M as MCPServerConfig } from './config-SkMIDN9L.js';
 
 type ContextManagerAction = 'check' | 'summary' | 'prune' | 'add_note' | 'compact' | 'repair';
 interface ContextManagerInput {

package/dist/{multi-agent-coordinator-COwCGIrU.d.ts → multi-agent-coordinator-DTXF2aAl.d.ts}

@@ -1,5 +1,5 @@
 import { n as SubagentConfig, l as MultiAgentCoordinator, M as MultiAgentConfig, t as SubagentRunner, S as SpawnResult, v as TaskSpec, B as BridgeMessage, A as AgentBridge, k as CoordinatorStatus, u as TaskResult } from './multi-agent-3ZnTB1aT.js';
-import { F as FleetBus } from './agent-subagent-runner-R0I0Xusn.js';
+import { F as FleetBus } from './agent-subagent-runner-DaF_EgRG.js';
 import { EventEmitter } from 'node:events';
 
 /**

package/dist/{null-fleet-bus-C1grTnOF.d.ts → null-fleet-bus-Chrc_3Pp.d.ts}

@@ -1,9 +1,9 @@
-import { c as AgentPhase, b as AgentDefinition, d as DefaultMultiAgentCoordinator, f as DispatchClassifier } from './multi-agent-coordinator-COwCGIrU.js';
+import { c as AgentPhase, b as AgentDefinition, d as DefaultMultiAgentCoordinator, f as DispatchClassifier } from './multi-agent-coordinator-DTXF2aAl.js';
 import { n as SubagentConfig, u as TaskResult, k as CoordinatorStatus, v as TaskSpec, M as MultiAgentConfig, t as SubagentRunner } from './multi-agent-3ZnTB1aT.js';
 import { B as SessionWriter, Q as Tool, y as SessionStore } from './context-BRNbHmRM.js';
 import { a as DirectorStateSnapshot } from './director-state-BmYi3DGA.js';
 import { I as InMemoryAgentBridge } from './agent-bridge-DMVOX0cF.js';
-import { F as FleetBus, e as FleetUsage, f as FleetUsageAggregator } from './agent-subagent-runner-R0I0Xusn.js';
+import { F as FleetBus, e as FleetUsage, f as FleetUsageAggregator } from './agent-subagent-runner-DaF_EgRG.js';
 import { E as EventBus } from './events-CiG9qUM_.js';
 
 /**

package/dist/{plan-templates-ByT1HcRI.d.ts → plan-templates-envSmNlZ.d.ts}

@@ -2,8 +2,8 @@ import { E as EventBus } from './events-CiG9qUM_.js';
 import { y as SessionStore, x as SessionMetadata, B as SessionWriter, r as ResumedSession, S as SessionData, z as SessionSummary, c as ContentBlock, w as SessionEvent, N as TodoItem, f as ConversationState } from './context-BRNbHmRM.js';
 import { e as AttachmentStore, A as AddAttachmentInput, d as AttachmentRef, a as Attachment } from './session-reader-CSWcb5Ga.js';
 import { b as MemoryStore, a as MemoryScope } from './memory-CEXuo7sz.js';
-import { a as WstackPaths } from './wstack-paths-CJYrjQU8.js';
-import { c as ConfigStore, a as Config, b as ConfigLoader } from './config-DoUAEvXH.js';
+import { a as WstackPaths } from './wstack-paths-BCgmTNlG.js';
+import { c as ConfigStore, a as Config, b as ConfigLoader } from './config-SkMIDN9L.js';
 import { S as SecretVault } from './secret-vault-DoISxaKO.js';
 
 interface SessionStoreOptions {

package/dist/sdd/index.d.ts

@@ -1,14 +1,14 @@
 import { h as Specification, S as SpecAnalysis, g as SpecValidationResult, l as TaskGraph, m as TaskNode, k as TaskFilter, p as TaskSort, o as TaskProgress, r as TaskType, n as TaskPriority, e as SpecStatus, f as SpecTemplate, b as SpecRequirement } from '../task-graph-D1YQbpxF.js';
 import { E as EventBus } from '../events-CiG9qUM_.js';
 import { D as DoneCondition, u as TaskResult } from '../multi-agent-3ZnTB1aT.js';
-import { c as Agent } from '../index-bOl8lzFV.js';
-import { A as AgentFactory } from '../agent-subagent-runner-R0I0Xusn.js';
+import { c as Agent } from '../index-CP8638Wm.js';
+import { A as AgentFactory } from '../agent-subagent-runner-DaF_EgRG.js';
 import '../context-BRNbHmRM.js';
 import '../logger-DDd5C--Z.js';
 import '../system-prompt-Bs-Wliab.js';
 import '../observability-BhnVLBLS.js';
 import '../secret-scrubber-DttNiGYA.js';
-import '../config-DoUAEvXH.js';
+import '../config-SkMIDN9L.js';
 import '../models-registry-BcYJDKLm.js';
 
 declare class SpecParser {

package/dist/storage/index.d.ts

@@ -1,15 +1,15 @@
-export { A as AbandonedSession, a as AttachmentStoreOptions, C as ConfigLoaderOptions, b as ConfigMigration, c as ConfigMigrationError, d as ConfigSource, D as DEFAULT_CONFIG_MIGRATIONS, e as DefaultAttachmentStore, f as DefaultConfigLoader, g as DefaultConfigStore, h as DefaultMemoryStore, i as DefaultSessionStore, M as MemoryStoreOptions, j as MigrationContext, k as MigrationResult, P as PersistedQueueItem, l as PlanFile, m as PlanItem, n as PlanTemplate, Q as QueueStore, R as RecoveryLock, o as RecoveryLockOptions, S as SessionAnalyzer, p as SessionStoreOptions, T as TodosCheckpointFile, q as addPlanItem, r as attachPlanCheckpoint, s as attachTodosCheckpoint, t as clearPlan, u as deriveTodosFromPlanItem, v as emptyPlan, w as formatPlan, x as formatPlanTemplates, y as getPlanTemplate, z as listPlanTemplates, B as loadPlan, E as loadTodosCheckpoint, F as removePlanItem, G as runConfigMigrations, H as savePlan, I as saveTodosCheckpoint, J as setPlanItemStatus } from '../plan-templates-ByT1HcRI.js';
+export { A as AbandonedSession, a as AttachmentStoreOptions, C as ConfigLoaderOptions, b as ConfigMigration, c as ConfigMigrationError, d as ConfigSource, D as DEFAULT_CONFIG_MIGRATIONS, e as DefaultAttachmentStore, f as DefaultConfigLoader, g as DefaultConfigStore, h as DefaultMemoryStore, i as DefaultSessionStore, M as MemoryStoreOptions, j as MigrationContext, k as MigrationResult, P as PersistedQueueItem, l as PlanFile, m as PlanItem, n as PlanTemplate, Q as QueueStore, R as RecoveryLock, o as RecoveryLockOptions, S as SessionAnalyzer, p as SessionStoreOptions, T as TodosCheckpointFile, q as addPlanItem, r as attachPlanCheckpoint, s as attachTodosCheckpoint, t as clearPlan, u as deriveTodosFromPlanItem, v as emptyPlan, w as formatPlan, x as formatPlanTemplates, y as getPlanTemplate, z as listPlanTemplates, B as loadPlan, E as loadTodosCheckpoint, F as removePlanItem, G as runConfigMigrations, H as savePlan, I as saveTodosCheckpoint, J as setPlanItemStatus } from '../plan-templates-envSmNlZ.js';
 export { D as DefaultSessionReader } from '../session-reader-CSWcb5Ga.js';
 import { S as SessionRewinder, C as CheckpointInfo, a as RewindResultExtended } from '../session-rewinder-C9HnMkhP.js';
 export { D as DirectorStateCheckpoint, a as DirectorStateSnapshot, b as DirectorSubagentState, c as DirectorTaskState, l as loadDirectorState } from '../director-state-BmYi3DGA.js';
 export { G as GoalFile, J as JournalEntry, M as MAX_JOURNAL_ENTRIES, a as appendJournal, e as emptyGoal, f as formatGoal, g as goalFilePath, l as loadGoal, s as saveGoal, b as summarizeUsage } from '../goal-store-C7jcumEh.js';
+import { a as WstackPaths } from '../wstack-paths-BCgmTNlG.js';
+import { S as SyncCategory, m as SyncConfig } from '../config-SkMIDN9L.js';
 import '../events-CiG9qUM_.js';
 import '../context-BRNbHmRM.js';
 import '../memory-CEXuo7sz.js';
-import '../wstack-paths-CJYrjQU8.js';
-import '../config-DoUAEvXH.js';
-import '../models-registry-BcYJDKLm.js';
 import '../secret-vault-DoISxaKO.js';
+import '../models-registry-BcYJDKLm.js';
 
 interface SessionRewinderOptions {
     sessionsDir: string;
@@ -30,4 +30,73 @@ declare class DefaultSessionRewinder implements SessionRewinder {
     rewindToStart(sessionId: string): Promise<RewindResultExtended>;
 }
 
-export { DefaultSessionRewinder, type SessionRewinderOptions };
+interface PromptEntry {
+    id: string;
+    title: string;
+    content: string;
+    tags: string[];
+    createdAt: string;
+    updatedAt: string;
+}
+interface PromptStore {
+    list(): Promise<PromptEntry[]>;
+    get(id: string): Promise<PromptEntry | null>;
+    save(entry: PromptEntry): Promise<void>;
+    delete(id: string): Promise<boolean>;
+    find(query: string): Promise<PromptEntry[]>;
+}
+declare class DefaultPromptStore implements PromptStore {
+    private readonly dir;
+    constructor(paths: WstackPaths);
+    list(): Promise<PromptEntry[]>;
+    get(id: string): Promise<PromptEntry | null>;
+    save(entry: PromptEntry): Promise<void>;
+    delete(id: string): Promise<boolean>;
+    find(query: string): Promise<PromptEntry[]>;
+    /** Create a new entry and return it. Does NOT persist — call save() afterwards. */
+    createNew(title: string, content: string, tags?: string[]): PromptEntry;
+}
+
+declare const ALL_SYNC_CATEGORIES: SyncCategory[];
+interface SyncResult {
+    ok: boolean;
+    action: 'push' | 'pull';
+    categories: SyncCategory[];
+    committedAt?: string;
+    message: string;
+}
+/**
+ * CloudSync — push/pull user-selected ~/.wrongstack categories to a
+ * private GitHub repo. No git CLI needed; uses GitHub REST API via fetch.
+ * The token is stored encrypted via SecretVault (field named `githubToken`
+ * so the vault walker picks it up automatically).
+ */
+declare class CloudSync {
+    private readonly paths;
+    private readonly getConfig;
+    private readonly setConfig;
+    private readonly statePath;
+    private state;
+    constructor(paths: WstackPaths, getConfig: () => SyncConfig | null, setConfig: (c: SyncConfig) => Promise<void>);
+    status(): Promise<string>;
+    enable(_repo: string, _categories: SyncCategory[]): Promise<string>;
+    disable(): Promise<string>;
+    push(token: string): Promise<SyncResult>;
+    pull(token: string): Promise<SyncResult>;
+    hasLocalChanges(): Promise<boolean>;
+    loadState(): Promise<void>;
+    private githubFetch;
+    private getRef;
+    private updateRef;
+    private getCommit;
+    private getTreeEntries;
+    private createCommit;
+    private createGitTree;
+    private getBlob;
+    private buildLocalTree;
+    private hashLocalCategories;
+    private categoryToPath;
+    private walkDir;
+}
+
+export { ALL_SYNC_CATEGORIES, CloudSync, DefaultPromptStore, DefaultSessionRewinder, type PromptEntry, type PromptStore, type SessionRewinderOptions, SyncCategory, SyncConfig, type SyncResult };

package/dist/storage/index.js

@@ -30,8 +30,8 @@ async function atomicWrite(targetPath, content, opts = {}) {
     }
     let mode;
     try {
-      const stat3 = await fsp.stat(targetPath);
-      mode = stat3.mode & 511;
+      const stat4 = await fsp.stat(targetPath);
+      mode = stat4.mode & 511;
     } catch {
       mode = opts.mode;
     }
@@ -291,8 +291,8 @@ var DefaultSessionStore = class {
       return JSON.parse(raw);
     } catch {
       const full = this.sessionPath(id, ".jsonl");
-      const stat3 = await fsp.stat(full);
-      const summary = await this.summarize(id, stat3.mtime.toISOString());
+      const stat4 = await fsp.stat(full);
+      const summary = await this.summarize(id, stat4.mtime.toISOString());
       await atomicWrite(manifest, JSON.stringify(summary), { mode: 384 }).catch((err) => {
         console.warn(
           `[session-store] Failed to write manifest for "${id}":`,
@@ -2778,7 +2778,354 @@ function formatGoal(goal, journalLimit = 10) {
   }
   return lines.join("\n");
 }
+var DefaultPromptStore = class {
+  dir;
+  constructor(paths) {
+    this.dir = paths.globalPrompts;
+  }
+  async list() {
+    await ensureDir(this.dir);
+    let entries = [];
+    try {
+      const files = await fsp.readdir(this.dir);
+      for (const file of files) {
+        if (!file.endsWith(".json")) continue;
+        try {
+          const raw = JSON.parse(
+            await fsp.readFile(path7.join(this.dir, file), "utf8")
+          );
+          entries.push(raw.entry);
+        } catch {
+        }
+      }
+    } catch {
+    }
+    return entries.sort(
+      (a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()
+    );
+  }
+  async get(id) {
+    const file = path7.join(this.dir, `${id}.json`);
+    try {
+      const raw = JSON.parse(await fsp.readFile(file, "utf8"));
+      return raw.entry;
+    } catch {
+      return null;
+    }
+  }
+  async save(entry) {
+    await ensureDir(this.dir);
+    const file = path7.join(this.dir, `${entry.id}.json`);
+    const raw = { version: 1, entry };
+    await atomicWrite(file, JSON.stringify(raw, null, 2));
+  }
+  async delete(id) {
+    const file = path7.join(this.dir, `${id}.json`);
+    try {
+      await fsp.unlink(file);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async find(query) {
+    const all = await this.list();
+    const lower = query.toLowerCase();
+    return all.filter(
+      (e) => e.title.toLowerCase().includes(lower) || e.content.toLowerCase().includes(lower) || e.tags.some((t) => t.toLowerCase().includes(lower))
+    );
+  }
+  /** Create a new entry and return it. Does NOT persist — call save() afterwards. */
+  createNew(title, content, tags = []) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    return {
+      id: randomUUID().slice(0, 8),
+      title,
+      content,
+      tags,
+      createdAt: now,
+      updatedAt: now
+    };
+  }
+};
+var ALL_SYNC_CATEGORIES = ["settings", "skills", "prompts", "memory", "history"];
+var CloudSync = class {
+  constructor(paths, getConfig, setConfig) {
+    this.paths = paths;
+    this.getConfig = getConfig;
+    this.setConfig = setConfig;
+    this.statePath = path7.join(paths.globalRoot, "sync-state.json");
+  }
+  paths;
+  getConfig;
+  setConfig;
+  statePath;
+  state = null;
+  // ── Public API ─────────────────────────────────────────────────────
+  async status() {
+    const cfg = this.getConfig();
+    if (!cfg?.enabled) {
+      return "CloudSync: disabled. Run `/sync enable` to activate.";
+    }
+    const last = this.state?.lastSyncedAt;
+    const since = last ? timeAgo(last) : "never";
+    return [
+      `CloudSync: enabled`,
+      `  repo:       ${cfg.repo}`,
+      `  categories: ${cfg.categories.join(", ")}`,
+      `  last sync:  ${since}`
+    ].join("\n");
+  }
+  async enable(_repo, _categories) {
+    return "Enable via /sync enable.";
+  }
+  async disable() {
+    const cfg = this.getConfig();
+    if (!cfg) return "CloudSync is not configured.";
+    const next = { ...cfg, enabled: false };
+    await this.setConfig(next);
+    return "CloudSync disabled. Local data kept.";
+  }
+  async push(token) {
+    const cfg = this.getConfig();
+    if (!cfg?.enabled) return { ok: false, action: "push", categories: [], message: "Not enabled." };
+    const parts = cfg.repo.split("/");
+    const owner = parts[0];
+    const repoName = parts[1];
+    const branch = "main";
+    const baseTreeSha = this.state?.sha;
+    const { treeEntries, rev } = await this.buildLocalTree(cfg.categories);
+    const newTreeSha = await this.createGitTree(token, owner, repoName, treeEntries, baseTreeSha);
+    const commitSha = await this.createCommit(
+      token,
+      owner,
+      repoName,
+      newTreeSha,
+      baseTreeSha,
+      `Sync ${cfg.categories.join(", ")} \u2014 ${(/* @__PURE__ */ new Date()).toISOString()}`
+    );
+    await this.updateRef(token, owner, repoName, branch, commitSha);
+    const syncState = {
+      version: 1,
+      sha: commitSha,
+      lastSyncedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      localRev: rev
+    };
+    await fsp.writeFile(this.statePath, JSON.stringify(syncState, null, 2), "utf8");
+    this.state = syncState;
+    return {
+      ok: true,
+      action: "push",
+      categories: cfg.categories,
+      committedAt: commitSha,
+      message: `Pushed ${cfg.categories.join(", ")} to ${cfg.repo}. Commit: ${commitSha.slice(0, 7)}`
+    };
+  }
+  async pull(token) {
+    const cfg = this.getConfig();
+    if (!cfg?.enabled) return { ok: false, action: "pull", categories: [], message: "Not enabled." };
+    const pullParts = cfg.repo.split("/");
+    const owner = pullParts[0];
+    const repoName = pullParts[1];
+    const branchData = await this.getRef(token, owner, repoName, "main");
+    const currentSha = branchData.object.sha;
+    const commitData = await this.getCommit(token, owner, repoName, currentSha);
+    const treeSha = commitData.tree.sha;
+    const treeEntries = await this.getTreeEntries(token, owner, repoName, treeSha);
+    for (const entry of treeEntries) {
+      if (entry.type !== "blob") continue;
+      const segments = entry.path.split("/");
+      if (segments[0] !== "data" || !segments[1]) continue;
+      const cat = segments[1];
+      if (!["settings", "skills", "prompts", "memory", "history"].includes(cat)) continue;
+      const localPath = this.categoryToPath(cat);
+      if (!localPath) continue;
+      const rel = segments.slice(2).join("/");
+      const destPath = rel ? path7.join(localPath, rel) : localPath;
+      const blobData = await this.getBlob(token, owner, repoName, entry.sha);
+      await fsp.mkdir(path7.dirname(destPath), { recursive: true });
+      await fsp.writeFile(destPath, Buffer.from(blobData, "base64"));
+    }
+    const localRev = await this.hashLocalCategories(cfg.categories);
+    const syncState = {
+      version: 1,
+      sha: currentSha,
+      lastSyncedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      localRev
+    };
+    await fsp.writeFile(this.statePath, JSON.stringify(syncState, null, 2), "utf8");
+    this.state = syncState;
+    return {
+      ok: true,
+      action: "pull",
+      categories: cfg.categories,
+      committedAt: currentSha,
+      message: `Pulled ${cfg.categories.join(", ")} from ${cfg.repo}. Commit: ${currentSha.slice(0, 7)}`
+    };
+  }
+  async hasLocalChanges() {
+    if (!this.state) return true;
+    const cfg = this.getConfig();
+    if (!cfg) return true;
+    const current = await this.hashLocalCategories(cfg.categories);
+    return current !== this.state.localRev;
+  }
+  async loadState() {
+    try {
+      const raw = await fsp.readFile(this.statePath, "utf8");
+      this.state = JSON.parse(raw);
+    } catch {
+      this.state = null;
+    }
+  }
+  // ── GitHub API helpers ──────────────────────────────────────────────
+  async githubFetch(token, owner, repo, method, pathSegment, body) {
+    const url = `https://api.github.com/repos/${owner}/${repo}${pathSegment}`;
+    const res = await fetch(url, {
+      method,
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/vnd.github+json",
+        "X-GitHub-Api-Version": "2022-11-28",
+        "Content-Type": "application/json"
+      },
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+    if (!res.ok) {
+      const errText = await res.text();
+      throw new Error(`GitHub API ${method} ${pathSegment} failed (${res.status}): ${errText}`);
+    }
+    const text = await res.text();
+    return text ? JSON.parse(text) : {};
+  }
+  async getRef(token, owner, repo, ref) {
+    return await this.githubFetch(token, owner, repo, "GET", `/git/refs/heads/${ref}`);
+  }
+  async updateRef(token, owner, repo, ref, sha) {
+    await this.githubFetch(token, owner, repo, "PATCH", `/git/refs/heads/${ref}`, {
+      sha,
+      force: false
+    });
+  }
+  async getCommit(token, owner, repo, sha) {
+    return await this.githubFetch(token, owner, repo, "GET", `/git/commits/${sha}`);
+  }
+  async getTreeEntries(token, owner, repo, treeSha) {
+    return await this.githubFetch(token, owner, repo, "GET", `/git/trees/${treeSha}?recursive=1`);
+  }
+  async createCommit(token, owner, repo, treeSha, parentSha, message = "sync") {
+    const body = { message, tree: treeSha };
+    if (parentSha) body.parents = [parentSha];
+    const result = await this.githubFetch(token, owner, repo, "POST", "/git/commits", body);
+    return result.sha;
+  }
+  async createGitTree(token, owner, repo, entries, baseTreeSha) {
+    const tree = entries.map((e) => ({
+      path: e.path,
+      mode: e.mode,
+      type: "blob",
+      content: e.content
+    }));
+    const body = { tree };
+    if (baseTreeSha) body.base_tree = baseTreeSha;
+    const result = await this.githubFetch(token, owner, repo, "POST", "/git/trees", body);
+    return result.sha;
+  }
+  async getBlob(token, owner, repo, sha) {
+    const result = await this.githubFetch(token, owner, repo, "GET", `/git/blobs/${sha}`);
+    return result.content;
+  }
+  // ── Local file helpers ──────────────────────────────────────────────
+  async buildLocalTree(categories) {
+    const entries = [];
+    const hashes = [];
+    for (const cat of categories) {
+      const localPath = this.categoryToPath(cat);
+      if (!localPath) continue;
+      try {
+        const stat4 = await fsp.stat(localPath);
+        if (stat4.isDirectory()) {
+          const files = await this.walkDir(localPath, localPath);
+          for (const file of files) {
+            const content = await fsp.readFile(file, "utf8");
+            const rel = path7.relative(localPath, file).replace(/\\/g, "/");
+            entries.push({ path: `data/${cat}/${rel}`, content, mode: "100644" });
+            hashes.push(content);
+          }
+        } else {
+          const content = await fsp.readFile(localPath, "utf8");
+          entries.push({ path: `data/${cat}`, content, mode: "100644" });
+          hashes.push(content);
+        }
+      } catch {
+      }
+    }
+    const rev = createHash("sha256").update(hashes.join("")).digest("hex").slice(0, 12);
+    return { treeEntries: entries, rev };
+  }
+  async hashLocalCategories(categories) {
+    const hashes = [];
+    for (const cat of categories) {
+      const localPath = this.categoryToPath(cat);
+      if (!localPath) continue;
+      try {
+        const stat4 = await fsp.stat(localPath);
+        if (stat4.isDirectory()) {
+          const files = await this.walkDir(localPath, localPath);
+          for (const file of files) {
+            const content = await fsp.readFile(file);
+            hashes.push(content.toString("base64") + file);
+          }
+        } else {
+          const content = await fsp.readFile(localPath);
+          hashes.push(content.toString("base64") + localPath);
+        }
+      } catch {
+      }
+    }
+    return createHash("sha256").update(hashes.join("")).digest("hex").slice(0, 12);
+  }
+  categoryToPath(cat) {
+    switch (cat) {
+      case "settings":
+        return this.paths.globalConfig;
+      case "skills":
+        return this.paths.globalSkills;
+      case "prompts":
+        return this.paths.globalPrompts;
+      case "memory":
+        return this.paths.globalMemory;
+      case "history":
+        return this.paths.historyFile;
+      default:
+        return null;
+    }
+  }
+  async walkDir(dir, base) {
+    const results = [];
+    const entries = await fsp.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = path7.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        results.push(...await this.walkDir(full, base));
+      } else {
+        results.push(full);
+      }
+    }
+    return results;
+  }
+};
+function timeAgo(iso) {
+  const diff = Date.now() - new Date(iso).getTime();
+  const mins = Math.floor(diff / 6e4);
+  if (mins < 1) return "just now";
+  if (mins < 60) return `${mins}m ago`;
+  const hrs = Math.floor(mins / 60);
+  if (hrs < 24) return `${hrs}h ago`;
+  const days = Math.floor(hrs / 24);
+  return `${days}d ago`;
+}
 
-export { ConfigMigrationError, DEFAULT_CONFIG_MIGRATIONS, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultMemoryStore, DefaultSessionReader, DefaultSessionRewinder, DefaultSessionStore, DirectorStateCheckpoint, MAX_JOURNAL_ENTRIES, QueueStore, RecoveryLock, SessionAnalyzer, addPlanItem, appendJournal, attachPlanCheckpoint, attachTodosCheckpoint, clearPlan, deriveTodosFromPlanItem, emptyGoal, emptyPlan, formatGoal, formatPlan, formatPlanTemplates, getPlanTemplate, goalFilePath, listPlanTemplates, loadDirectorState, loadGoal, loadPlan, loadTodosCheckpoint, removePlanItem, runConfigMigrations, saveGoal, savePlan, saveTodosCheckpoint, setPlanItemStatus, summarizeUsage };
+export { ALL_SYNC_CATEGORIES, CloudSync, ConfigMigrationError, DEFAULT_CONFIG_MIGRATIONS, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultMemoryStore, DefaultPromptStore, DefaultSessionReader, DefaultSessionRewinder, DefaultSessionStore, DirectorStateCheckpoint, MAX_JOURNAL_ENTRIES, QueueStore, RecoveryLock, SessionAnalyzer, addPlanItem, appendJournal, attachPlanCheckpoint, attachTodosCheckpoint, clearPlan, deriveTodosFromPlanItem, emptyGoal, emptyPlan, formatGoal, formatPlan, formatPlanTemplates, getPlanTemplate, goalFilePath, listPlanTemplates, loadDirectorState, loadGoal, loadPlan, loadTodosCheckpoint, removePlanItem, runConfigMigrations, saveGoal, savePlan, saveTodosCheckpoint, setPlanItemStatus, summarizeUsage };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map