@basou/cli 0.62.0 → 0.64.0

package/dist/index.js

@@ -136,11 +136,13 @@ import {
   acquireLock,
   appendChainedEventLocked,
   assertBasouRootSafe,
+  assertLockStoreSafe,
   assertSessionDirSafe,
   basouPaths,
   EVENT_SCHEMA_VERSION,
   enumerateApprovals,
   findErrorCode,
+  inspectApprovalEntry,
   inspectSessionEntry,
   isLazyExpired,
   LOCAL_CLI_EVENT_SOURCE,
@@ -192,6 +194,11 @@ async function doRunApprovalList(options, ctx) {
   const paths = basouPaths(repositoryRoot);
   await assertWorkspaceInitialized(paths.root);
   const ids = await enumerateApprovals(paths);
+  for (const entry of ids.unfollowed) {
+    console.error(
+      `Skipped ${entry.id} in ${entry.location}: not a file (a symlink or a directory is not followed)`
+    );
+  }
   const now = /* @__PURE__ */ new Date();
   const records = [];
   const resolvedSet = new Set(ids.resolved);
@@ -259,7 +266,8 @@ async function doRunApprovalShow(idInput, options, ctx) {
   const repositoryRoot = await resolveRepositoryRootForApproval(cwd, "show");
   const paths = basouPaths(repositoryRoot);
   await assertWorkspaceInitialized(paths.root);
-  const { id } = await resolveApprovalId(paths, idInput);
+  const { id, unfollowed } = await resolveApprovalId(paths, idInput);
+  for (const entry2 of unfollowed) console.error(`Warning: ${describeUnfollowed(entry2)}`);
   const loaded = await loadApproval(paths, id);
   if (loaded === null) {
     throw new Error(`Approval not found: ${idInput}`);
@@ -328,6 +336,15 @@ async function doRunApprovalResolve(idInput, options, ctx, decision) {
   if (location === "resolved") {
     throw new Error(`Approval already resolved: ${idInput}`);
   }
+  const resolvedEntry = await inspectApprovalEntry(paths, "resolved", id);
+  if (resolvedEntry === "file") {
+    throw new Error(`Approval already resolved: ${idInput}`);
+  }
+  if (resolvedEntry !== "missing") {
+    throw new Error(
+      `Approval ${id} cannot be resolved: its entry in resolved is not a file (a symlink or a directory is not followed)`
+    );
+  }
   const pendingPath = join(paths.approvals.pending, `${id}.yaml`);
   let pendingRaw;
   try {
@@ -354,6 +371,7 @@ async function doRunApprovalResolve(idInput, options, ctx, decision) {
   const now = /* @__PURE__ */ new Date();
   const occurredAt = now.toISOString();
   const eventId = prefixedUlid("evt");
+  await assertLockStoreSafe(paths);
   try {
     await mkdir(paths.approvals.resolved, { recursive: true });
   } catch (error) {
@@ -469,20 +487,31 @@ async function resolveApprovalId(paths, input) {
     }
     byId.set(id2, "resolved");
   }
-  if (byId.size === 0) {
+  const matched = new Set(byId.keys());
+  for (const entry of enumeration.unfollowed) {
+    if (entry.id.startsWith(normalized)) matched.add(entry.id);
+  }
+  if (matched.size === 0) {
     throw new Error(`Approval not found: ${input}`);
   }
-  if (byId.size > 1) {
+  if (matched.size > 1) {
     throw new Error(
-      `Ambiguous approval id '${input}': matched ${byId.size} approvals. Disambiguate with a longer prefix.`
+      `Ambiguous approval id '${input}': matched ${matched.size} approvals. Disambiguate with a longer prefix.`
     );
   }
-  const first = byId.entries().next().value;
-  if (first === void 0) {
+  const id = matched.values().next().value;
+  if (id === void 0) {
     throw new Error(`Approval not found: ${input}`);
   }
-  const [id, location] = first;
-  return { id, location };
+  const location = byId.get(id);
+  if (location === void 0) {
+    throw new Error(`Approval ${id} is not a file; a symlink or a directory there is not followed`);
+  }
+  const unfollowed = enumeration.unfollowed.filter((entry) => entry.id === id);
+  return { id, location, unfollowed };
+}
+function describeUnfollowed(entry) {
+  return `${entry.id} in ${entry.location} is not a file (a symlink or a directory is not followed)`;
 }
 function isApprovalEvent(ev) {
   return ev.type === "approval_requested" || ev.type === "approval_approved" || ev.type === "approval_rejected" || ev.type === "approval_expired";
@@ -2076,7 +2105,7 @@ async function assertWorkspaceInitialized3(basouRoot) {
 }
 
 // src/commands/exec.ts
-import { mkdir as mkdir2 } from "fs/promises";
+import { mkdir as mkdir2, rm } from "fs/promises";
 import { homedir as homedir4 } from "os";
 import { join as join6 } from "path";
 import {
@@ -2124,7 +2153,6 @@ async function runExec(command, args, options, ctx = {}) {
   await assertSessionStoreSafe(paths);
   const sessionId = prefixedUlid3("ses");
   const sessionDir = join6(paths.sessions, sessionId);
-  await mkdir2(sessionDir, { recursive: true });
   const appendEvent = ctx.appendEvent ?? (async (_sessionDir, event) => {
     await coreAppendChainedEvent(paths, sessionId, event);
   });
@@ -2138,7 +2166,22 @@ async function runExec(command, args, options, ctx = {}) {
     workspaceId: manifest.workspace.id,
     startedAt
   });
-  await writeYamlFile(sessionYamlPath, session);
+  const initialLock = await acquireLock3(paths, "session", sessionId);
+  try {
+    try {
+      await mkdir2(sessionDir, { recursive: true });
+    } catch (error) {
+      throw new Error("Failed to create session directory", { cause: error });
+    }
+    try {
+      await writeYamlFile(sessionYamlPath, session);
+    } catch (error) {
+      await rm(sessionDir, { recursive: true, force: true }).catch(() => void 0);
+      throw error;
+    }
+  } finally {
+    await initialLock.release();
+  }
   await appendEvent(sessionDir, {
     schema_version: EVENT_SCHEMA_VERSION3,
     type: "session_started",
@@ -2920,6 +2963,7 @@ async function loadHostsConfig(configPath = DEFAULT_HOSTS_CONFIG_PATH) {
 // src/lib/provenance-actions.ts
 import {
   assertApprovalStoreSafe,
+  assertLockStoreSafe as assertLockStoreSafe3,
   assertTaskStoreSafe,
   readMarkdownFile as readMarkdownFile5,
   renderDecisions as renderDecisions2,
@@ -2931,13 +2975,14 @@ import {
 
 // src/commands/import.ts
 import { createReadStream } from "fs";
-import { readdir, readFile as readFile2, rm, stat as stat3 } from "fs/promises";
+import { readdir, readFile as readFile2, rm as rm2, stat as stat3 } from "fs/promises";
 import { homedir as homedir7 } from "os";
 import { basename as basename4, dirname as dirname3, join as join9, resolve as resolve6 } from "path";
 import { createInterface } from "readline";
 import {
   AGENT_INFRA_DIRS as AGENT_INFRA_DIRS2,
   assertBasouRootSafe as assertBasouRootSafe6,
+  assertLockStoreSafe as assertLockStoreSafe2,
   assertSessionStoreSafe as assertSessionStoreSafe2,
   basouPaths as basouPaths8,
   CLAUDE_IMPORT_SOURCE,
@@ -3111,6 +3156,7 @@ async function resolveImportTarget(ctx) {
 }
 async function importDerivedSessions(paths, manifest, options, sourceKind, candidates, projectPaths, boundaryDeclared) {
   await assertSessionStoreSafe2(paths);
+  if (options.dryRun !== true) await assertLockStoreSafe2(paths);
   const { byExternalId: existingByExternalId, notDirectories } = await loadExistingByExternalId(
     paths,
     sourceKind
@@ -3202,7 +3248,7 @@ async function importDerivedSessions(paths, manifest, options, sourceKind, candi
     if (priors.length > 0 && options.force === true) {
       if (options.dryRun !== true) {
         for (const { sessionId } of priors) {
-          await rm(join9(paths.sessions, sessionId), { recursive: true, force: true });
+          await rm2(join9(paths.sessions, sessionId), { recursive: true, force: true });
         }
       }
       counts.replaced++;
@@ -3692,6 +3738,7 @@ async function refreshAll(args) {
   if (!dryRun) {
     await assertTaskStoreSafe(paths);
     await assertApprovalStoreSafe(paths);
+    await assertLockStoreSafe3(paths);
   }
   const claudeCode = await importClaudeCode(options, ctx);
   const codex = await importCodex(options, ctx);
@@ -8714,6 +8761,7 @@ import { homedir as homedir10 } from "os";
 import { join as join13 } from "path";
 import {
   assertApprovalStoreSafe as assertApprovalStoreSafe2,
+  assertLockStoreSafe as assertLockStoreSafe4,
   assertTaskStoreSafe as assertTaskStoreSafe2,
   findErrorCode as findErrorCode8
 } from "@basou/core";
@@ -8778,6 +8826,7 @@ function hms(date) {
 async function runImports(deps) {
   await assertTaskStoreSafe2(deps.paths);
   await assertApprovalStoreSafe2(deps.paths);
+  await assertLockStoreSafe4(deps.paths);
   const claude = await importClaudeCode(deps.importOptions, deps.ctx);
   const codex = await importCodex(deps.importOptions, deps.ctx);
   return { claude, codex, changed: changedCount(claude) + changedCount(codex) };
@@ -9599,7 +9648,7 @@ function unattachedLines(u) {
 }
 
 // src/commands/run.ts
-import { mkdir as mkdir3, readFile as readFile7 } from "fs/promises";
+import { mkdir as mkdir3, readFile as readFile7, rm as rm3 } from "fs/promises";
 import { homedir as homedir12 } from "os";
 import { join as join14 } from "path";
 import {
@@ -9684,7 +9733,6 @@ async function runTrackedTool(args, options, ctx, adapter) {
   await assertSessionStoreSafe3(paths);
   const sessionId = prefixedUlid4("ses");
   const sessionDir = join14(paths.sessions, sessionId);
-  await mkdir3(sessionDir, { recursive: true });
   const appendEvent = ctx.appendEvent ?? (async (_sessionDir, event) => {
     await coreAppendChainedEvent2(paths, sessionId, event);
   });
@@ -9699,7 +9747,22 @@ async function runTrackedTool(args, options, ctx, adapter) {
     startedAt,
     source: adapter.metadata
   });
-  await writeYamlFile2(sessionYamlPath, session);
+  const initialLock = await acquireLock5(paths, "session", sessionId);
+  try {
+    try {
+      await mkdir3(sessionDir, { recursive: true });
+    } catch (error) {
+      throw new Error("Failed to create session directory", { cause: error });
+    }
+    try {
+      await writeYamlFile2(sessionYamlPath, session);
+    } catch (error) {
+      await rm3(sessionDir, { recursive: true, force: true }).catch(() => void 0);
+      throw error;
+    }
+  } finally {
+    await initialLock.release();
+  }
   await appendEvent(sessionDir, {
     schema_version: EVENT_SCHEMA_VERSION5,
     type: "session_started",
@@ -10068,6 +10131,7 @@ import {
   acquireLock as acquireLock6,
   appendEventToExistingSession as appendEventToExistingSession3,
   assertBasouRootSafe as assertBasouRootSafe13,
+  assertLockStoreSafe as assertLockStoreSafe5,
   basouPaths as basouPaths18,
   displayPath as displayPath3,
   EVENT_SCHEMA_VERSION as EVENT_SCHEMA_VERSION6,
@@ -10703,6 +10767,7 @@ async function doRunSessionRechain(options, ctx) {
   const repositoryRoot = await resolveRepositoryRootForSession(cwd, "rechain");
   const paths = basouPaths18(repositoryRoot);
   await assertWorkspaceInitialized11(paths.root);
+  await assertLockStoreSafe5(paths);
   const sessionIds = options.session !== void 0 ? [await resolveSessionId3(paths, options.session)] : await enumerateAllSessionNames(paths);
   const dryRun = options.dryRun === true;
   const rows = [];
@@ -10991,6 +11056,7 @@ import { join as join16 } from "path";
 import {
   archiveTask,
   assertBasouRootSafe as assertBasouRootSafe16,
+  assertLockStoreSafe as assertLockStoreSafe6,
   basouPaths as basouPaths21,
   createTaskWithEvent,
   deleteTask,
@@ -11528,6 +11594,7 @@ async function doRunTaskReconcile(options, ctx) {
   const repositoryRoot = await resolveRepositoryRootForTask(cwd, "reconcile");
   const paths = basouPaths21(repositoryRoot);
   await assertWorkspaceInitialized13(paths.root);
+  await assertLockStoreSafe6(paths);
   const manifest = await readManifest13(paths);
   const nowProvider = ctx.nowProvider ?? (() => /* @__PURE__ */ new Date());
   const write = options.write === true;
@@ -14199,7 +14266,7 @@ async function assertWorkspaceInitialized15(basouRoot) {
 function readBuildStamp() {
   if (false) return void 0;
   try {
-    return JSON.parse('{"version":"0.62.0","commit":"5ce774d","committedAt":"2026-10-02T23:27:57+09:00"}');
+    return JSON.parse('{"version":"0.64.0","commit":"1caea85","committedAt":"2026-10-04T11:34:39+09:00"}');
   } catch {
     return void 0;
   }