@nowcrew/daemon 0.6.87-beta.2 → 0.6.87-beta.4

package/dist/local-memory/write.js

@@ -4,7 +4,7 @@ import { dirname, join, relative, resolve, sep } from "node:path";
 import { z } from "zod";
 import { containsLikelySecret } from "../agent-memory/policy.js";
 import { LOCAL_MEMORY_INDEX_CODE_POINT_CAP, LOCAL_MEMORY_INDEX_ENTRY_CAP, LOCAL_MEMORY_TOTAL_CODE_POINT_CAP, renderLocalMemoryIndexCard, selectLocalMemoryIndexEntries, } from "./index-budget.js";
-import { persistPendingMemoryCandidate } from "./pending.js";
+import { persistPendingMemoryCandidate, readPendingMemoryCandidates, removePendingMemoryCandidate, } from "./pending.js";
 const CategorySchema = z.enum([
     "preferences", "project-rules", "testing", "debugging", "git", "incidents", "lessons",
 ]);
@@ -228,6 +228,47 @@ function normalize(value) {
 function activeOrPinnedIds(entries) {
     return new Set(entries.filter((entry) => entry.status === "active" || entry.status === "pinned").map((entry) => entry.id));
 }
+function pinnedIds(entries) {
+    return new Set(entries.filter((entry) => entry.status === "pinned").map((entry) => entry.id));
+}
+const DETAIL_CATEGORIES = new Set([
+    "preferences", "project-rules", "testing", "debugging", "git", "incidents", "lessons",
+]);
+function detailCategoryFromFile(file) {
+    if (!file.startsWith("notes/") || !file.endsWith(".md"))
+        return null;
+    const category = file.slice("notes/".length, -".md".length);
+    return DETAIL_CATEGORIES.has(category) ? category : null;
+}
+function readNoteBody(content, id) {
+    const begin = content.indexOf(`<!-- NOWWORK:MEMORY_ENTRY:BEGIN id=${id}`);
+    if (begin < 0)
+        return null;
+    const bodyStart = content.indexOf("\n\n", begin);
+    const bodyEnd = content.indexOf(`\n<!-- NOWWORK:MEMORY_ENTRY:END id=${id}`, bodyStart + 2);
+    if (bodyStart < 0 || bodyEnd < 0)
+        return null;
+    return content.slice(bodyStart + 2, bodyEnd).trim();
+}
+function archivedChange(entry, detailBody) {
+    const detailCategory = detailCategoryFromFile(entry.file);
+    if (detailCategory === null)
+        return null;
+    return {
+        operation: "create",
+        memoryId: null,
+        baseRevision: null,
+        supersedesMemoryId: null,
+        title: entry.title,
+        kind: entry.type,
+        summary: entry.summary,
+        triggers: entry.triggers,
+        priority: entry.priority,
+        detailCategory,
+        detailBody,
+        reviewAfter: entry.reviewAfter,
+    };
+}
 function emptyResult() {
     return { createdIds: [], updatedIds: [], statusChangedIds: [], deferredIds: [], pendingIds: [] };
 }
@@ -341,7 +382,9 @@ export async function applyLocalMemoryResult(input) {
         const statusChangedIds = input.result.statusChanges.map((change) => change.memoryId);
         const deferredIds = [];
         const pendingCandidates = [];
+        const resolvedPendingIds = new Set();
         const noteUpdates = new Map();
+        let allowActiveEviction = false;
         const randomId = input.randomId ?? randomUUID;
         const executionId = input.executionId ?? "unknown";
         const defer = (change, index) => {
@@ -399,7 +442,10 @@ export async function applyLocalMemoryResult(input) {
                             : item),
                         entry,
                     ];
-            const protectedIds = new Set(activeOrPinnedIds(entries));
+            const allowEvictionForChange = change.operation === "create" && change.priority === "high";
+            const protectedIds = new Set(allowEvictionForChange ? pinnedIds(entries) : activeOrPinnedIds(entries));
+            if (allowEvictionForChange)
+                allowActiveEviction = true;
             if (change.supersedesMemoryId !== null)
                 protectedIds.delete(change.supersedesMemoryId);
             const projection = projectIndex(memory, candidateEntries, protectedIds);
@@ -428,15 +474,91 @@ export async function applyLocalMemoryResult(input) {
             else if (existingCreate === undefined)
                 createdIds.push(id);
         }
-        const finalProjection = projectIndex(memory, entries, activeOrPinnedIds(entries));
-        if (finalProjection.reason !== null)
+        // Pending create candidates are durable overflow, not dead ends. Promote only
+        // when the current catalog has room; supersede/update candidates stay pending
+        // until a fresh revision-aware decision can safely replay them.
+        const pendingCandidatesOnDisk = await readPendingMemoryCandidates({ agentDir: input.agentDir });
+        for (const pending of pendingCandidatesOnDisk) {
+            const change = pending.candidate;
+            if (change.operation !== "create")
+                continue;
+            const id = stableId(`pending:${pending.pendingId}`, 0, change);
+            const existing = entries.find((entry) => entry.id === id);
+            if (existing !== undefined) {
+                resolvedPendingIds.add(pending.pendingId);
+                continue;
+            }
+            const duplicate = entries.find((entry) => (entry.status === "active" || entry.status === "pinned")
+                && (normalize(entry.title) === normalize(change.title)
+                    || normalize(entry.summary) === normalize(change.summary)));
+            if (duplicate !== undefined) {
+                const duplicatePath = resolve(input.agentDir, duplicate.file);
+                const duplicateBody = readNoteBody(noteUpdates.get(duplicatePath) ?? await readNote(duplicatePath), duplicate.id);
+                if (duplicateBody === change.detailBody)
+                    resolvedPendingIds.add(pending.pendingId);
+                continue;
+            }
+            const entry = entryFromChange(change, id, 1, "active");
+            const candidateEntries = [...entries, entry];
+            const allowEvictionForPending = change.priority === "high";
+            const projection = projectIndex(memory, candidateEntries, allowEvictionForPending ? pinnedIds(entries) : activeOrPinnedIds(entries));
+            if (allowEvictionForPending)
+                allowActiveEviction = true;
+            if (projection.omittedIds.includes(id))
+                continue;
+            const notePath = resolve(input.agentDir, entry.file);
+            if (!isWithin(resolve(input.agentDir, "notes"), notePath))
+                throw new Error("local_memory_note_path_invalid");
+            const previous = noteUpdates.get(notePath) ?? await readNote(notePath);
+            const replacement = noteSection(id, 1, change.title, change.detailBody);
+            const existingSection = replaceNote(previous, id, replacement);
+            const next = existingSection ?? `${previous.trimEnd()}${previous.trimEnd() ? "\n\n" : ""}${replacement}`;
+            noteUpdates.set(notePath, next);
+            entries = candidateEntries;
+            createdIds.push(id);
+            resolvedPendingIds.add(pending.pendingId);
+        }
+        let finalProjection = projectIndex(memory, entries, allowActiveEviction ? pinnedIds(entries) : activeOrPinnedIds(entries));
+        if (finalProjection.reason !== null
+            && (!allowActiveEviction || finalProjection.reason === "index_over_budget_pinned")) {
             throw new Error(finalProjection.reason);
+        }
+        if (allowActiveEviction) {
+            const omittedActiveEntries = finalProjection.omittedIds
+                .map((id) => entries.find((entry) => entry.id === id))
+                .filter((entry) => entry?.status === "active");
+            for (const entry of omittedActiveEntries) {
+                const notePath = resolve(input.agentDir, entry.file);
+                const content = noteUpdates.get(notePath) ?? await readNote(notePath);
+                const detailBody = readNoteBody(content, entry.id);
+                const change = detailBody === null ? null : archivedChange(entry, detailBody);
+                if (change === null)
+                    throw new Error("local_memory_note_anchor_missing");
+                const pendingId = `pending-${stableId(`evicted:${executionId}`, 0, change).slice("mem_".length)}`;
+                pendingCandidates.push({
+                    schemaVersion: 1,
+                    pendingId,
+                    createdAt: new Date().toISOString(),
+                    reason: "index_over_budget",
+                    source: { executionId, pruneTraceId: input.pruneTraceId ?? null },
+                    candidate: change,
+                });
+                deferredIds.push(pendingId);
+                entries = entries.map((item) => item.id === entry.id ? { ...item, status: "archived" } : item);
+            }
+            finalProjection = projectIndex(memory, entries, pinnedIds(entries));
+            if (finalProjection.reason !== null)
+                throw new Error(finalProjection.reason);
+        }
         for (const candidate of pendingCandidates)
             await persistPendingMemoryCandidate({ agentDir: input.agentDir, candidate });
         for (const [path, content] of noteUpdates)
             await atomicWrite(path, content);
         if (noteUpdates.size > 0 || statusChangedIds.length > 0)
             await atomicWrite(memoryPath, finalProjection.memory);
+        for (const pendingId of resolvedPendingIds) {
+            await removePendingMemoryCandidate({ agentDir: input.agentDir, pendingId });
+        }
         return {
             createdIds,
             updatedIds,

package/dist/main.js

@@ -24,7 +24,7 @@ import { formatDaemonStartupError } from "./daemon-startup-error.js";
 import { assertManagedServiceStartup } from "./managed-service-startup.js";
 import { daemonGlobalInstallation } from "./daemon-installation.js";
 import { acquireDaemonInstallationLease, runWithDaemonInstallationLease, } from "./daemon-installation-lease.js";
-import { loadStorageRuntime } from "./storage-runtime.js";
+import { createStorageRuntimeOwnershipBinding, loadStorageRuntime } from "./storage-runtime.js";
 import { readStorageMigrationReceipt } from "./storage-migration-controller.js";
 import { storageMigrationStatusReplay } from "./storage-status-replay.js";
 import { runStorageWorkerCommand } from "./storage-worker-command.js";
@@ -160,6 +160,9 @@ async function main() {
                 ...(process.getuid === undefined ? {} : { uid: process.getuid() }),
                 environment: process.env,
             });
+        const targetStorageBinding = storageRuntime === null
+            ? null
+            : createStorageRuntimeOwnershipBinding(storageRuntime);
         const targetConfirmation = storageRuntime?.identity.storageMigrationId === undefined
             ? null
             : createStorageTargetConfirmationHandler({
@@ -172,7 +175,8 @@ async function main() {
             ? {
                 ready: false,
                 statusOutboxPath: join(storageRuntime.local.stateRoot, "storage-status-outbox.json"),
-                identity: storageRuntime.identity,
+                identity: targetStorageBinding.identity,
+                bindServerIdentity: targetStorageBinding.bind,
                 ...(targetConfirmation === null ? {} : { confirm: targetConfirmation.handle }),
                 ...(storageRuntime.identity.storageMigrationId === undefined ? {} : {
                     replayStatus: async (send) => {

package/dist/project-skills/capability.js

@@ -0,0 +1,109 @@
+import { PROJECT_SKILLS_CAPABILITY, PROJECT_SKILL_PROJECTION_V2_CAPABILITY, } from "./types.js";
+export function projectSkillV2RolloutReady(platform, readiness) {
+    const platformReady = platform === "darwin"
+        || platform === "linux"
+        || (platform === "win32" && readiness.nativeWindowsSmokePassed);
+    return platformReady
+        && readiness.runtimeRootStorePrimitiveReady
+        && readiness.runtimeRootStoreRecoveryReady
+        && readiness.leaseRecoveryReady
+        && readiness.controllerReady
+        && readiness.executionHandlerReady
+        && readiness.codexAdapterReady
+        && readiness.claudeAdapterReady;
+}
+export function effectiveProjectSkillCapabilities(capabilities, projectSkillsReady, projectSkillV2Ready) {
+    const projectSkillCapabilitiesReady = projectSkillsReady && projectSkillV2Ready;
+    if (!projectSkillCapabilitiesReady
+        && !capabilities.includes(PROJECT_SKILLS_CAPABILITY)
+        && !capabilities.includes(PROJECT_SKILL_PROJECTION_V2_CAPABILITY)
+        && Object.isFrozen(capabilities))
+        return capabilities;
+    const filtered = capabilities.filter((capability) => capability !== PROJECT_SKILL_PROJECTION_V2_CAPABILITY
+        && (projectSkillCapabilitiesReady || capability !== PROJECT_SKILLS_CAPABILITY));
+    if (!projectSkillCapabilitiesReady || !filtered.includes(PROJECT_SKILLS_CAPABILITY)) {
+        return Object.freeze(filtered);
+    }
+    const v1Index = filtered.indexOf(PROJECT_SKILLS_CAPABILITY);
+    return Object.freeze([
+        ...filtered.slice(0, v1Index + 1),
+        PROJECT_SKILL_PROJECTION_V2_CAPABILITY,
+        ...filtered.slice(v1Index + 1),
+    ]);
+}
+export function withProjectSkillCapabilityStatus(value, status) {
+    return {
+        ...value,
+        projectSkillsStatus: status,
+        capabilities: status === "ready"
+            ? value.capabilities
+            : effectiveProjectSkillCapabilities(value.capabilities, false, false),
+    };
+}
+const settleReadinessGate = async (operation) => {
+    try {
+        return await operation() === true;
+    }
+    catch {
+        return false;
+    }
+};
+export async function createProjectSkillConnectionCapabilitySnapshot(input) {
+    const runtimeRootStorePrimitiveReady = await settleReadinessGate(input.probeRuntimeRootStorePrimitive);
+    const controllerReady = await settleReadinessGate(input.initializeController);
+    const recoveryReady = await settleReadinessGate(input.recoverRuntimeRootsAndLeases);
+    const readiness = Object.freeze({
+        runtimeRootStorePrimitiveReady,
+        runtimeRootStoreRecoveryReady: recoveryReady,
+        leaseRecoveryReady: recoveryReady,
+        controllerReady,
+        executionHandlerReady: true,
+        codexAdapterReady: true,
+        claudeAdapterReady: true,
+        nativeWindowsSmokePassed: false,
+    });
+    const projectSkillsReady = projectSkillV2RolloutReady(input.platform, readiness);
+    return Object.freeze({
+        capabilities: effectiveProjectSkillCapabilities(input.baseCapabilities, projectSkillsReady, projectSkillsReady),
+        projectSkillsReady,
+        readiness,
+    });
+}
+export async function prepareProjectSkillConnectionCapabilities(input) {
+    const snapshot = await createProjectSkillConnectionCapabilitySnapshot({
+        ...input,
+        baseCapabilities: [...input.baseCapabilities, ...await input.additionalCapabilities()],
+    });
+    input.applyReadiness(snapshot.projectSkillsReady);
+    return snapshot.capabilities;
+}
+export function createProjectSkillControllerReadiness(input) {
+    let status = "initializing";
+    let initialization = null;
+    const ensure = () => {
+        if (status === "ready")
+            return Promise.resolve(true);
+        if (initialization !== null)
+            return initialization;
+        status = "initializing";
+        const attempt = input.initialize().then(() => {
+            status = "ready";
+            return true;
+        }, (error) => {
+            status = "unavailable";
+            input.onUnavailable(error);
+            return false;
+        }).finally(() => {
+            if (initialization === attempt)
+                initialization = null;
+            input.onSettled();
+        });
+        initialization = attempt;
+        return attempt;
+    };
+    return Object.freeze({
+        status: () => status,
+        ensure,
+        applyPreflight: (ready) => { status = ready ? "ready" : "unavailable"; },
+    });
+}

package/dist/project-skills/controller-convergence.js

@@ -0,0 +1,57 @@
+import { ProjectProjectionError, } from "./reconciler.js";
+export const MAX_REMEMBERED_PROJECT_SKILL_AGENTS = 64;
+const compareBinary = (left, right) => {
+    if (left < right)
+        return -1;
+    if (left > right)
+        return 1;
+    return 0;
+};
+const copySnapshot = (snapshot) => Object.freeze({
+    bindings: Object.freeze(snapshot.bindings.map((binding) => Object.freeze({ ...binding }))),
+    generation: snapshot.generation,
+});
+export function createProjectSkillSnapshotEpoch(maxEntries = MAX_REMEMBERED_PROJECT_SKILL_AGENTS) {
+    if (!Number.isSafeInteger(maxEntries) || maxEntries < 1) {
+        throw new ProjectProjectionError("skill_projection_failed");
+    }
+    const snapshots = new Map();
+    return Object.freeze({
+        begin() {
+            snapshots.clear();
+        },
+        remember(handle, snapshot) {
+            const previous = snapshots.get(handle);
+            if (previous !== undefined && snapshot.generation < previous.generation)
+                return;
+            if (previous === undefined && snapshots.size >= maxEntries) {
+                throw new ProjectProjectionError("skill_projection_failed");
+            }
+            snapshots.set(handle, copySnapshot(snapshot));
+        },
+        forget(handle) {
+            snapshots.delete(handle);
+        },
+        entries() {
+            return Object.freeze([...snapshots.entries()]
+                .sort(([left], [right]) => compareBinary(left, right))
+                .map(([handle, snapshot]) => Object.freeze([handle, copySnapshot(snapshot)])));
+        },
+    });
+}
+const stableErrorCode = (reason) => reason?.code === "skill_projection_snapshot_corrupt"
+    ? "skill_projection_snapshot_corrupt"
+    : "skill_projection_failed";
+export function toPathPrivateConvergenceResults(entries, results) {
+    return Object.freeze(entries.map(([handle], index) => {
+        const result = results[index];
+        if (result?.status === "fulfilled") {
+            return Object.freeze({ handle, status: "fulfilled" });
+        }
+        return Object.freeze({
+            handle,
+            status: "rejected",
+            errorCode: stableErrorCode(result?.reason),
+        });
+    }));
+}