@obsfx/trekker 1.1.0 → 1.2.2

package/dist/index.js

@@ -310,17 +310,498 @@ function wipeProject(cwd = process.cwd()) {
   deleteDb(cwd);
 }
 
+// node_modules/@toon-format/toon/dist/index.mjs
+var LIST_ITEM_MARKER = "-";
+var LIST_ITEM_PREFIX = "- ";
+var COMMA = ",";
+var PIPE = "|";
+var DOT = ".";
+var NULL_LITERAL = "null";
+var TRUE_LITERAL = "true";
+var FALSE_LITERAL = "false";
+var BACKSLASH = "\\";
+var DOUBLE_QUOTE = '"';
+var TAB = "\t";
+var DELIMITERS = {
+  comma: COMMA,
+  tab: TAB,
+  pipe: PIPE
+};
+var DEFAULT_DELIMITER = DELIMITERS.comma;
+function escapeString(value) {
+  return value.replace(/\\/g, `${BACKSLASH}${BACKSLASH}`).replace(/"/g, `${BACKSLASH}${DOUBLE_QUOTE}`).replace(/\n/g, `${BACKSLASH}n`).replace(/\r/g, `${BACKSLASH}r`).replace(/\t/g, `${BACKSLASH}t`);
+}
+function isBooleanOrNullLiteral(token) {
+  return token === TRUE_LITERAL || token === FALSE_LITERAL || token === NULL_LITERAL;
+}
+function normalizeValue(value) {
+  if (value === null)
+    return null;
+  if (typeof value === "object" && value !== null && "toJSON" in value && typeof value.toJSON === "function") {
+    const next = value.toJSON();
+    if (next !== value)
+      return normalizeValue(next);
+  }
+  if (typeof value === "string" || typeof value === "boolean")
+    return value;
+  if (typeof value === "number") {
+    if (Object.is(value, -0))
+      return 0;
+    if (!Number.isFinite(value))
+      return null;
+    return value;
+  }
+  if (typeof value === "bigint") {
+    if (value >= Number.MIN_SAFE_INTEGER && value <= Number.MAX_SAFE_INTEGER)
+      return Number(value);
+    return value.toString();
+  }
+  if (value instanceof Date)
+    return value.toISOString();
+  if (Array.isArray(value))
+    return value.map(normalizeValue);
+  if (value instanceof Set)
+    return Array.from(value).map(normalizeValue);
+  if (value instanceof Map)
+    return Object.fromEntries(Array.from(value, ([k, v]) => [String(k), normalizeValue(v)]));
+  if (isPlainObject(value)) {
+    const normalized = {};
+    for (const key in value)
+      if (Object.prototype.hasOwnProperty.call(value, key))
+        normalized[key] = normalizeValue(value[key]);
+    return normalized;
+  }
+  return null;
+}
+function isJsonPrimitive(value) {
+  return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function isJsonArray(value) {
+  return Array.isArray(value);
+}
+function isJsonObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isEmptyObject(value) {
+  return Object.keys(value).length === 0;
+}
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object")
+    return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === null || prototype === Object.prototype;
+}
+function isArrayOfPrimitives(value) {
+  return value.length === 0 || value.every((item) => isJsonPrimitive(item));
+}
+function isArrayOfArrays(value) {
+  return value.length === 0 || value.every((item) => isJsonArray(item));
+}
+function isArrayOfObjects(value) {
+  return value.length === 0 || value.every((item) => isJsonObject(item));
+}
+function isValidUnquotedKey(key) {
+  return /^[A-Z_][\w.]*$/i.test(key);
+}
+function isIdentifierSegment(key) {
+  return /^[A-Z_]\w*$/i.test(key);
+}
+function isSafeUnquoted(value, delimiter = DEFAULT_DELIMITER) {
+  if (!value)
+    return false;
+  if (value !== value.trim())
+    return false;
+  if (isBooleanOrNullLiteral(value) || isNumericLike(value))
+    return false;
+  if (value.includes(":"))
+    return false;
+  if (value.includes('"') || value.includes("\\"))
+    return false;
+  if (/[[\]{}]/.test(value))
+    return false;
+  if (/[\n\r\t]/.test(value))
+    return false;
+  if (value.includes(delimiter))
+    return false;
+  if (value.startsWith(LIST_ITEM_MARKER))
+    return false;
+  return true;
+}
+function isNumericLike(value) {
+  return /^-?\d+(?:\.\d+)?(?:e[+-]?\d+)?$/i.test(value) || /^0\d+$/.test(value);
+}
+var QUOTED_KEY_MARKER = Symbol("quotedKey");
+function tryFoldKeyChain(key, value, siblings, options, rootLiteralKeys, pathPrefix, flattenDepth) {
+  if (options.keyFolding !== "safe")
+    return;
+  if (!isJsonObject(value))
+    return;
+  const { segments, tail, leafValue } = collectSingleKeyChain(key, value, flattenDepth ?? options.flattenDepth);
+  if (segments.length < 2)
+    return;
+  if (!segments.every((seg) => isIdentifierSegment(seg)))
+    return;
+  const foldedKey = buildFoldedKey(segments);
+  const absolutePath = pathPrefix ? `${pathPrefix}${DOT}${foldedKey}` : foldedKey;
+  if (siblings.includes(foldedKey))
+    return;
+  if (rootLiteralKeys && rootLiteralKeys.has(absolutePath))
+    return;
+  return {
+    foldedKey,
+    remainder: tail,
+    leafValue,
+    segmentCount: segments.length
+  };
+}
+function collectSingleKeyChain(startKey, startValue, maxDepth) {
+  const segments = [startKey];
+  let currentValue = startValue;
+  while (segments.length < maxDepth) {
+    if (!isJsonObject(currentValue))
+      break;
+    const keys = Object.keys(currentValue);
+    if (keys.length !== 1)
+      break;
+    const nextKey = keys[0];
+    const nextValue = currentValue[nextKey];
+    segments.push(nextKey);
+    currentValue = nextValue;
+  }
+  if (!isJsonObject(currentValue) || isEmptyObject(currentValue))
+    return {
+      segments,
+      tail: undefined,
+      leafValue: currentValue
+    };
+  return {
+    segments,
+    tail: currentValue,
+    leafValue: currentValue
+  };
+}
+function buildFoldedKey(segments) {
+  return segments.join(DOT);
+}
+function encodePrimitive(value, delimiter) {
+  if (value === null)
+    return NULL_LITERAL;
+  if (typeof value === "boolean")
+    return String(value);
+  if (typeof value === "number")
+    return String(value);
+  return encodeStringLiteral(value, delimiter);
+}
+function encodeStringLiteral(value, delimiter = DEFAULT_DELIMITER) {
+  if (isSafeUnquoted(value, delimiter))
+    return value;
+  return `${DOUBLE_QUOTE}${escapeString(value)}${DOUBLE_QUOTE}`;
+}
+function encodeKey(key) {
+  if (isValidUnquotedKey(key))
+    return key;
+  return `${DOUBLE_QUOTE}${escapeString(key)}${DOUBLE_QUOTE}`;
+}
+function encodeAndJoinPrimitives(values, delimiter = DEFAULT_DELIMITER) {
+  return values.map((v) => encodePrimitive(v, delimiter)).join(delimiter);
+}
+function formatHeader(length, options) {
+  const key = options?.key;
+  const fields = options?.fields;
+  const delimiter = options?.delimiter ?? COMMA;
+  let header = "";
+  if (key)
+    header += encodeKey(key);
+  header += `[${length}${delimiter !== DEFAULT_DELIMITER ? delimiter : ""}]`;
+  if (fields) {
+    const quotedFields = fields.map((f) => encodeKey(f));
+    header += `{${quotedFields.join(delimiter)}}`;
+  }
+  header += ":";
+  return header;
+}
+function* encodeJsonValue(value, options, depth) {
+  if (isJsonPrimitive(value)) {
+    const encodedPrimitive = encodePrimitive(value, options.delimiter);
+    if (encodedPrimitive !== "")
+      yield encodedPrimitive;
+    return;
+  }
+  if (isJsonArray(value))
+    yield* encodeArrayLines(undefined, value, depth, options);
+  else if (isJsonObject(value))
+    yield* encodeObjectLines(value, depth, options);
+}
+function* encodeObjectLines(value, depth, options, rootLiteralKeys, pathPrefix, remainingDepth) {
+  const keys = Object.keys(value);
+  if (depth === 0 && !rootLiteralKeys)
+    rootLiteralKeys = new Set(keys.filter((k) => k.includes(".")));
+  const effectiveFlattenDepth = remainingDepth ?? options.flattenDepth;
+  for (const [key, val] of Object.entries(value))
+    yield* encodeKeyValuePairLines(key, val, depth, options, keys, rootLiteralKeys, pathPrefix, effectiveFlattenDepth);
+}
+function* encodeKeyValuePairLines(key, value, depth, options, siblings, rootLiteralKeys, pathPrefix, flattenDepth) {
+  const currentPath = pathPrefix ? `${pathPrefix}${DOT}${key}` : key;
+  const effectiveFlattenDepth = flattenDepth ?? options.flattenDepth;
+  if (options.keyFolding === "safe" && siblings) {
+    const foldResult = tryFoldKeyChain(key, value, siblings, options, rootLiteralKeys, pathPrefix, effectiveFlattenDepth);
+    if (foldResult) {
+      const { foldedKey, remainder, leafValue, segmentCount } = foldResult;
+      const encodedFoldedKey = encodeKey(foldedKey);
+      if (remainder === undefined) {
+        if (isJsonPrimitive(leafValue)) {
+          yield indentedLine(depth, `${encodedFoldedKey}: ${encodePrimitive(leafValue, options.delimiter)}`, options.indent);
+          return;
+        } else if (isJsonArray(leafValue)) {
+          yield* encodeArrayLines(foldedKey, leafValue, depth, options);
+          return;
+        } else if (isJsonObject(leafValue) && isEmptyObject(leafValue)) {
+          yield indentedLine(depth, `${encodedFoldedKey}:`, options.indent);
+          return;
+        }
+      }
+      if (isJsonObject(remainder)) {
+        yield indentedLine(depth, `${encodedFoldedKey}:`, options.indent);
+        const remainingDepth = effectiveFlattenDepth - segmentCount;
+        const foldedPath = pathPrefix ? `${pathPrefix}${DOT}${foldedKey}` : foldedKey;
+        yield* encodeObjectLines(remainder, depth + 1, options, rootLiteralKeys, foldedPath, remainingDepth);
+        return;
+      }
+    }
+  }
+  const encodedKey = encodeKey(key);
+  if (isJsonPrimitive(value))
+    yield indentedLine(depth, `${encodedKey}: ${encodePrimitive(value, options.delimiter)}`, options.indent);
+  else if (isJsonArray(value))
+    yield* encodeArrayLines(key, value, depth, options);
+  else if (isJsonObject(value)) {
+    yield indentedLine(depth, `${encodedKey}:`, options.indent);
+    if (!isEmptyObject(value))
+      yield* encodeObjectLines(value, depth + 1, options, rootLiteralKeys, currentPath, effectiveFlattenDepth);
+  }
+}
+function* encodeArrayLines(key, value, depth, options) {
+  if (value.length === 0) {
+    yield indentedLine(depth, formatHeader(0, {
+      key,
+      delimiter: options.delimiter
+    }), options.indent);
+    return;
+  }
+  if (isArrayOfPrimitives(value)) {
+    yield indentedLine(depth, encodeInlineArrayLine(value, options.delimiter, key), options.indent);
+    return;
+  }
+  if (isArrayOfArrays(value)) {
+    if (value.every((arr) => isArrayOfPrimitives(arr))) {
+      yield* encodeArrayOfArraysAsListItemsLines(key, value, depth, options);
+      return;
+    }
+  }
+  if (isArrayOfObjects(value)) {
+    const header = extractTabularHeader(value);
+    if (header)
+      yield* encodeArrayOfObjectsAsTabularLines(key, value, header, depth, options);
+    else
+      yield* encodeMixedArrayAsListItemsLines(key, value, depth, options);
+    return;
+  }
+  yield* encodeMixedArrayAsListItemsLines(key, value, depth, options);
+}
+function* encodeArrayOfArraysAsListItemsLines(prefix, values, depth, options) {
+  yield indentedLine(depth, formatHeader(values.length, {
+    key: prefix,
+    delimiter: options.delimiter
+  }), options.indent);
+  for (const arr of values)
+    if (isArrayOfPrimitives(arr)) {
+      const arrayLine = encodeInlineArrayLine(arr, options.delimiter);
+      yield indentedListItem(depth + 1, arrayLine, options.indent);
+    }
+}
+function encodeInlineArrayLine(values, delimiter, prefix) {
+  const header = formatHeader(values.length, {
+    key: prefix,
+    delimiter
+  });
+  const joinedValue = encodeAndJoinPrimitives(values, delimiter);
+  if (values.length === 0)
+    return header;
+  return `${header} ${joinedValue}`;
+}
+function* encodeArrayOfObjectsAsTabularLines(prefix, rows, header, depth, options) {
+  yield indentedLine(depth, formatHeader(rows.length, {
+    key: prefix,
+    fields: header,
+    delimiter: options.delimiter
+  }), options.indent);
+  yield* writeTabularRowsLines(rows, header, depth + 1, options);
+}
+function extractTabularHeader(rows) {
+  if (rows.length === 0)
+    return;
+  const firstRow = rows[0];
+  const firstKeys = Object.keys(firstRow);
+  if (firstKeys.length === 0)
+    return;
+  if (isTabularArray(rows, firstKeys))
+    return firstKeys;
+}
+function isTabularArray(rows, header) {
+  for (const row of rows) {
+    if (Object.keys(row).length !== header.length)
+      return false;
+    for (const key of header) {
+      if (!(key in row))
+        return false;
+      if (!isJsonPrimitive(row[key]))
+        return false;
+    }
+  }
+  return true;
+}
+function* writeTabularRowsLines(rows, header, depth, options) {
+  for (const row of rows)
+    yield indentedLine(depth, encodeAndJoinPrimitives(header.map((key) => row[key]), options.delimiter), options.indent);
+}
+function* encodeMixedArrayAsListItemsLines(prefix, items, depth, options) {
+  yield indentedLine(depth, formatHeader(items.length, {
+    key: prefix,
+    delimiter: options.delimiter
+  }), options.indent);
+  for (const item of items)
+    yield* encodeListItemValueLines(item, depth + 1, options);
+}
+function* encodeObjectAsListItemLines(obj, depth, options) {
+  if (isEmptyObject(obj)) {
+    yield indentedLine(depth, LIST_ITEM_MARKER, options.indent);
+    return;
+  }
+  const entries = Object.entries(obj);
+  const [firstKey, firstValue] = entries[0];
+  const restEntries = entries.slice(1);
+  if (isJsonArray(firstValue) && isArrayOfObjects(firstValue)) {
+    const header = extractTabularHeader(firstValue);
+    if (header) {
+      yield indentedListItem(depth, formatHeader(firstValue.length, {
+        key: firstKey,
+        fields: header,
+        delimiter: options.delimiter
+      }), options.indent);
+      yield* writeTabularRowsLines(firstValue, header, depth + 2, options);
+      if (restEntries.length > 0)
+        yield* encodeObjectLines(Object.fromEntries(restEntries), depth + 1, options);
+      return;
+    }
+  }
+  const encodedKey = encodeKey(firstKey);
+  if (isJsonPrimitive(firstValue))
+    yield indentedListItem(depth, `${encodedKey}: ${encodePrimitive(firstValue, options.delimiter)}`, options.indent);
+  else if (isJsonArray(firstValue))
+    if (firstValue.length === 0)
+      yield indentedListItem(depth, `${encodedKey}${formatHeader(0, { delimiter: options.delimiter })}`, options.indent);
+    else if (isArrayOfPrimitives(firstValue))
+      yield indentedListItem(depth, `${encodedKey}${encodeInlineArrayLine(firstValue, options.delimiter)}`, options.indent);
+    else {
+      yield indentedListItem(depth, `${encodedKey}${formatHeader(firstValue.length, { delimiter: options.delimiter })}`, options.indent);
+      for (const item of firstValue)
+        yield* encodeListItemValueLines(item, depth + 2, options);
+    }
+  else if (isJsonObject(firstValue)) {
+    yield indentedListItem(depth, `${encodedKey}:`, options.indent);
+    if (!isEmptyObject(firstValue))
+      yield* encodeObjectLines(firstValue, depth + 2, options);
+  }
+  if (restEntries.length > 0)
+    yield* encodeObjectLines(Object.fromEntries(restEntries), depth + 1, options);
+}
+function* encodeListItemValueLines(value, depth, options) {
+  if (isJsonPrimitive(value))
+    yield indentedListItem(depth, encodePrimitive(value, options.delimiter), options.indent);
+  else if (isJsonArray(value))
+    if (isArrayOfPrimitives(value))
+      yield indentedListItem(depth, encodeInlineArrayLine(value, options.delimiter), options.indent);
+    else {
+      yield indentedListItem(depth, formatHeader(value.length, { delimiter: options.delimiter }), options.indent);
+      for (const item of value)
+        yield* encodeListItemValueLines(item, depth + 1, options);
+    }
+  else if (isJsonObject(value))
+    yield* encodeObjectAsListItemLines(value, depth, options);
+}
+function indentedLine(depth, content, indentSize) {
+  return " ".repeat(indentSize * depth) + content;
+}
+function indentedListItem(depth, content, indentSize) {
+  return indentedLine(depth, LIST_ITEM_PREFIX + content, indentSize);
+}
+function applyReplacer(root, replacer) {
+  const replacedRoot = replacer("", root, []);
+  if (replacedRoot === undefined)
+    return transformChildren(root, replacer, []);
+  return transformChildren(normalizeValue(replacedRoot), replacer, []);
+}
+function transformChildren(value, replacer, path) {
+  if (isJsonObject(value))
+    return transformObject(value, replacer, path);
+  if (isJsonArray(value))
+    return transformArray(value, replacer, path);
+  return value;
+}
+function transformObject(obj, replacer, path) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const childPath = [...path, key];
+    const replacedValue = replacer(key, value, childPath);
+    if (replacedValue === undefined)
+      continue;
+    result[key] = transformChildren(normalizeValue(replacedValue), replacer, childPath);
+  }
+  return result;
+}
+function transformArray(arr, replacer, path) {
+  const result = [];
+  for (let i = 0;i < arr.length; i++) {
+    const value = arr[i];
+    const childPath = [...path, i];
+    const replacedValue = replacer(String(i), value, childPath);
+    if (replacedValue === undefined)
+      continue;
+    const normalizedValue = normalizeValue(replacedValue);
+    result.push(transformChildren(normalizedValue, replacer, childPath));
+  }
+  return result;
+}
+function encode(input, options) {
+  return Array.from(encodeLines(input, options)).join(`
+`);
+}
+function encodeLines(input, options) {
+  const normalizedValue = normalizeValue(input);
+  const resolvedOptions = resolveOptions(options);
+  return encodeJsonValue(resolvedOptions.replacer ? applyReplacer(normalizedValue, resolvedOptions.replacer) : normalizedValue, resolvedOptions, 0);
+}
+function resolveOptions(options) {
+  return {
+    indent: options?.indent ?? 2,
+    delimiter: options?.delimiter ?? DEFAULT_DELIMITER,
+    keyFolding: options?.keyFolding ?? "off",
+    flattenDepth: options?.flattenDepth ?? Number.POSITIVE_INFINITY,
+    replacer: options?.replacer
+  };
+}
+
 // src/utils/output.ts
-var jsonMode = false;
-function setJsonMode(enabled) {
-  jsonMode = enabled;
+var toonMode = false;
+function setToonMode(enabled) {
+  toonMode = enabled;
 }
-function isJsonMode() {
-  return jsonMode;
+function isToonMode() {
+  return toonMode;
 }
 function output(data) {
-  if (jsonMode) {
-    console.log(JSON.stringify(data, null, 2));
+  if (toonMode) {
+    console.log(encode(data));
   } else if (typeof data === "string") {
     console.log(data);
   } else {
@@ -328,8 +809,8 @@ function output(data) {
   }
 }
 function success(message, data) {
-  if (jsonMode) {
-    console.log(JSON.stringify({ success: true, message, data }, null, 2));
+  if (toonMode) {
+    console.log(encode({ success: true, message, data }));
   } else {
     console.log(`\u2713 ${message}`);
     if (data) {
@@ -338,8 +819,8 @@ function success(message, data) {
   }
 }
 function error(message, details) {
-  if (jsonMode) {
-    console.error(JSON.stringify({ success: false, error: message, details }, null, 2));
+  if (toonMode) {
+    console.error(encode({ success: false, error: message, details }));
   } else {
     console.error(`\u2717 Error: ${message}`);
     if (details) {
@@ -348,7 +829,7 @@ function error(message, details) {
   }
 }
 function info(message) {
-  if (!jsonMode) {
+  if (!toonMode) {
     console.log(message);
   }
 }
@@ -613,7 +1094,7 @@ epicCommand.command("create").description("Create a new epic").requiredOption("-
       priority: parsePriority(options.priority),
       status: parseStatus(options.status, "epic")
     });
-    if (isJsonMode()) {
+    if (isToonMode()) {
       output(epic);
     } else {
       success(`Epic created: ${epic.id}`);
@@ -628,7 +1109,7 @@ epicCommand.command("list").description("List all epics").option("-s, --status <
   try {
     const status = parseStatus(options.status, "epic");
     const epics2 = listEpics(status);
-    if (isJsonMode()) {
+    if (isToonMode()) {
       output(epics2);
     } else {
       console.log(formatEpicList(epics2));
@@ -645,7 +1126,7 @@ epicCommand.command("show <epic-id>").description("Show epic details").action((e
       error(`Epic not found: ${epicId}`);
       process.exit(1);
     }
-    if (isJsonMode()) {
+    if (isToonMode()) {
       output(epic);
     } else {
       console.log(formatEpic(epic));
@@ -663,7 +1144,7 @@ epicCommand.command("update <epic-id>").description("Update an epic").option("-t
       priority: parsePriority(options.priority),
       status: parseStatus(options.status, "epic")
     });
-    if (isJsonMode()) {
+    if (isToonMode()) {
       output(epic);
     } else {
       success(`Epic updated: ${epic.id}`);
@@ -805,7 +1286,7 @@ taskCommand.command("create").description("Create a new task").requiredOption("-
       tags: options.tags,
       epicId: options.epic
     });
-    if (isJsonMode()) {
+    if (isToonMode()) {
       output(task);
     } else {
       success(`Task created: ${task.id}`);
@@ -824,7 +1305,7 @@ taskCommand.command("list").description("List all tasks").option("-s, --status <
       epicId: options.epic,
       parentTaskId: null
     });
-    if (isJsonMode()) {
+    if (isToonMode()) {
       output(tasks2);
     } else {
       console.log(formatTaskList(tasks2));
@@ -841,7 +1322,7 @@ taskCommand.command("show <task-id>").description("Show task details").action((t
       error(`Task not found: ${taskId}`);
       process.exit(1);
     }
-    if (isJsonMode()) {
+    if (isToonMode()) {
       output(task);
     } else {
       console.log(formatTask(task));
@@ -871,7 +1352,7 @@ taskCommand.command("update <task-id>").description("Update a task").option("-t,
       updateInput.epicId = options.epic;
     }
     const task = updateTask(taskId, updateInput);
-    if (isJsonMode()) {
+    if (isToonMode()) {
       output(task);
     } else {
       success(`Task updated: ${task.id}`);
@@ -911,7 +1392,7 @@ subtaskCommand.command("create <parent-task-id>").description("Create a new subt
       parentTaskId,
       epicId: parent.epicId ?? undefined
     });
-    if (isJsonMode()) {
+    if (isToonMode()) {
       output(subtask);
     } else {
       success(`Subtask created: ${subtask.id}`);
@@ -930,7 +1411,7 @@ subtaskCommand.command("list <parent-task-id>").description("List all subtasks o
       process.exit(1);
     }
     const subtasks = listSubtasks(parentTaskId);
-    if (isJsonMode()) {
+    if (isToonMode()) {
       output(subtasks);
     } else {
       if (subtasks.length === 0) {
@@ -967,7 +1448,7 @@ subtaskCommand.command("update <subtask-id>").description("Update a subtask").op
       updateInput.status = parseStatus(options.status, "task");
     }
     const updated = updateTask(subtaskId, updateInput);
-    if (isJsonMode()) {
+    if (isToonMode()) {
       output(updated);
     } else {
       success(`Subtask updated: ${updated.id}`);
@@ -1066,7 +1547,7 @@ commentCommand.command("add <task-id>").description("Add a comment to a task").r
       author: options.author,
       content: options.content
     });
-    if (isJsonMode()) {
+    if (isToonMode()) {
       output(comment);
     } else {
       success(`Comment added: ${comment.id}`);
@@ -1080,7 +1561,7 @@ commentCommand.command("add <task-id>").description("Add a comment to a task").r
 commentCommand.command("list <task-id>").description("List all comments on a task").action((taskId) => {
   try {
     const comments2 = listComments(taskId);
-    if (isJsonMode()) {
+    if (isToonMode()) {
       output(comments2);
     } else {
       if (comments2.length === 0) {
@@ -1101,7 +1582,7 @@ commentCommand.command("update <comment-id>").description("Update a comment").re
     const comment = updateComment(commentId, {
       content: options.content
     });
-    if (isJsonMode()) {
+    if (isToonMode()) {
       output(comment);
     } else {
       success(`Comment updated: ${comment.id}`);
@@ -1206,7 +1687,7 @@ var depCommand = new Command7("dep").description("Manage task dependencies");
 depCommand.command("add <task-id> <depends-on-id>").description("Add a dependency (task-id depends on depends-on-id)").action((taskId, dependsOnId) => {
   try {
     const dependency = addDependency(taskId, dependsOnId);
-    if (isJsonMode()) {
+    if (isToonMode()) {
       output(dependency);
     } else {
       success(`Dependency added: ${taskId} \u2192 depends on ${dependsOnId}`);
@@ -1228,7 +1709,7 @@ depCommand.command("remove <task-id> <depends-on-id>").description("Remove a dep
 depCommand.command("list <task-id>").description("List dependencies for a task").action((taskId) => {
   try {
     const { dependsOn, blocks } = getDependencies(taskId);
-    if (isJsonMode()) {
+    if (isToonMode()) {
       output({ taskId, dependsOn, blocks });
     } else {
       console.log(`Dependencies for ${taskId}:`);
@@ -1247,729 +1728,76 @@ Blocks:`);
 
 // src/commands/quickstart.ts
 import { Command as Command8 } from "commander";
-var QUICKSTART_TEXT = `# Trekker - AI Agent Quickstart Guide
-
-Trekker is a CLI-based issue tracker designed for coding agents. It stores all data in a local SQLite database at \`.trekker/trekker.db\` in your project root.
-
-## Why Use Trekker?
-
-As an AI agent, you should use Trekker to:
-- **Track your work** across multiple sessions and context windows
-- **Break down complex tasks** into manageable, atomic pieces
-- **Document decisions** and progress for future reference
-- **Manage dependencies** between tasks to ensure correct execution order
-- **Offload context** - store your reasoning, findings, and state externally so you can recover after context resets
-- **Persist memory** - comments survive context window limits and session boundaries
-
----
-
-## Critical Rules for AI Agents
-
-These rules are **non-negotiable**. Following them ensures continuity across sessions and prevents lost context.
-
-### 1. ALWAYS Update Task Status
-
-**Never leave a task in the wrong status.** Status reflects reality and helps you (and future sessions) understand what's happening.
-
-- Set to \`in_progress\` **immediately** when you start working on a task
-- Set to \`completed\` **only after** you've verified the work is done
-- Set to \`wont_fix\` or \`archived\` if the task is no longer relevant
-- **Before ending any session**: ensure all task statuses are accurate
-
-\`\`\`bash
-# Starting work
-trekker task update TREK-1 -s in_progress
-
-# Finishing work
-trekker task update TREK-1 -s completed
-\`\`\`
-
-**Why this matters:** If you forget to update status, the next session (or another agent) won't know what's actually done. They'll either duplicate work or miss incomplete tasks.
-
-### 2. ALWAYS Add a Summary Comment Before Moving On
-
-**Before moving to a new task, document what you did on the current one.** This is your handoff to your future self.
-
-Every task completion should include a comment with:
-- **What was implemented** (files changed, functions added)
-- **Key decisions made** and why
-- **Any gotchas or important notes** for future reference
-- **Testing done** or verification steps taken
-
-\`\`\`bash
-# Before marking complete, add a summary
-trekker comment add TREK-1 -a "agent" -c "Completed: Implemented JWT auth endpoint.
-- Added POST /api/auth/login in routes/auth.ts (lines 45-80)
-- Created validateCredentials() in services/auth.ts
-- Chose bcrypt for hashing (better library support than argon2)
-- Tested: valid login returns token, invalid returns 401
-- Note: Token expires in 24h, configurable via JWT_EXPIRY env var"
-
-# Then mark complete
-trekker task update TREK-1 -s completed
-\`\`\`
-
-**Why this matters:** Comments are your external memory. Without a summary, you lose all the context and reasoning from your work session.
-
-### 3. Use Epic Descriptions for Implementation Plans
-
-**Epic descriptions are your design documents.** Don't put brief one-liners\u2014use them to capture the full implementation plan.
-
-An epic description should include:
-- **Goal and scope** - what problem are we solving?
-- **Architecture overview** - how will components fit together?
-- **Implementation phases** - what order should tasks follow?
-- **Technical decisions** - chosen approaches and rationale
-- **API contracts** - endpoints, request/response formats
-- **Data models** - schema changes, new entities
-- **Edge cases and constraints** - what to watch out for
-
-\`\`\`bash
-trekker epic create -t "User Authentication System" -d "## Goal
-Implement secure user authentication with JWT tokens.
-
-## Architecture
-- Auth service handles token generation/validation
-- Middleware intercepts requests and verifies tokens
-- Redis stores refresh tokens for revocation support
-
-## Implementation Phases
-1. Basic JWT auth (login, token generation)
-2. Refresh token mechanism
-3. Password reset flow
-4. Rate limiting on auth endpoints
-
-## API Endpoints
-- POST /api/auth/login - {email, password} -> {accessToken, refreshToken}
-- POST /api/auth/refresh - {refreshToken} -> {accessToken}
-- POST /api/auth/logout - invalidates refresh token
-- POST /api/auth/forgot-password - sends reset email
-
-## Data Model
-- users table: id, email, passwordHash, createdAt, updatedAt
-- refresh_tokens table: id, userId, token, expiresAt, revokedAt
-
-## Security Considerations
-- Passwords hashed with bcrypt (cost factor 12)
-- Access tokens expire in 15 minutes
-- Refresh tokens expire in 7 days
-- Rate limit: 5 login attempts per minute per IP"
-\`\`\`
-
-**Why this matters:** When you start a new session, the epic description tells you the full plan. You won't have to re-derive the architecture or remember why certain decisions were made.
-
-### 4. Archive Completed Work
-
-**When a feature is fully done, move everything to \`archived\` status.** This keeps the active task list clean and signals that work is truly finished.
-
-- Archive tasks after they've been completed and verified
-- Archive the epic once all its tasks are done
-- Archived items stay in the database for reference but don't clutter active views
-
-\`\`\`bash
-# After all tasks in an epic are completed
-trekker task update TREK-1 -s archived
-trekker task update TREK-2 -s archived
-trekker task update TREK-3 -s archived
-trekker epic update EPIC-1 -s archived
-\`\`\`
-
-**Why this matters:** A clean task list helps you focus on what's actually in progress. Archived items preserve history without noise.
-
----
-
-## Best Practices for AI Agents
-
-### Creating Epics
-- Create one epic per **feature or major goal**
-- Use clear, descriptive titles that explain the outcome (e.g., "User Authentication System" not "Auth")
-- Write descriptions that capture the **why** and **scope** of the work
-- Example: \`trekker epic create -t "REST API for User Management" -d "Build CRUD endpoints for users with JWT auth, input validation, and rate limiting"\`
-
-### Creating Atomic Tasks
-- Each task should be **completable in one focused session**
-- Tasks should have a **single, clear objective**
-- If a task feels too big, break it into subtasks
-- Use action verbs: "Implement", "Add", "Fix", "Refactor", "Update"
-- Bad: \`"Work on authentication"\`
-- Good: \`"Implement JWT token generation endpoint"\`
-
-### Writing Good Descriptions
-- Explain **what** needs to be done and **how** to verify it's complete
-- Include relevant technical details (endpoints, file paths, function names)
-- Mention acceptance criteria when applicable
-- Example: \`-d "Create POST /api/auth/login that accepts {email, password}, validates credentials against DB, returns JWT token. Should return 401 for invalid credentials."\`
-
-### Using Tags Effectively
-- Use tags to categorize work: \`--tags "api,auth,security"\`
-- Common tag categories: component (\`api\`, \`ui\`, \`db\`), type (\`bug\`, \`feature\`, \`refactor\`), area (\`auth\`, \`payments\`)
-
-### Managing Dependencies
-- Always define dependencies when task order matters
-- A task should not start until its dependencies are complete
-- Use \`trekker dep list <task-id>\` to check what's blocking a task
-
-### Adding Comments (Critical for Context Management)
-
-Comments are your **external memory**. Use them extensively to:
-
-**Save Your Thought Process:**
-- Document your reasoning and analysis as you work
-- Record hypotheses before investigating them
-- Note alternatives you considered and why you chose/rejected them
-
-**Offload Context:**
-- When your context window is filling up, dump your current state into comments
-- Record what you've tried, what worked, what didn't
-- Save partial progress so you can resume after a context reset
-
-**Preserve Investigation Results:**
-- Store findings from code exploration
-- Document file locations and relevant code snippets
-- Record error messages and stack traces you're debugging
-
-**Track Decision History:**
-- Log architectural decisions with rationale
-- Document trade-offs you evaluated
-- Record blockers and how you resolved them
-
-**Examples:**
-\`\`\`bash
-# Starting a task - record your initial analysis
-trekker comment add TREK-1 -a "agent" -c "Initial analysis: Need to modify auth.ts (line 45-80) and add new endpoint in routes/api.ts. Dependencies: bcrypt, jsonwebtoken already installed."
-
-# During investigation - save what you found
-trekker comment add TREK-1 -a "agent" -c "Found existing validation in utils/validate.ts:23. Can reuse validateEmail() and validatePassword(). Token generation should follow pattern in auth/jwt.ts."
+var QUICKSTART_TEXT = `# Trekker Quickstart
 
-# Recording a decision
-trekker comment add TREK-1 -a "agent" -c "Decision: Using bcrypt over argon2 for password hashing. Rationale: better library support, existing team familiarity, sufficient security for this use case."
+Issue tracker for AI agents. Data stored in \`.trekker/trekker.db\`.
 
-# Saving progress before context reset
-trekker comment add TREK-1 -a "agent" -c "Progress checkpoint: Implemented login endpoint (auth.ts:45-120). TODO: Add rate limiting, write tests. Blocked by: Need to clarify password reset flow with user."
+## Setup
+trekker init                    # Initialize
+trekker wipe -y                 # Remove all data
 
-# After hitting an issue
-trekker comment add TREK-1 -a "agent" -c "Issue: JWT verification failing. Tried: 1) Checked secret key - correct, 2) Verified token format - valid, 3) Found issue - clock skew on server. Solution: Added 30s leeway to verification."
-\`\`\`
+## Core Rules
+1. Set status to \`in_progress\` when starting, \`completed\` when done
+2. Add summary comment before marking task complete
+3. Use \`--toon\` flag for token-efficient output
 
----
+## Commands
 
-## Initialization
-
-Before using Trekker, initialize it in your project directory:
-
-\`\`\`bash
-trekker init              # Creates .trekker/ directory with database
-\`\`\`
-
-To remove all Trekker data:
-
-\`\`\`bash
-trekker wipe              # Prompts for confirmation
-trekker wipe -y           # Skip confirmation
-\`\`\`
-
-## Global Options
-
-| Option    | Description                                |
-|-----------|--------------------------------------------|
-| \`--json\`  | Output in JSON format (recommended for agents) |
-| \`--help\`  | Show help for any command                  |
-
-**Example:**
-\`\`\`bash
-trekker --json task list  # Returns tasks as JSON array
-\`\`\`
-
----
-
-## Epics
-
-> High-level features or milestones
-
-### Create Epic
-
-\`\`\`bash
-trekker epic create -t <title> [-d <description>] [-p <0-5>] [-s <status>]
-\`\`\`
-
-| Option | Required | Description |
-|--------|----------|-------------|
-| \`-t, --title\` | Yes | Epic title |
-| \`-d, --description\` | No | Detailed description |
-| \`-p, --priority\` | No | 0=critical, 1=high, 2=medium (default), 3=low, 4=backlog, 5=someday |
-| \`-s, --status\` | No | todo (default), in_progress, completed, archived |
-
-**Example:**
-\`\`\`bash
-trekker epic create -t "User Authentication" -d "Implement OAuth2 login" -p 1
-\`\`\`
-
-### List Epics
-
-\`\`\`bash
+### Epics (features/milestones)
+trekker epic create -t "Title" [-d "desc"] [-p 0-5] [-e EPIC-1]
 trekker epic list [--status <status>]
-\`\`\`
-
-### Show Epic
-
-\`\`\`bash
-trekker epic show <epic-id>
-\`\`\`
-
-### Update Epic
-
-\`\`\`bash
-trekker epic update <epic-id> [-t <title>] [-d <desc>] [-p <priority>] [-s <status>]
-\`\`\`
-
-### Delete Epic
-
-\`\`\`bash
-trekker epic delete <epic-id>
-\`\`\`
-
----
-
-## Tasks
-
-> Work items that can be assigned to epics
-
-### Create Task
-
-\`\`\`bash
-trekker task create -t <title> [-d <description>] [-p <0-5>] [-s <status>] [--tags <tags>] [-e <epic-id>]
-\`\`\`
-
-| Option | Required | Description |
-|--------|----------|-------------|
-| \`-t, --title\` | Yes | Task title |
-| \`-d, --description\` | No | Detailed description |
-| \`-p, --priority\` | No | 0-5, default: 2 |
-| \`-s, --status\` | No | todo (default), in_progress, completed, wont_fix, archived |
-| \`--tags\` | No | Comma-separated tags, e.g., "api,auth,backend" |
-| \`-e, --epic\` | No | Epic ID to assign task to |
-
-**Example:**
-\`\`\`bash
-trekker task create -t "Implement login API" -d "POST /api/login endpoint" -e EPIC-1 --tags "api,auth"
-\`\`\`
-
-### List Tasks
-
-\`\`\`bash
-trekker task list [--status <status>] [--epic <epic-id>]
-\`\`\`
-
-**Examples:**
-\`\`\`bash
-trekker task list                      # All top-level tasks
-trekker task list --status todo        # Filter by status
-trekker task list --epic EPIC-1        # Filter by epic
-\`\`\`
-
-### Show Task
-
-\`\`\`bash
-trekker task show <task-id>
-trekker --json task show TREK-1        # Get full task details as JSON
-\`\`\`
-
-### Update Task
-
-\`\`\`bash
-trekker task update <task-id> [-t <title>] [-d <desc>] [-p <priority>] [-s <status>] [--tags <tags>] [-e <epic-id>] [--no-epic]
-\`\`\`
-
-**Examples:**
-\`\`\`bash
-trekker task update TREK-1 -s in_progress
-trekker task update TREK-1 --no-epic   # Remove from epic
-\`\`\`
-
-### Delete Task
-
-\`\`\`bash
-trekker task delete <task-id>
-\`\`\`
-
----
-
-## Subtasks
-
-> Child tasks that belong to a parent task. They inherit the epic from their parent.
-
-### Create Subtask
-
-\`\`\`bash
-trekker subtask create <parent-task-id> -t <title> [-d <description>] [-p <0-5>] [-s <status>]
-\`\`\`
-
-**Example:**
-\`\`\`bash
-trekker subtask create TREK-1 -t "Add input validation"
-\`\`\`
-
-### List Subtasks
-
-\`\`\`bash
-trekker subtask list <parent-task-id>
-\`\`\`
-
-### Update Subtask
-
-\`\`\`bash
-trekker subtask update <subtask-id> [-t <title>] [-d <desc>] [-p <priority>] [-s <status>]
-\`\`\`
-
-### Delete Subtask
-
-\`\`\`bash
-trekker subtask delete <subtask-id>
-\`\`\`
-
----
-
-## Comments
-
-> Your external memory - use extensively to preserve context and reasoning
-
-Comments are **critical for AI agents**. They persist beyond your context window and session boundaries. Use them to:
-- Store your analysis and reasoning
-- Save investigation results
-- Record decisions with rationale
-- Checkpoint progress before context resets
-- Document blockers and solutions
-
-### Add Comment
-
-\`\`\`bash
-trekker comment add <task-id> -a <author> -c <content>
-\`\`\`
-
-| Option | Required | Description |
-|--------|----------|-------------|
-| \`-a, --author\` | Yes | Comment author name (use "agent" for AI) |
-| \`-c, --content\` | Yes | Comment text (can be multi-line) |
-
-**Examples:**
-\`\`\`bash
-# Record analysis
-trekker comment add TREK-1 -a "agent" -c "Analyzed codebase: auth logic in src/auth/, uses JWT stored in httpOnly cookies"
-
-# Save progress checkpoint
-trekker comment add TREK-1 -a "agent" -c "Checkpoint: Completed steps 1-3. Next: implement validation. Files modified: auth.ts, routes.ts"
-
-# Document a blocker
-trekker comment add TREK-1 -a "agent" -c "BLOCKED: Need clarification on password requirements. Asked user, waiting for response."
-\`\`\`
-
-### List Comments
-
-\`\`\`bash
-trekker comment list <task-id>
-trekker --json comment list <task-id>    # Get as JSON for parsing
-\`\`\`
-
-**Pro tip:** Always read comments when resuming work on a task - they contain your previous context!
-
-### Update Comment
-
-\`\`\`bash
-trekker comment update <comment-id> -c <new-content>
-\`\`\`
-
-### Delete Comment
-
-\`\`\`bash
-trekker comment delete <comment-id>
-\`\`\`
-
----
-
-## Dependencies
-
-> Task relationships - which tasks must be completed before others can start.
-> Trekker automatically detects and prevents circular dependencies.
-
-### Add Dependency
-
-\`\`\`bash
-trekker dep add <task-id> <depends-on-id>
-\`\`\`
-
-This means:
-- \`<task-id>\` depends on \`<depends-on-id>\`
-- \`<task-id>\` cannot start until \`<depends-on-id>\` is done
-
-**Example:**
-\`\`\`bash
-trekker dep add TREK-2 TREK-1    # TREK-2 depends on TREK-1
-\`\`\`
-
-### Remove Dependency
-
-\`\`\`bash
-trekker dep remove <task-id> <depends-on-id>
-\`\`\`
-
-### List Dependencies
-
-\`\`\`bash
-trekker dep list <task-id>
-\`\`\`
-
-Shows both:
-- What this task depends on (blockers)
-- What tasks this task blocks
-
----
-
-## Web Interface
-
-Trekker includes a web interface for visual task management.
-
-### Start the Web Interface
-
-\`\`\`bash
-trekker serve              # Start on port 3000
-trekker serve -p 8080      # Start on custom port
-\`\`\`
-
-The web interface provides:
-- Kanban board with tasks grouped by status (TODO, In Progress, Completed)
-- Epic filter to focus on specific features
-- Task details including dependencies, subtasks, and tags
-- Auto-refresh every 5 seconds to reflect CLI changes
-
----
-
-## Reference
-
-### ID Formats
-
-| Type | Format | Example |
-|------|--------|---------|
-| Epic | \`EPIC-n\` | EPIC-1, EPIC-2 |
-| Task/Subtask | \`TREK-n\` | TREK-1, TREK-42 |
-| Comment | \`CMT-n\` | CMT-1, CMT-5 |
-
-IDs are auto-generated and sequential within each type.
-
-### Task Status Values
-
-| Status | Description |
-|--------|-------------|
-| \`todo\` | Not started (default) |
-| \`in_progress\` | Currently being worked on |
-| \`completed\` | Finished successfully |
-| \`wont_fix\` | Decided not to implement |
-| \`archived\` | No longer relevant |
-
-### Epic Status Values
-
-| Status | Description |
-|--------|-------------|
-| \`todo\` | Not started (default) |
-| \`in_progress\` | Work has begun |
-| \`completed\` | All tasks done |
-| \`archived\` | No longer relevant |
-
-### Priority Scale
-
-| Value | Meaning |
-|-------|---------|
-| 0 | Critical (drop everything) |
-| 1 | High (do soon) |
-| 2 | Medium (default) |
-| 3 | Low (when time permits) |
-| 4 | Backlog (future consideration) |
-| 5 | Someday (nice to have) |
-
----
-
-## Recommended Workflow for AI Agents
-
-1. **Initialize** (once per project):
-   \`\`\`bash
-   trekker init
-   \`\`\`
-
-2. **Check existing state** (every session start):
-   \`\`\`bash
-   trekker --json task list --status in_progress   # See what's active
-   trekker --json comment list TREK-1              # Read your previous context
-   \`\`\`
-
-3. **Create epic** for the feature you're working on:
-   \`\`\`bash
-   trekker epic create -t "Feature Name" -d "Description"
-   \`\`\`
-
-4. **Create tasks** for each piece of work:
-   \`\`\`bash
-   trekker task create -t "Task name" -e EPIC-1
-   \`\`\`
-
-5. **Add dependencies** if tasks have ordering requirements:
-   \`\`\`bash
-   trekker dep add TREK-2 TREK-1
-   \`\`\`
-
-6. **Document your initial analysis** before starting work:
-   \`\`\`bash
-   trekker comment add TREK-1 -a "agent" -c "Analysis: Need to modify X, Y, Z. Approach: ..."
-   \`\`\`
-
-7. **Update status** as you work:
-   \`\`\`bash
-   trekker task update TREK-1 -s in_progress
-   \`\`\`
-
-8. **Add comments frequently** - this is your external memory:
-   \`\`\`bash
-   # After investigating
-   trekker comment add TREK-1 -a "agent" -c "Found: auth logic in src/auth.ts:45-80"
-
-   # After making a decision
-   trekker comment add TREK-1 -a "agent" -c "Decision: Using approach X because Y"
-
-   # Before context might reset
-   trekker comment add TREK-1 -a "agent" -c "Checkpoint: Completed A, B. Next: C, D"
-   \`\`\`
-
-9. **Mark complete** when done:
-   \`\`\`bash
-   trekker task update TREK-1 -s completed
-   trekker comment add TREK-1 -a "agent" -c "Completed. Summary: Implemented X in files A, B, C."
-   \`\`\`
-
-10. **Use JSON output** for parsing:
-    \`\`\`bash
-    trekker --json task list
-    trekker --json task show TREK-1
-    \`\`\`
-
----
-
-## Context Management Strategies
-
-AI agents have limited context windows. Use Trekker to extend your effective memory:
-
-### Starting a New Session
-
-Always begin by reading your previous state:
-\`\`\`bash
-# What was I working on?
-trekker --json task list --status in_progress
-
-# What did I learn/decide?
-trekker --json comment list TREK-1
-\`\`\`
-
-### During Long Tasks
-
-Periodically checkpoint your progress:
-\`\`\`bash
-trekker comment add TREK-1 -a "agent" -c "Progress: Steps 1-3 done. Current state: X. Next: Y. Blockers: Z."
-\`\`\`
-
-### Before Context Window Fills Up
-
-When you notice context getting large, dump your current mental state:
-\`\`\`bash
-trekker comment add TREK-1 -a "agent" -c "Context dump:
-- Working on: implementing login validation
-- Files involved: auth.ts (modified lines 45-80), routes.ts (new endpoint at line 120)
-- Current approach: using existing validateEmail() from utils
-- Remaining work: add rate limiting, write tests
-- Open questions: unclear if we need refresh tokens"
-\`\`\`
-
-### After Solving a Problem
-
-Document the solution so future-you doesn't repeat the investigation:
-\`\`\`bash
-trekker comment add TREK-1 -a "agent" -c "Solved: JWT verification failing. Root cause: clock skew. Fix: added 30s leeway in verify(). See auth.ts:67."
-\`\`\`
-
-### When Blocked
-
-Record what you're waiting for:
-\`\`\`bash
-trekker comment add TREK-1 -a "agent" -c "BLOCKED: Need user input on password complexity requirements. Asked in conversation. Current assumption: min 8 chars, 1 number."
-\`\`\`
-
----
-
-## Common Scenarios
-
-### Start a new feature
-
-\`\`\`bash
-trekker epic create -t "API Rate Limiting" -d "Implement rate limiting for all endpoints" -p 1
-trekker task create -t "Design rate limit algorithm" -e EPIC-1
-trekker task create -t "Implement Redis counter" -e EPIC-1
-trekker task create -t "Add middleware" -e EPIC-1
-trekker dep add TREK-3 TREK-2    # Middleware depends on Redis counter
-trekker dep add TREK-2 TREK-1    # Redis counter depends on design
-\`\`\`
-
-### Check what's ready to work on
-
-\`\`\`bash
-trekker --json task list --status todo
-\`\`\`
-
-### Get all details about a task
-
-\`\`\`bash
-trekker --json task show TREK-1
-\`\`\`
-
-### Log progress
-
-\`\`\`bash
+trekker epic show EPIC-1
+trekker epic update EPIC-1 [-t "Title"] [-d "desc"] [-p 0-5] [-s <status>]
+trekker epic delete EPIC-1
+
+### Tasks
+trekker task create -t "Title" [-d "desc"] [-p 0-5] [-e EPIC-1] [--tags "a,b"]
+trekker task list [--status <status>] [--epic EPIC-1]
+trekker task show TREK-1
+trekker task update TREK-1 [-t "Title"] [-d "desc"] [-p 0-5] [-s <status>] [--tags "a,b"] [-e EPIC-1] [--no-epic]
+trekker task delete TREK-1
+
+### Subtasks
+trekker subtask create TREK-1 -t "Title" [-d "desc"] [-p 0-5]
+trekker subtask list TREK-1
+trekker subtask update TREK-2 [-t "Title"] [-d "desc"] [-p 0-5] [-s <status>]
+trekker subtask delete TREK-2
+
+### Comments (external memory)
+trekker comment add TREK-1 -a "agent" -c "content"
+trekker comment list TREK-1
+trekker comment update CMT-1 -c "new content"
+trekker comment delete CMT-1
+
+### Dependencies
+trekker dep add TREK-2 TREK-1   # TREK-2 depends on TREK-1
+trekker dep remove TREK-2 TREK-1
+trekker dep list TREK-1
+
+## Status Values
+Tasks: todo, in_progress, completed, wont_fix, archived
+Epics: todo, in_progress, completed, archived
+
+## Priority Scale
+0=critical, 1=high, 2=medium (default), 3=low, 4=backlog, 5=someday
+
+## Workflow
+
+### Session Start
+trekker --toon task list --status in_progress
+trekker --toon comment list TREK-1
+
+### Working
 trekker task update TREK-1 -s in_progress
-trekker comment add TREK-1 -a "agent" -c "Chose token bucket algorithm"
+trekker comment add TREK-1 -a "agent" -c "Analysis: ..."
+# ... do work ...
+trekker comment add TREK-1 -a "agent" -c "Summary: implemented X in files A, B"
 trekker task update TREK-1 -s completed
-\`\`\`
-
-### Break down a complex task
-
-\`\`\`bash
-trekker subtask create TREK-2 -t "Set up Redis connection"
-trekker subtask create TREK-2 -t "Implement increment logic"
-trekker subtask create TREK-2 -t "Add TTL handling"
-\`\`\`
-
-### Resume work after context reset
-
-\`\`\`bash
-# 1. Find what you were working on
-trekker --json task list --status in_progress
-
-# 2. Read your previous comments to restore context
-trekker --json comment list TREK-1
-
-# 3. Read task details for full picture
-trekker --json task show TREK-1
-
-# 4. Continue work with restored context
-\`\`\`
-
-### Save context before stopping
 
-\`\`\`bash
-# Dump everything you know before session ends
-trekker comment add TREK-1 -a "agent" -c "Session end checkpoint:
-- Completed: login endpoint, validation
-- In progress: rate limiting (50% done, see middleware.ts:30)
-- Files modified: auth.ts, routes.ts, middleware.ts
-- Next steps: finish rate limiter, add tests
-- Notes: user prefers 100 req/min limit"
-\`\`\`
+### Before Context Reset
+trekker comment add TREK-1 -a "agent" -c "Checkpoint: done A,B. Next: C. Files: x.ts, y.ts"
 `;
-var quickstartCommand = new Command8("quickstart").description("Show comprehensive guide for AI agents").action(() => {
+var quickstartCommand = new Command8("quickstart").description("Show quick reference for AI agents").action(() => {
   console.log(QUICKSTART_TEXT);
 });
 
@@ -2245,7 +2073,7 @@ Seed complete! Created ${epicIds.length} epics, ${taskIds.length} tasks, ${SAMPL
 // package.json
 var package_default = {
   name: "@obsfx/trekker",
-  version: "1.1.0",
+  version: "1.2.2",
   description: "A CLI-based issue tracker built for AI coding agents. Stores tasks, epics, and dependencies in a local SQLite database.",
   type: "module",
   main: "dist/index.js",
@@ -2292,6 +2120,7 @@ var package_default = {
     bun: ">=1.0.0"
   },
   dependencies: {
+    "@toon-format/toon": "^2.1.0",
     commander: "^13.1.0",
     "drizzle-orm": "^0.38.4"
   },
@@ -2304,10 +2133,10 @@ var package_default = {
 
 // src/index.ts
 var program = new Command10;
-program.name("trekker").description("CLI-based issue tracker for coding agents").version(package_default.version).option("--json", "Output in JSON format").hook("preAction", (thisCommand) => {
+program.name("trekker").description("CLI-based issue tracker for coding agents").version(package_default.version).option("--toon", "Output in TOON format").hook("preAction", (thisCommand) => {
   const opts = thisCommand.opts();
-  if (opts.json) {
-    setJsonMode(true);
+  if (opts.toon) {
+    setToonMode(true);
   }
 });
 program.addCommand(initCommand);