recess-cli 2.6.1 → 2.8.0

package/dist/commands/apps.js

@@ -1,8 +1,9 @@
+import { createHash } from "node:crypto";
 import fs from "node:fs/promises";
 import http from "node:http";
 import path from "node:path";
 import { unwrap } from "../api.js";
-import { flagString, hasFlag } from "../args.js";
+import { flagNumber, flagString, hasFlag } from "../args.js";
 import { CliError } from "../errors.js";
 import { positional } from "./shared.js";
 const PROJECT_FILE = ".recess/app.json";
@@ -12,6 +13,13 @@ const BRIEF_FILE = "brief.md";
 const SKIP_DIRS = new Set([".recess", ".git", "node_modules"]);
 const MAX_FILE_BYTES = 512 * 1024;
 const TERMINAL = new Set(["COMPLETE", "FAILED", "REJECTED"]);
+export const APP_BUNDLE_EDITABLE_FILES = [
+    "skill.js",
+    "model.js",
+    "model.css",
+    "params.schema.json",
+    "params.json",
+];
 async function readAppLink(dir) {
     try {
         const raw = await fs.readFile(path.join(dir, PROJECT_FILE), "utf8");
@@ -72,6 +80,22 @@ function resolveDir(ctx, positionalIndex) {
     const fromPositional = ctx.parsed.positionals[positionalIndex];
     return path.resolve(flag ?? fromPositional ?? ".");
 }
+function assertRemoteShape(ctx, allowedFlags, positionals) {
+    if (ctx.parsed.positionals.length < positionals.min ||
+        ctx.parsed.positionals.length > positionals.max) {
+        throw new CliError("invalid_arguments", "The hosted command shape does not match its remote usage. Run `help apps`.");
+    }
+    const allowed = new Set([
+        "reason",
+        "confirm",
+        "operation-key",
+        ...allowedFlags,
+    ]);
+    const denied = [...ctx.parsed.flags.keys()].find((flag) => !allowed.has(flag));
+    if (denied) {
+        throw new CliError("remote_flag_unavailable", `--${denied} is not available for this hosted command.`);
+    }
+}
 async function readContract(dir) {
     const raw = await fs
         .readFile(path.join(dir, CONTRACT_FILE), "utf8")
@@ -212,6 +236,106 @@ function agentsGuide(docs) {
         "",
     ].join("\n");
 }
+function editableFilesFrom(files) {
+    return Object.fromEntries(APP_BUNDLE_EDITABLE_FILES.map((name) => [name, files[name] ?? ""]));
+}
+function canonicalJson(value) {
+    if (Array.isArray(value)) {
+        return `[${value.map(canonicalJson).join(",")}]`;
+    }
+    if (value && typeof value === "object") {
+        return `{${Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, entry]) => `${JSON.stringify(key)}:${canonicalJson(entry)}`)
+            .join(",")}}`;
+    }
+    return JSON.stringify(value) ?? "null";
+}
+function parseAppBundle(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new CliError("invalid_arguments", "input.appBundle must be an AppBundle object.");
+    }
+    const bundle = value;
+    const allowedBundleKeys = new Set([
+        "projectId",
+        "baseVersion",
+        "sourceTodoId",
+        "files",
+        "contract",
+        "manifest",
+    ]);
+    const unexpectedBundleKeys = Object.keys(bundle).filter((key) => !allowedBundleKeys.has(key));
+    if (unexpectedBundleKeys.length > 0) {
+        throw new CliError("invalid_arguments", "input.appBundle contains unsupported fields.", 1, { unexpected: unexpectedBundleKeys });
+    }
+    const files = bundle.files;
+    if (!files || typeof files !== "object" || Array.isArray(files)) {
+        throw new CliError("invalid_arguments", "input.appBundle.files must contain the five editable Studio files.");
+    }
+    const fileRecord = files;
+    const unexpected = Object.keys(fileRecord).filter((name) => !APP_BUNDLE_EDITABLE_FILES.includes(name));
+    const missing = APP_BUNDLE_EDITABLE_FILES.filter((name) => typeof fileRecord[name] !== "string");
+    if (unexpected.length || missing.length) {
+        throw new CliError("invalid_arguments", "An AppBundle accepts exactly skill.js, model.js, model.css, params.schema.json, and params.json.", 1, { unexpected, missing });
+    }
+    const manifest = bundle.manifest;
+    if (!manifest || typeof manifest !== "object" || Array.isArray(manifest)) {
+        throw new CliError("invalid_arguments", "input.appBundle.manifest is required.");
+    }
+    const title = manifest.title;
+    if (typeof title !== "string" || !title.trim()) {
+        throw new CliError("invalid_arguments", "input.appBundle.manifest.title is required.");
+    }
+    if (!bundle.contract ||
+        typeof bundle.contract !== "object" ||
+        Array.isArray(bundle.contract)) {
+        throw new CliError("invalid_arguments", "input.appBundle.contract must be a BuildContract object.");
+    }
+    if (bundle.baseVersion !== undefined &&
+        (!Number.isInteger(bundle.baseVersion) || Number(bundle.baseVersion) < 1)) {
+        throw new CliError("invalid_arguments", "input.appBundle.baseVersion must be a positive integer.");
+    }
+    return bundle;
+}
+function bundleSummary(bundle) {
+    return {
+        projectId: bundle.projectId ?? null,
+        baseVersion: bundle.baseVersion ?? null,
+        sourceTodoId: bundle.sourceTodoId ?? null,
+        title: bundle.manifest.title,
+        contractSha256: createHash("sha256")
+            .update(canonicalJson(bundle.contract))
+            .digest("hex"),
+        manifestSha256: createHash("sha256")
+            .update(canonicalJson(bundle.manifest))
+            .digest("hex"),
+        files: Object.fromEntries(APP_BUNDLE_EDITABLE_FILES.map((name) => {
+            const content = bundle.files[name];
+            return [
+                name,
+                {
+                    bytes: Buffer.byteLength(content, "utf8"),
+                    sha256: createHash("sha256").update(content).digest("hex"),
+                },
+            ];
+        })),
+    };
+}
+async function scaffoldResult(ctx, forTodo) {
+    const scaffold = unwrap(await ctx.api.client.GET("/studio/scaffold"));
+    const analysis = forTodo
+        ? unwrap(await ctx.api.client.GET("/studio/todos/{todoId}/analysis", {
+            params: { path: { todoId: forTodo } },
+        }))
+        : null;
+    return {
+        allFiles: scaffold.files,
+        editableFiles: editableFilesFrom(scaffold.files),
+        authoringInstructions: agentsGuide(scaffold.docs),
+        ...(scaffold.docs.forks ? { forkGuidance: scaffold.docs.forks } : {}),
+        ...(analysis ? { brief: briefFor(analysis), todo: analysis } : {}),
+    };
+}
 async function pollBuild(ctx, buildId, timeoutMs) {
     const started = Date.now();
     let delay = 3_000;
@@ -300,6 +424,143 @@ async function assign(ctx, projectId, body) {
 export async function runAppsCommand(ctx) {
     const { parsed, api } = ctx;
     const verb = parsed.positionals[1];
+    if (ctx.transport === "remote") {
+        if (verb === "scaffold") {
+            assertRemoteShape(ctx, ["for-todo"], { min: 2, max: 2 });
+            const result = await scaffoldResult(ctx, flagString(parsed, "for-todo"));
+            return {
+                authoringInstructions: result.authoringInstructions,
+                editableFiles: result.editableFiles,
+                ...(result.forkGuidance ? { forkGuidance: result.forkGuidance } : {}),
+                ...(result.brief ? { learnerBrief: result.brief } : {}),
+                ...(result.todo
+                    ? {
+                        sourceTodoId: result.todo.todo.id,
+                        studentId: result.todo.todo.studentId,
+                    }
+                    : {}),
+            };
+        }
+        if (verb === "validate") {
+            assertRemoteShape(ctx, [], { min: 2, max: 2 });
+            const bundle = parseAppBundle(ctx.structuredInput?.appBundle);
+            return ctx.writeCommand(parsed, {
+                action: bundle.projectId
+                    ? "save a new private Studio app revision and queue validation"
+                    : "create a private Studio app and queue validation",
+                target: bundleSummary(bundle),
+                request: { command: "apps validate" },
+                details: {
+                    consequence: "Studio merges these five files into its locked scaffold, stores one immutable revision, and validates it asynchronously. Nothing is published.",
+                },
+            }, async () => unwrap(await api.client.POST("/studio/apps/validate", {
+                body: { appBundle: bundle },
+            })));
+        }
+        if (verb === "pull") {
+            assertRemoteShape(ctx, [], { min: 3, max: 3 });
+            const projectId = positional(parsed, 2, "project id");
+            const project = unwrap(await api.client.GET("/studio/projects/{projectId}/bundle", {
+                params: { path: { projectId } },
+            }));
+            const sourceTodoId = project.appBundle.sourceTodoId;
+            if (!sourceTodoId)
+                return project;
+            const todoContext = unwrap(await api.client.GET("/studio/todos/{todoId}/analysis", {
+                params: { path: { todoId: sourceTodoId } },
+            }));
+            return {
+                ...project,
+                learnerBrief: briefFor(todoContext),
+                studentId: todoContext.todo.studentId,
+            };
+        }
+        if (verb === "preview") {
+            assertRemoteShape(ctx, ["version"], { min: 3, max: 3 });
+            const projectId = positional(parsed, 2, "project id");
+            const version = flagNumber(parsed, "version");
+            if (!Number.isInteger(version) || Number(version) < 1) {
+                throw new CliError("invalid_arguments", "Hosted preview requires --version <positive integer>.");
+            }
+            return unwrap(await api.client.POST("/studio/projects/{projectId}/preview", {
+                params: { path: { projectId } },
+                body: { versionNumber: version },
+            }));
+        }
+        if (verb === "publish") {
+            assertRemoteShape(ctx, ["version"], { min: 3, max: 3 });
+            const projectId = positional(parsed, 2, "project id");
+            const version = flagNumber(parsed, "version");
+            if (!Number.isInteger(version) || Number(version) < 1) {
+                throw new CliError("invalid_arguments", "Hosted publish requires --version <positive integer>.");
+            }
+            return ctx.writeCommand(parsed, {
+                action: "publish an exact validated Studio app revision",
+                target: { projectId, versionNumber: version },
+                request: { command: "apps publish" },
+                details: {
+                    consequence: "Studio rechecks the named current revision, queues its independent reviewer, and publishes only that exact revision if it passes.",
+                },
+            }, async () => unwrap(await api.client.POST("/studio/projects/{projectId}/publish", {
+                params: { path: { projectId } },
+                body: { versionNumber: version },
+            })));
+        }
+        if (verb === "assign") {
+            assertRemoteShape(ctx, ["student", "due"], { min: 3, max: 3 });
+            const projectId = positional(parsed, 2, "project id");
+            const studentId = flagString(parsed, "student", { required: true });
+            const dueDate = flagString(parsed, "due");
+            if (dueDate && !/^\d{4}-\d{2}-\d{2}$/.test(dueDate)) {
+                throw new CliError("invalid_arguments", "--due must be YYYY-MM-DD.");
+            }
+            const project = unwrap(await api.client.GET("/studio/projects/{projectId}/bundle", {
+                params: { path: { projectId } },
+            }));
+            const sourceTodoId = project.appBundle.sourceTodoId;
+            return ctx.writeCommand(parsed, {
+                action: "assign a published Studio app to a student",
+                target: { projectId, studentId },
+                request: {
+                    dueDate: dueDate ?? null,
+                    sourceTodoId: sourceTodoId ?? null,
+                },
+            }, () => assign(ctx, projectId, {
+                studentId,
+                ...(dueDate ? { dueDate } : {}),
+                ...(sourceTodoId ? { sourceTodoId } : {}),
+            }));
+        }
+        if (verb === "list") {
+            assertRemoteShape(ctx, [], { min: 2, max: 2 });
+            return unwrap(await api.client.GET("/studio/projects"));
+        }
+        if (verb === "status") {
+            assertRemoteShape(ctx, [], { min: 3, max: 3 });
+            const buildId = positional(parsed, 2, "build id");
+            return unwrap(await api.client.GET("/studio/builds/{buildId}", {
+                params: { path: { buildId } },
+            }));
+        }
+        if (verb !== "standards") {
+            throw new CliError("remote_command_unavailable", `apps ${verb ?? ""} is not available over hosted MCP.`);
+        }
+    }
+    if (verb === "scaffold") {
+        const result = await scaffoldResult(ctx, flagString(parsed, "for-todo"));
+        return {
+            authoringInstructions: result.authoringInstructions,
+            editableFiles: result.editableFiles,
+            ...(result.forkGuidance ? { forkGuidance: result.forkGuidance } : {}),
+            ...(result.brief ? { learnerBrief: result.brief } : {}),
+            ...(result.todo
+                ? {
+                    sourceTodoId: result.todo.todo.id,
+                    studentId: result.todo.todo.studentId,
+                }
+                : {}),
+        };
+    }
     if (verb === "init") {
         const dir = path.resolve(positional(parsed, 2, "app folder"));
         await fs.mkdir(dir, { recursive: true });
@@ -308,45 +569,40 @@ export async function runAppsCommand(ctx) {
             throw new CliError("invalid_arguments", `${dir} is not empty. Use --force to write the scaffold over it.`);
         }
         const forTodo = flagString(parsed, "for-todo");
-        const analysis = forTodo
-            ? unwrap(await api.client.GET("/studio/todos/{todoId}/analysis", {
-                params: { path: { todoId: forTodo } },
-            }))
-            : null;
-        const scaffold = unwrap(await api.client.GET("/studio/scaffold"));
-        const written = await writeFiles(dir, scaffold.files);
-        await fs.writeFile(path.join(dir, "AGENTS.md"), agentsGuide(scaffold.docs));
-        if (scaffold.docs.forks) {
-            await fs.writeFile(path.join(dir, "FORKS.md"), scaffold.docs.forks);
+        const scaffold = await scaffoldResult(ctx, forTodo);
+        const written = await writeFiles(dir, scaffold.allFiles);
+        await fs.writeFile(path.join(dir, "AGENTS.md"), scaffold.authoringInstructions);
+        if (scaffold.forkGuidance) {
+            await fs.writeFile(path.join(dir, "FORKS.md"), scaffold.forkGuidance);
         }
-        if (analysis) {
-            await fs.writeFile(path.join(dir, BRIEF_FILE), briefFor(analysis));
+        if (scaffold.todo && scaffold.brief) {
+            await fs.writeFile(path.join(dir, BRIEF_FILE), scaffold.brief);
             await writeAppLink(dir, {
-                forTodoId: analysis.todo.id,
-                studentId: analysis.todo.studentId,
+                forTodoId: scaffold.todo.todo.id,
+                studentId: scaffold.todo.todo.studentId,
             });
         }
         return {
             dir,
-            filesWritten: written + (analysis ? 2 : 1),
-            ...(analysis
+            filesWritten: written + (scaffold.todo ? 2 : 1),
+            ...(scaffold.todo
                 ? {
                     brief: BRIEF_FILE,
-                    studentId: analysis.todo.studentId,
-                    standards: analysis.standards.map((s) => s.notation),
-                    misconceptions: analysis.analysis.patterns.map((p) => p.instanceKey ?? slug(p.name)),
+                    studentId: scaffold.todo.todo.studentId,
+                    standards: scaffold.todo.standards.map((s) => s.notation),
+                    misconceptions: scaffold.todo.analysis.patterns.map((p) => p.instanceKey ?? slug(p.name)),
                 }
                 : {}),
             next: [
                 `cd ${dir}`,
-                analysis
+                scaffold.todo
                     ? "Open the folder with your agent: brief.md is the assignment, AGENTS.md the contract."
                     : "Open the folder with your agent and describe what the app should teach (AGENTS.md has the contract).",
                 "Customizing the wrong-answer detour? FORKS.md explains the fork and how to shape it per misconception.",
                 'recess apps preview --reason "See it in my browser"',
                 'recess apps validate --reason "Check my app"',
-                analysis
-                    ? `recess apps publish --assign ${analysis.todo.studentId} --reason "Ship it to the kid"`
+                scaffold.todo
+                    ? `recess apps publish --assign ${scaffold.todo.todo.studentId} --reason "Ship it to the kid"`
                     : 'recess apps publish --reason "Ship my app"',
             ],
         };
@@ -475,6 +731,9 @@ export async function runAppsCommand(ctx) {
         throw new CliError("invalid_arguments", "Use: apps primitives list | apps primitives publish <file.js> --name <kebab-name> [--description TEXT].");
     }
     if (verb === "standards") {
+        if (ctx.transport === "remote") {
+            assertRemoteShape(ctx, [], { min: 3, max: Number.MAX_SAFE_INTEGER });
+        }
         const q = parsed.positionals.slice(2).join(" ").trim();
         if (!q) {
             throw new CliError("invalid_arguments", 'Give words or a notation: recess apps standards "grade 4 adding fractions".');

package/dist/commands/mastery.js

@@ -0,0 +1,214 @@
+import { createHash } from "node:crypto";
+import { unwrap } from "../api.js";
+import { flagString, hasFlag } from "../args.js";
+import { CliError } from "../errors.js";
+import { getJob } from "../jobs.js";
+import { assertChoice, positional, readJsonFile, } from "./shared.js";
+const hash = (value) => createHash("sha256").update(JSON.stringify(value)).digest("hex");
+// Replay the exact approved request, without requiring mutable preview sources
+// to remain available after a successful write whose response was lost.
+async function executeApproved(api, preview) {
+    const body = preview.request;
+    switch (preview.action) {
+        case "mastery.link":
+            return unwrap(await api.client.POST("/ai/rcs/content-links", {
+                body: body,
+            }));
+        case "mastery.unlink":
+            return unwrap(await api.client.DELETE("/ai/rcs/content-links/{id}", {
+                params: { path: { id: String(body.id) } },
+            }));
+        case "mastery.publish":
+            return unwrap(await api.client.POST("/ai/rcs/drafts/{id}/promote", {
+                params: { path: { id: String(preview.target.draftId) } },
+                body,
+            }));
+        case "mastery.edit":
+            return "graphJson" in body
+                ? unwrap(await api.client.POST("/ai/rcs/drafts", {
+                    body: body,
+                }))
+                : unwrap(await api.client.POST("/ai/rcs/edits/propose", {
+                    body: body,
+                }));
+        default:
+            throw new CliError("approval_mismatch", "Unknown approved mastery action.");
+    }
+}
+export async function runMasteryCommand({ parsed, api, writeCommand: gate, }) {
+    // These commands curate shared school curriculum, not a family's private plan.
+    const session = unwrap(await api.client.GET("/auth/admin-cli/session/"));
+    if (session.user.role !== "ADMIN" || session.cliScope !== "full_admin")
+        throw new CliError("forbidden", "Mastery curriculum commands require a full-admin session.");
+    const verb = parsed.positionals[1];
+    const isWrite = ["edit", "publish", "link", "unlink"].includes(verb ?? "");
+    const file = isWrite ? flagString(parsed, "file") : undefined;
+    const invocation = hash({
+        actorId: session.user.id,
+        apiOrigin: api.config.apiOrigin,
+        positionals: parsed.positionals,
+        flags: [...parsed.flags]
+            .filter(([key]) => !["confirm", "operation-key", "json", "reason"].includes(key))
+            .sort(([a], [b]) => a.localeCompare(b)),
+        ...(file
+            ? { graphJson: await readJsonFile(file, "Edited graph JSON") }
+            : {}),
+    });
+    const writeCommand = (args, preview, execute) => gate(args, { ...preview, details: { ...preview.details, invocation } }, execute);
+    if (isWrite && hasFlag(parsed, "confirm")) {
+        const key = flagString(parsed, "operation-key", { required: true });
+        const { history } = await getJob(key);
+        const approved = history.find((event) => event.status === "awaiting_confirmation")?.preview;
+        if (!approved || approved.details?.invocation !== invocation)
+            throw new CliError("approval_mismatch", "Run an unchanged preview on this machine before confirming. The command, file, account, and API must match.");
+        return gate(parsed, approved, () => executeApproved(api, approved));
+    }
+    if (verb === "graphs") {
+        return unwrap(await api.client.GET("/ai/rcs/graphs", {
+            params: { query: { domainSlug: flagString(parsed, "domain") } },
+        }));
+    }
+    if (verb === "get" || verb === "edit" || verb === "publish") {
+        const id = positional(parsed, 2, "graph artifact ID");
+        const kind = verb === "publish"
+            ? "draft"
+            : assertChoice(flagString(parsed, "kind") ?? "release", ["seed", "draft", "release"], "--kind");
+        const artifact = unwrap(await api.client.GET("/ai/rcs/graphs/artifact", {
+            params: { query: { kind, id } },
+        }));
+        if (verb === "get")
+            return artifact;
+        const graph = artifact.draft ?? artifact.release ?? artifact.seed;
+        if (!graph)
+            throw new CliError("not_found", "Graph artifact not found.");
+        if (verb === "publish") {
+            const expected = flagString(parsed, "expected-active-release", {
+                required: true,
+            });
+            const body = {
+                expectedActiveReleaseId: expected === "none" ? null : expected,
+                expectedDraftUpdatedAt: artifact.draft.updatedAt,
+            };
+            return writeCommand(parsed, {
+                action: "mastery.publish",
+                target: {
+                    draftId: id,
+                    title: graph.title,
+                    domainSlug: graph.domainSlug,
+                },
+                request: body,
+                details: {
+                    graphSha256: hash(graph.graphJson),
+                    consequence: "Makes this draft the active curriculum graph. Retires the previous release. Existing content links stay on their original release and need review/relinking. First publication may queue historical todo evidence backfill.",
+                },
+            }, async () => unwrap(await api.client.POST("/ai/rcs/drafts/{id}/promote", {
+                params: { path: { id } },
+                body,
+            })));
+        }
+        const file = flagString(parsed, "file");
+        const instruction = flagString(parsed, "instruction");
+        const node = flagString(parsed, "node");
+        if (Boolean(file) === Boolean(instruction))
+            throw new CliError("invalid_arguments", "Provide exactly one of --file (edited graph JSON) or --instruction.");
+        const target = {
+            kind,
+            id,
+            title: graph.title,
+            domainSlug: graph.domainSlug,
+        };
+        if (file) {
+            if (node)
+                throw new CliError("invalid_arguments", "--node is only used with --instruction.");
+            const graphJson = await readJsonFile(file, "Edited graph JSON");
+            if (graphJson.domainSlug !== graph.domainSlug)
+                throw new CliError("invalid_arguments", "The edited graph must keep the source domainSlug.");
+            if (typeof graphJson.title !== "string" || !graphJson.title.trim())
+                throw new CliError("invalid_arguments", "The edited graph requires a title.");
+            const body = {
+                domainSlug: graph.domainSlug,
+                title: graphJson.title,
+                graphJson,
+            };
+            return writeCommand(parsed, {
+                action: "mastery.edit",
+                target,
+                request: body,
+                details: {
+                    sourceGraphSha256: hash(graph.graphJson),
+                    consequence: "Saves a NEW draft; does not overwrite or publish the current graph. No AI generation.",
+                },
+            }, async () => unwrap(await api.client.POST("/ai/rcs/drafts", { body })));
+        }
+        if (kind === "seed")
+            throw new CliError("invalid_arguments", "Use --file for seed graphs; instruction editing requires a draft or release.");
+        const body = {
+            ...(kind === "draft" ? { draftId: id } : { releaseId: id }),
+            feedback: [
+                { instruction: instruction, ...(node ? { objectiveId: node } : {}) },
+            ],
+        };
+        return writeCommand(parsed, {
+            action: "mastery.edit",
+            target,
+            request: body,
+            details: {
+                sourceGraphSha256: hash(graph.graphJson),
+                consequence: "Runs paid AI editing and saves a proposed draft for review. Does not publish. A node is context, not a strict boundary: related nodes may change.",
+            },
+        }, async () => unwrap(await api.client.POST("/ai/rcs/edits/propose", { body })));
+    }
+    if (verb === "links") {
+        const graphReleaseId = flagString(parsed, "graph", { required: true });
+        return unwrap(await api.client.GET("/ai/rcs/content-links", {
+            params: {
+                query: {
+                    graphReleaseId,
+                    objectiveId: flagString(parsed, "node"),
+                    cursor: flagString(parsed, "cursor"),
+                },
+            },
+        }));
+    }
+    if (verb === "link") {
+        const contentType = assertChoice(flagString(parsed, "type", { required: true }), ["applet", "goal"], "--type");
+        const body = {
+            graphReleaseId: flagString(parsed, "graph", { required: true }),
+            contentType: contentType === "applet" ? "APPLET" : "GOAL",
+            contentId: positional(parsed, 2, "content ID"),
+            objectiveId: flagString(parsed, "node"),
+        };
+        const preview = unwrap(await api.client.GET("/ai/rcs/content-links/preview", {
+            params: { query: body },
+        }));
+        return writeCommand(parsed, {
+            action: "mastery.link",
+            target: {
+                graphReleaseId: body.graphReleaseId,
+                contentId: body.contentId,
+            },
+            request: body,
+            details: {
+                ...preview,
+                consequence: "Adds a curriculum association on this release only. Does not assign work, grant XP, or change mastery.",
+            },
+        }, async () => unwrap(await api.client.POST("/ai/rcs/content-links", { body })));
+    }
+    if (verb === "unlink") {
+        const id = positional(parsed, 2, "link ID");
+        // The immutable link ID is obtained from `mastery links`; deletion is
+        // idempotent so an interrupted confirmed invocation can safely be retried.
+        return writeCommand(parsed, {
+            action: "mastery.unlink",
+            target: { linkId: id },
+            request: { id },
+            details: {
+                consequence: "Removes only this curriculum link, not the applet, goal, graph, or learner evidence.",
+            },
+        }, async () => unwrap(await api.client.DELETE("/ai/rcs/content-links/{id}", {
+            params: { path: { id } },
+        })));
+    }
+    throw new CliError("unknown_command", "Use recess help mastery.");
+}
+//# sourceMappingURL=mastery.js.map

package/dist/commands/onboarding.js

@@ -95,10 +95,6 @@ function suggestedCommandsForQueueAction(action, familyId) {
                 `recess onboarding active-tutors ${familyId}`,
                 `recess onboarding set-primary-tutor ${familyId} --tutor <user-id>`,
             ];
-        case "attest":
-            return [
-                `recess onboarding attest ${familyId} --condition <app_downloaded|tutor_met|goals_loaded|ma_diagnostic>`,
-            ];
         case "clear_for_cohort":
             return [`recess onboarding clear-for-cohort ${familyId}`];
         case "register_cohort":
@@ -111,8 +107,6 @@ function suggestedCommandsForQueueAction(action, familyId) {
                 `recess onboarding readiness ${familyId}`,
                 `recess onboarding timeline ${familyId}`,
             ];
-        case "mark_complete":
-            return [`recess onboarding set-stage ${familyId} --stage COMPLETE`];
         default:
             return [];
     }
@@ -478,7 +472,7 @@ export async function runOnboardingCommand({ parsed, api, writeCommand, }) {
         if (verb === "clear-for-cohort") {
             const familyId = positional(parsed, 2, "family ID");
             return writeCommand(parsed, {
-                action: "clear the family for cohort placement after the server rechecks stage, account, kids, goals, tutor, and attestations",
+                action: "clear the family for cohort placement after the server rechecks stage, account state, and that it has kids (goals, tutor and gate notes are not required)",
                 target: { familyId },
                 request: {},
             }, async () => unwrap(await api.client.POST("/admin/onboarding/families/{familyId}/clear-for-cohort", { params: { path: { familyId } } })));

package/dist/commands/school.js

@@ -268,7 +268,7 @@ export async function runSchoolCommand({ parsed, api, writeCommand, }) {
             request: { familyId, kidIds },
             details: {
                 kids: kidIds.map((id) => kidName(known.get(id)?.firstName ?? null, null, id)),
-                billing: "Default membership price unless the family is grandfathered onto one, with a 1-day trial, confirmed against the customer's saved default payment method.",
+                billing: "Default membership price unless the family is grandfathered onto one, with a 1-hour trial for restarts, confirmed against the customer's saved default payment method.",
                 note: "A kid whose membership is already ACTIVE comes back `skipped_active` rather than being charged twice; per-kid failures are reported in `results`, not thrown.",
             },
         }, async () => unwrap(await api.client.POST("/admin/memberships/start", {