@anhlp/alp-runtime 0.0.1-beta.3 → 0.0.1-beta.4

package/dist/session-config.d.ts

@@ -615,6 +615,41 @@ export declare function nativeSessionConfig(runtimeKind: RuntimeKind, mapping: R
             required: string[];
             additionalProperties: boolean;
         };
+    } | {
+        type: string;
+        name: string;
+        description: string;
+        inputSchema: {
+            type: string;
+            properties: {
+                action: {
+                    type: string;
+                    enum: string[];
+                };
+                dueAt: {
+                    type: string;
+                    description: string;
+                };
+                prompt: {
+                    type: string;
+                    description: string;
+                };
+                requestId: {
+                    type: string;
+                    description: string;
+                };
+                id: {
+                    type: string;
+                    description: string;
+                };
+                status: {
+                    type: string;
+                    enum: string[];
+                };
+            };
+            required: string[];
+            additionalProperties: boolean;
+        };
     } | {
         type: string;
         name: string;
@@ -1265,6 +1300,41 @@ export declare function nativeSessionConfig(runtimeKind: RuntimeKind, mapping: R
             required: string[];
             additionalProperties: boolean;
         };
+    } | {
+        type: string;
+        name: string;
+        description: string;
+        inputSchema: {
+            type: string;
+            properties: {
+                action: {
+                    type: string;
+                    enum: string[];
+                };
+                dueAt: {
+                    type: string;
+                    description: string;
+                };
+                prompt: {
+                    type: string;
+                    description: string;
+                };
+                requestId: {
+                    type: string;
+                    description: string;
+                };
+                id: {
+                    type: string;
+                    description: string;
+                };
+                status: {
+                    type: string;
+                    enum: string[];
+                };
+            };
+            required: string[];
+            additionalProperties: boolean;
+        };
     } | {
         type: string;
         name: string;
@@ -1917,6 +1987,41 @@ export declare function nativeSessionConfig(runtimeKind: RuntimeKind, mapping: R
             required: string[];
             additionalProperties: boolean;
         };
+    } | {
+        type: string;
+        name: string;
+        description: string;
+        inputSchema: {
+            type: string;
+            properties: {
+                action: {
+                    type: string;
+                    enum: string[];
+                };
+                dueAt: {
+                    type: string;
+                    description: string;
+                };
+                prompt: {
+                    type: string;
+                    description: string;
+                };
+                requestId: {
+                    type: string;
+                    description: string;
+                };
+                id: {
+                    type: string;
+                    description: string;
+                };
+                status: {
+                    type: string;
+                    enum: string[];
+                };
+            };
+            required: string[];
+            additionalProperties: boolean;
+        };
     } | {
         type: string;
         name: string;

package/dist/session-config.js

@@ -5,7 +5,7 @@ import { anyModel, profileModel } from "@anhlp/alp-core/profiles";
 import { models, thinkingOptionsFor } from "./catalog.js";
 import { claudeSandboxAvailable, SKILL_PLUGIN } from "./claude-transport.js";
 import { languageInstruction } from "./language.js";
-import { HANDOFF_TOOL, WAIT_TOOL, SEND_TOOL, MERGE_TOOL, VERIFY_TOOL, DISCARD_TOOL, CANCEL_TOOL, RECALL_TOOL, PIN_TOOL, BOARD_TOOL, UNPIN_TOOL, ASK_TOOL, LESSON_TOOL, SKILL_TOOL, ISSUE_TOOL, mainOf, taskActions, taskTool } from "./tools.js";
+import { HANDOFF_TOOL, WAIT_TOOL, SEND_TOOL, MERGE_TOOL, VERIFY_TOOL, DISCARD_TOOL, CANCEL_TOOL, RECALL_TOOL, PIN_TOOL, BOARD_TOOL, UNPIN_TOOL, ASK_TOOL, LESSON_TOOL, SKILL_TOOL, ISSUE_TOOL, SCHEDULE_TOOL, mainOf, taskActions, taskTool } from "./tools.js";
 import { COMPACT_SHARE } from "./runtime-context.js";
 var nativeMode = (mapping) => mapping.runtimeKind === "antigravity" && mapping.mode === "read-only" && mapping.antigravity?.readOnlyMode === "instructions" ? "full-access" : mapping.copy ? "workspace-write" : mapping.mode;
 function claudeFloor(mapping) {
@@ -182,7 +182,7 @@ function nativeSessionConfig(runtimeKind, mapping, targets, parentAgent, role, s
       ...targets.length || parentAgent ? [SEND_TOOL] : [],
       ...parentAgent ? [HANDOFF_TOOL] : [],
       ...supervised ? [LESSON_TOOL, SKILL_TOOL] : [],
-      ...!parentAgent && mapping.agent.name === mainOf(mapping) ? [ISSUE_TOOL] : [],
+      ...!parentAgent && mapping.agent.name === mainOf(mapping) ? [ISSUE_TOOL, SCHEDULE_TOOL] : [],
       ASK_TOOL,
       PIN_TOOL,
       BOARD_TOOL,

package/dist/session-state.d.ts

@@ -1,15 +1,28 @@
-import type { RuntimeTransport } from './contracts.js';
+import type { NativeBase, RuntimeTransport } from './contracts.js';
 import type { RuntimeKind, SessionSpec, ResolvedSession } from './resolve.js';
 import type { MailEvent } from './mailbox.js';
 import type { Worktree, WorktreeChange, Copy } from './workspace.js';
 import type { Verification } from '@anhlp/alp-core/verify';
 import type { Handoff } from './handoff.js';
 import type { SessionUsage } from './events.js';
+/** The pause that stopped a turn; a matching resume may arrive before its interruption settles. */
+export type ParkPause = {
+    scope: RuntimeKind | 'all';
+    resumed?: boolean;
+};
+export type Parked = {
+    reason: string;
+    since: number;
+    prompt?: string;
+    pause?: ParkPause;
+};
 export type Session = {
     runtimeKind: RuntimeKind;
     runtime: RuntimeTransport;
     mapping: ResolvedSession;
     threadId: string;
+    /** Claude: the conversation threadId is made from on its first prompt, until then (a fork or rewind, §12.7). */
+    base?: NativeBase;
     active?: string;
     /** A continued turn accepts a simultaneous user auto prompt as steering. */
     resumedTurn?: string;
@@ -44,11 +57,7 @@ export type Session = {
     /** Set by interrupt: pending mail waits for the next user prompt. */
     wakeBlocked: boolean;
     /** An assignment a usage limit or a pause stopped: it waits, open, until its runtime resumes. prompt is what continues it. */
-    parked?: {
-        reason: string;
-        since: number;
-        prompt?: string;
-    };
+    parked?: Parked;
     /** What the requester of a session parked by its turn's end is told happens next, instead of waiting for alp resume. */
     parkThen?: string;
     /** When ALP restarted this session's native process, within the last RESTART_WINDOW_MS. */
@@ -67,8 +76,15 @@ export type Session = {
     skillsUsed?: Set<string>;
     /** Why the running turn is being stopped, so its end parks the assignment instead of ending it. */
     parkReason?: string;
+    parkPause?: ParkPause;
     /** Mail arrived while its runtime was paused; it is delivered on resume. */
     wakeHeld?: boolean;
+    /** How many lifecycle operations (a rewind) hold its wakes now; mail waits until the last releases (AlpRuntime.hold). */
+    lifecycleHolds?: number;
+    /** Its parked work was to continue during a lifecycle hold; it continues when the last hold releases. */
+    resumeHeld?: Parked;
+    /** An assignment opened but not yet sent its brief: mail waits and rides with the brief's turn. */
+    awaitingBrief?: boolean;
     /** Permission questions to the user, one at a time. */
     permissionQueue?: Promise<unknown>;
     toolCalls: Map<string, Promise<unknown>>;

package/dist/tools.d.ts

@@ -680,3 +680,40 @@ export declare function taskTool(actions: TaskAction[]): {
 };
 /** The task an assignment takes, as the start of its brief. */
 export declare function taskBrief(task: Task, writing: boolean): string;
+/** Only the project's main root may schedule a future continuation. */
+export declare const SCHEDULE_TOOL: {
+    type: string;
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            action: {
+                type: string;
+                enum: string[];
+            };
+            dueAt: {
+                type: string;
+                description: string;
+            };
+            prompt: {
+                type: string;
+                description: string;
+            };
+            requestId: {
+                type: string;
+                description: string;
+            };
+            id: {
+                type: string;
+                description: string;
+            };
+            status: {
+                type: string;
+                enum: string[];
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+};

package/dist/tools.js

@@ -348,6 +348,24 @@ function taskBrief(task, writing) {
     "Your handoff moves this task to review for your requester to accept. List work you found outside the task under discovered; only main and the user create tasks."
   ].join("\n");
 }
+var SCHEDULE_TOOL = {
+  type: "function",
+  name: "alp_schedule",
+  description: "Create, list, inspect or cancel a one-shot continuation of this main/root session. create proposes the exact prompt and ISO time with UTC offset for user approval. Jobs wake an idle main without a user message; timer gates only unblock tasks, and assignment notes do not schedule a wake. Scheduling a quota-reset continuation never guarantees provider availability: recheck actual availability before delegating.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      action: { type: "string", enum: ["create", "list", "get", "cancel"] },
+      dueAt: { type: "string", description: "For create: ISO timestamp with Z or an explicit UTC offset." },
+      prompt: { type: "string", description: "For create: the exact continuation, at most 8000 characters." },
+      requestId: { type: "string", description: "For create: stable id for this approval proposal; reuse only for an identical draft." },
+      id: { type: "string", description: "For get/cancel: the scheduled job id." },
+      status: { type: "string", enum: ["pending", "delivered", "failed", "cancelled"] }
+    },
+    required: ["action"],
+    additionalProperties: false
+  }
+};
 export {
   ASK_TOOL,
   BOARD_TOOL,
@@ -359,6 +377,7 @@ export {
   MERGE_TOOL,
   PIN_TOOL,
   RECALL_TOOL,
+  SCHEDULE_TOOL,
   SEND_TOOL,
   SKILL_TOOL,
   TASK_ACTIONS,

package/dist/worktree-domain.d.ts

@@ -4,6 +4,7 @@ import type { RuntimeOptions } from './contracts.js';
 import type { Session, Assignment } from './session-state.js';
 type WorktreeContext = {
     options: RuntimeOptions;
+    releaseResult(assignmentId: string): Promise<void>;
     leases: Map<string, {
         assignment: string;
         agent: string;
@@ -15,7 +16,7 @@ type WorktreeContext = {
     touchTask(rootId: string, id: string): void;
 };
 /** Checkout mutation and verification retain one shared queue per checkout. */
-export declare function createWorktreeDomain({ options, leases, rootOf, lineage, runLog, runHooks, touchTask }: WorktreeContext): {
+export declare function createWorktreeDomain({ options, leases, releaseResult, rootOf, lineage, runLog, runHooks, touchTask }: WorktreeContext): {
     settleWorktree: (parentId: string, parent: Session, assignment: Assignment) => Promise<{
         branch: string;
         files: never[];

package/dist/worktree-domain.js

@@ -8,7 +8,7 @@ import { writes } from "./catalog.js";
 import { nativeEnvironment } from "./providers.js";
 import { mainOf } from "./tools.js";
 import { errorData, plainObject, toolResult } from "./tool-results.js";
-function createWorktreeDomain({ options, leases, rootOf, lineage, runLog, runHooks, touchTask }) {
+function createWorktreeDomain({ options, leases, releaseResult, rootOf, lineage, runLog, runHooks, touchTask }) {
   const merging = /* @__PURE__ */ new Map();
   async function settleWorktree(parentId, parent, assignment) {
     const worktree = assignment.worktree;
@@ -16,6 +16,7 @@ function createWorktreeDomain({ options, leases, rootOf, lineage, runLog, runHoo
       const change = await commitWorktree(worktree, `alp: ${assignment.agent} assignment ${assignment.id}`);
       if (!change.files.length) {
         await removeWorktree(worktree, { deleteBranch: true });
+        await releaseResult(assignment.id);
         return { branch: worktree.branch, files: [], note: "No changes; the worktree was removed" };
       }
       const described = { branch: worktree.branch, base: worktree.base, commit: change.commit, files: change.files, stat: change.stat };
@@ -44,6 +45,7 @@ function createWorktreeDomain({ options, leases, rootOf, lineage, runLog, runHoo
     if (action === "discard") {
       session.worktrees.delete(args.assignmentId);
       await removeWorktree(worktree, { deleteBranch: true });
+      await releaseResult(args.assignmentId);
       runLog(rootOf(sessionId), { event: "worktree.discarded", assignmentId: args.assignmentId, branch: worktree.branch });
       return toolResult(true, { discarded: args.assignmentId, branch: worktree.branch });
     }
@@ -104,6 +106,7 @@ ${refused}`, branch: worktree.branch, next: `Fix what it reports in a new assign
       return toolResult(false, { error: errorData(error).message, branch: worktree.branch, next: "Merge the branch yourself, or alp_discard it" });
     }
     await removeWorktree(worktree, { deleteBranch: merged.status !== "conflicts" });
+    if (merged.status !== "conflicts") await releaseResult(args.assignmentId);
     runLog(rootId, { event: "worktree.merged", assignmentId: args.assignmentId, branch: worktree.branch, ...merged });
     let checked;
     if (config && args.skipVerify === void 0 && merged.status === "applied" && moved) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anhlp/alp-runtime",
-  "version": "0.0.1-beta.3",
+  "version": "0.0.1-beta.4",
   "type": "module",
   "description": "ALP runtime module",
   "files": [
@@ -25,6 +25,14 @@
       "types": "./dist/antigravity-transport.d.ts",
       "default": "./dist/antigravity-transport.js"
     },
+    "./attachments": {
+      "alp-source": {
+        "types": "./src/attachments.ts",
+        "default": "./src/attachments.ts"
+      },
+      "types": "./dist/attachments.d.ts",
+      "default": "./dist/attachments.js"
+    },
     "./board": {
       "alp-source": {
         "types": "./src/board.ts",
@@ -222,8 +230,8 @@
     "node": ">=22.12"
   },
   "dependencies": {
-    "@anhlp/alp-core": "0.0.1-beta.3",
-    "@anhlp/alp-protocol": "0.0.1-beta.3",
+    "@anhlp/alp-core": "0.0.1-beta.4",
+    "@anhlp/alp-protocol": "0.0.1-beta.4",
     "@anthropic-ai/claude-agent-sdk": "^0.3.292",
     "@modelcontextprotocol/sdk": "^1.32.1",
     "@agentclientprotocol/sdk": "1.7.0",

package/src/assignment-results.ts

@@ -0,0 +1,64 @@
+import { readFile, mkdir, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { writeAtomic } from '@anhlp/alp-core/atomic';
+
+export type AssignmentResultOwner = { assignmentId: string; checkout: string; worktree?: string };
+type Ledger = { version: 1; workspaces: string[]; results: AssignmentResultOwner[] };
+const empty = (): Ledger => ({ version: 1, workspaces: [], results: [] });
+const absolute = (value: unknown): value is string => typeof value === 'string' && path.isAbsolute(value);
+const valid = (value: any): value is Ledger => value?.version === 1 && Array.isArray(value.workspaces) && value.workspaces.every(absolute) &&
+  Array.isArray(value.results) && value.results.every((entry: any) => entry && typeof entry.assignmentId === 'string' && absolute(entry.checkout) && (entry.worktree === undefined || absolute(entry.worktree)));
+
+/** Permanent ownership, independent of native-thread recall expiry. Missing initialized data is never recreated. */
+export function createAssignmentResults(file?: string) {
+  let memory = empty();
+  let queue = Promise.resolve();
+  const marker = file ? `${file}.initialized` : undefined;
+  async function load(initialize = false): Promise<Ledger> {
+    if (!file) return memory;
+    let value: unknown;
+    try { value = JSON.parse(await readFile(file, 'utf8')); }
+    catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT' || !initialize) throw new Error(`Cannot inspect assignment result ledger ${file}`);
+      try { await readFile(marker!, 'utf8'); }
+      catch (missing) {
+        if ((missing as NodeJS.ErrnoException).code === 'ENOENT') return empty();
+        throw missing;
+      }
+      throw new Error(`Assignment result ledger ${file} was lost; restore it before managing workspaces`);
+    }
+    if (!valid(value)) throw new Error(`Invalid assignment result ledger ${file}`);
+    return value;
+  }
+  async function save(value: Ledger) {
+    if (!file) { memory = value; return; }
+    await mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
+    await writeAtomic(file, JSON.stringify(value) + '\n');
+    // The marker survives a lost ledger; registration must never silently reset ownership.
+    await writeFile(marker!, '1\n', { flag: 'wx', mode: 0o600 }).catch(error => { if (error.code !== 'EEXIST') throw error; });
+  }
+  function serialize<T>(run: () => Promise<T>): Promise<T> {
+    const result = queue.then(run);
+    queue = result.then(() => {}, () => {});
+    return result;
+  }
+  return {
+    register(directory: string) { return serialize(async () => {
+      const value = await load(true);
+      if (!value.workspaces.includes(directory)) value.workspaces.push(directory);
+      await save(value);
+    }); },
+    put(entry: AssignmentResultOwner) { return serialize(async () => {
+      // Initial assignment activity can establish the index, but never certify old workspaces.
+      const value = await load(true);
+      value.results = [...value.results.filter(existing => existing.assignmentId !== entry.assignmentId), entry];
+      await save(value);
+    }); },
+    remove(assignmentId: string) { return serialize(async () => {
+      const value = await load();
+      value.results = value.results.filter(entry => entry.assignmentId !== assignmentId);
+      await save(value);
+    }); },
+    inspect() { return serialize(() => load()); },
+  };
+}