@cydm/happy-elves 0.1.0-beta.73 → 0.1.0-beta.74

package/apps/daemon/dist/gateway/runtime.js

@@ -923,6 +923,7 @@ async function runGatewayPrompt(ws, config, gateway, binding, input, session, le
             }
             const started = await startGatewayProviderTurnWithFence(lease, input, binding, () => withCancelSettlement(getRuntime(session.cwd).startTurn({
                 handle: session.handle,
+                applicationContext: prepared.applicationContext,
                 text: prepared.text,
                 mode: "prompt",
                 permissionMode,

package/apps/daemon/dist/lifecycle/detached-helper-bundle.mjs

@@ -17831,6 +17831,7 @@ var capabilitiesSchema = external_exports.object({
   memory: external_exports.boolean().optional(),
   memoryTurnOptionsV1: external_exports.boolean().optional(),
   memoryCommandsV1: external_exports.boolean().optional(),
+  memoryProjectsV1: external_exports.boolean().optional(),
   gatewayCommandsV1: external_exports.boolean().optional(),
   filePreview: external_exports.boolean().optional(),
   scheduleAuthContextV1: external_exports.boolean().optional(),
@@ -18169,6 +18170,14 @@ var controllerMessageSchema = external_exports.discriminatedUnion("type", [
     encryptedPayload: encryptedEnvelopeSchema,
     semanticDigest: external_exports.string().min(1)
   }),
+  external_exports.object({
+    type: external_exports.literal("controller:memoryProjectCommand"),
+    requestId: external_exports.string().min(1),
+    machineId: external_exports.string().min(1),
+    action: external_exports.enum(["list", "overview", "read", "search", "reindex"]),
+    encryptedPayload: encryptedEnvelopeSchema,
+    semanticDigest: external_exports.string().min(1)
+  }),
   external_exports.object({
     type: external_exports.literal("controller:gatewayCommand"),
     requestId: external_exports.string().min(1),
@@ -18532,6 +18541,13 @@ var machineMessageSchema = external_exports.discriminatedUnion("type", [
     encryptedPayload: encryptedEnvelopeSchema,
     messageId: external_exports.string().min(1).optional()
   }),
+  external_exports.object({
+    type: external_exports.literal("machine:memoryProjectResult"),
+    requestId: external_exports.string().min(1),
+    action: external_exports.enum(["list", "overview", "read", "search", "reindex"]),
+    encryptedPayload: encryptedEnvelopeSchema,
+    messageId: external_exports.string().min(1).optional()
+  }),
   external_exports.object({
     type: external_exports.literal("machine:gatewayResult"),
     requestId: external_exports.string().min(1),
@@ -18568,7 +18584,8 @@ var clientMessageSchema = external_exports.union([
     capabilities: external_exports.object({
       daemonLifecycleEventsV1: external_exports.boolean().optional(),
       daemonAutostartV1: external_exports.boolean().optional(),
-      resourcePreferenceInvalidationV1: external_exports.boolean().optional()
+      resourcePreferenceInvalidationV1: external_exports.boolean().optional(),
+      daemonProjectsPreferenceV1: external_exports.boolean().optional()
     }).optional()
   }),
   controllerMessageSchema,
@@ -18610,6 +18627,21 @@ var machineCommandSchema = external_exports.discriminatedUnion("type", [
     semanticDigest: external_exports.string().min(1),
     authorization: scheduleAuthorizationContextV1Schema
   }),
+  external_exports.object({
+    type: external_exports.literal("machine:memoryProjectCommand"),
+    requestId: external_exports.string().min(1),
+    controllerRequestId: external_exports.string().min(1),
+    machineId: external_exports.string().min(1),
+    action: external_exports.enum(["list", "overview", "read", "search", "reindex"]),
+    encryptedPayload: encryptedEnvelopeSchema,
+    semanticDigest: external_exports.string().min(1),
+    projectCandidates: external_exports.array(external_exports.object({
+      sessionId: external_exports.string().min(1),
+      cwd: external_exports.string().min(1).max(4096).refine((value) => !value.includes("\0"), "cwd must not contain NUL"),
+      updatedAt: external_exports.number().int().nonnegative()
+    })).max(500),
+    authorization: scheduleAuthorizationContextV1Schema
+  }),
   external_exports.object({
     type: external_exports.literal("machine:gatewayCommand"),
     requestId: external_exports.string().min(1),
@@ -18771,6 +18803,7 @@ var _machineClientMessageTypeSchema = external_exports.enum([
   "machine:cancelResult",
   "machine:scheduleResult",
   "machine:memoryResult",
+  "machine:memoryProjectResult",
   "machine:gatewayResult",
   "machine:daemonLifecycleResult",
   "machine:error"
@@ -18783,6 +18816,7 @@ var serverMessageSchema = external_exports.union([
       machineMessages: external_exports.array(external_exports.string().min(1)).optional(),
       scheduleCreateSemanticDigestV1: external_exports.boolean().optional(),
       memoryCommandsV1: external_exports.boolean().optional(),
+      memoryProjectsV1: external_exports.boolean().optional(),
       memoryTurnOptionsV1: external_exports.boolean().optional(),
       gatewayCommandsV1: external_exports.boolean().optional(),
       enrollmentInvitesV1: external_exports.boolean().optional(),
@@ -18869,6 +18903,13 @@ var serverMessageSchema = external_exports.union([
     action: external_exports.string().min(1),
     encryptedPayload: encryptedEnvelopeSchema
   }),
+  external_exports.object({
+    type: external_exports.literal("server:memoryProjectResult"),
+    requestId: external_exports.string().min(1),
+    machineId: external_exports.string().min(1),
+    action: external_exports.enum(["list", "overview", "read", "search", "reindex"]),
+    encryptedPayload: encryptedEnvelopeSchema
+  }),
   external_exports.object({
     type: external_exports.literal("server:gatewayResult"),
     requestId: external_exports.string().min(1),
@@ -18888,7 +18929,7 @@ var serverMessageSchema = external_exports.union([
     type: external_exports.literal("server:resourcePreferenceInvalidated"),
     resourceType: external_exports.enum(["session", "daemon"]),
     resourceId: external_exports.string().min(1),
-    preferenceKey: external_exports.enum(["session.star.v1", "daemon.alias.v1"]),
+    preferenceKey: external_exports.enum(["session.star.v1", "daemon.alias.v1", "daemon.projects.v1"]),
     revision: external_exports.number().int().positive()
   }),
   external_exports.object({
@@ -20539,10 +20580,9 @@ function windowsTaskBackend(run) {
   return {
     async inspect(spec) {
       const [result, identity] = await Promise.all([
-        run(command, ["/Query", "/TN", spec.serviceId, "/XML"]),
+        inspectWindowsTask(run, command, spec.serviceId),
         run(identityCommand, ["/user", "/fo", "csv", "/nh"])
       ]);
-      requireManagerInspectionQuery(result, "schtasks /Query");
       const registered = result.exitCode === 0;
       if (registered)
         requireManagerInspectionSuccess(identity, "whoami /user");
@@ -20576,6 +20616,15 @@ function windowsTaskBackend(run) {
     }
   };
 }
+async function inspectWindowsTask(run, command, serviceId) {
+  const result = await run(command, ["/Query", "/TN", serviceId, "/XML"]);
+  requireManagerInspectionSettled(result, "schtasks /Query");
+  if (result.exitCode === 0 || managerObjectMissing(result))
+    return result;
+  const managerProbe = await run(command, ["/Query", "/FO", "CSV", "/NH"]);
+  requireManagerInspectionSuccess(managerProbe, "schtasks /Query");
+  return result;
+}
 function windowsTaskDefinitionMatches(spec, xmlSource, userSid) {
   const triggers = singleXmlElementBody(xmlSource, "Triggers");
   const principals = singleXmlElementBody(xmlSource, "Principals");

package/apps/daemon/dist/loop/runner.js

@@ -242,6 +242,7 @@ async function runLoopOnce(ws, config, loop, reason) {
         };
         const turn = withCancelSettlement(runtime.startTurn({
             handle: turnHandle,
+            applicationContext: prepared.applicationContext,
             text: prepared.text,
             mode: "prompt",
             permissionMode,

package/apps/daemon/dist/memory/commands.js

@@ -3,7 +3,7 @@ import { canonicalizeMemoryCommandSemanticsV1, decryptJson, encryptJson, memoryC
 import { listMemoryFiles, MemoryError, scopeKeyFor } from "../../../../packages/memory/dist/index.js";
 import { appendAudit } from "../audit.js";
 import { claimCommandRequest, sendCommandResponse } from "../relay/send.js";
-import { getMemoryManager } from "./managers.js";
+import { withMemoryManager } from "./managers.js";
 const MAX_READ_BYTES = 256 * 1024;
 export async function handleMemoryCommand(ws, config, command) {
     if (command.type !== "machine:memoryCommand")
@@ -36,8 +36,48 @@ export async function handleMemoryCommand(ws, config, command) {
         if (semantics.action !== command.action || !digestEqual(memoryCommandSemanticDigestV1(config.accountSecret, semantics), command.semanticDigest)) {
             throw memoryError("Memory command semantic digest is invalid", "MEMORY_COMMAND_INVALID");
         }
-        const manager = await getMemoryManager(config, trustedSession.cwd);
-        if (!manager) {
+        const handled = await withMemoryManager(config, trustedSession.cwd, async (manager) => {
+            switch (command.action) {
+                case "overview": {
+                    const [status, files] = await Promise.all([manager.status(), listMemoryFiles(manager.rootDir)]);
+                    await respond(ws, config, command, { enabled: true, status: publicStatus(status), files });
+                    return true;
+                }
+                case "read": {
+                    if (!semantics.path)
+                        throw memoryError("Memory path is missing", "MEMORY_COMMAND_INVALID");
+                    const from = semantics.from ?? 1;
+                    const requestedLines = semantics.lines ?? 500;
+                    const read = await manager.readMemory(semantics.path, { from, lines: requestedLines });
+                    const limited = truncateUtf8(read.text, MAX_READ_BYTES);
+                    const lines = limited.text.length === 0 ? 0 : limited.text.split("\n").length;
+                    await respond(ws, config, command, {
+                        path: read.path,
+                        text: limited.text,
+                        from,
+                        lines,
+                        truncated: limited.truncated || read.endLine < read.totalLines,
+                    });
+                    return true;
+                }
+                case "search": {
+                    if (!semantics.query)
+                        throw memoryError("Memory query is missing", "MEMORY_COMMAND_INVALID");
+                    const results = await manager.search(semantics.query, {
+                        maxResults: semantics.maxResults,
+                        ...(semantics.minScore === undefined ? {} : { minScore: semantics.minScore }),
+                    });
+                    await respond(ws, config, command, { results });
+                    return true;
+                }
+                case "reindex": {
+                    const sync = await manager.sync({ force: true });
+                    await respond(ws, config, command, { sync, status: publicStatus(await manager.status()) });
+                    return true;
+                }
+            }
+        });
+        if (handled === null) {
             if (command.action === "overview") {
                 await respond(ws, config, command, {
                     enabled: false,
@@ -55,45 +95,7 @@ export async function handleMemoryCommand(ws, config, command) {
             }
             throw memoryError("Memory is disabled on this machine", "MEMORY_DISABLED");
         }
-        switch (command.action) {
-            case "overview": {
-                const [status, files] = await Promise.all([manager.status(), listMemoryFiles(manager.rootDir)]);
-                await respond(ws, config, command, { enabled: true, status: publicStatus(status), files });
-                return;
-            }
-            case "read": {
-                if (!semantics.path)
-                    throw memoryError("Memory path is missing", "MEMORY_COMMAND_INVALID");
-                const from = semantics.from ?? 1;
-                const requestedLines = semantics.lines ?? 500;
-                const read = await manager.readMemory(semantics.path, { from, lines: requestedLines });
-                const limited = truncateUtf8(read.text, MAX_READ_BYTES);
-                const lines = limited.text.length === 0 ? 0 : limited.text.split("\n").length;
-                await respond(ws, config, command, {
-                    path: read.path,
-                    text: limited.text,
-                    from,
-                    lines,
-                    truncated: limited.truncated || read.endLine < read.totalLines,
-                });
-                return;
-            }
-            case "search": {
-                if (!semantics.query)
-                    throw memoryError("Memory query is missing", "MEMORY_COMMAND_INVALID");
-                const results = await manager.search(semantics.query, {
-                    maxResults: semantics.maxResults,
-                    ...(semantics.minScore === undefined ? {} : { minScore: semantics.minScore }),
-                });
-                await respond(ws, config, command, { results });
-                return;
-            }
-            case "reindex": {
-                const sync = await manager.sync({ force: true });
-                await respond(ws, config, command, { sync, status: publicStatus(await manager.status()) });
-                return;
-            }
-        }
+        return;
     }
     catch (error) {
         await appendAudit({

package/apps/daemon/dist/memory/flush.js

@@ -61,6 +61,7 @@ export async function maybeRunMemoryFlush(ws, config, session, metadata) {
         memoryAccessLease = prepared.lease;
         const turn = getRuntime(session.cwd).startTurn({
             handle: session.handle,
+            applicationContext: prepared.applicationContext,
             text: prepared.text,
             mode: "prompt",
             requestId,

package/apps/daemon/dist/memory/inject.d.ts

@@ -15,6 +15,7 @@ export declare function prepareMemoryPrompt(input: {
     text: string;
 }): {
     text: string;
+    applicationContext?: string;
     memoryMode: MemoryMode;
     accessToken?: string;
     lease: MemoryAccessLease;

package/apps/daemon/dist/memory/inject.js

@@ -2,7 +2,7 @@ import { createMemoryAccessLease, revokeCurrentProcessMemoryAccess, } from "../.
 import { BoundedTtlCache } from "../turn-coordinator.js";
 import { memoryEnabled, resolveMemoryMode } from "./config.js";
 import { MEMORY_CLI_LAUNCHER, memoryInstructions } from "./instructions.js";
-import { getMemoryManager } from "./managers.js";
+import { withMemoryManager } from "./managers.js";
 import { assertMemoryAccessHealthy } from "./access-lifecycle.js";
 const injectedSessionLimit = 1000;
 const injectedSessionTtlMs = 24 * 60 * 60 * 1000;
@@ -26,14 +26,15 @@ export function prepareMemoryPrompt(input) {
         return { text: input.text, memoryMode, lease: granted.lease };
     // Warm the workspace index/watcher so agent writes via the memory CLI are
     // re-indexed promptly. Fire-and-forget; prompt latency is unaffected.
-    void getMemoryManager(input.config, input.cwd).catch(() => undefined);
+    void withMemoryManager(input.config, input.cwd, async () => undefined).catch(() => undefined);
     const injectionKey = input.injectionKey ?? input.sessionId;
     const capabilityPrefix = granted.accessToken
         ? `Memory write capability for this turn: add \`--access-token ${granted.accessToken}\` to every \`${MEMORY_CLI_LAUNCHER} memory write\` command.`
         : "";
     if (injectedSessions.get(injectionKey) === memoryMode) {
         return {
-            text: capabilityPrefix ? `${capabilityPrefix}\n\n${input.text}` : input.text,
+            text: input.text,
+            ...(capabilityPrefix ? { applicationContext: capabilityPrefix } : {}),
             memoryMode,
             ...(granted.accessToken ? { accessToken: granted.accessToken } : {}),
             lease: granted.lease,
@@ -44,7 +45,8 @@ export function prepareMemoryPrompt(input) {
         return { text: input.text, memoryMode, lease: granted.lease };
     injectedSessions.set(injectionKey, memoryMode);
     return {
-        text: `${instructions}${capabilityPrefix ? `\n\n${capabilityPrefix}` : ""}\n\n---\n\n${input.text}`,
+        text: input.text,
+        applicationContext: `${instructions}${capabilityPrefix ? `\n\n${capabilityPrefix}` : ""}`,
         memoryMode,
         ...(granted.accessToken ? { accessToken: granted.accessToken } : {}),
         lease: granted.lease,

package/apps/daemon/dist/memory/managers.d.ts

@@ -1,8 +1,10 @@
 import { MemoryManager } from "../../../../packages/memory/dist/index.js";
 import type { DaemonConfig } from "../types.js";
 /**
- * Returns the workspace memory manager for a session cwd, or null when the
- * memory subsystem is disabled in daemon.json.
+ * Borrows one workspace manager for the complete duration of an operation.
+ * Cache eviction may close only idle managers; a bulk all-project search can
+ * therefore cross the cache limit without closing a database underneath an
+ * in-flight search or sync.
  */
-export declare function getMemoryManager(config: DaemonConfig, cwd: string): Promise<MemoryManager | null>;
+export declare function withMemoryManager<T>(config: DaemonConfig, cwd: string, action: (manager: MemoryManager) => Promise<T>): Promise<T | null>;
 export declare function closeMemoryManagers(): Promise<void>;

package/apps/daemon/dist/memory/managers.js

@@ -1,53 +1,56 @@
 import path from "node:path";
-import { MemoryManager, revokeCurrentProcessMemoryAccess } from "../../../../packages/memory/dist/index.js";
+import { listRegisteredMemoryProjects, MemoryManager, registerMemoryProject, revokeCurrentProcessMemoryAccess, } from "../../../../packages/memory/dist/index.js";
 import { appendAudit } from "../audit.js";
 import { memoryEnabled } from "./config.js";
-const managers = new Map();
 const managerLimit = 32;
+const managers = new Map();
+const closingManagers = new Map();
 async function createManager(config, cwd) {
     const manager = new MemoryManager({
         scope: { kind: "workspace", cwd },
         embedding: config.memory?.embedding === "none" ? "none" : "auto",
         openai: config.memory?.openai,
     });
-    await manager.init();
-    await manager.sync();
-    manager.startWatcher();
-    return manager;
+    try {
+        await manager.init();
+        await manager.sync();
+        await registerMemoryProject(cwd);
+        manager.startWatcher();
+        return manager;
+    }
+    catch (error) {
+        await manager.close().catch(() => undefined);
+        throw error;
+    }
 }
 /**
- * Returns the workspace memory manager for a session cwd, or null when the
- * memory subsystem is disabled in daemon.json.
+ * Borrows one workspace manager for the complete duration of an operation.
+ * Cache eviction may close only idle managers; a bulk all-project search can
+ * therefore cross the cache limit without closing a database underneath an
+ * in-flight search or sync.
  */
-export async function getMemoryManager(config, cwd) {
+export async function withMemoryManager(config, cwd, action) {
     if (!memoryEnabled(config))
         return null;
-    // Normalize so different spellings of the same directory share one manager.
+    // Validate on every access, including cache hits. A future or malformed
+    // project registry must fail closed before an existing manager can continue
+    // reading or mutating adjacent Memory state.
+    await listRegisteredMemoryProjects();
     const key = `workspace:${path.resolve(cwd)}`;
-    let pending = managers.get(key);
-    if (!pending) {
-        while (managers.size >= managerLimit) {
-            const oldestKey = managers.keys().next().value;
-            if (oldestKey === undefined)
-                break;
-            const oldest = managers.get(oldestKey);
-            managers.delete(oldestKey);
-            void oldest?.then((manager) => manager.close()).catch(() => undefined);
-        }
-        pending = createManager(config, cwd).catch(async (error) => {
-            managers.delete(key);
-            await appendAudit({
-                machineId: config.machineId,
-                actor: "system",
-                action: "memory.manager.failed",
-                summary: `Failed to initialize memory manager for ${cwd}`,
-                evidence: { error: error instanceof Error ? error.message : String(error) },
-            });
-            throw error;
-        });
-        managers.set(key, pending);
+    let entry = managers.get(key);
+    if (!entry) {
+        entry = createManagerEntry(config, cwd, key);
+        managers.set(key, entry);
+    }
+    entry.borrowers += 1;
+    trimIdleManagers();
+    try {
+        return await action(await entry.pending);
+    }
+    finally {
+        entry.borrowers -= 1;
+        trimIdleManagers();
     }
-    return pending;
 }
 export async function closeMemoryManagers() {
     let revokeError;
@@ -57,12 +60,85 @@ export async function closeMemoryManagers() {
     catch (error) {
         revokeError = error;
     }
-    const pending = [...managers.values()];
+    const pending = [...managers.values()].map((entry) => entry.pending);
     managers.clear();
     for (const managerPromise of pending) {
         const manager = await managerPromise.catch(() => null);
         await manager?.close().catch(() => undefined);
     }
+    await Promise.allSettled([...closingManagers.values()].map((entry) => entry.pending));
+    closingManagers.clear();
     if (revokeError)
         throw revokeError;
 }
+function createManagerEntry(config, cwd, key) {
+    const entry = {
+        borrowers: 0,
+        pending: Promise.resolve(null),
+    };
+    entry.pending = (async () => {
+        // An evicted manager may still be completing a watcher sync. Do not open a
+        // replacement database for the same workspace until that exact close has
+        // settled.
+        const closing = closingManagers.get(key);
+        if (closing) {
+            await closing.pending;
+            if (closing.error) {
+                throw memoryManagerCloseError();
+            }
+        }
+        return await createManager(config, cwd);
+    })().catch(async (error) => {
+        if (managers.get(key) === entry)
+            managers.delete(key);
+        await appendAudit({
+            machineId: config.machineId,
+            actor: "system",
+            action: "memory.manager.failed",
+            summary: `Failed to initialize memory manager for ${cwd}`,
+            evidence: { error: error instanceof Error ? error.message : String(error) },
+        });
+        throw error;
+    });
+    return entry;
+}
+function trimIdleManagers() {
+    while (managers.size > managerLimit) {
+        const idle = [...managers.entries()].find(([, entry]) => entry.borrowers === 0);
+        if (!idle)
+            return;
+        const [key, entry] = idle;
+        managers.delete(key);
+        closeManagerEntry(key, entry);
+    }
+}
+function closeManagerEntry(key, entry) {
+    if (closingManagers.has(key))
+        return;
+    const closing = {
+        error: null,
+        pending: Promise.resolve(),
+    };
+    closing.pending = entry.pending
+        .then(async (manager) => {
+        try {
+            await manager.close();
+        }
+        catch (error) {
+            closing.error = error;
+        }
+    }, () => undefined)
+        .finally(() => {
+        // A failed close is an ownership fence, not a best-effort cleanup. Keep
+        // it until daemon shutdown so another manager cannot open the same DB
+        // while the old watcher/SQLite handle may still be alive.
+        if (closing.error === null && closingManagers.get(key) === closing)
+            closingManagers.delete(key);
+    });
+    closingManagers.set(key, closing);
+}
+function memoryManagerCloseError() {
+    const error = new Error("Previous Memory manager did not close safely");
+    error.code = "MEMORY_MANAGER_CLOSE_FAILED";
+    return error;
+}

package/apps/daemon/dist/memory/project-commands.d.ts

@@ -0,0 +1,3 @@
+import { type MachineCommand } from "../../../../packages/shared/dist/index.js";
+import type { DaemonConfig } from "../types.js";
+export declare function handleMemoryProjectCommand(ws: WebSocket, config: DaemonConfig, command: MachineCommand): Promise<void>;