@co0ontty/wand 4.102.0 → 4.103.0

package/dist/dingtalk-stream.d.ts

@@ -0,0 +1,24 @@
+import { boundedFetch } from "./dingtalk-dws.js";
+/** Native robot Stream ingress. DWS custom commands omit sender/group/message identity, so never use that escape hatch. */
+export declare class DingTalkRobotStream {
+    private readonly credentials;
+    private readonly receive;
+    private readonly status;
+    private readonly request;
+    private socket?;
+    private retry?;
+    private heartbeat?;
+    private closed;
+    private epoch;
+    private failures;
+    private active;
+    constructor(credentials: {
+        clientId: string;
+        clientSecret: string;
+    }, receive: (payload: Record<string, any>) => Promise<void>, status: (connected: boolean) => void, request?: typeof boundedFetch);
+    get connected(): boolean;
+    start(): void;
+    private connect;
+    private reconnect;
+    dispose(): void;
+}

package/dist/dingtalk-stream.js

@@ -0,0 +1,115 @@
+import WebSocket from "ws";
+import { boundedFetch, DingTalkError, object, string } from "./dingtalk-dws.js";
+/** Native robot Stream ingress. DWS custom commands omit sender/group/message identity, so never use that escape hatch. */
+export class DingTalkRobotStream {
+    credentials;
+    receive;
+    status;
+    request;
+    socket;
+    retry;
+    heartbeat;
+    closed = false;
+    epoch = 0;
+    failures = 0;
+    active = 0;
+    constructor(credentials, receive, status, request = boundedFetch) {
+        this.credentials = credentials;
+        this.receive = receive;
+        this.status = status;
+        this.request = request;
+    }
+    get connected() { return !this.closed && this.socket?.readyState === WebSocket.OPEN; }
+    start() { void this.connect(); }
+    async connect() {
+        const epoch = ++this.epoch;
+        try {
+            const response = object(JSON.parse((await this.request("https://api.dingtalk.com/v1.0/gateway/connections/open", {
+                method: "POST", redirect: "error", headers: { "Content-Type": "application/json", Accept: "application/json" },
+                body: JSON.stringify({ ...this.credentials, ua: "Wand", subscriptions: [{ type: "CALLBACK", topic: "/v1.0/im/bot/messages/get" }] }),
+            })).toString()));
+            if (this.closed || epoch !== this.epoch)
+                return;
+            const url = new URL(string(response.endpoint));
+            // Credential-bearing tickets may only be sent to DingTalk's TLS stream hosts.
+            if (url.protocol !== "wss:" || !(url.hostname === "dingtalk.com" || url.hostname.endsWith(".dingtalk.com")) || url.username || url.password || url.port || !string(response.ticket))
+                throw new Error("invalid stream endpoint");
+            url.searchParams.set("ticket", response.ticket);
+            const socket = new WebSocket(url, { maxPayload: 512 * 1024, handshakeTimeout: 15_000, followRedirects: false });
+            this.socket = socket;
+            socket.on("error", () => { }); // WebSocket errors can contain a secret-bearing URL; never log them.
+            socket.once("open", () => {
+                if (this.closed || epoch !== this.epoch) {
+                    socket.close();
+                    return;
+                }
+                this.failures = 0;
+                this.status(true);
+                let alive = true;
+                socket.on("pong", () => { alive = true; });
+                this.heartbeat = setInterval(() => { if (!alive) {
+                    socket.terminate();
+                    return;
+                } alive = false; if (socket.readyState === WebSocket.OPEN)
+                    socket.ping(); }, 30_000);
+                this.heartbeat.unref?.();
+            });
+            socket.on("message", raw => {
+                if (this.closed || epoch !== this.epoch || this.active >= 32)
+                    return;
+                let frame;
+                try {
+                    frame = object(JSON.parse(raw.toString()));
+                }
+                catch {
+                    return;
+                }
+                if (frame.type === "SYSTEM") {
+                    if (["ping", "disconnect"].includes(string(frame.headers?.topic))) {
+                        socket.send(JSON.stringify({ code: 200, headers: frame.headers, message: "OK", data: frame.data }));
+                        if (frame.headers.topic === "disconnect")
+                            socket.close();
+                    }
+                    return;
+                }
+                if (frame.type !== "CALLBACK" || frame.headers?.topic !== "/v1.0/im/bot/messages/get" || !string(frame.headers?.messageId))
+                    return;
+                let data;
+                try {
+                    data = object(JSON.parse(string(frame.data)));
+                }
+                catch {
+                    return;
+                }
+                this.active++;
+                // Acknowledge only after durable admission, not after model completion. On failure leave unacknowledged for redelivery.
+                void this.receive(data).then(() => {
+                    if (!this.closed && socket.readyState === WebSocket.OPEN)
+                        socket.send(JSON.stringify({ code: 200,
+                            headers: { contentType: "application/json", messageId: frame.headers.messageId }, message: "OK", data: JSON.stringify({ response: {} }) }));
+                }).catch(() => { }).finally(() => { this.active--; });
+            });
+            socket.once("close", () => { if (this.heartbeat)
+                clearInterval(this.heartbeat); this.heartbeat = undefined; if (!this.closed && epoch === this.epoch) {
+                this.status(false);
+                this.reconnect(epoch);
+            } });
+        }
+        catch (error) {
+            if (this.closed || epoch !== this.epoch)
+                return;
+            this.status(false);
+            if (!(error instanceof DingTalkError && [401, 403].includes(error.httpStatus ?? 0)))
+                this.reconnect(epoch);
+        }
+    }
+    reconnect(epoch) {
+        if (this.closed || epoch !== this.epoch || this.retry || this.failures >= 6)
+            return;
+        this.retry = setTimeout(() => { this.retry = undefined; void this.connect(); }, Math.min(60_000, 1000 * 2 ** Math.min(6, this.failures++)));
+        this.retry.unref?.();
+    }
+    dispose() { this.closed = true; this.epoch++; if (this.retry)
+        clearTimeout(this.retry); if (this.heartbeat)
+        clearInterval(this.heartbeat); this.socket?.close(); }
+}

package/dist/dingtalk-types.d.ts

@@ -0,0 +1,138 @@
+import type { WandTaskAgent } from "./task-types.js";
+export type DingTalkBindingState = "creating" | "configuring" | "joining" | "verifying" | "ready" | "paused" | "restricted" | "failed" | "unknown";
+export interface DingTalkAccount {
+    id: string;
+    corpId: string;
+    userId: string;
+    name: string;
+    corpName: string;
+}
+export interface DingTalkGroup {
+    id: string;
+    accountId: string;
+    corpId: string;
+    externalId: string;
+    name: string;
+    conversationId: string;
+    syncState: "connecting" | "live" | "at_only" | "disconnected" | "paused";
+    syncError?: string;
+    historyComplete: boolean;
+    updatedAt: string;
+}
+export interface DingTalkRobot {
+    id: string;
+    corpId: string;
+    employeeId: string;
+    accountId: string;
+    name: string;
+    state: DingTalkBindingState;
+    taskId?: string;
+    appId?: string;
+    robotCode?: string;
+    clientId?: string;
+    versionId?: string;
+    error?: string;
+    updatedAt: string;
+}
+export interface DingTalkBinding {
+    id: string;
+    groupId: string;
+    employeeId: string;
+    robotId: string;
+    state: DingTalkBindingState;
+    allowedUsers: string[];
+    ownerUserId?: string;
+    generation?: string;
+    fixedAgent?: WandTaskAgent;
+    error?: string;
+    removedAt?: string;
+    verifiedAt?: string;
+    updatedAt: string;
+}
+export interface DingTalkExternalConversation {
+    provider: "dingtalk";
+    groupId: string;
+    corpId: string;
+    externalId: string;
+    syncState: DingTalkGroup["syncState"];
+    syncError?: string;
+    historyComplete: boolean;
+    bindings: Array<Pick<DingTalkBinding, "id" | "employeeId" | "state" | "fixedAgent" | "error">>;
+}
+export interface DingTalkSelection {
+    accountId: string;
+    groupIds: string[];
+    employeeIds: string[];
+}
+export interface DingTalkPlan extends DingTalkSelection {
+    id: string;
+    expiresAt: string;
+    groups: Array<{
+        id: string;
+        name: string;
+    }>;
+    employees: Array<{
+        id: string;
+        name: string;
+        robotName: string;
+        appName: string;
+        candidateIndex?: number;
+        agent?: WandTaskAgent;
+    }>;
+    pairs: Array<{
+        groupId: string;
+        employeeId: string;
+        existing: boolean;
+    }>;
+    newRobots: number;
+    warning: string;
+}
+export interface DingTalkJob {
+    id: string;
+    planId: string;
+    state: "running" | "done" | "partial" | "unknown";
+    bindingIds: string[];
+    bindingGenerations?: Record<string, string | undefined>;
+    updatedAt: string;
+}
+export interface DingTalkDiscoveryGroup {
+    id: string;
+    name: string;
+    memberCount?: number;
+}
+export interface DingTalkMessage {
+    id: string;
+    groupId: string;
+    senderId: string;
+    senderName: string;
+    text: string;
+    createdAt: string;
+    senderIsBot: boolean;
+    mentionedRobotCodes: string[];
+    recalled?: boolean;
+}
+export interface DingTalkRun {
+    id: string;
+    groupId: string;
+    bindingId: string;
+    bindingGeneration?: string;
+    incomingId: string;
+    sessionId?: string;
+    state: "accepted" | "running" | "completed" | "failed" | "unknown" | "delivered";
+    text?: string;
+    error?: string;
+    delivery?: "pending" | "sending" | "sent" | "unknown" | "none";
+    updatedAt: string;
+}
+export interface DingTalkStatus {
+    installed: boolean;
+    version?: string;
+    accounts: DingTalkAccount[];
+    groups: DingTalkGroup[];
+    bindings: DingTalkBinding[];
+    robots: DingTalkRobot[];
+    jobs: DingTalkJob[];
+    /** Operational diagnostics, not the transport-level error envelope. Missing DWS is a normal state. */
+    diagnostic?: string;
+}
+export type DingTalkRecordKind = "group" | "binding" | "robot" | "plan" | "job" | "run" | "request" | "event";

package/dist/dingtalk-types.js

@@ -0,0 +1 @@
+export {};

package/dist/employee-knowledge.js

@@ -56,6 +56,14 @@ export function startEmployeeKnowledgeRunner(storage, runner, context, observer,
     delete env.WAND_KNOWLEDGE_DB;
     delete env.WAND_KNOWLEDGE_TOKEN;
     delete env.WAND_WEB_LOGIN_PROOF;
+    // External group requests retain employee identity, but never inherit private knowledge,
+    // explicit-memory writes or owner Web-login capabilities. This is a trusted session tag,
+    // not a phrase read from the remote message.
+    if (context.session.automationId?.startsWith("dingtalk:")) {
+        for (const key of ["DWS_CLIENT_ID", "DWS_CLIENT_SECRET", "DWS_ACCESS_TOKEN", "DWS_TOKEN", "DWS_CONFIG_DIR"])
+            delete env[key];
+        return runner.start({ ...context, env }, observer);
+    }
     if (!employeeId)
         return runner.start({ ...context, env }, observer);
     if (!storage.getSiliconEmployee(employeeId)) {

package/dist/live-activity-service.d.ts

@@ -0,0 +1,26 @@
+import type { ApnsConfiguration, ApnsTransport } from "./apns-client.js";
+import type { WandStorage } from "./storage.js";
+import type { ProcessEvent, SessionSnapshot } from "./types.js";
+/** Updates already-created ActivityKit activities only. Never starts an activity or changes execution facts. */
+export declare class LiveActivityService {
+    private readonly storage;
+    readonly configuration: ApnsConfiguration | null;
+    private readonly transport;
+    private readonly credentialDigest;
+    private readonly getSessions;
+    private readonly warn;
+    private readonly now;
+    private stopped;
+    private timer;
+    private running;
+    private lastSweep;
+    private nextWarningAt;
+    constructor(storage: WandStorage, configuration: ApnsConfiguration | null, transport: ApnsTransport | null, credentialDigest: () => string, getSessions: () => readonly SessionSnapshot[] | null, warn?: (message: string) => void, now?: () => number);
+    get available(): boolean;
+    private report;
+    start(): void;
+    ingest(event: ProcessEvent): void;
+    flush(): Promise<void>;
+    private drain;
+    dispose(): void;
+}

package/dist/live-activity-service.js

@@ -0,0 +1,158 @@
+import { LIVE_ACTIVITY_HEARTBEAT_MS, liveActivityPayload, projectLiveActivity } from "./live-activity-state.js";
+function newAttentionState(previousSignature, projection) {
+    if (!projection.urgent)
+        return false;
+    if (projection.event === "end")
+        return true;
+    const attention = new Set(["permission", "waiting-input", "failed", "stopped", "done"]);
+    let previous = [];
+    try {
+        const parsed = JSON.parse(previousSignature);
+        if (Array.isArray(parsed) && Array.isArray(parsed[1]))
+            previous = parsed[1];
+    }
+    catch { /* first update */ }
+    const key = (entry) => JSON.stringify([entry.id, entry.stateRaw, entry.finishedAt]);
+    const known = new Set(previous.filter(entry => attention.has(entry.stateRaw)).map(key));
+    return projection.entries.some(entry => attention.has(entry.stateRaw) && !known.has(key(entry)));
+}
+/** Updates already-created ActivityKit activities only. Never starts an activity or changes execution facts. */
+export class LiveActivityService {
+    storage;
+    configuration;
+    transport;
+    credentialDigest;
+    getSessions;
+    warn;
+    now;
+    stopped = false;
+    timer = null;
+    running = null;
+    lastSweep = 0;
+    nextWarningAt = 0;
+    constructor(storage, configuration, transport, credentialDigest, getSessions, warn = () => { }, now = Date.now) {
+        this.storage = storage;
+        this.configuration = configuration;
+        this.transport = transport;
+        this.credentialDigest = credentialDigest;
+        this.getSessions = getSessions;
+        this.warn = warn;
+        this.now = now;
+        storage.onClose(() => this.dispose());
+    }
+    get available() { return !!this.configuration && !!this.transport && !this.stopped; }
+    report(message) {
+        if (this.now() < this.nextWarningAt)
+            return;
+        this.nextWarningAt = this.now() + 60_000;
+        this.warn(message);
+    }
+    start() {
+        if (!this.available || this.timer)
+            return;
+        this.storage.liveActivities.wake(this.now());
+        this.timer = setInterval(() => { void this.flush(); }, 2000);
+        this.timer.unref();
+        void this.flush();
+    }
+    ingest(event) {
+        if (!this.available || !["started", "status", "task", "ended"].includes(event.type))
+            return;
+        try {
+            this.storage.liveActivities.dirty(this.now());
+        }
+        catch {
+            this.report("灵动岛状态暂不可入队；不影响任务执行。");
+        }
+    }
+    flush() {
+        if (!this.available)
+            return Promise.resolve();
+        if (!this.running) {
+            this.running = this.drain().catch(() => {
+                if (!this.stopped)
+                    this.report("灵动岛远程更新暂不可用，将稍后重试。");
+            }).finally(() => { this.running = null; });
+        }
+        return this.running;
+    }
+    async drain() {
+        if (this.now() - this.lastSweep >= 60_000) {
+            this.storage.liveActivities.sweep(this.now());
+            this.lastSweep = this.now();
+        }
+        for (let i = 0; i < 12 && !this.stopped; i++) {
+            let record = this.storage.liveActivities.due(this.now());
+            if (!record)
+                return;
+            if (record.expires_at <= this.now() || record.credential_digest !== this.credentialDigest()
+                || record.topic !== this.configuration.topic || record.environment !== this.configuration.environment) {
+                this.storage.liveActivities.disable(record.id, "ExpiredOrCredentialChanged", record.generation);
+                continue;
+            }
+            const snapshots = this.getSessions();
+            // A failed/unfinished session recovery is not evidence that every running session has completed or disappeared.
+            if (!snapshots) {
+                this.storage.liveActivities.defer(record.id, record.generation, this.now() + 30_000);
+                continue;
+            }
+            const previous = JSON.parse(record.content_json);
+            const projection = projectLiveActivity(snapshots, previous, record.server_id, this.now());
+            // Foreground optimistic Activity.request may beat the server's input-acceptance event.
+            if (!projection.entries.length && !record.signature && !previous.length && this.now() - record.created_at < 30_000) {
+                this.storage.liveActivities.defer(record.id, record.generation, Math.min(record.created_at + 30_000, this.now() + 2000));
+                continue;
+            }
+            if (!record.pending_payload || record.pending_signature !== projection.signature) {
+                if (record.signature === projection.signature && this.now() - record.last_sent_at < LIVE_ACTIVITY_HEARTBEAT_MS) {
+                    this.storage.liveActivities.defer(record.id, record.generation, Math.min(projection.nextAt, record.last_sent_at + LIVE_ACTIVITY_HEARTBEAT_MS));
+                    continue;
+                }
+                const timestamp = Math.floor(this.now() / 1000);
+                // ActivityKit orders by seconds. Never send equal/older timestamps or invent a future progress timestamp.
+                if (timestamp <= record.last_timestamp) {
+                    this.storage.liveActivities.defer(record.id, record.generation, (record.last_timestamp + 1) * 1000);
+                    continue;
+                }
+                const prepared = this.storage.liveActivities.prepare(record, {
+                    payload: liveActivityPayload(projection.content, projection.event, timestamp),
+                    signature: projection.signature, entries: projection.entries, event: projection.event,
+                    priority: newAttentionState(record.signature, projection) ? 10 : 5, timestamp, nextAt: projection.nextAt,
+                }, this.now());
+                if (!prepared)
+                    continue;
+                record = prepared;
+            }
+            let result;
+            try {
+                result = await this.transport.send({ id: record.pending_id, token: record.token,
+                    payload: record.pending_payload, collapseId: record.id,
+                    expiresAt: Math.min(record.expires_at, (record.last_timestamp + 180) * 1000),
+                    pushType: "liveactivity", priority: record.pending_priority ?? 5 });
+            }
+            catch {
+                result = { outcome: "retry", reason: "TransportFailure" };
+            }
+            if (this.stopped)
+                return;
+            if (result.outcome === "invalid-device") {
+                this.storage.liveActivities.disable(record.id, result.reason, record.generation);
+            }
+            else if (result.outcome === "retry" && record.attempts < 4) {
+                this.storage.liveActivities.retry(record, result.reason, this.now());
+            }
+            else {
+                this.storage.liveActivities.finish(record, result.outcome === "accepted" ? "accepted" : result.outcome === "rejected" ? "rejected" : "failed", result.reason, this.now());
+                if (result.outcome !== "accepted")
+                    this.report(`APNs 未接受灵动岛更新（${result.reason}）；不影响普通消息推送与任务执行。`);
+            }
+        }
+    }
+    dispose() {
+        this.stopped = true;
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = null;
+        this.transport?.close();
+    }
+}

package/dist/live-activity-state.d.ts

@@ -0,0 +1,37 @@
+import type { SessionSnapshot } from "./types.js";
+/** Exactly the Codable fields in iOS SessionActivityAttributes.ContentState; dates use Apple's reference epoch. */
+export interface LiveActivityEntry {
+    id: string;
+    serverID: string;
+    title: string;
+    providerRaw: string;
+    stateRaw: "responding" | "background" | "permission" | "waiting-input" | "failed" | "stopped" | "done";
+    taskTitle?: string;
+    queuedCount: number;
+    startedAt?: number;
+    finishedAt?: number;
+    engineRaw?: string;
+    pendingPrompt?: string;
+}
+export interface LiveActivityCachedEntry extends LiveActivityEntry {
+    finishedUntil?: number;
+}
+export interface LiveActivityContent {
+    sessions: LiveActivityEntry[];
+    updatedAt: number;
+}
+export declare const APPLE_REFERENCE_UNIX_SECONDS = 978307200;
+export declare const LIVE_ACTIVITY_HEARTBEAT_MS = 60000;
+export declare const LIVE_ACTIVITY_STALE_SECONDS = 180;
+export declare function liveActivityText(value: string, maxCharacters: number, maxBytes: number): string;
+export declare function liveActivityWireEntry(cached: LiveActivityCachedEntry): LiveActivityEntry;
+/** A pure snapshot projection: no execution changes, fabricated progress, historical-completion replay or timer extension. */
+export declare function projectLiveActivity(sessions: readonly SessionSnapshot[], previous: readonly LiveActivityCachedEntry[], serverID: string, now: number): {
+    entries: LiveActivityCachedEntry[];
+    content: LiveActivityContent;
+    event: "update" | "end";
+    signature: string;
+    urgent: boolean;
+    nextAt: number;
+};
+export declare function liveActivityPayload(content: LiveActivityContent, event: "update" | "end", timestamp: number): string;

package/dist/live-activity-state.js

@@ -0,0 +1,108 @@
+export const APPLE_REFERENCE_UNIX_SECONDS = 978_307_200;
+export const LIVE_ACTIVITY_HEARTBEAT_MS = 60_000;
+export const LIVE_ACTIVITY_STALE_SECONDS = 180;
+const priorities = {
+    permission: 0, "waiting-input": 1, failed: 2, responding: 3, background: 4, stopped: 5, done: 6,
+};
+const providers = new Set(["claude", "codex", "opencode", "grok", "qoder", "pi"]);
+const segmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+export function liveActivityText(value, maxCharacters, maxBytes) {
+    let text = "", bytes = 0, count = 0;
+    for (const { segment } of segmenter.segment(value.trim())) {
+        if (++count > maxCharacters || bytes + Buffer.byteLength(segment) > maxBytes)
+            break;
+        text += segment;
+        bytes += Buffer.byteLength(segment);
+    }
+    return text;
+}
+function appleDate(value) {
+    const ms = value ? Date.parse(value) : NaN;
+    return Number.isFinite(ms) ? ms / 1000 - APPLE_REFERENCE_UNIX_SECONDS : undefined;
+}
+function responding(session) {
+    if (session.sessionKind === "structured")
+        return session.structuredState?.inFlight === true;
+    if (session.status !== "running" || session.providerCliActive === false)
+        return false;
+    return providers.has(session.provider ?? "") ? session.ptyBusy === true : session.ptyCommandRunning === true;
+}
+function entry(session, serverID, stateRaw) {
+    const busy = stateRaw === "responding" || stateRaw === "background";
+    const title = liveActivityText(session.title || "会话", 24, 96);
+    return {
+        id: session.id, serverID, title,
+        providerRaw: liveActivityText(session.provider ?? "terminal", 40, 60), stateRaw,
+        taskTitle: session.currentTaskTitle ? liveActivityText(session.currentTaskTitle, 40, 120) : undefined,
+        queuedCount: Math.max(0, Math.min(9999, session.queuedMessages?.length ?? 0)),
+        startedAt: busy ? appleDate(session.structuredState?.turnStartedAt ?? session.ptyTurnStartedAt) : undefined,
+        engineRaw: session.structuredState?.engine,
+        // Do not put escalation arguments, targets, paths, transcript, command or cwd on Apple's servers.
+        pendingPrompt: stateRaw === "permission" ? "等待你的授权后继续" : stateRaw === "waiting-input" ? "等待你的回复后继续" : undefined,
+    };
+}
+export function liveActivityWireEntry(cached) {
+    const { finishedUntil: _finishedUntil, ...wire } = cached;
+    return wire;
+}
+/** A pure snapshot projection: no execution changes, fabricated progress, historical-completion replay or timer extension. */
+export function projectLiveActivity(sessions, previous, serverID, now) {
+    const oldById = new Map(previous.filter(item => item.serverID === serverID).map(item => [item.id, item]));
+    const entries = [];
+    for (const session of sessions) {
+        if (session.archived)
+            continue;
+        const old = oldById.get(session.id);
+        const pending = !!session.pendingEscalation || session.permissionBlocked === true;
+        if (pending) {
+            entries.push(entry(session, serverID, "permission"));
+            continue;
+        }
+        if (responding(session)) {
+            entries.push(entry(session, serverID, session.structuredState?.phase === "background" ? "background" : "responding"));
+            continue;
+        }
+        // A terminal snapshot only earns a grace period if this activity actually observed it working.
+        if (!old)
+            continue;
+        let state;
+        if (session.status === "failed" || (session.status === "exited" && session.exitCode !== 0))
+            state = "failed";
+        else if (session.status === "stopped")
+            state = "stopped";
+        else if (["responding", "background", "done"].includes(old.stateRaw))
+            state = "done";
+        if (!state)
+            continue;
+        const finishedUntil = old.stateRaw === state && old.finishedUntil !== undefined
+            ? old.finishedUntil : now + (state === "failed" ? 30_000 : 12_000);
+        if (finishedUntil <= now)
+            continue;
+        const finished = entry(session, serverID, state);
+        finished.finishedAt = (finishedUntil - (state === "failed" ? 30_000 : 12_000)) / 1000 - APPLE_REFERENCE_UNIX_SECONDS;
+        finished.queuedCount = 0;
+        delete finished.taskTitle;
+        delete finished.startedAt;
+        entries.push({ ...finished, finishedUntil });
+    }
+    entries.sort((a, b) => priorities[a.stateRaw] - priorities[b.stateRaw] || a.id.localeCompare(b.id));
+    entries.splice(8);
+    const updatedAt = now / 1000 - APPLE_REFERENCE_UNIX_SECONDS;
+    // Reserve ample room for APNs envelope/timestamp/stale-date. Never split a composed Unicode character.
+    while (entries.length > 1 && Buffer.byteLength(JSON.stringify({ sessions: entries.map(liveActivityWireEntry), updatedAt })) > 3300)
+        entries.pop();
+    const event = entries.length ? "update" : "end";
+    const wire = entries.length ? entries.map(liveActivityWireEntry) : previous.map(liveActivityWireEntry);
+    const content = { sessions: wire.slice(0, 8), updatedAt };
+    const signature = JSON.stringify([event, entries.map(liveActivityWireEntry)]);
+    const nextAt = Math.min(now + LIVE_ACTIVITY_HEARTBEAT_MS, ...entries.flatMap(item => item.finishedUntil === undefined ? [] : [item.finishedUntil]));
+    return { entries, content, event, signature,
+        urgent: event === "end" || entries.some(item => ["permission", "waiting-input", "failed", "done", "stopped"].includes(item.stateRaw)), nextAt };
+}
+export function liveActivityPayload(content, event, timestamp) {
+    const payload = JSON.stringify({ aps: { timestamp, event, "content-state": content,
+            ...(event === "end" ? { "dismissal-date": 0 } : { "stale-date": timestamp + LIVE_ACTIVITY_STALE_SECONDS }) } });
+    if (Buffer.byteLength(payload) > 4096)
+        throw new Error("Live Activity payload exceeds APNs budget");
+    return payload;
+}

package/dist/middleware/api-scope.js

@@ -35,6 +35,8 @@ export const API_ROUTE_RULES = [
     { prefix: "/api/settings", scope: "route-guarded" },
     { prefix: "/api/models", scope: "sessions" },
     { prefix: "/api/daemon-maintenance", scope: "route-guarded" },
+    // Mounted before the global guard: app-bearer registration, device-capability revocation only.
+    { prefix: "/api/push", scope: "route-guarded" },
     // ── 浏览器扩展密码库 ──
     { prefix: "/api/browser-extension", scope: "password-vault" },
     // ── 文件与目录 ──

package/dist/pi-cli-checkpoint.d.ts

@@ -0,0 +1,17 @@
+import type { StructuredRunnerTurnState } from "./structured-runner.js";
+/** Internal SQLite materialization, never a client DTO or a replay instruction. */
+export interface PiCliCheckpoint {
+    version: 1;
+    incarnationId: string;
+    requestId: string;
+    source: {
+        file: string;
+        dev: number;
+        ino: number;
+    };
+    /** Native-file byte position immediately after a fully parsed record. */
+    offset: number;
+    state: StructuredRunnerTurnState;
+    primaryError: string | null;
+}
+export declare function validPiCliCheckpoint(value: unknown): value is PiCliCheckpoint;

package/dist/pi-cli-checkpoint.js

@@ -0,0 +1,10 @@
+export function validPiCliCheckpoint(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const v = value;
+    return v.version === 1 && typeof v.incarnationId === "string" && typeof v.requestId === "string"
+        && Number.isSafeInteger(v.offset) && v.offset >= 0
+        && typeof v.source?.file === "string" && Number.isSafeInteger(v.source.dev) && Number.isSafeInteger(v.source.ino)
+        && Array.isArray(v.state?.blocks) && typeof v.state.result === "string"
+        && (v.primaryError === null || typeof v.primaryError === "string");
+}