@capybara-hq/kernel 0.1.0-rc.21 → 0.1.0-rc.22

package/dist/runtime/run-worker.js

@@ -23,7 +23,7 @@ import { TransactionHost } from "../infra/database/transaction-host.js";
 import { Transactional } from "../infra/database/transactional.decorator.js";
 import { KernelEvents } from "../infra/events/kernel-events.js";
 import { KERNEL_BUS, KERNEL_LOGGER } from "../infra/tokens.js";
-import { pinnedFailureText, SkillsCatalogService } from "../skills/catalog.js";
+import { SkillsCatalogService } from "../skills/catalog.js";
 import { normalizeStoredDefinitionIn } from "../tools/legacy-data.js";
 import { ToolPipeline } from "../tools/pipeline.js";
 import { RunAbort } from "./abort.js";
@@ -597,37 +597,13 @@ let RunWorker = class RunWorker {
                     await this.eventLog.notify(conversationId, toSeq);
             }
             // 技能目录快照（Ruling M17）：在置为 running 之前写，崩溃重试时仍走这里（幂等键去重）
-            try {
-                await this.skillsCatalog.record({
-                    orgId: conv.org_id,
-                    agentId: conv.agent_id,
-                    conversationId,
-                    runId,
-                    agent,
-                }, { log: this.log });
-            }
-            catch (e) {
-                // Pinned skill bodies could not be read (Decision 9), or the pinned skills kept changing
-                // while they were read (`conflict`): fail before any model request. A transient failure
-                // or a conflict is fixed by sending again; a permanent one names the skill for the owner
-                // (`SkillsCatalogService.record` already logged it at error). Other errors take the generic path.
-                if (!(e instanceof ApiError) ||
-                    (e.code !== "storage.unavailable" && e.code !== "conflict")) {
-                    throw e;
-                }
-                this.log.warn("skills catalog not recorded at run start", {
-                    conversationId,
-                    runId,
-                    code: e.code,
-                    err: e,
-                });
-                const message = e.code === "conflict" ? e.message : pinnedFailureText(e);
-                await this.finish(conversationId, runId, "failed", null, {
-                    type: "run_failed",
-                    payload: { error: { code: e.code, message } },
-                });
-                return "finished";
-            }
+            await this.skillsCatalog.record({
+                orgId: conv.org_id,
+                agentId: conv.agent_id,
+                conversationId,
+                runId,
+                agent,
+            }, { log: this.log });
             // run context (spec §5): after the catalog, before the run is running, so before any
             // compaction and model call; a retried run start finds its event or no change
             await this.runContext.record({
@@ -861,7 +837,7 @@ let RunWorker = class RunWorker {
         // delivery (agent map spec §5.3), not a message
         const boundary = await t
             .selectFrom("conversation_events")
-            .select("type")
+            .select(["type", "payload"])
             .where("conversation_id", "=", conversationId)
             .where("seq", "=", run.trigger_seq)
             .executeTakeFirst();
@@ -882,6 +858,11 @@ let RunWorker = class RunWorker {
                         trigger: "subagent",
                         triggerSeq: Number(run.trigger_seq),
                     }),
+                    // a scheduled task's message (scheduled tasks spec §6); display only
+                    ...(boundary?.type === "user_message" &&
+                        boundary.payload.schedule !== undefined && {
+                        trigger: "schedule",
+                    }),
                 },
             },
         ]);

package/dist/runtime/runtime.module.js

@@ -16,6 +16,7 @@ import { IdentityModule } from "../identity/identity.module.js";
 import { LockService } from "../infra/lock/lock.service.js";
 import { QueueModule } from "../infra/queue/queue.module.js";
 import { REDIS } from "../infra/tokens.js";
+import { ScheduledTaskTrackerModule } from "../schedules/run-tracker.js";
 import { SkillsModule } from "../skills/skills.module.js";
 import { ToolsModule } from "../tools/tools.module.js";
 import { RunAbort } from "./abort.js";
@@ -64,6 +65,8 @@ RuntimeModule = __decorate([
             TitlesModule,
             StepLogModule,
             BackgroundModule,
+            // a scheduled task's run follows its kernel run's end (`RunFinish`)
+            ScheduledTaskTrackerModule,
             // the producer side of `wait-timeout` jobs (`MaintenanceProcessor` consumes them)
             QueueModule.registerQueue(MAINTENANCE_QUEUE_NAME),
         ],

package/dist/runtime/subagents/definition.d.ts

@@ -1,6 +1,6 @@
 import { type AgentTemplateTier } from "@capybara-hq/plugin-sdk";
-import { type AgentDefinition, type DisabledToolRef, type ModelRef } from "../../agents/definition.js";
-import type { EventPayload } from "../../conversations/events.js";
+import { type AgentDefinition, DisabledSkillRef, type DisabledToolRef, type ModelRef } from "../../agents/definition.js";
+import { type EventPayload } from "../../conversations/events.js";
 import type { KernelSchemaDb } from "../../db/kernel-schema.js";
 import type { KernelConfigService } from "../../infra/config/kernel-config.service.js";
 import type { ModelPurposesService } from "../../models/purposes.js";
@@ -21,7 +21,15 @@ export interface EffectiveDefinition {
     definition: AgentDefinition;
     template: EventPayload<"subagent_started">["template"];
     maxSteps: number;
-    /** Dispatch warnings (pinned skills dropped), recorded in `subagent_started.warnings`. */
+    /**
+     * The child's preamble, frozen into `subagent_started.preamble` (model-visible):
+     * {@link SUBAGENT_PREAMBLE}, plus the line naming the template's skills to load first.
+     */
+    preamble: string;
+    /**
+     * Dispatch warnings (a template skill the child does not have), recorded in
+     * `subagent_started.warnings`.
+     */
     warnings: string[];
 }
 export interface EffectiveDefinitionDeps {
@@ -38,6 +46,15 @@ type Policy = "ask" | "deny";
  * `allow`, which the policy check reads from the agent's current version) are skipped on both sides.
  */
 export declare function stricterPolicies(base: Record<string, string>, over: Record<string, string>): Record<string, Policy>;
+/**
+ * A template's `disallowedSkills` as `disabledSkills` entries (skills default-on spec §6.1, §6.2):
+ * `<plugin>:*` turns the whole plugin off, `<plugin>:<name>` one of its skills, and a bare `<name>`
+ * the org's usable skills of that name without a plugin (by id). A bare name the org does not have
+ * and an entry that is no valid reference (stored template data is not re-validated) are dropped.
+ */
+export declare function disallowedSkillRefs(db: KernelSchemaDb, orgId: string, refs: readonly unknown[] | undefined): Promise<DisabledSkillRef[]>;
+/** The preamble line naming the skills a template child loads first (skills default-on §6.1). */
+export declare const loadSkillsFirstText: (names: readonly string[]) => string;
 /** An org agent's version and definition as checked by its gates. */
 export interface CheckedOrgAgent {
     version: number;
@@ -53,9 +70,9 @@ export interface ChildDepth {
 /**
  * The effective definition of a sub-agent at its first dispatch (spec §5.3–§5.5):
  * - `general` / `inline` / `plugin`: the parent's definition narrowed by the template (tools by
- *   resolved key, `disallowedTools`, {@link CHILD_REMOVED_TOOLS}; policies stricter-wins), the
- *   template's instructions, pinned = the template's skills the parent selects (general pins
- *   nothing), `maxSteps = min(template ?? runtime.maxSteps, runtime.maxSteps)`, and the model tier
+ *   resolved key, `disallowedTools`, {@link CHILD_REMOVED_TOOLS}; policies stricter-wins; skills
+ *   by its `disallowedSkills`), the template's instructions, its `skills` the child has named in
+ *   the preamble to load first (general gets no line), `maxSteps = min(template ?? runtime.maxSteps, runtime.maxSteps)`, and the model tier
  *   `tier` (the call's) → the template's → `inherit`; an unmapped tier runs on the parent's model
  *   (`tierFallback`); a template `effort` is set when the resolved model declares it;
  * - `agent`: the org agent's version that passed the gates (`orgAgent`, from {@link checkOrgAgent}),
@@ -79,13 +96,16 @@ export declare function effectiveDefinition(d: EffectiveDefinitionDeps, a: Child
 }>;
 /**
  * What a follow-up (`resume`) may still use (final review I1, spec §5.3): the frozen definition's
- * turned-off tools together with the current version's (it can lose tools, never gain them), and
- * the frozen org skills intersected with the current ones. Recorded on the follow-up's task message
- * (`user_message.dispatch.narrowed`), so the run and its replay read it from the log.
+ * turned-off tools and skills together with the current version's (it can lose tools and skills,
+ * never gain them). Recorded on the follow-up's task message (`user_message.dispatch.narrowed`), so
+ * the run and its replay read it from the log.
  */
 export interface FollowUpNarrowing {
     /** Absent in logs from before tools were on by default (no tool narrowing then). */
     disabledTools?: DisabledToolRef[] | undefined;
+    /** Absent in logs from before skills were on by default (skills default-on spec §6.1). */
+    disabledSkills?: DisabledSkillRef[] | undefined;
+    /** Older logs only: the frozen org skills intersected with the current ones. */
     skills?: {
         orgSkills: string[];
         pinned?: string[] | undefined;
@@ -96,13 +116,11 @@ export interface FollowUpNarrowing {
  * definition) against `current`, the definition a fresh dispatch would read now: the dispatching
  * parent run's version for `general` / inline / plugin children, the dispatched org agent's
  * current version for an org agent child (whose tools are its own at dispatch too, §5.5). Its
- * `disabledTools` are both lists together; its `orgSkills` keep only those `current` still
- * selects; a pinned id that was one of the frozen org skills goes with it (the agent's own skills
- * stay).
+ * `disabledTools` and `disabledSkills` are both lists together.
  */
-export declare function narrowFollowUp(frozen: Pick<AgentDefinition, "disabledTools" | "skills">, current: Pick<AgentDefinition, "disabledTools" | "skills">): FollowUpNarrowing;
+export declare function narrowFollowUp(frozen: Pick<AgentDefinition, "disabledTools" | "disabledSkills">, current: Pick<AgentDefinition, "disabledTools" | "disabledSkills">): FollowUpNarrowing;
 /**
  * The definition a child run uses: the frozen one with its trigger's follow-up narrowing. A
- * narrowing logged before tools were on by default (no `disabledTools`) narrows only skills.
+ * narrowing logged before tools (or skills) were on by default narrows nothing of that kind.
  */
 export declare function childRunDefinition(frozen: AgentDefinition, narrowed: FollowUpNarrowing | undefined): AgentDefinition;

package/dist/runtime/subagents/definition.js

@@ -1,10 +1,12 @@
-import { SKILL_ENTRY_FILE, sanitizeParams, } from "@capybara-hq/plugin-sdk";
-import { canonicalDisabledTools, } from "../../agents/definition.js";
+import { sanitizeParams, } from "@capybara-hq/plugin-sdk";
+import { canonicalDisabledSkills, canonicalDisabledTools, DisabledSkillRef, } from "../../agents/definition.js";
 import { loadTemplates } from "../../agents/templates.js";
+import { SKILLS_CATALOG_MAX } from "../../conversations/events.js";
 import { ApiError } from "../../errors.js";
-import { PINNED_SKILLS_LIMITS } from "../../skills/catalog.js";
-import { selectedSkills } from "../../skills/usable.js";
+import { invocationOf, resolveSkills } from "../../skills/catalog.js";
+import { agentSkills, usableSkills } from "../../skills/usable.js";
 import { AGENT_TOOL, CHILD_REMOVED_TOOLS } from "../../tools/builtin-names.js";
+import { SUBAGENT_PREAMBLE } from "./preamble.js";
 export { CHILD_REMOVED_TOOLS } from "../../tools/builtin-names.js";
 /**
  * The roster entry's template is gone (an inline template edited away, a plugin template
@@ -64,76 +66,81 @@ function childFilter(removeAgent, template, parent) {
     return { ...(allow !== undefined && { allow: [...allow] }), deny };
 }
 /**
- * The template's skills the parent selects (its `orgSkills` or the parent agent's own skills),
- * within the pinned limits (spec §5.3): inline templates name skill ids, plugin templates skill
- * names (`<name>` or `<plugin>:<name>`). A name that matches more than one selected skill picks, in
- * this order, the skill from the template's own plugin, the agent's own skill, the org skill (ties
- * by id), with a warning. Dropped ones get a warning.
+ * A template's `disallowedSkills` as `disabledSkills` entries (skills default-on spec §6.1, §6.2):
+ * `<plugin>:*` turns the whole plugin off, `<plugin>:<name>` one of its skills, and a bare `<name>`
+ * the org's usable skills of that name without a plugin (by id). A bare name the org does not have
+ * and an entry that is no valid reference (stored template data is not re-validated) are dropped.
  */
-async function pinnedFor(db, a, refs, byName, 
-/** Further names the template lists (`selectedSkills`): resolved the same way, never pinned. */
-selected = []) {
-    if (refs.length === 0 && selected.length === 0)
-        return { pinned: [], warnings: [] };
-    // org and agent skills, linked org copies and platform skills on in the org (phase 2), by id
-    const rows = (await selectedSkills(db, {
-        orgId: a.orgId,
-        agentId: a.parentAgentId,
-        orgSkills: a.parent.skills?.orgSkills ?? [],
-    })).map((r) => ({
-        id: r.id,
-        name: r.name,
-        scope: r.scope,
-        plugin: r.plugin,
-        bytes: r.manifest.files.find((f) => f.path === SKILL_ENTRY_FILE)?.size ?? 0,
-    }));
-    const pinned = [];
-    const warnings = [];
-    const own = byName?.plugin;
-    const rank = (r) => own !== undefined && r.plugin === own ? 0 : r.scope === "agent" ? 1 : 2;
-    const match = (ref) => {
-        if (byName === null)
-            return rows.find((r) => r.id === ref);
-        const i = ref.indexOf(":");
-        const found = i < 0
-            ? rows.filter((r) => r.name === ref)
-            : rows.filter((r) => r.name === ref.slice(i + 1) && r.plugin === ref.slice(0, i));
-        // rows are ordered by id, and the sort is stable: ties keep that order
-        const [first, ...rest] = found.sort((x, y) => rank(x) - rank(y));
-        if (first && rest.length > 0) {
-            const which = [`the one from the plugin ${own}`, "the agent's own skill", "the org skill"][rank(first)];
-            warnings.push(`The skill name "${ref}" matches more than one selected skill; ${which} was pinned.`);
-        }
-        return first;
-    };
-    let total = 0;
-    for (const ref of refs) {
-        const r = match(ref);
-        if (!r) {
-            warnings.push(`The skill "${ref}" was not pinned: the agent does not select it.`);
-            continue;
-        }
-        if (pinned.includes(r.id))
+export async function disallowedSkillRefs(db, orgId, refs) {
+    const out = [];
+    const bare = new Set();
+    for (const ref of refs ?? []) {
+        if (typeof ref !== "string")
             continue;
-        if (pinned.length >= PINNED_SKILLS_LIMITS.count) {
-            warnings.push(`The skill "${r.name}" was not pinned: at most 3 skills can be pinned.`);
+        const i = ref.indexOf(":");
+        if (i < 0) {
+            bare.add(ref);
             continue;
         }
-        if (total + r.bytes > PINNED_SKILLS_LIMITS.totalBytes) {
-            warnings.push(`The skill "${r.name}" was not pinned: pinned skills are limited to 32 KB in total.`);
-            continue;
+        const name = ref.slice(i + 1);
+        const entry = DisabledSkillRef.safeParse({
+            kind: "plugin",
+            plugin: ref.slice(0, i),
+            skills: name === "*" ? "all" : [name],
+        });
+        if (entry.success)
+            out.push(entry.data);
+    }
+    if (bare.size > 0) {
+        for (const s of await usableSkills(db, orgId)) {
+            if (s.plugin === null && bare.has(s.name))
+                out.push({ kind: "skill", skillId: s.id });
         }
-        total += r.bytes;
-        pinned.push(r.id);
     }
-    for (const ref of selected) {
-        if (refs.includes(ref))
-            continue;
-        if (!match(ref)) {
-            warnings.push(`The skill "${ref}" is not available: the agent does not select it.`);
+    return out;
+}
+/** The warning of a template skill the child does not have. */
+const skillNotLoadedText = (ref) => `The skill "${ref}" is not among the sub-agent's skills, so it is not asked to load it.`;
+/** The preamble line naming the skills a template child loads first (skills default-on §6.1). */
+export const loadSkillsFirstText = (names) => `Before you start, load these skills with Skill: ${names.join(", ")}.`;
+/**
+ * The template's `skills` the child has (skills default-on spec §6.1: they are no longer pinned),
+ * by the names its catalog lists them under, in the template's order: the catalog its first run
+ * records (the agent `agentId` with the child's `disabledSkills`, model-invocable skills only).
+ * Inline templates name skill ids (`byId`; a platform skill's id names its linked copy too), plugin
+ * templates names (`<name>`, or `<plugin>:<name>` when the catalog's skill of that name is from
+ * that plugin). The others become warnings.
+ */
+async function skillsToLoad(db, a, refs, byId) {
+    if (refs.length === 0)
+        return { names: [], warnings: [] };
+    const input = { orgId: a.orgId, agentId: a.agentId, disabledSkills: [...a.disabledSkills] };
+    const catalog = (await resolveSkills(db, { ...input, agent: input }))
+        .filter((r) => invocationOf(r.manifest).model)
+        .slice(0, SKILLS_CATALOG_MAX)
+        .map((r) => r.skill);
+    const rows = byId ? await agentSkills(db, input) : [];
+    const names = [];
+    const warnings = [];
+    for (const ref of refs) {
+        let found;
+        if (byId) {
+            const row = rows.find((r) => r.id === ref || r.platformSkillId === ref);
+            found = row && catalog.find((c) => c.id === row.id);
+        }
+        else {
+            const i = ref.indexOf(":");
+            found =
+                i < 0
+                    ? catalog.find((c) => c.name === ref)
+                    : catalog.find((c) => c.name === ref.slice(i + 1) && c.plugin === ref.slice(0, i));
         }
+        if (found === undefined)
+            warnings.push(skillNotLoadedText(ref));
+        else if (!names.includes(found.name))
+            names.push(found.name);
     }
-    return { pinned, warnings };
+    return { names, warnings };
 }
 /** The `effort` declaration of `model`, or null (or when the model cannot be resolved). */
 async function effortDecl(registry, orgId, model) {
@@ -187,7 +194,8 @@ function orgAgentDefinition(d, a) {
     // `subagent_started.definition` keeps its shape (spec 2026-11-04 §3.3); its own `subagents`
     // block stays: it is the roster the child dispatches from (agent map spec §4.1); pending
     // connectors are authoring data too (ruling P4-6)
-    const { skills, instructionFiles: _files, pendingConnectors: _pending, ...rest } = own;
+    // `skills.writePolicy` never reaches a child: it governs registration on the agent itself
+    const { skills: _skills, instructionFiles: _files, pendingConnectors: _pending, ...rest } = own;
     const { subagentTools: _filter, ...ownRest } = rest;
     const definition = {
         ...ownRest,
@@ -196,17 +204,14 @@ function orgAgentDefinition(d, a) {
         subagentTools: childFilter(atMaxDepth(a), null),
         // its policies, then the parent's on top, stricter wins (keys outside its tools are inert)
         toolPolicies: stricterPolicies(own.toolPolicies ?? {}, a.parent.toolPolicies ?? {}),
-        ...(skills !== undefined && {
-            skills: {
-                orgSkills: skills.orgSkills,
-                ...(skills.pinned !== undefined && { pinned: skills.pinned }),
-            },
-        }),
+        // its own skills: what it turns off (skills default-on spec §6.1)
+        disabledSkills: own.disabledSkills ?? [],
     };
     return {
         definition,
         template: { source: "agent", id: agentId, version: a.orgAgent.version },
         maxSteps: d.config.get().runtime.maxSteps,
+        preamble: SUBAGENT_PREAMBLE,
         warnings: [],
         model: own.model,
         tierFallback: false,
@@ -215,9 +220,9 @@ function orgAgentDefinition(d, a) {
 /**
  * The effective definition of a sub-agent at its first dispatch (spec §5.3–§5.5):
  * - `general` / `inline` / `plugin`: the parent's definition narrowed by the template (tools by
- *   resolved key, `disallowedTools`, {@link CHILD_REMOVED_TOOLS}; policies stricter-wins), the
- *   template's instructions, pinned = the template's skills the parent selects (general pins
- *   nothing), `maxSteps = min(template ?? runtime.maxSteps, runtime.maxSteps)`, and the model tier
+ *   resolved key, `disallowedTools`, {@link CHILD_REMOVED_TOOLS}; policies stricter-wins; skills
+ *   by its `disallowedSkills`), the template's instructions, its `skills` the child has named in
+ *   the preamble to load first (general gets no line), `maxSteps = min(template ?? runtime.maxSteps, runtime.maxSteps)`, and the model tier
  *   `tier` (the call's) → the template's → `inherit`; an unmapped tier runs on the parent's model
  *   (`tierFallback`); a template `effort` is set when the resolved model declares it;
  * - `agent`: the org agent's version that passed the gates (`orgAgent`, from {@link checkOrgAgent}),
@@ -253,7 +258,13 @@ export async function effectiveDefinition(d, a) {
         };
     }
     const toolPolicies = stricterPolicies(parent.toolPolicies ?? {}, template?.toolPolicies ?? {});
-    const { pinned, warnings } = await pinnedFor(d.db, a, template?.skills ?? [], entry.source === "plugin" ? { plugin: entry.plugin } : null, template?.selectedSkills ?? []);
+    // skills default-on (spec §6.1): the parent's catalog, narrowed by the template's
+    // `disallowedSkills`; the template's `skills` are named in the preamble, never pinned
+    const narrowing = await disallowedSkillRefs(d.db, a.orgId, template?.disallowedSkills);
+    const disabledSkills = narrowing.length === 0
+        ? (parent.disabledSkills ?? [])
+        : canonicalDisabledSkills([...(parent.disabledSkills ?? []), ...narrowing]);
+    const { names, warnings } = await skillsToLoad(d.db, { orgId: a.orgId, agentId: a.parentAgentId, disabledSkills }, template?.skills ?? [], entry.source === "inline");
     const tier = a.tier ?? template?.model ?? "inherit";
     const m = await resolveTier(d, a.orgId, parent, tier);
     let modelParams = m.modelParams;
@@ -265,7 +276,6 @@ export async function effectiveDefinition(d, a) {
                 modelParams = { ...modelParams, [decl.key]: v };
         }
     }
-    const parentSkills = parent.skills;
     const definition = {
         name: childName(parent.name, entry.type),
         avatarUrl: parent.avatarUrl,
@@ -277,18 +287,16 @@ export async function effectiveDefinition(d, a) {
         disabledTools: parent.disabledTools ?? [],
         subagentTools: childFilter(atMaxDepth(a), template, parent.subagentTools),
         toolPolicies,
-        ...((parentSkills !== undefined || pinned.length > 0) && {
-            skills: {
-                orgSkills: parentSkills?.orgSkills ?? [],
-                ...(pinned.length > 0 && { pinned }),
-            },
-        }),
+        disabledSkills,
         ...(parent.subagents !== undefined && { subagents: parent.subagents }),
     };
     return {
         definition,
         template: ref,
         maxSteps: Math.min(template?.maxSteps ?? runtimeMax, runtimeMax),
+        preamble: names.length === 0
+            ? SUBAGENT_PREAMBLE
+            : `${SUBAGENT_PREAMBLE}\n\n${loadSkillsFirstText(names)}`,
         warnings,
         model: m.model,
         tierFallback: m.tierFallback,
@@ -299,41 +307,30 @@ export async function effectiveDefinition(d, a) {
  * definition) against `current`, the definition a fresh dispatch would read now: the dispatching
  * parent run's version for `general` / inline / plugin children, the dispatched org agent's
  * current version for an org agent child (whose tools are its own at dispatch too, §5.5). Its
- * `disabledTools` are both lists together; its `orgSkills` keep only those `current` still
- * selects; a pinned id that was one of the frozen org skills goes with it (the agent's own skills
- * stay).
+ * `disabledTools` and `disabledSkills` are both lists together.
  */
 export function narrowFollowUp(frozen, current) {
-    const disabledTools = canonicalDisabledTools([
-        ...(frozen.disabledTools ?? []),
-        ...(current.disabledTools ?? []),
-    ]);
-    if (frozen.skills === undefined)
-        return { disabledTools };
-    const frozenOrg = new Set(frozen.skills.orgSkills);
-    const now = new Set(current.skills?.orgSkills ?? []);
-    const orgSkills = frozen.skills.orgSkills.filter((id) => now.has(id));
-    const pinned = frozen.skills.pinned?.filter((id) => !frozenOrg.has(id) || now.has(id));
-    return { disabledTools, skills: { orgSkills, ...(pinned !== undefined && { pinned }) } };
+    return {
+        disabledTools: canonicalDisabledTools([
+            ...(frozen.disabledTools ?? []),
+            ...(current.disabledTools ?? []),
+        ]),
+        disabledSkills: canonicalDisabledSkills([
+            ...(frozen.disabledSkills ?? []),
+            ...(current.disabledSkills ?? []),
+        ]),
+    };
 }
 /**
  * The definition a child run uses: the frozen one with its trigger's follow-up narrowing. A
- * narrowing logged before tools were on by default (no `disabledTools`) narrows only skills.
+ * narrowing logged before tools (or skills) were on by default narrows nothing of that kind.
  */
 export function childRunDefinition(frozen, narrowed) {
     if (narrowed === undefined)
         return frozen;
-    const { skills, ...rest } = frozen;
-    const kept = skills === undefined || narrowed.skills === undefined
-        ? skills
-        : {
-            ...skills,
-            orgSkills: narrowed.skills.orgSkills,
-            ...(narrowed.skills.pinned !== undefined && { pinned: narrowed.skills.pinned }),
-        };
     return {
-        ...rest,
+        ...frozen,
         ...(Array.isArray(narrowed.disabledTools) && { disabledTools: narrowed.disabledTools }),
-        ...(kept !== undefined && { skills: kept }),
+        ...(Array.isArray(narrowed.disabledSkills) && { disabledSkills: narrowed.disabledSkills }),
     };
 }

package/dist/runtime/subagents/dispatch.js

@@ -9,7 +9,6 @@ import { childResult, finishedEvent } from "./child.js";
 import { effectiveDefinition, SubagentTypeGoneError, } from "./definition.js";
 import { subagentLimits } from "./limits.js";
 import { auditRefusal, checkOrgAgent, currentAgentDefinition } from "./org-agents.js";
-import { SUBAGENT_PREAMBLE } from "./preamble.js";
 import { findType, GENERAL_PURPOSE_DESCRIPTION, resolveRoster, } from "./roster.js";
 const refused = (content) => ({ kind: "refused", content });
 /** The `general-purpose` roster entry (a fork invocation always has it). */
@@ -147,7 +146,7 @@ export async function dispatchSubagent(d, a) {
                             },
                         },
                     definition: eff.definition,
-                    preamble: SUBAGENT_PREAMBLE,
+                    preamble: eff.preamble,
                     maxSteps: eff.maxSteps,
                     ...([...eff.warnings, ...warnings].length > 0 && {
                         warnings: [...eff.warnings, ...warnings],
@@ -266,7 +265,7 @@ export async function commitDispatchIn(d, a, plan, child) {
         .executeTakeFirst();
     const parent = await t
         .selectFrom("runs")
-        .select(["status", "subagent_tokens_used", "budget_run_id"])
+        .select(["status", "subagent_tokens_used", "budget_run_id", "scheduled_task_run_id"])
         .where("id", "=", ctx.runId)
         .forUpdate()
         .executeTakeFirst();
@@ -367,6 +366,8 @@ export async function commitDispatchIn(d, a, plan, child) {
         trigger_account_id: ctx.accountId,
         trigger_seq: task.seq,
         budget_run_id: budgetRunId,
+        // an unattended parent's sub-agents are unattended too (scheduled tasks spec §4)
+        scheduled_task_run_id: parent.scheduled_task_run_id,
     })
         .execute();
     await t

package/dist/runtime/subagents/preamble.d.ts

@@ -2,6 +2,7 @@
  * The sub-agent preamble (spec §6.3, agent map spec §4.4, model-visible): rendered in a child's
  * system text after `BEHAVIOR_RULES` and before its instructions. Frozen into each child's
  * `subagent_started` at dispatch, and request building reads it from there, so changing this text
- * never alters an old child's requests.
+ * never alters an old child's requests. A template child's preamble ends with a line naming the
+ * template's skills to load first (`effectiveDefinition`, skills default-on spec §6.1).
  */
 export declare const SUBAGENT_PREAMBLE: string;

package/dist/runtime/subagents/preamble.js

@@ -2,7 +2,8 @@
  * The sub-agent preamble (spec §6.3, agent map spec §4.4, model-visible): rendered in a child's
  * system text after `BEHAVIOR_RULES` and before its instructions. Frozen into each child's
  * `subagent_started` at dispatch, and request building reads it from there, so changing this text
- * never alters an old child's requests.
+ * never alters an old child's requests. A template child's preamble ends with a line naming the
+ * template's skills to load first (`effectiveDefinition`, skills default-on spec §6.1).
  */
 export const SUBAGENT_PREAMBLE = "You are a sub-agent. Another agent dispatched you with the task in the first user message. " +
     "Work on it on your own: the user does not watch this conversation and you cannot ask them " +

package/dist/runtime/waits.js

@@ -21,7 +21,7 @@ import { KernelEvents } from "../infra/events/kernel-events.js";
 import { LockService } from "../infra/lock/lock.service.js";
 import { LockedCron } from "../infra/schedule/locked-cron.decorator.js";
 import { KERNEL_LOGGER } from "../infra/tokens.js";
-import { ApprovalsService } from "../tools/approvals.service.js";
+import { ApprovalsService, NETWORK_ASK_CANCELLED_NOTE, } from "../tools/approvals.service.js";
 import { APPROVAL_CANCELLED_TEXT, INPUT_CANCELLED_TEXT, RUN_STOPPED_TEXT, ToolPipeline, } from "../tools/pipeline.js";
 import { QuestionsService } from "../tools/questions.service.js";
 import { RunAbort } from "./abort.js";
@@ -393,12 +393,22 @@ let Waits = class Waits {
         const steps = new Set();
         const approvals = await t
             .selectFrom("approvals")
-            .select(["id", "call_id", "tool_key"])
+            .select(["id", "call_id", "tool_key", "kind", "detail"])
             .where("run_id", "=", runId)
             .orderBy("created_at")
+            .orderBy("attempt")
             .execute();
         for (const a of approvals) {
-            cancelled.set(a.call_id, { toolKey: a.tool_key, text: APPROVAL_CANCELLED_TEXT });
+            // a network ask's command already ran: its kept result, then why access stays blocked
+            // (network ask-to-allow spec §6.7)
+            const kept = a.kind === "network" ? a.detail?.result : null;
+            cancelled.set(a.call_id, kept
+                ? {
+                    toolKey: a.tool_key,
+                    text: `${kept.content}\n\n${NETWORK_ASK_CANCELLED_NOTE}`,
+                    isError: kept.isError,
+                }
+                : { toolKey: a.tool_key, text: APPROVAL_CANCELLED_TEXT });
             const step = await this.approvalStep(t, conversationId, a.id);
             if (step !== null)
                 steps.add(step);
@@ -1090,7 +1100,7 @@ let Waits = class Waits {
                         callId: b.id,
                         toolKey: c?.toolKey ?? b.name ?? "",
                         content: c?.text ?? RUN_STOPPED_TEXT,
-                        isError: true,
+                        isError: c?.isError ?? true,
                     },
                 });
             }