forgeos 0.1.0-alpha.24 → 0.1.0-alpha.25

package/AGENTS.md

@@ -1,4 +1,4 @@
-// @forge-generated generator=0.1.0-alpha.24 input=1257771517e723f30d9c8c6bdc328f3a9d0bfde1e673d859837f93f0f1bd15c4 content=0d493cf0e41b71cb652d5e0e1b0c1f83d2a1281b748321f0b00f0773ba93074e
+// @forge-generated generator=0.1.0-alpha.25 input=f4bc0a51dfadbdbabe4e7083c29844716f74c2beebcb86ce30e7a70c4f9487b4 content=0d493cf0e41b71cb652d5e0e1b0c1f83d2a1281b748321f0b00f0773ba93074e
 # AGENTS.md
 
 <!-- forge-generated:start -->

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 ## Unreleased
 
+## 0.1.0-alpha.25
+
+### Patch Changes
+
+- Harden DeltaDB and Agent Memory under real `forge dev` concurrency.
+
+  - Stop long-running dev recorders from holding the DeltaDB writer lock between events.
+  - Retry short transient DeltaDB writer conflicts before reporting `FORGE_DELTA_BUSY`.
+  - Keep Codex hook queue checkpoints unchanged when Agent Memory ingest is blocked by a busy DeltaDB writer, then retry safely instead of losing queued events.
+  - Add watcher backoff metadata for lock recovery and document the safe queue/DeltaDB behavior.
+
+- Fix tenant-scope reporting in the generated agent contract and capability map.
+
+  - Match tenant-scoped tables by both authored/camelCase table names and generated SQL snake_case table names.
+  - Report camelCase liveQuery dependencies such as `onboardingTasks` as `tenant` scoped when `tenantScope.json` confirms `tenant_id`.
+  - Add regression coverage for the Team Onboarding style liveQuery/capability-map path.
+
 ## 0.1.0-alpha.24
 
 ### Patch Changes

package/docs/changelog.md

@@ -6,6 +6,19 @@ The canonical source file in the repository is `CHANGELOG.md`.
 
 ## Unreleased
 
+## 0.1.0-alpha.25
+
+- Hardened DeltaDB and Agent Memory for concurrent `forge dev` usage:
+  dev recorders now release the writer lock between events, Agent Memory ingest
+  retries short transient writer conflicts, and queued Codex hook events keep
+  their checkpoint unchanged when DeltaDB is temporarily busy.
+- Fixed tenant-scope reporting in the generated agent contract and capability
+  map for camelCase authored tables such as `onboardingTasks`, so liveQuery
+  dependencies now report `tenant` scope when `tenantScope.json` confirms the
+  table is tenant-scoped.
+- Added regression tests and docs for the DeltaDB lock recovery path and the
+  Team Onboarding style capability-map tenant-scope path.
+
 ## 0.1.0-alpha.24
 
 - Consolidated the public alpha adoption surface: MIT license, package license

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forgeos",
-  "version": "0.1.0-alpha.24",
+  "version": "0.1.0-alpha.25",
   "description": "Agent-native application framework and compiler for building Forge apps without a mandatory dashboard.",
   "type": "module",
   "license": "MIT",

package/src/forge/_generated/releaseManifest.json

@@ -1 +1 @@
-{"defaultProvider":"local","diagnostics":[],"env":{"deployEnv":"FORGE_DEPLOY_ENV","deployId":"FORGE_DEPLOY_ID","publicReleaseId":"NEXT_PUBLIC_FORGE_RELEASE_ID","releaseId":"FORGE_RELEASE_ID"},"gitSha":"unknown","optionalProviders":["local","sentry-compatible","sentry","glitchtip","bugsink","otel","custom"],"packageName":"forgeos","packageVersion":"0.1.0-alpha.24","releaseId":"forgeos@0.1.0-alpha.24+unknown","schemaVersion":"0.1.0"}
+{"defaultProvider":"local","diagnostics":[],"env":{"deployEnv":"FORGE_DEPLOY_ENV","deployId":"FORGE_DEPLOY_ID","publicReleaseId":"NEXT_PUBLIC_FORGE_RELEASE_ID","releaseId":"FORGE_RELEASE_ID"},"gitSha":"unknown","optionalProviders":["local","sentry-compatible","sentry","glitchtip","bugsink","otel","custom"],"packageName":"forgeos","packageVersion":"0.1.0-alpha.25","releaseId":"forgeos@0.1.0-alpha.25+unknown","schemaVersion":"0.1.0"}

package/src/forge/_generated/releaseManifest.ts

@@ -1,4 +1,4 @@
-// @forge-generated generator=0.1.0-alpha.24 input=1257771517e723f30d9c8c6bdc328f3a9d0bfde1e673d859837f93f0f1bd15c4 content=4170e33ff26cbaa55732ed4f507f83f2ece3812a1c2184614337c8be91110499
+// @forge-generated generator=0.1.0-alpha.25 input=f4bc0a51dfadbdbabe4e7083c29844716f74c2beebcb86ce30e7a70c4f9487b4 content=a7c5e9f36b973e9b5a51716753739f57a63fa77c68b0fad18f059b5407aa58fe
 export const releaseManifest = {
   "defaultProvider": "local",
   "diagnostics": [],
@@ -19,7 +19,7 @@ export const releaseManifest = {
     "custom"
   ],
   "packageName": "forgeos",
-  "packageVersion": "0.1.0-alpha.24",
-  "releaseId": "forgeos@0.1.0-alpha.24+unknown",
+  "packageVersion": "0.1.0-alpha.25",
+  "releaseId": "forgeos@0.1.0-alpha.25+unknown",
   "schemaVersion": "0.1.0"
 } as const;

package/src/forge/agent-memory/bridge.ts

@@ -113,10 +113,16 @@ async function openMemoryStore(
   workspaceRoot: string,
   access: "read" | "write" = "write",
 ): Promise<DeltaStore | AgentMemoryUnavailableResult> {
-  try {
-    return await DeltaStore.open(workspaceRoot, { access });
-  } catch (error) {
-    return memoryUnavailable(error, workspaceRoot);
+  const retryDelays = access === "write" ? [25, 75, 150] : [];
+  for (let attempt = 0; ; attempt += 1) {
+    try {
+      return await DeltaStore.open(workspaceRoot, { access });
+    } catch (error) {
+      if (!(error instanceof DeltaStoreBusyError) || attempt >= retryDelays.length) {
+        return memoryUnavailable(error, workspaceRoot);
+      }
+      await sleep(retryDelays[attempt] ?? 0);
+    }
   }
 }
 
@@ -131,6 +137,10 @@ function isExternalPgliteRead(result: AgentMemoryUnavailableResult): boolean {
   );
 }
 
+function isDeltaBusyIngestResult(result: AgentIngestResult): boolean {
+  return result.ok === false && result.busy?.code === "FORGE_DELTA_BUSY";
+}
+
 function fallbackMemoryPath(workspaceRoot: string): string {
   return join(workspaceRoot, ".forge", "agent", "events.ndjson");
 }
@@ -413,23 +423,29 @@ async function ingestAgentMemoryQueueFile(options: AgentMemoryCommandOptions): P
     source,
     eventName: options.eventName,
   });
+  const errors = [
+    ...drained.errors,
+    ...(drained.busy ? ["DeltaDB is busy; queue checkpoint was not advanced"] : []),
+  ];
   return {
-    ok: drained.errors.length === 0,
+    ok: errors.length === 0,
     watch: false,
     source,
     file: options.file,
     eventsIngested: drained.eventsIngested,
-    errors: drained.errors,
+    errors,
     bytesRead: drained.bytesRead,
     pendingBytes: drained.pendingBytes,
     checkpointFile: drained.checkpointFile,
     compacted: drained.compacted,
     historyFile: drained.historyFile,
+    ...(drained.busy ? { busy: drained.busy, pendingDueToBusy: true } : {}),
     nextActions: [
+      ...(drained.busy ? ["forge delta status --json"] : []),
       `forge agent memory --entry ${source} --json`,
       `forge agent hooks status --target ${source} --json`,
     ],
-    exitCode: drained.errors.length === 0 ? 0 : 1,
+    exitCode: errors.length === 0 ? 0 : 1,
   };
 }
 
@@ -644,6 +660,7 @@ export async function drainAgentMemoryQueueFile(options: {
   checkpointFile: string;
   compacted: boolean;
   historyFile: string;
+  busy?: AgentMemoryUnavailableResult["busy"];
 }> {
   const historyFile = queueHistoryPath(options.watchFile);
   if (!existsSync(options.watchFile)) {
@@ -699,6 +716,17 @@ export async function drainAgentMemoryQueueFile(options: {
       eventsIngested += 1;
       consumedOffset = bytesRead + line.endOffset;
       writeQueueCheckpoint(options.watchFile, consumedOffset);
+    } else if (isDeltaBusyIngestResult(result)) {
+      return {
+        eventsIngested,
+        errors,
+        bytesRead,
+        pendingBytes,
+        checkpointFile: queueCheckpointPath(options.watchFile),
+        compacted: false,
+        historyFile,
+        busy: result.busy,
+      };
     } else {
       errors.push(result.error ?? "agent memory ingest failed");
       break;
@@ -886,7 +914,19 @@ async function watchAgentMemoryIngest(options: AgentMemoryCommandOptions): Promi
 
   let eventsIngested = 0;
   const errors: string[] = [];
+  let busyRetries = 0;
+  let lastBusy: AgentMemoryUnavailableResult["busy"] | undefined;
   let pendingIngest = Promise.resolve();
+  let retryTimer: ReturnType<typeof setTimeout> | undefined;
+  const scheduleBusyRetry = () => {
+    if (retryTimer) {
+      return;
+    }
+    retryTimer = setTimeout(() => {
+      retryTimer = undefined;
+      pendingIngest = pendingIngest.then(ingestNewContent, ingestNewContent);
+    }, 500);
+  };
   const ingestNewContent = async () => {
     const result = await drainAgentMemoryQueueFile({
       workspaceRoot: options.workspaceRoot,
@@ -895,6 +935,13 @@ async function watchAgentMemoryIngest(options: AgentMemoryCommandOptions): Promi
       eventName: options.eventName,
     });
     eventsIngested += result.eventsIngested;
+    if (result.busy) {
+      busyRetries += 1;
+      lastBusy = result.busy;
+      scheduleBusyRetry();
+      return;
+    }
+    lastBusy = undefined;
     errors.push(...result.errors);
   };
 
@@ -904,6 +951,10 @@ async function watchAgentMemoryIngest(options: AgentMemoryCommandOptions): Promi
       pendingIngest = pendingIngest.then(ingestNewContent, ingestNewContent);
     });
     const shutdown = () => {
+      if (retryTimer) {
+        clearTimeout(retryTimer);
+        retryTimer = undefined;
+      }
       watcher.close();
       void pendingIngest.finally(() => {
         resolve({
@@ -913,7 +964,9 @@ async function watchAgentMemoryIngest(options: AgentMemoryCommandOptions): Promi
           file,
           eventsIngested,
           errors,
+          ...(lastBusy ? { busy: lastBusy, pendingDueToBusy: true, busyRetries } : {}),
           nextActions: [
+            ...(lastBusy ? ["forge delta status --json"] : []),
             `forge agent memory --entry ${source} --json`,
             `forge agent hooks status --target ${source} --json`,
           ],
@@ -971,6 +1024,10 @@ function installAgentMemory(options: AgentMemoryCommandOptions): AgentInstallRes
   return cursorInstallResult(filesWritten, planned);
 }
 
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
 export function formatAgentMemoryJson(result: AgentMemoryCommandResult): string {
   return `${JSON.stringify(result, null, 2)}\n`;
 }

package/src/forge/agent-memory/types.ts

@@ -155,6 +155,7 @@ export interface AgentIngestResult {
     path: string;
     reason: "pglite-active";
   };
+  busy?: AgentMemoryUnavailableResult["busy"];
   exitCode: 0 | 1;
   error?: string;
   diagnostics?: Diagnostic[];
@@ -174,6 +175,9 @@ export interface AgentIngestWatchResult {
   checkpointFile?: string;
   compacted?: boolean;
   historyFile?: string;
+  busy?: AgentMemoryUnavailableResult["busy"];
+  pendingDueToBusy?: boolean;
+  busyRetries?: number;
   nextActions: string[];
   exitCode: 0 | 1;
 }

package/src/forge/compiler/agent-contract/build.ts

@@ -7,6 +7,7 @@ import { detectSecrets } from "../classifier/secrets.ts";
 import { GENERATOR_VERSION } from "../emitter/constants.ts";
 import { stripDeterministicHeader } from "../primitives/header.ts";
 import { canonicalJson, normalizeNewlines, serializeCanonical } from "../primitives/serialize.ts";
+import { toSnakeCase } from "../data-graph/sql/naming.ts";
 import { resolveByPackageName } from "../recipes/registry.ts";
 import {
   defaultRuntimeCompatibility,
@@ -288,6 +289,35 @@ function runtimeRules(): AgentRuntimeRule[] {
   ];
 }
 
+type TenantTableInfo = {
+  tenantIdColumn: string;
+  tenantField: string;
+};
+
+function buildTenantTableLookup(tenantScope: TenantScope, dataGraph: DataGraph): Map<string, TenantTableInfo> {
+  const lookup = new Map<string, TenantTableInfo>();
+  for (const scoped of tenantScope.tables) {
+    const table = dataGraph.tables.find((candidate) =>
+      candidate.name === scoped.table ||
+      candidate.exportName === scoped.exportName ||
+      toSnakeCase(candidate.name) === scoped.table ||
+      toSnakeCase(candidate.exportName) === scoped.table
+    );
+    const tenantField = table?.fields.find((field) => toSnakeCase(field.name) === scoped.tenantIdColumn)?.name ??
+      scoped.tenantIdColumn;
+    const info = { tenantIdColumn: scoped.tenantIdColumn, tenantField };
+    for (const key of uniqueSorted([
+      scoped.table,
+      scoped.exportName,
+      table?.name,
+      table?.exportName,
+    ].filter((key): key is string => typeof key === "string" && key.length > 0))) {
+      lookup.set(key, info);
+    }
+  }
+  return lookup;
+}
+
 function agentProtocols(workspaceRoot: string): AgentProtocolInfo[] {
   return [
     {
@@ -1037,9 +1067,7 @@ export function buildAgentContractArtifacts(
   input: AgentContractInput,
 ): AgentContractArtifacts {
   const project = readPackageInfo(input.workspaceRoot);
-  const tenantTables = new Map(
-    input.tenantScope.tables.map((table) => [table.table, table.tenantIdColumn]),
-  );
+  const tenantTables = buildTenantTableLookup(input.tenantScope, input.dataGraph);
   const commandAuth = new Map(
     input.policyRegistry.commandAuth.map((binding) => [binding.commandName, binding.auth]),
   );
@@ -1183,13 +1211,16 @@ export function buildAgentContractArtifacts(
       }),
     ),
     data: {
-      tables: sorted(input.dataGraph.tables, (table) => table.name).map((table) => ({
-        name: table.name,
-        file: table.file,
-        tenantScoped: tenantTables.has(table.name),
-        ...(tenantTables.has(table.name) ? { tenantField: tenantTables.get(table.name) } : {}),
-        fields: uniqueSorted(table.fields.map((field) => field.name)),
-      })),
+      tables: sorted(input.dataGraph.tables, (table) => table.name).map((table) => {
+        const tenantInfo = tenantTables.get(table.name);
+        return {
+          name: table.name,
+          file: table.file,
+          tenantScoped: Boolean(tenantInfo),
+          ...(tenantInfo ? { tenantField: tenantInfo.tenantField } : {}),
+          fields: uniqueSorted(table.fields.map((field) => field.name)),
+        };
+      }),
     },
     policies: sorted(input.policyRegistry.policies, (policy) => policy.name).map((policy) => ({
       name: policy.name,

package/src/forge/delta/recorder.ts

@@ -4,7 +4,7 @@ import type { ForgeCommand } from "../cli/parse.ts";
 import { GENERATED_DIR } from "../compiler/emitter/constants.ts";
 import { normalizePath } from "../compiler/primitives/paths.ts";
 import { hashUtf8Bytes } from "../compiler/primitives/hash.ts";
-import { DeltaStore, type DeltaRuntimeCallInput } from "./store.ts";
+import { DeltaStore, DeltaStoreBusyError, type DeltaRuntimeCallInput } from "./store.ts";
 import { classifyArtifactKind } from "./classifier.ts";
 import { readDeltaGitSnapshot } from "./git-observer.ts";
 
@@ -28,70 +28,129 @@ export async function createAmbientDeltaRecorder(
   if (isDeltaDisabled()) {
     return noopRecorder;
   }
-  try {
-    const store = await DeltaStore.open(workspaceRoot);
-    const actorId = await store.ensureActor("forge", "forge-cli", { pid: process.pid });
-    const sessionId = await store.createSession({
+  let actorId: string | undefined;
+  let sessionId: string | undefined;
+  let accepting = true;
+  let closed = false;
+  let queue = Promise.resolve();
+
+  const withStore = async (fn: (store: DeltaStore) => Promise<void>): Promise<void> => {
+    const store = await openDeltaStoreWithRetry(workspaceRoot);
+    try {
+      await fn(store);
+    } finally {
+      await store.close();
+    }
+  };
+
+  const enqueue = (fn: (store: DeltaStore) => Promise<void>): Promise<void> => {
+    queue = queue.then(() => safeDelta(() => withStore(fn)));
+    return queue;
+  };
+
+  const ensureSession = async (store: DeltaStore): Promise<{ actorId: string; sessionId: string } | null> => {
+    if (actorId && sessionId) {
+      return { actorId, sessionId };
+    }
+    actorId = await store.ensureActor("forge", "forge-cli", { pid: process.pid });
+    sessionId = await store.createSession({
       source,
       summary,
       metadata: { actorId },
       git: readDeltaGitSnapshot(workspaceRoot),
     });
-    return {
-      sessionId,
-      async recordRuntimeCall(input) {
-        await safeDelta(async () => {
-          const failedCode = input.diagnosticCode ?? diagnosticCode(input.diagnostics);
-          await store.appendOperation({
-            sessionId,
-            actorId,
-            kind: input.result === "denied"
-              ? "runtime.entry.denied"
-              : input.result === "failed"
-                ? "runtime.entry.failed"
-                : "runtime.entry.executed",
-            summary: `${input.entryName} ${input.result ?? "executed"}`,
-            data: {
-              entryName: input.entryName,
-              entryKind: input.entryKind,
-              result: input.result,
-              traceId: input.traceId,
-              diagnosticCode: failedCode,
-            },
-            runtimeCall: { ...input, diagnosticCode: failedCode },
-          });
-        });
-      },
-      async recordAgentTool(input) {
-        await safeDelta(async () => {
-          await store.appendOperation({
-            sessionId,
-            actorId,
-            kind: "agent.tool.called",
-            summary: `${input.toolName} ${input.status}`,
-            data: {
-              toolName: input.toolName,
-              risk: input.risk,
-              status: input.status,
-              traceId: input.traceId,
-              durationMs: input.durationMs,
-            },
-          });
+    return { actorId, sessionId };
+  };
+
+  await enqueue(async (store) => {
+    await ensureSession(store);
+  });
+
+  return {
+    get sessionId() {
+      return sessionId;
+    },
+    async recordRuntimeCall(input) {
+      if (!accepting) {
+        return;
+      }
+      await enqueue(async (store) => {
+        const session = await ensureSession(store);
+        if (!session) {
+          return;
+        }
+        const failedCode = input.diagnosticCode ?? diagnosticCode(input.diagnostics);
+        await store.appendOperation({
+          sessionId: session.sessionId,
+          actorId: session.actorId,
+          kind: input.result === "denied"
+            ? "runtime.entry.denied"
+            : input.result === "failed"
+              ? "runtime.entry.failed"
+              : "runtime.entry.executed",
+          summary: `${input.entryName} ${input.result ?? "executed"}`,
+          data: {
+            entryName: input.entryName,
+            entryKind: input.entryKind,
+            result: input.result,
+            traceId: input.traceId,
+            diagnosticCode: failedCode,
+          },
+          runtimeCall: { ...input, diagnosticCode: failedCode },
         });
-      },
-      async recordFileChanged(path, changeType = "modified") {
-        await safeDelta(() => store.recordFilePath(sessionId, path, changeType));
-      },
-      async close(closeSummary) {
-        await safeDelta(async () => {
-          await store.endSession(sessionId, closeSummary);
-          await store.close();
+      });
+    },
+    async recordAgentTool(input) {
+      if (!accepting) {
+        return;
+      }
+      await enqueue(async (store) => {
+        const session = await ensureSession(store);
+        if (!session) {
+          return;
+        }
+        await store.appendOperation({
+          sessionId: session.sessionId,
+          actorId: session.actorId,
+          kind: "agent.tool.called",
+          summary: `${input.toolName} ${input.status}`,
+          data: {
+            toolName: input.toolName,
+            risk: input.risk,
+            status: input.status,
+            traceId: input.traceId,
+            durationMs: input.durationMs,
+          },
         });
-      },
-    };
-  } catch {
-    return noopRecorder;
-  }
+      });
+    },
+    async recordFileChanged(path, changeType = "modified") {
+      if (!accepting) {
+        return;
+      }
+      await enqueue(async (store) => {
+        const session = await ensureSession(store);
+        if (!session) {
+          return;
+        }
+        await store.recordFilePath(session.sessionId, path, changeType);
+      });
+    },
+    async close(closeSummary) {
+      if (closed) {
+        await queue;
+        return;
+      }
+      accepting = false;
+      closed = true;
+      await enqueue(async (store) => {
+        if (!sessionId) {
+          return;
+        }
+        await store.endSession(sessionId, closeSummary);
+      });
+    },
+  };
 }
 
 export async function recordParsedCliCommand(input: {
@@ -343,6 +402,25 @@ const noopRecorder: AmbientDeltaRecorder = {
   async close() {},
 };
 
+const DELTA_STORE_RETRY_DELAYS_MS = [25, 75, 150];
+
+async function openDeltaStoreWithRetry(workspaceRoot: string): Promise<DeltaStore> {
+  for (let attempt = 0; ; attempt += 1) {
+    try {
+      return await DeltaStore.open(workspaceRoot);
+    } catch (error) {
+      if (!(error instanceof DeltaStoreBusyError) || attempt >= DELTA_STORE_RETRY_DELAYS_MS.length) {
+        throw error;
+      }
+      await sleep(DELTA_STORE_RETRY_DELAYS_MS[attempt] ?? 0);
+    }
+  }
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
 async function safeDelta(fn: () => Promise<void>): Promise<void> {
   try {
     await fn();

package/src/forge/version.ts

@@ -1,3 +1,3 @@
-export const FORGEOS_VERSION = "0.1.0-alpha.24";
+export const FORGEOS_VERSION = "0.1.0-alpha.25";
 export const GENERATOR_VERSION = FORGEOS_VERSION;
 export const CLI_VERSION = FORGEOS_VERSION;