@elizaos/agent 2.0.0-alpha.173 → 2.0.0-alpha.192

package/apps/app-lifeops/src/website-blocker/chat-integration/actions/releaseBlock.js

@@ -0,0 +1,98 @@
+import { BlockRuleWriter } from "../block-rule-service.js";
+function coerceString(value) {
+    if (typeof value === "string" && value.trim().length > 0) {
+        return value.trim();
+    }
+    return null;
+}
+function coerceBoolean(value) {
+    if (typeof value === "boolean")
+        return value;
+    if (typeof value === "string") {
+        const normalized = value.trim().toLowerCase();
+        return normalized === "true" || normalized === "yes" || normalized === "1";
+    }
+    if (typeof value === "number")
+        return value !== 0;
+    return false;
+}
+export const releaseBlockAction = {
+    name: "RELEASE_BLOCK",
+    similes: [
+        "RELEASE_WEBSITE_BLOCK",
+        "END_BLOCK_RULE",
+        "BYPASS_BLOCK_RULE",
+    ],
+    description: "Release an active website block rule. Requires confirmed:true. " +
+        "harsh_no_bypass rules cannot be released via confirmation — they must wait for gate fulfillment.",
+    descriptionCompressed: "Release a website block rule; requires confirmation.",
+    validate: async () => true,
+    handler: async (runtime, _message, _state, options) => {
+        const params = (options?.parameters ?? {});
+        const ruleId = coerceString(params.ruleId);
+        if (!ruleId) {
+            return {
+                success: false,
+                text: "RELEASE_BLOCK requires a ruleId.",
+            };
+        }
+        if (!coerceBoolean(params.confirmed)) {
+            return {
+                success: false,
+                text: "RELEASE_BLOCK requires confirmed:true to release the rule.",
+            };
+        }
+        const reason = coerceString(params.reason) ?? "user_confirmed";
+        const writer = new BlockRuleWriter(runtime);
+        try {
+            await writer.releaseBlockRule(ruleId, { confirmed: true, reason });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                success: false,
+                text: `Failed to release block rule ${ruleId}: ${message}`,
+            };
+        }
+        return {
+            success: true,
+            text: `Released block rule ${ruleId}.`,
+            data: { ruleId, reason },
+        };
+    },
+    parameters: [
+        {
+            name: "ruleId",
+            description: "ID of the block rule to release.",
+            required: true,
+            schema: { type: "string" },
+        },
+        {
+            name: "confirmed",
+            description: "Must be true to release. Prevents accidental unblocking.",
+            required: true,
+            schema: { type: "boolean" },
+        },
+        {
+            name: "reason",
+            description: "Optional reason for release, stored on the rule.",
+            required: false,
+            schema: { type: "string" },
+        },
+    ],
+    examples: [
+        [
+            {
+                name: "{{name1}}",
+                content: { text: "Release the block rule I just created." },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "Released block rule <id>.",
+                    action: "RELEASE_BLOCK",
+                },
+            },
+        ],
+    ],
+};

package/apps/app-lifeops/src/website-blocker/chat-integration/block-rule-reconciler.d.ts

@@ -0,0 +1,7 @@
+import type { IAgentRuntime } from "@elizaos/core";
+export declare const BLOCK_RULE_RECONCILE_TASK_NAME: "BLOCK_RULE_RECONCILE";
+export declare const BLOCK_RULE_RECONCILE_TASK_TAGS: readonly ["queue", "website-blocker", "block-rule-reconciler"];
+export declare const BLOCK_RULE_RECONCILE_INTERVAL_MS = 60000;
+export declare function reconcileBlockRulesOnce(runtime: IAgentRuntime, nowMs?: number): Promise<void>;
+export declare function registerBlockRuleReconcilerWorker(runtime: IAgentRuntime): void;
+//# sourceMappingURL=block-rule-reconciler.d.ts.map

package/apps/app-lifeops/src/website-blocker/chat-integration/block-rule-reconciler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block-rule-reconciler.d.ts","sourceRoot":"","sources":["../../../../../../../../apps/app-lifeops/src/website-blocker/chat-integration/block-rule-reconciler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAMnD,eAAO,MAAM,8BAA8B,EACzC,sBAA+B,CAAC;AAClC,eAAO,MAAM,8BAA8B,gEAIjC,CAAC;AACX,eAAO,MAAM,gCAAgC,QAAS,CAAC;AA2GvD,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,aAAa,EACtB,KAAK,GAAE,MAAmB,GACzB,OAAO,CAAC,IAAI,CAAC,CAOf;AAED,wBAAgB,iCAAiC,CAC/C,OAAO,EAAE,aAAa,GACrB,IAAI,CAYN"}

package/apps/app-lifeops/src/website-blocker/chat-integration/block-rule-reconciler.js

@@ -0,0 +1,111 @@
+import { logger } from "@elizaos/core";
+import { executeRawSql, sqlQuote } from "../../lifeops/sql.js";
+import { BlockRuleReader, BlockRuleWriter } from "./block-rule-service.js";
+export const BLOCK_RULE_RECONCILE_TASK_NAME = "BLOCK_RULE_RECONCILE";
+export const BLOCK_RULE_RECONCILE_TASK_TAGS = [
+    "queue",
+    "website-blocker",
+    "block-rule-reconciler",
+];
+export const BLOCK_RULE_RECONCILE_INTERVAL_MS = 60_000;
+/**
+ * T7g — Website blocker chat integration reconciler (plan §6.8).
+ *
+ * Walks the `life_block_rules` table every tick and releases rules whose
+ * gates have been fulfilled. `harsh_no_bypass` rules behave like
+ * `until_todo` but also reject manual release attempts in the writer.
+ */
+async function isTodoCompleted(runtime, todoId) {
+    const rows = await executeRawSql(runtime, `SELECT state FROM life_task_occurrences
+       WHERE id = ${sqlQuote(todoId)}
+       LIMIT 1`);
+    if (rows.length === 0) {
+        const defRows = await executeRawSql(runtime, `SELECT status FROM life_task_definitions
+         WHERE id = ${sqlQuote(todoId)}
+         LIMIT 1`);
+        if (defRows.length === 0)
+            return false;
+        const definitionRow = defRows[0];
+        if (!definitionRow)
+            return false;
+        const status = definitionRow.status;
+        return typeof status === "string" && status.toLowerCase() === "completed";
+    }
+    const row = rows[0];
+    if (!row)
+        return false;
+    const state = row.state;
+    return typeof state === "string" && state.toLowerCase() === "completed";
+}
+function shouldReleaseByTime(rule, nowMs) {
+    if (rule.gateType === "fixed_duration") {
+        if (rule.fixedDurationMs === null)
+            return { release: false, reason: "" };
+        if (nowMs - rule.createdAt >= rule.fixedDurationMs) {
+            return { release: true, reason: "fixed_duration_elapsed" };
+        }
+        return { release: false, reason: "" };
+    }
+    if (rule.gateType === "until_iso") {
+        if (rule.gateUntilMs === null)
+            return { release: false, reason: "" };
+        if (nowMs >= rule.gateUntilMs) {
+            return { release: true, reason: "until_iso_reached" };
+        }
+        return { release: false, reason: "" };
+    }
+    return { release: false, reason: "" };
+}
+async function evaluateRule(runtime, writer, rule, nowMs) {
+    if (rule.gateType === "until_todo" || rule.gateType === "harsh_no_bypass") {
+        if (!rule.gateTodoId)
+            return;
+        const completed = await isTodoCompleted(runtime, rule.gateTodoId);
+        if (!completed)
+            return;
+        await writer.updateGateFulfilled(rule.id, "todo_completed");
+        logger.info(`[BlockRuleReconciler] Released rule ${rule.id}: gate todo ${rule.gateTodoId} completed`);
+        if (rule.unlockDurationMs !== null && rule.unlockDurationMs > 0) {
+            await scheduleAutoReLock(runtime, writer, rule, nowMs);
+        }
+        return;
+    }
+    const decision = shouldReleaseByTime(rule, nowMs);
+    if (!decision.release)
+        return;
+    await writer.updateGateFulfilled(rule.id, decision.reason);
+    logger.info(`[BlockRuleReconciler] Released rule ${rule.id}: ${decision.reason}`);
+}
+async function scheduleAutoReLock(runtime, writer, rule, nowMs) {
+    if (rule.unlockDurationMs === null || rule.unlockDurationMs <= 0)
+        return;
+    const reLockAtMs = nowMs + rule.unlockDurationMs;
+    const followUpRuleId = await writer.createBlockRule({
+        profile: rule.profile,
+        websites: rule.websites,
+        gateType: "until_iso",
+        gateUntilMs: reLockAtMs,
+    });
+    logger.info(`[BlockRuleReconciler] Scheduled auto re-lock ${followUpRuleId} until ${new Date(reLockAtMs).toISOString()}`);
+}
+export async function reconcileBlockRulesOnce(runtime, nowMs = Date.now()) {
+    const reader = new BlockRuleReader(runtime);
+    const writer = new BlockRuleWriter(runtime);
+    const active = await reader.listActiveBlocks();
+    for (const rule of active) {
+        await evaluateRule(runtime, writer, rule, nowMs);
+    }
+}
+export function registerBlockRuleReconcilerWorker(runtime) {
+    if (runtime.getTaskWorker(BLOCK_RULE_RECONCILE_TASK_NAME)) {
+        return;
+    }
+    runtime.registerTaskWorker({
+        name: BLOCK_RULE_RECONCILE_TASK_NAME,
+        shouldRun: async () => true,
+        execute: async (rt) => {
+            await reconcileBlockRulesOnce(rt);
+            return undefined;
+        },
+    });
+}

package/apps/app-lifeops/src/website-blocker/chat-integration/block-rule-schema.d.ts

@@ -0,0 +1,39 @@
+/**
+ * T7g — Website blocker chat integration (plan §6.8).
+ *
+ * Domain types for the `life_block_rules` table. The table is bootstrapped
+ * in `LifeOpsRepository.bootstrapSchema`; this module only provides typed
+ * shapes and narrow runtime decoders for rows read back from SQL.
+ */
+export declare const BLOCK_RULES_TABLE: "life_block_rules";
+export type BlockRuleGateType = "fixed_duration" | "until_todo" | "until_iso" | "harsh_no_bypass";
+export interface BlockRule {
+    id: string;
+    agentId: string;
+    profile: string;
+    websites: string[];
+    gateType: BlockRuleGateType;
+    gateTodoId: string | null;
+    gateUntilMs: number | null;
+    fixedDurationMs: number | null;
+    unlockDurationMs: number | null;
+    active: boolean;
+    createdAt: number;
+    releasedAt: number | null;
+    releasedReason: string | null;
+}
+export interface CreateBlockRuleInput {
+    id?: string;
+    profile: string;
+    websites: string[];
+    gateType: BlockRuleGateType;
+    gateTodoId?: string | null;
+    gateUntilMs?: number | null;
+    fixedDurationMs?: number | null;
+    unlockDurationMs?: number | null;
+}
+export declare class BlockRuleRowError extends Error {
+    constructor(message: string);
+}
+export declare function rowToBlockRule(row: Record<string, unknown>): BlockRule;
+//# sourceMappingURL=block-rule-schema.d.ts.map

package/apps/app-lifeops/src/website-blocker/chat-integration/block-rule-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block-rule-schema.d.ts","sourceRoot":"","sources":["../../../../../../../../apps/app-lifeops/src/website-blocker/chat-integration/block-rule-schema.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,eAAO,MAAM,iBAAiB,EAAG,kBAA2B,CAAC;AAE7D,MAAM,MAAM,iBAAiB,GACzB,gBAAgB,GAChB,YAAY,GACZ,WAAW,GACX,iBAAiB,CAAC;AAEtB,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,MAAM,EAAE,OAAO,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAED,MAAM,WAAW,oBAAoB;IACnC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAClC;AAED,qBAAa,iBAAkB,SAAQ,KAAK;gBAC9B,OAAO,EAAE,MAAM;CAI5B;AA0GD,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAyBtE"}

package/apps/app-lifeops/src/website-blocker/chat-integration/block-rule-schema.js

@@ -0,0 +1,123 @@
+/**
+ * T7g — Website blocker chat integration (plan §6.8).
+ *
+ * Domain types for the `life_block_rules` table. The table is bootstrapped
+ * in `LifeOpsRepository.bootstrapSchema`; this module only provides typed
+ * shapes and narrow runtime decoders for rows read back from SQL.
+ */
+export const BLOCK_RULES_TABLE = "life_block_rules";
+export class BlockRuleRowError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "BlockRuleRowError";
+    }
+}
+function isGateType(value) {
+    return (value === "fixed_duration" ||
+        value === "until_todo" ||
+        value === "until_iso" ||
+        value === "harsh_no_bypass");
+}
+function toStringArray(value) {
+    if (typeof value === "string") {
+        const parsed = JSON.parse(value);
+        if (!Array.isArray(parsed)) {
+            throw new BlockRuleRowError("life_block_rules.websites JSON is not an array");
+        }
+        return parsed.map((entry) => {
+            if (typeof entry !== "string") {
+                throw new BlockRuleRowError("life_block_rules.websites contains a non-string entry");
+            }
+            return entry;
+        });
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry) => {
+            if (typeof entry !== "string") {
+                throw new BlockRuleRowError("life_block_rules.websites contains a non-string entry");
+            }
+            return entry;
+        });
+    }
+    throw new BlockRuleRowError("life_block_rules.websites is neither string nor array");
+}
+function toNumberOrNull(value, field) {
+    if (value === null || value === undefined)
+        return null;
+    if (typeof value === "number") {
+        if (!Number.isFinite(value)) {
+            throw new BlockRuleRowError(`life_block_rules.${field} is not finite`);
+        }
+        return value;
+    }
+    if (typeof value === "bigint")
+        return Number(value);
+    if (typeof value === "string") {
+        const parsed = Number(value);
+        if (!Number.isFinite(parsed)) {
+            throw new BlockRuleRowError(`life_block_rules.${field} could not be parsed as number`);
+        }
+        return parsed;
+    }
+    throw new BlockRuleRowError(`life_block_rules.${field} has unexpected type ${typeof value}`);
+}
+function toRequiredNumber(value, field) {
+    const result = toNumberOrNull(value, field);
+    if (result === null) {
+        throw new BlockRuleRowError(`life_block_rules.${field} is NULL`);
+    }
+    return result;
+}
+function toStringOrNull(value, field) {
+    if (value === null || value === undefined)
+        return null;
+    if (typeof value === "string")
+        return value;
+    throw new BlockRuleRowError(`life_block_rules.${field} has unexpected type ${typeof value}`);
+}
+function toRequiredString(value, field) {
+    const result = toStringOrNull(value, field);
+    if (result === null) {
+        throw new BlockRuleRowError(`life_block_rules.${field} is NULL`);
+    }
+    return result;
+}
+function toBool(value, field) {
+    if (typeof value === "boolean")
+        return value;
+    if (typeof value === "number")
+        return value !== 0;
+    if (typeof value === "string") {
+        const normalized = value.trim().toLowerCase();
+        if (normalized === "true" || normalized === "t" || normalized === "1") {
+            return true;
+        }
+        if (normalized === "false" || normalized === "f" || normalized === "0") {
+            return false;
+        }
+    }
+    if (value === null || value === undefined)
+        return false;
+    throw new BlockRuleRowError(`life_block_rules.${field} is not a boolean-compatible value`);
+}
+export function rowToBlockRule(row) {
+    const gateType = toRequiredString(row.gate_type, "gate_type");
+    if (!isGateType(gateType)) {
+        throw new BlockRuleRowError(`life_block_rules.gate_type is invalid: ${gateType}`);
+    }
+    return {
+        id: toRequiredString(row.id, "id"),
+        agentId: toRequiredString(row.agent_id, "agent_id"),
+        profile: toRequiredString(row.profile, "profile"),
+        websites: toStringArray(row.websites),
+        gateType,
+        gateTodoId: toStringOrNull(row.gate_todo_id, "gate_todo_id"),
+        gateUntilMs: toNumberOrNull(row.gate_until_ms, "gate_until_ms"),
+        fixedDurationMs: toNumberOrNull(row.fixed_duration_ms, "fixed_duration_ms"),
+        unlockDurationMs: toNumberOrNull(row.unlock_duration_ms, "unlock_duration_ms"),
+        active: toBool(row.active, "active"),
+        createdAt: toRequiredNumber(row.created_at, "created_at"),
+        releasedAt: toNumberOrNull(row.released_at, "released_at"),
+        releasedReason: toStringOrNull(row.released_reason, "released_reason"),
+    };
+}

package/apps/app-lifeops/src/website-blocker/chat-integration/block-rule-service.d.ts

@@ -0,0 +1,21 @@
+import type { IAgentRuntime } from "@elizaos/core";
+import { type BlockRule, type CreateBlockRuleInput } from "./block-rule-schema.js";
+export declare class BlockRuleWriter {
+    private readonly runtime;
+    constructor(runtime: IAgentRuntime);
+    createBlockRule(input: CreateBlockRuleInput): Promise<string>;
+    releaseBlockRule(id: string, options: {
+        confirmed: boolean;
+        reason?: string;
+    }): Promise<void>;
+    updateGateFulfilled(id: string, reason: string): Promise<void>;
+}
+export declare class BlockRuleReader {
+    private readonly runtime;
+    constructor(runtime: IAgentRuntime);
+    listActiveBlocks(): Promise<BlockRule[]>;
+    findBlocksGatedByTodo(todoId: string): Promise<BlockRule[]>;
+    isBlockActive(profile: string): Promise<boolean>;
+    getBlockRuleById(id: string): Promise<BlockRule | null>;
+}
+//# sourceMappingURL=block-rule-service.d.ts.map

package/apps/app-lifeops/src/website-blocker/chat-integration/block-rule-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block-rule-service.d.ts","sourceRoot":"","sources":["../../../../../../../../apps/app-lifeops/src/website-blocker/chat-integration/block-rule-service.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAEV,aAAa,EAGd,MAAM,eAAe,CAAC;AAIvB,OAAO,EAEL,KAAK,SAAS,EAEd,KAAK,oBAAoB,EAE1B,MAAM,wBAAwB,CAAC;AAuHhC,qBAAa,eAAe;IACd,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,EAAE,aAAa;IAE7C,eAAe,CAAC,KAAK,EAAE,oBAAoB,GAAG,OAAO,CAAC,MAAM,CAAC;IA8D7D,gBAAgB,CACpB,EAAE,EAAE,MAAM,EACV,OAAO,EAAE;QAAE,SAAS,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,GAC/C,OAAO,CAAC,IAAI,CAAC;IA4CV,mBAAmB,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAarE;AAED,qBAAa,eAAe;IACd,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,EAAE,aAAa;IAE7C,gBAAgB,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;IAYxC,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IAa3D,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAahD,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC;CAa9D"}

package/apps/app-lifeops/src/website-blocker/chat-integration/block-rule-service.js

@@ -0,0 +1,227 @@
+import crypto from "node:crypto";
+import { createUniqueUuid, logger, stringToUuid } from "@elizaos/core";
+import { executeRawSql, sqlQuote, sqlText } from "../../lifeops/sql.js";
+import { blockWebsitesAction } from "../../actions/website-blocker.js";
+import { BLOCK_RULES_TABLE, rowToBlockRule, } from "./block-rule-schema.js";
+/**
+ * CQRS: writers only mutate. They return the new id or void. Readers return
+ * domain objects. Both live in the same module because they share the table
+ * encoders, but they are separate classes so tests exercise the pipelines
+ * independently.
+ */
+function nowMs() {
+    return Date.now();
+}
+function newBlockRuleId() {
+    const maybeCrypto = globalThis.crypto;
+    if (maybeCrypto?.randomUUID)
+        return maybeCrypto.randomUUID();
+    return crypto.randomUUID();
+}
+function sqlBigint(value) {
+    if (value === null || value === undefined)
+        return "NULL";
+    if (!Number.isFinite(value)) {
+        throw new Error(`[BlockRuleWriter] non-finite numeric: ${String(value)}`);
+    }
+    return String(Math.trunc(value));
+}
+function sqlJsonArray(values) {
+    return sqlQuote(JSON.stringify([...values]));
+}
+function assertValidGateType(gateType) {
+    switch (gateType) {
+        case "fixed_duration":
+        case "until_todo":
+        case "until_iso":
+        case "harsh_no_bypass":
+            return;
+    }
+}
+function assertCreateInput(input) {
+    if (!input.profile.trim()) {
+        throw new Error("[BlockRuleWriter] profile is required");
+    }
+    if (input.websites.length === 0) {
+        throw new Error("[BlockRuleWriter] websites must not be empty");
+    }
+    assertValidGateType(input.gateType);
+    if (input.gateType === "until_todo" && !input.gateTodoId) {
+        throw new Error("[BlockRuleWriter] until_todo gate requires gateTodoId");
+    }
+    if (input.gateType === "until_iso" && input.gateUntilMs === undefined) {
+        throw new Error("[BlockRuleWriter] until_iso gate requires gateUntilMs");
+    }
+    if (input.gateType === "fixed_duration" &&
+        (input.fixedDurationMs === undefined || input.fixedDurationMs === null)) {
+        throw new Error("[BlockRuleWriter] fixed_duration gate requires fixedDurationMs");
+    }
+}
+function makeSyntheticMessage(runtime, websites) {
+    const roomId = stringToUuid(`block-rule-service-${String(runtime.agentId)}`);
+    const entityId = stringToUuid(`block-rule-service-entity-${String(runtime.agentId)}`);
+    return {
+        id: createUniqueUuid(runtime, `block-rule-${Date.now()}`),
+        entityId,
+        agentId: runtime.agentId,
+        roomId,
+        content: {
+            text: `Block ${websites.join(", ")}.`,
+        },
+    };
+}
+function computeHandlerOptionsForCreate(input) {
+    const durationMinutes = (() => {
+        if (input.gateType === "fixed_duration") {
+            if (input.fixedDurationMs === null || input.fixedDurationMs === undefined) {
+                return null;
+            }
+            return Math.max(1, Math.round(input.fixedDurationMs / 60_000));
+        }
+        if (input.gateType === "until_iso" && input.gateUntilMs != null) {
+            const remaining = input.gateUntilMs - nowMs();
+            return remaining > 0 ? Math.max(1, Math.round(remaining / 60_000)) : 1;
+        }
+        return null;
+    })();
+    return {
+        parameters: {
+            websites: [...input.websites],
+            durationMinutes,
+        },
+    };
+}
+export class BlockRuleWriter {
+    runtime;
+    constructor(runtime) {
+        this.runtime = runtime;
+    }
+    async createBlockRule(input) {
+        assertCreateInput(input);
+        const id = input.id ?? newBlockRuleId();
+        const agentId = String(this.runtime.agentId);
+        const createdAt = nowMs();
+        await executeRawSql(this.runtime, `INSERT INTO ${BLOCK_RULES_TABLE} (
+         id, agent_id, profile, websites, gate_type, gate_todo_id,
+         gate_until_ms, fixed_duration_ms, unlock_duration_ms,
+         active, created_at, released_at, released_reason
+       ) VALUES (
+         ${sqlQuote(id)},
+         ${sqlQuote(agentId)},
+         ${sqlQuote(input.profile)},
+         ${sqlJsonArray(input.websites)}::jsonb,
+         ${sqlQuote(input.gateType)},
+         ${sqlText(input.gateTodoId ?? null)},
+         ${sqlBigint(input.gateUntilMs ?? null)},
+         ${sqlBigint(input.fixedDurationMs ?? null)},
+         ${sqlBigint(input.unlockDurationMs ?? null)},
+         TRUE,
+         ${sqlBigint(createdAt)},
+         NULL,
+         NULL
+       )`);
+        const message = makeSyntheticMessage(this.runtime, input.websites);
+        const handlerOptions = computeHandlerOptionsForCreate(input);
+        const result = await blockWebsitesAction.handler(this.runtime, message, undefined, handlerOptions);
+        if (result && typeof result === "object" && "success" in result) {
+            const typedResult = result;
+            if (typedResult.success === false) {
+                // The rule is the source of truth. SelfControl activation failures
+                // (missing admin permission, unsupported platform, no helper binary)
+                // are logged but do not tear down the rule — the reconciler keeps
+                // the lifecycle and a retry on rule creation will re-attempt
+                // activation.
+                const reason = typeof typedResult.text === "string"
+                    ? typedResult.text
+                    : "SelfControl activation returned success=false";
+                logger.warn(`[BlockRuleWriter] SelfControl activation did not complete for rule ${id}: ${reason}`);
+            }
+        }
+        logger.info(`[BlockRuleWriter] Created block rule ${id} (${input.gateType}) for ${input.websites.join(", ")}`);
+        return id;
+    }
+    async releaseBlockRule(id, options) {
+        if (!options.confirmed) {
+            throw new Error("[BlockRuleWriter] releaseBlockRule requires confirmed:true");
+        }
+        const agentId = String(this.runtime.agentId);
+        const rows = await executeRawSql(this.runtime, `SELECT * FROM ${BLOCK_RULES_TABLE}
+         WHERE id = ${sqlQuote(id)}
+           AND agent_id = ${sqlQuote(agentId)}`);
+        if (rows.length === 0) {
+            throw new Error(`[BlockRuleWriter] block rule ${id} not found`);
+        }
+        const row = rows[0];
+        if (!row) {
+            throw new Error(`[BlockRuleWriter] block rule ${id} not found`);
+        }
+        const rule = rowToBlockRule(row);
+        if (rule.gateType === "harsh_no_bypass") {
+            throw new Error(`[BlockRuleWriter] block rule ${id} is harsh_no_bypass and cannot be released by user confirmation`);
+        }
+        if (!rule.active) {
+            return;
+        }
+        const reason = options.reason ?? "user_confirmed";
+        await executeRawSql(this.runtime, `UPDATE ${BLOCK_RULES_TABLE}
+          SET active = FALSE,
+              released_at = ${sqlBigint(nowMs())},
+              released_reason = ${sqlQuote(reason)}
+        WHERE id = ${sqlQuote(id)}
+          AND agent_id = ${sqlQuote(agentId)}`);
+        logger.info(`[BlockRuleWriter] Released block rule ${id} (${reason})`);
+    }
+    async updateGateFulfilled(id, reason) {
+        const agentId = String(this.runtime.agentId);
+        await executeRawSql(this.runtime, `UPDATE ${BLOCK_RULES_TABLE}
+          SET active = FALSE,
+              released_at = ${sqlBigint(nowMs())},
+              released_reason = ${sqlQuote(reason)}
+        WHERE id = ${sqlQuote(id)}
+          AND agent_id = ${sqlQuote(agentId)}
+          AND active = TRUE`);
+    }
+}
+export class BlockRuleReader {
+    runtime;
+    constructor(runtime) {
+        this.runtime = runtime;
+    }
+    async listActiveBlocks() {
+        const agentId = String(this.runtime.agentId);
+        const rows = await executeRawSql(this.runtime, `SELECT * FROM ${BLOCK_RULES_TABLE}
+         WHERE agent_id = ${sqlQuote(agentId)}
+           AND active = TRUE
+         ORDER BY created_at ASC`);
+        return rows.map(rowToBlockRule);
+    }
+    async findBlocksGatedByTodo(todoId) {
+        const agentId = String(this.runtime.agentId);
+        const rows = await executeRawSql(this.runtime, `SELECT * FROM ${BLOCK_RULES_TABLE}
+         WHERE agent_id = ${sqlQuote(agentId)}
+           AND active = TRUE
+           AND gate_type = 'until_todo'
+           AND gate_todo_id = ${sqlQuote(todoId)}`);
+        return rows.map(rowToBlockRule);
+    }
+    async isBlockActive(profile) {
+        const agentId = String(this.runtime.agentId);
+        const rows = await executeRawSql(this.runtime, `SELECT 1 AS ok FROM ${BLOCK_RULES_TABLE}
+         WHERE agent_id = ${sqlQuote(agentId)}
+           AND active = TRUE
+           AND profile = ${sqlQuote(profile)}
+         LIMIT 1`);
+        return rows.length > 0;
+    }
+    async getBlockRuleById(id) {
+        const agentId = String(this.runtime.agentId);
+        const rows = await executeRawSql(this.runtime, `SELECT * FROM ${BLOCK_RULES_TABLE}
+         WHERE id = ${sqlQuote(id)}
+           AND agent_id = ${sqlQuote(agentId)}
+         LIMIT 1`);
+        if (rows.length === 0)
+            return null;
+        const row = rows[0];
+        return row ? rowToBlockRule(row) : null;
+    }
+}

package/apps/app-lifeops/src/website-blocker/chat-integration/index.d.ts

@@ -0,0 +1,8 @@
+export { BLOCK_RULES_TABLE, rowToBlockRule, BlockRuleRowError, } from "./block-rule-schema.js";
+export type { BlockRule, BlockRuleGateType, CreateBlockRuleInput, } from "./block-rule-schema.js";
+export { BlockRuleReader, BlockRuleWriter } from "./block-rule-service.js";
+export { BLOCK_RULE_RECONCILE_TASK_NAME, BLOCK_RULE_RECONCILE_TASK_TAGS, BLOCK_RULE_RECONCILE_INTERVAL_MS, reconcileBlockRulesOnce, registerBlockRuleReconcilerWorker, } from "./block-rule-reconciler.js";
+export { blockUntilTaskCompleteAction } from "./actions/blockUntilTaskComplete.js";
+export { listActiveBlocksAction } from "./actions/listActiveBlocks.js";
+export { releaseBlockAction } from "./actions/releaseBlock.js";
+//# sourceMappingURL=index.d.ts.map

package/apps/app-lifeops/src/website-blocker/chat-integration/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../apps/app-lifeops/src/website-blocker/chat-integration/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,cAAc,EACd,iBAAiB,GAClB,MAAM,wBAAwB,CAAC;AAChC,YAAY,EACV,SAAS,EACT,iBAAiB,EACjB,oBAAoB,GACrB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC3E,OAAO,EACL,8BAA8B,EAC9B,8BAA8B,EAC9B,gCAAgC,EAChC,uBAAuB,EACvB,iCAAiC,GAClC,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,4BAA4B,EAAE,MAAM,qCAAqC,CAAC;AACnF,OAAO,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC"}

package/apps/app-lifeops/src/website-blocker/chat-integration/index.js

@@ -0,0 +1,6 @@
+export { BLOCK_RULES_TABLE, rowToBlockRule, BlockRuleRowError, } from "./block-rule-schema.js";
+export { BlockRuleReader, BlockRuleWriter } from "./block-rule-service.js";
+export { BLOCK_RULE_RECONCILE_TASK_NAME, BLOCK_RULE_RECONCILE_TASK_TAGS, BLOCK_RULE_RECONCILE_INTERVAL_MS, reconcileBlockRulesOnce, registerBlockRuleReconcilerWorker, } from "./block-rule-reconciler.js";
+export { blockUntilTaskCompleteAction } from "./actions/blockUntilTaskComplete.js";
+export { listActiveBlocksAction } from "./actions/listActiveBlocks.js";
+export { releaseBlockAction } from "./actions/releaseBlock.js";