loopengine 0.1.67 → 0.1.68

package/README.md

@@ -171,11 +171,20 @@ export const config: AgentConfig = {
 }
 ```
 
-Or skip the code: in the console, **Permissions → Approvals** sets a
+Or skip the code: in the console, the Permissions tab's **Where approval
+requests and questions are sent** section sets a
 webhook, Slack or Lark target for one agent (saved to
 `agents/<name>/notifier.yml`, with its secret in the agent's own `.env`),
 sends a test, shows recent deliveries, and lists every decision still
-waiting with Approve/Deny buttons.
+waiting with Approve/Deny buttons. The tab warns you when an agent has
+`ask` rules but nobody would be told.
+
+Every notification links to a **decision page**: a signed, single-use
+link (`/decide/<token>`, valid 7 days) where whoever got the message can
+approve, deny, edit the arguments or answer a question, with no login and
+no app of your own. So the quickest setup is Slack: paste a bot token,
+pick a channel, save; each approval arrives with an "Open to approve or
+deny" link.
 
 For a third-party app calling an agent over plain HTTP:
 

package/dist/core/agent-config.d.ts

@@ -185,6 +185,7 @@ export type HttpNotifierConfig = {
     config: {
         webhookUrl: string;
         webhookSecret: string;
+        publicUrl?: string;
     };
     events: HttpNotifierEvent[];
 } | {
@@ -192,6 +193,8 @@ export type HttpNotifierConfig = {
     config: {
         botToken: string;
         channelId: string;
+        publicUrl?: string;
+        buttons?: boolean;
     };
     events: HttpNotifierEvent[];
 } | {

package/dist/core/approval-links.d.ts

@@ -0,0 +1,16 @@
+export type DecisionKind = 'approval' | 'question';
+/** How long a link works: 7 days, or LOOPENGINE_LINK_TTL_HOURS. */
+export declare function decisionLinkTtlMs(): number;
+export declare function createDecisionToken(pendingId: string, kind: DecisionKind, nowMs?: number): string;
+/** The pendingId and kind a token names, or null for a malformed,
+ * tampered or expired one. */
+export declare function verifyDecisionToken(token: string, nowMs?: number): {
+    pendingId: string;
+    kind: DecisionKind;
+    expiresAt: number;
+} | null;
+export declare function decidePath(pendingId: string, kind: DecisionKind): string;
+/** Builds full decision links against `baseUrl` — undefined when there's
+ * no base URL to build them against. */
+export type DecideLinkMaker = (pendingId: string, kind: DecisionKind) => string | undefined;
+export declare function decideLinkMaker(baseUrl: string | undefined): DecideLinkMaker;

package/dist/core/approval-links.js

@@ -0,0 +1,76 @@
+// Decision links: a signed, expiring URL for one waiting approval or
+// question (/decide/<token>) that opens a small page where whoever has
+// the link can approve, deny or answer — no admin login, no app of your
+// own, no Slack interactivity setup. Every notifier that knows where this
+// server is reachable puts one in its message.
+//
+// The token only names the pendingId, its kind and an expiry, signed
+// with HMAC-SHA256. It's single-use by construction: once the decision
+// is made the pending item no longer exists, so the same link just shows
+// "already decided."
+//
+// The signing secret is LOOPENGINE_LINK_SECRET when set (required for a
+// deployment with more than one server, which must share it), otherwise
+// one generated on first use and kept in .checkpoints/link-secret next to
+// the paused turns it unlocks, so links keep working across restarts.
+import { createHmac, randomBytes, timingSafeEqual } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+/** How long a link works: 7 days, or LOOPENGINE_LINK_TTL_HOURS. */
+export function decisionLinkTtlMs() {
+    const hours = Number(process.env.LOOPENGINE_LINK_TTL_HOURS);
+    return (Number.isFinite(hours) && hours > 0 ? hours : 24 * 7) * 3_600_000;
+}
+let generatedSecret;
+function linkSecret() {
+    if (process.env.LOOPENGINE_LINK_SECRET)
+        return process.env.LOOPENGINE_LINK_SECRET;
+    if (generatedSecret)
+        return generatedSecret;
+    const dir = join(process.cwd(), '.checkpoints');
+    const path = join(dir, 'link-secret');
+    if (existsSync(path)) {
+        generatedSecret = readFileSync(path, 'utf8').trim();
+    }
+    else {
+        generatedSecret = randomBytes(32).toString('hex');
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(path, generatedSecret + '\n', { mode: 0o600 });
+    }
+    return generatedSecret;
+}
+function sign(body) {
+    return createHmac('sha256', linkSecret()).update(body).digest('base64url');
+}
+export function createDecisionToken(pendingId, kind, nowMs = Date.now()) {
+    const body = Buffer.from(JSON.stringify({ p: pendingId, k: kind, exp: nowMs + decisionLinkTtlMs() })).toString('base64url');
+    return `${body}.${sign(body)}`;
+}
+/** The pendingId and kind a token names, or null for a malformed,
+ * tampered or expired one. */
+export function verifyDecisionToken(token, nowMs = Date.now()) {
+    const [body, signature] = token.split('.');
+    if (!body || !signature)
+        return null;
+    const expected = Buffer.from(sign(body));
+    const actual = Buffer.from(signature);
+    if (expected.length !== actual.length || !timingSafeEqual(expected, actual))
+        return null;
+    try {
+        const payload = JSON.parse(Buffer.from(body, 'base64url').toString('utf8'));
+        if (typeof payload.p !== 'string' || (payload.k !== 'approval' && payload.k !== 'question') || typeof payload.exp !== 'number')
+            return null;
+        if (nowMs > payload.exp)
+            return null;
+        return { pendingId: payload.p, kind: payload.k, expiresAt: payload.exp };
+    }
+    catch {
+        return null;
+    }
+}
+export function decidePath(pendingId, kind) {
+    return `/decide/${createDecisionToken(pendingId, kind)}`;
+}
+export function decideLinkMaker(baseUrl) {
+    return (pendingId, kind) => (baseUrl ? baseUrl.replace(/\/+$/, '') + decidePath(pendingId, kind) : undefined);
+}

package/dist/core/durable-approvals.d.ts

@@ -65,6 +65,10 @@ export interface CheckpointStore {
      * first — backs GET /agents/:name/pending. Reads without locking: a
      * snapshot for display, not something to act on without withCheckpoint. */
     listOpen(): Promise<TurnCheckpoint[]>;
+    /** The open checkpoint `pendingId` belongs to, read without locking —
+     * for showing a decision page, not for acting on it (use
+     * withCheckpoint for that). undefined once it's decided or unknown. */
+    get(pendingId: string): Promise<TurnCheckpoint | undefined>;
     close(): Promise<void>;
 }
 /** One JSON file per checkpoint under `<dir>/checkpoints/`, plus one
@@ -82,6 +86,7 @@ export declare class FileCheckpointStore implements CheckpointStore {
         checkpoint: TurnCheckpoint | undefined;
         result: T;
     }>): Promise<T>;
+    get(pendingId: string): Promise<TurnCheckpoint | undefined>;
     listOpen(): Promise<TurnCheckpoint[]>;
     close(): Promise<void>;
 }
@@ -106,6 +111,7 @@ export declare class RedisCheckpointStore implements CheckpointStore {
         checkpoint: TurnCheckpoint | undefined;
         result: T;
     }>): Promise<T>;
+    get(pendingId: string): Promise<TurnCheckpoint | undefined>;
     listOpen(): Promise<TurnCheckpoint[]>;
     close(): Promise<void>;
 }

package/dist/core/durable-approvals.js

@@ -72,6 +72,16 @@ export class FileCheckpointStore {
             return result;
         });
     }
+    async get(pendingId) {
+        const indexPath = this.indexPath(pendingId);
+        if (!existsSync(indexPath))
+            return undefined;
+        const checkpointPath = this.checkpointPath(readFileSync(indexPath, 'utf8'));
+        if (!existsSync(checkpointPath))
+            return undefined;
+        const checkpoint = JSON.parse(readFileSync(checkpointPath, 'utf8'));
+        return !checkpoint.closed && checkpoint.outstanding[pendingId] ? checkpoint : undefined;
+    }
     async listOpen() {
         const open = [];
         for (const name of readdirSync(this.checkpointsDir)) {
@@ -164,6 +174,16 @@ export class RedisCheckpointStore {
             return result;
         });
     }
+    async get(pendingId) {
+        const checkpointId = await this.redis.get(this.indexKey(pendingId));
+        if (!checkpointId)
+            return undefined;
+        const raw = await this.redis.get(this.checkpointKey(checkpointId));
+        if (!raw)
+            return undefined;
+        const checkpoint = JSON.parse(raw);
+        return !checkpoint.closed && checkpoint.outstanding[pendingId] ? checkpoint : undefined;
+    }
     async listOpen() {
         const open = [];
         let cursor = '0';

package/dist/core/http-notifier.js

@@ -84,11 +84,11 @@ function buildResolved(httpNotifier) {
     let resolved;
     switch (httpNotifier.channel) {
         case 'webhook': {
-            const { webhookUrl, webhookSecret } = httpNotifier.config;
+            const { webhookUrl, webhookSecret, publicUrl } = httpNotifier.config;
             // One shared instance for both concerns, same "it's channel-
             // specific, not concern-specific" reasoning every other channel's
             // own file already has — see WebhookNotifier's own doc comment.
-            const webhook = new WebhookNotifier({ webhookUrl, signingSecret: webhookSecret });
+            const webhook = new WebhookNotifier({ webhookUrl, signingSecret: webhookSecret, publicUrl });
             resolved = {
                 approver: events.has('approval') ? webhook : undefined,
                 questionHandler: events.has('question') ? webhook : undefined,
@@ -98,13 +98,13 @@ function buildResolved(httpNotifier) {
             break;
         }
         case 'slack': {
-            const { botToken, channelId } = httpNotifier.config;
+            const { botToken, channelId, publicUrl, buttons } = httpNotifier.config;
             // One shared instance for every concern this httpNotifier actually
             // covers — same "it's Slack-specific, not approval/question/
             // lifecycle-specific" reasoning SlackNotifier's own doc
             // comment works out; cheap to construct (holds two strings, does no
             // I/O itself) so there's no reason to build one per event kind.
-            const slack = new SlackNotifier({ botToken, channelId });
+            const slack = new SlackNotifier({ botToken, channelId, publicUrl, buttons });
             resolved = {
                 approver: events.has('approval') ? slack : undefined,
                 questionHandler: events.has('question') ? slack : undefined,

package/dist/core/http-notify-triggers/slack.d.ts

@@ -3,10 +3,22 @@ import type { DurableQuestionHandler } from '../agent-config.js';
 export declare class SlackNotifier implements DurableApprover, DurableQuestionHandler {
     private readonly botToken;
     private readonly channelId;
+    private readonly publicUrl?;
+    private readonly buttons;
+    /** `publicUrl`: where this server is reachable (LOOPENGINE_PUBLIC_URL
+     * wins when set) — when known, each message links to a decision page
+     * (core/approval-links.ts) anyone in the channel can open. `buttons`:
+     * whether to add interactive Approve/Deny buttons, which only work with
+     * a Slack interactivity endpoint deployed (examples/notifier-handler/
+     * slack.ts); default true, false for a console-configured notifier,
+     * which relies on the link instead. */
     constructor(options: {
         botToken: string;
         channelId: string;
+        publicUrl?: string;
+        buttons?: boolean;
     });
+    private decideLine;
     requestDurableApproval(tool: string, args: Record<string, unknown>, scope: Scope, reason: string): {
         pendingId: string;
     };

package/dist/core/http-notify-triggers/slack.js

@@ -24,12 +24,29 @@
 // it's Slack-specific (the bot token, the channel, the chat.postMessage
 // call shape).
 import { randomUUID } from 'node:crypto';
+import { decidePath } from '../approval-links.js';
+import { publicBaseUrl } from './webhook.js';
 export class SlackNotifier {
     botToken;
     channelId;
+    publicUrl;
+    buttons;
+    /** `publicUrl`: where this server is reachable (LOOPENGINE_PUBLIC_URL
+     * wins when set) — when known, each message links to a decision page
+     * (core/approval-links.ts) anyone in the channel can open. `buttons`:
+     * whether to add interactive Approve/Deny buttons, which only work with
+     * a Slack interactivity endpoint deployed (examples/notifier-handler/
+     * slack.ts); default true, false for a console-configured notifier,
+     * which relies on the link instead. */
     constructor(options) {
         this.botToken = options.botToken;
         this.channelId = options.channelId;
+        this.publicUrl = options.publicUrl;
+        this.buttons = options.buttons ?? true;
+    }
+    decideLine(pendingId, kind) {
+        const base = publicBaseUrl(this.publicUrl);
+        return base ? `\n<${base}${decidePath(pendingId, kind)}|${kind === 'approval' ? 'Open to approve or deny' : 'Open to answer'}>` : '';
     }
     requestDurableApproval(tool, args, scope, reason) {
         const pendingId = randomUUID();
@@ -38,16 +55,18 @@ export class SlackNotifier {
                 type: 'section',
                 text: {
                     type: 'mrkdwn',
-                    text: `*Approval requested*\n*tool:* ${tool}\n*args:* \`${JSON.stringify(args)}\`\n*scope:* ${scope.tenant}/${scope.environment}/${scope.agent}\n*reason:* ${reason}`,
+                    text: `*Approval requested*\n*tool:* ${tool}\n*args:* \`${JSON.stringify(args)}\`\n*scope:* ${scope.tenant}/${scope.environment}/${scope.agent}\n*reason:* ${reason}${this.decideLine(pendingId, 'approval')}`,
                 },
             },
-            {
-                type: 'actions',
-                elements: [
-                    { type: 'button', text: { type: 'plain_text', text: 'Approve' }, style: 'primary', action_id: 'approve', value: pendingId },
-                    { type: 'button', text: { type: 'plain_text', text: 'Deny' }, style: 'danger', action_id: 'deny', value: pendingId },
-                ],
-            },
+            ...(this.buttons
+                ? [{
+                        type: 'actions',
+                        elements: [
+                            { type: 'button', text: { type: 'plain_text', text: 'Approve' }, style: 'primary', action_id: 'approve', value: pendingId },
+                            { type: 'button', text: { type: 'plain_text', text: 'Deny' }, style: 'danger', action_id: 'deny', value: pendingId },
+                        ],
+                    }]
+                : []),
         ]);
         return { pendingId };
     }
@@ -60,8 +79,10 @@ export class SlackNotifier {
             action_id: 'answer_option',
         }));
         this.postMessage(`Question from ${agent}: ${question}`, [
-            { type: 'section', text: { type: 'mrkdwn', text: `*Question from ${agent}${sessionId ? ` (session ${sessionId})` : ''}:*\n${question}` } },
-            { type: 'actions', elements: [...optionButtons, { type: 'button', text: { type: 'plain_text', text: 'Other…' }, action_id: 'open_answer_modal', value: pendingId }] },
+            { type: 'section', text: { type: 'mrkdwn', text: `*Question from ${agent}${sessionId ? ` (session ${sessionId})` : ''}:*\n${question}${this.decideLine(pendingId, 'question')}` } },
+            ...(this.buttons
+                ? [{ type: 'actions', elements: [...optionButtons, { type: 'button', text: { type: 'plain_text', text: 'Other…' }, action_id: 'open_answer_modal', value: pendingId }] }]
+                : []),
         ]);
         return { pendingId };
     }

package/dist/core/http-notify-triggers/webhook.d.ts

@@ -5,14 +5,22 @@ export interface DeliveryResult {
     status?: number;
     error?: string;
 }
+/** Where this server is reachable: LOOPENGINE_PUBLIC_URL (e.g.
+ * https://acme.loopengine.app) when set, read per call so a change takes
+ * effect without a restart, else `fallback` (a notifier.yml's own
+ * publicUrl, remembered from the console). undefined when neither is
+ * known, in which case payloads carry only relative paths. */
+export declare function publicBaseUrl(fallback?: string): string | undefined;
 export declare class WebhookNotifier implements DurableApprover, DurableQuestionHandler {
     private readonly webhookUrl;
     private readonly signingSecret;
     private readonly retryDelaysMs;
+    private readonly publicUrl?;
     constructor(options: {
         webhookUrl: string;
         signingSecret: string;
         retryDelaysMs?: number[];
+        publicUrl?: string;
     });
     requestDurableApproval(tool: string, args: Record<string, unknown>, scope: Scope, reason: string): {
         pendingId: string;

package/dist/core/http-notify-triggers/webhook.js

@@ -48,18 +48,24 @@
 // working unchanged.
 import { createHmac, randomUUID } from 'node:crypto';
 import { recordDelivery } from '../notifier-deliveries.js';
+import { decidePath } from '../approval-links.js';
 /** Waits before each retry after the first attempt — four tries in all,
  * spread over about 40 seconds. */
 const RETRY_DELAYS_MS = [2_000, 10_000, 30_000];
 function sign(body, secret) {
     return `sha256=${createHmac('sha256', secret).update(body).digest('hex')}`;
 }
-/** LOOPENGINE_PUBLIC_URL (e.g. https://acme.loopengine.app), read per
- * call so a change takes effect without a restart; undefined when unset,
- * in which case payloads carry only the relative path. */
-function publicUrl(path) {
-    const base = process.env.LOOPENGINE_PUBLIC_URL;
-    return base ? base.replace(/\/+$/, '') + path : undefined;
+/** Where this server is reachable: LOOPENGINE_PUBLIC_URL (e.g.
+ * https://acme.loopengine.app) when set, read per call so a change takes
+ * effect without a restart, else `fallback` (a notifier.yml's own
+ * publicUrl, remembered from the console). undefined when neither is
+ * known, in which case payloads carry only relative paths. */
+export function publicBaseUrl(fallback) {
+    const base = process.env.LOOPENGINE_PUBLIC_URL || fallback;
+    return base ? base.replace(/\/+$/, '') : undefined;
+}
+function absolute(base, path) {
+    return base ? base + path : undefined;
 }
 async function attemptOnce(url, body, headers) {
     try {
@@ -91,18 +97,24 @@ export class WebhookNotifier {
     webhookUrl;
     signingSecret;
     retryDelaysMs;
+    publicUrl;
     constructor(options) {
         this.webhookUrl = options.webhookUrl;
         this.signingSecret = options.signingSecret;
         this.retryDelaysMs = options.retryDelaysMs ?? RETRY_DELAYS_MS;
+        this.publicUrl = options.publicUrl;
     }
     requestDurableApproval(tool, args, scope, reason) {
         const pendingId = randomUUID();
         const requestedAt = new Date().toISOString();
         const resolvePath = `/pending-approvals/${pendingId}/resolve`;
+        const decide = decidePath(pendingId, 'approval');
+        const base = publicBaseUrl(this.publicUrl);
         const body = JSON.stringify({
             pendingId, tool, args, scope, reason, requestedAt,
-            kind: 'approval', agent: scope.agent, resolvePath, resolveUrl: publicUrl(resolvePath),
+            kind: 'approval', agent: scope.agent, resolvePath, resolveUrl: absolute(base, resolvePath),
+            // A signed link a person can open to decide, no login needed.
+            decidePath: decide, decideUrl: absolute(base, decide),
         });
         void deliver(this.webhookUrl, body, { 'X-Actauth-Signature': sign(body, this.signingSecret) }, { agent: scope.agent, kind: 'approval', pendingId }, this.retryDelaysMs);
         return { pendingId };
@@ -111,9 +123,12 @@ export class WebhookNotifier {
         const pendingId = randomUUID();
         const requestedAt = new Date().toISOString();
         const answerPath = `/pending-questions/${pendingId}/answer`;
+        const decide = decidePath(pendingId, 'question');
+        const base = publicBaseUrl(this.publicUrl);
         const body = JSON.stringify({
             pendingId, question, options, agent, sessionId, requestedAt,
-            kind: 'question', answerPath, answerUrl: publicUrl(answerPath),
+            kind: 'question', answerPath, answerUrl: absolute(base, answerPath),
+            decidePath: decide, decideUrl: absolute(base, decide),
         });
         void deliver(this.webhookUrl, body, { 'X-Askuser-Signature': sign(body, this.signingSecret) }, { agent, kind: 'question', pendingId }, this.retryDelaysMs);
         return { pendingId };

package/dist/core/notifier-file.d.ts

@@ -10,6 +10,10 @@ export interface NotifierFile {
     /** lark: app id and chat to post into. */
     appId?: string;
     chatId?: string;
+    /** Where this server is reachable, for the links in each message —
+     * remembered from the console's own address when saving.
+     * LOOPENGINE_PUBLIC_URL, when set, wins over it. */
+    publicUrl?: string;
 }
 /** The env var each channel's secret is read from, per agent. */
 export declare const NOTIFIER_SECRET_VARS: Record<NotifierFileChannel, string>;

package/dist/core/notifier-file.js

@@ -1,6 +1,6 @@
 // agents/<name>/notifier.yml — where an agent's "ask" approvals and
 // questions go when nobody is watching a live chat, set from the console
-// (Permissions → Approvals) instead of in code. Only consulted when the
+// (Permissions → "Where approval requests and questions are sent") instead of in code. Only consulted when the
 // agent's own AgentConfig.httpNotifier is unset; code always wins.
 //
 // The file holds only non-secret settings. The one secret each channel
@@ -38,6 +38,12 @@ export function validateNotifierFile(input) {
     }
     const str = (key) => (typeof raw[key] === 'string' && raw[key].trim() ? raw[key].trim() : undefined);
     const file = { channel, events: events };
+    const publicUrl = str('publicUrl');
+    if (publicUrl) {
+        if (!/^https?:\/\/[^/]+/.test(publicUrl))
+            throw new NotifierFileError('publicUrl must be an http(s) URL');
+        file.publicUrl = publicUrl.replace(/\/+$/, '');
+    }
     if (channel === 'webhook') {
         const url = str('url');
         if (!url || !/^https?:\/\//.test(url))
@@ -69,8 +75,8 @@ export function readNotifierFile(dir) {
 }
 export function writeNotifierFile(dir, input) {
     const file = validateNotifierFile(input);
-    const header = '# Where this agent sends "ask" approvals and questions when nobody is in a live chat.\n' +
-        `# Edited from the console (Permissions > Approvals). The secret lives in this agent's env as ${NOTIFIER_SECRET_VARS[file.channel]}.\n`;
+    const header = '# Where this agent sends approval requests and questions when it is called over HTTP.\n' +
+        `# Edited from the console (Permissions tab). The secret lives in this agent's env as ${NOTIFIER_SECRET_VARS[file.channel]}.\n`;
     writeFileSync(notifierFilePath(dir), header + stringifyYaml(file));
     return file;
 }
@@ -87,9 +93,11 @@ export function notifierConfigFromFile(file, env) {
         return { missingSecret: secretVar };
     switch (file.channel) {
         case 'webhook':
-            return { config: { channel: 'webhook', config: { webhookUrl: file.url, webhookSecret: secret }, events: file.events } };
+            return { config: { channel: 'webhook', config: { webhookUrl: file.url, webhookSecret: secret, publicUrl: file.publicUrl }, events: file.events } };
         case 'slack':
-            return { config: { channel: 'slack', config: { botToken: secret, channelId: file.channelId }, events: file.events } };
+            // No interactive buttons: a console-configured Slack notifier has
+            // no interactivity endpoint behind it; the decision link replaces them.
+            return { config: { channel: 'slack', config: { botToken: secret, channelId: file.channelId, publicUrl: file.publicUrl, buttons: false }, events: file.events } };
         case 'lark':
             return { config: { channel: 'lark', config: { appId: file.appId, appSecret: secret, chatId: file.chatId }, events: file.events } };
     }

package/dist/index.d.ts

@@ -10,6 +10,8 @@ export { setUsageSink, recordUsage, type UsageEvent, type UsageSink } from '#cor
 export { readNotifierFile, writeNotifierFile, removeNotifierFile, validateNotifierFile, notifierConfigFromFile, NotifierFileError, NOTIFIER_SECRET_VARS, type NotifierFile } from '#core/notifier-file.js';
 export { listDeliveries, recordDelivery, type NotifierDelivery } from '#core/notifier-deliveries.js';
 export { describeNotifier } from '#core/http-notifier.js';
+export { createDecisionToken, verifyDecisionToken, decidePath, decideLinkMaker, decisionLinkTtlMs, type DecisionKind } from '#core/approval-links.js';
+export { renderDecidePage, renderDecideGonePage, renderDecideInvalidPage, type DecidePageItem } from './web/decide-page.js';
 export { sendTestWebhook } from '#core/http-notify-triggers/webhook.js';
 export { describeAgentNotifier, saveAgentNotifier, removeAgentNotifier, testAgentNotifier, listAgentPending, type DefaultWebhook } from './web/notifier-admin.js';
 export type * from './core/loop-events.js';

package/dist/index.js

@@ -12,6 +12,8 @@ export { setUsageSink, recordUsage } from '#core/usage.js';
 export { readNotifierFile, writeNotifierFile, removeNotifierFile, validateNotifierFile, notifierConfigFromFile, NotifierFileError, NOTIFIER_SECRET_VARS } from '#core/notifier-file.js';
 export { listDeliveries, recordDelivery } from '#core/notifier-deliveries.js';
 export { describeNotifier } from '#core/http-notifier.js';
+export { createDecisionToken, verifyDecisionToken, decidePath, decideLinkMaker, decisionLinkTtlMs } from '#core/approval-links.js';
+export { renderDecidePage, renderDecideGonePage, renderDecideInvalidPage } from './web/decide-page.js';
 export { sendTestWebhook } from '#core/http-notify-triggers/webhook.js';
 export { describeAgentNotifier, saveAgentNotifier, removeAgentNotifier, testAgentNotifier, listAgentPending } from './web/notifier-admin.js';
 // The framework-agnostic browser client for adapters/http.ts's own wire

package/dist/web/agents-config-page.js

@@ -39,6 +39,7 @@ export const agentsConfigPageHtml = `<!doctype html>
      panels' own content. */
   #empty { color: var(--ink-muted); font-size: 13px; padding: 24px; }
   .env-cell { display: grid; gap: 6px; }
+  .approvals-nudge { border: 1px solid var(--warn); background: var(--warn-soft); color: var(--ink); border-radius: var(--radius); padding: 12px 14px; margin-bottom: 24px; font-size: 13px; }
   .env-desc { max-width: 340px; display: -webkit-box; -webkit-line-clamp: 3; -webkit-box-orient: vertical; overflow: hidden; }
   form.add-source.env-inline { border: 0; padding: 0; display: flex; flex-wrap: wrap; gap: 6px; max-width: 320px; }
   form.add-source.env-inline input, form.add-source.env-inline select { flex: 1 1 140px; width: auto; min-width: 0; }
@@ -955,7 +956,7 @@ ${consoleShellScript}
         '</form></section>';
   }
 
-  // ---- Permissions → Approvals: where "ask" decisions go when nobody is
+  // ---- Permissions → "Where approval requests and questions are sent": where "ask" decisions go when nobody is
   // in Chat (web/notifier-admin.ts behind GET/PUT/DELETE .../notifier),
   // the decisions still waiting (GET .../pending), and recent webhook
   // deliveries. Reloaded every time the tab opens, so the waiting list is
@@ -980,6 +981,9 @@ ${consoleShellScript}
           ? '<form class="pending-answer" data-id="' + escapeHtml(p.pendingId) + '" style="display:flex;gap:6px"><input name="answer" placeholder="Answer" required style="min-width:0"><button type="submit">Answer</button></form>'
           : '<div style="display:flex;gap:6px"><button type="button" class="primary pending-decide" data-id="' + escapeHtml(p.pendingId) + '" data-decision="approve">Approve</button>' +
             '<button type="button" class="pending-decide" data-id="' + escapeHtml(p.pendingId) + '" data-decision="deny">Deny</button></div>';
+        if (p.decidePath) {
+          actions += '<button type="button" class="pending-copy" data-path="' + escapeHtml(p.decidePath) + '" title="A link anyone can open to decide, no login needed" style="margin-top:6px">Copy link</button>';
+        }
         return '<tr><td><span class="le-pill ' + (p.kind === 'question' ? 'accent' : 'ask') + '">' + (p.kind === 'question' ? 'question' : 'approval') + '</span>' +
           (p.createdAt ? '<div class="hint">' + escapeHtml(new Date(p.createdAt).toLocaleString()) + '</div>' : '') + '</td>' +
           '<td>' + details + '</td><td><code>' + escapeHtml(p.sessionId) + '</code></td><td>' + actions + '</td></tr>';
@@ -991,12 +995,15 @@ ${consoleShellScript}
     if (n.source === 'file') return 'Sending to <strong>' + escapeHtml(n.channel) + '</strong> for: ' + escapeHtml((n.events || []).join(', ')) + '.';
     if (n.missingSecret) return 'Saved, but not sending yet: set the secret below (<code>' + escapeHtml(n.missingSecret) + '</code>).';
     if (n.source === 'default') return 'Using the project-wide default webhook (<code>LOOPENGINE_DEFAULT_WEBHOOK_URL</code>, ' + escapeHtml(n.defaultWebhookUrl) + '). Set one below to use a different target for this agent.';
-    return 'Not set up. A call that needs approval only reaches someone in Chat; set a webhook or Slack channel so apps calling this agent over HTTP can get approvals.';
+    return '<strong>Nowhere yet</strong>, so nobody is notified. Choose a webhook, Slack channel or Lark chat below.';
   }
 
   function renderNotifierForm(n) {
     var f = n.file || { channel: 'webhook', events: ['approval', 'question'] };
     var events = f.events || [];
+    function eventBox(e) {
+      return '<label class="tool-picker-item" style="border:0;padding:0;justify-content:flex-start"><input type="checkbox" name="events" value="' + e[0] + '"' + (events.indexOf(e[0]) !== -1 ? ' checked' : '') + '> ' + e[1] + '</label>';
+    }
     function field(channel, html) {
       return '<div class="notifier-fields" data-channel="' + channel + '"' + (f.channel === channel ? '' : ' hidden') + '>' + html + '</div>';
     }
@@ -1013,15 +1020,18 @@ ${consoleShellScript}
       field('webhook', '<label>Webhook URL<input type="url" name="url" placeholder="https://your-app.example.com/hooks/loopengine" value="' + escapeHtml(f.url || '') + '"></label>' + secretField('webhook', 'Signing secret')) +
       field('slack', '<label>Channel ID<input name="channelId" placeholder="C0123ABC456" value="' + escapeHtml(f.channelId || '') + '"></label>' + secretField('slack', 'Bot token')) +
       field('lark', '<label>App ID<input name="appId" value="' + escapeHtml(f.appId || '') + '"></label><label>Chat ID<input name="chatId" value="' + escapeHtml(f.chatId || '') + '"></label>' + secretField('lark', 'App secret')) +
-      '<div class="body-field">Send<div style="display:flex;gap:14px;flex-wrap:wrap">' +
-        NOTIFIER_EVENTS.map(function (e) {
-          return '<label class="tool-picker-item" style="border:0;padding:0;justify-content:flex-start"><input type="checkbox" name="events" value="' + e[0] + '"' + (events.indexOf(e[0]) !== -1 ? ' checked' : '') + '> ' + e[1] + '</label>';
-        }).join('') + '</div></div>' +
-      '<div style="display:flex;gap:8px;flex-wrap:wrap"><button type="submit">Save</button><button type="button" id="notifierTestBtn">Send test</button>' +
+      '<label>Link address <span class="hint">(messages link here so people can approve without logging in; use an address they can reach)</span>' +
+        '<input type="url" name="publicUrl" id="notifierPublicUrl" value="' + escapeHtml(n.publicUrl || f.publicUrl || location.origin) + '"' + (n.publicUrl ? ' disabled title="Set by LOOPENGINE_PUBLIC_URL"' : '') + '></label>' +
+      '<div class="body-field">Send' +
+        '<div style="display:flex;gap:14px;flex-wrap:wrap">' + NOTIFIER_EVENTS.slice(0, 2).map(eventBox).join('') + '</div>' +
+        '<details' + (events.indexOf('run_finish') !== -1 || events.indexOf('run_start') !== -1 ? ' open' : '') + '><summary>More events</summary>' +
+        '<div style="display:flex;gap:14px;flex-wrap:wrap;margin-top:6px">' + NOTIFIER_EVENTS.slice(2).map(eventBox).join('') + '</div>' +
+        '<p class="hint" style="margin:4px 0 0">Run finished tells your app the agent&#39;s final reply once a decision lets it finish.</p></details></div>' +
+      (n.canSave === false ? '<p class="error" style="margin:0">Saving needs <code>LOOPENGINE_ADMIN_AUTH</code> set on the server, because this stores a secret. Add <code>LOOPENGINE_ADMIN_AUTH=user:pass</code> to <code>.env</code> and restart.</p>' : '') +
+      '<div style="display:flex;gap:8px;flex-wrap:wrap"><button type="submit"' + (n.canSave === false ? ' disabled' : '') + '>Save</button><button type="button" id="notifierTestBtn">Send test</button>' +
         (n.file ? '<button type="button" class="delete-btn" id="notifierRemoveBtn">Remove</button>' : '') + '</div>' +
       '<div id="notifierResult" class="hint"></div>' +
-      '<p class="hint" style="margin:0">Your app checks the <code>X-Actauth-Signature</code> header (HMAC-SHA256 of the body with the signing secret). Each payload carries <code>pendingId</code> and <code>resolvePath</code>; your app sends <code>{"decision":"approve"}</code> or <code>{"decision":"deny"}</code> there.' +
-        (n.publicUrl ? '' : ' Set <code>LOOPENGINE_PUBLIC_URL</code> to include a full <code>resolveUrl</code> too.') + '</p>' +
+      '<p class="hint" style="margin:0">For a webhook: your app checks the <code>X-Actauth-Signature</code> header (HMAC-SHA256 of the body with the signing secret). Each payload carries a <code>decideUrl</code> it can simply forward to a person, or it can decide itself by sending <code>{"decision":"approve"}</code> or <code>{"decision":"deny"}</code> to <code>resolveUrl</code>.</p>' +
       '</form>';
   }
 
@@ -1034,14 +1044,35 @@ ${consoleShellScript}
       }).join('') + '</tbody></table></div>';
   }
 
-  // Shown at the top of the tab, and only when something is waiting.
-  function renderPendingHtml(pending) {
-    if (!pending.length) return '';
-    return '<section><h3>Waiting for a decision (' + pending.length + ')</h3>' + renderPendingTable(pending) + '</section>';
+  // Tools that can stop for approval: a rule that asks, or "ask" as the
+  // decision when no rule matches.
+  function askingTools() {
+    var perms = currentCfg && currentCfg.permissions;
+    if (!perms) return [];
+    var tools = [];
+    perms.rules.forEach(function (r) { if (r.decision === 'ask' && tools.indexOf(r.tool) === -1) tools.push(r.tool); });
+    if (perms.defaultDecision === 'ask') tools.push('any tool without a rule');
+    return tools;
+  }
+
+  // The top of the tab: a nudge when approvals over HTTP would reach
+  // nobody, and whatever is waiting right now.
+  function renderPendingHtml(pending, n) {
+    var html = '';
+    var tools = askingTools();
+    if (tools.length && n && n.source === 'none') {
+      html += '<div class="approvals-nudge"><strong>Approval requests aren&#39;t sent anywhere yet.</strong> ' +
+        escapeHtml(tools.slice(0, 3).join(', ')) + (tools.length > 3 ? ' and more' : '') + ' can stop for approval, but when an app calls this agent over HTTP nobody is notified. ' +
+        '<a href="#approvalsSetup" class="approvals-nudge-link">Choose where they go</a></div>';
+    }
+    if (pending.length) html += '<section><h3>Waiting for a decision (' + pending.length + ')</h3>' + renderPendingTable(pending) + '</section>';
+    return html;
   }
 
   function renderApprovalsHtml(n) {
-    return '<section><h3>Approvals when nobody is in Chat</h3><p class="muted" style="margin:0 0 12px">' + renderNotifierStatus(n) + '</p>' +
+    return '<section id="approvalsSetup"><h3>Where approval requests and questions are sent</h3>' +
+      '<p class="muted" style="margin:0 0 8px">When an app calls this agent over HTTP and a tool call needs approval, or the agent asks a question, it&#39;s sent here. In Chat it shows up in the conversation instead.</p>' +
+      '<p class="muted" style="margin:0 0 12px">Currently: ' + renderNotifierStatus(n) + '</p>' +
         (n.error ? '<p class="error">' + escapeHtml(n.error) + '</p>' : '') +
         (n.source === 'code' ? '' : renderNotifierForm(n)) + '</section>' +
       '<section><h3>Recent deliveries</h3>' + renderDeliveries(n.deliveries || []) + '</section>';
@@ -1050,6 +1081,24 @@ ${consoleShellScript}
   function wirePendingHandlers(name) {
     var content = detail.querySelector('#pendingContent');
     if (!content) return;
+    var nudgeLink = content.querySelector('.approvals-nudge-link');
+    if (nudgeLink) {
+      nudgeLink.addEventListener('click', function (ev) {
+        ev.preventDefault();
+        var target = detail.querySelector('#approvalsSetup');
+        if (target) target.scrollIntoView({ behavior: 'smooth', block: 'start' });
+      });
+    }
+    var copyBtns = content.querySelectorAll('.pending-copy');
+    for (var c = 0; c < copyBtns.length; c++) {
+      copyBtns[c].addEventListener('click', function (ev) {
+        var btn = ev.currentTarget;
+        var link = location.origin + btn.dataset.path;
+        var done = function () { btn.textContent = 'Copied'; setTimeout(function () { btn.textContent = 'Copy link'; }, 1500); };
+        if (navigator.clipboard) navigator.clipboard.writeText(link).then(done, function () { window.prompt('Copy this link', link); });
+        else window.prompt('Copy this link', link);
+      });
+    }
     var decideBtns = content.querySelectorAll('.pending-decide');
     for (var i = 0; i < decideBtns.length; i++) {
       decideBtns[i].addEventListener('click', function (ev) {
@@ -1097,7 +1146,7 @@ ${consoleShellScript}
       ev.preventDefault();
       var data = new FormData(form);
       var channel = data.get('channel');
-      var body = { channel: channel, events: data.getAll('events'), url: data.get('url'), channelId: data.get('channelId'), appId: data.get('appId'), chatId: data.get('chatId') };
+      var body = { channel: channel, events: data.getAll('events'), url: data.get('url'), channelId: data.get('channelId'), appId: data.get('appId'), chatId: data.get('chatId'), publicUrl: data.get('publicUrl') };
       var secret = data.get('secret_' + channel);
       if (secret) body.secret = secret;
       result.textContent = 'Saving…';
@@ -1137,7 +1186,7 @@ ${consoleShellScript}
       wireApprovalsHandlers(name);
       var pendingEl = detail.querySelector('#pendingContent');
       if (pendingEl) {
-        pendingEl.innerHTML = renderPendingHtml((results[1].ok && results[1].body.pending) || []);
+        pendingEl.innerHTML = renderPendingHtml((results[1].ok && results[1].body.pending) || [], results[0].body);
         wirePendingHandlers(name);
       }
       if (message) { var r = content.querySelector('#notifierResult'); if (r) r.textContent = message; }

package/dist/web/decide-page.d.ts

@@ -0,0 +1,16 @@
+export interface DecidePageItem {
+    kind: 'approval' | 'question';
+    agent: string;
+    tool: string;
+    args: Record<string, unknown>;
+    reason: string;
+    sessionId: string;
+    tenant: string;
+    createdAt?: string;
+    expiresAt: number;
+}
+/** A link that's malformed, tampered with, or past its expiry. */
+export declare function renderDecideInvalidPage(): string;
+/** A valid link whose decision has already been made. */
+export declare function renderDecideGonePage(): string;
+export declare function renderDecidePage(item: DecidePageItem): string;

package/dist/web/decide-page.js

@@ -0,0 +1,138 @@
+// The page a decision link opens (GET /decide/<token>, see
+// core/approval-links.ts): what's waiting — the tool and its arguments,
+// or the question — and buttons to approve, deny or answer. Anyone with
+// the link can decide; the signed token is the only credential, so this
+// page shows nothing beyond the one decision it names.
+//
+// Rendered on the server; the small script only posts the choice back to
+// the same URL (POST /decide/<token>) and shows the outcome. Written
+// without backticks or backslashes inside the script, same convention as
+// the other embedded pages.
+import { devUiCss } from './dev-ui-styles.js';
+function esc(s) {
+    return String(s == null ? '' : s).replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[c]);
+}
+const PAGE_CSS = `
+  body { display: grid; place-items: start center; padding: 48px 16px; background: var(--surface); }
+  main { width: 100%; max-width: 560px; background: var(--bg); border: 1px solid var(--line); border-radius: 12px; padding: 24px; display: grid; gap: 16px; }
+  .brand { display: flex; align-items: center; gap: 8px; font-weight: 600; color: var(--ink-muted); font-size: 13px; }
+  .mark { width: 18px; height: 18px; border-radius: 5px; background: var(--accent); }
+  h1 { font-size: 20px; margin: 0; }
+  dl { display: grid; grid-template-columns: max-content minmax(0, 1fr); gap: 6px 16px; margin: 0; font-size: 13px; }
+  dt { color: var(--ink-faint); }
+  dd { margin: 0; overflow-wrap: anywhere; }
+  pre, textarea { font-family: var(--font-mono); font-size: 12.5px; background: var(--code-bg); border-radius: 8px; padding: 12px; margin: 0; white-space: pre-wrap; overflow-wrap: anywhere; }
+  textarea { width: 100%; min-height: 120px; border: 1px solid var(--line); }
+  .actions { display: flex; gap: 8px; flex-wrap: wrap; }
+  .actions button { padding: 8px 16px; }
+  .deny { color: var(--bad); }
+  .note { font-size: 12px; color: var(--ink-faint); margin: 0; }
+  .result { padding: 12px 14px; border-radius: 8px; background: var(--good-soft); color: var(--good); }
+  .result.bad { background: var(--bad-soft); color: var(--bad); }
+  .reply { white-space: pre-wrap; background: var(--surface); border-radius: 8px; padding: 12px 14px; }
+  details summary { cursor: pointer; font-size: 13px; color: var(--ink-muted); }
+`;
+function shell(title, body, script = '') {
+    return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta name="robots" content="noindex">
+<title>${esc(title)}</title>
+<style>${devUiCss}${PAGE_CSS}</style>
+</head>
+<body>
+<main>
+<div class="brand"><span class="mark" aria-hidden="true"></span>LoopEngine</div>
+${body}
+</main>
+${script}
+</body>
+</html>`;
+}
+/** A link that's malformed, tampered with, or past its expiry. */
+export function renderDecideInvalidPage() {
+    return shell('Link not valid', '<h1>This link isn&#39;t valid</h1><p class="muted">It may have expired or been copied incompletely. Ask for a new one, or decide from the agent&#39;s Permissions tab.</p>');
+}
+/** A valid link whose decision has already been made. */
+export function renderDecideGonePage() {
+    return shell('Already decided', '<h1>Already decided</h1><p class="muted">Someone has already made this decision, so there&#39;s nothing left to do here.</p>');
+}
+const SCRIPT = `<script>
+(function () {
+  var main = document.querySelector('main');
+  var result = document.getElementById('result');
+  function send(body, button) {
+    var buttons = main.querySelectorAll('button');
+    for (var i = 0; i < buttons.length; i++) buttons[i].disabled = true;
+    result.hidden = false;
+    result.className = 'result';
+    result.textContent = 'Sending' + String.fromCharCode(8230);
+    fetch(location.pathname, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body) })
+      .then(function (r) { return r.json().then(function (j) { return { ok: r.ok, body: j }; }); })
+      .then(function (r) {
+        if (!r.ok) throw new Error(r.body.error || 'request failed');
+        var form = document.getElementById('decision');
+        if (form) form.hidden = true;
+        result.textContent = r.body.message || (body.decision === 'deny' ? 'Denied.' : body.answer !== undefined ? 'Answer sent.' : 'Approved.');
+        if (r.body.text) {
+          var reply = document.createElement('div');
+          reply.className = 'reply';
+          reply.textContent = r.body.text;
+          result.after(reply);
+        }
+      })
+      .catch(function (err) {
+        result.className = 'result bad';
+        result.textContent = err.message;
+        for (var i = 0; i < buttons.length; i++) buttons[i].disabled = false;
+      });
+  }
+  main.addEventListener('click', function (ev) {
+    var btn = ev.target.closest('button[data-send]');
+    if (!btn) return;
+    var payload = JSON.parse(btn.getAttribute('data-send'));
+    if (payload.editedFrom) {
+      try { payload = { decision: 'approve', editedArgs: JSON.parse(document.getElementById(payload.editedFrom).value) }; }
+      catch (e) { result.hidden = false; result.className = 'result bad'; result.textContent = 'The arguments aren' + String.fromCharCode(39) + 't valid JSON.'; return; }
+    }
+    if (payload.answerFrom) {
+      var text = document.getElementById(payload.answerFrom).value.trim();
+      if (!text) return;
+      payload = { answer: text };
+    }
+    send(payload, btn);
+  });
+})();
+</script>`;
+export function renderDecidePage(item) {
+    const expires = new Date(item.expiresAt).toUTCString();
+    const facts = `<dl><dt>Agent</dt><dd>${esc(item.agent)}</dd>` +
+        `<dt>Conversation</dt><dd><code>${esc(item.sessionId)}</code>${item.tenant && item.tenant !== 'default' ? ` (tenant ${esc(item.tenant)})` : ''}</dd>` +
+        (item.createdAt ? `<dt>Asked</dt><dd>${esc(new Date(item.createdAt).toUTCString())}</dd>` : '') +
+        `</dl>`;
+    const note = `<p class="note">Anyone with this link can make this decision. It works once and expires ${esc(expires)}.</p>`;
+    const result = '<div id="result" class="result" hidden role="status"></div>';
+    if (item.kind === 'question') {
+        const question = typeof item.args.question === 'string' ? item.args.question : item.reason;
+        const options = Array.isArray(item.args.options) ? item.args.options.map(String) : [];
+        const optionButtons = options.map((o) => `<button type="button" data-send="${esc(JSON.stringify({ answer: o }))}">${esc(o)}</button>`).join('');
+        return shell(`Question from ${item.agent}`, `<h1>${esc(item.agent)} has a question</h1>${facts}<pre>${esc(question)}</pre>` +
+            `<div id="decision" style="display:grid;gap:10px">` +
+            (optionButtons ? `<div class="actions">${optionButtons}</div>` : '') +
+            `<label style="display:grid;gap:6px;font-size:13px">${options.length ? 'Or answer in your own words' : 'Your answer'}<textarea id="answerText" style="min-height:80px;font-family:var(--font-sans)"></textarea></label>` +
+            `<div class="actions"><button type="button" class="primary" data-send="${esc(JSON.stringify({ answerFrom: 'answerText' }))}">Send answer</button></div></div>` +
+            result + note, SCRIPT);
+    }
+    return shell(`Approve ${item.tool}?`, `<h1>Approve <code>${esc(item.tool)}</code>?</h1>${facts}` +
+        `<pre>${esc(JSON.stringify(item.args, null, 2))}</pre>` +
+        `<p class="muted" style="margin:0">${esc(item.reason)}</p>` +
+        `<div id="decision" style="display:grid;gap:12px">` +
+        `<div class="actions"><button type="button" class="primary" data-send="${esc(JSON.stringify({ decision: 'approve' }))}">Approve</button>` +
+        `<button type="button" class="deny" data-send="${esc(JSON.stringify({ decision: 'deny' }))}">Deny</button></div>` +
+        `<details><summary>Change the arguments first</summary><div style="display:grid;gap:8px;margin-top:8px">` +
+        `<textarea id="editedArgs">${esc(JSON.stringify(item.args, null, 2))}</textarea>` +
+        `<div class="actions"><button type="button" data-send="${esc(JSON.stringify({ editedFrom: 'editedArgs' }))}">Approve with these arguments</button></div></div></details>` +
+        `</div>` + result + note, SCRIPT);
+}

package/dist/web/notifier-admin.d.ts

@@ -39,6 +39,7 @@ export declare function testAgentNotifier(config: AgentConfig, defaultWebhook?:
 /** Every decision still waiting for this agent, oldest first, each with
  * where to send the answer. */
 export declare function listAgentPending(store: CheckpointStore, agentName: string): Promise<({
+    decidePath: string;
     answerPath: string;
     pendingId: string;
     kind: "approval" | "question";
@@ -49,6 +50,7 @@ export declare function listAgentPending(store: CheckpointStore, agentName: stri
     tenant: string;
     createdAt: string | null;
 } | {
+    decidePath: string;
     resolvePath: string;
     pendingId: string;
     kind: "approval" | "question";

package/dist/web/notifier-admin.js

@@ -1,4 +1,5 @@
 import { agentDirFor, createAgentEnv } from '../core/agent-env.js';
+import { decidePath } from '../core/approval-links.js';
 import { describeNotifier } from '../core/http-notifier.js';
 import { sendTestSlackMessage } from '../core/http-notify-triggers/slack.js';
 import { sendTestWebhook } from '../core/http-notify-triggers/webhook.js';
@@ -81,6 +82,8 @@ export async function listAgentPending(store, agentName) {
                 tenant: checkpoint.tenant,
                 createdAt: checkpoint.createdAt ?? null,
                 ...(kind === 'question' ? { answerPath: `/pending-questions/${pendingId}/answer` } : { resolvePath: `/pending-approvals/${pendingId}/resolve` }),
+                // A signed link anyone can open to decide (core/approval-links.ts).
+                decidePath: decidePath(pendingId, kind),
             });
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loopengine",
-  "version": "0.1.67",
+  "version": "0.1.68",
   "type": "module",
   "description": "Runtime for tool-using AI agents with a transparent ReAct loop.",
   "license": "MIT",
@@ -48,6 +48,8 @@
     "dist/core/notifier-file.d.ts",
     "dist/core/notifier-deliveries.js",
     "dist/core/notifier-deliveries.d.ts",
+    "dist/core/approval-links.js",
+    "dist/core/approval-links.d.ts",
     "dist/core/session-store.js",
     "dist/core/session-store.d.ts",
     "dist/core/vector-index.js",