@rse/ase 2.0.5 → 2.0.7

package/dst/ase-agent-definition-api.d.ts

@@ -18,6 +18,7 @@ export interface AgentDefinition {
     lifecycle?: Many<string>;
     serial?: boolean;
     unclaimed?: boolean;
+    model?: string;
     state?: {
         incoming?: Many<string>;
         activity?: string;
@@ -175,6 +176,7 @@ export interface AgentHooks {
     ready?: (task: AgentHookTask, ctx: AgentHookContext) => Async<boolean | string>;
     prepare?: (task: AgentHookTask, job: AgentHookJob, ctx: AgentHookContext) => Async<void>;
     prompt?: (task: AgentHookTask, prompt: AgentHookPrompt, job: AgentHookJob, ctx: AgentHookContext) => Async<AgentHookPrompt | string | undefined>;
+    model?: (task: AgentHookTask, model: string, job: AgentHookJob, ctx: AgentHookContext) => Async<string | undefined>;
     verdict?: (task: AgentHookTask, result: AgentHookResult, ctx: AgentHookContext) => Async<string | undefined>;
     success?: (task: AgentHookTask, result: AgentHookResult, ctx: AgentHookContext) => Async<boolean | string>;
     settle?: (task: AgentHookTask, outcome: AgentHookOutcome, ctx: AgentHookContext) => Async<AgentHookSettlement | undefined>;

package/dst/ase-agent-definition-core.js

@@ -92,6 +92,9 @@ export const definitionOptions = [
     opt("unclaimed", "flag", "", "process the tasks of the incoming states (each adapted onto the " +
         "task lifecycle model) without claiming them, independent of their assignee and predecessors, " +
         "and without ever changing their status and assignee (for \"phase\" only)"),
+    opt("model", "value", "model", "model of the agent tool: a model for all tasks, or comma-separated " +
+        "\"<size>=<model>\" pairs per \"Effort:\" size (\"XS\", \"S\", \"M\", \"L\", \"XL\", or \"*\" for all other tasks) " +
+        "(default: the default model of the agent tool)"),
     opt("params", "list", "name=value", "value of a parameter declared by the definition (repeatable)"),
     opt("state-incoming", "list", "state", "state of the tasks to claim (mandatory for \"phase\", " +
         "repeatable with \"--unclaimed\" or \"--state-activity\" only)"),
@@ -272,7 +275,7 @@ export const flattenDefinition = (data, where) => {
     return flat;
 };
 /*  the names of the hooks of a definition (see "AgentHooks")  */
-const hookNames = ["start", "order", "passes", "ready", "prepare", "prompt", "verdict", "success", "settle", "finish", "stop"];
+const hookNames = ["start", "order", "passes", "ready", "prepare", "prompt", "model", "verdict", "success", "settle", "finish", "stop"];
 /*  normalize the parameter declarations <spec> of a definition (see "AgentParam"),
     where <where> names the definition in errors  */
 const definitionParams = (spec, where) => {
@@ -741,6 +744,24 @@ export const resolveDefinition = async (opts, name) => {
         if (loaded.hooks.passes !== undefined)
             fail("definition", "hook \"passes\" is not for \"--unclaimed\" (as an unclaimed task never waits for its predecessors)");
     }
+    /*  the model of the agent tool: a plain model (for all tasks, as size "*"),
+        or the models per "Effort:" size, where none means the default of the tool  */
+    const modelSpec = str("model").trim();
+    const sizes = {};
+    if (modelSpec !== "" && !modelSpec.includes("="))
+        sizes["*"] = modelSpec;
+    else if (modelSpec !== "") {
+        for (const pair of modelSpec.split(",").map((item) => item.trim())) {
+            const m = /^(XS|S|M|L|XL|\*)=(\S+)$/.exec(pair);
+            if (m === null)
+                fail("model", `invalid pair "${pair}" (expected "<size>=<model>" with size "XS", "S", "M", "L", "XL", or "*")`);
+            else if (Object.hasOwn(sizes, m[1]))
+                fail("model", `size "${m[1]}" given twice`);
+            else
+                sizes[m[1]] = m[2];
+        }
+    }
+    const model = { spec: modelSpec, sizes };
     /*  whether a verdict is determined (by "--verdict-label" or the hook "verdict")  */
     const verdicting = has("verdict-label") || loaded.hooks.verdict !== undefined;
     /*  the states (see "resolveStates")  */
@@ -821,10 +842,10 @@ export const resolveDefinition = async (opts, name) => {
         hence the prompt of the request), resp. uses them optionally by "{prompt}" used only
         within the conditional "{?prompt:...}", else ignores them  */
     const consumes = type === "request" && (template.required.has("prompt")
-        || ["prepare", "prompt", "finish"].some((hook) => loaded.hooks[hook] !== undefined)) ? "required" :
+        || ["prepare", "prompt", "model", "finish"].some((hook) => loaded.hooks[hook] !== undefined)) ? "required" :
         type === "request" && template.names.has("prompt") ? "optional" : "ignored";
     return {
-        name, title, description, type, workdir, lifecycles, unclaimed,
+        name, title, description, type, workdir, lifecycles, unclaimed, model,
         serial: flag("serial"),
         state: { incoming, activity, success, failure, phase, passed, verdict: verdicts },
         tag: {

package/dst/ase-agent-fleet.js

@@ -45,7 +45,7 @@ const logLevelRe = /^([^|]*\| [^:]+: \[[^\]]+\]: )\[(ERROR|WARNING|INFO|DEBUG)\]
     agents, and applied to an agent only if it supports them)  */
 const fleetKeys = ["foreground"];
 const relayKeys = ["address", "port", "token", "cors", "tls-cert", "tls-key"];
-const defaultKeys = ["tool", "parallel", "timeout", "repo", "tempdir", "agent-relay"];
+const defaultKeys = ["tool", "model", "parallel", "timeout", "repo", "tempdir", "agent-relay"];
 /*  the options not allowed in the section of an agent, as the fleet decides on them  */
 const deniedKeys = ["name", "one-shot", "foreground", "help"];
 /*  the state of the planned tasks per task lifecycle model, as estimated by the estimator  */
@@ -76,6 +76,7 @@ const initConfig = (tool, lifecycle) => [
     #   (each applied only to the agents supporting it, where an empty value omits it)
     default:
         tool:           ${tool.padEnd(16)}# agent tool ("claude", "copilot", or "codex")
+        #model:         <model>         # model of the agent tool (or "<size>=<model>" pairs per "Effort:" size)
         parallel:       1               # maximum number of tasks processed in parallel
         timeout:        60m             # maximum duration of processing a task (<number><unit> with unit "s", "m", or "h")
         #repo:          <url>           # Git repository to clone temporarily for the tasks without "worktree"

package/dst/ase-agent-runtime-engine.js

@@ -45,6 +45,15 @@ const promptOf = (value, configured) => {
     }
     throw new Error("invalid prompt (expected a string, \"{ text }\", or \"{ skill, args }\")");
 };
+/*  the model returned by the hook "model", validated, where undefined
+    keeps the configured model <configured>  */
+const modelOf = (value, configured) => {
+    if (value === undefined)
+        return configured;
+    else if (typeof value !== "string")
+        throw new Error("invalid model (expected a string)");
+    return value.trim();
+};
 /*  whether a record of an agent of a definition succeeded (where a missing one counts as failure)  */
 const recordSuccess = (record) => record !== undefined && record.fixed === "" && record.checks.every((check) => check.ok);
 /*  escape a text for its literal use in a regular expression  */
@@ -331,7 +340,7 @@ class DefinedCore {
     }
     /*  prepare the job of a task in its work <work>: render the prompt (with the request
         prompt <prompt> of a request agent), run the preparing commands, and run the hooks
-        "prepare" and "prompt", where the work is cleaned up again on a failure, and where
+        "prepare", "prompt", and "model", where the work is cleaned up again on a failure, and where
         <changed> decides preliminarily whether the plan content of a request agent changed  */
     async prepare(task, log, work, prompt, changed) {
         try {
@@ -374,7 +383,7 @@ class DefinedCore {
                     throw err;
                 }
             }
-            /*  run the hooks "prepare" and "prompt", where a failed hook fails the processing  */
+            /*  run the hooks "prepare", "prompt", and "model", where a failed hook fails the processing  */
             const job = Object.freeze({
                 dir: work.cwd,
                 dirs: Object.freeze([...work.dirs]),
@@ -392,7 +401,7 @@ class DefinedCore {
                     throw new Error(`agent: hook "${name}" failed: ${reason(err)}`, { cause: err });
                 }
             };
-            const { prepare: prepareHook, prompt: promptHook } = this.def.hooks;
+            const { prepare: prepareHook, prompt: promptHook, model: modelHook } = this.def.hooks;
             if (prepareHook !== undefined)
                 await hooked("prepare", async () => prepareHook(this.task(task), job, ctx));
             let spec = this.def.prompt.skill !== "" ?
@@ -401,10 +410,17 @@ class DefinedCore {
                 const configured = Object.freeze(spec);
                 spec = await hooked("prompt", async () => promptOf(await promptHook(this.task(task), configured, job, ctx), configured));
             }
+            const { sizes } = this.def.model;
+            let model = sizes[TaskFormat.parseEffort(task.keys.get("Effort") ?? "")?.size ?? "*"] ?? sizes["*"] ?? "";
+            if (modelHook !== undefined) {
+                const configured = model;
+                model = await hooked("model", async () => modelOf(await modelHook(this.task(task), configured, job, ctx), configured));
+            }
             return {
                 ...("skill" in spec ?
                     { cmd: `${spec.skill}${spec.args !== "" ? ` ${spec.args}` : ""}` } :
                     { prompt: spec.text }),
+                model,
                 cwd: work.cwd,
                 dirs: work.dirs,
                 finish: (log, result) => this.finish(task, log, result, work, job, env, before, changed),
@@ -714,6 +730,7 @@ class DefinedPhaseAgent extends PhaseAgent {
         };
         this.presenceTitle = def.title;
         this.presenceDesc = def.description;
+        this.modelSpec = def.model.spec;
         this.assigned = def.assign.required;
         this.finishing = def.finish.commit || def.finish.success !== "" || def.workdir === "target"
             || def.hooks.finish !== undefined;
@@ -858,6 +875,7 @@ class DefinedRequestAgent extends RequestAgent {
         this.presencePrompt = def.request.prompt;
         this.presenceTitle = def.title;
         this.presenceDesc = def.description;
+        this.modelSpec = def.model.spec;
         this.serial = def.serial;
         this.worktree = def.workdir !== "project";
         this.lifecycles = def.lifecycles;
@@ -950,7 +968,7 @@ export class DefinedAgent extends Agent {
         for (const option of definitionOptions) {
             if (option.key === "definition" && !definition)
                 continue;
-            const flags = (option.key === "definition" ? "-D, " : "") + `--${option.key}` +
+            const flags = (option.key === "definition" ? "-D, " : option.key === "model" ? "-M, " : "") + `--${option.key}` +
                 (option.kind !== "flag" ? ` <${option.arg}>` : "");
             if (option.kind === "list")
                 cmd.option(flags, option.desc, (value, prev) => [...(prev ?? []), value]);

package/dst/ase-agent-runtime-tool.js

@@ -8,20 +8,22 @@ import { stripVTControlCharacters } from "node:util";
     of the task (as an agent message can be huge, e.g. the rendering of the whole task plan,
     which would otherwise be fed back into the next rendering of the task plan)  */
 const TEXT_MAX = 20;
+/*  the "--model" option of all tools for the model <model> (none for the default model)  */
+const modelArgs = (model) => model !== "" ? ["--model", model] : [];
 /*  the per-tool headless invocation of the rendered prompt <prompt> with access to the
-    additional directories <add> (the "--add-dir" options), streaming JSONL events,
-    where risky actions are denied or automatically reviewed instead of being prompted for
+    additional directories <add> (the "--add-dir" options) and the model <model>, streaming JSONL
+    events, where risky actions are denied or automatically reviewed instead of being prompted for
     (the variadic "--add-dir" of Claude has to precede the other options to not consume the prompt)  */
 export const toolArgs = {
-    "claude": (prompt, add) => [
-        ...add, "-p", "--output-format", "stream-json", "--verbose", "--disallowedTools", "AskUserQuestion",
+    "claude": (prompt, add, model) => [
+        ...add, ...modelArgs(model), "-p", "--output-format", "stream-json", "--verbose", "--disallowedTools", "AskUserQuestion",
         "--permission-mode", "auto", "--permission-prompts", "none", prompt
     ],
-    "copilot": (prompt, add) => [
-        ...add, "--allow-all-tools", "--no-ask-user", "--no-color", "--output-format", "json", "-p", prompt
+    "copilot": (prompt, add, model) => [
+        ...add, ...modelArgs(model), "--allow-all-tools", "--no-ask-user", "--no-color", "--output-format", "json", "-p", prompt
     ],
-    "codex": (prompt, add) => [
-        "exec", ...add, "--json", "--approve-for-me", "--color", "never", prompt
+    "codex": (prompt, add, model) => [
+        "exec", ...add, ...modelArgs(model), "--json", "--approve-for-me", "--color", "never", prompt
     ]
 };
 /*  the per-tool rendering of the invocation of the skill <skill> with the arguments <args>:

package/dst/ase-agent-runtime.js

@@ -145,6 +145,8 @@ export class Agent {
     /*  the title and the description of the operation of the agent, as announced in its presence (default: none)  */
     presenceTitle = "";
     presenceDesc = "";
+    /*  the configured model of the agent tool, as shown in the start log line (default: none)  */
+    modelSpec = "";
     /*  whether tasks are processed serially only (clamping "--parallel" to 1, and
         refusing multiple agents of the kind in a fleet, see "ase agent fleet")  */
     serial = false;
@@ -840,7 +842,8 @@ export class Agent {
         const cli = toolSpecs[tool].cli;
         const cmd = job.cmd ?? "";
         const i = cmd.indexOf(" ");
-        const args = toolArgs[tool](job.prompt ?? skillPrompt(tool, i < 0 ? cmd : cmd.slice(0, i), i < 0 ? "" : cmd.slice(i + 1)), [...new Set(job.dirs ?? [])].filter((dir) => dir !== cwd).flatMap((dir) => ["--add-dir", dir]));
+        const model = job.model ?? "";
+        const args = toolArgs[tool](job.prompt ?? skillPrompt(tool, i < 0 ? cmd : cmd.slice(0, i), i < 0 ? "" : cmd.slice(i + 1)), [...new Set(job.dirs ?? [])].filter((dir) => dir !== cwd).flatMap((dir) => ["--add-dir", dir]), model);
         await log("info", `running: ${cli} ${args.map((arg) => arg.includes(" ") ? `"${arg}"` : arg).join(" ")}`);
         const started = Date.now();
         const costs = { costToken: null, costUSD: null, cread: 0, cwrite: 0, input: 0, apiMs: null };
@@ -881,7 +884,7 @@ export class Agent {
         this.presence?.used(usage);
         /*  book the usage onto the task, if the AI usage accounting is enabled ("telemetry.enabled"),
             (the AI request time falling back to the wall time and an unreported cost to the price
-            table entry of the tool, as its model is unknown), without any human time and costs,
+            table entry of the given model, else of the tool), without any human time and costs,
             as the headless agent tool runs unattended; the times are booked in rounded minutes,
             with the (signed) rounding remainder carried over to the next booking onto the task,
             where a failed booking is only reported  */
@@ -894,7 +897,8 @@ export class Agent {
             if (cost === null) {
                 const cfg = new Config("config", configSchema, this.log);
                 cfg.read();
-                cost = tokenCost(modelPrice(parsePrices(String(cfg.get("telemetry.prices.ai") ?? "")), tool), tokens);
+                const prices = parsePrices(String(cfg.get("telemetry.prices.ai") ?? ""));
+                cost = tokenCost(modelPrice(prices, model !== "" && prices.has(model) ? model : tool), tokens);
             }
             const carry = this.unbooked.get(taskId) ?? { aiMs: 0, realMs: 0 };
             const aiMs = carry.aiMs + (costs.apiMs ?? walltimeMs);
@@ -1250,7 +1254,7 @@ export class Agent {
             if (this.repo !== "")
                 await this.cloneRepo();
             await this.write("info", this.name, `observing ${this.observing()} ` +
-                `(tool: ${tool}, parallel: ${parallel}, timeout: ${this.timeoutSpec}${this.oneShot ? ", one-shot" : ""})`);
+                `(tool: ${tool}${this.modelSpec !== "" ? `, model: ${this.modelSpec}` : ""}, parallel: ${parallel}, timeout: ${this.timeoutSpec}${this.oneShot ? ", one-shot" : ""})`);
             let finished = false;
             let failure = null;
             while (!abort.signal.aborted && !finished) {

package/dst/ase-config-schema.js

@@ -61,7 +61,7 @@ export const projectClassificationPresets = {
         "project.task.effort.line": "0.025",
         "project.task.effort.iteration": "2.5",
         "project.artifact.spec.basedir": "docs/specbook",
-        "project.artifact.spec.files": "*.{md,txt,svg,png,jpg}",
+        "project.artifact.spec.files": "**/*.{md,txt,svg,png,jpg}",
         "project.artifact.spec.schema": "",
         "project.artifact.code.basedir": "src",
         "project.artifact.code.files": "** !**/etc/** !**/{.gitignore,.npmignore,package.json}",

package/dst/ase-man-catalog.js

@@ -24,7 +24,7 @@ const skillGroups = [
     ["SPEC", ["ase-spec-lint", "ase-spec-edit", "ase-spec-activate"]],
     ["CODE", ["ase-code-edit", "ase-code-analyze", "ase-code-insight", "ase-code-explain", "ase-code-lint"]],
     ["REPO", ["ase-repo-review", "ase-repo-diff", "ase-repo-changelog", "ase-repo-commit",
-            "ase-repo-dissect", "ase-repo-merge", "ase-repo-resolve"]],
+            "ase-repo-dissect", "ase-repo-stage", "ase-repo-merge", "ase-repo-resolve"]],
     ["SYNC", ["ase-sync-reconcile", "ase-sync-import", "ase-sync-export"]],
     ["TASK: MANAGE", ["ase-task-list", "ase-task-rename", "ase-task-delete"]],
     ["TASK: HANDLE", ["ase-task-id", "ase-task-status", "ase-task-assign"]],

package/dst/ase-setup-settings.js

@@ -11,7 +11,7 @@ import { mkdirp } from "mkdirp";
 import JsonAsty from "json-asty";
 import { toolSpecs } from "./ase-setup-common.js";
 import { telemetryEndpoint, telemetryEnabled } from "./ase-service-otel.js";
-/*  settings file handling of "ase setup statusline", "ase setup telemetry", and the output style  */
+/*  settings file handling of "ase setup statusline", "ase setup telemetry", the output style, and the function hooks  */
 export class SetupSettings {
     log;
     constructor(log) {
@@ -358,6 +358,116 @@ export class SetupSettings {
         }
         return entries;
     }
+    /*  the environment variable enabling the function hooks of the plugin-shipped mods
+        (Anthropic Claude Code CLI only, as the other tools have no function hooks concept)  */
+    functionHooksVar = "CLAUDE_CODE_ENABLE_FUNCTION_HOOKS";
+    /*  determine the value of the function hooks variable in an "env" object  */
+    functionHooksValue(env) {
+        const val = this.settingsFindMember(env, this.functionHooksVar)?.query("/ * [ pos() == 2 ]")[0];
+        return val !== undefined ? String(val.get("value") ?? "") : undefined;
+    }
+    /*  enable the function hooks of the plugin-shipped mods by setting their
+        variable in the "env" of the settings file of the scope  */
+    async functionHooksActivate(action, scope) {
+        const file = this.settingsFile("claude", scope);
+        const root = await this.settingsReadAst(file);
+        /*  reject a non-object "env" member  */
+        let member = this.settingsFindMember(root, "env");
+        let env = member?.query("/ * [ pos() == 2 ]")[0];
+        if (member !== undefined && (env === undefined || env.type() !== "object")) {
+            this.log.write("warning", `setup: ${action}: a non-object "env" ` +
+                `is present in ${file}: preserving it (skipped)`);
+            return;
+        }
+        /*  leave an ASE variable as is and preserve a foreign value: skip and warn  */
+        const value = env !== undefined ? this.functionHooksValue(env) : undefined;
+        if (value !== undefined) {
+            if (value !== "1")
+                this.log.write("warning", `setup: ${action}: a non-ASE "${this.functionHooksVar}" ` +
+                    `is already present in "env" of ${file}: preserving it (skipped)`);
+            return;
+        }
+        /*  insert a fresh (still empty) "env" member  */
+        if (member === undefined || env === undefined) {
+            env = root.create("object").set({ prolog: "{", epilog: "}" });
+            member = root.create("member").add(root.create("string").set({ body: JSON.stringify("env"), value: "env", epilog: ": " }), env);
+            this.settingsAddMember(root, member, false);
+        }
+        /*  add the variable  */
+        const key = root.create("string").set({
+            body: JSON.stringify(this.functionHooksVar),
+            value: this.functionHooksVar,
+            epilog: ": "
+        });
+        const val = root.create("string").set({ body: JSON.stringify("1"), value: "1" });
+        env.add(root.create("member").add(key, val));
+        this.settingsNormalizeObject(env, 1, this.settingsTrailing(root, member));
+        await this.settingsWriteAst(file, root);
+        this.log.write("info", `setup: ${action}: enabling function hooks in "env" of ${file}`);
+    }
+    /*  disable the function hooks of the plugin-shipped mods by removing
+        their variable from the "env" of the settings file of the scope  */
+    async functionHooksDeactivate(action, scope) {
+        const file = this.settingsFile("claude", scope);
+        /*  a missing settings file means nothing to remove  */
+        try {
+            await fs.access(file);
+        }
+        catch {
+            return;
+        }
+        const root = await this.settingsReadAst(file);
+        const member = this.settingsFindMember(root, "env");
+        const env = member?.query("/ * [ pos() == 2 ]")[0];
+        if (member === undefined || env === undefined || env.type() !== "object")
+            return;
+        const target = this.settingsFindMember(env, this.functionHooksVar);
+        if (target === undefined)
+            return;
+        /*  preserve a foreign value: skip and warn  */
+        if (this.functionHooksValue(env) !== "1") {
+            this.log.write("warning", `setup: ${action}: a non-ASE "${this.functionHooksVar}" ` +
+                `is present in "env" of ${file}: preserving it (skipped)`);
+            return;
+        }
+        /*  remove the variable and, if it became empty, the "env" member  */
+        env.del(target);
+        if (env.query("/ member").length === 0)
+            this.settingsRemoveMember(root, member);
+        else
+            this.settingsNormalizeObject(env, 1, this.settingsTrailing(root, member));
+        await this.settingsWriteAst(file, root);
+        this.log.write("info", `setup: ${action}: disabling function hooks in "env" of ${file}`);
+    }
+    /*  probe the function hooks variables by inspecting the tool
+        settings files of all installation scopes (Anthropic Claude Code CLI only)  */
+    async functionHooksStatus(tool) {
+        if (tool !== "claude")
+            return [];
+        const scopes = ["user", "project", "local"];
+        const entries = [];
+        for (const scope of scopes) {
+            const file = this.settingsFile(tool, scope);
+            let root;
+            try {
+                root = await this.settingsReadAst(file);
+            }
+            catch {
+                /*  an unparsable settings file carries no usable state  */
+                continue;
+            }
+            const env = this.settingsFindMember(root, "env")?.query("/ * [ pos() == 2 ]")[0];
+            const value = env !== undefined && env.type() === "object" ? this.functionHooksValue(env) : undefined;
+            if (value === undefined)
+                continue;
+            entries.push({
+                file: this.fileDisplay(file),
+                scope,
+                status: value === "1" ? "enabled" : "foreign"
+            });
+        }
+        return entries;
+    }
     /*  auto-detect the scope in which the ASE plugin is currently
         installed, so an omitted --scope targets the existing installation
         instead of blindly assuming the per-user scope; only the Anthropic

package/dst/ase-setup.js

@@ -38,9 +38,12 @@ export default class SetupCommand {
         const scopeArgs = tool === "claude" && scope !== "user" ? ["--scope", scope] : [];
         await this.runner.run(spec.cli, ["plugin", "marketplace", "add", source, ...scopeArgs]);
         await this.runner.run(spec.cli, ["plugin", spec.pInstall, "ase@ase", ...scopeArgs], { retries: 3 });
-        /*  select the plugin-shipped ASE output style (Anthropic Claude Code CLI only)  */
-        if (tool === "claude")
+        /*  select the plugin-shipped ASE output style and enable the function
+            hooks of the plugin-shipped mods (Anthropic Claude Code CLI only)  */
+        if (tool === "claude") {
             await this.settings.outputStyleActivate(`install${dev ? "[dev]" : ""}`, scope);
+            await this.settings.functionHooksActivate(`install${dev ? "[dev]" : ""}`, scope);
+        }
         return 0;
     }
     /*  handler for "ase setup update" (all tools)  */
@@ -97,9 +100,12 @@ export default class SetupCommand {
                 await this.runner.run(spec.cli, ["plugin", spec.pInstall, "ase@ase", ...scopeArgs], { retries: 3 });
             }
         }
-        /*  select the plugin-shipped ASE output style (Anthropic Claude Code CLI only)  */
-        if (tool === "claude")
+        /*  select the plugin-shipped ASE output style and enable the function
+            hooks of the plugin-shipped mods (Anthropic Claude Code CLI only)  */
+        if (tool === "claude") {
             await this.settings.outputStyleActivate(`update${dev ? "[dev]" : ""}`, scope);
+            await this.settings.functionHooksActivate(`update${dev ? "[dev]" : ""}`, scope);
+        }
         return 0;
     }
     /*  handler for "ase setup enable|disable" (all tools)  */
@@ -130,9 +136,12 @@ export default class SetupCommand {
         this.log.write("info", `setup: uninstall${dev ? "[dev]" : ""}: ` +
             "stopping potentially running ASE service");
         await this.runner.run("ase", ["service", "stop"], { quiet: true, ignoreError: "ASE service not running" });
-        /*  deselect the plugin-shipped ASE output style (Anthropic Claude Code CLI only)  */
-        if (tool === "claude")
+        /*  deselect the plugin-shipped ASE output style and disable the function
+            hooks of the plugin-shipped mods (Anthropic Claude Code CLI only)  */
+        if (tool === "claude") {
             await this.settings.outputStyleDeactivate(`uninstall${dev ? "[dev]" : ""}`, scope);
+            await this.settings.functionHooksDeactivate(`uninstall${dev ? "[dev]" : ""}`, scope);
+        }
         /*  uninstall ASE plugin  */
         this.log.write("info", `setup: uninstall${dev ? "[dev]" : ""}: ` +
             `uninstalling ASE ${spec.label} plugin (origin: ${dev ? "local" : "remote/bundled"})`);
@@ -172,6 +181,9 @@ export default class SetupCommand {
         /*  report the ASE output style selections  */
         for (const outputStyle of await this.settings.outputStyleStatus(tool))
             rows.push(["OUTPUTSTYLE", chalk.bold(outputStyle.file), outputStyle.scope, outputStyle.status]);
+        /*  report the function hooks enablements  */
+        for (const functionHooks of await this.settings.functionHooksStatus(tool))
+            rows.push(["FUNCTIONHOOKS", chalk.bold(functionHooks.file), functionHooks.scope, functionHooks.status]);
         /*  report the ASE statusline registrations  */
         for (const statusline of await this.settings.statuslineStatus(tool))
             rows.push(["STATUSLINE", chalk.bold(statusline.file), statusline.scope, statusline.status]);
@@ -307,7 +319,7 @@ export default class SetupCommand {
         /*  register CLI sub-command "ase setup status"  */
         setupCmd
             .command("status")
-            .description("report the ASE plugin, MCP server, output style, statusline, and telemetry registrations for a tool")
+            .description("report the ASE plugin, MCP server, output style, function hooks, statusline, and telemetry registrations for a tool")
             .option("-t, --tool <tool>", "target tool (\"claude\", \"copilot\", or \"codex\")", toolDflt)
             .action(async (opts) => {
             process.exit(await this.doStatus(parseTool(opts.tool)));