forgeos 0.1.0-alpha.24 → 0.1.0-alpha.26

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.26 input=23c00c5407aab4088b55b49905f2b195667a75b8544fa180786ac637ee67e1e5 content=0d493cf0e41b71cb652d5e0e1b0c1f83d2a1281b748321f0b00f0773ba93074e
 # AGENTS.md
 
 <!-- forge-generated:start -->

package/CHANGELOG.md

@@ -1,7 +1,35 @@
 # forgeos
 
+## 0.1.0-alpha.26
+
+### Patch Changes
+
+- Harden the field-demo loop after the Team Onboarding app exercise.
+
+  - Let `forge changed` and `forge handoff` summarize non-git workspaces with a filesystem inventory instead of reporting zero useful changes.
+  - Keep `forge make resource` global by default unless a tenants table exists or `--tenant-scoped` is explicit.
+  - Expand capability-map table detection for aliased `ctx.db` usage.
+  - Wait through short-lived DeltaDB writer locks before reporting `FORGE_DELTA_BUSY`.
+
 ## 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,28 @@ The canonical source file in the repository is `CHANGELOG.md`.
 
 ## Unreleased
 
+## 0.1.0-alpha.26
+
+- Hardened the field-demo loop after the Team Onboarding app exercise:
+  non-git workspaces now get a filesystem-backed `changed`/`handoff` summary,
+  `forge make resource` stays global unless tenant scope is explicit or already
+  modeled, capability-map extraction sees aliased `ctx.db` table usage, and
+  Agent Memory waits through short-lived DeltaDB writer locks before reporting
+  `FORGE_DELTA_BUSY`.
+
+## 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.26",
   "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.26","releaseId":"forgeos@0.1.0-alpha.26+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.26 input=23c00c5407aab4088b55b49905f2b195667a75b8544fa180786ac637ee67e1e5 content=967d4e05aa540b3e3d843fa6ed4516658ab4c364c1d8c42a14f36c57b75dff71
 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.26",
+  "releaseId": "forgeos@0.1.0-alpha.26+unknown",
   "schemaVersion": "0.1.0"
 } as const;

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

@@ -113,10 +113,19 @@ 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,
+        ...(access === "write" ? { waitMs: 1_500, retryDelayMs: 50 } : {}),
+      });
+    } catch (error) {
+      if (!(error instanceof DeltaStoreBusyError) || attempt >= retryDelays.length) {
+        return memoryUnavailable(error, workspaceRoot);
+      }
+      await sleep(retryDelays[attempt] ?? 0);
+    }
   }
 }
 
@@ -131,6 +140,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 +426,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 +663,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 +719,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 +917,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 +938,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 +954,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 +967,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 +1027,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/cli/changed.ts

@@ -82,8 +82,7 @@ function buildRisks(git: WorkspaceGitSummary): string[] {
   const risks: string[] = [];
   const changed = git.changeSummary.changed;
   if (!git.available) {
-    risks.push("git status is unavailable; changed-file analysis may be incomplete");
-    return risks;
+    risks.push("git status is unavailable; using filesystem inventory as untracked-file analysis");
   }
   if (git.untracked.count > 0) {
     risks.push(`${git.untracked.count} untracked file(s) are not in git history`);
@@ -103,7 +102,7 @@ function buildRisks(git: WorkspaceGitSummary): string[] {
 
 function buildRecommendedCommands(git: WorkspaceGitSummary): string[] {
   if (!git.available) {
-    return ["git status --short", "forge status --json"];
+    return ["forge status --json", "forge handoff --json", "git init"];
   }
   if (git.changeSummary.changed.total.count === 0) {
     return ["forge status --json", "forge dev --once --json"];
@@ -202,12 +201,13 @@ export function runChangedCommand(workspaceRoot: string, options: { authoredOnly
   const reviewFocus = buildReviewFocus(humanChanges, viewDerivedChanges);
   const generatedExplanation = buildGeneratedChangeExplanation(humanChanges, viewDerivedChanges);
   const diffPlan: DiffPlan = buildDiffPlanFromChangeSummary(viewChanged);
+  const ok = git.available || git.source === "filesystem";
 
   return {
-    ok: git.available,
+    ok,
     data: {
       schemaVersion: "0.1.0",
-      ok: git.available,
+      ok,
       summary: {
         branch: git.branch,
         commit: git.commit,
@@ -223,6 +223,7 @@ export function runChangedCommand(workspaceRoot: string, options: { authoredOnly
       },
       git: {
         available: git.available,
+        source: git.source,
         ...(git.error ? { error: git.error } : {}),
         branch: git.branch,
         commit: git.commit,
@@ -240,7 +241,7 @@ export function runChangedCommand(workspaceRoot: string, options: { authoredOnly
       recommendedCommands,
       nextActions: recommendedCommands,
     },
-    exitCode: git.available ? 0 : 1,
+    exitCode: ok ? 0 : 1,
   };
 }
 

package/src/forge/cli/handoff.ts

@@ -140,6 +140,7 @@ function buildOpeningBrief(input: {
 }): string {
   const agent = input.dev.summary.agentContext;
   const changedByType = summarizeChangeTypes(input.git.changeSummary.changed);
+  const changedFiles = Math.max(agent.changedFiles, input.git.changed.count);
   const tests = input.recentRuns.test
     ? input.recentRuns.test.ok
       ? "last test run passed"
@@ -150,7 +151,7 @@ function buildOpeningBrief(input: {
     : "no blocking issues";
   return [
     `ForgeOS handoff: ${input.dev.ok ? "dev diagnostics are clean" : "dev diagnostics need attention"}.`,
-    `${agent.changedFiles} changed file(s)${changedByType ? `: ${changedByType}` : ""}; ${input.git.staged.count} staged, ${input.git.untracked.count} untracked.`,
+    `${changedFiles} changed file(s)${changedByType ? `: ${changedByType}` : ""}; ${input.git.staged.count} staged, ${input.git.untracked.count} untracked.`,
     `${tests}; ${blockers}.`,
     `Next command: ${input.dev.summary.primaryAction?.command ?? input.dev.nextActions[0]?.command ?? "forge dev"}.`,
   ].join(" ");
@@ -168,6 +169,7 @@ export async function runHandoffCommand(options: HandoffCommandOptions): Promise
   const agent = dev.summary.agentContext;
   const risks = [
     ...agent.blockingIssues,
+    ...(!git.available ? ["git status is unavailable; using filesystem inventory as untracked-file analysis"] : []),
     ...(git.untracked.count > 0 ? [`${git.untracked.count} untracked file(s) are not in git history`] : []),
     ...(recentRuns.test && !recentRuns.test.ok ? ["last test run failed"] : []),
     ...(recentRuns.ui && !recentRuns.ui.ok ? ["last UI run failed"] : []),
@@ -181,6 +183,7 @@ export async function runHandoffCommand(options: HandoffCommandOptions): Promise
     agent.blockingIssues.length === 0 &&
     (!recentRuns.test || recentRuns.test.ok) &&
     (!recentRuns.ui || recentRuns.ui.ok);
+  const changedFiles = Math.max(agent.changedFiles, git.changed.count);
 
   return {
     schemaVersion: "0.1.0",
@@ -192,7 +195,7 @@ export async function runHandoffCommand(options: HandoffCommandOptions): Promise
       generatedChanged: agent.generatedChanged,
       generatedChangedFiles: agent.generatedChangedFiles,
       frontendReady: agent.frontendReady,
-      changedFiles: agent.changedFiles,
+      changedFiles,
       stagedFiles: git.staged.count,
       unstagedFiles: git.unstaged.count,
       untrackedFiles: git.untracked.count,

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,
@@ -185,6 +186,38 @@ function sourceText(workspaceRoot: string, file: string | undefined): string {
   return nodeFileSystem.readText(absolute) ?? "";
 }
 
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function addDbAliasesForText(
+  text: string,
+  tableNames: Set<string>,
+  aliases: Map<string, string>,
+): void {
+  for (const match of text.matchAll(
+    /\b(?:const|let|var)\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*=\s*ctx\.db(?:\.([A-Za-z_$][A-Za-z0-9_$]*)|\[\s*["'`]([^"'`]+)["'`]\s*\])/g,
+  )) {
+    const alias = match[1] ?? "";
+    const table = match[2] ?? match[3] ?? "";
+    if (alias && tableNames.has(table)) {
+      aliases.set(alias, table);
+    }
+  }
+
+  for (const match of text.matchAll(/\b(?:const|let|var)\s*\{([^}]+)\}\s*=\s*ctx\.db/g)) {
+    const body = match[1] ?? "";
+    for (const part of body.split(",")) {
+      const [rawTable, rawAlias] = part.split(":").map((value) => value.trim());
+      const table = rawTable?.replace(/["'`]/g, "") ?? "";
+      const alias = (rawAlias ?? rawTable ?? "").replace(/\s*=.*$/, "").trim();
+      if (tableNames.has(table) && alias) {
+        aliases.set(alias, table);
+      }
+    }
+  }
+}
+
 function dbTablesForText(
   text: string,
   tableNames: Set<string>,
@@ -198,6 +231,24 @@ function dbTablesForText(
       tables.push(table);
     }
   }
+  for (const match of text.matchAll(/ctx\.db\s*\[\s*["'`]([^"'`]+)["'`]\s*\]\s*\.\s*([A-Za-z_$][A-Za-z0-9_$]*)/g)) {
+    const table = match[1] ?? "";
+    const op = match[2] ?? "";
+    if (tableNames.has(table) && ops.has(op)) {
+      tables.push(table);
+    }
+  }
+  const aliases = new Map<string, string>();
+  addDbAliasesForText(text, tableNames, aliases);
+  for (const [alias, table] of aliases) {
+    const aliasPattern = new RegExp(`\\b${escapeRegExp(alias)}\\s*\\.\\s*([A-Za-z_$][A-Za-z0-9_$]*)`, "g");
+    for (const match of text.matchAll(aliasPattern)) {
+      const op = match[1] ?? "";
+      if (ops.has(op)) {
+        tables.push(table);
+      }
+    }
+  }
   return uniqueSorted(tables);
 }
 
@@ -288,6 +339,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 +1117,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 +1261,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, { waitMs: 1_500, retryDelayMs: 50 });
+    } 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/delta/store.ts

@@ -348,6 +348,12 @@ interface DeltaStoreLock {
   token: string;
 }
 
+export interface DeltaStoreOpenOptions {
+  access?: DeltaStoreAccess;
+  waitMs?: number;
+  retryDelayMs?: number;
+}
+
 function getDeltaLockPath(workspaceRoot: string): string {
   return join(workspaceRoot, ".forge", "delta", "delta.lock");
 }
@@ -488,6 +494,33 @@ function acquireDeltaStoreLock(workspaceRoot: string): DeltaStoreLock {
   throw new DeltaStoreBusyError(lockPath, readLockHolder(lockPath));
 }
 
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function acquireDeltaStoreLockWithWait(
+  workspaceRoot: string,
+  options: { waitMs?: number; retryDelayMs?: number } = {},
+): Promise<DeltaStoreLock> {
+  const waitMs = Math.max(0, options.waitMs ?? 0);
+  const retryDelayMs = Math.max(10, options.retryDelayMs ?? 50);
+  const started = Date.now();
+  for (;;) {
+    try {
+      return acquireDeltaStoreLock(workspaceRoot);
+    } catch (error) {
+      if (!(error instanceof DeltaStoreBusyError)) {
+        throw error;
+      }
+      const elapsed = Date.now() - started;
+      if (elapsed >= waitMs) {
+        throw error;
+      }
+      await sleep(Math.min(retryDelayMs, waitMs - elapsed));
+    }
+  }
+}
+
 export function probeDeltaStoreBusy(workspaceRoot: string): DeltaStoreBusyError | null {
   const lockPath = getDeltaLockPath(workspaceRoot);
   if (!existsSync(lockPath)) {
@@ -551,11 +584,11 @@ export class DeltaStore {
     private readonly lock: DeltaStoreLock | null,
   ) {}
 
-  static async open(workspaceRoot: string, options: { access?: DeltaStoreAccess } = {}): Promise<DeltaStore> {
+  static async open(workspaceRoot: string, options: DeltaStoreOpenOptions = {}): Promise<DeltaStore> {
     const storePath = getDeltaStorePath(workspaceRoot);
     mkdirSync(dirname(storePath), { recursive: true });
     const initializedBeforeOpen = deltaStoreInitialized(storePath);
-    const lock = options.access === "read" ? null : acquireDeltaStoreLock(workspaceRoot);
+    const lock = options.access === "read" ? null : await acquireDeltaStoreLockWithWait(workspaceRoot, options);
     let store: DeltaStore | null = null;
     try {
       const adapter = await createPgliteAdapter(storePath);
@@ -565,7 +598,7 @@ export class DeltaStore {
       } else if (await store.needsSchemaInit()) {
         await store.close();
         store = null;
-        const migrateLock = acquireDeltaStoreLock(workspaceRoot);
+        const migrateLock = await acquireDeltaStoreLockWithWait(workspaceRoot, options);
         try {
           const migrateAdapter = await createPgliteAdapter(storePath);
           store = new DeltaStore(workspaceRoot, storePath, migrateAdapter, migrateLock);

package/src/forge/make/index.ts

@@ -200,6 +200,13 @@ function chooseSchemaFile(workspaceRoot: string): string {
   return "src/forge/schema.ts";
 }
 
+function schemaHasTenantsTable(workspaceRoot: string): boolean {
+  const schema = readIfExists(workspaceRoot, chooseSchemaFile(workspaceRoot)) ?? "";
+  return schema.includes('name: "tenants"') ||
+    schema.includes("name: 'tenants'") ||
+    /\btenants\s*=\s*(?:defineTable|table)\s*\(/.test(schema);
+}
+
 function choosePolicyFile(workspaceRoot: string): string {
   if (fileExists(workspaceRoot, "src/policies.ts")) {
     return "src/policies.ts";
@@ -551,6 +558,8 @@ function buildIntent(options: MakeCommandOptions): {
     kind === "command"
       ? actionName?.replace(/^(create|update|delete)/, "") || "create"
       : "read";
+  const tenantScoped =
+    options.tenantScoped || (kind === "resource" && schemaHasTenantsTable(options.workspaceRoot));
 
   return {
     diagnostics,
@@ -560,7 +569,7 @@ function buildIntent(options: MakeCommandOptions): {
       table,
       field: fieldOptions.field,
       fields,
-      tenantScoped: options.tenantScoped || kind === "resource",
+      tenantScoped,
       crud: options.withCrud || kind === "resource",
       liveQuery: options.withLiveQuery || kind === "resource" || kind === "livequery",
       react:
@@ -898,7 +907,7 @@ function buildPlan(options: MakeCommandOptions): MakePlan {
     kind: "resource" as const,
     name: options.name ?? "resource",
     fields: [],
-    tenantScoped: true,
+    tenantScoped: false,
     crud: true,
     liveQuery: true,
     react: true,

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.26";
 export const GENERATOR_VERSION = FORGEOS_VERSION;
 export const CLI_VERSION = FORGEOS_VERSION;

package/src/forge/workspace/git-summary.ts

@@ -1,6 +1,7 @@
 import { spawnSync } from "node:child_process";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
+import { readdirSync, readFileSync } from "node:fs";
+import { join, relative } from "node:path";
+import { normalizePath } from "../compiler/primitives/paths.ts";
 import {
   categorizeFiles,
   classifyChangeType,
@@ -13,6 +14,7 @@ import {
 
 export interface WorkspaceGitSummary {
   available: boolean;
+  source?: "git" | "filesystem";
   branch?: string;
   commit?: string;
   changed: FileListSummary;
@@ -28,18 +30,64 @@ export interface WorkspaceGitSummary {
   error?: string;
 }
 
-function emptySummary(error?: string): WorkspaceGitSummary {
+const FALLBACK_IGNORED_DIRS = new Set([
+  ".git",
+  "node_modules",
+  "dist",
+  "build",
+  "coverage",
+  ".next",
+  ".nuxt",
+  ".turbo",
+  ".cache",
+]);
+
+function listWorkspaceFiles(root: string): string[] {
+  const files: string[] = [];
+  const visit = (dir: string): void => {
+    let entries: Array<{ name: string; isDirectory: () => boolean; isFile: () => boolean }> = [];
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory() && FALLBACK_IGNORED_DIRS.has(entry.name)) {
+        continue;
+      }
+      const absolute = join(dir, entry.name);
+      const rel = normalizePath(relative(root, absolute));
+      if (!rel || rel === ".") {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        visit(absolute);
+        continue;
+      }
+      if (entry.isFile()) {
+        files.push(rel);
+      }
+    }
+  };
+  visit(root);
+  return filterVolatileForgeState(files).sort();
+}
+
+function filesystemSummary(workspaceRoot: string, error?: string): WorkspaceGitSummary {
+  const files = listWorkspaceFiles(workspaceRoot);
+  const classify = workspaceChangeClassifier(workspaceRoot);
   return {
     available: false,
-    changed: compactFiles([]),
+    source: "filesystem",
+    changed: compactFiles(files),
     staged: compactFiles([]),
     unstaged: compactFiles([]),
-    untracked: compactFiles([]),
+    untracked: compactFiles(files),
     changeSummary: {
-      changed: categorizeFiles([]),
+      changed: categorizeFiles(files, 8, classify),
       staged: categorizeFiles([]),
       unstaged: categorizeFiles([]),
-      untracked: categorizeFiles([]),
+      untracked: categorizeFiles(files, 8, classify),
     },
     ...(error ? { error } : {}),
   };
@@ -227,7 +275,7 @@ function parseStatusPath(line: string): string {
 export function buildWorkspaceGitSummary(workspaceRoot: string): WorkspaceGitSummary {
   const root = runGit(["rev-parse", "--show-toplevel"], workspaceRoot);
   if (!root.ok) {
-    return emptySummary(root.error);
+    return filesystemSummary(workspaceRoot, root.error);
   }
 
   const status = runGit(["status", "--porcelain=v1", "-uall"], workspaceRoot, { trim: false });
@@ -262,6 +310,7 @@ export function buildWorkspaceGitSummary(workspaceRoot: string): WorkspaceGitSum
 
   return {
     available: true,
+    source: "git",
     ...(branch.ok ? { branch: branch.stdout } : {}),
     ...(commit.ok ? { commit: commit.stdout } : {}),
     changed: compactFiles(changedFiles),