@elizaos/plugin-personal-assistant 2.0.3-beta.5 → 2.0.3-beta.7

package/dist/lifeops/registries/feature-flag-default-pack.js

@@ -0,0 +1,36 @@
+import {
+  ALL_FEATURE_KEYS,
+  BASE_FEATURE_DEFAULTS
+} from "../feature-flags.types.js";
+import {
+  createFeatureFlagRegistry,
+  registerFeatureFlagRegistry
+} from "./feature-flag-registry.js";
+const LIFEOPS_BUILTIN_FEATURE_KEYS = new Set(ALL_FEATURE_KEYS);
+const DEFAULT_FEATURE_FLAG_PACK = ALL_FEATURE_KEYS.map((key) => {
+  const def = BASE_FEATURE_DEFAULTS[key];
+  return {
+    key,
+    label: def.label,
+    description: def.description,
+    defaultEnabled: def.enabled,
+    namespace: "core",
+    metadata: { costsMoney: def.costsMoney ? "true" : "false" }
+  };
+});
+function registerDefaultFeatureFlagPack(runtime) {
+  const registry = createFeatureFlagRegistry({
+    builtinKeys: LIFEOPS_BUILTIN_FEATURE_KEYS
+  });
+  for (const contribution of DEFAULT_FEATURE_FLAG_PACK) {
+    registry.register(contribution);
+  }
+  registerFeatureFlagRegistry(runtime, registry);
+  return registry;
+}
+export {
+  DEFAULT_FEATURE_FLAG_PACK,
+  LIFEOPS_BUILTIN_FEATURE_KEYS,
+  registerDefaultFeatureFlagPack
+};
+//# sourceMappingURL=feature-flag-default-pack.js.map

package/dist/lifeops/registries/feature-flag-default-pack.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lifeops/registries/feature-flag-default-pack.ts"],"sourcesContent":["/**\n * Default-pack of `FeatureFlagContribution`s for the closed\n * `LifeOpsFeatureKey` built-ins.\n *\n * Source of truth for the built-in shape stays at `BASE_FEATURE_DEFAULTS`\n * in `feature-flags.types.ts` (it carries the compile-time defaults that\n * `resolveFeatureDefaults` uses for Cloud-aware policy). This pack mirrors\n * those keys into the `FeatureFlagRegistry` so the registry is the single\n * runtime source of truth for \"what feature flags exist\", while the closed\n * union keeps its compile-time guarantees for typed callers like\n * `requireFeatureEnabled(runtime, \"travel.book_flight\")`.\n */\n\nimport type { IAgentRuntime } from \"@elizaos/core\";\nimport {\n  ALL_FEATURE_KEYS,\n  BASE_FEATURE_DEFAULTS,\n  type LifeOpsFeatureKey,\n} from \"../feature-flags.types.js\";\nimport {\n  createFeatureFlagRegistry,\n  type FeatureFlagContribution,\n  type FeatureFlagRegistry,\n  registerFeatureFlagRegistry,\n} from \"./feature-flag-registry.js\";\n\n/**\n * Set of compile-time built-in keys. Passed to the registry factory so\n * `registry.isBuiltin(key)` answers without re-importing the closed union.\n */\nexport const LIFEOPS_BUILTIN_FEATURE_KEYS: ReadonlySet<LifeOpsFeatureKey> =\n  new Set<LifeOpsFeatureKey>(ALL_FEATURE_KEYS);\n\n/**\n * Default contributions: one per `LifeOpsFeatureKey` built-in, mirroring\n * the compile-time `BASE_FEATURE_DEFAULTS` baseline (Cloud-link policy is\n * applied separately by `resolveFeatureDefaults`).\n */\nexport const DEFAULT_FEATURE_FLAG_PACK: readonly FeatureFlagContribution[] =\n  ALL_FEATURE_KEYS.map((key) => {\n    const def = BASE_FEATURE_DEFAULTS[key];\n    return {\n      key,\n      label: def.label,\n      description: def.description,\n      defaultEnabled: def.enabled,\n      namespace: \"core\",\n      metadata: { costsMoney: def.costsMoney ? \"true\" : \"false\" },\n    } satisfies FeatureFlagContribution;\n  });\n\n/**\n * Create a registry, register every built-in `LifeOpsFeatureKey`, and bind\n * it to the runtime. Plugin `init` calls this once during bootstrap.\n */\nexport function registerDefaultFeatureFlagPack(\n  runtime: IAgentRuntime,\n): FeatureFlagRegistry {\n  const registry = createFeatureFlagRegistry({\n    builtinKeys: LIFEOPS_BUILTIN_FEATURE_KEYS,\n  });\n  for (const contribution of DEFAULT_FEATURE_FLAG_PACK) {\n    registry.register(contribution);\n  }\n  registerFeatureFlagRegistry(runtime, registry);\n  return registry;\n}\n"],"mappings":"AAcA;AAAA,EACE;AAAA,EACA;AAAA,OAEK;AACP;AAAA,EACE;AAAA,EAGA;AAAA,OACK;AAMA,MAAM,+BACX,IAAI,IAAuB,gBAAgB;AAOtC,MAAM,4BACX,iBAAiB,IAAI,CAAC,QAAQ;AAC5B,QAAM,MAAM,sBAAsB,GAAG;AACrC,SAAO;AAAA,IACL;AAAA,IACA,OAAO,IAAI;AAAA,IACX,aAAa,IAAI;AAAA,IACjB,gBAAgB,IAAI;AAAA,IACpB,WAAW;AAAA,IACX,UAAU,EAAE,YAAY,IAAI,aAAa,SAAS,QAAQ;AAAA,EAC5D;AACF,CAAC;AAMI,SAAS,+BACd,SACqB;AACrB,QAAM,WAAW,0BAA0B;AAAA,IACzC,aAAa;AAAA,EACf,CAAC;AACD,aAAW,gBAAgB,2BAA2B;AACpD,aAAS,SAAS,YAAY;AAAA,EAChC;AACA,8BAA4B,SAAS,QAAQ;AAC7C,SAAO;AACT;","names":[]}

package/dist/lifeops/registries/feature-flag-registry.d.ts

@@ -0,0 +1,76 @@
+/**
+ * FeatureFlagRegistry.
+ *
+ * Lifts the closed `LifeOpsFeatureKey` literal union into an open registry of
+ * gateable feature keys, allowing 3rd-party plugin contributions at runtime.
+ *
+ * The closed `LifeOpsFeatureKey` literal union still encodes the canonical
+ * built-ins shipped with the plugin (their compile-time `BASE_FEATURE_DEFAULTS`
+ * and `CLOUD_LINKED_DEFAULT_ON` policy still apply); the registry tracks
+ * every feature flag the runtime is aware of, including 3rd-party
+ * contributions registered via plugin `init`.
+ *
+ * Mirrors the per-runtime WeakMap pattern used by `FamilyRegistry`,
+ * `EventKindRegistry`, `BlockerRegistry`, and `AnchorRegistry`.
+ */
+import type { IAgentRuntime } from "@elizaos/core";
+import type { LifeOpsFeatureFlagKey, LifeOpsFeatureKey } from "../feature-flags.types.js";
+export interface FeatureFlagContribution {
+    /** Open-string feature-flag identifier (built-in or 3rd-party). */
+    readonly key: LifeOpsFeatureFlagKey;
+    /** Human-readable label shown in settings UI + confirmation prompts. */
+    readonly label: string;
+    /** One-line user-facing description. */
+    readonly description: string;
+    /** Compile-time baseline. UI defaults to this when no DB row exists. */
+    readonly defaultEnabled: boolean;
+    /**
+     * Logical grouping. `"core"` for built-ins shipped with `app-lifeops`,
+     * `"experimental"` for opt-in betas, `"third_party"` for plugin-contributed
+     * flags. Free-form because new namespaces can appear.
+     */
+    readonly namespace?: string;
+    /**
+     * Free-form metadata: `{ costsMoney: "true" }`, `{ provider: "duffel" }`,
+     * etc. Values are strings so the contribution shape stays serializable for
+     * the dev-registries view.
+     */
+    readonly metadata?: Readonly<Record<string, string>>;
+}
+export interface FeatureFlagRegistry {
+    register(contribution: FeatureFlagContribution): void;
+    list(filter?: {
+        namespace?: string;
+    }): FeatureFlagContribution[];
+    get(key: LifeOpsFeatureFlagKey): FeatureFlagContribution | null;
+    has(key: LifeOpsFeatureFlagKey): boolean;
+    /**
+     * `true` when the key is one of the closed `LifeOpsFeatureKey` built-ins
+     * (`BASE_FEATURE_DEFAULTS` is the compile-time authority for them). Used
+     * by callers that need to decide whether to apply Cloud-default policy.
+     */
+    isBuiltin(key: LifeOpsFeatureFlagKey): key is LifeOpsFeatureKey;
+}
+/**
+ * Thrown when a caller tries to toggle / inspect a feature key that has not
+ * been registered in the FeatureFlagRegistry. Carries enough context for
+ * action handlers to surface a clean error to the planner / owner.
+ */
+export declare class UnknownFeatureFlagError extends Error {
+    readonly code: "UNKNOWN_FEATURE_FLAG";
+    readonly featureKey: string;
+    readonly registeredKeys: readonly string[];
+    constructor(featureKey: string, registeredKeys: readonly string[]);
+}
+/**
+ * Factory. Pass the set of compile-time built-in keys so `isBuiltin()` can
+ * answer without re-importing `BASE_FEATURE_DEFAULTS` (avoids a cycle with
+ * the consumer that owns the keys).
+ */
+export declare function createFeatureFlagRegistry(args: {
+    builtinKeys: ReadonlySet<LifeOpsFeatureKey>;
+}): FeatureFlagRegistry;
+export declare function registerFeatureFlagRegistry(runtime: IAgentRuntime, registry: FeatureFlagRegistry): void;
+export declare function getFeatureFlagRegistry(runtime: IAgentRuntime): FeatureFlagRegistry | null;
+export declare function __resetFeatureFlagRegistryForTests(runtime: IAgentRuntime): void;
+//# sourceMappingURL=feature-flag-registry.d.ts.map

package/dist/lifeops/registries/feature-flag-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature-flag-registry.d.ts","sourceRoot":"","sources":["../../../src/lifeops/registries/feature-flag-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,KAAK,EACV,qBAAqB,EACrB,iBAAiB,EAClB,MAAM,2BAA2B,CAAC;AAEnC,MAAM,WAAW,uBAAuB;IACtC,mEAAmE;IACnE,QAAQ,CAAC,GAAG,EAAE,qBAAqB,CAAC;IACpC,wEAAwE;IACxE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,wCAAwC;IACxC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,wEAAwE;IACxE,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;IACjC;;;;OAIG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CACtD;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,YAAY,EAAE,uBAAuB,GAAG,IAAI,CAAC;IACtD,IAAI,CAAC,MAAM,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,uBAAuB,EAAE,CAAC;IACjE,GAAG,CAAC,GAAG,EAAE,qBAAqB,GAAG,uBAAuB,GAAG,IAAI,CAAC;IAChE,GAAG,CAAC,GAAG,EAAE,qBAAqB,GAAG,OAAO,CAAC;IACzC;;;;OAIG;IACH,SAAS,CAAC,GAAG,EAAE,qBAAqB,GAAG,GAAG,IAAI,iBAAiB,CAAC;CACjE;AAED;;;;GAIG;AACH,qBAAa,uBAAwB,SAAQ,KAAK;IAChD,QAAQ,CAAC,IAAI,EAAG,sBAAsB,CAAU;IAChD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;gBAE/B,UAAU,EAAE,MAAM,EAAE,cAAc,EAAE,SAAS,MAAM,EAAE;CAUlE;AAyCD;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE;IAC9C,WAAW,EAAE,WAAW,CAAC,iBAAiB,CAAC,CAAC;CAC7C,GAAG,mBAAmB,CAItB;AAQD,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,aAAa,EACtB,QAAQ,EAAE,mBAAmB,GAC5B,IAAI,CAEN;AAED,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,aAAa,GACrB,mBAAmB,GAAG,IAAI,CAE5B;AAED,wBAAgB,kCAAkC,CAChD,OAAO,EAAE,aAAa,GACrB,IAAI,CAEN"}

package/dist/lifeops/registries/feature-flag-registry.js

@@ -0,0 +1,68 @@
+class UnknownFeatureFlagError extends Error {
+  code = "UNKNOWN_FEATURE_FLAG";
+  featureKey;
+  registeredKeys;
+  constructor(featureKey, registeredKeys) {
+    super(
+      `Unknown feature flag '${featureKey}'. Registered keys: ${registeredKeys.length > 0 ? registeredKeys.join(", ") : "(none)"}.`
+    );
+    this.name = "UnknownFeatureFlagError";
+    this.featureKey = featureKey;
+    this.registeredKeys = [...registeredKeys];
+  }
+}
+class InMemoryFeatureFlagRegistry {
+  byKey = /* @__PURE__ */ new Map();
+  builtinKeys;
+  constructor(builtinKeys) {
+    this.builtinKeys = builtinKeys;
+  }
+  register(contribution) {
+    if (!contribution.key) {
+      throw new Error("FeatureFlagRegistry.register: key is required");
+    }
+    if (this.byKey.has(contribution.key)) {
+      throw new Error(
+        `FeatureFlagRegistry.register: key "${contribution.key}" already registered`
+      );
+    }
+    this.byKey.set(contribution.key, contribution);
+  }
+  list(filter) {
+    const all = Array.from(this.byKey.values());
+    if (!filter?.namespace) return all;
+    return all.filter((c) => c.namespace === filter.namespace);
+  }
+  get(key) {
+    return this.byKey.get(key) ?? null;
+  }
+  has(key) {
+    return this.byKey.has(key);
+  }
+  isBuiltin(key) {
+    return this.builtinKeys.has(key);
+  }
+}
+function createFeatureFlagRegistry(args) {
+  return new InMemoryFeatureFlagRegistry(
+    args.builtinKeys
+  );
+}
+const registries = /* @__PURE__ */ new WeakMap();
+function registerFeatureFlagRegistry(runtime, registry) {
+  registries.set(runtime, registry);
+}
+function getFeatureFlagRegistry(runtime) {
+  return registries.get(runtime) ?? null;
+}
+function __resetFeatureFlagRegistryForTests(runtime) {
+  registries.delete(runtime);
+}
+export {
+  UnknownFeatureFlagError,
+  __resetFeatureFlagRegistryForTests,
+  createFeatureFlagRegistry,
+  getFeatureFlagRegistry,
+  registerFeatureFlagRegistry
+};
+//# sourceMappingURL=feature-flag-registry.js.map

package/dist/lifeops/registries/feature-flag-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lifeops/registries/feature-flag-registry.ts"],"sourcesContent":["/**\n * FeatureFlagRegistry.\n *\n * Lifts the closed `LifeOpsFeatureKey` literal union into an open registry of\n * gateable feature keys, allowing 3rd-party plugin contributions at runtime.\n *\n * The closed `LifeOpsFeatureKey` literal union still encodes the canonical\n * built-ins shipped with the plugin (their compile-time `BASE_FEATURE_DEFAULTS`\n * and `CLOUD_LINKED_DEFAULT_ON` policy still apply); the registry tracks\n * every feature flag the runtime is aware of, including 3rd-party\n * contributions registered via plugin `init`.\n *\n * Mirrors the per-runtime WeakMap pattern used by `FamilyRegistry`,\n * `EventKindRegistry`, `BlockerRegistry`, and `AnchorRegistry`.\n */\n\nimport type { IAgentRuntime } from \"@elizaos/core\";\nimport type {\n  LifeOpsFeatureFlagKey,\n  LifeOpsFeatureKey,\n} from \"../feature-flags.types.js\";\n\nexport interface FeatureFlagContribution {\n  /** Open-string feature-flag identifier (built-in or 3rd-party). */\n  readonly key: LifeOpsFeatureFlagKey;\n  /** Human-readable label shown in settings UI + confirmation prompts. */\n  readonly label: string;\n  /** One-line user-facing description. */\n  readonly description: string;\n  /** Compile-time baseline. UI defaults to this when no DB row exists. */\n  readonly defaultEnabled: boolean;\n  /**\n   * Logical grouping. `\"core\"` for built-ins shipped with `app-lifeops`,\n   * `\"experimental\"` for opt-in betas, `\"third_party\"` for plugin-contributed\n   * flags. Free-form because new namespaces can appear.\n   */\n  readonly namespace?: string;\n  /**\n   * Free-form metadata: `{ costsMoney: \"true\" }`, `{ provider: \"duffel\" }`,\n   * etc. Values are strings so the contribution shape stays serializable for\n   * the dev-registries view.\n   */\n  readonly metadata?: Readonly<Record<string, string>>;\n}\n\nexport interface FeatureFlagRegistry {\n  register(contribution: FeatureFlagContribution): void;\n  list(filter?: { namespace?: string }): FeatureFlagContribution[];\n  get(key: LifeOpsFeatureFlagKey): FeatureFlagContribution | null;\n  has(key: LifeOpsFeatureFlagKey): boolean;\n  /**\n   * `true` when the key is one of the closed `LifeOpsFeatureKey` built-ins\n   * (`BASE_FEATURE_DEFAULTS` is the compile-time authority for them). Used\n   * by callers that need to decide whether to apply Cloud-default policy.\n   */\n  isBuiltin(key: LifeOpsFeatureFlagKey): key is LifeOpsFeatureKey;\n}\n\n/**\n * Thrown when a caller tries to toggle / inspect a feature key that has not\n * been registered in the FeatureFlagRegistry. Carries enough context for\n * action handlers to surface a clean error to the planner / owner.\n */\nexport class UnknownFeatureFlagError extends Error {\n  readonly code = \"UNKNOWN_FEATURE_FLAG\" as const;\n  readonly featureKey: string;\n  readonly registeredKeys: readonly string[];\n\n  constructor(featureKey: string, registeredKeys: readonly string[]) {\n    super(\n      `Unknown feature flag '${featureKey}'. Registered keys: ${\n        registeredKeys.length > 0 ? registeredKeys.join(\", \") : \"(none)\"\n      }.`,\n    );\n    this.name = \"UnknownFeatureFlagError\";\n    this.featureKey = featureKey;\n    this.registeredKeys = [...registeredKeys];\n  }\n}\n\nclass InMemoryFeatureFlagRegistry implements FeatureFlagRegistry {\n  private readonly byKey = new Map<string, FeatureFlagContribution>();\n  private readonly builtinKeys: ReadonlySet<string>;\n\n  constructor(builtinKeys: ReadonlySet<string>) {\n    this.builtinKeys = builtinKeys;\n  }\n\n  register(contribution: FeatureFlagContribution): void {\n    if (!contribution.key) {\n      throw new Error(\"FeatureFlagRegistry.register: key is required\");\n    }\n    if (this.byKey.has(contribution.key)) {\n      throw new Error(\n        `FeatureFlagRegistry.register: key \"${contribution.key}\" already registered`,\n      );\n    }\n    this.byKey.set(contribution.key, contribution);\n  }\n\n  list(filter?: { namespace?: string }): FeatureFlagContribution[] {\n    const all = Array.from(this.byKey.values());\n    if (!filter?.namespace) return all;\n    return all.filter((c) => c.namespace === filter.namespace);\n  }\n\n  get(key: LifeOpsFeatureFlagKey): FeatureFlagContribution | null {\n    return this.byKey.get(key) ?? null;\n  }\n\n  has(key: LifeOpsFeatureFlagKey): boolean {\n    return this.byKey.has(key);\n  }\n\n  isBuiltin(key: LifeOpsFeatureFlagKey): key is LifeOpsFeatureKey {\n    return this.builtinKeys.has(key);\n  }\n}\n\n/**\n * Factory. Pass the set of compile-time built-in keys so `isBuiltin()` can\n * answer without re-importing `BASE_FEATURE_DEFAULTS` (avoids a cycle with\n * the consumer that owns the keys).\n */\nexport function createFeatureFlagRegistry(args: {\n  builtinKeys: ReadonlySet<LifeOpsFeatureKey>;\n}): FeatureFlagRegistry {\n  return new InMemoryFeatureFlagRegistry(\n    args.builtinKeys as ReadonlySet<string>,\n  );\n}\n\n// ---------------------------------------------------------------------------\n// Per-runtime registration\n// ---------------------------------------------------------------------------\n\nconst registries = new WeakMap<IAgentRuntime, FeatureFlagRegistry>();\n\nexport function registerFeatureFlagRegistry(\n  runtime: IAgentRuntime,\n  registry: FeatureFlagRegistry,\n): void {\n  registries.set(runtime, registry);\n}\n\nexport function getFeatureFlagRegistry(\n  runtime: IAgentRuntime,\n): FeatureFlagRegistry | null {\n  return registries.get(runtime) ?? null;\n}\n\nexport function __resetFeatureFlagRegistryForTests(\n  runtime: IAgentRuntime,\n): void {\n  registries.delete(runtime);\n}\n"],"mappings":"AA+DO,MAAM,gCAAgC,MAAM;AAAA,EACxC,OAAO;AAAA,EACP;AAAA,EACA;AAAA,EAET,YAAY,YAAoB,gBAAmC;AACjE;AAAA,MACE,yBAAyB,UAAU,uBACjC,eAAe,SAAS,IAAI,eAAe,KAAK,IAAI,IAAI,QAC1D;AAAA,IACF;AACA,SAAK,OAAO;AACZ,SAAK,aAAa;AAClB,SAAK,iBAAiB,CAAC,GAAG,cAAc;AAAA,EAC1C;AACF;AAEA,MAAM,4BAA2D;AAAA,EAC9C,QAAQ,oBAAI,IAAqC;AAAA,EACjD;AAAA,EAEjB,YAAY,aAAkC;AAC5C,SAAK,cAAc;AAAA,EACrB;AAAA,EAEA,SAAS,cAA6C;AACpD,QAAI,CAAC,aAAa,KAAK;AACrB,YAAM,IAAI,MAAM,+CAA+C;AAAA,IACjE;AACA,QAAI,KAAK,MAAM,IAAI,aAAa,GAAG,GAAG;AACpC,YAAM,IAAI;AAAA,QACR,sCAAsC,aAAa,GAAG;AAAA,MACxD;AAAA,IACF;AACA,SAAK,MAAM,IAAI,aAAa,KAAK,YAAY;AAAA,EAC/C;AAAA,EAEA,KAAK,QAA4D;AAC/D,UAAM,MAAM,MAAM,KAAK,KAAK,MAAM,OAAO,CAAC;AAC1C,QAAI,CAAC,QAAQ,UAAW,QAAO;AAC/B,WAAO,IAAI,OAAO,CAAC,MAAM,EAAE,cAAc,OAAO,SAAS;AAAA,EAC3D;AAAA,EAEA,IAAI,KAA4D;AAC9D,WAAO,KAAK,MAAM,IAAI,GAAG,KAAK;AAAA,EAChC;AAAA,EAEA,IAAI,KAAqC;AACvC,WAAO,KAAK,MAAM,IAAI,GAAG;AAAA,EAC3B;AAAA,EAEA,UAAU,KAAsD;AAC9D,WAAO,KAAK,YAAY,IAAI,GAAG;AAAA,EACjC;AACF;AAOO,SAAS,0BAA0B,MAElB;AACtB,SAAO,IAAI;AAAA,IACT,KAAK;AAAA,EACP;AACF;AAMA,MAAM,aAAa,oBAAI,QAA4C;AAE5D,SAAS,4BACd,SACA,UACM;AACN,aAAW,IAAI,SAAS,QAAQ;AAClC;AAEO,SAAS,uBACd,SAC4B;AAC5B,SAAO,WAAW,IAAI,OAAO,KAAK;AACpC;AAEO,SAAS,mCACd,SACM;AACN,aAAW,OAAO,OAAO;AAC3B;","names":[]}

package/dist/lifeops/registries/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Registries barrel. BlockerRegistry, AnchorRegistry, EventKindRegistry,
+ * FamilyRegistry, WorkflowStepRegistry, FeatureFlagRegistry. No cross-imports
+ * between siblings — each registry stands alone.
+ */
+export { __resetAnchorRegistryForTests, type AnchorContext, type AnchorContribution, type AnchorRegistry, APP_LIFEOPS_ANCHORS, createAnchorRegistry, getAnchorRegistry, registerAnchorRegistry, registerAppLifeOpsAnchors, } from "@elizaos/plugin-scheduling";
+export { appBlockerContribution } from "./app-blocker-contribution.js";
+export type { BlockerAvailability, BlockerContribution, BlockerKind, BlockerRegistry, BlockerStatusSummary, } from "./blocker-registry.js";
+export { __resetBlockerRegistryForTests, createBlockerRegistry, getBlockerRegistry, registerBlockerRegistry, } from "./blocker-registry.js";
+export { __resetEventKindRegistryForTests, APP_LIFEOPS_EVENT_KINDS, createEventKindRegistry, type EventKindContribution, type EventKindRegistry, getEventKindRegistry, registerAppLifeOpsEventKinds, registerEventKindRegistry, } from "./event-kind-registry.js";
+export { __resetFamilyRegistryForTests, APP_LIFEOPS_BUS_FAMILIES, type BusFamilyContribution, createFamilyRegistry, type FamilyRegistry, getFamilyRegistry, registerAppLifeOpsBusFamilies, registerBuiltinTelemetryFamilies, registerFamilyRegistry, } from "./family-registry.js";
+export { DEFAULT_FEATURE_FLAG_PACK, LIFEOPS_BUILTIN_FEATURE_KEYS, registerDefaultFeatureFlagPack, } from "./feature-flag-default-pack.js";
+export { __resetFeatureFlagRegistryForTests, createFeatureFlagRegistry, type FeatureFlagContribution, type FeatureFlagRegistry, getFeatureFlagRegistry, registerFeatureFlagRegistry, UnknownFeatureFlagError, } from "./feature-flag-registry.js";
+export { type WebsiteBlockerStartResult, websiteBlockerContribution, } from "./website-blocker-contribution.js";
+export { APP_LIFEOPS_WORKFLOW_STEP_CONTRIBUTIONS, registerDefaultWorkflowStepPack, } from "./workflow-step-default-pack.js";
+export { __resetWorkflowStepRegistryForTests, type AnyWorkflowStepContribution, createWorkflowStepRegistry, getWorkflowStepRegistry, registerWorkflowStepRegistry, UnknownWorkflowStepError, type WorkflowStepContribution, type WorkflowStepExecuteArgs, type WorkflowStepExecuteContext, type WorkflowStepRegistry, } from "./workflow-step-registry.js";
+import type { IAgentRuntime } from "@elizaos/core";
+import { type BlockerRegistry } from "./blocker-registry.js";
+/**
+ * Create a registry, register the two built-in enforcers (website + app),
+ * and bind it to the runtime. Plugin `init` calls this once during bootstrap.
+ */
+export declare function registerDefaultBlockerPack(runtime: IAgentRuntime): BlockerRegistry;
+//# sourceMappingURL=index.d.ts.map

package/dist/lifeops/registries/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lifeops/registries/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,OAAO,EACL,6BAA6B,EAC7B,KAAK,aAAa,EAClB,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACnB,mBAAmB,EACnB,oBAAoB,EACpB,iBAAiB,EACjB,sBAAsB,EACtB,yBAAyB,GAC1B,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AACvE,YAAY,EACV,mBAAmB,EACnB,mBAAmB,EACnB,WAAW,EACX,eAAe,EACf,oBAAoB,GACrB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,8BAA8B,EAC9B,qBAAqB,EACrB,kBAAkB,EAClB,uBAAuB,GACxB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,gCAAgC,EAChC,uBAAuB,EACvB,uBAAuB,EACvB,KAAK,qBAAqB,EAC1B,KAAK,iBAAiB,EACtB,oBAAoB,EACpB,4BAA4B,EAC5B,yBAAyB,GAC1B,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,6BAA6B,EAC7B,wBAAwB,EACxB,KAAK,qBAAqB,EAC1B,oBAAoB,EACpB,KAAK,cAAc,EACnB,iBAAiB,EACjB,6BAA6B,EAC7B,gCAAgC,EAChC,sBAAsB,GACvB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,yBAAyB,EACzB,4BAA4B,EAC5B,8BAA8B,GAC/B,MAAM,gCAAgC,CAAC;AACxC,OAAO,EACL,kCAAkC,EAClC,yBAAyB,EACzB,KAAK,uBAAuB,EAC5B,KAAK,mBAAmB,EACxB,sBAAsB,EACtB,2BAA2B,EAC3B,uBAAuB,GACxB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,KAAK,yBAAyB,EAC9B,0BAA0B,GAC3B,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EACL,uCAAuC,EACvC,+BAA+B,GAChC,MAAM,iCAAiC,CAAC;AACzC,OAAO,EACL,mCAAmC,EACnC,KAAK,2BAA2B,EAChC,0BAA0B,EAC1B,uBAAuB,EACvB,4BAA4B,EAC5B,wBAAwB,EACxB,KAAK,wBAAwB,EAC7B,KAAK,uBAAuB,EAC5B,KAAK,0BAA0B,EAC/B,KAAK,oBAAoB,GAC1B,MAAM,6BAA6B,CAAC;AAErC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,EACL,KAAK,eAAe,EAGrB,MAAM,uBAAuB,CAAC;AAG/B;;;GAGG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,aAAa,GACrB,eAAe,CAMjB"}

package/dist/lifeops/registries/index.js

@@ -0,0 +1,115 @@
+import {
+  __resetAnchorRegistryForTests,
+  APP_LIFEOPS_ANCHORS,
+  createAnchorRegistry,
+  getAnchorRegistry,
+  registerAnchorRegistry,
+  registerAppLifeOpsAnchors
+} from "@elizaos/plugin-scheduling";
+import { appBlockerContribution } from "./app-blocker-contribution.js";
+import {
+  __resetBlockerRegistryForTests,
+  createBlockerRegistry,
+  getBlockerRegistry,
+  registerBlockerRegistry
+} from "./blocker-registry.js";
+import {
+  __resetEventKindRegistryForTests,
+  APP_LIFEOPS_EVENT_KINDS,
+  createEventKindRegistry,
+  getEventKindRegistry,
+  registerAppLifeOpsEventKinds,
+  registerEventKindRegistry
+} from "./event-kind-registry.js";
+import {
+  __resetFamilyRegistryForTests,
+  APP_LIFEOPS_BUS_FAMILIES,
+  createFamilyRegistry,
+  getFamilyRegistry,
+  registerAppLifeOpsBusFamilies,
+  registerBuiltinTelemetryFamilies,
+  registerFamilyRegistry
+} from "./family-registry.js";
+import {
+  DEFAULT_FEATURE_FLAG_PACK,
+  LIFEOPS_BUILTIN_FEATURE_KEYS,
+  registerDefaultFeatureFlagPack
+} from "./feature-flag-default-pack.js";
+import {
+  __resetFeatureFlagRegistryForTests,
+  createFeatureFlagRegistry,
+  getFeatureFlagRegistry,
+  registerFeatureFlagRegistry,
+  UnknownFeatureFlagError
+} from "./feature-flag-registry.js";
+import {
+  websiteBlockerContribution
+} from "./website-blocker-contribution.js";
+import {
+  APP_LIFEOPS_WORKFLOW_STEP_CONTRIBUTIONS,
+  registerDefaultWorkflowStepPack
+} from "./workflow-step-default-pack.js";
+import {
+  __resetWorkflowStepRegistryForTests,
+  createWorkflowStepRegistry,
+  getWorkflowStepRegistry,
+  registerWorkflowStepRegistry,
+  UnknownWorkflowStepError
+} from "./workflow-step-registry.js";
+import { appBlockerContribution as appBlockerContribution2 } from "./app-blocker-contribution.js";
+import {
+  createBlockerRegistry as createBlockerRegistry2,
+  registerBlockerRegistry as registerBlockerRegistry2
+} from "./blocker-registry.js";
+import { websiteBlockerContribution as websiteBlockerContribution2 } from "./website-blocker-contribution.js";
+function registerDefaultBlockerPack(runtime) {
+  const registry = createBlockerRegistry2();
+  registry.register(websiteBlockerContribution2);
+  registry.register(appBlockerContribution2);
+  registerBlockerRegistry2(runtime, registry);
+  return registry;
+}
+export {
+  APP_LIFEOPS_ANCHORS,
+  APP_LIFEOPS_BUS_FAMILIES,
+  APP_LIFEOPS_EVENT_KINDS,
+  APP_LIFEOPS_WORKFLOW_STEP_CONTRIBUTIONS,
+  DEFAULT_FEATURE_FLAG_PACK,
+  LIFEOPS_BUILTIN_FEATURE_KEYS,
+  UnknownFeatureFlagError,
+  UnknownWorkflowStepError,
+  __resetAnchorRegistryForTests,
+  __resetBlockerRegistryForTests,
+  __resetEventKindRegistryForTests,
+  __resetFamilyRegistryForTests,
+  __resetFeatureFlagRegistryForTests,
+  __resetWorkflowStepRegistryForTests,
+  appBlockerContribution,
+  createAnchorRegistry,
+  createBlockerRegistry,
+  createEventKindRegistry,
+  createFamilyRegistry,
+  createFeatureFlagRegistry,
+  createWorkflowStepRegistry,
+  getAnchorRegistry,
+  getBlockerRegistry,
+  getEventKindRegistry,
+  getFamilyRegistry,
+  getFeatureFlagRegistry,
+  getWorkflowStepRegistry,
+  registerAnchorRegistry,
+  registerAppLifeOpsAnchors,
+  registerAppLifeOpsBusFamilies,
+  registerAppLifeOpsEventKinds,
+  registerBlockerRegistry,
+  registerBuiltinTelemetryFamilies,
+  registerDefaultBlockerPack,
+  registerDefaultFeatureFlagPack,
+  registerDefaultWorkflowStepPack,
+  registerEventKindRegistry,
+  registerFamilyRegistry,
+  registerFeatureFlagRegistry,
+  registerWorkflowStepRegistry,
+  websiteBlockerContribution
+};
+//# sourceMappingURL=index.js.map

package/dist/lifeops/registries/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lifeops/registries/index.ts"],"sourcesContent":["/**\n * Registries barrel. BlockerRegistry, AnchorRegistry, EventKindRegistry,\n * FamilyRegistry, WorkflowStepRegistry, FeatureFlagRegistry. No cross-imports\n * between siblings — each registry stands alone.\n */\n\n// Anchor / event-kind / family registries. The anchor registry moved to\n// @elizaos/plugin-scheduling (the scheduling spine); re-exported here so PA's\n// registries barrel keeps its surface.\nexport {\n  __resetAnchorRegistryForTests,\n  type AnchorContext,\n  type AnchorContribution,\n  type AnchorRegistry,\n  APP_LIFEOPS_ANCHORS,\n  createAnchorRegistry,\n  getAnchorRegistry,\n  registerAnchorRegistry,\n  registerAppLifeOpsAnchors,\n} from \"@elizaos/plugin-scheduling\";\nexport { appBlockerContribution } from \"./app-blocker-contribution.js\";\nexport type {\n  BlockerAvailability,\n  BlockerContribution,\n  BlockerKind,\n  BlockerRegistry,\n  BlockerStatusSummary,\n} from \"./blocker-registry.js\";\nexport {\n  __resetBlockerRegistryForTests,\n  createBlockerRegistry,\n  getBlockerRegistry,\n  registerBlockerRegistry,\n} from \"./blocker-registry.js\";\nexport {\n  __resetEventKindRegistryForTests,\n  APP_LIFEOPS_EVENT_KINDS,\n  createEventKindRegistry,\n  type EventKindContribution,\n  type EventKindRegistry,\n  getEventKindRegistry,\n  registerAppLifeOpsEventKinds,\n  registerEventKindRegistry,\n} from \"./event-kind-registry.js\";\nexport {\n  __resetFamilyRegistryForTests,\n  APP_LIFEOPS_BUS_FAMILIES,\n  type BusFamilyContribution,\n  createFamilyRegistry,\n  type FamilyRegistry,\n  getFamilyRegistry,\n  registerAppLifeOpsBusFamilies,\n  registerBuiltinTelemetryFamilies,\n  registerFamilyRegistry,\n} from \"./family-registry.js\";\nexport {\n  DEFAULT_FEATURE_FLAG_PACK,\n  LIFEOPS_BUILTIN_FEATURE_KEYS,\n  registerDefaultFeatureFlagPack,\n} from \"./feature-flag-default-pack.js\";\nexport {\n  __resetFeatureFlagRegistryForTests,\n  createFeatureFlagRegistry,\n  type FeatureFlagContribution,\n  type FeatureFlagRegistry,\n  getFeatureFlagRegistry,\n  registerFeatureFlagRegistry,\n  UnknownFeatureFlagError,\n} from \"./feature-flag-registry.js\";\nexport {\n  type WebsiteBlockerStartResult,\n  websiteBlockerContribution,\n} from \"./website-blocker-contribution.js\";\nexport {\n  APP_LIFEOPS_WORKFLOW_STEP_CONTRIBUTIONS,\n  registerDefaultWorkflowStepPack,\n} from \"./workflow-step-default-pack.js\";\nexport {\n  __resetWorkflowStepRegistryForTests,\n  type AnyWorkflowStepContribution,\n  createWorkflowStepRegistry,\n  getWorkflowStepRegistry,\n  registerWorkflowStepRegistry,\n  UnknownWorkflowStepError,\n  type WorkflowStepContribution,\n  type WorkflowStepExecuteArgs,\n  type WorkflowStepExecuteContext,\n  type WorkflowStepRegistry,\n} from \"./workflow-step-registry.js\";\n\nimport type { IAgentRuntime } from \"@elizaos/core\";\nimport { appBlockerContribution } from \"./app-blocker-contribution.js\";\nimport {\n  type BlockerRegistry,\n  createBlockerRegistry,\n  registerBlockerRegistry,\n} from \"./blocker-registry.js\";\nimport { websiteBlockerContribution } from \"./website-blocker-contribution.js\";\n\n/**\n * Create a registry, register the two built-in enforcers (website + app),\n * and bind it to the runtime. Plugin `init` calls this once during bootstrap.\n */\nexport function registerDefaultBlockerPack(\n  runtime: IAgentRuntime,\n): BlockerRegistry {\n  const registry = createBlockerRegistry();\n  registry.register(websiteBlockerContribution);\n  registry.register(appBlockerContribution);\n  registerBlockerRegistry(runtime, registry);\n  return registry;\n}\n"],"mappings":"AASA;AAAA,EACE;AAAA,EAIA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,8BAA8B;AAQvC;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EAGA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,EAEA;AAAA,EAEA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,EAGA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP;AAAA,EAEE;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EAEA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OAKK;AAGP,SAAS,0BAAAA,+BAA8B;AACvC;AAAA,EAEE,yBAAAC;AAAA,EACA,2BAAAC;AAAA,OACK;AACP,SAAS,8BAAAC,mCAAkC;AAMpC,SAAS,2BACd,SACiB;AACjB,QAAM,WAAWF,uBAAsB;AACvC,WAAS,SAASE,2BAA0B;AAC5C,WAAS,SAASH,uBAAsB;AACxC,EAAAE,yBAAwB,SAAS,QAAQ;AACzC,SAAO;AACT;","names":["appBlockerContribution","createBlockerRegistry","registerBlockerRegistry","websiteBlockerContribution"]}

package/dist/lifeops/registries/website-blocker-contribution.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Website-blocker enforcer.
+ *
+ * Wraps the `website-blocker` engine (hosts-file editor + iOS/Android native
+ * backends when registered) as a {@link BlockerContribution}. BLOCK
+ * target=website dispatches through this entry instead of importing engine
+ * functions directly so adding a new website-blocker backend is a
+ * registration call.
+ */
+import { getSelfControlStatus, type SelfControlBlockRequest } from "@elizaos/plugin-blocker/services/website-blocker/engine";
+import type { BlockerContribution } from "./blocker-registry.js";
+export type WebsiteBlockerStartResult = {
+    success: true;
+    endsAt: string | null;
+} | {
+    success: false;
+    error: string;
+    status?: Awaited<ReturnType<typeof getSelfControlStatus>>;
+};
+export declare const websiteBlockerContribution: BlockerContribution<SelfControlBlockRequest, WebsiteBlockerStartResult>;
+//# sourceMappingURL=website-blocker-contribution.d.ts.map

package/dist/lifeops/registries/website-blocker-contribution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"website-blocker-contribution.d.ts","sourceRoot":"","sources":["../../../src/lifeops/registries/website-blocker-contribution.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAGL,oBAAoB,EACpB,KAAK,uBAAuB,EAG7B,MAAM,yDAAyD,CAAC;AACjE,OAAO,KAAK,EAEV,mBAAmB,EAEpB,MAAM,uBAAuB,CAAC;AAE/B,MAAM,MAAM,yBAAyB,GACjC;IAAE,OAAO,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,GACxC;IACE,OAAO,EAAE,KAAK,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC,CAAC;CAC3D,CAAC;AAEN,eAAO,MAAM,0BAA0B,EAAE,mBAAmB,CAC1D,uBAAuB,EACvB,yBAAyB,CAgF1B,CAAC"}

package/dist/lifeops/registries/website-blocker-contribution.js

@@ -0,0 +1,76 @@
+import {
+  formatWebsiteList,
+  getSelfControlPermissionState,
+  getSelfControlStatus,
+  startSelfControlBlock,
+  stopSelfControlBlock
+} from "@elizaos/plugin-blocker/services/website-blocker/engine";
+const websiteBlockerContribution = {
+  kind: "website",
+  describe: { label: "Website blocker (hosts-file / native)" },
+  async verifyAvailable() {
+    const status = await getSelfControlStatus();
+    if (!status.available) {
+      return {
+        available: false,
+        reason: status.reason ?? "Local website blocking is unavailable on this machine.",
+        permission: "denied"
+      };
+    }
+    const permissionState = await getSelfControlPermissionState();
+    const permission = (() => {
+      switch (permissionState.status) {
+        case "granted":
+          return "granted";
+        case "not-determined":
+          return permissionState.canRequest ? "prompt" : "denied";
+        case "denied":
+          return "denied";
+        default:
+          return permissionState.canRequest ? "prompt" : "denied";
+      }
+    })();
+    return {
+      available: true,
+      reason: null,
+      permission
+    };
+  },
+  async start(request) {
+    return startSelfControlBlock(request);
+  },
+  async stop() {
+    const result = await stopSelfControlBlock();
+    if (result.success === false) {
+      throw new Error(result.error);
+    }
+  },
+  async status() {
+    const status = await getSelfControlStatus();
+    if (!status.available) {
+      return {
+        active: false,
+        endsAt: null,
+        text: status.reason ?? "Local website blocking is unavailable on this machine."
+      };
+    }
+    if (!status.active) {
+      return {
+        active: false,
+        endsAt: null,
+        text: "No website block is active right now."
+      };
+    }
+    const websites = status.websites.length > 0 ? formatWebsiteList(status.websites) : "an unknown website set";
+    const text = status.endsAt ? `A website block is active for ${websites} until ${status.endsAt}.` : `A website block is active for ${websites} until you remove it.`;
+    return {
+      active: true,
+      endsAt: status.endsAt,
+      text
+    };
+  }
+};
+export {
+  websiteBlockerContribution
+};
+//# sourceMappingURL=website-blocker-contribution.js.map

package/dist/lifeops/registries/website-blocker-contribution.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lifeops/registries/website-blocker-contribution.ts"],"sourcesContent":["/**\n * Website-blocker enforcer.\n *\n * Wraps the `website-blocker` engine (hosts-file editor + iOS/Android native\n * backends when registered) as a {@link BlockerContribution}. BLOCK\n * target=website dispatches through this entry instead of importing engine\n * functions directly so adding a new website-blocker backend is a\n * registration call.\n */\n\nimport {\n  formatWebsiteList,\n  getSelfControlPermissionState,\n  getSelfControlStatus,\n  type SelfControlBlockRequest,\n  startSelfControlBlock,\n  stopSelfControlBlock,\n} from \"@elizaos/plugin-blocker/services/website-blocker/engine\";\nimport type {\n  BlockerAvailability,\n  BlockerContribution,\n  BlockerStatusSummary,\n} from \"./blocker-registry.js\";\n\nexport type WebsiteBlockerStartResult =\n  | { success: true; endsAt: string | null }\n  | {\n      success: false;\n      error: string;\n      status?: Awaited<ReturnType<typeof getSelfControlStatus>>;\n    };\n\nexport const websiteBlockerContribution: BlockerContribution<\n  SelfControlBlockRequest,\n  WebsiteBlockerStartResult\n> = {\n  kind: \"website\",\n  describe: { label: \"Website blocker (hosts-file / native)\" },\n\n  async verifyAvailable(): Promise<BlockerAvailability> {\n    const status = await getSelfControlStatus();\n    if (!status.available) {\n      return {\n        available: false,\n        reason:\n          status.reason ??\n          \"Local website blocking is unavailable on this machine.\",\n        permission: \"denied\",\n      };\n    }\n    const permissionState = await getSelfControlPermissionState();\n    const permission = ((): BlockerAvailability[\"permission\"] => {\n      switch (permissionState.status) {\n        case \"granted\":\n          return \"granted\";\n        case \"not-determined\":\n          return permissionState.canRequest ? \"prompt\" : \"denied\";\n        case \"denied\":\n          return \"denied\";\n        default:\n          return permissionState.canRequest ? \"prompt\" : \"denied\";\n      }\n    })();\n    return {\n      available: true,\n      reason: null,\n      permission,\n    };\n  },\n\n  async start(\n    request: SelfControlBlockRequest,\n  ): Promise<WebsiteBlockerStartResult> {\n    return startSelfControlBlock(request);\n  },\n\n  async stop(): Promise<void> {\n    const result = await stopSelfControlBlock();\n    if (result.success === false) {\n      throw new Error(result.error);\n    }\n  },\n\n  async status(): Promise<BlockerStatusSummary> {\n    const status = await getSelfControlStatus();\n    if (!status.available) {\n      return {\n        active: false,\n        endsAt: null,\n        text:\n          status.reason ??\n          \"Local website blocking is unavailable on this machine.\",\n      };\n    }\n    if (!status.active) {\n      return {\n        active: false,\n        endsAt: null,\n        text: \"No website block is active right now.\",\n      };\n    }\n    const websites =\n      status.websites.length > 0\n        ? formatWebsiteList(status.websites)\n        : \"an unknown website set\";\n    const text = status.endsAt\n      ? `A website block is active for ${websites} until ${status.endsAt}.`\n      : `A website block is active for ${websites} until you remove it.`;\n    return {\n      active: true,\n      endsAt: status.endsAt,\n      text,\n    };\n  },\n};\n"],"mappings":"AAUA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EAEA;AAAA,EACA;AAAA,OACK;AAeA,MAAM,6BAGT;AAAA,EACF,MAAM;AAAA,EACN,UAAU,EAAE,OAAO,wCAAwC;AAAA,EAE3D,MAAM,kBAAgD;AACpD,UAAM,SAAS,MAAM,qBAAqB;AAC1C,QAAI,CAAC,OAAO,WAAW;AACrB,aAAO;AAAA,QACL,WAAW;AAAA,QACX,QACE,OAAO,UACP;AAAA,QACF,YAAY;AAAA,MACd;AAAA,IACF;AACA,UAAM,kBAAkB,MAAM,8BAA8B;AAC5D,UAAM,cAAc,MAAyC;AAC3D,cAAQ,gBAAgB,QAAQ;AAAA,QAC9B,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO,gBAAgB,aAAa,WAAW;AAAA,QACjD,KAAK;AACH,iBAAO;AAAA,QACT;AACE,iBAAO,gBAAgB,aAAa,WAAW;AAAA,MACnD;AAAA,IACF,GAAG;AACH,WAAO;AAAA,MACL,WAAW;AAAA,MACX,QAAQ;AAAA,MACR;AAAA,IACF;AAAA,EACF;AAAA,EAEA,MAAM,MACJ,SACoC;AACpC,WAAO,sBAAsB,OAAO;AAAA,EACtC;AAAA,EAEA,MAAM,OAAsB;AAC1B,UAAM,SAAS,MAAM,qBAAqB;AAC1C,QAAI,OAAO,YAAY,OAAO;AAC5B,YAAM,IAAI,MAAM,OAAO,KAAK;AAAA,IAC9B;AAAA,EACF;AAAA,EAEA,MAAM,SAAwC;AAC5C,UAAM,SAAS,MAAM,qBAAqB;AAC1C,QAAI,CAAC,OAAO,WAAW;AACrB,aAAO;AAAA,QACL,QAAQ;AAAA,QACR,QAAQ;AAAA,QACR,MACE,OAAO,UACP;AAAA,MACJ;AAAA,IACF;AACA,QAAI,CAAC,OAAO,QAAQ;AAClB,aAAO;AAAA,QACL,QAAQ;AAAA,QACR,QAAQ;AAAA,QACR,MAAM;AAAA,MACR;AAAA,IACF;AACA,UAAM,WACJ,OAAO,SAAS,SAAS,IACrB,kBAAkB,OAAO,QAAQ,IACjC;AACN,UAAM,OAAO,OAAO,SAChB,iCAAiC,QAAQ,UAAU,OAAO,MAAM,MAChE,iCAAiC,QAAQ;AAC7C,WAAO;AAAA,MACL,QAAQ;AAAA,MACR,QAAQ,OAAO;AAAA,MACf;AAAA,IACF;AAAA,EACF;AACF;","names":[]}

package/dist/lifeops/registries/workflow-step-default-pack.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Default WorkflowStepRegistry pack.
+ *
+ * Lifts the 9-branch `if/else` switch from `service-mixin-workflows.ts`
+ * (audit `rigidity-hunt-audit.md` top-2: workflow step dispatch) into 10
+ * registry contributions — one per existing `step.kind`. Pure refactor:
+ * each handler is the same body that previously lived inside the switch
+ * arm. Behavior must be identical.
+ *
+ * The 10 contributions:
+ *   1. `create_task` — delegate to `LifeOpsServiceBase.createDefinition`,
+ *      defaulting ownership to the workflow's domain/subject when the
+ *      step omits its own ownership block.
+ *   2. `relock_website_access` — call `relockWebsiteAccessGroup(groupKey, now)`.
+ *   3. `resolve_website_access_callback` —
+ *      call `resolveWebsiteAccessCallback(callbackKey, now)`.
+ *   4. `get_calendar_feed` — invoke `getCalendarFeed` with an internal URL.
+ *   5. `get_gmail_triage` — invoke `getGmailTriage`.
+ *   6. `get_gmail_unresponded` — invoke `getGmailUnresponded`.
+ *   7. `get_health_summary` — invoke `getHealthSummary`.
+ *   8. `dispatch_workflow` — resolve `WORKFLOW_DISPATCH` service and
+ *      delegate, threading the workflow `request` + accumulated outputs.
+ *   9. `summarize` — describe the previous step or named-output value.
+ *  10. `browser` — open a browser session honoring the workflow's
+ *      permission policy + confirmation flag.
+ */
+import type { AnyWorkflowStepContribution, WorkflowStepRegistry } from "./workflow-step-registry.js";
+export declare const APP_LIFEOPS_WORKFLOW_STEP_CONTRIBUTIONS: readonly AnyWorkflowStepContribution[];
+export declare function registerDefaultWorkflowStepPack(registry: WorkflowStepRegistry): void;
+//# sourceMappingURL=workflow-step-default-pack.d.ts.map

package/dist/lifeops/registries/workflow-step-default-pack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-step-default-pack.d.ts","sourceRoot":"","sources":["../../../src/lifeops/registries/workflow-step-default-pack.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAIH,OAAO,KAAK,EACV,2BAA2B,EAC3B,oBAAoB,EACrB,MAAM,6BAA6B,CAAC;AA6WrC,eAAO,MAAM,uCAAuC,EAAE,SAAS,2BAA2B,EAYvF,CAAC;AAEJ,wBAAgB,+BAA+B,CAC7C,QAAQ,EAAE,oBAAoB,GAC7B,IAAI,CAIN"}