@cjhyy/code-shell-pet 0.9.8 → 0.9.10

package/dist/long-task.d.ts

@@ -30,7 +30,7 @@ export interface PetLongTaskCompletionTarget {
     replyAttachmentKinds?: PetReplyAttachmentKind[];
 }
 export type PetReplyAttachmentKind = "image" | "file" | "audio" | "video";
-export type PetLongTaskEventKind = "created" | "started" | "progress" | "waiting" | "paused" | "resumed" | "retrying" | "artifact" | "checkpoint" | "verification-changed" | "completion-target-set" | "interrupted" | "completed" | "failed" | "cancelled" | "closure-decided" | "continuation-started" | "closure-recorded" | "work-memory-recorded";
+export type PetLongTaskEventKind = "created" | "started" | "run-bound" | "run-prepared" | "result-updated" | "progress" | "waiting" | "paused" | "resumed" | "retrying" | "artifact" | "checkpoint" | "verification-changed" | "completion-target-set" | "interrupted" | "completed" | "failed" | "cancelled" | "closure-decided" | "continuation-started" | "closure-recorded" | "work-memory-recorded";
 export interface PetLongTaskEvent {
     id: string;
     sequence: number;
@@ -41,6 +41,9 @@ export interface PetLongTaskEvent {
     waitingFor?: string;
     nextAction?: string;
     artifacts?: PetLongTaskArtifact[];
+    attempt?: number;
+    runId?: string;
+    clientMessageId?: string;
 }
 export interface PetLongTask {
     schemaVersion: typeof PET_LONG_TASK_SCHEMA_VERSION;
@@ -59,6 +62,10 @@ export interface PetLongTask {
     status: PetLongTaskStatus;
     phase: PetLongTaskPhase;
     attempt: number;
+    /** Current run's transcript user-message id; absent in historical rows. */
+    runId?: string;
+    /** Expected launch client id before binding, current run client id afterwards. */
+    clientMessageId?: string;
     revision: number;
     createdAt: number;
     updatedAt: number;
@@ -127,6 +134,8 @@ export interface CreatePetLongTaskInput {
     objective: string;
     workspacePath: string | null;
     sessionId: string;
+    runId?: string;
+    clientMessageId?: string;
     executionBackend?: PetWorkExecutionBackend;
     verificationMode?: PetLongTaskVerificationMode;
     completionTarget?: PetLongTaskCompletionTarget;
@@ -134,6 +143,28 @@ export interface CreatePetLongTaskInput {
     at: number;
 }
 export type PetLongTaskTransition = {
+    /** Optimistic fence for observations queued before retry/resume. */
+    attempt?: number;
+    runId?: string;
+    clientMessageId?: string;
+} & PetLongTaskTransitionInput;
+type PetLongTaskTransitionInput = {
+    kind: "run-prepared";
+    at: number;
+    clientMessageId?: string;
+} | {
+    kind: "run-bound";
+    at: number;
+    runId: string;
+    previousRunId?: string;
+} | {
+    kind: "result-updated";
+    at: number;
+    attempt: number;
+    runId: string;
+    summary?: string;
+    terminalStatus?: "completed" | "failed";
+} | {
     kind: "started";
     at: number;
     message?: string;
@@ -233,9 +264,9 @@ export type PetLongTaskTransition = {
 export declare function createPetLongTask(input: CreatePetLongTaskInput): PetLongTask;
 /**
  * Apply one durable transition. Terminal tasks only accept retry/cancel or a
- * closure-delivery acknowledgement; late
- * worker events are ignored so a stale completion cannot undo an explicit user
- * action such as pause or cancel.
+ * closure-delivery acknowledgement. A completed task can also record an explicit
+ * result update fenced to its current run and attempt. Late worker events cannot
+ * undo an explicit user action such as pause, cancel, or retry.
  */
 export declare function transitionPetLongTask(current: PetLongTask, transition: PetLongTaskTransition): PetLongTask;
 /** Defensive parser used by durable hosts. Invalid rows are dropped independently. */
@@ -269,3 +300,4 @@ export interface PetLongTaskContext {
 /** Bounded task continuity injected into each Mimi manager turn. */
 export declare function buildPetLongTaskContext(tasks: readonly PetLongTask[]): PetLongTaskContext;
 export declare function petLongTaskResumePrompt(task: PetLongTask): string;
+export {};

package/dist/long-task.js

@@ -159,6 +159,8 @@ export function createPetLongTask(input) {
         status: "queued",
         phase: "planning",
         attempt: 1,
+        runId: input.runId,
+        clientMessageId: input.clientMessageId,
         revision: 1,
         createdAt: input.at,
         updatedAt: input.at,
@@ -169,11 +171,26 @@ export function createPetLongTask(input) {
 }
 /**
  * Apply one durable transition. Terminal tasks only accept retry/cancel or a
- * closure-delivery acknowledgement; late
- * worker events are ignored so a stale completion cannot undo an explicit user
- * action such as pause or cancel.
+ * closure-delivery acknowledgement. A completed task can also record an explicit
+ * result update fenced to its current run and attempt. Late worker events cannot
+ * undo an explicit user action such as pause, cancel, or retry.
  */
 export function transitionPetLongTask(current, transition) {
+    if (transition.attempt !== undefined && transition.attempt !== current.attempt)
+        return current;
+    if (current.status === "paused" && transition.runId !== undefined)
+        return current;
+    if (transition.kind !== "run-bound" &&
+        transition.kind !== "run-prepared" &&
+        transition.kind !== "retrying" &&
+        ((transition.runId !== undefined &&
+            (transition.runId !== current.runId ||
+                transition.clientMessageId !== current.clientMessageId)) ||
+            (transition.clientMessageId !== undefined &&
+                transition.clientMessageId !== current.clientMessageId)))
+        return current;
+    if (transition.kind === "result-updated" && (current.status !== "completed" || !current.runId))
+        return current;
     if (transition.kind === "closure-decided" && current.closureDecision?.key === transition.key) {
         return current;
     }
@@ -202,6 +219,7 @@ export function transitionPetLongTask(current, transition) {
         transition.kind !== "retrying" &&
         transition.kind !== "cancelled" &&
         transition.kind !== "background-wait-recovered" &&
+        transition.kind !== "result-updated" &&
         transition.kind !== "closure-decided" &&
         transition.kind !== "continuation-started" &&
         transition.kind !== "closure-recorded" &&
@@ -231,6 +249,50 @@ export function transitionPetLongTask(current, transition) {
     };
     let event;
     switch (transition.kind) {
+        case "run-prepared":
+            Object.assign(next, { runId: undefined, clientMessageId: transition.clientMessageId });
+            event = { kind: transition.kind, at: transition.at, message: "Preparing to continue work" };
+            break;
+        case "run-bound":
+            if (current.runId !== transition.previousRunId)
+                return current;
+            // A resume can prepare a different launch before a queued start is applied.
+            // Unbound launches share undefined previousRunId; the submit id is their CAS.
+            if (!current.runId &&
+                current.clientMessageId !== undefined &&
+                current.clientMessageId !== transition.clientMessageId)
+                return current;
+            if (current.runId === transition.runId)
+                return current;
+            Object.assign(next, {
+                runId: transition.runId,
+                clientMessageId: transition.clientMessageId,
+                status: "running",
+                phase: "executing",
+                resultSummary: undefined,
+                waitingFor: undefined,
+            });
+            event = { kind: transition.kind, at: transition.at, message: "Work session started" };
+            break;
+        case "result-updated": {
+            const summary = bounded(transition.summary, MAX_PET_LONG_TASK_SUMMARY_LENGTH);
+            const message = summary ?? current.resultSummary ?? "Work session result confirmed";
+            if (current.events.some((item) => item.kind === "result-updated" &&
+                item.runId === transition.runId &&
+                item.attempt === current.attempt) &&
+                (!summary || summary === current.resultSummary) &&
+                (!transition.terminalStatus || transition.terminalStatus === current.status))
+                return current;
+            Object.assign(next, {
+                status: transition.terminalStatus ?? current.status,
+                ...(summary ? { resultSummary: summary, summary } : {}),
+                ...(transition.terminalStatus === "failed"
+                    ? { lastError: summary, completedAt: transition.at }
+                    : {}),
+            });
+            event = { kind: transition.kind, at: transition.at, phase: "finalizing", message };
+            break;
+        }
         case "started":
             Object.assign(next, {
                 status: "running",
@@ -334,6 +396,8 @@ export function transitionPetLongTask(current, transition) {
                 status: "queued",
                 phase: "planning",
                 attempt: current.attempt + 1,
+                runId: undefined,
+                clientMessageId: transition.clientMessageId,
                 // A retry is a new attempt in the same durable Session. Keeping the
                 // previous attempt's start time would let an old projection terminal
                 // pass the new attempt's time fence.
@@ -593,7 +657,12 @@ export function transitionPetLongTask(current, transition) {
             };
             break;
     }
-    next.events = appendEvent(current, event);
+    next.events = appendEvent(current, {
+        ...event,
+        attempt: next.attempt,
+        runId: next.runId,
+        clientMessageId: next.clientMessageId,
+    });
     return next;
 }
 function isStatus(value) {
@@ -618,6 +687,9 @@ function isEventKind(value) {
         [
             "created",
             "started",
+            "run-bound",
+            "run-prepared",
+            "result-updated",
             "progress",
             "waiting",
             "paused",
@@ -657,6 +729,19 @@ function parseEvent(value) {
         sequence: event.sequence,
         kind: event.kind,
         at: event.at,
+        ...(typeof event.attempt === "number" &&
+            Number.isSafeInteger(event.attempt) &&
+            event.attempt > 0
+            ? { attempt: event.attempt }
+            : {}),
+        ...(typeof event.runId === "string" && event.runId.length > 0 && event.runId.length <= 256
+            ? { runId: event.runId }
+            : {}),
+        ...(typeof event.clientMessageId === "string" &&
+            event.clientMessageId.length > 0 &&
+            event.clientMessageId.length <= 256
+            ? { clientMessageId: event.clientMessageId }
+            : {}),
         ...(typeof event.message === "string" ? { message: bounded(event.message, 2_000) } : {}),
         ...(isPhase(event.phase) ? { phase: event.phase } : {}),
         ...(typeof event.waitingFor === "string" ? { waitingFor: bounded(event.waitingFor, 500) } : {}),
@@ -794,6 +879,14 @@ export function parsePetLongTask(value) {
         status: record.status,
         phase: record.phase,
         attempt: record.attempt,
+        ...(typeof record.runId === "string" && record.runId.length > 0 && record.runId.length <= 256
+            ? { runId: record.runId }
+            : {}),
+        ...(typeof record.clientMessageId === "string" &&
+            record.clientMessageId.length > 0 &&
+            record.clientMessageId.length <= 256
+            ? { clientMessageId: record.clientMessageId }
+            : {}),
         revision: record.revision,
         createdAt: record.createdAt,
         updatedAt: record.updatedAt,

package/dist/projection-extension.js

@@ -75,6 +75,8 @@ export function createPetProjectionObserver(host) {
             queueDepth: live.queueDepth,
             lastActivityAt: Math.max(live.lastActivityAt, indexed?.lastActivityAt ?? 0),
             pendingDecisionCount,
+            runId: indexed?.runId,
+            clientMessageId: indexed?.clientMessageId,
             completionKind: liveRunState === "idle" ? indexed?.completionKind : undefined,
             terminal,
             freshness: { source: "live-snapshot", observedAt, workerState: "active" },

package/dist/session-index.js

@@ -54,6 +54,8 @@ function baseProjection(catalog, observedAt, workerState) {
         owner: LOCAL_PET_OWNER,
         agentSessionId: catalog.sessionId,
         coreSessionId: catalog.sessionId,
+        runId: catalog.runId,
+        clientMessageId: catalog.clientMessageId,
         title: catalog.title,
         workspaceDisplayName: catalog.workspaceDisplayName,
         runState: status ? "terminal" : "dormant",
@@ -68,7 +70,14 @@ function baseProjection(catalog, observedAt, workerState) {
                 : completionKind === "limit_stop"
                     ? "已到运行限制"
                     : undefined,
-        terminal: status ? { status, at: catalog.updatedAt } : undefined,
+        terminal: status
+            ? {
+                status,
+                at: catalog.updatedAt,
+                runId: catalog.runId,
+                clientMessageId: catalog.clientMessageId,
+            }
+            : undefined,
         freshness: { source: "disk", observedAt, workerState },
     };
 }
@@ -261,12 +270,44 @@ export class SessionIndex {
         return true;
     }
     reduceEvent(current, event, observedAt) {
+        if ("agentId" in event && event.agentId !== undefined) {
+            // Child activity is useful progress, but cannot change the parent's lifecycle.
+            if (event.type === "turn_complete" || event.type === "error")
+                return current;
+            return {
+                ...current,
+                lastActivityAt: observedAt,
+                summary: event.type === "tool_use_start"
+                    ? `正在运行 ${safeToolName(event.toolCall.toolName)}`.slice(0, 64)
+                    : current.summary,
+                freshness: { source: "live-event", observedAt, workerState: "active" },
+            };
+        }
+        if (event.type !== "session_started" &&
+            current.runId &&
+            (event.runId !== current.runId || event.clientMessageId !== current.clientMessageId)) {
+            return current;
+        }
         const next = {
             ...current,
             lastActivityAt: observedAt,
             freshness: { source: "live-event", observedAt, workerState: "active" },
         };
         switch (event.type) {
+            case "session_started":
+                if (current.runId &&
+                    (event.runId === current.runId || event.previousRunId !== current.runId))
+                    return current;
+                return {
+                    ...next,
+                    runId: event.runId,
+                    clientMessageId: event.clientMessageId,
+                    runState: "running",
+                    phase: "model",
+                    summary: "模型处理中",
+                    completionKind: undefined,
+                    terminal: undefined,
+                };
             case "stream_request_start":
                 return {
                     ...next,
@@ -322,7 +363,14 @@ export class SessionIndex {
                             ? "本轮已完成"
                             : "运行已结束",
                     completionKind: undefined,
-                    terminal: current.queueDepth > 0 ? undefined : { status, at: observedAt },
+                    terminal: current.queueDepth > 0
+                        ? undefined
+                        : {
+                            status,
+                            at: observedAt,
+                            runId: current.runId,
+                            clientMessageId: current.clientMessageId,
+                        },
                 };
             }
             case "error":
@@ -332,7 +380,12 @@ export class SessionIndex {
                     phase: "finalizing",
                     summary: "运行失败",
                     completionKind: undefined,
-                    terminal: { status: "failed", at: observedAt },
+                    terminal: {
+                        status: "failed",
+                        at: observedAt,
+                        runId: current.runId,
+                        clientMessageId: current.clientMessageId,
+                    },
                 };
             default:
                 return next;

package/dist/types.d.ts

@@ -27,16 +27,22 @@ export interface PetSessionProjection {
     queueDepth: number;
     lastActivityAt: number;
     pendingDecisionCount: number;
+    runId?: string;
+    clientMessageId?: string;
     /** Exceptional completed-run boundary that is waiting for recovery/continuation. */
     completionKind?: TurnCompletionKind;
     terminal?: {
         status: PetTerminalStatus;
         at: number;
+        runId?: string;
+        clientMessageId?: string;
     };
     freshness: PetProjectionFreshness;
 }
 export interface PetCatalogSession {
     sessionId: string;
+    runId?: string;
+    clientMessageId?: string;
     title?: string;
     workspaceDisplayName?: string;
     updatedAt: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cjhyy/code-shell-pet",
-  "version": "0.9.8",
+  "version": "0.9.10",
   "description": "Pet (top-level personal assistant) capability for CodeShell — projection state machine, DelegateWork contract, Mimi behavior profile.",
   "type": "module",
   "main": "./dist/index.js",
@@ -36,7 +36,7 @@
     "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\""
   },
   "dependencies": {
-    "@cjhyy/code-shell-core": "0.9.8"
+    "@cjhyy/code-shell-core": "0.9.10"
   },
   "engines": {
     "node": ">=20.10"