@zq-silk/yui 2.10.0 → 2.12.0

package/dist/scheduler/wakeReason.js

@@ -24,6 +24,7 @@ export const WAKE_REASON_KINDS = Object.freeze([
     "leader-turn-failed",
     "role-turn-failed",
     "job-finished",
+    "job-agent-input",
     "published-tree-authorized",
     "notification-retry",
     "force-wake"
@@ -31,6 +32,9 @@ export const WAKE_REASON_KINDS = Object.freeze([
 const IMMEDIATE_KINDS = new Set([
     "operator-input",
     "user-message",
+    // An explicitly admitted Agent Job is new input, not a background result
+    // to debounce. All existing busy/ownership/delivery checks still apply.
+    "job-agent-input",
     "task-created",
     "execution-started",
     "session-replaced",

package/dist/storage/agentJobSchema.js

@@ -0,0 +1,10 @@
+/** Storage 1.18: Agent Runs are not shell runs with fabricated Task/workspace fields. */
+export const AGENT_JOB_SCHEMA_SQL = `
+CREATE TABLE agent_job_runs (
+  run_id TEXT PRIMARY KEY,
+  scope_key TEXT NOT NULL,
+  definition_id TEXT NOT NULL,
+  payload TEXT NOT NULL
+);
+CREATE INDEX idx_agent_job_runs_owner ON agent_job_runs(scope_key, definition_id);
+`;

package/dist/storage/maintenanceCaller.js

@@ -5,16 +5,23 @@ import { ManagedRuntimeDriftError, requireManagedGlobalCaller } from "../runtime
 import { sessionCallerEnvironment } from "../runtime/sessionCaller.js";
 import { validateStoredRecord } from "./recordValidation.js";
 import { inspectSqliteSchema, storageMinorUpgradePlan, validateSqliteSchemaObjects } from "./sqliteSchema.js";
-import { CURRENT_DATABASE_FILENAME } from "./storageSchema.js";
+import { CURRENT_DATABASE_FILENAME, inspectStorageSchema } from "./storageSchema.js";
+import { findNativeSessionSets } from "./nativeSessionLookup.js";
 /**
- * Maintenance must authenticate before migration, without opening a current-only
- * business Store. The declared 1.x migrations preserve these Role/Session
- * envelopes and physical tables. Read only those records in one SQLite snapshot;
- * this grants no old-format business reads, writes or implicit migration.
+ * Read-only caller resolution, also usable before maintenance/migration and by
+ * offline discovery. The declared 1.x migrations preserve these Role/Session
+ * envelopes and physical tables. Read only those records in one SQLite snapshot.
+ * operatorOnly adds the maintenance gate; ordinary execution still applies its
+ * current storage, Session and domain checks. No implicit migration or setup.
  */
 export function maintenanceCallerEnvironment(home, env, operatorOnly = true) {
-    if (!hasManagedIdentity(env))
+    if (!hasManagedIdentity(env) && env.CODEX_THREAD_ID === undefined)
         return env;
+    // A genuinely new Home has no managed registrations. Do not initialize it
+    // here: setup remains the explicit owner. Existing invalid storage fails closed.
+    if (!hasManagedIdentity(env) && inspectStorageSchema(home).status === "uninitialized") {
+        return sessionCallerEnvironment({ findNativeSessionSets: () => [] }, env);
+    }
     const db = new Database(join(home, CURRENT_DATABASE_FILENAME), { readonly: true, fileMustExist: true });
     try {
         return db.transaction(() => {
@@ -34,29 +41,14 @@ export function maintenanceCallerEnvironment(home, env, operatorOnly = true) {
             const registry = {
                 getGlobalRole: (name) => read("global_roles", "name=?", [name]),
                 getGlobalRoleSessionSet: (name) => read("global_role_session_sets", "name=?", [name]),
-                getTaskRoleSessionSet: (task, role) => read("role_session_sets", "task_id=? AND role_name=?", [task, role]),
-                listRuntimeSessionCandidates: () => {
-                    // Read canonical sets, not a derived index that could be stale. Only
-                    // active bindings participate, exactly as in normal caller discovery.
-                    const rows = db.prepare(`
-            SELECT 'global_role_session_sets' AS source, payload FROM global_role_session_sets
-            UNION ALL SELECT 'role_session_sets' AS source, payload FROM role_session_sets
-          `).all();
-                    return rows.flatMap(row => {
-                        const set = JSON.parse(row.payload);
-                        validateStoredRecord(row.source, set);
-                        const session = set.sessions[set.activeAgentId];
-                        if (!session || session.status !== "active")
-                            return [];
-                        return [{ owner: set.owner, agentId: session.agentId, adapterId: session.adapterId,
-                                nativeSessionId: session.nativeSessionId, sessionUpdatedAt: set.updatedAt }];
-                    });
-                }
+                findNativeSessionSets: (nativeIds) => findNativeSessionSets(db, nativeIds)
             };
             const current = sessionCallerEnvironment(registry, env);
+            if (!hasManagedIdentity(current))
+                return current;
             if (current.YUI_SESSION_SCOPE !== "global" || current.YUI_ROLE !== "operator") {
                 if (!operatorOnly)
-                    return current; // Doctor keeps normal scoped authorization below.
+                    return current; // Execution retains its normal scoped checks.
                 throw new ManagedRuntimeDriftError("Home maintenance requires the user or current Operator, not a Task or custom Role.");
             }
             requireManagedGlobalCaller(registry, current);

package/dist/storage/nativeSessionLookup.js

@@ -0,0 +1,23 @@
+import { validateStoredRecord } from "./recordValidation.js";
+/** Identity lookup includes terminal and replaced Sessions. The hot active
+ * runtime projection cannot prove that an unknown caller is unmanaged.
+ * Read existing canonical records; no second identity registry or schema. */
+export function findNativeSessionSets(db, nativeIds) {
+    const ids = [...new Set(nativeIds)];
+    if (!ids.length)
+        return [];
+    const placeholders = ids.map(() => "?").join(", ");
+    return ["role_session_sets", "global_role_session_sets"].flatMap(table => {
+        const rows = db.prepare(`SELECT payload FROM ${table}
+      WHERE EXISTS (SELECT 1 FROM json_each(payload, '$.sessions')
+        WHERE json_extract(value, '$.nativeSessionId') IN (${placeholders}))
+      OR EXISTS (SELECT 1 FROM json_each(payload, '$.history')
+        WHERE json_extract(value, '$.nativeSessionId') IN (${placeholders}))`)
+            .all(...ids, ...ids);
+        return rows.map(row => {
+            const set = JSON.parse(row.payload);
+            validateStoredRecord(table, set);
+            return set;
+        });
+    });
+}

package/dist/storage/recordValidation.js

@@ -9,6 +9,7 @@ import { validateChangeSet } from "../integration/changeSet.js";
 import { validateIntegrationAttempt } from "../integration/integrationAttempt.js";
 import { validateDurableJob } from "../job/durableJob.js";
 import { validateJobDefinition } from "../job/jobDefinition.js";
+import { validateAgentJobRun } from "../job/agentJob.js";
 import { validateSchedule } from "../schedule/schedule.js";
 import { validateGlobalRoleMessage, validateTaskMessage } from "../message/message.js";
 import { validateMilestone } from "../milestone/milestone.js";
@@ -57,6 +58,7 @@ const validators = {
     integration_attempts: check(validateIntegrationAttempt),
     durable_jobs: check(validateDurableJob),
     job_definitions: check(validateJobDefinition),
+    agent_job_runs: check(validateAgentJobRun),
     schedules: check(validateSchedule),
     global_job_runs: check(validateDurableJob),
     context_snapshots: check(validateContextSnapshot),

package/dist/storage/sessionHistorySchema.js

@@ -0,0 +1,17 @@
+/** Session history outlives Role deletion. It is identity evidence, not a
+ * grant or an independently managed lifecycle. Payload format is unchanged. */
+export const GLOBAL_SESSION_TABLE_SQL = `CREATE TABLE global_role_session_sets (
+  name       TEXT PRIMARY KEY,
+  payload    TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);`;
+export const GLOBAL_SESSION_RETRY_INDEX_SQL = `CREATE INDEX idx_global_provider_retry ON global_role_session_sets(
+  json_extract(payload, '$.providerBinding.retry.status')
+) WHERE json_extract(payload, '$.providerBinding.retry.status') IN ('waiting', 'in-flight');`;
+export const SESSION_HISTORY_UPGRADE_SQL = `
+ALTER TABLE global_role_session_sets RENAME TO global_role_session_sets_113;
+${GLOBAL_SESSION_TABLE_SQL}
+INSERT INTO global_role_session_sets SELECT * FROM global_role_session_sets_113;
+DROP TABLE global_role_session_sets_113;
+${GLOBAL_SESSION_RETRY_INDEX_SQL}
+`;

package/dist/storage/sqliteSchema.js

@@ -4,16 +4,25 @@ import { BASELINE_SCHEMA_SQL, SQLITE_SCHEMA_TABLES as BASELINE_SCHEMA_TABLES } f
 import { migrateTaskMainWorkspaces } from "./upgrade/taskMainWorkspaceMigration.js";
 import { migrateProjectKnowledge } from "./upgrade/projectKnowledgeMigration.js";
 import { JOB_SCHEMA_SQL } from "./jobSchema.js";
+import { AGENT_JOB_SCHEMA_SQL } from "./agentJobSchema.js";
 import { SCHEDULE_SCHEMA_SQL } from "./scheduleSchema.js";
+import { GLOBAL_SESSION_TABLE_SQL, SESSION_HISTORY_UPGRADE_SQL } from "./sessionHistorySchema.js";
 import { migrateJobDefinitions } from "./upgrade/jobDefinitionMigration.js";
+import { migrateJobBusinessResults } from "./upgrade/jobBusinessResultMigration.js";
+import { migrateScheduleDispatch } from "./upgrade/scheduleDispatchMigration.js";
 import { CURRENT_STORAGE_VERSION, MIN_SUPPORTED_STORAGE_VERSION, STORAGE_FORMAT, isMinorStorageUpgrade, isStorageVersion, storageVersionParts } from "./storageVersions.js";
 export { BASELINE_SCHEMA_SQL };
-export const SQLITE_SCHEMA_TABLES = [...BASELINE_SCHEMA_TABLES, "job_definitions", "global_job_runs", "schedules"];
+export const SQLITE_SCHEMA_TABLES = [...BASELINE_SCHEMA_TABLES, "job_definitions", "global_job_runs", "schedules", "agent_job_runs"];
 export const TELEMETRY_KEEP_PER_RUN = 200;
 export const TELEMETRY_RUN_CAP = 50_000;
 export const BASELINE_SCHEMA_CHECKSUM = createHash("sha256").update(BASELINE_SCHEMA_SQL).digest("hex");
 export const JOB_SCHEMA_CHECKSUM = createHash("sha256").update(BASELINE_SCHEMA_SQL + JOB_SCHEMA_SQL).digest("hex");
-export const CURRENT_SCHEMA_SQL = BASELINE_SCHEMA_SQL + JOB_SCHEMA_SQL + SCHEDULE_SCHEMA_SQL;
+export const SCHEDULE_SCHEMA_SQL_COMPLETE = BASELINE_SCHEMA_SQL + JOB_SCHEMA_SQL + SCHEDULE_SCHEMA_SQL;
+export const SCHEDULE_SCHEMA_CHECKSUM = createHash("sha256").update(SCHEDULE_SCHEMA_SQL_COMPLETE).digest("hex");
+// Fresh Homes create the final layout directly; published baseline SQL stays immutable.
+const SESSION_SCHEMA_SQL = SCHEDULE_SCHEMA_SQL_COMPLETE.replace(/CREATE TABLE global_role_session_sets \([\s\S]*?\n\);/, GLOBAL_SESSION_TABLE_SQL);
+const SESSION_SCHEMA_CHECKSUM = createHash("sha256").update(SESSION_SCHEMA_SQL).digest("hex");
+export const CURRENT_SCHEMA_SQL = SESSION_SCHEMA_SQL + AGENT_JOB_SCHEMA_SQL;
 export const CURRENT_SCHEMA_CHECKSUM = createHash("sha256").update(CURRENT_SCHEMA_SQL).digest("hex");
 export class SqliteSchemaError extends Error {
     code;
@@ -118,15 +127,15 @@ const MINOR_UPGRADES = Object.freeze([{
         name: "persistent-schedules",
         introducedIn: "next",
         sourceChecksum: JOB_SCHEMA_CHECKSUM,
-        targetChecksum: CURRENT_SCHEMA_CHECKSUM,
+        targetChecksum: SCHEDULE_SCHEMA_CHECKSUM,
         sql: SCHEDULE_SCHEMA_SQL
     }, {
         fromVersion: "1.10",
         toVersion: "1.11",
         name: "activation-input-provenance",
         introducedIn: "next",
-        sourceChecksum: CURRENT_SCHEMA_CHECKSUM,
-        targetChecksum: CURRENT_SCHEMA_CHECKSUM,
+        sourceChecksum: SCHEDULE_SCHEMA_CHECKSUM,
+        targetChecksum: SCHEDULE_SCHEMA_CHECKSUM,
         // Activation event payloads may now name an exact input or contain attributed
         // native input text. Existing events remain immutable; missing old provenance
         // stays explicitly missing. No historical source is guessed from timestamps.
@@ -138,8 +147,8 @@ const MINOR_UPGRADES = Object.freeze([{
         toVersion: "1.12",
         name: "project-delivery-scope",
         introducedIn: "next",
-        sourceChecksum: CURRENT_SCHEMA_CHECKSUM,
-        targetChecksum: CURRENT_SCHEMA_CHECKSUM,
+        sourceChecksum: SCHEDULE_SCHEMA_CHECKSUM,
+        targetChecksum: SCHEDULE_SCHEMA_CHECKSUM,
         // New append-only Project scope decisions use Task events. Preserve all old
         // completion, binding and publication records; absence still means required.
         sql: ""
@@ -148,12 +157,82 @@ const MINOR_UPGRADES = Object.freeze([{
         toVersion: "1.13",
         name: "inbox-turn-handling",
         introducedIn: "next",
-        sourceChecksum: CURRENT_SCHEMA_CHECKSUM,
-        targetChecksum: CURRENT_SCHEMA_CHECKSUM,
+        sourceChecksum: SCHEDULE_SCHEMA_CHECKSUM,
+        targetChecksum: SCHEDULE_SCHEMA_CHECKSUM,
         // Claims may name their exact current attempt; explicit Global retirement
         // and terminal-check notices preserve original records. Never backfill
         // historical turn ownership, handling evidence or acknowledgements.
         sql: ""
+    }, {
+        fromVersion: "1.13",
+        toVersion: "1.14",
+        name: "retained-session-identity",
+        introducedIn: "next",
+        sourceChecksum: SCHEDULE_SCHEMA_CHECKSUM,
+        targetChecksum: SESSION_SCHEMA_CHECKSUM,
+        // Preserve every payload byte. No identity or authorization is inferred.
+        sql: SESSION_HISTORY_UPGRADE_SQL
+    }, {
+        fromVersion: "1.14",
+        toVersion: "1.15",
+        name: "job-business-results",
+        introducedIn: "next",
+        sourceChecksum: SESSION_SCHEMA_CHECKSUM,
+        targetChecksum: SESSION_SCHEMA_CHECKSUM,
+        sql: "",
+        dataMigration: "job-business-results"
+    }, {
+        fromVersion: "1.15",
+        toVersion: "1.16",
+        name: "schedule-dispatch",
+        introducedIn: "next",
+        sourceChecksum: SESSION_SCHEMA_CHECKSUM,
+        targetChecksum: SESSION_SCHEMA_CHECKSUM,
+        sql: "",
+        dataMigration: "schedule-dispatch"
+    }, {
+        fromVersion: "1.16",
+        toVersion: "1.17",
+        name: "job-owned-artifacts",
+        introducedIn: "next",
+        sourceChecksum: SESSION_SCHEMA_CHECKSUM,
+        targetChecksum: SESSION_SCHEMA_CHECKSUM,
+        // New optional append-only Run artifact references and Home-owned per-Run
+        // repositories. Existing payloads, Task repositories and frozen Git refs are
+        // unchanged. No files are moved and no historical provenance is invented.
+        sql: ""
+    }, {
+        fromVersion: "1.17",
+        toVersion: "1.18",
+        name: "builtin-project-sync",
+        introducedIn: "next",
+        sourceChecksum: SESSION_SCHEMA_CHECKSUM,
+        targetChecksum: SESSION_SCHEMA_CHECKSUM,
+        // Additive installer provenance, explicit compiled service issuer and user
+        // intent on new definitions/plans. Do not adopt or rewrite historical Jobs,
+        // grants, time overrides or Runs. Installation is a separate runtime action.
+        sql: ""
+    }, {
+        fromVersion: "1.18",
+        toVersion: "1.19",
+        name: "job-task-delegation",
+        introducedIn: "next",
+        sourceChecksum: SESSION_SCHEMA_CHECKSUM,
+        targetChecksum: SESSION_SCHEMA_CHECKSUM,
+        // Optional immutable Task creation source and Run delegation. Existing
+        // ordinary Tasks retain absence of source; all historical payload bytes,
+        // references and unknown effects remain unchanged.
+        sql: ""
+    }, {
+        fromVersion: "1.19",
+        toVersion: "1.20",
+        name: "job-agent-execution",
+        introducedIn: "next",
+        sourceChecksum: SESSION_SCHEMA_CHECKSUM,
+        targetChecksum: CURRENT_SCHEMA_CHECKSUM,
+        // Existing records and immutable artifacts remain byte-for-byte unchanged.
+        // Declares Agent definitions/Runs and optional Job ownership of a non-Task Role.
+        sql: AGENT_JOB_SCHEMA_SQL
     }]);
 export function storageMinorUpgradePlan(from) {
     if (from === CURRENT_STORAGE_VERSION)
@@ -183,8 +262,10 @@ export function validateSqliteSchemaObjects(db, version = CURRENT_STORAGE_VERSIO
     const checksum = version === CURRENT_STORAGE_VERSION
         ? CURRENT_SCHEMA_CHECKSUM : storageMinorUpgradePlan(version)?.[0]?.sourceChecksum;
     const sql = checksum === CURRENT_SCHEMA_CHECKSUM ? CURRENT_SCHEMA_SQL
-        : checksum === JOB_SCHEMA_CHECKSUM ? BASELINE_SCHEMA_SQL + JOB_SCHEMA_SQL
-            : checksum === BASELINE_SCHEMA_CHECKSUM ? BASELINE_SCHEMA_SQL : undefined;
+        : checksum === SESSION_SCHEMA_CHECKSUM ? SESSION_SCHEMA_SQL
+            : checksum === SCHEDULE_SCHEMA_CHECKSUM ? SCHEDULE_SCHEMA_SQL_COMPLETE
+                : checksum === JOB_SCHEMA_CHECKSUM ? BASELINE_SCHEMA_SQL + JOB_SCHEMA_SQL
+                    : checksum === BASELINE_SCHEMA_CHECKSUM ? BASELINE_SCHEMA_SQL : undefined;
     if (sql === undefined || checksum === undefined)
         throw new SqliteSchemaError(`unsupported schema definition for storage ${version}.`);
     let expectedObjects = schemaObjectsByChecksum.get(checksum);
@@ -278,6 +359,10 @@ export function applySqliteMinorUpgrades(db, home, createdRoots = []) {
                 migrateProjectKnowledge(db);
             if (step.dataMigration === "job-definitions")
                 migrateJobDefinitions(db);
+            if (step.dataMigration === "job-business-results")
+                migrateJobBusinessResults(db);
+            if (step.dataMigration === "schedule-dispatch")
+                migrateScheduleDispatch(db);
             const { major, minor } = storageVersionParts(step.toVersion);
             db.prepare("UPDATE storage_schema SET major=?,minor=?,checksum=? WHERE id=1")
                 .run(major, minor, step.targetChecksum);

package/dist/storage/sqliteStore.js

@@ -1,3 +1,4 @@
+import { validateAgentJobRun, assertAgentJobRunTransition } from "../job/agentJob.js";
 /**
  * SQLite WAL Store (task-21, work-item-3).
  *
@@ -33,6 +34,7 @@
  * in-process contract or deferred validation phase.
  */
 import Database from "../sqlite/driver.js";
+import { findNativeSessionSets } from "./nativeSessionLookup.js";
 import { existsSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { isDeepStrictEqual } from "node:util";
@@ -929,7 +931,9 @@ export class SqliteTaskStore {
                 this.#saveRuntimeSessionCandidate(sessions);
             }
             else {
-                this.#db.prepare("DELETE FROM global_role_session_sets WHERE name = ?").run(role.name);
+                if (this.getGlobalRoleSessionSet(role.name) !== null) {
+                    throw new Error("Cannot discard recorded Session identity/history while saving a Role.");
+                }
                 this.#deleteRuntimeSessionCandidate({ scope: "global", roleName: role.name });
             }
         });
@@ -948,8 +952,13 @@ export class SqliteTaskStore {
     }
     removeGlobalRole(name) {
         return this.#mutate(() => {
+            const sessions = this.getGlobalRoleSessionSet(name);
+            if (Object.values(sessions?.sessions ?? {}).some(session => session.status === "active")) {
+                throw new Error("Stop the Role's native Sessions before removing it.");
+            }
             this.#deleteRuntimeSessionCandidate({ scope: "global", roleName: name });
-            this.#db.prepare("DELETE FROM global_role_session_sets WHERE name = ?").run(name);
+            // Removal requires stopped Sessions at the domain boundary. Retain their
+            // canonical identity evidence so native-only callers never become public.
             return this.#db.prepare("DELETE FROM global_roles WHERE name = ?").run(name).changes > 0;
         });
     }
@@ -1071,6 +1080,10 @@ export class SqliteTaskStore {
             throw new StorageRecordError("Task id is required.");
         }
         this.#mutate(() => {
+            const previous = this.getTask(task.id);
+            if (previous !== null && !isDeepStrictEqual(previous.source, task.source)) {
+                throw new StorageRecordError("Task source is immutable after creation.");
+            }
             const schedules = this.listSchedules({ kind: "task", taskId: task.id });
             if (task.status === "completed" && schedules.some(s => s.rule.kind === "once"
                 && (s.state === "enabled" || s.state === "needs-attention"))) {
@@ -1109,6 +1122,18 @@ export class SqliteTaskStore {
         const tasks = this.#listPayload("task_records", "1=1", []);
         return this.#sortById(tasks, (task) => task.id);
     }
+    listTaskDelegations(taskId) {
+        const rows = this.#db.prepare(`SELECT task_id AS scope, job_id AS id, payload FROM durable_jobs
+      WHERE json_extract(payload,'$.delegation.taskId') = ?
+      UNION ALL SELECT 'global' AS scope, run_id AS id, payload FROM global_job_runs
+      WHERE json_extract(payload,'$.delegation.taskId') = ? LIMIT 101`).all(taskId, taskId);
+        return { complete: rows.length <= 100, items: rows.slice(0, 100).map(row => {
+                const run = JSON.parse(row.payload);
+                return { sourceRun: { scope: row.scope === "global" ? { kind: "global" }
+                            : { kind: "task", taskId: row.scope }, runId: row.id },
+                    jobId: run.definitionId, delegation: run.delegation, status: run.status };
+            }) };
+    }
     queryTaskCatalog(query) {
         return queryTaskCatalog(this.#db, query);
     }
@@ -1167,6 +1192,7 @@ export class SqliteTaskStore {
         return {
             ...base,
             pendingUserMessages: pendingCompletionMessages(this, taskId),
+            agentJobs: this.listAgentJobRuns({ kind: "task", taskId }),
             managedWorkspaces: this.#sortById(this.#listPayload("managed_workspaces", "task_id = ?", [taskId]), (workspace) => managedWorkspaceKey(workspace.owner)),
             durableJobs: this.#sortById(this.#listPayload("durable_jobs", "task_id = ?", [taskId]), (job) => job.id),
         };
@@ -1324,6 +1350,41 @@ export class SqliteTaskStore {
                 .run(run.id, this.#recordJson("global_job_runs", run), run.status);
         });
     }
+    saveAgentJobRun(run) {
+        validateAgentJobRun(run);
+        if (run.scope.kind === "task")
+            this.#requireTask(run.scope.taskId);
+        this.#mutate(() => {
+            const previous = this.getAgentJobRun(run.id);
+            if (previous)
+                assertAgentJobRunTransition(previous, run);
+            this.#db.prepare(`INSERT INTO agent_job_runs VALUES(?,?,?,?)
+        ON CONFLICT(run_id) DO UPDATE SET payload=excluded.payload`)
+                .run(run.id, jobScopeKey(run.scope), run.definitionId, this.#recordJson("agent_job_runs", run));
+            if (run.scope.kind === "task" && (!previous || previous.status !== run.status
+                || !isDeepStrictEqual(previous.businessResult, run.businessResult) || previous.cancelRequestedAt !== run.cancelRequestedAt)) {
+                const taskId = run.scope.taskId;
+                this.saveEvent(taskId, createTaskEvent(this.nextEventId(taskId), taskId, "job.state-changed", {
+                    jobId: run.id, status: run.status,
+                    ...(previous ? { previousStatus: previous.status } : {}),
+                    ...(run.cancelRequestedAt ? { cancelRequestedAt: run.cancelRequestedAt } : {})
+                }, new Date(run.updatedAt)));
+            }
+        });
+    }
+    getAgentJobRun(id) {
+        return this.#getPayload("agent_job_runs", "run_id=?", [id]);
+    }
+    listAgentJobRuns(scope, definitionId) {
+        return this.#listPayload("agent_job_runs", definitionId === undefined ? "scope_key=?" : "scope_key=? AND definition_id=?", definitionId === undefined ? [jobScopeKey(scope)] : [jobScopeKey(scope), definitionId]);
+    }
+    listAgentJobRunsForRole(recipient) {
+        return this.#listPayload("agent_job_runs", `json_extract(payload,'$.attempts[#-1].recipient.scope')=?
+       AND json_extract(payload,'$.attempts[#-1].recipient.roleName')=?
+       AND COALESCE(json_extract(payload,'$.attempts[#-1].recipient.taskId'),'')=?
+       AND (json_extract(payload,'$.attempts[#-1].terminal') IS NULL
+         OR json_extract(payload,'$.businessResult') IS NULL)`, [recipient.scope, recipient.roleName, recipient.scope === "task" ? recipient.taskId : ""]);
+    }
     getGlobalJobRun(id) {
         return this.#getPayload("global_job_runs", "run_id=?", [id]);
     }
@@ -1449,13 +1510,16 @@ export class SqliteTaskStore {
     }
     removeTaskRole(taskId, name) {
         return this.#mutate(() => {
+            const sessions = this.getTaskRoleSessionSet(taskId, name);
+            if (Object.values(sessions?.sessions ?? {}).some(session => session.status === "active")) {
+                throw new Error("Stop the Role's native Sessions before removing it.");
+            }
             this.#deleteRuntimeSessionCandidate({
                 scope: "task",
                 taskId,
                 roleName: name
             });
-            this.#db.prepare("DELETE FROM role_session_sets WHERE task_id = ? AND role_name = ?").run(taskId, name);
-            this.#db.prepare("DELETE FROM pending_runtime_turn_completions WHERE task_id = ? AND role_name = ?").run(taskId, name);
+            // Role deletion removes authority, not stopped Session identity/history.
             const result = this.#db.prepare("DELETE FROM task_roles WHERE task_id = ? AND role_name = ?").run(taskId, name);
             return result.changes > 0;
         });
@@ -1517,6 +1581,9 @@ export class SqliteTaskStore {
             ...this.#listPayload("global_role_session_sets", pending, [])
         ];
     }
+    findNativeSessionSets(nativeIds) {
+        return findNativeSessionSets(this.#db, nativeIds);
+    }
     listRuntimeSessionCandidates(query = {}) {
         const taskIds = query.taskIds === undefined
             ? undefined

package/dist/storage/storageVersions.js

@@ -1,4 +1,4 @@
-export const CURRENT_STORAGE_VERSION = "1.13";
+export const CURRENT_STORAGE_VERSION = "1.20";
 export const MIN_SUPPORTED_STORAGE_VERSION = "1.0";
 export const STORAGE_FORMAT = "yui-home";
 export function isStorageVersion(value) {

package/dist/storage/storeRpc.js

@@ -73,6 +73,9 @@ const READ_ONLY_STORE_METHODS = new Set([
     "getJobDefinition",
     "listJobDefinitions",
     "getGlobalJobRun",
+    "getAgentJobRun",
+    "listAgentJobRuns",
+    "listAgentJobRunsForRole",
     "listGlobalJobRuns",
     "listActiveGlobalJobRuns",
     "listRoles",
@@ -89,6 +92,7 @@ const READ_ONLY_STORE_METHODS = new Set([
     "listRoleSessionSets",
     "listProviderRetrySessions",
     "listRuntimeSessionCandidates",
+    "findNativeSessionSets",
     "getRoleSession",
     "getWorkItem",
     "listWorkItems",

package/dist/storage/taskCatalog.js

@@ -21,6 +21,10 @@ export function queryTaskCatalog(db, query) {
         match.push("status = @status");
         params.status = query.status;
     }
+    if (query.source !== undefined) {
+        match.push(`EXISTS (SELECT 1 FROM task_records r WHERE r.task_id = facts.id AND
+      json_extract(r.payload, '$.source.kind') ${query.source === "job" ? "= 'job-run'" : "IS NULL"})`);
+    }
     if (query.project !== undefined) {
         match.push(`EXISTS (SELECT 1 FROM task_records r, json_each(r.payload, '$.projectBindings') p
       WHERE r.task_id = facts.id AND json_extract(p.value, '$.projectId') = @project)`);
@@ -57,6 +61,10 @@ export function queryTaskCatalog(db, query) {
         after.push("(createdAt, id) > (@afterDate, @afterId)");
     }
     const count = (table, condition) => `(SELECT count(*) FROM ${table} x WHERE x.task_id = c.task_id AND (${condition}))`;
+    const incoming = (statuses) => `(SELECT count(*) FROM global_job_runs x
+    WHERE json_extract(x.payload,'$.delegation.taskId') = c.task_id AND x.status IN (${statuses}))
+    + (SELECT count(*) FROM durable_jobs x WHERE x.task_id <> c.task_id
+      AND json_extract(x.payload,'$.delegation.taskId') = c.task_id AND x.status IN (${statuses}))`;
     const displaySummary = `CASE
     WHEN page.status IN ('completed','archived')
       AND json_extract(r.payload,'$.completionSummary') IS NOT NULL
@@ -76,8 +84,8 @@ export function queryTaskCatalog(db, query) {
       ${count("work_items", "1=1")} AS workItems,
       ${count("turns", "status = 'active'")} AS activeRuns,
       ${count("input_requests", "status = 'open'")} AS openInputs,
-      ${count("durable_jobs", "status IN ('queued','running')")} AS pendingOperations,
-      ${count("durable_jobs", "status = 'unknown-needs-attention'")} AS unknownOperations,
+      ${count("durable_jobs", "status IN ('queued','running')")} + ${incoming("'queued','running'")} AS pendingOperations,
+      ${count("durable_jobs", "status = 'unknown-needs-attention'")} + ${incoming("'unknown-needs-attention'")} AS unknownOperations,
       CASE WHEN c.status IN ('active','draft') THEN
         ${count("turns", "status = 'active'")} +
         ${count("work_items", "status = 'open' OR (status = 'accepted' AND json_extract(payload, '$.currentExecutionGroupId') IS NOT NULL)")} +

package/dist/storage/upgrade/jobBusinessResultMigration.js

@@ -0,0 +1,20 @@
+import { processBusinessResult } from "../../job/jobBusinessResult.js";
+import { validateDurableJob } from "../../job/durableJob.js";
+/** Preserve raw history and derive only what each original result actually proves. */
+export function migrateJobBusinessResults(db) {
+    for (const table of ["durable_jobs", "global_job_runs"]) {
+        const rows = db.prepare(`SELECT rowid, payload FROM ${table}`).all();
+        for (const row of rows) {
+            const run = JSON.parse(row.payload);
+            if (run.businessResult !== undefined)
+                throw new Error("Unexpected business result in storage 1.14.");
+            validateDurableJob(run);
+            if (!run.result)
+                continue;
+            const migrated = validateDurableJob({ ...run, businessResult: processBusinessResult(run, run.result) });
+            db.prepare("INSERT INTO storage_migration_archive(migration_version,family,record_key,payload) VALUES(?,?,?,?)")
+                .run(15, table, `${"taskId" in run ? run.taskId : "global"}/${run.id}`, row.payload);
+            db.prepare(`UPDATE ${table} SET payload=? WHERE rowid=?`).run(JSON.stringify(migrated), row.rowid);
+        }
+    }
+}

package/dist/storage/upgrade/scheduleDispatchMigration.js

@@ -0,0 +1,15 @@
+import { validateSchedule } from "../../schedule/schedule.js";
+/** Keep valid historical Session authority; never infer a service grant. */
+export function migrateScheduleDispatch(db) {
+    const rows = db.prepare("SELECT rowid,scope_key,schedule_id,payload FROM schedules").all();
+    for (const row of rows) {
+        const old = JSON.parse(row.payload);
+        if (old.target !== undefined || old.authorization?.kind !== undefined)
+            throw new Error("Unexpected Schedule shape in storage 1.15.");
+        const next = validateSchedule({ ...old, target: { kind: "existing-job" },
+            authorization: { ...old.authorization, kind: "session" } });
+        db.prepare("INSERT INTO storage_migration_archive(migration_version,family,record_key,payload) VALUES(?,?,?,?)")
+            .run(16, "schedules", `${row.scope_key}/${row.schedule_id}`, row.payload);
+        db.prepare("UPDATE schedules SET payload=? WHERE rowid=?").run(JSON.stringify(next), row.rowid);
+    }
+}

package/dist/task/archivePreflight.js

@@ -23,6 +23,9 @@ export function archiveSettlementChecks(store, task) {
     for (const job of store.listDurableJobs(task.id).filter(j => ["queued", "running"].includes(j.status) || (j.status === "unknown-needs-attention" && j.acknowledgedAt === undefined))) {
         add(`job:${task.id}/${job.id}`, "active-durable-job", "Task has an active or unacknowledged DurableJob.", "settled job", job.status, `yui job get --task ${task.id} --job ${job.id}`);
     }
+    for (const job of store.listAgentJobRuns({ kind: "task", taskId: task.id }).filter(run => !run.businessResult)) {
+        add(`job:${task.id}/${job.id}`, "active-durable-job", "Agent JobRun has no explicit business result.", "settled job", job.status, `yui job run-context --task ${task.id} --job ${job.definitionId} --run ${job.id}`);
+    }
     return checks;
 }
 /** Unknown execution is never permission to remove workspaces, even after
@@ -40,6 +43,18 @@ export function archiveExecutionChecks(store, taskId, home, phase = "before-remo
         if (blocker !== undefined)
             add(`job:${taskId}/${job.id}`, "unresolved-execution", blocker, job.status, `yui job get --task ${taskId} --job ${job.id}`);
     }
+    for (const job of store.listAgentJobRuns({ kind: "task", taskId })) {
+        const last = job.attempts.at(-1);
+        if (!last.terminal)
+            add(`job:${taskId}/${job.id}`, "unresolved-execution", "Agent Job input has no exact native terminal; business reporting alone is not quiescence.", job.status, `yui job run-evidence --task ${taskId} --job ${job.definitionId} --run ${job.id}`);
+    }
+    for (const role of store.listGlobalRoles().filter(role => role.jobOwner?.scope.kind === "task" && role.jobOwner.scope.taskId === taskId)) {
+        const binding = store.getGlobalRoleSessionSet(role.name)?.providerBinding;
+        if (binding?.run && !["completed", "failed", "cancelled", "rejected"].includes(binding.run.status)
+            || hasRuntimeLifecycleWork(store.getWorkMailbox(runtimeLifecycleTarget({ scope: "global", roleName: role.name })))) {
+            add(`global-role:${role.name}`, "unresolved-provider-input", "Task-owned Job Role retains an unresolved input or lifecycle operation.", binding?.run?.status ?? "lifecycle pending", `yui job session-inspect --task ${taskId} --job ${role.jobOwner.jobId}`);
+        }
+    }
     for (const role of store.listRoles(taskId)) {
         const resource = `role:${taskId}/${role.name}`;
         const action = `yui task role session inspect ${taskId} ${role.name}`;

package/dist/task/completionReadiness.js

@@ -81,6 +81,13 @@ export function projectCompletionReadiness(facts) {
         });
     }
     // Active DurableJobs (integration checks, etc.) must settle.
+    for (const job of facts.agentJobs ?? []) {
+        if (job.businessResult)
+            continue;
+        blockers.push({ code: "active-durable-job", ref: ref("durable-job", job.id),
+            reason: `Agent JobRun ${job.id} has no explicit business result.`,
+            fix: `inspect yui job run-context --task ${facts.task.id} --job ${job.definitionId} --run ${job.id}; settle its original input without replay` });
+    }
     for (const job of facts.durableJobs) {
         if (!ACTIVE_JOB_STATUSES.has(job.status))
             continue;

package/dist/task/task.js

@@ -400,7 +400,7 @@ export function validateTask(task) {
     if (task.schemaVersion !== 1)
         throw new Error("Task must use schemaVersion 1.");
     const fields = [
-        "schemaVersion", "id", "title", "type", "description", "priority", "tags", "dueAt",
+        "schemaVersion", "source", "id", "title", "type", "description", "priority", "tags", "dueAt",
         "projectBindings", "cwd", "workspaceIdentity", "status", "executionGate", "activationRequest",
         "settledActivationRequests", "completedAt", "completedBy", "completionSummary", "completionArtifactRefs",
         "retiredAt", "retiredBy", "retirementSummary", "retirementIsolation", "replacementTaskId",
@@ -411,6 +411,22 @@ export function validateTask(task) {
             throw new Error(`Task contains an unsupported field: ${field}.`);
     }
     requireSafeIdentity(task.id, "Task id");
+    if (task.source !== undefined) {
+        const source = task.source;
+        if (source.kind !== "job-run" || Object.keys(source).some(key => !["kind", "jobId", "run"].includes(key))) {
+            throw new Error("Invalid Task source.");
+        }
+        requireSafeIdentity(source.jobId, "Source Job id");
+        requireSafeIdentity(source.run.runId, "Source Run id");
+        if (Object.keys(source.run).some(key => !["scope", "runId"].includes(key))
+            || Object.keys(source.run.scope).some(key => !["kind", "taskId"].includes(key))
+            || !["global", "task"].includes(source.run.scope.kind))
+            throw new Error("Invalid Task source Run.");
+        if (source.run.scope.kind === "task")
+            requireSafeIdentity(source.run.scope.taskId, "Source Task id");
+        else if ("taskId" in source.run.scope)
+            throw new Error("Global source cannot name a Task.");
+    }
     requireText(task.title, "Task title");
     if (task.type !== undefined)
         requireSafeIdentity(task.type, "Task type");