@qilin-agent/schedule 3.1.7 → 3.1.8

package/lib/types/storage.d.ts

@@ -1,57 +1,159 @@
-/** Durable Host-wide Schedule tasks, independently of Session activation. */
 import { z } from 'zod';
 import { SessionId } from '@qilin-agent/session';
 import { MessageId } from '@qilin-agent/llm/brand';
-import type { ScheduleId } from './types.ts';
-/** Stored task binds one schedule to its original Session; absent status decodes as active. */
-export declare const scheduleTaskSchema: z.ZodObject<{
-    sessionId: z.ZodPipe<z.ZodString, z.ZodTransform<SessionId, string>>;
-    record: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("./types.ts").AfterScheduleRecord | import("./types.ts").AtScheduleRecord | import("./types.ts").EveryScheduleRecord | import("./types.ts").DailyScheduleRecord | import("./types.ts").WeeklyScheduleRecord | import("./types.ts").CronScheduleRecord, unknown>>;
+import type { ScheduleDeliveryRecord, ScheduleId, ScheduleTarget } from './types.ts';
+/**
+ * Version-2 task schema accepting version-1 rows. New metadata is optional on disk. An explicit target
+ * ignores the former Session binding; a missing target uses that binding or a stable create-once destination.
+ * Normal decoding does not write. The next edit or delivery writes this current shape without `sessionId`.
+ */
+export declare const scheduleTaskSchema: z.ZodPipe<z.ZodObject<{
+    record: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("./types.ts").AfterScheduleRecord | import("./types.ts").AtScheduleRecord | import("./types.ts").EveryScheduleRecord | import("./types.ts").DailyScheduleRecord | import("./types.ts").WeeklyScheduleRecord | import("./types.ts").CronScheduleRecord | import("./types.ts").RRuleScheduleRecord, unknown>>;
+    sessionId: z.ZodOptional<z.ZodUnknown>;
+    target: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"session">;
+        sessionId: z.ZodPipe<z.ZodString, z.ZodTransform<SessionId, string>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"new_once">;
+        sessionId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<SessionId, string>>>;
+        create: z.ZodDefault<z.ZodObject<{
+            cwd: z.ZodExactOptional<z.ZodString>;
+            agentPreset: z.ZodExactOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"new">;
+        create: z.ZodDefault<z.ZodObject<{
+            cwd: z.ZodExactOptional<z.ZodString>;
+            agentPreset: z.ZodExactOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>], "kind">>;
+    involvedSessionIds: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<SessionId, string>>>>;
     status: z.ZodDefault<z.ZodEnum<{
         active: "active";
+        paused: "paused";
+        ended: "ended";
         inactive: "inactive";
     }>>;
+    createdAt: z.ZodOptional<z.ZodISODateTime>;
+    updatedAt: z.ZodOptional<z.ZodISODateTime>;
     lastDelivery: z.ZodOptional<z.ZodObject<{
         scheduledAt: z.ZodISODateTime;
         deliveredAt: z.ZodISODateTime;
         messageId: z.ZodPipe<z.ZodString, z.ZodTransform<MessageId, string>>;
+        targetSessionId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<SessionId, string>>>;
     }, z.core.$strict>>;
     deliveryHistory: z.ZodOptional<z.ZodObject<{
         records: z.ZodArray<z.ZodObject<{
             scheduledAt: z.ZodISODateTime;
             deliveredAt: z.ZodISODateTime;
             messageId: z.ZodPipe<z.ZodString, z.ZodTransform<MessageId, string>>;
-            prompt: z.ZodOptional<z.ZodString>;
+            targetSessionId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<SessionId, string>>>;
+            prompt: z.ZodExactOptional<z.ZodString>;
         }, z.core.$strict>>;
         earlierRecordsUnavailable: z.ZodBoolean;
-        earlierRecordsPruned: z.ZodOptional<z.ZodBoolean>;
+        earlierRecordsPruned: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strict>>;
-}, z.core.$strict>;
-/** Persistent task value; absent history retains only its legacy last receipt without a read-time rewrite. */
+    pendingDelivery: z.ZodOptional<z.ZodObject<{
+        targetSessionId: z.ZodPipe<z.ZodString, z.ZodTransform<SessionId, string>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodTransform<{
+    deliveryHistory: {
+        records: ScheduleDeliveryRecord[];
+        earlierRecordsUnavailable: boolean;
+        earlierRecordsPruned: boolean;
+    };
+    lastDelivery?: {
+        scheduledAt: string;
+        deliveredAt: string;
+        messageId: MessageId;
+        targetSessionId?: SessionId | undefined;
+    } & {
+        targetSessionId: SessionId;
+    };
+    target: ScheduleTarget;
+    status: "active" | "paused" | "ended";
+    involvedSessionIds: SessionId[];
+    record: import("./types.ts").AfterScheduleRecord | import("./types.ts").AtScheduleRecord | import("./types.ts").EveryScheduleRecord | import("./types.ts").DailyScheduleRecord | import("./types.ts").WeeklyScheduleRecord | import("./types.ts").CronScheduleRecord | import("./types.ts").RRuleScheduleRecord;
+    createdAt?: string | undefined;
+    updatedAt?: string | undefined;
+    pendingDelivery?: {
+        targetSessionId: SessionId;
+    } | undefined;
+}, {
+    record: import("./types.ts").AfterScheduleRecord | import("./types.ts").AtScheduleRecord | import("./types.ts").EveryScheduleRecord | import("./types.ts").DailyScheduleRecord | import("./types.ts").WeeklyScheduleRecord | import("./types.ts").CronScheduleRecord | import("./types.ts").RRuleScheduleRecord;
+    status: "active" | "paused" | "ended" | "inactive";
+    sessionId?: unknown;
+    target?: {
+        kind: "session";
+        sessionId: SessionId;
+    } | {
+        kind: "new_once";
+        create: {
+            cwd?: string;
+            agentPreset?: string;
+        };
+        sessionId?: SessionId | undefined;
+    } | {
+        kind: "new";
+        create: {
+            cwd?: string;
+            agentPreset?: string;
+        };
+    } | undefined;
+    involvedSessionIds?: SessionId[] | undefined;
+    createdAt?: string | undefined;
+    updatedAt?: string | undefined;
+    lastDelivery?: {
+        scheduledAt: string;
+        deliveredAt: string;
+        messageId: MessageId;
+        targetSessionId?: SessionId | undefined;
+    } | undefined;
+    deliveryHistory?: {
+        records: {
+            scheduledAt: string;
+            deliveredAt: string;
+            messageId: MessageId;
+            targetSessionId?: SessionId | undefined;
+            prompt?: string;
+        }[];
+        earlierRecordsUnavailable: boolean;
+        earlierRecordsPruned: boolean;
+    } | undefined;
+    pendingDelivery?: {
+        targetSessionId: SessionId;
+    } | undefined;
+}>>;
+/** Persistent task value; a delivery receipt does not record model execution completion. */
 export type ScheduleTask = z.infer<typeof scheduleTaskSchema>;
-/** Authoritative Schedule storage; malformed tasks reject opening the domain. */
+/** Authoritative Host tasks retain their domain, backend routing, and envelope; v2 also reads v1 without startup writes. */
 export declare const scheduleDomain: {
     name: string;
     version: number;
+    compatibleVersions: number[];
     tables: {
         tasks: import("@qilin-agent/storage-domain").DomainTableSpec<ScheduleId, {
-            sessionId: SessionId;
-            record: import("./types.ts").AfterScheduleRecord | import("./types.ts").AtScheduleRecord | import("./types.ts").EveryScheduleRecord | import("./types.ts").DailyScheduleRecord | import("./types.ts").WeeklyScheduleRecord | import("./types.ts").CronScheduleRecord;
-            status: "active" | "inactive";
+            deliveryHistory: {
+                records: ScheduleDeliveryRecord[];
+                earlierRecordsUnavailable: boolean;
+                earlierRecordsPruned: boolean;
+            };
             lastDelivery?: {
                 scheduledAt: string;
                 deliveredAt: string;
                 messageId: MessageId;
-            } | undefined;
-            deliveryHistory?: {
-                records: {
-                    scheduledAt: string;
-                    deliveredAt: string;
-                    messageId: MessageId;
-                    prompt?: string | undefined;
-                }[];
-                earlierRecordsUnavailable: boolean;
-                earlierRecordsPruned?: boolean | undefined;
+                targetSessionId?: SessionId | undefined;
+            } & {
+                targetSessionId: SessionId;
+            };
+            target: ScheduleTarget;
+            status: "active" | "paused" | "ended";
+            involvedSessionIds: SessionId[];
+            record: import("./types.ts").AfterScheduleRecord | import("./types.ts").AtScheduleRecord | import("./types.ts").EveryScheduleRecord | import("./types.ts").DailyScheduleRecord | import("./types.ts").WeeklyScheduleRecord | import("./types.ts").CronScheduleRecord | import("./types.ts").RRuleScheduleRecord;
+            createdAt?: string | undefined;
+            updatedAt?: string | undefined;
+            pendingDelivery?: {
+                targetSessionId: SessionId;
             } | undefined;
         }>;
     };

package/lib/types/storage.js

@@ -1,4 +1,6 @@
 /** Durable Host-wide Schedule tasks, independently of Session activation. */
+import { createHash } from 'node:crypto';
+import { isDeepStrictEqual } from 'node:util';
 import { z } from 'zod';
 import { SessionId } from '@qilin-agent/session';
 import { MessageId } from '@qilin-agent/llm/brand';
@@ -13,42 +15,109 @@ const recordSchema = z.unknown().transform((value, context) => {
     }
     return z.NEVER;
 });
+/** Canonical millisecond UTC instant with a four-digit year. */
 const instantSchema = z.iso.datetime({ precision: 3 }).refine(value => !value.startsWith('0000-'), {
     message: 'Expected a canonical four-digit-year UTC calendar instant',
 });
+/** Identity of one delivered inbox message: non-empty, without surrounding whitespace. */
+const messageIdSchema = z.string().min(1).refine(value => value.trim() === value).transform(MessageId);
+/** Non-empty saved Session identity. */
+const sessionIdSchema = z.string().min(1).transform(SessionId);
 const deliveryReceiptSchema = z.object({
     scheduledAt: instantSchema,
     deliveredAt: instantSchema,
-    messageId: z.string().min(1).refine(value => value.trim() === value).transform(MessageId),
+    messageId: messageIdSchema,
+    targetSessionId: sessionIdSchema.optional(),
 }).strict();
 const deliveryHistorySchema = z.object({
-    records: z.array(deliveryReceiptSchema.extend({ prompt: z.string().optional() }).strict()),
+    records: z.array(deliveryReceiptSchema.extend({ prompt: z.string().exactOptional() }).strict()),
     earlierRecordsUnavailable: z.boolean(),
-    earlierRecordsPruned: z.boolean().optional(),
+    earlierRecordsPruned: z.boolean().default(false),
 }).strict().refine(history => new Set(history.records.map(record => record.messageId)).size === history.records.length, {
     message: 'Delivery history message identities must be unique within a task',
 });
-/** Stored task binds one schedule to its original Session; absent status decodes as active. */
+const createSpecSchema = z.object({
+    cwd: z.string().min(1).exactOptional(),
+    agentPreset: z.string().min(1).exactOptional(),
+}).strict();
+const targetSchema = z.discriminatedUnion('kind', [
+    z.object({ kind: z.literal('session'), sessionId: sessionIdSchema }).strict(),
+    z.object({ kind: z.literal('new_once'), sessionId: sessionIdSchema.optional(), create: createSpecSchema.default({}) }).strict(),
+    z.object({ kind: z.literal('new'), create: createSpecSchema.default({}) }).strict(),
+]);
+/** Stable reservation for a task without a saved destination; reads never allocate or persist a Session. */
+function defaultSessionId(id) {
+    return SessionId(`session-schedule-${createHash('sha256').update(id).digest('hex')}`);
+}
+/**
+ * Version-2 task schema accepting version-1 rows. New metadata is optional on disk. An explicit target
+ * ignores the former Session binding; a missing target uses that binding or a stable create-once destination.
+ * Normal decoding does not write. The next edit or delivery writes this current shape without `sessionId`.
+ */
 export const scheduleTaskSchema = z.object({
-    sessionId: z.string().min(1).transform(SessionId),
     record: recordSchema,
-    status: z.enum(['active', 'inactive']).default('active'),
+    sessionId: z.unknown().optional(),
+    target: targetSchema.optional(),
+    involvedSessionIds: z.array(sessionIdSchema).optional(),
+    status: z.enum(['active', 'paused', 'ended', 'inactive']).default('active'),
+    createdAt: instantSchema.optional(),
+    updatedAt: instantSchema.optional(),
     lastDelivery: deliveryReceiptSchema.optional(),
     deliveryHistory: deliveryHistorySchema.optional(),
-}).strict().refine((task) => {
-    if (task.deliveryHistory === undefined)
-        return true;
+    pendingDelivery: z.object({ targetSessionId: sessionIdSchema }).strict().optional(),
+}).strict().transform(({ sessionId, target: savedTarget, lastDelivery, deliveryHistory, ...task }, context) => {
+    const binding = savedTarget === undefined && sessionId !== undefined ? sessionIdSchema.safeParse(sessionId) : undefined;
+    if (binding?.success === false) {
+        context.addIssue({ code: 'custom', path: ['sessionId'], message: 'A missing target requires a valid stored Session binding' });
+        return z.NEVER;
+    }
+    const target = savedTarget === undefined
+        ? binding?.success === true
+            ? { kind: 'session', sessionId: binding.data }
+            : { kind: 'new_once', sessionId: defaultSessionId(task.record.id), create: {} }
+        : savedTarget.kind === 'new_once'
+            ? { ...savedTarget, sessionId: savedTarget.sessionId ?? defaultSessionId(task.record.id) }
+            : savedTarget;
+    const hasReceiptTarget = savedTarget === undefined
+        ? binding?.success === true
+        : savedTarget.kind !== 'new' && savedTarget.sessionId !== undefined;
+    const receipts = [lastDelivery, ...(deliveryHistory?.records ?? [])];
+    if (!hasReceiptTarget && receipts.some(value => value !== undefined && value.targetSessionId === undefined)) {
+        context.addIssue({ code: 'custom', message: 'A saved delivery without an existing destination must name its target Session' });
+        return z.NEVER;
+    }
+    const receipt = (value) => {
+        if (value.targetSessionId !== undefined)
+            return { ...value, targetSessionId: value.targetSessionId };
+        /* v8 ignore next -- the receipt-destination validation above rejects this combination before normalization. */
+        if (target.kind === 'new')
+            throw new Error('A delivery to a fresh Session must name its target Session');
+        return { ...value, targetSessionId: target.sessionId };
+    };
+    const last = lastDelivery === undefined ? undefined : receipt(lastDelivery);
+    const history = deliveryHistory === undefined
+        ? { records: last === undefined ? [] : [last], earlierRecordsUnavailable: true, earlierRecordsPruned: false }
+        : { ...deliveryHistory, records: deliveryHistory.records.map(value => receipt(value)) };
+    return {
+        ...task,
+        target,
+        status: task.status === 'inactive' ? 'ended' : task.status,
+        involvedSessionIds: task.involvedSessionIds ?? (target.kind === 'new' ? [] : [target.sessionId]),
+        ...(last === undefined ? {} : { lastDelivery: last }),
+        deliveryHistory: history,
+    };
+}).refine((task) => {
     const latest = task.deliveryHistory.records.at(-1);
     if (latest === undefined)
         return task.lastDelivery === undefined;
-    return task.lastDelivery !== undefined
-        && latest.scheduledAt === task.lastDelivery.scheduledAt
-        && latest.deliveredAt === task.lastDelivery.deliveredAt
-        && latest.messageId === task.lastDelivery.messageId;
-}, { message: 'Last delivery must match the latest saved delivery receipt' });
-/** Authoritative Schedule storage; malformed tasks reject opening the domain. */
+    const { prompt: _prompt, ...receipt } = latest;
+    return isDeepStrictEqual(receipt, task.lastDelivery);
+}, {
+    message: 'Last delivery must match the latest saved delivery receipt',
+});
+/** Authoritative Host tasks retain their domain, backend routing, and envelope; v2 also reads v1 without startup writes. */
 export const scheduleDomain = defineDomain({
-    name: 'schedule', version: 1,
+    name: 'schedule', version: 2, compatibleVersions: [1],
     tables: { tasks: domainTable(scheduleTaskSchema) },
 });
 //# sourceMappingURL=storage.js.map