prjct-cli 1.18.0 → 1.20.0

package/dist/bin/prjct.mjs

@@ -4277,6 +4277,30 @@ var init_database = __esm({
         );
       `);
         }, "up")
+      },
+      {
+        version: 2,
+        name: "archives-table",
+        up: /* @__PURE__ */ __name((db) => {
+          db.run(`
+        -- =======================================================================
+        -- Archives: Stale data moved out of active storage (PRJ-267)
+        -- =======================================================================
+        CREATE TABLE archives (
+          id            TEXT PRIMARY KEY,
+          entity_type   TEXT NOT NULL,
+          entity_id     TEXT NOT NULL,
+          entity_data   TEXT NOT NULL,
+          summary       TEXT,
+          archived_at   TEXT NOT NULL,
+          reason        TEXT NOT NULL
+        );
+
+        CREATE INDEX idx_archives_entity_type ON archives(entity_type);
+        CREATE INDEX idx_archives_archived_at ON archives(archived_at);
+        CREATE INDEX idx_archives_entity_id ON archives(entity_id);
+      `);
+        }, "up")
       }
     ];
     PrjctDatabase = class {
@@ -9716,7 +9740,7 @@ var init_ideas = __esm({
   "core/schemas/ideas.ts"() {
     "use strict";
     IdeaPrioritySchema = z6.enum(["low", "medium", "high"]);
-    IdeaStatusSchema = z6.enum(["pending", "converted", "completed", "archived"]);
+    IdeaStatusSchema = z6.enum(["pending", "converted", "completed", "archived", "dormant"]);
     ImpactLevelSchema = z6.enum(["high", "medium", "low"]);
     ImpactEffortSchema = z6.object({
       impact: ImpactLevelSchema,
@@ -12726,6 +12750,147 @@ var init_analysis_storage = __esm({
   }
 });
 
+// core/storage/archive-storage.ts
+var ARCHIVE_POLICIES, ArchiveStorage, archiveStorage;
+var init_archive_storage = __esm({
+  "core/storage/archive-storage.ts"() {
+    "use strict";
+    init_schemas2();
+    init_date_helper();
+    init_database();
+    ARCHIVE_POLICIES = {
+      SHIPPED_RETENTION_DAYS: 90,
+      IDEA_DORMANT_DAYS: 180,
+      QUEUE_COMPLETED_DAYS: 7,
+      PAUSED_TASK_DAYS: 30,
+      MEMORY_MAX_ENTRIES: 500
+    };
+    ArchiveStorage = class {
+      static {
+        __name(this, "ArchiveStorage");
+      }
+      /**
+       * Archive a single item
+       */
+      archive(projectId, item) {
+        const id = generateUUID();
+        const now = getTimestamp();
+        prjctDb.run(
+          projectId,
+          "INSERT INTO archives (id, entity_type, entity_id, entity_data, summary, archived_at, reason) VALUES (?, ?, ?, ?, ?, ?, ?)",
+          id,
+          item.entityType,
+          item.entityId,
+          JSON.stringify(item.entityData),
+          item.summary ?? null,
+          now,
+          item.reason
+        );
+        return id;
+      }
+      /**
+       * Archive multiple items in a transaction
+       */
+      archiveMany(projectId, items) {
+        if (items.length === 0) return 0;
+        const now = getTimestamp();
+        prjctDb.transaction(projectId, (db) => {
+          const stmt = db.prepare(
+            "INSERT INTO archives (id, entity_type, entity_id, entity_data, summary, archived_at, reason) VALUES (?, ?, ?, ?, ?, ?, ?)"
+          );
+          for (const item of items) {
+            stmt.run(
+              generateUUID(),
+              item.entityType,
+              item.entityId,
+              JSON.stringify(item.entityData),
+              item.summary ?? null,
+              now,
+              item.reason
+            );
+          }
+        });
+        return items.length;
+      }
+      /**
+       * Query archived items by type
+       */
+      getArchived(projectId, entityType, limit = 50) {
+        if (entityType) {
+          return prjctDb.query(
+            projectId,
+            "SELECT * FROM archives WHERE entity_type = ? ORDER BY archived_at DESC LIMIT ?",
+            entityType,
+            limit
+          );
+        }
+        return prjctDb.query(
+          projectId,
+          "SELECT * FROM archives ORDER BY archived_at DESC LIMIT ?",
+          limit
+        );
+      }
+      /**
+       * Get count of archived items by type
+       */
+      getStats(projectId) {
+        const rows = prjctDb.query(
+          projectId,
+          "SELECT entity_type, COUNT(*) as count FROM archives GROUP BY entity_type"
+        );
+        const stats = {
+          shipped: 0,
+          idea: 0,
+          queue_task: 0,
+          paused_task: 0,
+          memory_entry: 0,
+          total: 0
+        };
+        for (const row of rows) {
+          const type = row.entity_type;
+          if (type in stats) {
+            stats[type] = row.count;
+          }
+          stats.total += row.count;
+        }
+        return stats;
+      }
+      /**
+       * Restore an item from archive (removes from archive table)
+       * Returns the entity data for the caller to re-insert into active storage.
+       */
+      restore(projectId, archiveId) {
+        const record = prjctDb.get(
+          projectId,
+          "SELECT * FROM archives WHERE id = ?",
+          archiveId
+        );
+        if (!record) return null;
+        prjctDb.run(projectId, "DELETE FROM archives WHERE id = ?", archiveId);
+        return JSON.parse(record.entity_data);
+      }
+      /**
+       * Permanently delete archives older than N days
+       */
+      pruneOldArchives(projectId, olderThanDays) {
+        const threshold = new Date(Date.now() - olderThanDays * 24 * 60 * 60 * 1e3).toISOString();
+        const before = this.getTotalCount(projectId);
+        prjctDb.run(projectId, "DELETE FROM archives WHERE archived_at < ?", threshold);
+        const after = this.getTotalCount(projectId);
+        return before - after;
+      }
+      /**
+       * Get total count of archived items
+       */
+      getTotalCount(projectId) {
+        const row = prjctDb.get(projectId, "SELECT COUNT(*) as count FROM archives");
+        return row?.count ?? 0;
+      }
+    };
+    archiveStorage = new ArchiveStorage();
+  }
+});
+
 // core/storage/ideas-storage.ts
 var IdeasStorage, ideasStorage;
 var init_ideas_storage = __esm({
@@ -12734,6 +12899,7 @@ var init_ideas_storage = __esm({
     init_schemas2();
     init_ideas();
     init_date_helper();
+    init_archive_storage();
     init_storage_manager();
     IdeasStorage = class extends StorageManager {
       static {
@@ -12762,6 +12928,7 @@ var init_ideas_storage = __esm({
         const pending = data.ideas.filter((i) => i.status === "pending");
         const converted = data.ideas.filter((i) => i.status === "converted");
         const archived = data.ideas.filter((i) => i.status === "archived");
+        const dormant = data.ideas.filter((i) => i.status === "dormant");
         lines.push("## Brain Dump");
         if (pending.length > 0) {
           pending.forEach((idea) => {
@@ -12791,6 +12958,10 @@ var init_ideas_storage = __esm({
           });
           lines.push("");
         }
+        if (dormant.length > 0) {
+          lines.push(`_${dormant.length} dormant idea(s) excluded from context_`);
+          lines.push("");
+        }
         return lines.join("\n");
       }
       // =========== Domain Methods ===========
@@ -12926,6 +13097,40 @@ var init_ideas_storage = __esm({
         }));
         return { removed };
       }
+      /**
+       * Mark pending ideas older than retention period as dormant (PRJ-267).
+       * Dormant ideas are excluded from LLM context but remain queryable.
+       * Returns count of newly dormant ideas.
+       */
+      async markDormantIdeas(projectId) {
+        const data = await this.read(projectId);
+        const threshold = getDaysAgo(ARCHIVE_POLICIES.IDEA_DORMANT_DAYS);
+        const stalePending = data.ideas.filter(
+          (i) => i.status === "pending" && new Date(i.addedAt) < threshold
+        );
+        if (stalePending.length === 0) return 0;
+        archiveStorage.archiveMany(
+          projectId,
+          stalePending.map((idea) => ({
+            entityType: "idea",
+            entityId: idea.id,
+            entityData: idea,
+            summary: idea.text,
+            reason: "dormant"
+          }))
+        );
+        const staleIds = new Set(stalePending.map((i) => i.id));
+        await this.update(projectId, (d) => ({
+          ideas: d.ideas.map(
+            (i) => staleIds.has(i.id) ? { ...i, status: "dormant" } : i
+          ),
+          lastUpdated: getTimestamp()
+        }));
+        await this.publishEvent(projectId, "ideas.dormant", {
+          count: stalePending.length
+        });
+        return stalePending.length;
+      }
     };
     ideasStorage = new IdeasStorage();
   }
@@ -13764,6 +13969,7 @@ var init_queue_storage = __esm({
     init_schemas2();
     init_state();
     init_date_helper();
+    init_archive_storage();
     init_storage_manager();
     QueueStorage = class extends StorageManager {
       static {
@@ -13969,6 +14175,38 @@ var init_queue_storage = __esm({
         }));
         return completedCount;
       }
+      /**
+       * Remove completed tasks older than retention period (PRJ-267).
+       * Archives them to SQLite before removal.
+       * Returns count of removed tasks.
+       */
+      async removeStaleCompleted(projectId) {
+        const queue = await this.read(projectId);
+        const threshold = getDaysAgo(ARCHIVE_POLICIES.QUEUE_COMPLETED_DAYS);
+        const stale = queue.tasks.filter(
+          (t) => t.completed && t.completedAt && new Date(t.completedAt) < threshold
+        );
+        if (stale.length === 0) return 0;
+        archiveStorage.archiveMany(
+          projectId,
+          stale.map((t) => ({
+            entityType: "queue_task",
+            entityId: t.id,
+            entityData: t,
+            summary: t.description,
+            reason: "age"
+          }))
+        );
+        const staleIds = new Set(stale.map((t) => t.id));
+        await this.update(projectId, (q) => ({
+          tasks: q.tasks.filter((t) => !staleIds.has(t.id)),
+          lastUpdated: getTimestamp()
+        }));
+        await this.publishEvent(projectId, "queue.stale_removed", {
+          count: stale.length
+        });
+        return stale.length;
+      }
       /**
        * Sort tasks by priority and section
        */
@@ -14005,6 +14243,7 @@ var init_shipped_storage = __esm({
     init_schemas2();
     init_shipped();
     init_date_helper();
+    init_archive_storage();
     init_storage_manager();
     ShippedStorage = class extends StorageManager {
       static {
@@ -14154,6 +14393,39 @@ var init_shipped_storage = __esm({
           period
         };
       }
+      /**
+       * Archive shipped features older than retention period (PRJ-267).
+       * Moves old items to archive table, keeps 1-line summary in active storage.
+       * Returns count of archived items.
+       */
+      async archiveOldShipped(projectId) {
+        const data = await this.read(projectId);
+        const threshold = getDaysAgo(ARCHIVE_POLICIES.SHIPPED_RETENTION_DAYS);
+        const stale = data.shipped.filter((s) => new Date(s.shippedAt) < threshold);
+        if (stale.length === 0) return 0;
+        archiveStorage.archiveMany(
+          projectId,
+          stale.map((s) => ({
+            entityType: "shipped",
+            entityId: s.id,
+            entityData: s,
+            summary: `${s.name} v${s.version}`,
+            reason: "age"
+          }))
+        );
+        const freshIds = new Set(
+          data.shipped.filter((s) => new Date(s.shippedAt) >= threshold).map((s) => s.id)
+        );
+        await this.update(projectId, (d) => ({
+          shipped: d.shipped.filter((s) => freshIds.has(s.id)),
+          lastUpdated: getTimestamp()
+        }));
+        await this.publishEvent(projectId, "shipped.archived", {
+          count: stale.length,
+          oldestShippedAt: stale[stale.length - 1]?.shippedAt
+        });
+        return stale.length;
+      }
     };
     shippedStorage = new ShippedStorage();
   }
@@ -14557,6 +14829,7 @@ var init_state_storage = __esm({
     init_date_helper();
     init_markdown_builder();
     init_state_machine();
+    init_archive_storage();
     init_storage_manager();
     StateStorage = class extends StorageManager {
       static {
@@ -14809,8 +15082,9 @@ var init_state_storage = __esm({
         return pausedTasks.filter((t) => new Date(t.pausedAt).getTime() < threshold);
       }
       /**
-       * Archive stale paused tasks (remove from pausedTasks)
-       * Returns archived tasks
+       * Archive stale paused tasks (PRJ-267).
+       * Persists to archive table before removing from active storage.
+       * Returns archived tasks.
        */
       async archiveStalePausedTasks(projectId) {
         const state = await this.read(projectId);
@@ -14819,6 +15093,16 @@ var init_state_storage = __esm({
         const stale = pausedTasks.filter((t) => new Date(t.pausedAt).getTime() < threshold);
         const fresh = pausedTasks.filter((t) => new Date(t.pausedAt).getTime() >= threshold);
         if (stale.length === 0) return [];
+        archiveStorage.archiveMany(
+          projectId,
+          stale.map((task) => ({
+            entityType: "paused_task",
+            entityId: task.id,
+            entityData: task,
+            summary: task.description,
+            reason: "staleness"
+          }))
+        );
         await this.update(projectId, (s) => ({
           ...s,
           pausedTasks: fresh,
@@ -15434,6 +15718,7 @@ var init_storage2 = __esm({
   "core/storage/index.ts"() {
     "use strict";
     init_analysis_storage();
+    init_archive_storage();
     init_database();
     init_ideas_storage();
     init_index_storage();
@@ -18572,6 +18857,211 @@ When fragmenting tasks:
   }
 });
 
+// core/utils/retry.ts
+function isTransientError(error) {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const err = error;
+  if (err.code && TRANSIENT_ERROR_CODES.has(err.code)) {
+    return true;
+  }
+  if (err.code && PERMANENT_ERROR_CODES.has(err.code)) {
+    return false;
+  }
+  if (err.message) {
+    const msg = err.message.toLowerCase();
+    if (msg.includes("timeout") || msg.includes("timed out")) {
+      return true;
+    }
+  }
+  return false;
+}
+function isPermanentError(error) {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const err = error;
+  return !!(err.code && PERMANENT_ERROR_CODES.has(err.code));
+}
+function isCircuitOpen(operationId, threshold, timeoutMs) {
+  const state = circuitStates.get(operationId);
+  if (!state) {
+    return false;
+  }
+  if (state.consecutiveFailures >= threshold && state.openedAt) {
+    const elapsed = Date.now() - state.openedAt;
+    if (elapsed >= timeoutMs) {
+      circuitStates.delete(operationId);
+      return false;
+    }
+    return true;
+  }
+  return false;
+}
+function recordFailure(operationId, threshold) {
+  const state = circuitStates.get(operationId) || {
+    consecutiveFailures: 0,
+    openedAt: null
+  };
+  state.consecutiveFailures++;
+  if (state.consecutiveFailures >= threshold && !state.openedAt) {
+    state.openedAt = Date.now();
+  }
+  circuitStates.set(operationId, state);
+}
+function recordSuccess(operationId) {
+  circuitStates.delete(operationId);
+}
+var TRANSIENT_ERROR_CODES, PERMANENT_ERROR_CODES, circuitStates, RetryPolicy, defaultAgentRetryPolicy, defaultToolRetryPolicy;
+var init_retry = __esm({
+  "core/utils/retry.ts"() {
+    "use strict";
+    TRANSIENT_ERROR_CODES = /* @__PURE__ */ new Set([
+      "EBUSY",
+      // Resource busy
+      "EAGAIN",
+      // Resource temporarily unavailable
+      "ETIMEDOUT",
+      // Operation timed out
+      "ECONNRESET",
+      // Connection reset by peer
+      "ECONNREFUSED",
+      // Connection refused (may be temporary)
+      "ENOTFOUND",
+      // DNS lookup failed (may be temporary)
+      "EAI_AGAIN"
+      // DNS temporary failure
+    ]);
+    PERMANENT_ERROR_CODES = /* @__PURE__ */ new Set([
+      "ENOENT",
+      // No such file or directory
+      "EACCES",
+      // Permission denied
+      "EPERM",
+      // Operation not permitted
+      "EISDIR",
+      // Is a directory
+      "ENOTDIR",
+      // Not a directory
+      "EINVAL"
+      // Invalid argument
+    ]);
+    __name(isTransientError, "isTransientError");
+    __name(isPermanentError, "isPermanentError");
+    circuitStates = /* @__PURE__ */ new Map();
+    __name(isCircuitOpen, "isCircuitOpen");
+    __name(recordFailure, "recordFailure");
+    __name(recordSuccess, "recordSuccess");
+    RetryPolicy = class {
+      static {
+        __name(this, "RetryPolicy");
+      }
+      options;
+      constructor(options = {}) {
+        this.options = {
+          maxAttempts: options.maxAttempts ?? 3,
+          baseDelayMs: options.baseDelayMs ?? 1e3,
+          maxDelayMs: options.maxDelayMs ?? 8e3,
+          circuitBreakerThreshold: options.circuitBreakerThreshold ?? 5,
+          circuitBreakerTimeoutMs: options.circuitBreakerTimeoutMs ?? 6e4
+        };
+      }
+      /**
+       * Execute an operation with retry logic
+       *
+       * @param operation - Async function to execute
+       * @param operationId - Optional ID for circuit breaker tracking
+       * @returns Result of the operation
+       * @throws Error if all attempts fail or circuit is open
+       */
+      async execute(operation, operationId = "default") {
+        if (isCircuitOpen(
+          operationId,
+          this.options.circuitBreakerThreshold,
+          this.options.circuitBreakerTimeoutMs
+        )) {
+          throw new Error(
+            `Circuit breaker is open for operation: ${operationId}. Too many consecutive failures.`
+          );
+        }
+        let lastError;
+        let attempt = 0;
+        while (attempt < this.options.maxAttempts) {
+          try {
+            const result = await operation();
+            recordSuccess(operationId);
+            return result;
+          } catch (error) {
+            lastError = error;
+            attempt++;
+            if (isPermanentError(error)) {
+              recordFailure(operationId, this.options.circuitBreakerThreshold);
+              throw error;
+            }
+            const shouldRetry = isTransientError(error) && attempt < this.options.maxAttempts;
+            if (!shouldRetry) {
+              recordFailure(operationId, this.options.circuitBreakerThreshold);
+              throw error;
+            }
+            const delay = Math.min(
+              this.options.baseDelayMs * 2 ** (attempt - 1),
+              this.options.maxDelayMs
+            );
+            await new Promise((resolve) => setTimeout(resolve, delay));
+          }
+        }
+        recordFailure(operationId, this.options.circuitBreakerThreshold);
+        throw lastError;
+      }
+      /**
+       * Check if an error is transient (exposed for testing)
+       */
+      isTransientError(error) {
+        return isTransientError(error);
+      }
+      /**
+       * Check if circuit is open for an operation (exposed for testing)
+       */
+      isCircuitOpen(operationId) {
+        return isCircuitOpen(
+          operationId,
+          this.options.circuitBreakerThreshold,
+          this.options.circuitBreakerTimeoutMs
+        );
+      }
+      /**
+       * Get current circuit state for an operation (exposed for testing)
+       */
+      getCircuitState(operationId) {
+        return circuitStates.get(operationId);
+      }
+      /**
+       * Reset circuit breaker for an operation (exposed for testing)
+       */
+      resetCircuit(operationId) {
+        circuitStates.delete(operationId);
+      }
+      /**
+       * Reset all circuit breakers (exposed for testing)
+       */
+      resetAllCircuits() {
+        circuitStates.clear();
+      }
+    };
+    defaultAgentRetryPolicy = new RetryPolicy({
+      maxAttempts: 3,
+      baseDelayMs: 1e3,
+      maxDelayMs: 8e3
+    });
+    defaultToolRetryPolicy = new RetryPolicy({
+      maxAttempts: 2,
+      baseDelayMs: 500,
+      maxDelayMs: 2e3
+    });
+  }
+});
+
 // core/agentic/tool-registry.ts
 import { exec as exec7 } from "node:child_process";
 import fs36 from "node:fs/promises";
@@ -18580,6 +19070,7 @@ var execAsync4, toolRegistry, tool_registry_default;
 var init_tool_registry = __esm({
   "core/agentic/tool-registry.ts"() {
     "use strict";
+    init_retry();
     execAsync4 = promisify8(exec7);
     toolRegistry = {
       tools: /* @__PURE__ */ new Map(),
@@ -18618,16 +19109,34 @@ var init_tool_registry = __esm({
     };
     toolRegistry.register("Read", async (filePath) => {
       try {
-        return await fs36.readFile(filePath, "utf-8");
-      } catch (_error) {
+        return await defaultToolRetryPolicy.execute(
+          async () => await fs36.readFile(filePath, "utf-8"),
+          `read-${filePath}`
+        );
+      } catch (error) {
+        if (isPermanentError(error)) {
+          return null;
+        }
+        if (isTransientError(error)) {
+          return null;
+        }
         return null;
       }
     });
     toolRegistry.register("Write", async (filePath, content) => {
       try {
-        await fs36.writeFile(filePath, content, "utf-8");
+        await defaultToolRetryPolicy.execute(
+          async () => await fs36.writeFile(filePath, content, "utf-8"),
+          `write-${filePath}`
+        );
         return true;
-      } catch (_error) {
+      } catch (error) {
+        if (isPermanentError(error)) {
+          return false;
+        }
+        if (isTransientError(error)) {
+          return false;
+        }
         return false;
       }
     });
@@ -18635,8 +19144,10 @@ var init_tool_registry = __esm({
       "Bash",
       async (command) => {
         try {
-          const { stdout, stderr } = await execAsync4(command);
-          return { stdout, stderr };
+          return await defaultToolRetryPolicy.execute(
+            async () => await execAsync4(command),
+            `bash-${command}`
+          );
         } catch (error) {
           const err = error;
           return {
@@ -19279,6 +19790,7 @@ var init_agent_generator = __esm({
   "core/services/agent-generator.ts"() {
     "use strict";
     init_preserve_sections();
+    init_retry();
   }
 });
 
@@ -19507,6 +20019,7 @@ var init_agent_service = __esm({
     init_agent_router();
     init_errors();
     init_agent_detector();
+    init_retry();
     init_();
     VALID_AGENT_TYPES = ["claude"];
     AgentService = class {
@@ -19521,20 +20034,23 @@ var init_agent_service = __esm({
       }
       /**
        * Initialize agent (Claude Code, Desktop, or Terminal)
+       * Wrapped with retry policy to handle transient failures
        */
       async initialize() {
         if (this.agent) return this.agent;
-        this.agentInfo = await detect2();
-        if (!this.agentInfo?.isSupported) {
-          throw AgentError.notSupported(this.agentInfo?.type ?? "unknown");
-        }
-        const agentType = this.agentInfo.type;
-        if (!agentType || !VALID_AGENT_TYPES.includes(agentType)) {
-          throw AgentError.notSupported(this.agentInfo?.type ?? "unknown");
-        }
-        const { default: Agent } = await globImport_infrastructure_agent(`../infrastructure/${agentType}-agent`);
-        this.agent = new Agent();
-        return this.agent;
+        return await defaultAgentRetryPolicy.execute(async () => {
+          this.agentInfo = await detect2();
+          if (!this.agentInfo?.isSupported) {
+            throw AgentError.notSupported(this.agentInfo?.type ?? "unknown");
+          }
+          const agentType = this.agentInfo.type;
+          if (!agentType || !VALID_AGENT_TYPES.includes(agentType)) {
+            throw AgentError.notSupported(this.agentInfo?.type ?? "unknown");
+          }
+          const { default: Agent } = await globImport_infrastructure_agent(`../infrastructure/${agentType}-agent`);
+          this.agent = new Agent();
+          return this.agent;
+        }, "agent-initialization");
       }
       /**
        * Get current agent info
@@ -20764,6 +21280,7 @@ var init_memory_service = __esm({
     "use strict";
     init_config_manager();
     init_path_manager();
+    init_archive_storage();
     init_fs();
     init_date_helper();
     init_jsonl_helper();
@@ -20859,6 +21376,39 @@ var init_memory_service = __esm({
           return [];
         }
       }
+      /**
+       * Cap memory log at max entries (PRJ-267).
+       * Moves overflow entries to archive table, keeps most recent entries.
+       * Returns count of archived entries.
+       */
+      async capEntries(projectId) {
+        try {
+          const memoryPath = path_manager_default.getFilePath(projectId, "memory", "context.jsonl");
+          const entries = await readJsonLines(memoryPath);
+          if (entries.length <= ARCHIVE_POLICIES.MEMORY_MAX_ENTRIES) {
+            return 0;
+          }
+          const overflow = entries.slice(0, entries.length - ARCHIVE_POLICIES.MEMORY_MAX_ENTRIES);
+          const kept = entries.slice(-ARCHIVE_POLICIES.MEMORY_MAX_ENTRIES);
+          archiveStorage.archiveMany(
+            projectId,
+            overflow.map((entry, i) => ({
+              entityType: "memory_entry",
+              entityId: `memory-${entry.timestamp || i}`,
+              entityData: entry,
+              summary: entry.action,
+              reason: "overflow"
+            }))
+          );
+          await writeJsonLines(memoryPath, kept);
+          return overflow.length;
+        } catch (error) {
+          if (!isNotFoundError(error)) {
+            console.error(`Memory cap error: ${getErrorMessage2(error)}`);
+          }
+          return 0;
+        }
+      }
     };
     memoryService = new MemoryService();
   }
@@ -26977,13 +27527,19 @@ var init_sync_service = __esm({
     init_config_manager();
     init_path_manager();
     init_analysis_storage();
+    init_archive_storage();
+    init_ideas_storage();
     init_metrics_storage();
     init_migrate_json();
+    init_queue_storage();
+    init_shipped_storage();
+    init_state_storage();
     init_citations();
     init_date_helper();
     init_logger();
     init_context_generator();
     init_local_state_generator();
+    init_memory_service();
     init_skill_installer();
     init_stack_detector();
     init_sync_verifier();
@@ -27159,6 +27715,7 @@ var init_sync_service = __esm({
           ]);
           const duration = Date.now() - startTime;
           const syncMetrics = await this.recordSyncMetrics(stats, contextFiles, agents, duration);
+          await this.archiveStaleData();
           await command_installer_default.installGlobalConfig();
           await command_installer_default.syncCommands();
           let verification;
@@ -27938,6 +28495,40 @@ You are the ${name} expert for this project. Apply best practices for the detect
         }
       }
       // ==========================================================================
+      // ARCHIVAL (PRJ-267)
+      // ==========================================================================
+      /**
+       * Archive stale data across all storage types.
+       * Runs during sync to keep active storage lean.
+       */
+      async archiveStaleData() {
+        if (!this.projectId) return;
+        try {
+          const [shipped, dormant, staleQueue, stalePaused, memoryCapped] = await Promise.all([
+            shippedStorage.archiveOldShipped(this.projectId).catch(() => 0),
+            ideasStorage.markDormantIdeas(this.projectId).catch(() => 0),
+            queueStorage.removeStaleCompleted(this.projectId).catch(() => 0),
+            stateStorage.archiveStalePausedTasks(this.projectId).catch(() => []),
+            memoryService.capEntries(this.projectId).catch(() => 0)
+          ]);
+          const totalArchived = shipped + dormant + staleQueue + stalePaused.length + memoryCapped;
+          if (totalArchived > 0) {
+            logger_default.info("Archived stale data", {
+              shipped,
+              dormant,
+              staleQueue,
+              stalePaused: stalePaused.length,
+              memoryCapped,
+              total: totalArchived
+            });
+            const stats = archiveStorage.getStats(this.projectId);
+            logger_default.debug("Archive stats", stats);
+          }
+        } catch (error) {
+          logger_default.debug("Archival failed (non-critical)", { error: getErrorMessage(error) });
+        }
+      }
+      // ==========================================================================
       // HELPERS
       // ==========================================================================
       async fileExists(filename) {
@@ -33881,7 +34472,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "prjct-cli",
-      version: "1.18.0",
+      version: "1.20.0",
       description: "Context layer for AI agents. Project context for Claude Code, Gemini CLI, and more.",
       main: "core/index.ts",
       bin: {