@anchrd/intel-contract 0.21.0 → 0.22.0

package/dist/contract/bundle.d.ts

@@ -57,11 +57,30 @@ export declare const BundleManifestEntry: z.ZodObject<{
     }>>;
 }, z.core.$strict>;
 export type BundleManifestEntry = z.infer<typeof BundleManifestEntry>;
+/**
+ * What an export leaves out on purpose, named so a bundle says it rather than a reader guessing:
+ * version history, grants/shares, flow runs, and archived nodes are not in any bundle (#136).
+ *
+ * ⚠️ `unpublished-flow-changes` is the FIFTH, and it is the one exception to ADR-0006's own
+ * headline (#585). A bundle carries the current state of everything — except a flow that has been
+ * published, which travels as its PUBLISHED graph. Edits made after that publication are in no
+ * bundle, and they are not history: they are the newest state there is. The word exists because the
+ * loss is only acceptable while it is named, and `version-history` does not name it — a reader who
+ * saw only that word would expect the newest graph and get one that is deliberately older.
+ *
+ * ⚠️ These are WIRE values: an older reader refuses a bundle naming an exclusion it does not know,
+ * the same way it would refuse an unknown `kind`. The enum grows only for something an installation
+ * genuinely leaves behind, never as a place to note a nicety (ADR-0006, #433). Growing it costs the
+ * direction nobody migrates in — a bundle written HERE is refused by an installation older than
+ * this line, while every bundle written before it still parses, which is the direction 0.22.0's
+ * rebuild actually runs.
+ */
 export declare const BundleExclusion: z.ZodEnum<{
     "version-history": "version-history";
     grants: "grants";
     "flow-runs": "flow-runs";
     "archived-nodes": "archived-nodes";
+    "unpublished-flow-changes": "unpublished-flow-changes";
 }>;
 export type BundleExclusion = z.infer<typeof BundleExclusion>;
 export declare const BundleManifest: z.ZodObject<{
@@ -92,13 +111,37 @@ export declare const BundleManifest: z.ZodObject<{
         grants: "grants";
         "flow-runs": "flow-runs";
         "archived-nodes": "archived-nodes";
+        "unpublished-flow-changes": "unpublished-flow-changes";
     }>>;
 }, z.core.$strict>;
 export type BundleManifest = z.infer<typeof BundleManifest>;
+/**
+ * What one import made. Import always creates new nodes — no merge, no overwrite, no restored IDs
+ * (#137, phase 1) — so the answer is counts and the new roots, never a diff. `replayed` marks the
+ * idempotent second answer to the same key: nothing was created twice.
+ *
+ * ⚠️ `excluded` is what the IMPORT knows about itself, never what the bundle claimed (ADR-0006,
+ * #433). A subtree moved between installations arrives with one version per node, no grants and no
+ * runs, and until now nothing said so at the moment somebody could still act on it — the word stood
+ * only in a `manifest.json` inside the zip that had already been written.
+ *
+ * It is deliberately NOT read back out of that manifest. A hand-written bundle saying `excluded: []`
+ * would then make the import report that nothing was left behind, and the import would launder
+ * somebody else's claim into an answer that sounds like its own — the trap `absence` is bound
+ * against in `BundleManifestEntry` above (#534, #560). The five exclusions hold for every import
+ * this build performs, with a manifest or from a naked folder, so this is a constant of the code.
+ */
 export declare const BundleImportResult: z.ZodObject<{
     nodes: z.ZodNumber;
     flows: z.ZodNumber;
     rootNodeIds: z.ZodArray<z.ZodString>;
     replayed: z.ZodBoolean;
+    excluded: z.ZodArray<z.ZodEnum<{
+        "version-history": "version-history";
+        grants: "grants";
+        "flow-runs": "flow-runs";
+        "archived-nodes": "archived-nodes";
+        "unpublished-flow-changes": "unpublished-flow-changes";
+    }>>;
 }, z.core.$strict>;
 export type BundleImportResult = z.infer<typeof BundleImportResult>;

package/dist/contract/bundle.js

@@ -79,9 +79,31 @@ export const BundleManifestEntry = z
     message: "Only a table or attachment entry may declare an absence",
     path: ["absence"],
 });
-// What an export leaves out on purpose, named so a bundle says it rather than a reader guessing:
-// version history, grants/shares, flow runs, and archived nodes are not in any bundle (#136).
-export const BundleExclusion = z.enum(["version-history", "grants", "flow-runs", "archived-nodes"]);
+/**
+ * What an export leaves out on purpose, named so a bundle says it rather than a reader guessing:
+ * version history, grants/shares, flow runs, and archived nodes are not in any bundle (#136).
+ *
+ * ⚠️ `unpublished-flow-changes` is the FIFTH, and it is the one exception to ADR-0006's own
+ * headline (#585). A bundle carries the current state of everything — except a flow that has been
+ * published, which travels as its PUBLISHED graph. Edits made after that publication are in no
+ * bundle, and they are not history: they are the newest state there is. The word exists because the
+ * loss is only acceptable while it is named, and `version-history` does not name it — a reader who
+ * saw only that word would expect the newest graph and get one that is deliberately older.
+ *
+ * ⚠️ These are WIRE values: an older reader refuses a bundle naming an exclusion it does not know,
+ * the same way it would refuse an unknown `kind`. The enum grows only for something an installation
+ * genuinely leaves behind, never as a place to note a nicety (ADR-0006, #433). Growing it costs the
+ * direction nobody migrates in — a bundle written HERE is refused by an installation older than
+ * this line, while every bundle written before it still parses, which is the direction 0.22.0's
+ * rebuild actually runs.
+ */
+export const BundleExclusion = z.enum([
+    "version-history",
+    "grants",
+    "flow-runs",
+    "archived-nodes",
+    "unpublished-flow-changes",
+]);
 export const BundleManifest = z.strictObject({
     version: z.literal(1),
     exportedAt: IsoDateTime,
@@ -92,12 +114,26 @@ export const BundleManifest = z.strictObject({
     excluded: z.array(BundleExclusion),
 });
 // ── Bundle import (#137) ────────────────────────────────────────────────────────────────────────
-// What one import made. Import always creates new nodes — no merge, no overwrite, no restored IDs
-// (#137, phase 1) — so the answer is counts and the new roots, never a diff. `replayed` marks the
-// idempotent second answer to the same key: nothing was created twice.
+/**
+ * What one import made. Import always creates new nodes — no merge, no overwrite, no restored IDs
+ * (#137, phase 1) — so the answer is counts and the new roots, never a diff. `replayed` marks the
+ * idempotent second answer to the same key: nothing was created twice.
+ *
+ * ⚠️ `excluded` is what the IMPORT knows about itself, never what the bundle claimed (ADR-0006,
+ * #433). A subtree moved between installations arrives with one version per node, no grants and no
+ * runs, and until now nothing said so at the moment somebody could still act on it — the word stood
+ * only in a `manifest.json` inside the zip that had already been written.
+ *
+ * It is deliberately NOT read back out of that manifest. A hand-written bundle saying `excluded: []`
+ * would then make the import report that nothing was left behind, and the import would launder
+ * somebody else's claim into an answer that sounds like its own — the trap `absence` is bound
+ * against in `BundleManifestEntry` above (#534, #560). The five exclusions hold for every import
+ * this build performs, with a manifest or from a naked folder, so this is a constant of the code.
+ */
 export const BundleImportResult = z.strictObject({
     nodes: z.number().int().nonnegative(),
     flows: z.number().int().nonnegative(),
     rootNodeIds: z.array(IntelId),
     replayed: z.boolean(),
+    excluded: z.array(BundleExclusion),
 });

package/dist/contract/contract.d.ts

@@ -38,6 +38,38 @@ export declare const IdempotencyKey: z.ZodString;
 export declare function baseVersion(rule: string): z.ZodUnion<readonly [z.ZodString, z.ZodNull]>;
 export declare const UI_LANGUAGES: readonly ["en", "de", "es"];
 export type UiLanguage = (typeof UI_LANGUAGES)[number];
+/**
+ * A set of things the reader is only partly entitled to see: the ones they may see BY NAME, the
+ * rest as a NUMBER (ADR-0004 §3). Never the titles of the rest, in any field, ever — a warning or a
+ * refusal must not become a way of reading the tree.
+ *
+ * ⚠️ It lives here rather than in `share.ts` because two domains state it: a grant says what it
+ * does not reach (`UnreadableNodes`), and a refusal says who is still calling in
+ * (`ProblemDetails.callers`, #448). `contract.ts` may not import from `share.ts` — the graph
+ * between these files has to stay acyclic — and a copy would be a second place for one rule to
+ * drift, which is what `IdempotencyKey` and `baseVersion` above exist against.
+ */
+export declare const NamedOrCounted: z.ZodObject<{
+    titles: z.ZodArray<z.ZodString>;
+    hidden: z.ZodNumber;
+}, z.core.$strict>;
+export type NamedOrCounted = z.infer<typeof NamedOrCounted>;
+/**
+ * ⚠️ `callers` is the one member here that is not about every problem, and it is deliberate (#448).
+ * RFC 9457 allows extension members for exactly this: `folder_execute_in_use` refuses to narrow a
+ * library folder while flows from outside still call into it, and the CALLERS are the only thing
+ * that makes the refusal actionable. They used to exist only inside `detail` — an English sentence
+ * built on the server — so a German or Spanish surface could do nothing but print it verbatim, and
+ * no surface could shorten it or link the titles.
+ *
+ * The split is the point: the server decides WHAT is named and what is only counted, because that
+ * is an authorization answer nobody else can give; the surface decides how the sentence READS,
+ * because that is a language answer no server can give.
+ *
+ * `detail` keeps its sentence rather than emptying out — MCP hands a model prose and has nothing to
+ * formulate with, and an empty `detail` beside a new field would be the worst of the three states.
+ * It is absent on every other problem, so a reader must not treat its presence as guaranteed.
+ */
 export declare const ProblemDetails: z.ZodObject<{
     type: z.ZodString;
     status: z.ZodNumber;
@@ -45,6 +77,10 @@ export declare const ProblemDetails: z.ZodObject<{
     detail: z.ZodOptional<z.ZodString>;
     instance: z.ZodOptional<z.ZodString>;
     code: z.ZodOptional<z.ZodString>;
+    callers: z.ZodOptional<z.ZodObject<{
+        titles: z.ZodArray<z.ZodString>;
+        hidden: z.ZodNumber;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 export type ProblemDetails = z.infer<typeof ProblemDetails>;
 export declare const SessionUser: z.ZodObject<{

package/dist/contract/contract.js

@@ -57,6 +57,37 @@ export function baseVersion(rule) {
 // `i18n.unit.ts` compares it against the catalogs actually built in; a language listed here without
 // a file gives a red run there instead of a UI that starts on a catalog which does not exist.
 export const UI_LANGUAGES = ["en", "de", "es"];
+/**
+ * A set of things the reader is only partly entitled to see: the ones they may see BY NAME, the
+ * rest as a NUMBER (ADR-0004 §3). Never the titles of the rest, in any field, ever — a warning or a
+ * refusal must not become a way of reading the tree.
+ *
+ * ⚠️ It lives here rather than in `share.ts` because two domains state it: a grant says what it
+ * does not reach (`UnreadableNodes`), and a refusal says who is still calling in
+ * (`ProblemDetails.callers`, #448). `contract.ts` may not import from `share.ts` — the graph
+ * between these files has to stay acyclic — and a copy would be a second place for one rule to
+ * drift, which is what `IdempotencyKey` and `baseVersion` above exist against.
+ */
+export const NamedOrCounted = z.strictObject({
+    titles: z.array(z.string().min(1).max(240)),
+    hidden: z.number().int().nonnegative(),
+});
+/**
+ * ⚠️ `callers` is the one member here that is not about every problem, and it is deliberate (#448).
+ * RFC 9457 allows extension members for exactly this: `folder_execute_in_use` refuses to narrow a
+ * library folder while flows from outside still call into it, and the CALLERS are the only thing
+ * that makes the refusal actionable. They used to exist only inside `detail` — an English sentence
+ * built on the server — so a German or Spanish surface could do nothing but print it verbatim, and
+ * no surface could shorten it or link the titles.
+ *
+ * The split is the point: the server decides WHAT is named and what is only counted, because that
+ * is an authorization answer nobody else can give; the surface decides how the sentence READS,
+ * because that is a language answer no server can give.
+ *
+ * `detail` keeps its sentence rather than emptying out — MCP hands a model prose and has nothing to
+ * formulate with, and an empty `detail` beside a new field would be the worst of the three states.
+ * It is absent on every other problem, so a reader must not treat its presence as guaranteed.
+ */
 export const ProblemDetails = z.strictObject({
     type: z.string(),
     status: z.number().int().min(400).max(599),
@@ -64,6 +95,7 @@ export const ProblemDetails = z.strictObject({
     detail: z.string().optional(),
     instance: z.string().optional(),
     code: z.string().optional(),
+    callers: NamedOrCounted.optional(),
 });
 // Who the caller is, as Gate resolved it from the bearer: no token, and no capability list.
 //

package/dist/contract/node.js

@@ -170,7 +170,13 @@ export const PurgeNodeInput = z.strictObject({
     nodeId: IntelId.describe("Node to delete for good. It must already be archived — a living node has no path into nothing."),
     idempotencyKey: IdempotencyKey,
 });
-export const PurgeNodePreviewInput = z.strictObject({ nodeId: IntelId });
+// The question `PurgeNodeInput` cannot be asked afterwards: what goes with it, while it is all
+// still there to be counted. Described since #586, because the count reached MCP that day — and a
+// surface that may delete without being able to look first is the state `destructive.md` calls a
+// confirmation that cannot name what disappears.
+export const PurgeNodePreviewInput = z.strictObject({
+    nodeId: IntelId.describe("Archived node a purge would delete. Answers how many items would go with it and how many documents link to it from outside, and changes nothing. A node that is not archived is refused here for the same reason node_purge refuses it."),
+});
 export const PurgeNodePreview = z.strictObject({
     inboundLinks: z.number().int().nonnegative(),
     totalItems: z.number().int().positive(),

package/dist/contract/share.d.ts

@@ -24,6 +24,14 @@ export declare const ListFlowGrantsInput: z.ZodObject<{
     flowId: z.ZodString;
 }, z.core.$strict>;
 export type ListFlowGrantsInput = z.infer<typeof ListFlowGrantsInput>;
+export declare const ListEffectiveAccessInput: z.ZodObject<{
+    resourceId: z.ZodString;
+}, z.core.$strict>;
+export type ListEffectiveAccessInput = z.infer<typeof ListEffectiveAccessInput>;
+export declare const ListFlowEffectiveAccessInput: z.ZodObject<{
+    flowId: z.ZodString;
+}, z.core.$strict>;
+export type ListFlowEffectiveAccessInput = z.infer<typeof ListFlowEffectiveAccessInput>;
 export declare const ResourceGrant: z.ZodObject<{
     id: z.ZodString;
     resourceId: z.ZodString;

package/dist/contract/share.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { IdempotencyKey, IntelId, IsoDateTime } from "./contract.js";
+import { IdempotencyKey, IntelId, IsoDateTime, NamedOrCounted } from "./contract.js";
 // ⚠️ There is no `ContextPolicy`, and it is not coming back in this shape (#76). It said whether a
 // document should be pinned into a context, be found by relevance, or be named explicitly — an
 // instruction to a retrieval Intel does not perform. Intel hands out references and the agent
@@ -23,6 +23,21 @@ export const ListGrantsInput = z.strictObject({
 export const ListFlowGrantsInput = z.strictObject({
     flowId: IntelId.describe("Flow whose direct grants to list. Access inherited from the folder it is filed in is not a grant on this flow and is not listed here."),
 });
+// ⚠️ A DIFFERENT question from the two above, not a fuller answer to them (#586). The `*GrantsInput`
+// pair asks what sits ON this one resource; these two ask who REACHES it once inheritance is
+// resolved — every grant along the folders above plus the owners, who need no grant row at all. On
+// the everyday resource, whose access comes from the folder it is filed in, the first answer is
+// empty and this one is not, so a caller that reaches for the wrong one is told "nobody" about
+// something half the organization can open.
+//
+// Two inputs rather than one widened `resourceId`, for the reason the pair above gives: the id
+// names a different table, and the queries behind them are two statements over two sets of tables.
+export const ListEffectiveAccessInput = z.strictObject({
+    resourceId: IntelId.describe("Node to answer for. The answer crosses the folders above it and names owners as well as grants, so it is not the list node_grant_list gives."),
+});
+export const ListFlowEffectiveAccessInput = z.strictObject({
+    flowId: IntelId.describe("Flow to answer for. The answer includes what the folder it is filed in passes down and names owners as well as grants, so it is not the list flow_grant_list gives."),
+});
 export const ResourceGrant = z.strictObject({
     id: IntelId,
     resourceId: IntelId,
@@ -71,10 +86,11 @@ export const RevokeFlowGrantInput = z.strictObject({
 //
 // ⚠️ `titles` holds only the documents the sharer may see; everything else is in `hidden` as a
 // number. A warning must not become a way of reading titles out of the tree.
-export const UnreadableNodes = z.strictObject({
-    titles: z.array(z.string().min(1).max(240)),
-    hidden: z.number().int().nonnegative(),
-});
+//
+// It IS `NamedOrCounted` — one schema, under the name this domain calls it by. The shape moved to
+// `contract.ts` when a refusal started carrying it too (#448); it is not restated here, because two
+// declarations of one rule are two places for it to drift.
+export const UnreadableNodes = NamedOrCounted;
 // The grant is in the answer, so the warning cannot be mistaken for a refusal: it is written first
 // and described afterwards. Blocking would force everyone who uses a central policy document to
 // duplicate it, which is the opposite of what one tree is for (ADR-0004 §4).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anchrd/intel-contract",
-  "version": "0.21.0",
+  "version": "0.22.0",
   "type": "module",
   "license": "UNLICENSED",
   "repository": {