@nowcrew/daemon 0.6.101-beta.1 → 0.6.101-beta.3

package/dist/local-memory/runtime.js

@@ -2,12 +2,6 @@ import { createHash } from "node:crypto";
 import { constants } from "node:fs";
 import { lstat, mkdir, open, readFile, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
-import { applyMemoryMigration, prepareMemoryMigration, recoverMemoryMigration } from "./migration-store.js";
-import { MigrationStateSchema } from "./migration-schema.js";
-import { detectLocalMemoryStorageVersion } from "./storage-format.js";
-import { isLocalMemoryInitializationIdentity, localMemoryInitializationIdentity } from "./initialization-identity.js";
-import { inventory } from "./migration-io.js";
-import { initializeExactWorkspaceSeed } from "./migration-plan.js";
 import { applyLocalMemoryResult, parseLocalMemoryResult } from "./write.js";
 import { verifyWorkLogSource } from "./work-log.js";
 export function isLocalMemoryV2Eligible(input) {
@@ -18,8 +12,7 @@ export function isLocalMemoryV2Eligible(input) {
     return input.enabledForHandle && input.memoryPrune;
 }
 const LOCAL_MEMORY_V2_MARKER = "v2-enabled";
-const DELIVERY_EVIDENCE_PATTERN = /release(?:[-_.]\S+)?\.md|publish(?:[-_.]\S+)?\.md|build(?:[-_.]\S+)?\.md|deploy(?:[-_.]\S+)?\.md|artifact(?:[-_.]\S+)?\.md|registry|manifest|changelog|tarball|sha256|发布|构建|打包|发版|注册表|交付/iu;
-async function writeLocalMemoryV2Marker(agentDir) {
+export async function initializeLocalMemoryV2(agentDir) {
     const crewDir = join(agentDir, ".crew");
     const memoryDir = join(crewDir, "memory");
     await mkdir(crewDir, { recursive: true });
@@ -38,151 +31,24 @@ async function writeLocalMemoryV2Marker(agentDir) {
             throw error;
     }
 }
-function initializedIntent(identity, state) {
-    return {
-        ...identity,
-        kind: "server_write_intent",
-        sourceDigest: state.sourceDigest,
-        planDigest: state.planDigest,
-        intentVersion: 1,
-        // New-Agent initialization is derived from the exact pristine seed.  Keep
-        // the receipt deterministic so a crash between intent publication and the
-        // mutable state update can be retried without creating a conflicting fact.
-        confirmedAt: "1970-01-01T00:00:00.000Z",
-    };
-}
-/**
- * Initialize a pristine new Agent through the same journaled schema2
- * publication path used by migration.  The marker is written only after the
- * committed catalog and state have both been verified.
- */
-async function initializeLocalMemoryV2WithBinding(agentDir, agentId, binding) {
-    const identity = await localMemoryInitializationIdentity(agentDir, agentId, binding);
-    let state = await prepareMemoryMigration({
-        agentDir,
-        identity,
-        serverHistory: { kind: "none", isNewAgent: true },
-    });
-    if (state.origin !== "initialized")
-        throw new Error("local_memory_v2_initialization_source_invalid");
-    if (state.phase === "prepared") {
-        state = await applyMemoryMigration({
-            agentDir,
-            identity,
-            intentReceipt: initializedIntent(identity, state),
-        });
-    }
-    else if (state.phase === "applying" || state.phase === "repair_required") {
-        state = await recoverMemoryMigration({
-            agentDir,
-            identity,
-            intentReceipt: state.intentReceipt ?? initializedIntent(identity, state),
-            stoppedReceipt: {
-                kind: "migration_process_stopped",
-                migrationId: identity.migrationId,
-                machineId: identity.machineId,
-                executionId: identity.executionId,
-                ownerIdentity: identity.ownerIdentity,
-                pid: null,
-                stoppedAt: new Date().toISOString(),
-                proof: "journal_reconciled",
-            },
-            cancelled: false,
-        });
-    }
-    const memory = await readFile(join(agentDir, "MEMORY.md"), "utf8");
-    if (state.phase !== "committed" || state.origin !== "initialized" || state.storageVersion !== 2
-        || detectLocalMemoryStorageVersion(memory) !== 2) {
-        throw new Error("local_memory_v2_initialization_incomplete");
-    }
-    await writeLocalMemoryV2Marker(agentDir);
-}
-/** Fresh initialization requires the identity from the authenticated ready frame. */
-export function initializeLocalMemoryV2(agentDir, agentId, binding) {
-    return initializeLocalMemoryV2WithBinding(agentDir, agentId, binding);
-}
-export async function initializeLocalMemoryV2ForWorkspace(workspace, enabledForHandle, agentId, binding) {
+export async function initializeLocalMemoryV2ForWorkspace(workspace, enabledForHandle) {
     const initialized = workspace.localMemoryV2Initialized === true;
-    if (initialized)
-        return true;
-    // Real workspaces always report this boolean.  Keep partial/mock workspace
-    // callers side-effect free instead of probing an unrelated filesystem path.
-    if (workspace.localMemoryV2Initialized !== false)
-        return false;
-    let resumable = false;
-    let effectiveBinding = binding;
+    if (!enabledForHandle || initialized || workspace.localMemoryV2Initialized !== false
+        || workspace.agentHomePreexisted === true || workspace.memorySeedCreated !== true)
+        return initialized;
     try {
-        const state = MigrationStateSchema.parse(JSON.parse(await readFile(join(workspace.dir, ".crew", "memory", "migration.v1.json"), "utf8")));
-        const identity = await localMemoryInitializationIdentity(workspace.dir, agentId, binding);
-        const legacyIdentity = binding === undefined
-            ? identity
-            : await localMemoryInitializationIdentity(workspace.dir, agentId);
-        resumable = state.origin === "initialized"
-            && state.phase !== "rolled_back"
-            && (isLocalMemoryInitializationIdentity(state.identity, identity)
-                || isLocalMemoryInitializationIdentity(state.identity, legacyIdentity));
-        if (resumable && isLocalMemoryInitializationIdentity(state.identity, legacyIdentity))
-            effectiveBinding = undefined;
-    }
-    catch (error) {
-        if (error.code !== "ENOENT")
-            throw error;
-        try {
-            const migrations = await lstat(join(workspace.dir, ".crew", "memory", "migrations"));
-            if (!migrations.isDirectory() || migrations.isSymbolicLink()) {
-                throw new Error("local_memory_v2_initialization_residue_invalid");
-            }
-            const identity = await localMemoryInitializationIdentity(workspace.dir, agentId, binding);
-            const legacyIdentity = binding === undefined
-                ? identity
-                : await localMemoryInitializationIdentity(workspace.dir, agentId);
-            let operationIdentity = identity;
-            const operation = await lstat(join(workspace.dir, ".crew", "memory", "migrations", identity.migrationId))
-                .catch(async (error) => {
-                if (error.code !== "ENOENT" || identity.migrationId === legacyIdentity.migrationId)
-                    throw error;
-                operationIdentity = legacyIdentity;
-                return lstat(join(workspace.dir, ".crew", "memory", "migrations", legacyIdentity.migrationId));
-            });
-            if (!operation.isDirectory() || operation.isSymbolicLink()) {
-                throw new Error("local_memory_v2_initialization_residue_invalid");
-            }
-            const current = await inventory(workspace.dir);
-            const memory = current.files.get("MEMORY.md");
-            resumable = current.files.size === 1 && memory !== undefined
-                && current.directories.every(path => path === "notes" || path === ".crew/memory/pending")
-                && initializeExactWorkspaceSeed(memory) !== null;
-            if (resumable && operationIdentity.migrationId === legacyIdentity.migrationId)
-                effectiveBinding = undefined;
-        }
-        catch (residueError) {
-            if (residueError.code !== "ENOENT")
-                throw residueError;
-        }
+        await initializeLocalMemoryV2(workspace.dir);
+        return true;
     }
-    const pristineFirstInitialization = enabledForHandle
-        && workspace.localMemoryV2Initialized === false
-        && workspace.agentHomePreexisted !== true
-        && workspace.memorySeedCreated === true;
-    if (!resumable && !pristineFirstInitialization)
-        return false;
-    // Never create another unbound sentinel. Undefined is retained solely to
-    // finish a pre-upgrade journal already proven above.
-    if (!resumable && effectiveBinding === undefined)
+    catch {
         return false;
-    await initializeLocalMemoryV2WithBinding(workspace.dir, agentId, effectiveBinding);
-    return true;
+    }
 }
 export function localMemoryResultPath(runDir, executionId) {
     const suffix = createHash("sha256").update(executionId, "utf8").digest("hex").slice(0, 32);
     return join(runDir, `.memory-result.v1-${suffix}.json`);
 }
-export function renderLocalMemoryResultInstructions(resultPath, storageVersion = 1, migrationDeferred = false) {
-    const storagePolicy = migrationDeferred
-        ? "该 Agent 的旧记忆仍在迁移审阅中。本轮只允许提交新的 create 候选；daemon 会把候选原子保存到 .crew/memory/pending/，reason=legacy_requires_migration，并提供 search-pending/read-pending 查询。候选不会进入 active，也不会自动注入普通上下文；更新、替代和 statusChanges 必须留待迁移完成后按当前 V2 ID/revision/hash 重新核对。旧 MEMORY.md、notes 和已有 active/pending 保持不变。"
-        : storageVersion === 2
-            ? "完整目录保存在 MEMORY.md，模型只看到有界预览；未展示记录仍然有效。涉及旧规则时先用 crew-memory search 查询完整目录，按当前 ID/revision 更新，不因预览未命中就重复新建。20条预览不是有效记录上限；完整存储超出资源上限会拒绝提交，不得自行删除或降级旧记录。已有 pending 仍是未应用候选，须重新核对授权、重复与版本后通过 changes 申请保存，不因迁移自动生效。"
-            : "daemon 会校验、去重、限制 MEMORY.md 大小，超出索引容量的候选会保存在 pending 归档中。容量暂存的 create 可按需检索参考但不能覆盖现行规则；有空间的后续 proposed 提交可提升。未应用的 update/supersede 不进入普通召回，必须重新核对目标版本后处理。";
+export function renderLocalMemoryResultInstructions(resultPath) {
     return `
 
 ## Structured memory prune (daemon-managed)
@@ -195,18 +61,17 @@ outcome 只允许 no_change、proposed、conflict、failed。新增、更新、
 
 新增记忆的完整合法示例（内容须替换为本任务实际候选）：
 \`\`\`json
-{"schemaVersion":1,"purpose":"memory_prune","baseCatalogRevision":0,"outcome":"proposed","changes":[{"operation":"create","memoryId":null,"baseRevision":null,"supersedesMemoryId":null,"title":"发布验收约定","kind":"procedural","summary":"发布前必须验证回滚步骤。","triggers":["发布","回滚"],"priority":"medium","detailCategory":"project-rules","detailBody":"发布前必须验证回滚步骤，并将验证结果写入发布报告。","reviewAfter":null}],"statusChanges":[],"workLogDisposition":"clear"}
+{"schemaVersion":1,"purpose":"memory_prune","baseCatalogRevision":0,"outcome":"proposed","changes":[{"operation":"create","memoryId":null,"baseRevision":null,"supersedesMemoryId":null,"title":"发布验收约定","kind":"procedural","summary":"发布前必须验证回滚步骤。","triggers":["发布","回滚"],"priority":"medium","detailCategory":"project-rules","detailBody":"发布前必须验证回滚步骤，并将验证结果写入发布报告。","reviewAfter":null}],"statusChanges":[]}
 \`\`\`
 
 没有需要变更的记忆时：
 \`\`\`json
-{"schemaVersion":1,"purpose":"memory_prune","baseCatalogRevision":0,"outcome":"no_change","changes":[],"statusChanges":[],"workLogDisposition":"clear"}
+{"schemaVersion":1,"purpose":"memory_prune","baseCatalogRevision":0,"outcome":"no_change","changes":[],"statusChanges":[]}
 \`\`\`
 
 每个 changes 项须保留示例中的全部字段。operation=create|update|supersede；kind=procedural|semantic|episodic|preference；priority=high|medium|low；detailCategory=preferences|project-rules|testing|debugging|git|incidents|lessons。create 的 memoryId/baseRevision/supersedesMemoryId 必须为 null；update 按现有索引填写 memoryId/baseRevision，supersedesMemoryId 为 null；supersede 填 supersedesMemoryId/baseRevision，memoryId 为 null。
-只提交可复用、与本次任务明确相关的少量候选；不要写入凭证、token、隐私或内部控制标记。${storagePolicy}
-发布、构建、打包、发版和注册表交付证据属于任务产物，不是长期记忆；不要直接创建或更新 notes/release.md 或 notes/release-*.md、notes/publish.md 或 notes/publish-*.md、notes/build.md 或 notes/build-*.md、notes/deploy.md 或 notes/deploy-*.md、notes/artifact.md 或 notes/artifact-*.md，也不要把 release/changelog/manifest 证据复制进 MEMORY.md 或 notes。只有明确授权且内容本身是跨任务可复用的流程规则时，才提交 project-rules 候选。
-写入候选文件只表示提交候选，不能提前宣称已经记住或规则已经更新；daemon 在本轮结束后才处理，候选持久化与进入有效索引也不是同一结果。默认保留 $CREW_TASK_LOG；只有确认没有交付证据且所有后置条件满足时，才在 JSON 中显式填写 workLogDisposition="clear"。缺少该字段或填写 preserve 时，daemon 保留日志；daemon 发现日志包含交付证据关键词时会保守保留，即使结果填写 clear；失败、冲突或证据不完整时不得清理。
+只提交可复用、与本次任务明确相关的少量候选；不要写入凭证、token、隐私或内部控制标记。daemon 会校验、去重、限制 MEMORY.md 大小，超出索引容量的候选会保存在 pending 归档中。容量暂存的 create 可按需检索参考但不能覆盖现行规则；有空间的后续 proposed 提交可提升。未应用的 update/supersede 不进入普通召回，必须重新核对目标版本后处理。
+写入候选文件只表示提交候选，不能提前宣称已经记住或规则已经更新；daemon 在本轮结束后才处理，候选持久化与进入有效索引也不是同一结果。本结构化轮次覆盖前文提前清理工作日志的要求：保留 $CREW_TASK_LOG，不要清空或删除；daemon 将在处理成功后清理，失败时保留日志和候选用于排查或重试。
 `;
 }
 /** Prevent ordinary V2 turns from racing the daemon-managed memory writer. */
@@ -216,20 +81,6 @@ export function renderLocalMemoryV2WriteGuard() {
 ## V2 shared memory write safety
 本节覆盖前文关于普通任务直接更新共享记忆的例外规则。本 Agent 已启用结构化本地记忆 V2。普通任务不得直接编辑共享的 $CREW_HOME/MEMORY.md 或 $CREW_HOME/notes/ 文件；即使用户明确要求记住内容，也只把候选、用户授权和分类理由记录到本任务的 $CREW_TASK_LOG，留给任务结束后的 memory-prune 结构化收尾应用。只有 memory-prune 收尾提示明确要求写入 daemon 提供的 result 文件时，才按该协议提交候选。`;
 }
-async function localMemoryStorageFacts(agentDir) {
-    const memory = await readFile(join(agentDir, "MEMORY.md"), "utf8");
-    const storageVersion = detectLocalMemoryStorageVersion(memory);
-    let committedState = false;
-    try {
-        const state = MigrationStateSchema.parse(JSON.parse(await readFile(join(agentDir, ".crew", "memory", "migration.v1.json"), "utf8")));
-        committedState = state.phase === "committed" && state.storageVersion === 2;
-    }
-    catch (error) {
-        if (error.code !== "ENOENT" && storageVersion === 2)
-            throw error;
-    }
-    return { storageVersion, committedState };
-}
 function workLogFailure(error) {
     const reason = error instanceof Error ? error.message : "";
     return { status: "failed", error: reason === "local_memory_work_log_source_changed"
@@ -247,50 +98,30 @@ export async function commitLocalMemoryResultAfterExit(input) {
             return { status: "missing" };
         return { status: "failed", error: error instanceof Error ? error.message : "read_failed" };
     }
-    let storageBefore;
-    let storageAfter;
-    let applied;
-    let shouldClearWorkLog = false;
     try {
         const result = parseLocalMemoryResult(raw);
         if (result.outcome === "conflict" || result.outcome === "failed") {
             return { status: "failed", error: `local_memory_result_${result.outcome}` };
         }
-        shouldClearWorkLog = result.workLogDisposition === "clear";
         if (input.workLogPath !== undefined) {
             try {
                 await verifyWorkLogSource(input.agentDir, input.workLogPath, input.expectedWorkLogSha256);
-                if (shouldClearWorkLog)
-                    shouldClearWorkLog = !DELIVERY_EVIDENCE_PATTERN.test(await readFile(input.workLogPath, "utf8"));
             }
             catch (error) {
                 return workLogFailure(error);
             }
         }
-        storageBefore = await localMemoryStorageFacts(input.agentDir);
-        if (input.requiredStorageVersion === 2
-            && (storageBefore.storageVersion !== 2 || !storageBefore.committedState)) {
-            return { status: "failed", error: "local_memory_v2_state_invalid_before_commit" };
-        }
-        applied = await applyLocalMemoryResult({
+        await applyLocalMemoryResult({
             agentDir: input.agentDir,
             result,
             executionId: input.executionId,
             pruneTraceId: input.pruneTraceId,
-            ...(input.writerCapabilities === undefined ? {} : { writerCapabilities: input.writerCapabilities }),
-            ...(input.requiredStorageVersion === undefined ? {} : { requiredStorageVersion: input.requiredStorageVersion }),
-            ...(input.migrationDeferredPending ? { migrationDeferredPending: true } : {}),
         });
-        storageAfter = await localMemoryStorageFacts(input.agentDir);
-        if (input.requiredStorageVersion === 2
-            && (storageAfter.storageVersion !== 2 || !storageAfter.committedState)) {
-            return { status: "failed", error: "local_memory_v2_state_invalid_after_commit" };
-        }
     }
     catch (error) {
         return { status: "failed", error: error instanceof Error ? error.message : "apply_failed" };
     }
-    if (input.workLogPath !== undefined && shouldClearWorkLog) {
+    if (input.workLogPath !== undefined) {
         try {
             const before = await verifyWorkLogSource(input.agentDir, input.workLogPath, input.expectedWorkLogSha256);
             const handle = await open(input.workLogPath, constants.O_WRONLY | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0));
@@ -316,10 +147,5 @@ export async function commitLocalMemoryResultAfterExit(input) {
     catch {
         return { status: "failed", error: "local_memory_result_cleanup_failed" };
     }
-    return { status: "applied", storageVersionBefore: storageBefore.storageVersion,
-        storageVersionAfter: storageAfter.storageVersion, committedState: storageAfter.committedState,
-        createdIds: applied.createdIds, updatedIds: applied.updatedIds,
-        statusChangedIds: applied.statusChangedIds, pendingIds: applied.pendingIds,
-        ...(input.migrationDeferredPending
-            ? { pendingReason: "legacy_requires_migration" } : {}) };
+    return { status: "applied" };
 }