@graphorin/memory 0.5.0

package/dist/errors/index.d.ts

@@ -0,0 +1,171 @@
+//#region src/errors/index.d.ts
+/**
+ * Typed error classes raised by `@graphorin/memory`. Every memory
+ * subsystem throws one of these instead of plain `Error` so consumers
+ * can pattern-match on `kind` and `name` without parsing the message.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Base class for every error raised by `@graphorin/memory`. Carries a
+ * stable lowercase `kind` discriminator and an optional `hint`
+ * surfaced to operators (CLI command / docs link to fix the issue).
+ *
+ * @stable
+ */
+declare abstract class GraphorinMemoryError extends Error {
+  /** Stable lowercase discriminator. */
+  abstract readonly kind: string;
+  /** Optional actionable hint surfaced to operators. */
+  readonly hint?: string;
+  constructor(message: string, options?: {
+    cause?: unknown;
+    hint?: string;
+  });
+}
+/**
+ * Raised when a memory write would reference an embedder that is not
+ * registered in the storage layer's `embedding_meta` registry.
+ *
+ * @stable
+ */
+declare class EmbedderRegistrationError extends GraphorinMemoryError {
+  readonly name = "EmbedderRegistrationError";
+  readonly kind: "embedder-registration";
+  readonly embedderId: string;
+  constructor(embedderId: string, options?: {
+    cause?: unknown;
+  });
+}
+/**
+ * Raised when a memory tool is invoked outside the per-tool ACL or the
+ * memory-modification guard tier rejects the call.
+ *
+ * @stable
+ */
+declare class MemoryToolDeniedError extends GraphorinMemoryError {
+  readonly name = "MemoryToolDeniedError";
+  readonly kind: "memory-tool-denied";
+  readonly toolName: string;
+  readonly reason: string;
+  constructor(toolName: string, reason: string);
+}
+/**
+ * Raised by `WorkingMemory` when a write would exceed the declared
+ * `charLimit` and the overflow policy is `'reject'`.
+ *
+ * @stable
+ */
+declare class WorkingBlockOverflowError extends GraphorinMemoryError {
+  readonly name = "WorkingBlockOverflowError";
+  readonly kind: "working-block-overflow";
+  readonly label: string;
+  readonly attempted: number;
+  readonly charLimit: number;
+  constructor(label: string, attempted: number, charLimit: number);
+}
+/**
+ * Raised by `WorkingMemory.replace(...)` when the supplied unique
+ * substring is not present (or appears more than once) in the block
+ * value.
+ *
+ * @stable
+ */
+declare class WorkingBlockReplaceMismatchError extends GraphorinMemoryError {
+  readonly name = "WorkingBlockReplaceMismatchError";
+  readonly kind: "working-block-replace-mismatch";
+  readonly label: string;
+  readonly occurrences: number;
+  constructor(label: string, occurrences: number);
+}
+/**
+ * Thrown when any mutation targets a block defined with
+ * `readOnly: true` (MRET-14). Previously this guard threw
+ * `WorkingBlockReplaceMismatchError(label, 0)` — semantically "your
+ * unique substring matched 0 times", which misled callers that retry
+ * replace operations on mismatch.
+ *
+ * @stable
+ */
+declare class WorkingBlockReadOnlyError extends GraphorinMemoryError {
+  readonly name = "WorkingBlockReadOnlyError";
+  readonly kind: "working-block-read-only";
+  readonly label: string;
+  constructor(label: string);
+}
+/**
+ * Raised by the embedder migration runner when the operator attempts a
+ * silent embedder swap under the `lock-on-first` policy.
+ *
+ * @stable
+ */
+declare class EmbedderMigrationLockedError extends GraphorinMemoryError {
+  readonly name = "EmbedderMigrationLockedError";
+  readonly kind: "embedder-migration-locked";
+  readonly source: string;
+  readonly target: string;
+  constructor(source: string, target: string);
+}
+/**
+ * Raised by `migrateEmbedder(...)` when the runner is interrupted via
+ * `AbortSignal`. The surrounding `for-await` loop receives this error so
+ * the operator can re-run the migration. MST-12: there is no persisted
+ * cursor today, so a re-run restarts from the beginning.
+ *
+ * @stable
+ */
+declare class EmbedderMigrationAbortedError extends GraphorinMemoryError {
+  readonly name = "EmbedderMigrationAbortedError";
+  readonly kind: "embedder-migration-aborted";
+  readonly migrationId: string;
+  constructor(migrationId: string);
+}
+/**
+ * Raised by the migration runner when the migration references embedders
+ * that are no longer registered (e.g. the operator removed the underlying
+ * tables manually).
+ *
+ * @stable
+ */
+declare class EmbedderMigrationStateError extends GraphorinMemoryError {
+  readonly name = "EmbedderMigrationStateError";
+  readonly kind: "embedder-migration-state";
+  constructor(message: string);
+}
+/**
+ * Raised by {@link SemanticMemory.validate} (P1-4 / MRET-3) when a caller
+ * tries to promote a fact whose quarantine was triggered by the offline
+ * injection heuristics. Such a fact is a memory-poisoning candidate: the
+ * agent's own `fact_validate` tool must never be able to admit it into
+ * action-driving recall, so promotion is refused unless an operator
+ * passes the explicit `force` flag through the programmatic API.
+ *
+ * @stable
+ */
+declare class QuarantinePromotionRefusedError extends GraphorinMemoryError {
+  readonly name = "QuarantinePromotionRefusedError";
+  readonly kind: "quarantine-promotion-refused";
+  readonly factId: string;
+  /** Injection-rule labels that tripped on the fact's text. */
+  readonly markers: ReadonlyArray<string>;
+  constructor(factId: string, markers: ReadonlyArray<string>);
+}
+/**
+ * Raised when {@link ProceduralMemory.induce} (P2-2) is called but no
+ * workflow inducer was configured. Induction abstracts concrete values into
+ * variables, which needs a provider — so the capability is opt-in and the
+ * default (offline) procedural tier never silently no-ops a requested
+ * induction.
+ *
+ * @stable
+ */
+declare class ProcedureInductionNotConfiguredError extends GraphorinMemoryError {
+  readonly name = "ProcedureInductionNotConfiguredError";
+  readonly kind: "procedure-induction-not-configured";
+  constructor(options?: {
+    cause?: unknown;
+  });
+}
+//#endregion
+export { EmbedderMigrationAbortedError, EmbedderMigrationLockedError, EmbedderMigrationStateError, EmbedderRegistrationError, GraphorinMemoryError, MemoryToolDeniedError, ProcedureInductionNotConfiguredError, QuarantinePromotionRefusedError, WorkingBlockOverflowError, WorkingBlockReadOnlyError, WorkingBlockReplaceMismatchError };
+//# sourceMappingURL=index.d.ts.map

package/dist/errors/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/errors/index.ts"],"sourcesContent":[],"mappings":";;AAeA;AAoBA;AAyBA;AAqBA;AA2BA;AA2BA;AAmBA;AA2BA;AAwBA;AAqBA;;;;AAAyE,uBAnNnD,oBAAA,SAA6B,KAAA,CAmNsB;EA+B5D;;;;;;;;;;;;;;;cA9NA,yBAAA,SAAkC,oBAAA;;;;;;;;;;;;;;cAyBlC,qBAAA,SAA8B,oBAAA;;;;;;;;;;;;;cAqB9B,yBAAA,SAAkC,oBAAA;;;;;;;;;;;;;;;cA2BlC,gCAAA,SAAyC,oBAAA;;;;;;;;;;;;;;;;cA2BzC,yBAAA,SAAkC,oBAAA;;;;;;;;;;;;cAmBlC,4BAAA,SAAqC,oBAAA;;;;;;;;;;;;;;;cA2BrC,6BAAA,SAAsC,oBAAA;;;;;;;;;;;;;cAwBtC,2BAAA,SAAoC,oBAAA;;;;;;;;;;;;;;;cAqBpC,+BAAA,SAAwC,oBAAA;;;;;oBAKjC;uCAEmB;;;;;;;;;;;cAwB1B,oCAAA,SAA6C,oBAAA"}

package/dist/errors/index.js

@@ -0,0 +1,206 @@
+//#region src/errors/index.ts
+/**
+* Typed error classes raised by `@graphorin/memory`. Every memory
+* subsystem throws one of these instead of plain `Error` so consumers
+* can pattern-match on `kind` and `name` without parsing the message.
+*
+* @packageDocumentation
+*/
+/**
+* Base class for every error raised by `@graphorin/memory`. Carries a
+* stable lowercase `kind` discriminator and an optional `hint`
+* surfaced to operators (CLI command / docs link to fix the issue).
+*
+* @stable
+*/
+var GraphorinMemoryError = class extends Error {
+	/** Optional actionable hint surfaced to operators. */
+	hint;
+	constructor(message, options) {
+		super(message, options !== void 0 && "cause" in options ? { cause: options.cause } : {});
+		if (options?.hint !== void 0) this.hint = options.hint;
+	}
+};
+/**
+* Raised when a memory write would reference an embedder that is not
+* registered in the storage layer's `embedding_meta` registry.
+*
+* @stable
+*/
+var EmbedderRegistrationError = class extends GraphorinMemoryError {
+	name = "EmbedderRegistrationError";
+	kind = "embedder-registration";
+	embedderId;
+	constructor(embedderId, options) {
+		super(`[graphorin/memory] embedder '${embedderId}' is not registered. createMemory({ embedder, ... }) registers the configured embedder; manual writes must reference an already-registered embedder_id.`, {
+			...options?.cause !== void 0 ? { cause: options.cause } : {},
+			hint: "Pass `embedder` to createMemory(...) so the registration runs at startup."
+		});
+		this.embedderId = embedderId;
+	}
+};
+/**
+* Raised when a memory tool is invoked outside the per-tool ACL or the
+* memory-modification guard tier rejects the call.
+*
+* @stable
+*/
+var MemoryToolDeniedError = class extends GraphorinMemoryError {
+	name = "MemoryToolDeniedError";
+	kind = "memory-tool-denied";
+	toolName;
+	reason;
+	constructor(toolName, reason) {
+		super(`[graphorin/memory] memory tool '${toolName}' was denied: ${reason}`, { hint: "Check the tool authorisation matrix and the memory-modification guard tier policy." });
+		this.toolName = toolName;
+		this.reason = reason;
+	}
+};
+/**
+* Raised by `WorkingMemory` when a write would exceed the declared
+* `charLimit` and the overflow policy is `'reject'`.
+*
+* @stable
+*/
+var WorkingBlockOverflowError = class extends GraphorinMemoryError {
+	name = "WorkingBlockOverflowError";
+	kind = "working-block-overflow";
+	label;
+	attempted;
+	charLimit;
+	constructor(label, attempted, charLimit) {
+		super(`[graphorin/memory] working block '${label}' overflow: attempted ${attempted} chars, limit is ${charLimit}.`, { hint: "Switch the block's overflow policy to 'truncate' or shorten the input." });
+		this.label = label;
+		this.attempted = attempted;
+		this.charLimit = charLimit;
+	}
+};
+/**
+* Raised by `WorkingMemory.replace(...)` when the supplied unique
+* substring is not present (or appears more than once) in the block
+* value.
+*
+* @stable
+*/
+var WorkingBlockReplaceMismatchError = class extends GraphorinMemoryError {
+	name = "WorkingBlockReplaceMismatchError";
+	kind = "working-block-replace-mismatch";
+	label;
+	occurrences;
+	constructor(label, occurrences) {
+		super(`[graphorin/memory] block_replace on '${label}' expected exactly one occurrence of the unique substring, found ${occurrences}.`, { hint: "Pass a longer unique substring or use block_rethink to replace the entire value." });
+		this.label = label;
+		this.occurrences = occurrences;
+	}
+};
+/**
+* Thrown when any mutation targets a block defined with
+* `readOnly: true` (MRET-14). Previously this guard threw
+* `WorkingBlockReplaceMismatchError(label, 0)` — semantically "your
+* unique substring matched 0 times", which misled callers that retry
+* replace operations on mismatch.
+*
+* @stable
+*/
+var WorkingBlockReadOnlyError = class extends GraphorinMemoryError {
+	name = "WorkingBlockReadOnlyError";
+	kind = "working-block-read-only";
+	label;
+	constructor(label) {
+		super(`[graphorin/memory] block '${label}' is read-only — mutations are not allowed.`, { hint: "Define the block without readOnly, or write through an operator path that redefines it." });
+		this.label = label;
+	}
+};
+/**
+* Raised by the embedder migration runner when the operator attempts a
+* silent embedder swap under the `lock-on-first` policy.
+*
+* @stable
+*/
+var EmbedderMigrationLockedError = class extends GraphorinMemoryError {
+	name = "EmbedderMigrationLockedError";
+	kind = "embedder-migration-locked";
+	source;
+	target;
+	constructor(source, target) {
+		super(`[graphorin/memory] cannot swap embedder from '${source}' to '${target}' under the 'lock-on-first' policy. Run \`graphorin memory migrate\` (Phase 15) or pass \`policy: "auto-migrate"\` / "multi-active".`, { hint: "Plan an explicit migration before swapping the active embedder." });
+		this.source = source;
+		this.target = target;
+	}
+};
+/**
+* Raised by `migrateEmbedder(...)` when the runner is interrupted via
+* `AbortSignal`. The surrounding `for-await` loop receives this error so
+* the operator can re-run the migration. MST-12: there is no persisted
+* cursor today, so a re-run restarts from the beginning.
+*
+* @stable
+*/
+var EmbedderMigrationAbortedError = class extends GraphorinMemoryError {
+	name = "EmbedderMigrationAbortedError";
+	kind = "embedder-migration-aborted";
+	migrationId;
+	constructor(migrationId) {
+		super(`[graphorin/memory] embedder migration '${migrationId}' aborted before completion. Re-run \`migrateEmbedder(...)\` to restart (there is no persisted cursor yet, so it begins again).`, { hint: "Re-invoke migrateEmbedder(...) to restart the migration." });
+		this.migrationId = migrationId;
+	}
+};
+/**
+* Raised by the migration runner when the migration references embedders
+* that are no longer registered (e.g. the operator removed the underlying
+* tables manually).
+*
+* @stable
+*/
+var EmbedderMigrationStateError = class extends GraphorinMemoryError {
+	name = "EmbedderMigrationStateError";
+	kind = "embedder-migration-state";
+	constructor(message) {
+		super(`[graphorin/memory] ${message}`, { hint: "Re-register the source/target embedders (or re-run with the current ones) before retrying." });
+	}
+};
+/**
+* Raised by {@link SemanticMemory.validate} (P1-4 / MRET-3) when a caller
+* tries to promote a fact whose quarantine was triggered by the offline
+* injection heuristics. Such a fact is a memory-poisoning candidate: the
+* agent's own `fact_validate` tool must never be able to admit it into
+* action-driving recall, so promotion is refused unless an operator
+* passes the explicit `force` flag through the programmatic API.
+*
+* @stable
+*/
+var QuarantinePromotionRefusedError = class extends GraphorinMemoryError {
+	name = "QuarantinePromotionRefusedError";
+	kind = "quarantine-promotion-refused";
+	factId;
+	/** Injection-rule labels that tripped on the fact's text. */
+	markers;
+	constructor(factId, markers) {
+		super(`[graphorin/memory] refusing to promote fact '${factId}' out of quarantine: its text trips the injection heuristics (${markers.join(", ")}). Promotion of an injection-flagged memory is an operator action — pass \`{ force: true }\` to validate(...) from a trusted (non-agent) caller after review.`, { hint: "Review the quarantined fact, then promote it with validate(scope, id, reason, { force: true }) from an operator context." });
+		this.factId = factId;
+		this.markers = Object.freeze([...markers]);
+	}
+};
+/**
+* Raised when {@link ProceduralMemory.induce} (P2-2) is called but no
+* workflow inducer was configured. Induction abstracts concrete values into
+* variables, which needs a provider — so the capability is opt-in and the
+* default (offline) procedural tier never silently no-ops a requested
+* induction.
+*
+* @stable
+*/
+var ProcedureInductionNotConfiguredError = class extends GraphorinMemoryError {
+	name = "ProcedureInductionNotConfiguredError";
+	kind = "procedure-induction-not-configured";
+	constructor(options) {
+		super("[graphorin/memory] procedure induction requires a provider. ProceduralMemory.induce(...) needs an inducer to abstract values into variables; enable it with createMemory({ procedureInduction: { provider } }).", {
+			...options?.cause !== void 0 ? { cause: options.cause } : {},
+			hint: "Pass `procedureInduction: { provider }` to createMemory(...)."
+		});
+	}
+};
+
+//#endregion
+export { EmbedderMigrationAbortedError, EmbedderMigrationLockedError, EmbedderMigrationStateError, EmbedderRegistrationError, GraphorinMemoryError, MemoryToolDeniedError, ProcedureInductionNotConfiguredError, QuarantinePromotionRefusedError, WorkingBlockOverflowError, WorkingBlockReadOnlyError, WorkingBlockReplaceMismatchError };
+//# sourceMappingURL=index.js.map

package/dist/errors/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/errors/index.ts"],"sourcesContent":["/**\n * Typed error classes raised by `@graphorin/memory`. Every memory\n * subsystem throws one of these instead of plain `Error` so consumers\n * can pattern-match on `kind` and `name` without parsing the message.\n *\n * @packageDocumentation\n */\n\n/**\n * Base class for every error raised by `@graphorin/memory`. Carries a\n * stable lowercase `kind` discriminator and an optional `hint`\n * surfaced to operators (CLI command / docs link to fix the issue).\n *\n * @stable\n */\nexport abstract class GraphorinMemoryError extends Error {\n  /** Stable lowercase discriminator. */\n  abstract readonly kind: string;\n  /** Optional actionable hint surfaced to operators. */\n  readonly hint?: string;\n\n  constructor(message: string, options?: { cause?: unknown; hint?: string }) {\n    super(message, options !== undefined && 'cause' in options ? { cause: options.cause } : {});\n    if (options?.hint !== undefined) {\n      this.hint = options.hint;\n    }\n  }\n}\n\n/**\n * Raised when a memory write would reference an embedder that is not\n * registered in the storage layer's `embedding_meta` registry.\n *\n * @stable\n */\nexport class EmbedderRegistrationError extends GraphorinMemoryError {\n  override readonly name = 'EmbedderRegistrationError';\n  readonly kind = 'embedder-registration' as const;\n  readonly embedderId: string;\n\n  constructor(embedderId: string, options?: { cause?: unknown }) {\n    super(\n      `[graphorin/memory] embedder '${embedderId}' is not registered. ` +\n        'createMemory({ embedder, ... }) registers the configured embedder; ' +\n        'manual writes must reference an already-registered embedder_id.',\n      {\n        ...(options?.cause !== undefined ? { cause: options.cause } : {}),\n        hint: 'Pass `embedder` to createMemory(...) so the registration runs at startup.',\n      },\n    );\n    this.embedderId = embedderId;\n  }\n}\n\n/**\n * Raised when a memory tool is invoked outside the per-tool ACL or the\n * memory-modification guard tier rejects the call.\n *\n * @stable\n */\nexport class MemoryToolDeniedError extends GraphorinMemoryError {\n  override readonly name = 'MemoryToolDeniedError';\n  readonly kind = 'memory-tool-denied' as const;\n  readonly toolName: string;\n  readonly reason: string;\n\n  constructor(toolName: string, reason: string) {\n    super(`[graphorin/memory] memory tool '${toolName}' was denied: ${reason}`, {\n      hint: 'Check the tool authorisation matrix and the memory-modification guard tier policy.',\n    });\n    this.toolName = toolName;\n    this.reason = reason;\n  }\n}\n\n/**\n * Raised by `WorkingMemory` when a write would exceed the declared\n * `charLimit` and the overflow policy is `'reject'`.\n *\n * @stable\n */\nexport class WorkingBlockOverflowError extends GraphorinMemoryError {\n  override readonly name = 'WorkingBlockOverflowError';\n  readonly kind = 'working-block-overflow' as const;\n  readonly label: string;\n  readonly attempted: number;\n  readonly charLimit: number;\n\n  constructor(label: string, attempted: number, charLimit: number) {\n    super(\n      `[graphorin/memory] working block '${label}' overflow: attempted ${attempted} chars, limit is ${charLimit}.`,\n      {\n        hint: \"Switch the block's overflow policy to 'truncate' or shorten the input.\",\n      },\n    );\n    this.label = label;\n    this.attempted = attempted;\n    this.charLimit = charLimit;\n  }\n}\n\n/**\n * Raised by `WorkingMemory.replace(...)` when the supplied unique\n * substring is not present (or appears more than once) in the block\n * value.\n *\n * @stable\n */\nexport class WorkingBlockReplaceMismatchError extends GraphorinMemoryError {\n  override readonly name = 'WorkingBlockReplaceMismatchError';\n  readonly kind = 'working-block-replace-mismatch' as const;\n  readonly label: string;\n  readonly occurrences: number;\n\n  constructor(label: string, occurrences: number) {\n    super(\n      `[graphorin/memory] block_replace on '${label}' expected exactly one occurrence of the unique substring, found ${occurrences}.`,\n      {\n        hint: 'Pass a longer unique substring or use block_rethink to replace the entire value.',\n      },\n    );\n    this.label = label;\n    this.occurrences = occurrences;\n  }\n}\n\n/**\n * Thrown when any mutation targets a block defined with\n * `readOnly: true` (MRET-14). Previously this guard threw\n * `WorkingBlockReplaceMismatchError(label, 0)` — semantically \"your\n * unique substring matched 0 times\", which misled callers that retry\n * replace operations on mismatch.\n *\n * @stable\n */\nexport class WorkingBlockReadOnlyError extends GraphorinMemoryError {\n  override readonly name = 'WorkingBlockReadOnlyError';\n  readonly kind = 'working-block-read-only' as const;\n  readonly label: string;\n\n  constructor(label: string) {\n    super(`[graphorin/memory] block '${label}' is read-only — mutations are not allowed.`, {\n      hint: 'Define the block without readOnly, or write through an operator path that redefines it.',\n    });\n    this.label = label;\n  }\n}\n\n/**\n * Raised by the embedder migration runner when the operator attempts a\n * silent embedder swap under the `lock-on-first` policy.\n *\n * @stable\n */\nexport class EmbedderMigrationLockedError extends GraphorinMemoryError {\n  override readonly name = 'EmbedderMigrationLockedError';\n  readonly kind = 'embedder-migration-locked' as const;\n  readonly source: string;\n  readonly target: string;\n\n  constructor(source: string, target: string) {\n    super(\n      `[graphorin/memory] cannot swap embedder from '${source}' to '${target}' under the 'lock-on-first' policy. ` +\n        'Run `graphorin memory migrate` (Phase 15) or pass `policy: \"auto-migrate\"` / \"multi-active\".',\n      {\n        hint: 'Plan an explicit migration before swapping the active embedder.',\n      },\n    );\n    this.source = source;\n    this.target = target;\n  }\n}\n\n/**\n * Raised by `migrateEmbedder(...)` when the runner is interrupted via\n * `AbortSignal`. The surrounding `for-await` loop receives this error so\n * the operator can re-run the migration. MST-12: there is no persisted\n * cursor today, so a re-run restarts from the beginning.\n *\n * @stable\n */\nexport class EmbedderMigrationAbortedError extends GraphorinMemoryError {\n  override readonly name = 'EmbedderMigrationAbortedError';\n  readonly kind = 'embedder-migration-aborted' as const;\n  readonly migrationId: string;\n\n  constructor(migrationId: string) {\n    super(\n      `[graphorin/memory] embedder migration '${migrationId}' aborted before completion. ` +\n        'Re-run `migrateEmbedder(...)` to restart (there is no persisted cursor yet, so it begins again).',\n      {\n        hint: 'Re-invoke migrateEmbedder(...) to restart the migration.',\n      },\n    );\n    this.migrationId = migrationId;\n  }\n}\n\n/**\n * Raised by the migration runner when the migration references embedders\n * that are no longer registered (e.g. the operator removed the underlying\n * tables manually).\n *\n * @stable\n */\nexport class EmbedderMigrationStateError extends GraphorinMemoryError {\n  override readonly name = 'EmbedderMigrationStateError';\n  readonly kind = 'embedder-migration-state' as const;\n\n  constructor(message: string) {\n    super(`[graphorin/memory] ${message}`, {\n      hint: 'Re-register the source/target embedders (or re-run with the current ones) before retrying.',\n    });\n  }\n}\n\n/**\n * Raised by {@link SemanticMemory.validate} (P1-4 / MRET-3) when a caller\n * tries to promote a fact whose quarantine was triggered by the offline\n * injection heuristics. Such a fact is a memory-poisoning candidate: the\n * agent's own `fact_validate` tool must never be able to admit it into\n * action-driving recall, so promotion is refused unless an operator\n * passes the explicit `force` flag through the programmatic API.\n *\n * @stable\n */\nexport class QuarantinePromotionRefusedError extends GraphorinMemoryError {\n  override readonly name = 'QuarantinePromotionRefusedError';\n  readonly kind = 'quarantine-promotion-refused' as const;\n  readonly factId: string;\n  /** Injection-rule labels that tripped on the fact's text. */\n  readonly markers: ReadonlyArray<string>;\n\n  constructor(factId: string, markers: ReadonlyArray<string>) {\n    super(\n      `[graphorin/memory] refusing to promote fact '${factId}' out of quarantine: ` +\n        `its text trips the injection heuristics (${markers.join(', ')}). ` +\n        'Promotion of an injection-flagged memory is an operator action — ' +\n        'pass `{ force: true }` to validate(...) from a trusted (non-agent) caller after review.',\n      {\n        hint: 'Review the quarantined fact, then promote it with validate(scope, id, reason, { force: true }) from an operator context.',\n      },\n    );\n    this.factId = factId;\n    this.markers = Object.freeze([...markers]);\n  }\n}\n\n/**\n * Raised when {@link ProceduralMemory.induce} (P2-2) is called but no\n * workflow inducer was configured. Induction abstracts concrete values into\n * variables, which needs a provider — so the capability is opt-in and the\n * default (offline) procedural tier never silently no-ops a requested\n * induction.\n *\n * @stable\n */\nexport class ProcedureInductionNotConfiguredError extends GraphorinMemoryError {\n  override readonly name = 'ProcedureInductionNotConfiguredError';\n  readonly kind = 'procedure-induction-not-configured' as const;\n\n  constructor(options?: { cause?: unknown }) {\n    super(\n      '[graphorin/memory] procedure induction requires a provider. ' +\n        'ProceduralMemory.induce(...) needs an inducer to abstract values into ' +\n        'variables; enable it with createMemory({ procedureInduction: { provider } }).',\n      {\n        ...(options?.cause !== undefined ? { cause: options.cause } : {}),\n        hint: 'Pass `procedureInduction: { provider }` to createMemory(...).',\n      },\n    );\n  }\n}\n"],"mappings":"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"}