@platless/axom-cli 0.1.0 → 0.5.9

package/dist/workstation/update/taskRegistry.js

@@ -3,19 +3,64 @@
  * forced update closes it permanently because this daemon is about to be replaced.
  */
 export class TaskRegistry {
-    /** Every running shell's abort handle plus the promise that says its finally cleanup has run. */
+    /** Every running computer task's abort handle plus the promise that says its finally cleanup has run. */
     shellTasks = new Map();
-    agentTasks = new Set();
     agentOpenReservations = new Map();
     agentSessions = new Map();
     idleWaiters = new Set();
     stopping = null;
     accepting = true;
+    /** Keeper-terminal execs also counted in `activeShellTasks` right now (see {@link countKeeperExec}). */
+    keeperExecsCounted = 0;
+    /**
+     * Work owned by another process that a daemon restart would interrupt (the files host's in-progress uploads plus
+     * running media encodes), sampled **now** on every snapshot — never an edge counter. Its owner calls
+     * [externalActivityChanged] when the level may have dropped, so a drain waiting on it wakes.
+     */
+    externalActivity = () => 0;
+    /**
+     * 忙碌是**现在采出来的**，不是攒出来的。
+     *
+     * 上一版把每个 `tool_call` / `permission_request` 记进一个 `Set`，指望 `turn_done` 来删。
+     * 任何一条没有配套 `turn_done` 的开始事件都会把那个 ref 永久钉住，`isIdle()` 于是永远假，
+     * 优雅更新白等满 drain 超时——2026-09-21 一次重装就这样卡在 BUSY。集合删掉之后这类缺陷
+     * **按构造**不存在：没有可泄漏的东西，而不是"记得要删"。
+     *
+     * `busy()` 由会话自己提供，两个来源取或（见 agentSessions.ts 的注册点）：本进程发出的
+     * 提示词是否在途，以及 agent 自报的状态。两个都是层级量。
+     */
     snapshot() {
-        const activeAgentRefs = new Set(this.agentTasks);
+        const activeAgentRefs = new Set();
+        for (const [sessionRef, session] of this.agentSessions) {
+            // Spec §8.2: `activeAgentTasks` counts only agent work a daemon restart would cut. A keeper-hosted (durable) session is not
+            // such work — its turn goes on in keeper-acp and the next daemon adopts it — so a busy one neither holds a graceful drain nor
+            // blocks an automatic patch. Fallback sessions (in this process) and in-flight open reservations are counted.
+            if (session.durable)
+                continue;
+            // 一个抛异常的采样器不得让心跳和更新准入一起垮掉；读不出来就当它不主张忙碌，
+            // 与未知 vendor 值的处置同一条推理。
+            let busy = false;
+            try {
+                busy = session.busy();
+            }
+            catch {
+                busy = false;
+            }
+            if (busy)
+                activeAgentRefs.add(sessionRef);
+        }
         for (const sessionRef of this.agentOpenReservations.keys())
             activeAgentRefs.add(sessionRef);
-        return { activeShellTasks: this.shellTasks.size, activeAgentTasks: activeAgentRefs.size };
+        let external = 0;
+        // Same rule as the session sampler above: a failing sampler claims nothing rather than taking the heartbeat down.
+        try {
+            const sampled = this.externalActivity();
+            external = Number.isSafeInteger(sampled) && sampled > 0 ? sampled : 0;
+        }
+        catch {
+            external = 0;
+        }
+        return { activeShellTasks: this.shellTasks.size + external, activeAgentTasks: activeAgentRefs.size };
     }
     canUpdate() {
         const snapshot = this.snapshot();
@@ -56,7 +101,11 @@ export class TaskRegistry {
         for (const waiter of [...this.idleWaiters])
             waiter();
     }
-    /** Run one shell task under an abort signal which force-update owns. */
+    /**
+     * Run one computer task under an abort signal which force-update owns. The method name preserves old callers.
+     * `release()` stops counting the task before it ends (work a daemon restart would no longer interrupt, spec §8.2): from then on it
+     * is not in `activeShellTasks`, a drain does not wait for it and `stopAll()` does not abort it. Idempotent.
+     */
     async withShellTask(run) {
         if (!this.accepting)
             throw new Error('Workstation is not accepting new work');
@@ -64,18 +113,72 @@ export class TaskRegistry {
         let complete;
         const cleanedUp = new Promise((resolve) => { complete = resolve; });
         this.shellTasks.set(controller, cleanedUp);
+        let counted = true;
+        const release = () => {
+            if (!counted)
+                return;
+            counted = false;
+            this.shellTasks.delete(controller);
+            complete();
+            this.notifyIfIdle();
+        };
         try {
-            return await run(controller.signal);
+            return await run(controller.signal, release);
         }
         finally {
+            release();
+        }
+    }
+    /**
+     * Counts a short window of work in `activeShellTasks` WITHOUT the admission gate and without being stoppable: a drain (graceful
+     * or forced) waits for it, nothing aborts it. For work admitted while draining that a restart must not cut in half (a wire v5
+     * exec between `exec.start` and its first checkpoint, spec §8.2). Returns the release (idempotent).
+     */
+    holdShellTask() {
+        const controller = new AbortController();
+        let complete;
+        this.shellTasks.set(controller, new Promise((resolve) => { complete = resolve; }));
+        let held = true;
+        return () => {
+            if (!held)
+                return;
+            held = false;
             this.shellTasks.delete(controller);
             complete();
             this.notifyIfIdle();
-        }
+        };
     }
-    /** Register a live native agent for force-stop; idle sessions deliberately do not count as busy. */
-    registerAgentSession(sessionRef, close) {
-        this.agentSessions.set(sessionRef, close);
+    /**
+     * Marks one exec that runs in keeper-terminal AND is counted in `activeShellTasks` right now — a wire ≤ 4 exec (a shell task for
+     * its whole run) or a wire v5 exec before its first checkpoint (held). keeper-terminal's `execRunning` counts it too: the heartbeat
+     * reports this number (`execCounted`) so the Workstations page does not count it twice (final review minor 7). Returns the
+     * release (idempotent).
+     */
+    countKeeperExec() {
+        this.keeperExecsCounted += 1;
+        let counted = true;
+        return () => { if (!counted)
+            return; counted = false; this.keeperExecsCounted -= 1; };
+    }
+    /** How many keeper-terminal execs `activeShellTasks` includes now (see {@link countKeeperExec}). */
+    get countedKeeperExecs() { return this.keeperExecsCounted; }
+    /**
+     * Register a live native agent for force-stop, plus how to ask whether it is busy right now. A durable session's `close` must be
+     * its detach (see {@link AgentSessionRegistration}).
+     */
+    registerAgentSession(sessionRef, close, busy, registration = {}) {
+        this.agentSessions.set(sessionRef, { close, busy, durable: registration.durable === true });
+    }
+    /**
+     * 采样式判据没有"变空闲"这个事件可以挂钩，所以持有者在可能变空闲时喊一声。
+     * 多喊无害（`notifyIfIdle` 自己会再判一次），漏喊的代价只是等到下一次调用或超时。
+     */
+    sessionBusyChanged() {
+        this.notifyIfIdle();
+    }
+    /** The external activity level may have changed (see [externalActivity]). */
+    externalActivityChanged() {
+        this.notifyIfIdle();
     }
     /** Atomically admits and counts an asynchronous open before any journal or subprocess await. */
     tryReserveAgentOpen(sessionRef) {
@@ -96,25 +199,41 @@ export class TaskRegistry {
     isForceStopping() {
         return this.stopping !== null;
     }
+    /** Whether `sessionRef` is registered as a keeper-hosted (durable) session: a force stop leaves it admitted (see {@link stopAll}). */
+    isDurableSession(sessionRef) {
+        return this.agentSessions.get(sessionRef)?.durable === true;
+    }
     unregisterAgentSession(sessionRef) {
         this.agentSessions.delete(sessionRef);
-        this.agentTasks.delete(sessionRef);
         this.notifyIfIdle();
     }
-    /** Returns false whenever an update has closed the new-turn admission gate. */
-    agentTurnStarted(sessionRef) {
-        if (!this.accepting)
-            return false;
-        this.agentTasks.add(sessionRef);
-        return true;
+    /**
+     * 排干期间拒收新回合。**只管准入**——它不再登记任何东西，忙碌由 [snapshot] 现场采样。
+     * 这两件事以前挤在一个方法里，删计数时极易把准入一起删掉，那会让 drain 期间照收新活。
+     */
+    tryAdmitTurn(sessionRef) {
+        // Spec §8.2: a keeper-hosted session's prompt is admitted while draining — it enters keeper-acp's log first and a restart
+        // continues it; a fallback session's would be cut by the restart.
+        return this.accepting || this.agentSessions.get(sessionRef)?.durable === true;
     }
-    agentTurnFinished(sessionRef) {
-        this.agentTasks.delete(sessionRef);
-        this.notifyIfIdle();
+    /**
+     * The restart path of an update (Task 21, spec §5.5.5): every durable session is detached (its registered close), so the next daemon
+     * adopts it with a head checkpoint; fallback sessions are left as they are (they end with this process, their outboxes kept).
+     * Bounded by `timeoutMs`: a restart never waits on a session longer than that. All are attempted even when one fails.
+     */
+    async detachDurableSessions(timeoutMs = 5_000) {
+        const durable = [...this.agentSessions.values()].filter((session) => session.durable);
+        const all = Promise.allSettled(durable.map(async (session) => session.close()));
+        let timer;
+        await Promise.race([all, new Promise((resolve) => { timer = setTimeout(resolve, timeoutMs); })]);
+        clearTimeout(timer);
     }
     /**
      * Atomically refuse future work, signal every shell process group through its owning executor,
-     * and close every native agent. All closes are attempted even when one bridge fails.
+     * and close every native agent that runs in this process. A durable (keeper-hosted) session is left alone: it stays registered,
+     * attached and admitted (spec §8.2, the same as a graceful drain) — the restart path detaches it right before the hand-off
+     * ({@link detachDurableSessions}), and a forced update that fails before that leaves it exactly as it was. All closes are
+     * attempted even when one bridge fails.
      */
     async stopAll() {
         if (this.stopping)
@@ -126,11 +245,10 @@ export class TaskRegistry {
             const shells = [...this.shellTasks.entries()];
             for (const [task] of shells)
                 task.abort();
-            this.agentTasks.clear();
             this.agentOpenReservations.clear();
             this.notifyIfIdle();
             const [outcomes] = await Promise.all([
-                Promise.allSettled([...this.agentSessions.values()].map(async (close) => close())),
+                Promise.allSettled([...this.agentSessions.values()].filter((session) => !session.durable).map(async (session) => session.close())),
                 Promise.all(shells.map(([, cleanedUp]) => cleanedUp)),
             ]);
             const failures = outcomes.filter((outcome) => outcome.status === 'rejected');

package/dist/workstation/update/watchdog.js

@@ -242,6 +242,72 @@ async function npmInstall(npmPath, npmPrefix, archive) {
         child.once('error', reject);
         child.once('close', (code) => code === 0 ? resolve() : reject(new Error(`npm rollback failed with exit ${code ?? 'unknown'}`)));
     });
+    await verifyOptionalPty(npmPrefix);
+}
+/**
+ * Whether the installed CLI's optional `node-pty` loads in this runtime. Kept in this standalone file
+ * because the rollback watchdog is copied out of the package.
+ *
+ * There is nothing to build: the pinned node-pty ships N-API prebuilds for all six desktop targets
+ * (linux included since 1.2.0-beta; 1.1.0 had none for linux, which is why this used to run
+ * `npm rebuild` and needed Python/make/a C++ compiler on the workstation). The check runs in a
+ * child process so a crashing addon cannot take the installer with it.
+ *
+ * Never fails the install. Terminal support is optional and the daemon already degrades only the
+ * terminal tool when the addon is missing; an update that rolled back over it left the whole
+ * workstation on the old client instead.
+ */
+export async function verifyOptionalPty(npmPrefix, spawn = nodeSpawn, timeoutMs = 60_000, warn = console.warn) {
+    const root = path.join(npmPrefix, process.platform === 'win32' ? 'node_modules' : 'lib/node_modules', PACKAGE_NAME);
+    const addon = path.join(root, 'node_modules/node-pty');
+    try {
+        await fs.access(path.join(addon, 'package.json'));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return false; // Explicitly omitted optional dependency.
+        throw error;
+    }
+    try {
+        await new Promise((resolve, reject) => {
+            // A detached POSIX group lets a timeout stop the check and anything the addon started.
+            // It must finish well before the previous release's 120-second rollback deadline.
+            const child = spawn(process.execPath, ['-e', 'require(process.argv[1])', addon], { shell: false, stdio: 'ignore', windowsHide: true, detached: process.platform !== 'win32' });
+            let done = false;
+            const finish = (error) => {
+                if (done)
+                    return;
+                done = true;
+                clearTimeout(timer);
+                if (error)
+                    reject(error);
+                else
+                    resolve();
+            };
+            const timer = setTimeout(() => {
+                try {
+                    if (process.platform !== 'win32' && child.pid)
+                        process.kill(-child.pid, 'SIGKILL');
+                    else
+                        child.kill('SIGKILL');
+                }
+                catch {
+                    try {
+                        child.kill('SIGKILL');
+                    }
+                    catch { /* Already exited. */ }
+                }
+                finish(new Error('timed out'));
+            }, timeoutMs);
+            child.once('error', () => finish(new Error('could not start the check')));
+            child.once('close', code => finish(code === 0 ? undefined : new Error(`exit ${code ?? 'unknown'}`)));
+        });
+        return true;
+    }
+    catch (error) {
+        warn(`[update] Optional node-pty does not load on this platform (${error.message}); the terminal tool stays unavailable.`);
+        return false;
+    }
 }
 /** How much of the child's own complaint is worth carrying into a 512-character status field. */
 const CAPTURED_STDERR_LIMIT = 300;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platless/axom-cli",
-  "version": "0.1.0",
+  "version": "0.5.9",
   "description": "Axomwork CLI - manage Axomwork structures, records and executions over MCP",
   "type": "module",
   "bin": {
@@ -11,29 +11,42 @@
     "skills"
   ],
   "engines": {
-    "node": ">=20"
+    "node": ">=24"
   },
   "scripts": {
-    "build": "rm -rf dist && tsc",
+    "build": "rm -rf dist && tsc && node scripts/copy-patches.mjs && node scripts/copy-runtime-deps.mjs && node scripts/bundle-keepers.mjs",
+    "pretest": "npm run build",
     "test": "vitest run",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "prepack": "node scripts/copy-patches.mjs --check && node scripts/copy-runtime-deps.mjs --check && node scripts/bundle-keepers.mjs --check"
   },
   "dependencies": {
-    "@agentclientprotocol/sdk": "^1.4.0",
+    "@agentclientprotocol/sdk": "1.4.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@napi-rs/keyring": "^1.1.3",
+    "@xterm/addon-serialize": "^0.14.0",
+    "@xterm/headless": "^6.0.0",
     "commander": "^15.0.0",
     "js-yaml": "^4.1.0",
+    "proper-lockfile": "4.1.2",
     "semver": "^7.8.5",
     "ws": "^8.18.0",
     "zod": "^4.4.3"
   },
   "devDependencies": {
+    "@qoder-ai/qoder-agent-sdk": "1.0.50",
     "@types/js-yaml": "^4.0.9",
-    "@types/node": "^20.11.0",
+    "@types/node": "^24.19.2",
+    "@types/proper-lockfile": "4.1.4",
     "@types/semver": "^7.8.0",
     "@types/ws": "^8.5.13",
+    "esbuild": "0.27.7",
     "typescript": "^5.2.2",
     "vitest": "^2.1.9"
-  }
+  },
+  "optionalDependencies": {
+    "node-pty": "1.2.0-beta.15",
+    "playwright-core": "1.63.0"
+  },
+  "axomPatchBundle": true
 }

package/skills/axom/SKILL.md

@@ -1,31 +1,31 @@
 ---
 name: axom
-description: "Work with Axomwork applications: inspect structures, query and mutate records, execute operations and services via Axomwork MCP tools"
+description: "Work with Axomwork applications: inspect structures, query and mutate records, execute operations and services, manage projects and tasks, and read or update your own account via Axomwork MCP tools"
 ---
 
 # Axomwork
 
-Use this skill when an Axomwork MCP server is connected and you need to inspect application structure, read or change business records, or execute model operations and services.
+Use this skill when an Axomwork MCP server is connected and you need to inspect application structure, read or change business records, execute model operations and services, manage projects and tasks, or read or update your own account.
 
 ## Workflow
 
-Start by discovering structure before changing records. Use `axom__struct__list_applications()` to find applications, then `axom__struct__get_model({ applicationName, modelName })` to inspect fields, operations, and record shape. Only then query, create, update, delete, upsert, or execute.
+Start by discovering structure before changing records. Use `axom__app_struct__list_applications()` to find applications, then `axom__app_struct__get_model({ applicationName, modelName })` to inspect fields, operations, and record shape. Only then query, create, update, delete, upsert, or execute.
 
 ## Core Tools
 
 - `axom__system__whoami()` - returns the current authenticated user and role.
-- `axom__struct__list_applications()` - lists available applications.
-- `axom__struct__get_application({ applicationName })` - reads one application definition.
-- `axom__struct__list_models({ applicationName })` - lists models in an application.
-- `axom__struct__get_model({ applicationName, modelName })` - reads one model definition, including attributes and operations.
-- `axom__record__query({ applicationName, modelName, criteria?, page? })` - queries records using REST-compatible filters and sorts in `criteria`.
-- `axom__record__get({ applicationName, modelName, id })` - reads one record by id.
-- `axom__record__create({ applicationName, modelName, record })` - creates a record; `record` contains model field values.
-- `axom__record__update({ applicationName, modelName, id, changes })` - updates one record; `changes` contains only the fields to modify.
-- `axom__record__upsert({ applicationName, modelName, identityField, record })` - creates or updates a record matched by `identityField`; `record` must include that field. The model must declare a `unique` validation on `identityField`, or the call throws — check `get_model` for that before calling upsert on an unfamiliar model.
-- `axom__record__delete({ applicationName, modelName, id })` - deletes one record by id.
-- `axom__operation__execute({ applicationName, modelName, operationName, input })` - executes a model operation and waits for the result. Use `axom__operation__execute_async` with the same arguments when asynchronous continuation is intended; it returns a running status and a child run id.
-- `axom__service__execute({ applicationName?, serviceName, input })` - executes a reusable platform or application-scoped service, with `axom__service__execute_async` as its non-waiting counterpart.
+- `axom__app_struct__list_applications()` - lists available applications.
+- `axom__app_struct__get_application({ applicationName })` - reads one application definition.
+- `axom__app_struct__list_models({ applicationName })` - lists models in an application.
+- `axom__app_struct__get_model({ applicationName, modelName })` - reads one model definition, including attributes and operations.
+- `axom__record_query__query_records({ applicationName, modelName, criteria?, page? })` - queries records using REST-compatible filters and sorts in `criteria`.
+- `axom__record_query__get_record({ applicationName, modelName, id })` - reads one record by id.
+- `axom__record_write__create_record({ applicationName, modelName, record })` - creates a record; `record` contains model field values.
+- `axom__record_write__update_record({ applicationName, modelName, id, changes })` - updates one record; `changes` contains only the fields to modify.
+- `axom__record_write__upsert_record({ applicationName, modelName, identityField, record })` - creates or updates a record matched by `identityField`; `record` must include that field. The model must declare a `unique` validation on `identityField`, or the call throws — check `get_model` for that before calling upsert on an unfamiliar model.
+- `axom__record_write__delete_record({ applicationName, modelName, id })` - deletes one record by id.
+- `axom__execute__run_operation({ applicationName, modelName, operationName, input })` - executes a model operation and waits for the result. Use `axom__execute__run_operation_async` with the same arguments when asynchronous continuation is intended; it returns a running status and a child run id.
+- `axom__execute__run_service({ applicationName?, serviceName, input })` - executes a reusable platform or application-scoped service, with `axom__execute__run_service_async` as its non-waiting counterpart.
 
 ## Query Criteria
 
@@ -50,7 +50,7 @@ Filter `op` values are `eq|gt|lt|like|in|and|or`. Use nested `filters` for `and`
 
 ## Upserting a Record
 
-Use `axom__record__upsert` when a stable external identifier should select an existing record or create a new one. Supply the canonical fields in this order, and include the identity value inside `record`:
+Use `axom__record_write__upsert_record` when a stable external identifier should select an existing record or create a new one. Supply the canonical fields in this order, and include the identity value inside `record`:
 For create/update/upsert safety, load guide
 `agent-integration/operating-patterns/safe-record-mutations.md`; before deletion, load
 `agent-integration/operating-patterns/destructive-actions.md`.
@@ -69,11 +69,49 @@ For create/update/upsert safety, load guide
 
 ## Execution Results
 
-`axom__operation__execute` and `axom__service__execute` return an OperationResult-style payload. Interpret `success` as the primary outcome, `text` as user-facing output, `data` as structured result data, `message` as diagnostic detail, `processing` as whether work continues asynchronously, and `runId` as the related run identifier when one is started.
+`axom__execute__run_operation` and `axom__execute__run_service` return an OperationResult-style payload. Interpret `success` as the primary outcome, `text` as user-facing output, `data` as structured result data, `message` as diagnostic detail, `processing` as whether work continues asynchronously, and `runId` as the related run identifier when one is started.
 For asynchronous continuation, load guides
 `concepts/execution/synchronous-and-task-execution.md` and
 `agent-integration/operating-patterns/following-runs.md`.
 
+## Tasks
+
+Requires the `task` scope. The acting user is always the authenticated account; never pass a user id to act as someone else.
+
+- `axom__task__list_projects({ limit?, offset? })` - lists projects you can see.
+- `axom__task__get_project({ projectId })` - reads one project.
+- `axom__task__create_project({ name, description?, prompts? })` - creates a project owned by you; `prompts` is `[{ type, content }]` with `type` one of `brainstorm`, `execute`, `validate`, `archive` (at most one each).
+- `axom__task__update_project({ projectId, name, description?, prompts? })` - renames or re-describes a project; other project settings are kept, and so are its prompts unless you pass `prompts`, which replaces them all.
+- `axom__task__delete_project({ projectId })` - deletes a project. Confirm with the user first.
+- `axom__task__list_project_members({ projectId })` - lists members and their roles.
+- `axom__task__add_project_member({ projectId, userId, type })` - adds a member; `type` is `owner` or `member`.
+- `axom__task__update_project_member({ projectId, userId, type })` - changes a member's role.
+- `axom__task__remove_project_member({ projectId, userId })` - removes a member.
+- `axom__task__list_tasks({ projectId?, parentTaskId?, status?, assigneeId?, limit?, offset? })` - lists tasks by filter.
+- `axom__task__get_task({ taskId })` - reads one task.
+- `axom__task__create_task({ projectId?, parentTaskId?, title, proposal?, status?, assigneeId? })` - creates a task; `proposal` is Markdown.
+- `axom__task__update_task({ taskId, projectId?, parentTaskId?, title, proposal?, status, assigneeId? })` - replaces a task's fields; read it first and send every field you want to keep.
+- `axom__task__delete_task({ taskId })` - deletes a task. Confirm with the user first.
+- `axom__task__list_artifacts({ taskId, kind?, status?, limit?, offset? })` - lists one page (at most 50) of a task's artifacts (insights, decisions, specs, plans), newest first, without content; `summary` is a 100-character preview. Continue with `offset: nextOffset` until `nextOffset` is null.
+- `axom__task__get_artifact({ artifactId, offset?, length? })` - reads one artifact; long content comes in windows of at most 12000 characters, continue from `nextContentOffset`.
+- `axom__task__search_artifacts({ query, taskId?, projectId?, scope?, limit? })` - searches one task's artifacts (`scope: task`) or every task in a project (`scope: project`); without `scope`, passing only `projectId` searches the project, otherwise the task.
+- `axom__task__create_artifact({ taskId, kind, title, summary, content, status? })` - records an artifact; a `final` `plan` moves a `brainstorming` task to `planned`.
+- `axom__task__update_artifact({ artifactId, kind?, title?, summary?, content?, status? })` - changes only the fields you pass.
+- `axom__task__delete_artifact({ artifactId })` - deletes an artifact; the task's status does not change. Confirm with the user first.
+- `axom__task__import_artifact({ taskId, path, kind, title, summary, status? })` - imports a Markdown file from the task's worktree (`path` is relative to it); importing the same path again updates the same artifact.
+- `axom__task__list_agent_members({ taskId })` - lists the task's live agent team.
+- `axom__task__execute_plan({ taskId })` - starts a `planned` task (`planned` becomes `in_progress`).
+
+## Your account
+
+Requires the `setting_user` scope. These tools only ever act on the authenticated user. Passwords, sessions, and access tokens are deliberately not available over MCP; manage them in Settings → Security.
+
+- `axom__setting_user__get_profile()` - gets the calling user's profile.
+- `axom__setting_user__update_profile({ displayName?, email? })` - replaces the calling user's display name and email; omitted or null fields are cleared.
+- `axom__setting_user__list_memories({ limit?, offset? })` - lists the calling user's memory facts (deleted ones excluded), newest first; `limit` defaults to 50.
+- `axom__setting_user__delete_memory({ factId })` - deletes one of the calling user's memory facts; another user's fact id answers not-found.
+- `axom__setting_user__list_workstations()` - lists the calling user's personal workstations and their status.
+
 ## Guide
 
 Axomwork ships an AI-first manual. Call `axom__guide__load` with no arguments for the table of

package/skills/axom-definition/SKILL.md

@@ -5,7 +5,7 @@ description: "Develop Axomwork application definitions with independently callab
 
 # Axomwork Definition
 
-Use this skill to edit application definitions with the canonical `axom__definition__*` MCP tools. These tools require an ADMIN token. Check `tools/list` for the specific tool before calling it.
+Use this skill to edit application definitions with the canonical `axom__app_studio__*` MCP tools. These tools require the `app_studio` scope and an administrator account. Check `tools/list` for the specific tool before calling it.
 
 Call each tool directly with camelCase arguments:
 
@@ -21,49 +21,49 @@ Load guides `agent-integration/operating-patterns/etag-write-workflow.md` and
 
 ## Applications
 
-- `axom__definition__list_applications`
-- `axom__definition__get_application` — `applicationName`
-- `axom__definition__create_application` — `application`, `expectedEtag`
-- `axom__definition__update_application` — `applicationName`, `application`, `expectedEtag`
-- `axom__definition__delete_application` — `applicationName`, `expectedEtag`
+- `axom__app_studio__list_applications`
+- `axom__app_studio__get_application` — `applicationName`
+- `axom__app_studio__create_application` — `application`, `expectedEtag`
+- `axom__app_studio__update_application` — `applicationName`, `application`, `expectedEtag`
+- `axom__app_studio__delete_application` — `applicationName`, `expectedEtag`
 
 ## Models
 
-- `axom__definition__list_models` — `applicationName`
-- `axom__definition__get_model` — `applicationName`, `modelName`
-- `axom__definition__create_model` — `applicationName`, `model`, `expectedEtag`
-- `axom__definition__update_model` — `applicationName`, `modelName`, `model`, `expectedEtag`
-- `axom__definition__delete_model` — `applicationName`, `modelName`, `expectedEtag`
+- `axom__app_studio__list_models` — `applicationName`
+- `axom__app_studio__get_model` — `applicationName`, `modelName`
+- `axom__app_studio__create_model` — `applicationName`, `model`, `expectedEtag`
+- `axom__app_studio__update_model` — `applicationName`, `modelName`, `model`, `expectedEtag`
+- `axom__app_studio__delete_model` — `applicationName`, `modelName`, `expectedEtag`
 
 ## Attributes and operations
 
-- `axom__definition__get_attribute` — `applicationName`, `modelName`, `attributeName`
-- `axom__definition__create_attribute` — `applicationName`, `modelName`, `attribute`, `expectedEtag`
-- `axom__definition__update_attribute` — `applicationName`, `modelName`, `attributeName`, `attribute`, `expectedEtag`
-- `axom__definition__delete_attribute` — `applicationName`, `modelName`, `attributeName`, `expectedEtag`
-- `axom__definition__get_operation` — `applicationName`, `modelName`, `operationName`
-- `axom__definition__create_operation` — `applicationName`, `modelName`, `operation`, `expectedEtag`
-- `axom__definition__update_operation` — `applicationName`, `modelName`, `operationName`, `operation`, `expectedEtag`
-- `axom__definition__delete_operation` — `applicationName`, `modelName`, `operationName`, `expectedEtag`
-- `axom__definition__get_operation_body` — `applicationName`, `modelName`, `operationName`
-- `axom__definition__update_operation_body` — `applicationName`, `modelName`, `operationName`, `content`, `expectedBodyEtag`
+- `axom__app_studio__get_attribute` — `applicationName`, `modelName`, `attributeName`
+- `axom__app_studio__create_attribute` — `applicationName`, `modelName`, `attribute`, `expectedEtag`
+- `axom__app_studio__update_attribute` — `applicationName`, `modelName`, `attributeName`, `attribute`, `expectedEtag`
+- `axom__app_studio__delete_attribute` — `applicationName`, `modelName`, `attributeName`, `expectedEtag`
+- `axom__app_studio__get_operation` — `applicationName`, `modelName`, `operationName`
+- `axom__app_studio__create_operation` — `applicationName`, `modelName`, `operation`, `expectedEtag`
+- `axom__app_studio__update_operation` — `applicationName`, `modelName`, `operationName`, `operation`, `expectedEtag`
+- `axom__app_studio__delete_operation` — `applicationName`, `modelName`, `operationName`, `expectedEtag`
+- `axom__app_studio__get_operation_body` — `applicationName`, `modelName`, `operationName`
+- `axom__app_studio__update_operation_body` — `applicationName`, `modelName`, `operationName`, `content`, `expectedBodyEtag`
 
 ## Triggers and lifecycle
 
-- `axom__definition__update_triggers` — `applicationName`, `modelName`, `triggers`, `expectedEtag`
-- `axom__definition__get_lifecycle` — `applicationName`, `modelName`
-- `axom__definition__update_lifecycle` — `applicationName`, `modelName`, `lifecycle`, `expectedEtag`
-- `axom__definition__delete_lifecycle` — `applicationName`, `modelName`, `expectedEtag`
+- `axom__app_studio__update_triggers` — `applicationName`, `modelName`, `triggers`, `expectedEtag`
+- `axom__app_studio__get_lifecycle` — `applicationName`, `modelName`
+- `axom__app_studio__update_lifecycle` — `applicationName`, `modelName`, `lifecycle`, `expectedEtag`
+- `axom__app_studio__delete_lifecycle` — `applicationName`, `modelName`, `expectedEtag`
 
 ## Workflows
 
-- `axom__definition__list_workflows` — `applicationName`, `modelName`
-- `axom__definition__get_workflow` — `applicationName`, `modelName`, `workflowName`
-- `axom__definition__create_workflow` — `applicationName`, `modelName`, `workflow`, `expectedEtag`
-- `axom__definition__update_workflow` — `applicationName`, `modelName`, `workflowName`, `workflow`, `expectedEtag`
-- `axom__definition__delete_workflow` — `applicationName`, `modelName`, `workflowName`, `expectedEtag`
-- `axom__definition__get_workflow_body` — `applicationName`, `modelName`, `workflowName`
-- `axom__definition__update_workflow_body` — `applicationName`, `modelName`, `workflowName`, `content`, `expectedBodyEtag`
+- `axom__app_studio__list_workflows` — `applicationName`, `modelName`
+- `axom__app_studio__get_workflow` — `applicationName`, `modelName`, `workflowName`
+- `axom__app_studio__create_workflow` — `applicationName`, `modelName`, `workflow`, `expectedEtag`
+- `axom__app_studio__update_workflow` — `applicationName`, `modelName`, `workflowName`, `workflow`, `expectedEtag`
+- `axom__app_studio__delete_workflow` — `applicationName`, `modelName`, `workflowName`, `expectedEtag`
+- `axom__app_studio__get_workflow_body` — `applicationName`, `modelName`, `workflowName`
+- `axom__app_studio__update_workflow_body` — `applicationName`, `modelName`, `workflowName`, `content`, `expectedBodyEtag`
 
 ## Guide