@elizaos/agent 2.0.0-alpha.358 → 2.0.0-alpha.376

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;AAkJhC,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;IA0CV,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,258 @@
+import crypto from "node:crypto";
+import { createUniqueUuid, logger, stringToUuid } from "@elizaos/core";
+import { blockWebsitesAction } from "../../actions/website-blocker.js";
+import { executeRawSql, sqlQuote, sqlText } from "../../lifeops/sql.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-room-${String(runtime.agentId)}`);
+    return {
+        id: createUniqueUuid(runtime, `block-rule-${Date.now()}`),
+        entityId: runtime.agentId,
+        agentId: runtime.agentId,
+        roomId,
+        content: {
+            text: `Block ${websites.join(", ")}.`,
+            source: "agent",
+        },
+    };
+}
+async function ensureSyntheticMessageContext(runtime, message) {
+    if (typeof runtime.ensureWorldExists !== "function" ||
+        typeof runtime.ensureConnection !== "function" ||
+        typeof runtime.ensureParticipantInRoom !== "function") {
+        return;
+    }
+    const worldId = stringToUuid(`block-rule-service-world-${String(runtime.agentId)}`);
+    const metadata = {
+        ownership: {
+            ownerId: runtime.agentId,
+        },
+        roles: {
+            [runtime.agentId]: "OWNER",
+        },
+    };
+    await runtime.ensureWorldExists({
+        id: worldId,
+        name: "Block Rule Service",
+        agentId: runtime.agentId,
+        messageServerId: worldId,
+        metadata,
+    });
+    await runtime.ensureConnection({
+        entityId: runtime.agentId,
+        roomId: message.roomId,
+        worldId,
+        worldName: "Block Rule Service",
+        userName: "BlockRuleWriter",
+        name: "BlockRuleWriter",
+        source: "agent",
+        channelId: message.roomId,
+        type: "DM",
+        messageServerId: worldId,
+        metadata,
+    });
+    await runtime.ensureParticipantInRoom(runtime.agentId, message.roomId);
+}
+function computeHandlerOptionsForCreate(input) {
+    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;
+}
+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)},
+         ${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);
+        await ensureSyntheticMessageContext(this.runtime, message);
+        const durationMinutes = computeHandlerOptionsForCreate(input);
+        const result = await blockWebsitesAction.handler(this.runtime, message, undefined, {
+            parameters: {
+                websites: input.websites,
+                durationMinutes,
+                confirmed: true,
+            },
+        });
+        if (result?.success === false) {
+            // The rule is the source of truth. 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.
+            logger.warn(`[BlockRuleWriter] SelfControl activation did not complete for rule ${id}: ${result.text ?? "unknown error"}`);
+        }
+        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";

package/apps/app-lifeops/src/website-blocker/engine.js

@@ -1112,7 +1112,7 @@ async function writeHostsFileContentWithElevation(hostsFilePath, nextContent) {
     }
 }
 function normalizeWebsiteTarget(rawTarget) {
-    const trimmed = rawTarget.trim().replace(/[),.!?]+$/g, "");
+    const trimmed = rawTarget.slice(0, 4096).trim().replace(/[),.!?]{1,64}$/g, "");
     if (!trimmed)
         return null;
     let hostname = trimmed;
@@ -1164,9 +1164,10 @@ function normalizeStringList(value) {
             }
         }
         return trimmed
+            .slice(0, 10_000)
             .split(/[,\n]/)
-            .map((item) => item.trim())
-            .map((item) => item.replace(/^[\[\]'"]+|[\[\]'"]+$/g, ""))
+            .map((item) => item.trim().slice(0, 1024))
+            .map((item) => item.replace(/^[\[\]'"]{1,32}|[\[\]'"]{1,32}$/g, ""))
             .filter((item) => item.length > 0);
     }
     return null;

package/apps/app-steward/src/ApprovalQueue.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Approval queue — shows pending transactions that need manual approval.
+ * Polls every 10 seconds for new items.
+ */
+import type { StewardApprovalActionResponse, StewardPendingApproval } from "./types/steward";
+interface ApprovalQueueProps {
+    getStewardPending: () => Promise<StewardPendingApproval[]>;
+    approveStewardTx: (txId: string) => Promise<StewardApprovalActionResponse>;
+    rejectStewardTx: (txId: string, reason?: string) => Promise<StewardApprovalActionResponse>;
+    copyToClipboard: (text: string) => Promise<void>;
+    setActionNotice: (text: string, tone?: "info" | "success" | "error", ttlMs?: number) => void;
+    onPendingCountChange?: (count: number) => void;
+    embedded?: boolean;
+    refreshKey?: number | string;
+}
+export declare function ApprovalQueue({ getStewardPending, approveStewardTx, rejectStewardTx, copyToClipboard, setActionNotice, onPendingCountChange, embedded, refreshKey, }: ApprovalQueueProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=ApprovalQueue.d.ts.map

package/apps/app-steward/src/ApprovalQueue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApprovalQueue.d.ts","sourceRoot":"","sources":["../../../../../../apps/app-steward/src/ApprovalQueue.tsx"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,OAAO,KAAK,EACV,6BAA6B,EAC7B,sBAAsB,EAEvB,MAAM,iBAAiB,CAAC;AAEzB,UAAU,kBAAkB;IAC1B,iBAAiB,EAAE,MAAM,OAAO,CAAC,sBAAsB,EAAE,CAAC,CAAC;IAC3D,gBAAgB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,6BAA6B,CAAC,CAAC;IAC3E,eAAe,EAAE,CACf,IAAI,EAAE,MAAM,EACZ,MAAM,CAAC,EAAE,MAAM,KACZ,OAAO,CAAC,6BAA6B,CAAC,CAAC;IAC5C,eAAe,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACjD,eAAe,EAAE,CACf,IAAI,EAAE,MAAM,EACZ,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,EACnC,KAAK,CAAC,EAAE,MAAM,KACX,IAAI,CAAC;IACV,oBAAoB,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/C,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CAC9B;AAID,wBAAgB,aAAa,CAAC,EAC5B,iBAAiB,EACjB,gBAAgB,EAChB,eAAe,EACf,eAAe,EACf,eAAe,EACf,oBAAoB,EACpB,QAAgB,EAChB,UAAU,GACX,EAAE,kBAAkB,2CAkVpB"}