@taskset/cli 5.1.0 → 6.1.0

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # @taskset/cli
 
+## 6.1.0
+
+### Minor Changes
+
+- Add operational memory document kinds (`lesson`, `concern`, `audit`), program rollup, optional closeout gates, and taxonomy allowlists.
+  
+  Agents can create and query lessons, concerns, and audits under `.taskset/` with the same document command surface as existing kinds. `taskset task program` summarizes parent-task programs. Optional `closeout`, `taxonomy`, and `doctor` config keep defaults compatible with existing repositories. `taskset sync` creates the new directories.
+
+### Patch Changes
+
+- Updated dependencies
+  - @taskset/contracts@6.1.0
+  - @taskset/core@6.1.0
+
+## 6.0.0
+
+### Major Changes
+
+- Make Taskset agent-first and polyglot-friendly: discover repositories by `.taskset/`, treat `taskset.config.ts` as optional, support package-runner and global installs, and split docs for humans and agents.
+- 89c31c3: Replace sequential and ULID entity IDs with immutable 5-6 character lowercase hex IDs.
+  
+  Filenames are now `{sequence}-{slug}-{id}.md`. `taskset sync` and `task migrate-ids` migrate legacy IDs, normalize filenames, repair duplicate sequence prefixes by `createdAt`, and rewrite repository references. Default task and document list sorting uses `createdAt` so creation order remains stable. Agents and commands must cite the short `id`, not the mutable sequence prefix.
+
+### Patch Changes
+
+- Updated dependencies
+- Updated dependencies [89c31c3]
+  - @taskset/core@6.0.0
+  - @taskset/contracts@6.0.0
+
 ## 5.1.0
 
 ### Minor Changes

package/README.md

@@ -1,42 +1,41 @@
 # @taskset/cli
 
-The public command-line adapter for Taskset. Full documentation is available at
-[taskset.false.foundation](https://taskset.false.foundation/), including the
-[complete CLI reference](./docs/cli-reference.md).
+The public command-line adapter for Taskset, the Git-native workspace for plans, research, decisions, runbooks, lessons, concerns, audits, and executable tasks. Full documentation is on [taskset.false.foundation](https://taskset.false.foundation/), including the [CLI reference](./docs/cli-reference.md), [document types](./docs/document-types.md), [memory model](./docs/memory-model.md), and [agent guide](./docs/agents/index.md).
 
-The published package also ships the repository `docs/` tree and `skills/` tree
-beside the CLI so installed projects can load offline references from
-`node_modules/@taskset/cli/docs` and `node_modules/@taskset/cli/skills`.
+The published package ships the repository `docs/` and `skills/` trees beside the CLI so agents can load offline references from `node_modules/@taskset/cli/docs` and `node_modules/@taskset/cli/skills`.
+
+## Install
 
 ```bash
+npx @taskset/cli@latest init
+pnpm dlx @taskset/cli init
 pnpm add --save-dev @taskset/cli
-pnpm taskset init
-pnpm taskset task create --title "Document the release"
+npm install --global @taskset/cli
 ```
 
-The package owns argument tokenization, Zod-backed command validation, output,
-and exit-code mapping. Repository behavior is delegated to `@taskset/core`.
+```bash
+taskset document create research --title "Evaluate release options"
+taskset task create --title "Ship the release notes" --related your_research_id_here
+taskset document list --json
+taskset task list --json
+```
 
-Supported command groups:
+The package owns argument tokenization, Zod-backed command validation, output, and exit-code mapping. Repository behavior is delegated to `@taskset/core`.
+
+## Commands
 
 - `taskset init`, `config`, `doctor`, `generate`, and `sync`
 - `taskset task create|list|show|update|status|delete|migrate-ids`
 - `taskset document create|import|batch|list|show|update|status|delete` (`doc` is an alias)
 - `taskset snapshot create|list|restore`
 
-Use `task list --file <path> --impact` for direct and transitive code-impact
-queries. Repeated path values use OR, distinct filter categories use AND,
-repeated labels require every label, and planning or timestamp ranges are
-inclusive. Filters include
-`--estimate-min`/`--estimate-max`, `--effort-min`/`--effort-max`,
-`--duplicate`, `--sort order`, and due/created/updated before/after bounds.
-`tasks-for-file` was removed.
+`init` creates `.taskset/` for tasks, stories, flows, decisions, research, runbooks, lessons, concerns, and audits without requiring a config file. Pass `--config` for optional `taskset.config.ts`.
+
+Exit code `0` means success, `1` means a repository or domain failure, and `2` means invalid CLI usage. Commands reserve stdout for requested output and send diagnostics to stderr.
 
-Exit code `0` means success, `1` means a repository or domain failure, and `2`
-means invalid CLI usage. Commands reserve stdout for requested output and send
-diagnostics or generation warnings to stderr.
+## Optional config helper
 
-`defineConfig` is re-exported for `taskset.config.ts`:
+`defineConfig` is re-exported for optional `taskset.config.ts`:
 
 ```typescript
 import { defineConfig } from '@taskset/cli'

package/dist/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAuGA,MAAM,WAAW,UAAU;IAC1B,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IACzC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;CACzC;AAwuBD,wBAAsB,MAAM,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,EAAE,OAAO,GAAE,UAAe,GAAG,OAAO,CAAC,MAAM,CAAC,CAy4B/F"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AA6GA,MAAM,WAAW,UAAU;IAC1B,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IACzC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;CACzC;AAgvBD,wBAAsB,MAAM,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,EAAE,OAAO,GAAE,UAAe,GAAG,OAAO,CAAC,MAAM,CAAC,CAy7B/F"}

package/dist/cli.js

@@ -1,11 +1,11 @@
 import { readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { parseArgs } from 'node:util';
-import { DocumentIdSchema, DocumentStatusSchema, DocumentTimestampSchema, TaskIdSchema, TaskPrioritySchema, TaskRiskSchema, TaskStatusSchema, TaskTimestampSchema, } from '@taskset/contracts';
-import { buildDocumentGraph, buildTaskIndex, createDocument, createSnapshot, createTask, DOCUMENT_SORT_DIRECTIONS, DOCUMENT_SORT_KEYS, DocumentQuerySchema, deleteDocument, deleteTask, diagnoseRepository, discoverRepository, executeDocumentBatch, generateViews, importDocument, initializeRepository, listDocuments, listSnapshots, migrateTaskIds, normalizeDocumentKind, normalizeRepositoryPath, queryDocuments, queryTasks, RepositoryPathError, readDocument, readTask, restoreSnapshot, serializeDocumentFile, serializeTaskFile, syncRepository, TASK_SORT_DIRECTIONS, TASK_SORT_KEYS, TaskQuerySchema, updateDocument, updateTask, } from '@taskset/core';
+import { ConcernClassSchema, DocumentIdSchema, DocumentStatusSchema, DocumentTimestampSchema, LessonSeveritySchema, TaskIdSchema, TaskPrioritySchema, TaskRiskSchema, TaskStatusSchema, TaskTimestampSchema, } from '@taskset/contracts';
+import { buildDocumentGraph, buildTaskIndex, createDocument, createSnapshot, createTask, DOCUMENT_SORT_DIRECTIONS, DOCUMENT_SORT_KEYS, DocumentQuerySchema, deleteDocument, deleteTask, diagnoseRepository, discoverRepository, executeDocumentBatch, generateViews, getProgramRollup, importDocument, initializeRepository, listDocuments, listSnapshots, migrateTaskIds, normalizeDocumentKind, normalizeRepositoryPath, queryDocuments, queryTasks, RepositoryPathError, readDocument, readTask, restoreSnapshot, serializeDocumentFile, serializeTaskFile, syncRepository, TASK_SORT_DIRECTIONS, TASK_SORT_KEYS, TaskQuerySchema, updateDocument, updateTask, } from '@taskset/core';
 import * as z from 'zod';
 const USAGE = `Usage:
-  taskset init [--cwd <path>]
+  taskset init [--config] [--cwd <path>]
   taskset config [--json] [--cwd <path>]
   taskset doctor [--json] [--cwd <path>]
   taskset generate [--json] [--cwd <path>]
@@ -18,8 +18,9 @@ const USAGE = `Usage:
   taskset task status <task-id> <status> [--json] [--cwd <path>]
   taskset task delete <task-id> [--remove-dependencies] [--json] [--cwd <path>]
   taskset task migrate-ids [--json] [--cwd <path>]
+  taskset task program <parent-id> [--json] [--cwd <path>]
   taskset sync [--concurrency <count>] [--json] [--cwd <path>]
-  taskset document create <story|flow|decision|adr|dr|research|runbook> --title <title> [metadata options]
+  taskset document create <story|flow|decision|adr|dr|research|runbook|lesson|antipattern|concern|audit> --title <title> [metadata options]
   taskset document import <markdown-path> [--type <type>] [--move]
   taskset document batch <manifest.json> [--concurrency <count>] [--json]
   taskset document list [type] [query options]
@@ -32,10 +33,12 @@ Metadata options:
   --status --priority --order --owner --team --estimate --effort --risk --due-date
   --label --assignee --reviewer --depends-on --related --duplicate
   --parent --file --directory --project --body
+  Lesson/concern options: --severity --related-skill --pack --class --cadence
   Repeat array options. Task and document updates clear arrays with --clear-dependencies,
   --clear-labels, --clear-assignees, --clear-reviewers, --clear-related,
-  --clear-files, --clear-directories, or --clear-projects. Clear scalar
-  relationships with --clear-parent or --clear-owner.
+  --clear-files, --clear-directories, --clear-projects, --clear-related-skills,
+  or --clear-packs. Clear scalar relationships with --clear-parent, --clear-owner,
+  --clear-severity, --clear-class, or --clear-cadence.
 
 List query options:
   --status --priority --label --owner --assignee --reviewer --team --risk
@@ -67,6 +70,10 @@ const CommonValuesSchema = z.strictObject({
     cwd: CwdSchema,
     json: JsonSchema,
 });
+const InitValuesSchema = z.strictObject({
+    cwd: CwdSchema,
+    config: z.boolean().optional(),
+});
 const ConcurrencySchema = z.coerce.number().int().min(1).max(32).optional();
 const DocumentKindInputSchema = TrimmedStringSchema.transform((value, context) => {
     try {
@@ -102,6 +109,11 @@ const DocumentInputSchema = z.strictObject({
     parent: TaskIdSchema.optional(),
     directories: StringListSchema.optional(),
     projects: StringListSchema.optional(),
+    severity: LessonSeveritySchema.optional(),
+    relatedSkills: StringListSchema.optional(),
+    packs: StringListSchema.optional(),
+    class: ConcernClassSchema.optional(),
+    cadence: TrimmedStringSchema.optional(),
     body: z.string().optional(),
 });
 const DocumentUpdateSchema = z
@@ -126,6 +138,11 @@ const DocumentUpdateSchema = z
     parent: TaskIdSchema.nullable().optional(),
     directories: StringListSchema.optional(),
     projects: StringListSchema.optional(),
+    severity: LessonSeveritySchema.nullable().optional(),
+    relatedSkills: StringListSchema.optional(),
+    packs: StringListSchema.optional(),
+    class: ConcernClassSchema.nullable().optional(),
+    cadence: TrimmedStringSchema.nullable().optional(),
     body: z.string().optional(),
 })
     .refine((input) => Object.keys(input).length > 0, 'Document update requires at least one field');
@@ -178,6 +195,14 @@ const UPDATE_CLEAR_PAIRS = [
     ['directory', 'clear-directories'],
     ['project', 'clear-projects'],
 ];
+const DOCUMENT_UPDATE_CLEAR_PAIRS = [
+    ...UPDATE_CLEAR_PAIRS,
+    ['severity', 'clear-severity'],
+    ['related-skill', 'clear-related-skills'],
+    ['pack', 'clear-packs'],
+    ['class', 'clear-class'],
+    ['cadence', 'clear-cadence'],
+];
 const DocumentCreateValuesSchema = z.strictObject({
     title: TrimmedStringSchema,
     status: DocumentStatusSchema.optional(),
@@ -199,6 +224,11 @@ const DocumentCreateValuesSchema = z.strictObject({
     parent: TaskIdSchema.optional(),
     directory: StringListSchema.optional(),
     project: StringListSchema.optional(),
+    severity: LessonSeveritySchema.optional(),
+    'related-skill': StringListSchema.optional(),
+    pack: StringListSchema.optional(),
+    class: ConcernClassSchema.optional(),
+    cadence: TrimmedStringSchema.optional(),
     body: z.string().optional(),
     cwd: CwdSchema,
     json: JsonSchema,
@@ -225,6 +255,11 @@ const DocumentUpdateValuesSchema = z
     parent: TaskIdSchema.optional(),
     directory: StringListSchema.optional(),
     project: StringListSchema.optional(),
+    severity: LessonSeveritySchema.optional(),
+    'related-skill': StringListSchema.optional(),
+    pack: StringListSchema.optional(),
+    class: ConcernClassSchema.optional(),
+    cadence: TrimmedStringSchema.optional(),
     body: z.string().optional(),
     type: TrimmedStringSchema.optional(),
     'clear-priority': z.boolean().optional(),
@@ -245,11 +280,16 @@ const DocumentUpdateValuesSchema = z
     'clear-parent': z.boolean().optional(),
     'clear-directories': z.boolean().optional(),
     'clear-projects': z.boolean().optional(),
+    'clear-severity': z.boolean().optional(),
+    'clear-related-skills': z.boolean().optional(),
+    'clear-packs': z.boolean().optional(),
+    'clear-class': z.boolean().optional(),
+    'clear-cadence': z.boolean().optional(),
     cwd: CwdSchema,
     json: JsonSchema,
 })
     .superRefine((values, context) => {
-    for (const [valueKey, clearKey] of UPDATE_CLEAR_PAIRS) {
+    for (const [valueKey, clearKey] of DOCUMENT_UPDATE_CLEAR_PAIRS) {
         if (values[valueKey] !== undefined && values[clearKey]) {
             context.addIssue({
                 code: 'custom',
@@ -276,6 +316,8 @@ const DocumentListValuesSchema = z.strictObject({
     team: StringListSchema.optional(),
     risk: z.array(TaskRiskSchema).optional(),
     project: StringListSchema.optional(),
+    class: z.array(ConcernClassSchema).optional(),
+    severity: z.array(LessonSeveritySchema).optional(),
     'depends-on': TaskIdSchema.optional(),
     related: TaskIdSchema.optional(),
     duplicate: TaskIdSchema.optional(),
@@ -444,6 +486,14 @@ const metadataOptionDefinitions = {
     directory: { type: 'string', multiple: true },
     project: { type: 'string', multiple: true },
 };
+const documentMetadataOptionDefinitions = {
+    ...metadataOptionDefinitions,
+    severity: { type: 'string' },
+    'related-skill': { type: 'string', multiple: true },
+    pack: { type: 'string', multiple: true },
+    class: { type: 'string' },
+    cadence: { type: 'string' },
+};
 const commonOptionDefinitions = {
     cwd: { type: 'string' },
     json: { type: 'boolean' },
@@ -614,101 +664,107 @@ function updateInputFromValues(repository, values) {
     };
 }
 function documentUpdateInputFromValues(repository, values) {
-    return {
-        ...(values.title !== undefined ? { title: values.title } : {}),
-        ...(values.status !== undefined ? { status: values.status } : {}),
-        ...(values['clear-priority']
-            ? { priority: null }
-            : values.priority !== undefined
-                ? { priority: values.priority }
-                : {}),
-        ...(values['clear-order']
-            ? { order: null }
-            : values.order !== undefined
-                ? { order: values.order }
-                : {}),
-        ...(values['clear-labels']
-            ? { labels: [] }
-            : values.label !== undefined
-                ? { labels: values.label }
-                : {}),
-        ...(values['clear-dependencies']
-            ? { dependsOn: [] }
-            : values['depends-on'] !== undefined
-                ? { dependsOn: values['depends-on'] }
-                : {}),
-        ...(values['clear-files']
-            ? { files: [] }
-            : values.file !== undefined
-                ? { files: normalizeMutationPaths(repository, values.file) }
-                : {}),
-        ...(values['clear-owner']
-            ? { owner: null }
-            : values.owner !== undefined
-                ? { owner: values.owner }
-                : {}),
-        ...(values['clear-assignees']
-            ? { assignees: [] }
-            : values.assignee !== undefined
-                ? { assignees: values.assignee }
-                : {}),
-        ...(values['clear-reviewers']
-            ? { reviewers: [] }
-            : values.reviewer !== undefined
-                ? { reviewers: values.reviewer }
-                : {}),
-        ...(values['clear-team']
-            ? { team: null }
-            : values.team !== undefined
-                ? { team: values.team }
-                : {}),
-        ...(values['clear-estimate']
-            ? { estimate: null }
-            : values.estimate !== undefined
-                ? { estimate: values.estimate }
-                : {}),
-        ...(values['clear-effort']
-            ? { effort: null }
-            : values.effort !== undefined
-                ? { effort: values.effort }
-                : {}),
-        ...(values['clear-risk']
-            ? { risk: null }
-            : values.risk !== undefined
-                ? { risk: values.risk }
-                : {}),
-        ...(values['clear-due-date']
-            ? { dueDate: null }
-            : values['due-date'] !== undefined
-                ? { dueDate: values['due-date'] }
-                : {}),
-        ...(values['clear-related']
-            ? { related: [] }
-            : values.related !== undefined
-                ? { related: values.related }
-                : {}),
-        ...(values['clear-duplicates']
-            ? { duplicates: [] }
-            : values.duplicate !== undefined
-                ? { duplicates: values.duplicate }
-                : {}),
-        ...(values['clear-parent']
-            ? { parent: null }
-            : values.parent !== undefined
-                ? { parent: values.parent }
-                : {}),
-        ...(values['clear-directories']
-            ? { directories: [] }
-            : values.directory !== undefined
-                ? { directories: normalizeMutationPaths(repository, values.directory) }
-                : {}),
-        ...(values['clear-projects']
-            ? { projects: [] }
-            : values.project !== undefined
-                ? { projects: values.project }
-                : {}),
-        ...(values.body !== undefined ? { body: values.body } : {}),
-    };
+    const input = {};
+    if (values.title !== undefined)
+        input.title = values.title;
+    if (values.status !== undefined)
+        input.status = values.status;
+    if (values['clear-priority'])
+        input.priority = null;
+    else if (values.priority !== undefined)
+        input.priority = values.priority;
+    if (values['clear-order'])
+        input.order = null;
+    else if (values.order !== undefined)
+        input.order = values.order;
+    if (values['clear-labels'])
+        input.labels = [];
+    else if (values.label !== undefined)
+        input.labels = values.label;
+    if (values['clear-dependencies'])
+        input.dependsOn = [];
+    else if (values['depends-on'] !== undefined)
+        input.dependsOn = values['depends-on'];
+    if (values['clear-files'])
+        input.files = [];
+    else if (values.file !== undefined)
+        input.files = normalizeMutationPaths(repository, values.file);
+    if (values['clear-owner'])
+        input.owner = null;
+    else if (values.owner !== undefined)
+        input.owner = values.owner;
+    if (values['clear-assignees'])
+        input.assignees = [];
+    else if (values.assignee !== undefined)
+        input.assignees = values.assignee;
+    if (values['clear-reviewers'])
+        input.reviewers = [];
+    else if (values.reviewer !== undefined)
+        input.reviewers = values.reviewer;
+    if (values['clear-team'])
+        input.team = null;
+    else if (values.team !== undefined)
+        input.team = values.team;
+    if (values['clear-estimate'])
+        input.estimate = null;
+    else if (values.estimate !== undefined)
+        input.estimate = values.estimate;
+    if (values['clear-effort'])
+        input.effort = null;
+    else if (values.effort !== undefined)
+        input.effort = values.effort;
+    if (values['clear-risk'])
+        input.risk = null;
+    else if (values.risk !== undefined)
+        input.risk = values.risk;
+    if (values['clear-due-date'])
+        input.dueDate = null;
+    else if (values['due-date'] !== undefined)
+        input.dueDate = values['due-date'];
+    if (values['clear-related'])
+        input.related = [];
+    else if (values.related !== undefined)
+        input.related = values.related;
+    if (values['clear-duplicates'])
+        input.duplicates = [];
+    else if (values.duplicate !== undefined)
+        input.duplicates = values.duplicate;
+    if (values['clear-parent'])
+        input.parent = null;
+    else if (values.parent !== undefined)
+        input.parent = values.parent;
+    if (values['clear-directories'])
+        input.directories = [];
+    else if (values.directory !== undefined) {
+        input.directories = normalizeMutationPaths(repository, values.directory);
+    }
+    if (values['clear-projects'])
+        input.projects = [];
+    else if (values.project !== undefined)
+        input.projects = values.project;
+    if (values['clear-severity'])
+        input.severity = null;
+    else if (values.severity !== undefined)
+        input.severity = values.severity;
+    if (values['clear-related-skills'])
+        input.relatedSkills = [];
+    else if (values['related-skill'] !== undefined)
+        input.relatedSkills = values['related-skill'];
+    if (values['clear-packs'])
+        input.packs = [];
+    else if (values.pack !== undefined)
+        input.packs = values.pack;
+    if (values['clear-class'])
+        input.class = null;
+    else if (values.class !== undefined)
+        input.class = values.class;
+    if (values['clear-cadence'])
+        input.cadence = null;
+    else if (values.cadence !== undefined)
+        input.cadence = values.cadence;
+    if (values.body !== undefined)
+        input.body = values.body;
+    return input;
 }
 export async function runCli(args, context = {}) {
     const cwd = path.resolve(context.cwd ?? process.cwd());
@@ -724,6 +780,23 @@ export async function runCli(args, context = {}) {
             return 0;
         }
         if (command === 'init' || command === 'config' || command === 'doctor') {
+            if (command === 'init') {
+                const parsed = parseArgs({
+                    args: commandArgs,
+                    allowPositionals: false,
+                    options: {
+                        cwd: { type: 'string' },
+                        config: { type: 'boolean' },
+                    },
+                });
+                const values = parseSchema(InitValuesSchema, parsed.values, 'init options');
+                const commandCwd = resolveCommandCwd(cwd, values.cwd);
+                const repository = await initializeRepository(commandCwd, {
+                    writeConfig: values.config === true,
+                });
+                stdout(`Initialized Taskset in ${repository.rootDirectory}\n`);
+                return 0;
+            }
             const parsed = parseArgs({
                 args: commandArgs,
                 allowPositionals: false,
@@ -731,24 +804,23 @@ export async function runCli(args, context = {}) {
             });
             const values = parseSchema(CommonValuesSchema, parsed.values, `${command} options`);
             const commandCwd = resolveCommandCwd(cwd, values.cwd);
-            if (command === 'init') {
-                const repository = await initializeRepository(commandCwd);
-                stdout(`Initialized Taskset in ${repository.rootDirectory}\n`);
-                return 0;
-            }
             const repository = await discoverRepository(commandCwd);
             if (command === 'config') {
                 if (values.json) {
                     stdout(`${JSON.stringify({
                         rootDirectory: repository.rootDirectory,
                         configPath: repository.configPath,
+                        hasConfig: repository.hasConfig,
                         dataDirectory: repository.dataDirectory,
                         config: repository.config,
                     }, null, 2)}\n`);
                 }
-                else {
+                else if (repository.hasConfig) {
                     stdout(`${repository.configPath}\n`);
                 }
+                else {
+                    stdout(`defaults (${repository.rootDirectory})\n`);
+                }
                 return 0;
             }
             const result = await diagnoseRepository(repository);
@@ -756,7 +828,7 @@ export async function runCli(args, context = {}) {
                 stdout(`${JSON.stringify(result, null, 2)}\n`);
             }
             else if (result.valid) {
-                stdout(`Taskset repository is valid (${result.taskCount} tasks)\n`);
+                stdout(`Taskset repository is valid (${result.taskCount} tasks, ${result.documentCount} documents)\n`);
             }
             else {
                 for (const diagnostic of result.diagnostics) {
@@ -793,7 +865,7 @@ export async function runCli(args, context = {}) {
             });
             stdout(values.json
                 ? `${JSON.stringify(result, null, 2)}\n`
-                : `Synced ${result.migrations.length} migrations and generated views\n`);
+                : `Synced ${result.migrations.length + result.documentMigrations.length} migrations and generated views\n`);
             return 0;
         }
         if (command === 'snapshot') {
@@ -876,7 +948,7 @@ export async function runCli(args, context = {}) {
                 const parsed = parseArgs({
                     args: subcommandArgs,
                     allowPositionals: true,
-                    options: { ...metadataOptionDefinitions, ...commonOptionDefinitions },
+                    options: { ...documentMetadataOptionDefinitions, ...commonOptionDefinitions },
                 });
                 const [rawType] = requirePositionals(parsed.positionals, 1, 'exactly one document type');
                 const values = parseSchema(DocumentCreateValuesSchema, parsed.values, 'document create options');
@@ -905,6 +977,11 @@ export async function runCli(args, context = {}) {
                         ? { directories: normalizeMutationPaths(repository, values.directory) }
                         : {}),
                     ...(values.project ? { projects: values.project } : {}),
+                    ...(values.severity ? { severity: values.severity } : {}),
+                    ...(values['related-skill'] ? { relatedSkills: values['related-skill'] } : {}),
+                    ...(values.pack ? { packs: values.pack } : {}),
+                    ...(values.class ? { class: values.class } : {}),
+                    ...(values.cadence ? { cadence: values.cadence } : {}),
                     ...(values.body !== undefined ? { body: values.body } : {}),
                 }, { onWarning });
                 writeDocumentRecord(record, values.json, stdout);
@@ -954,6 +1031,8 @@ export async function runCli(args, context = {}) {
                         team: { type: 'string', multiple: true },
                         risk: { type: 'string', multiple: true },
                         project: { type: 'string', multiple: true },
+                        class: { type: 'string', multiple: true },
+                        severity: { type: 'string', multiple: true },
                         'depends-on': { type: 'string' },
                         related: { type: 'string' },
                         duplicate: { type: 'string' },
@@ -994,6 +1073,8 @@ export async function runCli(args, context = {}) {
                     ...(values.team ? { teams: values.team } : {}),
                     ...(values.risk ? { risks: values.risk } : {}),
                     ...(values.project ? { projects: values.project } : {}),
+                    ...(values.class ? { classes: values.class } : {}),
+                    ...(values.severity ? { severities: values.severity } : {}),
                     ...(values['depends-on'] ? { dependsOn: values['depends-on'] } : {}),
                     ...(values.related ? { related: values.related } : {}),
                     ...(values.duplicate ? { duplicate: values.duplicate } : {}),
@@ -1079,12 +1160,12 @@ export async function runCli(args, context = {}) {
                 return 0;
             }
             if (subcommand === 'update') {
-                const clearDefinitions = Object.fromEntries(UPDATE_CLEAR_PAIRS.map(([, clear]) => [clear, { type: 'boolean' }]));
+                const clearDefinitions = Object.fromEntries(DOCUMENT_UPDATE_CLEAR_PAIRS.map(([, clear]) => [clear, { type: 'boolean' }]));
                 const parsed = parseArgs({
                     args: subcommandArgs,
                     allowPositionals: true,
                     options: {
-                        ...metadataOptionDefinitions,
+                        ...documentMetadataOptionDefinitions,
                         ...clearDefinitions,
                         ...commonOptionDefinitions,
                         type: { type: 'string' },
@@ -1167,6 +1248,24 @@ export async function runCli(args, context = {}) {
                     stdout(`${migration.from}\t${migration.to}\n`);
             return 0;
         }
+        if (subcommand === 'program') {
+            const parsed = parseArgs({
+                args: subcommandArgs,
+                allowPositionals: true,
+                options: commonOptionDefinitions,
+            });
+            const [parentId] = requirePositionals(parsed.positionals, 1, 'exactly one parent task ID');
+            const values = parseSchema(CommonValuesSchema, parsed.values, 'task program options');
+            const repository = await discoverRepository(resolveCommandCwd(cwd, values.cwd));
+            const rollup = await getProgramRollup(repository, parseSchema(TaskIdSchema, parentId, 'parent task ID'));
+            if (values.json) {
+                stdout(`${JSON.stringify(rollup, null, 2)}\n`);
+            }
+            else {
+                stdout(`${rollup.parentId}\t${rollup.status}\tchildren=${rollup.children.total}\topen=${rollup.children.openIds.length}\tconcerns=${rollup.relatedOpenConcerns.length}\tcloseoutReady=${rollup.closeoutReady}\t${rollup.title}\n`);
+            }
+            return 0;
+        }
         if (subcommand === 'create') {
             const parsed = parseArgs({
                 args: subcommandArgs,

package/docs/_meta.ts

@@ -5,4 +5,9 @@ export default {
 	'cli-reference': 'CLI Reference',
 	'task-files': 'Task Files',
 	'document-types': 'Document Types',
+	'memory-model': 'Memory Model',
+	'security-compliance-tracking': 'Security Tracking',
+	'agent-closeout': 'Agent Closeout',
+	'taxonomy-cookbook': 'Taxonomy Cookbook',
+	agents: 'For Agents',
 }