@remnic/core 9.15.0 → 9.15.2

package/dist/{types-D_fG2ix8.d.ts → types-2q_MRFcM.d.ts}

@@ -1990,6 +1990,12 @@ interface PluginConfig extends BoundedJsonlStateConfig {
      *  `chat_template_kwargs`, so this is the only think-off dialect it honors.
      *  Issue #1996. */
     localLlmReasoningEffort: string;
+    /**
+     * Maximum transcript length that re-enables thinking for local extraction.
+     * Set to `0` to keep thinking suppressed for every extraction. Default:
+     * `3000`. Consolidation is unaffected.
+     */
+    localLlmThinkingThresholdChars: number;
     /** Master gate. When false, restores pre-change behavior (extractor called on every triggered observe; no gate). */
     extractionRetryEnabled: boolean;
     /** Per-fingerprint exponential backoff schedule (ms), indexed by attempt number. */

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-export { aB as AccessTrackingEntry, A as ActiveRecallChatType, f as ActiveRecallModelFallbackPolicy, d as ActiveRecallPromptStyle, c as ActiveRecallQueryMode, e as ActiveRecallThinking, a6 as AgentAccessAuthToken, bj as AgentAccessHttpConfig, bk as AgentDefaultsConfig, bl as AgentPersona, q as AgentPersonaModelConfig, bm as BehaviorLoopAdjustment, v as BehaviorLoopPolicyState, bn as BehaviorSignalDirection, $ as BehaviorSignalEvent, bo as BehaviorSignalType, aQ as BootstrapOptions, aR as BootstrapResult, k as BriefingActiveThread, bp as BriefingCalendarSourceError, aY as BriefingConfig, i as BriefingFocus, h as BriefingFollowup, aZ as BriefingOpenCommitment, m as BriefingRecentEntity, l as BriefingResult, B as BriefingSections, a_ as BriefingWindow, bq as BufferEntryState, aw as BufferState, a0 as BufferSurpriseEvent, n as BufferTurn, j as CalendarEvent, C as CalendarSource, br as CaptureMode, bs as ChatConfig, p as Checkpoint, bt as CodexCliReasoningEffort, bu as CodexCompactionFlushMode, b1 as CodexCompatConfig, bv as CodexConnectorConfig, aD as CodingContext, bw as CodingGraphLspConfig, aU as CodingKnowledgeConfig, aT as CodingModeConfig, bx as CompressionGuidelineActivationState, a8 as CompressionGuidelineOptimizerActionSummary, a7 as CompressionGuidelineOptimizerEventCounts, a9 as CompressionGuidelineOptimizerRuleUpdate, by as CompressionGuidelineOptimizerSourceWindow, ac as CompressionGuidelineOptimizerState, bz as ConfidenceTier, bA as ConsolidationAction, bB as ConsolidationItem, aS as ConsolidationObservation, K as ConsolidationResult, bC as ContradictionScanConfig, W as ConversationThread, bD as CronConversationRecallMode, bE as CronRecallMode, b2 as DEFAULT_RECALL_DISCLOSURE, N as DaySummaryResult, bF as DreamingConfig, bG as DreamingNarrativePromptStyle, bH as DreamsDeepSleepConfig, bI as DreamsLightSleepConfig, D as DreamsPhase, bJ as DreamsPhaseStatus, bK as DreamsPhasesConfig, bL as DreamsRemConfig, a as DreamsRunResult, aE as DreamsStatusResult, bM as EngramTraceEvent, aA as EntityActivityEntry, E as EntityFile, ad as EntityMention, az as EntityRelationship, ae as EntitySchemaDefinition, af as EntitySchemaSectionDefinition, ag as EntityStructuredSection, au as EntityTimelineEntry, b3 as ExtractedFact, bN as ExtractedProcedureStep, bO as ExtractedQuestion, bP as ExtractedReasoningTrace, bQ as ExtractedReasoningTraceStep, bR as ExtractedRelationship, O as ExtractionFailureClass, bS as ExtractionPassSource, J as ExtractionResult, F as FaithfulnessFrontmatter, ay as FileHygieneConfig, G as GatewayConfig, bT as GitHubLiveConnectorConfig, bU as GmailLiveConnectorConfig, bV as GoogleDriveLiveConnectorConfig, bW as HeartbeatConfig, bX as HeartbeatDetectionMode, H as HourlySummary, I as IdentityInjectionMode, _ as ImportanceLevel, ah as ImportanceScore, X as LifecycleState, L as LiveConnectorsConfig, bY as LlmTraceCallback, bZ as LlmTraceEvent, aj as MemoryActionEligibilityContext, b6 as MemoryActionEligibilitySource, ab as MemoryActionEvent, b_ as MemoryActionOutcome, b$ as MemoryActionPolicyDecision, ak as MemoryActionPolicyResult, c0 as MemoryActionStatus, aa as MemoryActionType, w as MemoryCategory, M as MemoryFile, o as MemoryFrontmatter, ai as MemoryIntent, z as MemoryLifecycleEvent, al as MemoryLifecycleEventType, am as MemoryLifecycleStateSummary, av as MemoryLink, c1 as MemoryLinkType, b7 as MemoryObservation, c2 as MemoryOsPresetName, y as MemoryProjectionCurrentState, b8 as MemoryScope, x as MemoryStatus, aC as MemorySummary, ax as MetaState, c3 as ModelApi, c4 as ModelDefinitionConfig, c5 as ModelProviderAuthMode, an as ModelProviderConfig, c6 as NamespacePolicy, ao as NativeKnowledgeConfig, c7 as NativeKnowledgeFolderRuleConfig, c8 as NativeKnowledgeObsidianVaultConfig, c9 as NativeKnowledgeOpenClawWorkspaceConfig, ca as NotionLiveConnectorConfig, P as PluginConfig, Z as PolicyClass, cb as PrincipalFromSessionKeyMode, cc as PrincipalRule, cd as ProceduralConfig, ap as ProvenanceConfig, U as ProvenanceSource, at as QmdSearchExplain, Q as QmdSearchResult, ce as QuestionEntry, b9 as RECALL_DISCLOSURE_LEVELS, cf as ReasoningEffort, b as RecallDisclosure, cg as RecallPipelineConfig, R as RecallPlanMode, aP as RecallSectionConfig, g as RecallTierExplain, ch as RecallTraceEvent, ci as RelevanceFeedback, aq as RetrievalTier, cj as SPECULATIVE_TTL_DAYS, ck as ScopeProfileAutoPromoteConfig, s as ScopeProfileConfig, t as ScopeProfileLayerId, u as ScopeProfilePromotionTarget, cl as ScopeProfileTeamProjectConfig, cm as ScopeTeamConfig, cn as ScoredEntity, a5 as SecretRef, co as SemanticChunkingConfigShape, S as SessionObserverBandConfig, cp as SignalLevel, ar as SignalScanResult, cq as SlotBehaviorConfig, cr as SlotMismatchMode, r as SourceConnectorProvenance, as as TopicScore, T as TranscriptEntry, cs as TriggerMode, V as TrustWeights, Y as VerificationState, ct as confidenceTier, bg as isRecallDisclosure } from './types-D_fG2ix8.js';
+export { aB as AccessTrackingEntry, A as ActiveRecallChatType, f as ActiveRecallModelFallbackPolicy, d as ActiveRecallPromptStyle, c as ActiveRecallQueryMode, e as ActiveRecallThinking, a6 as AgentAccessAuthToken, bj as AgentAccessHttpConfig, bk as AgentDefaultsConfig, bl as AgentPersona, q as AgentPersonaModelConfig, bm as BehaviorLoopAdjustment, v as BehaviorLoopPolicyState, bn as BehaviorSignalDirection, $ as BehaviorSignalEvent, bo as BehaviorSignalType, aQ as BootstrapOptions, aR as BootstrapResult, k as BriefingActiveThread, bp as BriefingCalendarSourceError, aY as BriefingConfig, i as BriefingFocus, h as BriefingFollowup, aZ as BriefingOpenCommitment, m as BriefingRecentEntity, l as BriefingResult, B as BriefingSections, a_ as BriefingWindow, bq as BufferEntryState, aw as BufferState, a0 as BufferSurpriseEvent, n as BufferTurn, j as CalendarEvent, C as CalendarSource, br as CaptureMode, bs as ChatConfig, p as Checkpoint, bt as CodexCliReasoningEffort, bu as CodexCompactionFlushMode, b1 as CodexCompatConfig, bv as CodexConnectorConfig, aD as CodingContext, bw as CodingGraphLspConfig, aU as CodingKnowledgeConfig, aT as CodingModeConfig, bx as CompressionGuidelineActivationState, a8 as CompressionGuidelineOptimizerActionSummary, a7 as CompressionGuidelineOptimizerEventCounts, a9 as CompressionGuidelineOptimizerRuleUpdate, by as CompressionGuidelineOptimizerSourceWindow, ac as CompressionGuidelineOptimizerState, bz as ConfidenceTier, bA as ConsolidationAction, bB as ConsolidationItem, aS as ConsolidationObservation, K as ConsolidationResult, bC as ContradictionScanConfig, W as ConversationThread, bD as CronConversationRecallMode, bE as CronRecallMode, b2 as DEFAULT_RECALL_DISCLOSURE, N as DaySummaryResult, bF as DreamingConfig, bG as DreamingNarrativePromptStyle, bH as DreamsDeepSleepConfig, bI as DreamsLightSleepConfig, D as DreamsPhase, bJ as DreamsPhaseStatus, bK as DreamsPhasesConfig, bL as DreamsRemConfig, a as DreamsRunResult, aE as DreamsStatusResult, bM as EngramTraceEvent, aA as EntityActivityEntry, E as EntityFile, ad as EntityMention, az as EntityRelationship, ae as EntitySchemaDefinition, af as EntitySchemaSectionDefinition, ag as EntityStructuredSection, au as EntityTimelineEntry, b3 as ExtractedFact, bN as ExtractedProcedureStep, bO as ExtractedQuestion, bP as ExtractedReasoningTrace, bQ as ExtractedReasoningTraceStep, bR as ExtractedRelationship, O as ExtractionFailureClass, bS as ExtractionPassSource, J as ExtractionResult, F as FaithfulnessFrontmatter, ay as FileHygieneConfig, G as GatewayConfig, bT as GitHubLiveConnectorConfig, bU as GmailLiveConnectorConfig, bV as GoogleDriveLiveConnectorConfig, bW as HeartbeatConfig, bX as HeartbeatDetectionMode, H as HourlySummary, I as IdentityInjectionMode, _ as ImportanceLevel, ah as ImportanceScore, X as LifecycleState, L as LiveConnectorsConfig, bY as LlmTraceCallback, bZ as LlmTraceEvent, aj as MemoryActionEligibilityContext, b6 as MemoryActionEligibilitySource, ab as MemoryActionEvent, b_ as MemoryActionOutcome, b$ as MemoryActionPolicyDecision, ak as MemoryActionPolicyResult, c0 as MemoryActionStatus, aa as MemoryActionType, w as MemoryCategory, M as MemoryFile, o as MemoryFrontmatter, ai as MemoryIntent, z as MemoryLifecycleEvent, al as MemoryLifecycleEventType, am as MemoryLifecycleStateSummary, av as MemoryLink, c1 as MemoryLinkType, b7 as MemoryObservation, c2 as MemoryOsPresetName, y as MemoryProjectionCurrentState, b8 as MemoryScope, x as MemoryStatus, aC as MemorySummary, ax as MetaState, c3 as ModelApi, c4 as ModelDefinitionConfig, c5 as ModelProviderAuthMode, an as ModelProviderConfig, c6 as NamespacePolicy, ao as NativeKnowledgeConfig, c7 as NativeKnowledgeFolderRuleConfig, c8 as NativeKnowledgeObsidianVaultConfig, c9 as NativeKnowledgeOpenClawWorkspaceConfig, ca as NotionLiveConnectorConfig, P as PluginConfig, Z as PolicyClass, cb as PrincipalFromSessionKeyMode, cc as PrincipalRule, cd as ProceduralConfig, ap as ProvenanceConfig, U as ProvenanceSource, at as QmdSearchExplain, Q as QmdSearchResult, ce as QuestionEntry, b9 as RECALL_DISCLOSURE_LEVELS, cf as ReasoningEffort, b as RecallDisclosure, cg as RecallPipelineConfig, R as RecallPlanMode, aP as RecallSectionConfig, g as RecallTierExplain, ch as RecallTraceEvent, ci as RelevanceFeedback, aq as RetrievalTier, cj as SPECULATIVE_TTL_DAYS, ck as ScopeProfileAutoPromoteConfig, s as ScopeProfileConfig, t as ScopeProfileLayerId, u as ScopeProfilePromotionTarget, cl as ScopeProfileTeamProjectConfig, cm as ScopeTeamConfig, cn as ScoredEntity, a5 as SecretRef, co as SemanticChunkingConfigShape, S as SessionObserverBandConfig, cp as SignalLevel, ar as SignalScanResult, cq as SlotBehaviorConfig, cr as SlotMismatchMode, r as SourceConnectorProvenance, as as TopicScore, T as TranscriptEntry, cs as TriggerMode, V as TrustWeights, Y as VerificationState, ct as confidenceTier, bg as isRecallDisclosure } from './types-2q_MRFcM.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
 export { ContinuityImprovementLoop, ContinuityIncidentCloseInput, ContinuityIncidentOpenInput, ContinuityIncidentRecord, ContinuityIncidentState, ContinuityLoopCadence, ContinuityLoopReviewInput, ContinuityLoopStatus, ContinuityLoopUpsertInput } from './types-continuity.js';

package/dist/types.js

@@ -4,7 +4,7 @@ import {
   SPECULATIVE_TTL_DAYS,
   confidenceTier,
   isRecallDisclosure
-} from "./chunk-YVKF3HEW.js";
+} from "./chunk-FJ5IQ3SI.js";
 import "./chunk-PZ5AY32C.js";
 export {
   DEFAULT_RECALL_DISCLOSURE,

package/dist/utility-runtime.d.ts

@@ -1,5 +1,5 @@
 import { TierRoutingPolicy } from './tier-routing.js';
-import './types-D_fG2ix8.js';
+import './types-2q_MRFcM.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
 import './types-continuity.js';

package/dist/verified-recall.js

@@ -1,9 +1,9 @@
 import {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
-} from "./chunk-W2OST2HH.js";
+} from "./chunk-6EJL2O3G.js";
 import "./chunk-B7RWBZXW.js";
-import "./chunk-7HZMTXXB.js";
+import "./chunk-O7ACJAHR.js";
 import "./chunk-B3ABVQ36.js";
 import "./chunk-2QMKMVHH.js";
 import "./chunk-DEBHXHJR.js";
@@ -11,15 +11,15 @@ import "./chunk-DNHVPZOD.js";
 import "./chunk-6CIAGZ6X.js";
 import "./chunk-J6A3CX5N.js";
 import "./chunk-V57NLO5P.js";
-import "./chunk-YVKF3HEW.js";
-import "./chunk-AVPXXV6J.js";
+import "./chunk-FJ5IQ3SI.js";
+import "./chunk-XKGPIWGI.js";
 import "./chunk-EGGE52UU.js";
 import "./chunk-GCASGYIO.js";
 import "./chunk-WL5EBRDH.js";
+import "./chunk-ILGC6JH6.js";
 import "./chunk-SCU65EZI.js";
 import "./chunk-347WD2LE.js";
 import "./chunk-RL6NEVXT.js";
-import "./chunk-ILGC6JH6.js";
 import "./chunk-DM2T26WE.js";
 import "./chunk-LDXUBPMO.js";
 import "./chunk-CGASUJVP.js";
@@ -41,8 +41,8 @@ import "./chunk-45GF7Y3V.js";
 import "./chunk-RGMVMVMF.js";
 import "./chunk-N7RWREIQ.js";
 import "./chunk-5I4M26Q7.js";
-import "./chunk-5GKPFL3S.js";
 import "./chunk-4DJQYKMN.js";
+import "./chunk-5GKPFL3S.js";
 import "./chunk-PQVCH2AE.js";
 import "./chunk-EYIEWJNI.js";
 import "./chunk-JUC24CTX.js";

package/dist/write-envelope.d.ts

@@ -1,4 +1,4 @@
-import { w as MemoryCategory } from './types-D_fG2ix8.js';
+import { w as MemoryCategory } from './types-2q_MRFcM.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
 import './types-continuity.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "9.15.0",
+  "version": "9.15.2",
   "description": "Framework-agnostic Remnic memory engine — orchestrator, storage, extraction, search, trust zones",
   "type": "module",
   "main": "dist/index.js",
@@ -3045,7 +3045,7 @@
     "core"
   ],
   "peerDependencies": {
-    "@remnic/coding-graph": "^9.15.0"
+    "@remnic/coding-graph": "^9.15.2"
   },
   "peerDependenciesMeta": {
     "@remnic/coding-graph": {

package/src/access-http.test.ts

@@ -2727,6 +2727,10 @@ test("HTTP namespace/writable preflight returns the structured writability resul
   // is a valid 200 answer (read via `ok`), not an HTTP error.
   const service = {
     configRef: parseConfig({ memoryDir: "/tmp/remnic-http-preflight-test", defaultNamespace: "default" }),
+    namespaceWritablePreflight: async ({ namespace }: { namespace?: string }) =>
+      namespace && namespace !== "default"
+        ? { ok: false as const, reason: "not_writable" as const, namespace }
+        : { ok: true as const, namespace: "default" },
   } as unknown as EngramAccessService;
   const server = new EngramAccessHttpServer({
     service,
@@ -2757,9 +2761,90 @@ test("HTTP namespace/writable preflight returns the structured writability resul
   }
 });
 
+test("HTTP namespace/writable forwards project context to the scoped write preflight", async () => {
+  let received:
+    | {
+        namespace?: string;
+        sessionKey?: string;
+        projectTag?: string;
+        cwd?: string;
+      }
+    | undefined;
+  const service = {
+    configRef: parseConfig({ memoryDir: "/tmp/remnic-http-preflight-context", defaultNamespace: "default" }),
+    namespaceWritablePreflight: async (request: {
+      namespace?: string;
+      sessionKey?: string;
+      projectTag?: string;
+      cwd?: string;
+    }) => {
+      received = request;
+      return { ok: true as const, namespace: "derived-project-namespace" };
+    },
+  } as unknown as EngramAccessService;
+  const server = new EngramAccessHttpServer({
+    service,
+    port: 0,
+    authToken: "test-token",
+    adminConsoleEnabled: false,
+  });
+
+  const status = await server.start();
+  try {
+    const response = await fetch(
+      `http://127.0.0.1:${status.port}/engram/v1/namespace/writable?session=s-1&projectTag=Acme%2FWebshop&cwd=%2Ftmp%2Frepo`,
+      { headers: { authorization: "Bearer test-token" } },
+    );
+    assert.deepEqual(await response.json(), { ok: true, namespace: "derived-project-namespace" });
+    assert.deepEqual(received, {
+      namespace: undefined,
+      sessionKey: "s-1",
+      authenticatedPrincipal: undefined,
+      projectTag: "Acme/Webshop",
+      cwd: "/tmp/repo",
+    });
+  } finally {
+    await server.stop();
+  }
+});
+
+test("HTTP namespace/writable checks token scope against the effective scoped namespace", async () => {
+  const service = {
+    configRef: parseConfig({ memoryDir: "/tmp/remnic-http-preflight-effective", defaultNamespace: "default" }),
+    namespaceWritablePreflight: async () => ({
+      ok: true as const,
+      namespace: "principal-project-derived",
+    }),
+  } as unknown as EngramAccessService;
+  const server = new EngramAccessHttpServer({
+    service,
+    port: 0,
+    authTokenEntriesGetter: () => [
+      { token: "default-only", capabilities: { version: 1, ops: ["observe"], namespaces: ["default"] } },
+    ],
+    adminConsoleEnabled: false,
+  });
+
+  const status = await server.start();
+  try {
+    const response = await fetch(
+      `http://127.0.0.1:${status.port}/engram/v1/namespace/writable?session=s-1&projectTag=Acme%2FWebshop`,
+      { headers: { authorization: "Bearer default-only" } },
+    );
+    assert.deepEqual(await response.json(), {
+      ok: false,
+      reason: "not_writable",
+      namespace: "principal-project-derived",
+    });
+  } finally {
+    await server.stop();
+  }
+});
+
 test("HTTP namespace/writable preflight admits write-scoped tokens and rejects read-only ops", async () => {
   const service = {
     configRef: parseConfig({ memoryDir: "/tmp/remnic-http-preflight-ops-test", defaultNamespace: "default" }),
+    namespaceWritablePreflight: async () => ({ ok: true as const, namespace: "default" }),
   } as unknown as EngramAccessService;
   const server = new EngramAccessHttpServer({
     service,
@@ -2800,6 +2885,12 @@ test("HTTP namespace/writable preflight admits write-scoped tokens and rejects r
     assert.equal(await okOf(diag), false);
     // A read-only token cannot write, so it has nothing to preflight → 403.
     assert.equal((await request("read-only")).status, 403);
+    const invalidOp = await request("write-scoped", "memory_stroe");
+    assert.equal(invalidOp.status, 400);
+    assert.match(
+      JSON.stringify(await invalidOp.json()),
+      /unsupported namespace preflight operation: memory_stroe/,
+    );
   } finally {
     await server.stop();
   }

package/src/access-http.ts

@@ -37,7 +37,7 @@ import {
 import { expandTildePath } from "./utils/path.js";
 import { projectTagProjectId } from "./coding/coding-namespace.js";
 import { getOperation, type OperationName } from "./access-boundary.js";
-import { resolveNamespacePreflight } from "./scopes/scope-plan.js";
+import { resolveQueryNamespaceWritablePreflight } from "./access-namespace-preflight.js";
 import {
   assertOperationAllowed,
   capabilityAllowsOp,
@@ -1467,20 +1467,19 @@ export class EngramAccessHttpServer {
       return;
     }
 
-    // Namespace-writability preflight (issue #1888 part 3): would the client's
-    // enabled write (`?op=observe|memory_store`, default observe) to the
-    // requested namespace by THIS token succeed? Out-of-allow-list → 200
-    // {ok:false}; any allowedByOps token may run it (HTTP + batch admit alike).
     if (req.method === "GET" && pathname === "/engram/v1/namespace/writable") {
-      const preflightOp = getOperation("namespace_writable"); // boundary marker (catalog parity, issue #1888)
-      const caps = tokenCapabilityStore.getStore();
-      if (!(preflightOp?.spec.allowedByOps ?? []).some((op) => capabilityAllowsOp(caps, op))) {
-        throw new EngramAccessForbiddenError("token is not permitted to run the namespace preflight");
-      }
-      const ns = parsed.searchParams.get("namespace") || undefined;
-      const sk = parsed.searchParams.get("session") || undefined;
-      const writeOp = parsed.searchParams.get("op") === "memory_store" ? "memory_store" : "observe";
-      this.respondJson(res, 200, resolveNamespacePreflight(caps, ns, sk, this.resolveRequestPrincipal(req), this.service.configRef, writeOp));
+      if (!getOperation("namespace_writable")) throw new Error("namespace_writable operation is not registered");
+      this.respondJson(
+        res,
+        200,
+        await resolveQueryNamespaceWritablePreflight(
+          tokenCapabilityStore.getStore(),
+          parsed.searchParams,
+          this.resolveRequestPrincipal(req),
+          this.service.configRef.defaultNamespace,
+          (request) => this.service.namespaceWritablePreflight(request),
+        ),
+      );
       return;
     }
 

package/src/access-namespace-preflight.test.ts

@@ -0,0 +1,111 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import "./access-operations.js";
+import { getOperation } from "./access-boundary.js";
+import { tokenCapabilityStore, type TokenCapabilities } from "./access-token-capabilities.js";
+import {
+  assertNamespacePreflightPermitted,
+  resolveAuthorizedNamespaceWritablePreflight,
+  resolveQueryNamespaceWritablePreflight,
+  type EngramAccessNamespaceWritableRequest,
+} from "./access-namespace-preflight.js";
+import type { EngramAccessService } from "./access-service.js";
+
+test("namespace_writable forwards coding context through the batch boundary", async () => {
+  let received: EngramAccessNamespaceWritableRequest | undefined;
+  const service = {
+    configRef: { defaultNamespace: "default" },
+    namespaceWritablePreflight: async (request: EngramAccessNamespaceWritableRequest) => {
+      received = request;
+      return { ok: true as const, namespace: "principal-project" };
+    },
+  } as unknown as EngramAccessService;
+  const operation = getOperation("namespace_writable");
+  assert.ok(operation);
+
+  const caps: TokenCapabilities = { version: 1, ops: ["observe"] };
+  const output = await tokenCapabilityStore.run(caps, () =>
+    operation.run(
+      {
+        sessionKey: "session-1",
+        cwd: "/workspace/project",
+        projectTag: "project-tag",
+      },
+      { service, authenticatedPrincipal: "principal" },
+    ),
+  );
+
+  assert.deepEqual(output, { result: { ok: true, namespace: "principal-project" } });
+  assert.deepEqual(received, {
+    sessionKey: "session-1",
+    authenticatedPrincipal: "principal",
+    cwd: "/workspace/project",
+    projectTag: "project-tag",
+  });
+});
+
+test("namespace_writable rejects unsupported write operations", async () => {
+  const operation = getOperation("namespace_writable");
+  assert.ok(operation);
+  const service = {
+    configRef: { defaultNamespace: "default" },
+    namespaceWritablePreflight: async () => ({ ok: true as const, namespace: "default" }),
+  } as unknown as EngramAccessService;
+
+  await assert.rejects(
+    () =>
+      tokenCapabilityStore.run({ version: 1, ops: ["observe"] }, () =>
+        operation.run({ op: "memory_stroe" }, { service }),
+      ),
+    /unsupported namespace preflight operation: memory_stroe/,
+  );
+  assert.throws(
+    () =>
+      resolveQueryNamespaceWritablePreflight(
+        { version: 1, ops: ["observe"] },
+        new URLSearchParams({ op: "memory_stroe" }),
+        undefined,
+        "default",
+        async () => ({ ok: true, namespace: "default" }),
+      ),
+    /unsupported namespace preflight operation: memory_stroe/,
+  );
+});
+
+test("namespace_writable rejects unavailable preflight and denied write scope", async () => {
+  assert.throws(
+    () => assertNamespacePreflightPermitted({ version: 1, ops: ["memory_get"] }),
+    /token is not permitted to run the namespace preflight/,
+  );
+  assert.deepEqual(
+    await resolveAuthorizedNamespaceWritablePreflight(
+      { version: 1, ops: ["observe"] },
+      { namespace: "default" },
+      "default",
+      "memory_store",
+      async () => ({ ok: true, namespace: "default" }),
+    ),
+    { ok: false, reason: "not_writable", namespace: "default" },
+  );
+  assert.deepEqual(
+    await resolveAuthorizedNamespaceWritablePreflight(
+      { version: 1, ops: ["observe"], namespaces: ["team-a"] },
+      {},
+      "default",
+      "observe",
+      async () => ({ ok: true, namespace: "default" }),
+    ),
+    { ok: false, reason: "not_writable", namespace: "default" },
+  );
+  assert.deepEqual(
+    await resolveAuthorizedNamespaceWritablePreflight(
+      { version: 1, ops: ["observe"], namespaces: ["team-a"] },
+      { namespace: "outside-scope" },
+      "default",
+      "observe",
+      async () => ({ ok: false, reason: "unsupported", namespace: "outside-scope" }),
+    ),
+    { ok: false, reason: "not_writable", namespace: "outside-scope" },
+  );
+});

package/src/access-namespace-preflight.ts

@@ -0,0 +1,111 @@
+import { getOperation } from "./access-boundary.js";
+import { capabilityAllowsOp, isNamespaceAllowed, type TokenCapabilities } from "./access-token-capabilities.js";
+import { EngramAccessForbiddenError, EngramAccessInputError, NamespaceNotWritableError } from "./access-errors.js";
+import type { WritableNamespaceResult } from "./scopes/scope-plan.js";
+
+export interface EngramAccessNamespaceWritableRequest {
+  namespace?: string;
+  sessionKey?: string;
+  authenticatedPrincipal?: string;
+  cwd?: string;
+  projectTag?: string;
+}
+
+export function namespaceWritableRequest(
+  params: URLSearchParams,
+  authenticatedPrincipal?: string,
+): EngramAccessNamespaceWritableRequest {
+  const namespace = params.get("namespace") || undefined;
+  return {
+    namespace,
+    sessionKey: params.get("session") || undefined,
+    authenticatedPrincipal,
+    cwd: params.get("cwd") || undefined,
+    projectTag: params.get("projectTag") || undefined,
+  };
+}
+
+export function parseNamespacePreflightWriteOp(
+  value: string | undefined,
+): "observe" | "memory_store" {
+  if (value === undefined || value === "observe") return "observe";
+  if (value === "memory_store") return "memory_store";
+  throw new EngramAccessInputError(`unsupported namespace preflight operation: ${value}`);
+}
+
+export function assertNamespacePreflightPermitted(
+  caps: TokenCapabilities | undefined | null,
+): void {
+  const allowedOps = getOperation("namespace_writable")?.spec.allowedByOps ?? [];
+  if (!allowedOps.some((op) => capabilityAllowsOp(caps, op))) {
+    throw new EngramAccessForbiddenError("token is not permitted to run the namespace preflight");
+  }
+}
+
+export type NamespaceWritableResolver = (
+  request: EngramAccessNamespaceWritableRequest,
+) => Promise<string>;
+export type NamespaceWritablePreflightResolver = (
+  request: EngramAccessNamespaceWritableRequest,
+) => Promise<WritableNamespaceResult>;
+
+export async function resolveNamespaceWritablePreflight(
+  request: EngramAccessNamespaceWritableRequest,
+  resolveWritable: NamespaceWritableResolver,
+): Promise<WritableNamespaceResult> {
+  try {
+    return { ok: true, namespace: await resolveWritable(request) };
+  } catch (error) {
+    if (error instanceof NamespaceNotWritableError) {
+      return { ok: false, reason: "not_writable", namespace: error.attemptedNamespace };
+    }
+    if (error instanceof EngramAccessInputError) {
+      return {
+        ok: false,
+        reason: "unsupported",
+        namespace: request.namespace?.trim() ?? "",
+      };
+    }
+    throw error;
+  }
+}
+
+export async function resolveAuthorizedNamespaceWritablePreflight(
+  caps: TokenCapabilities | undefined | null,
+  request: EngramAccessNamespaceWritableRequest,
+  defaultNamespace: string,
+  writeOp: "observe" | "memory_store",
+  resolvePreflight: NamespaceWritablePreflightResolver,
+): Promise<WritableNamespaceResult> {
+  if (!capabilityAllowsOp(caps, writeOp)) {
+    return {
+      ok: false,
+      reason: "not_writable",
+      namespace: request.namespace?.trim() || defaultNamespace,
+    };
+  }
+
+  const result = await resolvePreflight(request);
+  if (!isNamespaceAllowed(caps, result.namespace, defaultNamespace)) {
+
+    return { ok: false, reason: "not_writable", namespace: result.namespace };
+  }
+  return result;
+}
+
+export function resolveQueryNamespaceWritablePreflight(
+  caps: TokenCapabilities | undefined | null,
+  params: URLSearchParams,
+  authenticatedPrincipal: string | undefined,
+  defaultNamespace: string,
+  resolvePreflight: NamespaceWritablePreflightResolver,
+): Promise<WritableNamespaceResult> {
+  assertNamespacePreflightPermitted(caps);
+  return resolveAuthorizedNamespaceWritablePreflight(
+    caps,
+    namespaceWritableRequest(params, authenticatedPrincipal),
+    defaultNamespace,
+    parseNamespacePreflightWriteOp(params.get("op") ?? undefined),
+    resolvePreflight,
+  );
+}

package/src/access-operations-batch.ts

@@ -18,7 +18,11 @@ import { EngramAccessForbiddenError } from "./access-errors.js";
 import { EngramAccessInputError, type EngramAccessService } from "./access-service.js";
 import { enforceNamespaceAllowList, tokenCapabilityStore } from "./access-token-capabilities.js";
 import { projectTagProjectId } from "./coding/coding-namespace.js";
-import { resolveNamespacePreflight } from "./scopes/scope-plan.js";
+import {
+  parseNamespacePreflightWriteOp,
+  resolveAuthorizedNamespaceWritablePreflight,
+  type EngramAccessNamespaceWritableRequest,
+} from "./access-namespace-preflight.js";
 import { expandTildePath } from "./utils/path.js";
 import { resolvePrincipal } from "./namespaces/principal.js";
 import { getRecallTimingStatus, isRecallTimingsOperator } from "./recall-timings.js";
@@ -114,7 +118,26 @@ defineOperation({ name: "recall_xray", description: "X-ray recall.", schema: str
     return { result: await ctx.service.recallXray({ query: defStr(input.query, ""), sessionKey: optStr(input.sessionKey), namespace: optStr(input.namespace), budget, authenticatedPrincipal: ctx.authenticatedPrincipal, ...(dr && dr !== "" ? { disclosure: dr as RecallDisclosure } : {}), ...(ctx.abortSignal ? { abortSignal: ctx.abortSignal } : {}) }) };
   },
 });
-defineOperation({ name: "namespace_writable", description: "Read-only preflight: is a namespace writable for the caller's principal?", allowedByOps: ["namespace_writable", "observe", "memory_store"], schema: strictSchema({ namespace: S.str, sessionKey: S.str, op: S.str }), handler: async (input, ctx) => { const ns = optStr(input.namespace); const sk = optStr(input.sessionKey); const writeOp = optStr(input.op) === "memory_store" ? "memory_store" : "observe"; return { result: resolveNamespacePreflight(tokenCapabilityStore.getStore(), ns && ns.length > 0 ? ns : undefined, sk && sk.length > 0 ? sk : undefined, ctx.authenticatedPrincipal, ctx.service.configRef, writeOp) }; } });
+defineOperation({ name: "namespace_writable", description: "Read-only preflight: is a namespace writable for the caller's principal?", allowedByOps: ["namespace_writable", "observe", "memory_store"], schema: strictSchema({ namespace: S.str, sessionKey: S.str, op: S.str, cwd: S.str, projectTag: S.str }), handler: async (input, ctx) => {
+  const writeOp = parseNamespacePreflightWriteOp(optStr(input.op));
+  const namespace = optStr(input.namespace);
+  const request: EngramAccessNamespaceWritableRequest = {
+    sessionKey: optStr(input.sessionKey),
+    authenticatedPrincipal: ctx.authenticatedPrincipal,
+    cwd: optStr(input.cwd),
+    projectTag: optStr(input.projectTag),
+    ...(namespace ? { namespace } : {}),
+  };
+  return {
+    result: await resolveAuthorizedNamespaceWritablePreflight(
+      tokenCapabilityStore.getStore(),
+      request,
+      ctx.service.configRef.defaultNamespace,
+      writeOp,
+      (preflightRequest) => ctx.service.namespaceWritablePreflight(preflightRequest),
+    ),
+  };
+} });
 
 // === WEARABLES ===
 defineOperation({ name: "wearables_status", description: "Wearables status.", schema: strictSchema({}), handler: async (_i, ctx) => ({ result: await ctx.service.wearablesStatus() }) });

package/src/access-service-observe-scope.test.ts

@@ -33,6 +33,8 @@ import { join } from "node:path";
 import test from "node:test";
 
 import { EngramAccessService } from "./access-service.js";
+import { tokenCapabilityStore } from "./access-token-capabilities.js";
+import { resolveAuthorizedNamespaceWritablePreflight } from "./access-namespace-preflight.js";
 import { Orchestrator } from "./orchestrator.js";
 import type { StorageManager } from "./storage.js";
 import type { EngramAccessObserveRequest } from "./access-service.js";
@@ -604,6 +606,85 @@ test("#1505 (cursor hAp) scopeDebug.baseNamespace reports the principal self bas
   );
 });
 
+test("#2080 preflight resolves an implicit project scope through the observe write resolver", async () => {
+  const probe = makeObserveProbe({
+    ...withSelfPolicyPrefix("pi-geek"),
+    namespacePolicies: [
+      { name: "default", readPrincipals: ["admin"], writePrincipals: ["admin"] },
+      { name: "pi-geek", readPrincipals: ["pi-geek"], writePrincipals: ["pi-geek"] },
+    ],
+  });
+  const service = new EngramAccessService(probe.orch);
+  const expected = combineNamespaces(
+    "pi-geek",
+    projectNamespaceName(projectTagProjectId("Acme/Webshop")),
+  );
+
+  const result = await (
+    service as unknown as {
+      namespaceWritablePreflight: (request: {
+        sessionKey: string;
+        authenticatedPrincipal: string;
+        projectTag: string;
+      }) => Promise<{ ok: boolean; namespace: string }>;
+    }
+  ).namespaceWritablePreflight({
+    sessionKey: "pi-geek:abc123",
+    authenticatedPrincipal: "pi-geek",
+    projectTag: "Acme/Webshop",
+  });
+
+  assert.deepEqual(result, { ok: true, namespace: expected });
+  await assert.rejects(
+    () =>
+      tokenCapabilityStore.run({ version: 1, namespaces: ["default"] }, () =>
+        (
+          service as unknown as {
+            resolveCodingScopedWriteNamespace: (request: {
+              sessionKey: string;
+              authenticatedPrincipal: string;
+              projectTag: string;
+            }) => Promise<string>;
+          }
+        ).resolveCodingScopedWriteNamespace({
+          sessionKey: "pi-geek:abc123",
+          authenticatedPrincipal: "pi-geek",
+          projectTag: "Acme/Webshop",
+        }),
+      ),
+    /not permitted/,
+  );
+  const deniedPreflight = await tokenCapabilityStore.run(
+    { version: 1, ops: ["observe"], namespaces: ["default"] },
+    () =>
+      resolveAuthorizedNamespaceWritablePreflight(
+        tokenCapabilityStore.getStore(),
+        {
+          sessionKey: "pi-geek:abc123",
+          authenticatedPrincipal: "pi-geek",
+          projectTag: "Acme/Webshop",
+        },
+        "default",
+        "observe",
+        (request) => service.namespaceWritablePreflight(request),
+      ),
+  );
+  assert.deepEqual(deniedPreflight, { ok: false, reason: "not_writable", namespace: expected });
+  await assert.rejects(
+    () =>
+      tokenCapabilityStore.run({ version: 1, namespaces: ["default"] }, () =>
+        service.observe(
+          observeRequest({
+            sessionKey: "pi-geek:abc123",
+            authenticatedPrincipal: "pi-geek",
+            projectTag: "Acme/Webshop",
+          }),
+        ),
+      ),
+    /not permitted/,
+  );
+});
+
 test("#1495 the scope plan's writeNamespace matches resolveCodingScopedWriteNamespace (memory_store / suggestion_submit parity, rule 39)", async () => {
   // Regression guard: observe's effective scope MUST be identical to what the
   // explicit-write tools (memory_store / suggestion_submit) resolve via