outask 0.0.0-stage → 1.7.0

package/node_modules/zod/v4/package.json

@@ -0,0 +1,7 @@
+{ 
+  "type": "module",
+  "main": "./index.cjs",
+  "module": "./index.js",
+  "types": "./index.d.cts",
+  "sideEffects": false
+}

package/node_modules/zod/v4-mini/index.cjs

@@ -0,0 +1,51 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.z = void 0;
+const z = __importStar(require("../v4/mini/external.cjs"));
+exports.z = z;
+__exportStar(require("../v4/mini/external.cjs"), exports);
+
+// seal-cjs-exports
+(function () {
+  var keys = Object.getOwnPropertyNames(exports);
+  for (var i = 0; i < keys.length; i++) {
+    var desc = Object.getOwnPropertyDescriptor(exports, keys[i]);
+    if (!desc || !desc.get || !desc.configurable) continue;
+    var value;
+    try {
+      value = desc.get();
+    } catch (e) {
+      continue;
+    }
+    // a circular require may not have settled this one yet, so leave it live
+    if (value === undefined) continue;
+    Object.defineProperty(exports, keys[i], { value: value, writable: false, enumerable: desc.enumerable, configurable: false });
+  }
+  Object.freeze(exports);
+})();

package/node_modules/zod/v4-mini/index.d.cts

@@ -0,0 +1,3 @@
+import * as z from "../v4/mini/external.cjs";
+export * from "../v4/mini/external.cjs";
+export { z };

package/node_modules/zod/v4-mini/index.d.ts

@@ -0,0 +1,3 @@
+import * as z from "../v4/mini/external.js";
+export * from "../v4/mini/external.js";
+export { z };

package/node_modules/zod/v4-mini/index.js

@@ -0,0 +1,3 @@
+import * as z from "../v4/mini/external.js";
+export * from "../v4/mini/external.js";
+export { z };

package/node_modules/zod/v4-mini/package.json

@@ -0,0 +1,7 @@
+{ 
+  "type": "module",
+  "main": "./index.cjs",
+  "module": "./index.js",
+  "types": "./index.d.cts",
+  "sideEffects": false
+}

package/package.json

@@ -1,6 +1,34 @@
 {
   "name": "outask",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.7.0",
+  "description": "Outask CLI for repository-local JSON task tracking",
+  "author": "Henry <me@henrydev.me>",
+  "license": "AGPL-3.0-only",
+  "type": "module",
+  "engines": {
+    "node": ">=22.23.3"
+  },
+  "dependencies": {
+    "jsonc-parser": "3.3.1",
+    "@modelcontextprotocol/server": "2.3.0",
+    "zod": "^4.6.6"
+  },
+  "bin": {
+    "outask": "bin/outask",
+    "tasks": "bin/tasks"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/henryh/outask.git",
+    "directory": "app"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "bundleDependencies": [
+    "jsonc-parser",
+    "@modelcontextprotocol/server",
+    "zod"
+  ]
+}

package/runtime.cjs

@@ -0,0 +1,14 @@
+// Keep the preflight parseable on old Node versions and derive bounds from the manifest.
+const range = require('./package.json').engines.node;
+const current = process.versions.node.split('.').map(Number);
+const supported = range.split(' || ').some(function (branch) {
+  return branch.split(' ').every(function (bound) {
+    const match = /^(>=|<)(\d+)(?:\.(\d+))?(?:\.(\d+))?$/.exec(bound);
+    if (!match) return false;
+    const version = [Number(match[2]), Number(match[3] || 0), Number(match[4] || 0)];
+    let order = 0;
+    for (let index = 0; index < 3 && !order; index += 1) order = current[index] - version[index];
+    return match[1] === '>=' ? order >= 0 : order < 0;
+  });
+});
+if (!supported) throw new Error('INCOMPATIBLE_RUNTIME: Outask requires Node.js ' + range + '; found ' + process.versions.node);

package/scripts/arguments.mjs

@@ -0,0 +1,77 @@
+import { fail } from '../src/errors.mjs';
+
+export const commonOptions = {
+  store: { type: 'string', multiple: true }, group: { type: 'string' },
+  fields: { type: 'string' }, format: { type: 'string', default: 'text' },
+  'max-width': { type: 'string', default: '60' }, 'schema-path': { type: 'string' },
+  'no-cache': { type: 'boolean' },
+  help: { type: 'boolean', short: 'h' },
+};
+
+export const commonHelp = `  --store <name>       Explicit store (repeatable); all includes history
+  --group <group>      Active (default), Done or Archive; exclusive with --store
+  --format <format>    text (default), table, json or ids
+  --max-width <n>      Table cell width, at least 10 (default: 60)
+  --schema-path <file> Project-relative schema file; overrides automatic selection
+  --no-cache          Read authoritative JSON without opening or refreshing the SQLite cache
+  --help, -h          Show this help
+`;
+
+export function parseSchema(values, tokens = []) {
+  if (tokens.filter((token) => token.kind === 'option' && token.name === 'schema-path').length > 1) {
+    fail('INVALID_INPUT', '--schema-path may be supplied only once');
+  }
+  if (values['schema-path'] === '') fail('INVALID_INPUT', '--schema-path must not be empty');
+  return values['schema-path'];
+}
+
+export const projectHelp = `Omit project-path to use the current working directory, or supply one directory explicitly.
+Project operations prepare missing service metadata; reads require task stores.
+Mutations create standard stores when needed; no other directories are searched.
+Use --schema-path for a project-relative schema; automatic selection uses tasks/task-schema.json, then legacy docs/task-schema.json.
+`;
+
+export function parseProject(positionals, usage, withId = false) {
+  const required = withId ? 1 : 0;
+  if (positionals.length < required || positionals.length > required + 1) fail('INVALID_INPUT', usage);
+  return {
+    project: positionals.length === required ? process.cwd() : positionals[0],
+    id: withId ? positionals.at(-1) : undefined,
+  };
+}
+
+export function parseInteger(value, name, minimum = 0, maximum = Number.MAX_SAFE_INTEGER) {
+  if (!/^\d+$/.test(value) || !Number.isSafeInteger(Number(value)) || Number(value) < minimum || Number(value) > maximum) {
+    fail('INVALID_INPUT', `${name} expects a safe integer from ${minimum} to ${maximum}`);
+  }
+  return Number(value);
+}
+
+function splitNames(value) {
+  const names = value.split(',').map((name) => name.trim());
+  if (names.some((name) => !name)) fail('INVALID_INPUT', 'field and store names cannot be empty');
+  return names;
+}
+
+export function parseSelection(values) {
+  const stores = (values.store ?? []).flatMap(splitNames);
+  const fields = values.fields === undefined ? undefined : splitNames(values.fields);
+  // An IDs format is itself an explicit projection, regardless of --fields.
+  return { stores, group: values.group, fields: values.format === 'ids' ? ['id'] : fields };
+}
+
+export function parseOutput(values) {
+  if (!['text', 'table', 'json', 'ids'].includes(values.format)) {
+    fail('INVALID_INPUT', 'format must be text, table, json or ids');
+  }
+  return { format: values.format, maxWidth: parseInteger(values['max-width'], '--max-width', 10) };
+}
+
+export function cacheOptions(values) {
+  return {
+    noCache: values['no-cache'] ?? false,
+    onAdvisory(advisory) {
+      process.stderr.write(`Advisory ${advisory.code}: ${advisory.message}\n`);
+    },
+  };
+}

package/scripts/continuation.mjs

@@ -0,0 +1,31 @@
+import { relative } from 'node:path';
+import { textBuffer } from '../src/response.mjs';
+
+function quoteArgument(buffer, value) {
+  if (/^[a-zA-Z0-9_@%+=:,./-]+$/.test(value)) return buffer.add(value);
+  if (!buffer.add("'")) return false;
+  const parts = value.split("'");
+  for (let index = 0; index < parts.length; index++) {
+    if (index && !buffer.add("'\\''")) return false;
+    if (!buffer.add(parts[index])) return false;
+  }
+  return buffer.add("'");
+}
+
+export function nextCommand(args, tokens, option, value, invocation) {
+  const omitted = new Set();
+  for (const token of tokens) {
+    if (token.kind !== 'option' || token.name !== option) continue;
+    omitted.add(token.index);
+    if (!token.inlineValue) omitted.add(token.index + 1);
+  }
+  const script = relative(process.cwd(), process.argv[1]);
+  const words = [...(invocation ?? ['node', script.startsWith('-') ? `./${script}` : script]),
+    `--${option}`, String(value), ...args.filter((_, index) => !omitted.has(index))];
+  const buffer = textBuffer();
+  for (let index = 0; index < words.length; index++) {
+    if (index && !buffer.add(' ')) return undefined;
+    if (!quoteArgument(buffer, words[index])) return undefined;
+  }
+  return buffer.finish();
+}

package/scripts/create-task.mjs

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+import { parseArgs } from 'node:util';
+import { createTask } from '../src/create.mjs';
+import { fail } from '../src/errors.mjs';
+import { parseProject, parseSchema, projectHelp } from './arguments.mjs';
+import { isMain } from './entry.mjs';
+import { checkOptions, taskWriteHelp, readTaskWriteInput, taskWriteOptions } from './task-write-input.mjs';
+import { reportError } from './output.mjs';
+
+export const options = taskWriteOptions;
+export const usage = 'Usage: node app/scripts/create-task.mjs [project-path] [field options | --json <object> | --input <file|->] [options]';
+export const help = `${usage}\n${projectHelp}Create one task. JSON is the full task structure; omitted id is allocated. Project format/default_status settings apply (normally pending, medium priority and empty blockers). Creation sets updated_at; caller-supplied updated_at is rejected.\n${taskWriteHelp}\n`;
+
+export async function main(args) {
+  const { values, positionals, tokens } = parseArgs({ args, allowPositionals: true, tokens: true, options });
+  if (values.help) { process.stdout.write(help); return; }
+  checkOptions(tokens);
+  const { project } = parseProject(positionals, usage);
+  if (values.format !== 'json') fail('INVALID_INPUT', 'format must be json');
+  const input = await readTaskWriteInput(values, false);
+  const task = createTask(project, input, { store: values.store, schemaPath: parseSchema(values, tokens) });
+  process.stdout.write(`${JSON.stringify(task, null, 2)}\n`);
+}
+
+if (isMain(import.meta.url)) {
+  try { await main(process.argv.slice(2)); } catch (error) { reportError(error); }
+}

package/scripts/delete-task.mjs

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { runLifecycle } from './lifecycle.mjs';
+runLifecycle(true);

package/scripts/entry.mjs

@@ -0,0 +1,6 @@
+import { realpathSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+
+export function isMain(url) {
+  return process.argv[1] !== undefined && realpathSync(process.argv[1]) === fileURLToPath(url);
+}

package/scripts/get-task.mjs

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+import { parseArgs } from 'node:util';
+import { getTask } from '../src/tasks.mjs';
+import { cacheOptions, commonHelp, commonOptions, parseInteger, parseOutput, parseProject, parseSchema, parseSelection, projectHelp } from './arguments.mjs';
+import { isMain } from './entry.mjs';
+import { printOutput, reportError } from './output.mjs';
+
+export const options = commonOptions;
+export const usage = 'Usage: node app/scripts/get-task.mjs [project-path] <id> [options]';
+export const help = `${usage}
+
+${projectHelp}One positional argument is the ID; two are project-path then ID. Reads never change task files.
+  --fields <names>     Comma-separated fields; all (default)
+${commonHelp}`;
+
+export function main(args) {
+  const { values, positionals, tokens } = parseArgs({ args, options: commonOptions, allowPositionals: true, tokens: true });
+  if (values.help) {
+    process.stdout.write(help);
+    return;
+  }
+  const selected = parseProject(positionals, usage, true);
+  const output = parseOutput(values);
+  const selection = parseSelection(values);
+  selection.schemaPath = parseSchema(values, tokens);
+  selection.refreshMode = 'detached';
+  Object.assign(selection, cacheOptions(values));
+  const id = parseInteger(selected.id, 'id', 1);
+  const task = getTask(selected.project, id, selection);
+  const fields = selection.fields && !selection.fields.includes('all') ? selection.fields : Object.keys(task);
+  printOutput(task, fields, output);
+}
+
+if (isMain(import.meta.url)) {
+  try {
+    main(process.argv.slice(2));
+  } catch (error) {
+    reportError(error);
+  }
+}

package/scripts/get-tasks.mjs

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+import { parseArgs } from 'node:util';
+import { fail } from '../src/errors.mjs';
+import { defaultLimit, maxLimit, responseBytes } from '../src/limits.mjs';
+import { textBuffer } from '../src/response.mjs';
+import { getTasks } from '../src/tasks.mjs';
+import {
+  cacheOptions, commonHelp, commonOptions, parseInteger, parseOutput, parseProject, parseSchema, parseSelection, projectHelp,
+} from './arguments.mjs';
+import { nextCommand } from './continuation.mjs';
+import { isMain } from './entry.mjs';
+import { formatOutput, reportError } from './output.mjs';
+
+export const options = {
+  ...commonOptions,
+  format: { type: 'string' },
+  id: { type: 'string', multiple: true }, cursor: { type: 'string' },
+  limit: { type: 'string', default: String(defaultLimit) },
+};
+export const usage = 'Usage: node app/scripts/get-tasks.mjs [project-path] --id <id> [--id <id> ...] [options]';
+export const help = `${usage}
+
+${projectHelp}Reads never change task files.
+  --id <id>           Requested task ID; repeat in the required result order
+  --fields <names>    Comma-separated result fields (default: id,title,status)
+${commonHelp.replace('  --fields <names>     Comma-separated field names\n', '')}  --limit <n>         Requested IDs per page from 1 to 50 (default: 10)
+  --cursor <cursor>   Continue the same ID request from an opaque cursor
+`;
+
+function pageInfo(page, args, tokens, invocation) {
+  const buffer = textBuffer();
+  buffer.add(`Retrieved ${page.tasks.length} task${page.tasks.length === 1 ? '' : 's'}.\n`);
+  if (page.not_found.length) buffer.add(`Missing IDs: ${page.not_found.join(', ')}\n`);
+  if (page.hasMore) {
+    const command = nextCommand(args, tokens, 'cursor', page.next_cursor, invocation);
+    if (command === undefined) return undefined;
+    buffer.add(`Next page: ${command}\n`);
+  }
+  return buffer.finish();
+}
+
+function showPage(page, output, args, tokens, invocation) {
+  if (output.format === 'json') {
+    const text = formatOutput(page, page.fields, output);
+    if (text === undefined) fail('OUTPUT_TOO_LARGE', 'rendered batch response exceeds 32 KiB; select fewer --fields');
+    process.stdout.write(text);
+    return;
+  }
+  const info = pageInfo(page, args, tokens, invocation);
+  if (info === undefined) fail('OUTPUT_TOO_LARGE', 'batch guidance exceeds 32 KiB; request fewer IDs');
+  const text = formatOutput(page.tasks, page.fields, output, responseBytes - Buffer.byteLength(info, 'utf8'));
+  if (text === undefined) fail('OUTPUT_TOO_LARGE', 'rendered batch response exceeds 32 KiB; select fewer --fields');
+  process.stdout.write(text);
+  process.stderr.write(info);
+}
+
+export function main(args, guidance) {
+  const { values, positionals, tokens } = parseArgs({ args, options, allowPositionals: true, tokens: true });
+  if (values.help) {
+    process.stdout.write(help);
+    return;
+  }
+  const { project } = parseProject(positionals, usage);
+  if (!values.id?.length) fail('INVALID_INPUT', '--id must be supplied at least once');
+  values.format ??= 'table';
+  const output = parseOutput(values);
+  const selection = parseSelection(values);
+  const ids = values.id.map((value) => parseInteger(value, '--id', 1));
+  const page = getTasks(project, ids, {
+    ...selection,
+    limit: parseInteger(values.limit, '--limit', 1, maxLimit), cursor: values.cursor,
+    schemaPath: parseSchema(values, tokens), refreshMode: 'detached',
+    ...cacheOptions(values),
+  });
+  showPage(page, output, guidance?.args ?? args, guidance?.tokens ?? tokens, guidance?.invocation);
+}
+
+if (isMain(import.meta.url)) {
+  try {
+    main(process.argv.slice(2));
+  } catch (error) {
+    reportError(error);
+  }
+}

package/scripts/hook.mjs

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+import { chmodSync, lstatSync, mkdirSync, readFileSync, realpathSync, unlinkSync, writeFileSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { dirname, isAbsolute, relative, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { parseArgs } from 'node:util';
+import { fail } from '../src/errors.mjs';
+import { parseProject, parseSchema, projectHelp } from './arguments.mjs';
+import { isMain } from './entry.mjs';
+import { reportError } from './output.mjs';
+
+export const options = {
+  install: { type: 'boolean' }, remove: { type: 'boolean' }, 'schema-path': { type: 'string' }, help: { type: 'boolean', short: 'h' },
+};
+export const usage = 'Usage: node app/scripts/hook.mjs [project-path] --install|--remove';
+export const help = `${usage}\n${projectHelp}Explicitly install/remove a POSIX pre-commit hook at the selected Git root.\nChecks working-tree files, NOT the index; refreshes service metadata without staging it.\nExisting hooks and shared locations require manual integration; see the diagnostic.\nHook management leaves task stores/service metadata untouched. --schema-path is persisted in the generated validator command.
+Repeat installation/removal is safe. Keep this checkout and Node on PATH available.\n`;
+const validator = fileURLToPath(new URL('./validate-task-stores.mjs', import.meta.url));
+const quote = (value) => `'${value.replaceAll("'", "'\\''")}'`;
+function inspect(path) {
+  try { return lstatSync(path); } catch (error) {
+    if (error.code === 'ENOENT') return undefined;
+    throw error;
+  }
+}
+function git(project, args) {
+  const result = spawnSync('git', ['-C', project, ...args], { encoding: 'utf8' });
+  if (result.error || result.status !== 0) fail('HOOK_UNAVAILABLE', `Git could not resolve hooks: ${result.error?.message ?? result.stderr.trim()}`);
+  return result.stdout.trimEnd();
+}
+function inside(root, path) {
+  const tail = relative(root, path);
+  return tail !== '..' && !tail.startsWith('../') && !isAbsolute(tail);
+}
+
+export function main(args) {
+  const { values, positionals, tokens } = parseArgs({ args, allowPositionals: true, options, tokens: true });
+  if (values.help) { process.stdout.write(help); return; }
+  if (Boolean(values.install) === Boolean(values.remove)) fail('INVALID_INPUT', usage);
+  const { project: selected } = parseProject(positionals, usage);
+  const project = realpathSync(selected);
+  const schemaPath = parseSchema(values, tokens);
+  const schemaOption = schemaPath === undefined ? '' : ` --schema-path ${quote(schemaPath)}`;
+  const command = `node ${quote(validator)} ${quote(project)}${schemaOption}`;
+  const manual = (reason, shared = false) => {
+    const invocation = shared ? `node ${quote(validator)} "$(git rev-parse --show-toplevel)"${schemaOption}` : command;
+    fail('HOOK_CONFLICT', `${reason}. No hook changed. In your existing hook/manager, run:\n${invocation} || exit $?\nKeep existing checks and propagate failures; remove that line manually to undo integration.`);
+  };
+  const root = realpathSync(git(project, ['rev-parse', '--show-toplevel']));
+  if (root !== project) manual('Select the Git root for automatic installation; nested projects require manual integration');
+  const hook = resolve(project, git(project, ['rev-parse', '--path-format=absolute', '--git-path', 'hooks']), 'pre-commit');
+  // A configured directory may be shared by other repositories, including through a symlink.
+  let ancestor = dirname(hook);
+  while (!inspect(ancestor)) ancestor = dirname(ancestor);
+  if (!inside(root, hook) || !inside(root, realpathSync(ancestor))) manual(`Shared/external hook location ${hook}`, true);
+  if (values.install && git(project, ['worktree', 'list', '--porcelain', '-z'])
+    .split('\0').filter((field) => field.startsWith('worktree ')).length > 1) {
+    manual('Repository has linked worktrees; automatic hook installation is unavailable', true);
+  }
+  // Git may share this hook with a worktree created after installation.
+  const content = `#!/bin/sh\n# outask: working-tree validation; index is not validated or staged.
+root=$(git rev-parse --show-toplevel) || exit $?
+if [ "$root" != ${quote(project)} ]; then
+  printf '%s\\n' 'HOOK_CONFLICT: This hook belongs to another working tree. Integrate validation for the invoking worktree manually.' >&2
+  exit 1
+fi
+exec ${command}\n`;
+  const present = inspect(hook);
+  const previous = present?.isFile() ? readFileSync(hook, 'utf8') : undefined;
+  const managed = previous === content || previous === content.replace('# outask:', '# task-tracker:');
+  if (present && !managed) manual(`Existing or modified hook at ${hook}`);
+  if (values.remove) {
+    if (present) unlinkSync(hook);
+    process.stdout.write(`${present ? 'Removed' : 'Already absent'}: ${hook}.\n`);
+  } else {
+    if (!present) {
+      mkdirSync(dirname(hook), { recursive: true });
+      writeFileSync(hook, content, { flag: 'wx', mode: 0o755 });
+    } else {
+      if (readFileSync(hook, 'utf8') !== content) writeFileSync(hook, content);
+      chmodSync(hook, 0o755);
+    }
+    process.stdout.write(`${present ? 'Already installed' : 'Installed'}: ${hook}. Checks working-tree files, not staged data; stage refreshed service metadata yourself.\n`);
+  }
+}
+
+if (isMain(import.meta.url)) {
+  try { main(process.argv.slice(2)); } catch (error) { reportError(error); }
+}

package/scripts/inspect-blockers.mjs

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+import { parseArgs } from 'node:util';
+import { defaultDepth, inspectBlockers, maxDepth } from '../src/blockers.mjs';
+import { fail } from '../src/errors.mjs';
+import { defaultLimit, maxLimit } from '../src/limits.mjs';
+import { textBuffer } from '../src/response.mjs';
+import { cacheOptions, parseInteger, parseProject, parseSchema, projectHelp } from './arguments.mjs';
+import { isMain } from './entry.mjs';
+import { formatOutput, reportError } from './output.mjs';
+
+export const options = {
+  depth: { type: 'string', default: String(defaultDepth) },
+  limit: { type: 'string', default: String(defaultLimit) },
+  format: { type: 'string', default: 'text' }, help: { type: 'boolean', short: 'h' },
+  'schema-path': { type: 'string' },
+  'no-cache': { type: 'boolean' },
+};
+export const usage = 'Usage: node app/scripts/inspect-blockers.mjs [project-path] <id> [options]';
+export const help = `${usage}
+
+${projectHelp}One positional argument is the ID; two are project-path then ID.
+Inspect one Active task. Reads only Active stores and never changes task files.
+Direct active blocker IDs and eligibility remain exact when the graph is truncated.
+  --depth <n>         Maximum graph hops, 1 to ${maxDepth} (default: ${defaultDepth})
+  --limit <n>         Maximum graph edges, 1 to ${maxLimit} (default: ${defaultLimit})
+  --format <format>   text (default) or json
+  --schema-path <file> Project-relative schema file; overrides automatic selection
+  --no-cache          Read authoritative JSON without opening or refreshing the SQLite cache
+  --help, -h          Show this help
+
+Cycles are result diagnostics. An incomplete check reports cycleStatus: unknown.
+Use list-tasks.mjs and get-task.mjs to choose work and read task details.
+`;
+
+function humanText(result) {
+  const { id, eligible, activeBlockers, graph } = result;
+  const buffer = textBuffer();
+  buffer.add(`task: ${id}\neligible: ${eligible ? 'yes' : 'no'}\n`);
+  buffer.add(`active blockers: ${activeBlockers.length ? activeBlockers.join(', ') : 'none'}\n`);
+  const cycle = graph.cycleStatus === 'found' ? graph.cycle.join(' -> ')
+    : graph.cycleStatus === 'unknown' ? 'unknown (graph is truncated)' : 'none';
+  buffer.add(`cycle: ${cycle}\ngraph: ${graph.edges.length} edges (depth ${graph.depth}, limit ${graph.limit})\n`);
+  for (const { from, to } of graph.edges) buffer.add(`  ${from} -> ${to}\n`);
+  const reasons = Object.keys(graph.truncated).filter((key) => graph.truncated[key]);
+  buffer.add(`truncated: ${reasons.length ? reasons.join(', ') : 'no'}\n`);
+  return buffer.finish();
+}
+
+export function main(args) {
+  const { values, positionals, tokens } = parseArgs({ args, allowPositionals: true, options, tokens: true });
+  if (values.help) {
+    process.stdout.write(help);
+    return;
+  }
+  const selected = parseProject(positionals, usage, true);
+  if (!['text', 'json'].includes(values.format)) fail('INVALID_INPUT', 'format must be text or json');
+  const id = parseInteger(selected.id, 'id', 1);
+  const result = inspectBlockers(selected.project, id, {
+    depth: parseInteger(values.depth, '--depth', 1, maxDepth),
+    limit: parseInteger(values.limit, '--limit', 1, maxLimit),
+    schemaPath: parseSchema(values, tokens),
+    refreshMode: 'detached',
+    ...cacheOptions(values),
+  });
+  const output = values.format === 'json' ? formatOutput(result, [], { format: 'json' }) : humanText(result);
+  if (output === undefined) fail('OUTPUT_TOO_LARGE', 'rendered blocker result exceeds 32 KiB; use --format json');
+  process.stdout.write(output);
+}
+
+if (isMain(import.meta.url)) {
+  try {
+    main(process.argv.slice(2));
+  } catch (error) {
+    reportError(error);
+  }
+}

package/scripts/install-launcher.mjs

@@ -0,0 +1,28 @@
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { applicationRoot } from '../src/locations.mjs';
+
+export const commandNames = ['outask', 'tasks'];
+export const packageNames = ['outask', 'task-tracker-local'];
+
+export function installLocations() {
+  const destination = applicationRoot();
+  return {
+    bin: process.platform === 'win32' ? join(destination, 'commands') : join(process.env.HOME || homedir(), '.local/bin'),
+    releases: dirname(destination), destination,
+  };
+}
+
+export function windowsLauncher(entry) {
+  // ASCII batch text survives legacy console code pages; Node decodes the path.
+  const encoded = Buffer.from(entry, 'utf8').toString('base64');
+  const bootstrap = `const p=Buffer.from('${encoded}','base64').toString('utf8');process.argv.splice(1,0,p);import(require('node:url').pathToFileURL(p).href).catch(e=>{console.error(e);process.exitCode=1});`;
+  return `@echo off\r\nrem Outask managed launcher\r\nsetlocal DisableDelayedExpansion\r\nwhere.exe node >nul 2>nul\r\nif errorlevel 1 (\r\n  echo DEPENDENCY_MISSING: install Node.js 22.23.3 or later and put node on PATH 1>&2\r\n  exit /b 1\r\n)\r\nnode -e "${bootstrap}" -- %*\r\nexit /b %errorlevel%\r\n`;
+}
+
+export function launcherEntry(contents) {
+  const match = contents.match(/Buffer\.from\('([A-Za-z0-9+/]+={0,2})','base64'\)/);
+  if (!match) return undefined;
+  const entry = Buffer.from(match[1], 'base64').toString('utf8');
+  return contents === windowsLauncher(entry) ? entry : undefined;
+}