@youtyan/code-viewer 0.6.3 → 0.6.4

package/dist/code-viewer.js

@@ -823,7 +823,7 @@ function isCommandNotFoundMessage(command, message) {
 }
 var EXTERNAL_COMMAND_NAMES, commandNameSet, activeOverrides;
 var init_command_resolver = __esm(() => {
-  EXTERNAL_COMMAND_NAMES = ["git", "rg", "docker"];
+  EXTERNAL_COMMAND_NAMES = ["git", "rg", "docker", "gh"];
   commandNameSet = new Set(EXTERNAL_COMMAND_NAMES);
   activeOverrides = new Map;
 });
@@ -2231,6 +2231,15 @@ function takeValue(argv, index, flag) {
 function shellSingleQuote(value) {
   return `'${value.replace(/'/g, "'\\''")}'`;
 }
+async function readStdin() {
+  if (process.stdin.isTTY)
+    return "";
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
 function isUnsafeText(value) {
   if (value.includes("\x00"))
     return true;
@@ -2704,15 +2713,6 @@ function parseAnnotateArgs(argv) {
   }
   return { ok: false, error: `unknown annotate command: ${subcommand}` };
 }
-async function readStdin() {
-  if (process.stdin.isTTY)
-    return "";
-  const chunks = [];
-  for await (const chunk of process.stdin) {
-    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-  }
-  return Buffer.concat(chunks).toString("utf8");
-}
 async function annotateRequest(serverUrl, method, action, body) {
   return requestJson(serverUrl, "/_annotations", method, body, action);
 }
@@ -3016,8 +3016,8 @@ location and renders your explanation directly under the annotated lines.
 - The body is Markdown. Code spans, fenced blocks, and links work. Long
   bodies: use --body-file <path> or pipe via stdin instead of --body.
 - Give every annotation a short --title; it becomes the inline heading.
-- Annotating unchanged code is fine: the viewer auto-expands diff context
-  or falls back to the full source view.
+- Annotating unchanged code is fine: when the selected lines are not an
+  after-side diff change, the viewer falls back to the full source view.
 
 ## Sessions
 
@@ -3080,7 +3080,7 @@ bunch of probing commands or open the \uD83E\uDE7A browser panel.
 ## When to use
 
 - A previous command failed; you want to confirm Node / Bun / SQLite /
-  Docker / git state before suggesting a fix.
+  Docker / git / gh state before suggesting a fix.
 - The human asks "is my environment OK", "why does install fail", or
   similar; \`code-viewer doctor\` is the single source of truth.
 - Pre-flight before a destructive step (DB snapshot reset, npx upgrade)
@@ -3111,7 +3111,7 @@ Stable JSON contract (see core/doctor-types.ts):
     "generation": number,         // monotonic, restart resets to 1
     "worstStatus": "ok"|"warn"|"error",
     "groups": [
-      { "id": "runtime"|"package"|"sqlite"|"snapshot"|"git"
+      { "id": "runtime"|"package"|"sqlite"|"snapshot"|"git"|"github"
             |"discovery"|"datastore"|"docker"|"server",
         "title": string,
         "rows": [
@@ -3142,6 +3142,9 @@ The exit code is 1 iff \`worstStatus === "error"\` — never on \`warn\`.
 - \`hint\` is the human-readable fix; quote it verbatim when reporting back.
 - A \`runtime.node\` row failing means Node < 20 — almost everything else
   is downstream of that. Fix it first.
+- A \`github.gh\` row warning means GitHub Issue listing/linking cannot use
+  the GitHub CLI yet. Install \`gh\` or pass \`--bin gh=/absolute/path\`.
+  Doctor intentionally does not inspect GitHub auth metadata.
 - A \`sqlite.*\` row failing usually points at npx cache; the hint shows
   the rm -rf ~/.npm/_npx workaround.
 - Docker rows are advisory — \`code-viewer\` works without Docker; warnings
@@ -4045,123 +4048,1291 @@ Diff Viewer views.
 - Git must be available on PATH, or supplied with --bin git=/absolute/path
   / CODE_VIEWER_BIN_GIT.
 
-## How to call
+## How to call
+
+  code-viewer file blame --path src/sample.ts --json
+  code-viewer file blame --path src/sample.ts --base HEAD --json
+  code-viewer file history --path src/sample.ts --limit 10 --json
+  code-viewer file history --path src/sample.ts --query "author:tester" --json
+  code-viewer file show --path src/sample.ts --json
+  code-viewer file show --path src/sample.ts --start 100 --end 150 --json
+  code-viewer file show --path src/sample.ts --ref main --json
+  code-viewer file diff --path src/sample.ts --json
+  code-viewer file diff --path src/sample.ts --from main --to HEAD --json
+  code-viewer file diff --path src/sample.ts --full --json
+  code-viewer file diff --path new_sample.ts --untracked --json
+  code-viewer file diff --path renamed.ts --old-path original.ts --from HEAD~1 --to HEAD --json
+
+## Output contract
+
+--json shapes (mirroring git.ts DTOs verbatim where possible):
+
+  blame:
+    {
+      "path": string,
+      "ref": string,         // the literal ref the CLI resolved to
+      "base": "worktree"|"HEAD",
+      "result": GitBlameResult   // { lines, commits, isUntracked?, isSynthetic?, error? }
+    }
+  history:
+    {
+      "path": string,
+      "ref": string,
+      "limit": number,
+      "skip": number,
+      "query"?: string,
+      "result": { commits: GitHistoryCommit[], hasMore: boolean, error?: string }
+    }
+  show:
+    {
+      "path": string,
+      "ref": string,
+      "start"?: number,
+      "end"?: number,
+      "totalLines": number,    // total lines in the file at <ref>
+      "complete": boolean,     // true when the returned text covers the whole file
+      "text": string
+    }
+  diff:
+    {
+      "path": string,
+      "old_path"?: string,
+      "from": string,                  // "/dev/null" when untracked is true
+      "to": string,
+      "untracked": boolean,
+      "ignore_ws": boolean,
+      "ignore_blank": boolean,
+      "mode": "preview"|"full",
+      "max_hunks": number|null,        // null in full mode
+      "max_lines": number|null,        // null in full mode
+      "diff": string,                  // unified diff text
+      "hunk_count": number,            // total hunks before truncation
+      "rendered_hunk_count": number,   // hunks actually included in diff
+      "line_count": number,            // total newlines in the returned diff
+      "truncated": boolean,            // true when preview dropped hunks/lines
+      "binary": boolean,               // git emitted "Binary files ..."
+      "error"?: string                 // git stderr (also exits 1)
+    }
+
+Default (non --json) output:
+
+  blame:    one line per source line  →  <line><TAB><shortSha or "worktree"><TAB><summary>
+            uncommitted edits show as "worktree" and "<uncommitted>".
+  history:  one line per commit       →  <shortSha><TAB><whenISO><TAB><author><TAB><subject>
+            0 commits prints "no history" to stderr, exit 0.
+  show:     the file (or sliced lines) as text. 0-byte files succeed (exit 0).
+  diff:     unified diff text (the same bytes the JSON "diff" field carries).
+            Empty (or worktree==worktree) returns nothing on stdout, exit 0.
+
+## Tips
+
+- Prefer --json. blame DTO carries author / authorMail / authorTime per
+  commit; the plain-text format only shows summary.
+- For huge files, slice with --start/--end before piping to a model
+  context — "totalLines" / "complete" tell you what was dropped.
+- file show reads the worktree by default. Pass --ref HEAD / --ref <branch>
+  when you need a committed snapshot.
+- A non-fatal git failure (e.g. unknown ref, unsafe path) returns the
+  error string inside the JSON "result.error" / "error" field AND exits 1.
+- file diff defaults to preview mode (${FILE_DIFF_DEFAULT_MAX_HUNKS} hunks /
+  ${FILE_DIFF_DEFAULT_MAX_LINES} lines). Use --full only when you need every
+  hunk — preview matches the browser's initial paint and is almost always
+  enough context for an LLM. In full mode, max_hunks / max_lines are null in
+  JSON because no preview cap is applied. Worktree == Worktree range returns
+  "" instantly.
+- Use "code-viewer search code" to discover the path first, then drill
+  in with blame / history / show / diff.
+`;
+  VALUE_FLAGS = new Set([
+    "--path",
+    "--ref",
+    "--base",
+    "--limit",
+    "--skip",
+    "--query",
+    "--start",
+    "--end",
+    "--from",
+    "--to",
+    "--old-path",
+    "--max-hunks",
+    "--max-lines"
+  ]);
+  BOOL_FLAGS = new Set([
+    "--json",
+    "--untracked",
+    "--ignore-ws",
+    "--ignore-blank",
+    "--full"
+  ]);
+});
+
+// web-src/core/journal.ts
+function isJournalTaskStatus(value) {
+  return JOURNAL_TASK_STATUSES.includes(value);
+}
+function isJournalTaskPriority(value) {
+  return JOURNAL_TASK_PRIORITIES.includes(value);
+}
+function isIsoDate(value) {
+  if (typeof value !== "string" || !/^\d{4}-\d{2}-\d{2}$/.test(value))
+    return false;
+  const date = new Date(`${value}T00:00:00.000Z`);
+  return Number.isFinite(date.getTime()) && date.toISOString().slice(0, 10) === value;
+}
+function todayIsoDate(now = new Date) {
+  const year = now.getFullYear();
+  const month = String(now.getMonth() + 1).padStart(2, "0");
+  const date = String(now.getDate()).padStart(2, "0");
+  return `${year}-${month}-${date}`;
+}
+function taskClaimActive(task, now = Date.now()) {
+  if (!task.claim)
+    return false;
+  const expires = Date.parse(task.claim.lease_expires_at);
+  return Number.isFinite(expires) && expires > now;
+}
+function normalizeJournalLabel(value) {
+  if (typeof value !== "string")
+    return null;
+  const label = value.trim().toLowerCase().replace(/\s+/g, "-").replace(/[^\p{L}\p{N}._:-]+/gu, "").slice(0, JOURNAL_LABEL_MAX_CHARS).replace(/^[-_.:]+|[-_.:]+$/g, "");
+  return label || null;
+}
+function normalizeJournalLabels(raw) {
+  if (!Array.isArray(raw))
+    return [];
+  const labels = [];
+  const seen = new Set;
+  for (const item of raw) {
+    const label = normalizeJournalLabel(item);
+    if (!label || seen.has(label))
+      continue;
+    seen.add(label);
+    labels.push(label);
+    if (labels.length >= JOURNAL_MAX_LABELS)
+      break;
+  }
+  return labels;
+}
+function journalIssueLabel(issueNumber) {
+  return `issue-${issueNumber}`;
+}
+function journalIssueRepoLabel(repo) {
+  if (typeof repo !== "string")
+    return null;
+  return normalizeJournalLabel(`repo-${repo.replace(/[\\/]+/g, "-")}`);
+}
+function collectJournalLabels(journal, tasks) {
+  const labels = new Set;
+  for (const entry of journal.entries) {
+    for (const label of entry.labels)
+      labels.add(label);
+  }
+  for (const task of tasks.tasks) {
+    for (const label of task.labels)
+      labels.add(label);
+  }
+  return [...labels].sort((a, b) => a.localeCompare(b));
+}
+function filterJournalTasks(state, filter = {}) {
+  const statuses = Array.isArray(filter.status) ? filter.status : filter.status ? [filter.status] : undefined;
+  const labels = filter.labels?.filter(Boolean) || [];
+  return state.tasks.filter((task) => {
+    if (statuses && !statuses.includes(task.status))
+      return false;
+    if (labels.length && !labels.every((label) => task.labels.includes(label))) {
+      return false;
+    }
+    if (!filter.includeClaimed && taskClaimActive(task, filter.now))
+      return false;
+    return true;
+  });
+}
+function selectNextJournalTasks(state, filter = {}, limit = 1) {
+  const status = filter.status || "todo";
+  const indexed = filterJournalTasks(state, { ...filter, status }).map((task, index) => ({ task, index }));
+  indexed.sort((a, b) => {
+    const priority = PRIORITY_SCORE[a.task.priority] - PRIORITY_SCORE[b.task.priority];
+    if (priority !== 0)
+      return priority;
+    if (a.index !== b.index)
+      return a.index - b.index;
+    return a.task.created_at.localeCompare(b.task.created_at);
+  });
+  return indexed.slice(0, Math.max(0, limit)).map((item) => item.task);
+}
+var JOURNAL_TASK_STATUSES, JOURNAL_TASK_PRIORITIES, JOURNAL_LABEL_MAX_CHARS = 48, JOURNAL_MAX_LABELS = 24, PRIORITY_SCORE;
+var init_journal = __esm(() => {
+  JOURNAL_TASK_STATUSES = [
+    "draft",
+    "todo",
+    "doing",
+    "blocked",
+    "done"
+  ];
+  JOURNAL_TASK_PRIORITIES = ["p0", "p1", "p2", "p3"];
+  PRIORITY_SCORE = {
+    p0: 0,
+    p1: 1,
+    p2: 2,
+    p3: 3
+  };
+});
+
+// web-src/server/github-issues.ts
+function normalizeGithubIssueListState(value) {
+  return value === "closed" || value === "all" ? value : "open";
+}
+function normalizeGithubIssueListLimit(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 1) {
+    return 30;
+  }
+  return Math.min(Math.floor(value), 100);
+}
+function singleLineGithubOption(value) {
+  if (!value)
+    return;
+  const trimmed = value.trim();
+  if (!trimmed || trimmed.includes("\x00") || /[\r\n]/.test(trimmed)) {
+    return;
+  }
+  return trimmed.slice(0, 200);
+}
+function githubSearchHasStateQualifier(value) {
+  const search = singleLineGithubOption(value);
+  return !!search && /(^|\s)(is|state):(open|closed|all)(?=\s|$)/i.test(search);
+}
+function extractGithubIssueLabels(raw) {
+  if (!Array.isArray(raw))
+    return [];
+  const labels = [];
+  for (const item of raw) {
+    if (typeof item === "string") {
+      const label = singleLineGithubOption(item);
+      if (label)
+        labels.push(label);
+    } else if (item && typeof item === "object" && "name" in item) {
+      const label = singleLineGithubOption(item.name);
+      if (label)
+        labels.push(label);
+    }
+  }
+  return labels.slice(0, 12);
+}
+function normalizeGithubIssueListItem(raw) {
+  if (!raw || typeof raw !== "object")
+    return null;
+  const issue = raw;
+  const number = issue.number;
+  const title = issue.title;
+  if (typeof number !== "number" || !Number.isInteger(number) || number <= 0 || typeof title !== "string" || !title.trim()) {
+    return null;
+  }
+  const url = singleLineGithubOption(issue.url);
+  const state = typeof issue.state === "string" && issue.state.trim() ? issue.state.trim().toLowerCase() : "open";
+  return {
+    number,
+    title: title.trim().slice(0, 200),
+    state,
+    ...url ? { url } : {},
+    labels: extractGithubIssueLabels(issue.labels)
+  };
+}
+function parseGithubIssueListOutput(stdout) {
+  const parsed = JSON.parse(stdout);
+  if (!Array.isArray(parsed))
+    return [];
+  return parsed.map(normalizeGithubIssueListItem).filter((issue) => issue !== null);
+}
+function parseGithubIssueViewOutput(stdout) {
+  const issue = normalizeGithubIssueListItem(JSON.parse(stdout));
+  if (!issue)
+    throw new GithubIssueListError("failed to parse gh issue output");
+  return issue;
+}
+function buildGithubIssueListArgs(options) {
+  const search = singleLineGithubOption(options.search);
+  const args = [
+    commandForExternal("gh"),
+    "issue",
+    "list",
+    "--json",
+    "number,title,state,labels,url",
+    "--limit",
+    String(normalizeGithubIssueListLimit(options.limit)),
+    "--state",
+    search && githubSearchHasStateQualifier(search) ? "all" : normalizeGithubIssueListState(options.state)
+  ];
+  const repo = singleLineGithubOption(options.repo);
+  if (repo)
+    args.push("--repo", repo);
+  if (search)
+    args.push("--search", search);
+  const seenLabels = new Set;
+  for (const rawLabel of options.labels || []) {
+    const label = singleLineGithubOption(rawLabel);
+    if (!label || seenLabels.has(label))
+      continue;
+    seenLabels.add(label);
+    args.push("--label", label);
+    if (seenLabels.size >= GITHUB_ISSUE_LABEL_FILTER_LIMIT)
+      break;
+  }
+  return args;
+}
+function buildGithubIssueViewArgs(options) {
+  const args = [
+    commandForExternal("gh"),
+    "issue",
+    "view",
+    String(options.number),
+    "--json",
+    "number,title,state,labels,url"
+  ];
+  const repo = singleLineGithubOption(options.repo);
+  if (repo)
+    args.push("--repo", repo);
+  return args;
+}
+function readGithubIssueList(options) {
+  const proc = runSync(buildGithubIssueListArgs(options), options.cwd, {
+    timeout: 30000
+  });
+  if (proc.code !== 0) {
+    const detail = isCommandNotFoundResult("gh", proc) ? commandNotFoundDetail("gh") : proc.stderr.trim() || `gh issue list exited with code ${proc.code}`;
+    throw new GithubIssueListError(detail);
+  }
+  try {
+    return parseGithubIssueListOutput(proc.stdout);
+  } catch {
+    throw new GithubIssueListError("failed to parse gh issue list output");
+  }
+}
+function readGithubIssue(options) {
+  const proc = runSync(buildGithubIssueViewArgs(options), options.cwd, {
+    timeout: 30000
+  });
+  if (proc.code !== 0) {
+    const detail = isCommandNotFoundResult("gh", proc) ? commandNotFoundDetail("gh") : proc.stderr.trim() || `gh issue view exited with code ${proc.code}`;
+    throw new GithubIssueListError(detail);
+  }
+  try {
+    return parseGithubIssueViewOutput(proc.stdout);
+  } catch (error) {
+    if (error instanceof GithubIssueListError)
+      throw error;
+    throw new GithubIssueListError("failed to parse gh issue output");
+  }
+}
+var GITHUB_ISSUE_LABEL_FILTER_LIMIT = 24, GithubIssueListError;
+var init_github_issues = __esm(() => {
+  init_command_resolver();
+  init_runtime();
+  GithubIssueListError = class GithubIssueListError extends Error {
+    status;
+    constructor(message, status = 502) {
+      super(message);
+      this.status = status;
+    }
+  };
+});
+
+// web-src/server/journal-cli.ts
+var exports_journal_cli = {};
+__export(exports_journal_cli, {
+  runJournalCli: () => runJournalCli,
+  parseJournalArgs: () => parseJournalArgs,
+  JOURNAL_HELP: () => JOURNAL_HELP,
+  JOURNAL_AGENT_HELP: () => JOURNAL_AGENT_HELP
+});
+import { readFileSync as readFileSync5 } from "node:fs";
+function parsePositiveInteger(value, flag) {
+  if (value === undefined)
+    return;
+  const n = Number(value);
+  if (!Number.isInteger(n) || n < 1)
+    throw new Error(`${flag} must be a positive integer`);
+  return n;
+}
+function parseDateValue(value, flag) {
+  if (value === undefined)
+    return;
+  if (value === "today")
+    return todayIsoDate();
+  if (value === "none")
+    return "";
+  if (!isIsoDate(value))
+    throw new Error(`${flag} must be YYYY-MM-DD or today`);
+  return value;
+}
+function parseStatus(value) {
+  if (value === undefined)
+    return;
+  if (isJournalTaskStatus(value))
+    return value;
+  throw new Error("--status must be draft, todo, doing, blocked, or done");
+}
+function parsePriority(value) {
+  if (value === undefined)
+    return;
+  if (isJournalTaskPriority(value))
+    return value;
+  throw new Error("--priority must be p0, p1, p2, or p3");
+}
+function parseGithubIssueState(value) {
+  if (value === undefined)
+    return "open";
+  if (value === "open" || value === "closed" || value === "all")
+    return value;
+  throw new Error("--state must be open, closed, or all");
+}
+function parseGithubOption(value, flag) {
+  if (value === undefined)
+    return;
+  const normalized = singleLineGithubOption(value);
+  if (!normalized)
+    throw new Error(`${flag} must be a non-empty single line`);
+  return normalized;
+}
+function parseJournalArgs(argv) {
+  const rest = [];
+  let cwd;
+  let server;
+  const options = new Map;
+  const multiOptions = new Map;
+  const flags = new Set;
+  const commandOverrides = [];
+  const valueFlags = new Set([
+    "--date",
+    "--title",
+    "--body",
+    "--body-file",
+    "--note",
+    "--note-file",
+    "--label",
+    "--status",
+    "--priority",
+    "--due",
+    "--source-date",
+    "--before",
+    "--after",
+    "--position",
+    "--by",
+    "--lease-minutes",
+    "--wip-limit",
+    "--limit",
+    "--repo",
+    "--gh-label",
+    "--search",
+    "--state"
+  ]);
+  try {
+    for (let i = 0;i < argv.length; i++) {
+      const arg = argv[i];
+      if (arg === "--help" || arg === "-h")
+        return { ok: true, args: { command: { kind: "help" }, dryRun: false } };
+      if (arg === "--cwd" || arg === "--server") {
+        const taken = takeValue(argv, i, arg);
+        if ("error" in taken)
+          return { ok: false, error: taken.error };
+        if (arg === "--cwd")
+          cwd = taken.value;
+        else
+          server = taken.value;
+        i = taken.next;
+      } else if (arg === "--bin") {
+        const taken = takeValue(argv, i, arg);
+        if ("error" in taken)
+          return { ok: false, error: taken.error };
+        const parsed = parseExternalCommandOverride(taken.value, "--bin", [
+          "gh"
+        ]);
+        if (parsed.ok === false)
+          return { ok: false, error: parsed.error };
+        commandOverrides.push(parsed.override);
+        i = taken.next;
+      } else if (valueFlags.has(arg)) {
+        const taken = takeValue(argv, i, arg);
+        if ("error" in taken)
+          return { ok: false, error: taken.error };
+        options.set(arg, taken.value);
+        const values = multiOptions.get(arg) || [];
+        values.push(taken.value);
+        multiOptions.set(arg, values);
+        i = taken.next;
+      } else if (arg === "--json" || arg === "--dry-run" || arg === "--clear-labels") {
+        flags.add(arg);
+      } else if (arg.startsWith("-")) {
+        return { ok: false, error: `unknown option: ${arg}` };
+      } else {
+        rest.push(arg);
+      }
+    }
+    const labels = multiOptions.get("--label") || [];
+    const subcommand = rest[0];
+    const dryRun = flags.has("--dry-run");
+    if (!subcommand)
+      return { ok: true, args: { command: { kind: "help" }, dryRun } };
+    if (subcommand === "agent-help")
+      return { ok: true, args: { command: { kind: "agent-help" }, dryRun } };
+    if (commandOverrides.length > 0 && subcommand !== "github-issues" && subcommand !== "task-link-issue") {
+      return {
+        ok: false,
+        error: "--bin is only supported with github-issues or task-link-issue"
+      };
+    }
+    if (subcommand === "list") {
+      return {
+        ok: true,
+        args: {
+          command: {
+            kind: "list",
+            date: parseDateValue(options.get("--date"), "--date"),
+            limit: parsePositiveInteger(options.get("--limit"), "--limit"),
+            json: flags.has("--json")
+          },
+          cwd,
+          server,
+          dryRun
+        }
+      };
+    }
+    if (subcommand === "add") {
+      const date = parseDateValue(options.get("--date"), "--date");
+      if (!date)
+        return { ok: false, error: "add requires --date <YYYY-MM-DD|today>" };
+      return {
+        ok: true,
+        args: {
+          command: {
+            kind: "add",
+            date,
+            title: options.get("--title"),
+            labels,
+            body: options.get("--body"),
+            bodyFile: options.get("--body-file")
+          },
+          cwd,
+          server,
+          dryRun
+        }
+      };
+    }
+    if (subcommand === "edit") {
+      const id = rest[1];
+      if (!id)
+        return { ok: false, error: "edit requires a journal entry id" };
+      return {
+        ok: true,
+        args: {
+          command: {
+            kind: "edit",
+            id,
+            date: parseDateValue(options.get("--date"), "--date"),
+            title: options.get("--title"),
+            labels: multiOptions.has("--label") ? labels : undefined,
+            body: options.get("--body"),
+            bodyFile: options.get("--body-file")
+          },
+          cwd,
+          server,
+          dryRun
+        }
+      };
+    }
+    if (subcommand === "tasks") {
+      return {
+        ok: true,
+        args: {
+          command: {
+            kind: "tasks",
+            status: parseStatus(options.get("--status")),
+            labels,
+            json: flags.has("--json")
+          },
+          cwd,
+          server,
+          dryRun
+        }
+      };
+    }
+    if (subcommand === "task-add") {
+      const title = options.get("--title");
+      if (!title)
+        return { ok: false, error: "task-add requires --title <text>" };
+      return {
+        ok: true,
+        args: {
+          command: {
+            kind: "task-add",
+            title,
+            status: parseStatus(options.get("--status")),
+            priority: parsePriority(options.get("--priority")),
+            labels,
+            dueDate: parseDateValue(options.get("--due"), "--due"),
+            sourceDate: parseDateValue(options.get("--source-date"), "--source-date"),
+            before: options.get("--before"),
+            after: options.get("--after"),
+            position: parsePositiveInteger(options.get("--position"), "--position"),
+            body: options.get("--body"),
+            bodyFile: options.get("--body-file")
+          },
+          cwd,
+          server,
+          dryRun
+        }
+      };
+    }
+    if (subcommand === "task-update") {
+      const id = rest[1];
+      if (!id)
+        return { ok: false, error: "task-update requires a task id" };
+      return {
+        ok: true,
+        args: {
+          command: {
+            kind: "task-update",
+            id,
+            title: options.get("--title"),
+            status: parseStatus(options.get("--status")),
+            priority: parsePriority(options.get("--priority")),
+            labels: multiOptions.has("--label") ? labels : undefined,
+            clearLabels: flags.has("--clear-labels"),
+            dueDate: parseDateValue(options.get("--due"), "--due") ?? undefined,
+            sourceDate: parseDateValue(options.get("--source-date"), "--source-date") ?? undefined,
+            body: options.get("--body"),
+            bodyFile: options.get("--body-file")
+          },
+          cwd,
+          server,
+          dryRun
+        }
+      };
+    }
+    if (subcommand === "task-next") {
+      return {
+        ok: true,
+        args: {
+          command: {
+            kind: "task-next",
+            status: parseStatus(options.get("--status")),
+            labels,
+            limit: parsePositiveInteger(options.get("--limit"), "--limit") || 1,
+            json: flags.has("--json")
+          },
+          cwd,
+          server,
+          dryRun
+        }
+      };
+    }
+    if (subcommand === "github-issues") {
+      if (multiOptions.has("--label")) {
+        return {
+          ok: false,
+          error: "github-issues uses --gh-label, not --label"
+        };
+      }
+      return {
+        ok: true,
+        args: {
+          command: {
+            kind: "github-issues",
+            repo: parseGithubOption(options.get("--repo"), "--repo"),
+            ghState: parseGithubIssueState(options.get("--state")),
+            ghLabels: (multiOptions.get("--gh-label") || []).map((label) => parseGithubOption(label, "--gh-label")),
+            search: parseGithubOption(options.get("--search"), "--search"),
+            limit: parsePositiveInteger(options.get("--limit"), "--limit") || 30,
+            json: flags.has("--json")
+          },
+          cwd,
+          server,
+          commandOverrides,
+          dryRun
+        }
+      };
+    }
+    if (subcommand === "task-link-issue") {
+      if (multiOptions.has("--gh-label")) {
+        return {
+          ok: false,
+          error: "task-link-issue uses --label for local labels"
+        };
+      }
+      const issueNumber = parsePositiveInteger(rest[1], "issue number");
+      if (!issueNumber) {
+        return {
+          ok: false,
+          error: "task-link-issue requires <number>"
+        };
+      }
+      return {
+        ok: true,
+        args: {
+          command: {
+            kind: "task-link-issue",
+            issueNumber,
+            repo: parseGithubOption(options.get("--repo"), "--repo"),
+            status: parseStatus(options.get("--status")),
+            priority: parsePriority(options.get("--priority")),
+            labels,
+            before: options.get("--before"),
+            after: options.get("--after"),
+            position: parsePositiveInteger(options.get("--position"), "--position"),
+            json: flags.has("--json")
+          },
+          cwd,
+          server,
+          commandOverrides,
+          dryRun
+        }
+      };
+    }
+    if (subcommand === "task-claim") {
+      const id = rest[1];
+      if (!id)
+        return { ok: false, error: "task-claim requires a task id" };
+      return {
+        ok: true,
+        args: {
+          command: {
+            kind: "task-claim",
+            id,
+            by: options.get("--by"),
+            leaseMinutes: parsePositiveInteger(options.get("--lease-minutes"), "--lease-minutes"),
+            wipLimit: parsePositiveInteger(options.get("--wip-limit"), "--wip-limit")
+          },
+          cwd,
+          server,
+          dryRun
+        }
+      };
+    }
+    if (subcommand === "task-done") {
+      const id = rest[1];
+      if (!id)
+        return { ok: false, error: "task-done requires a task id" };
+      if (!options.get("--by"))
+        return { ok: false, error: "task-done requires --by <agent>" };
+      return {
+        ok: true,
+        args: {
+          command: {
+            kind: "task-done",
+            id,
+            by: options.get("--by"),
+            note: options.get("--note"),
+            noteFile: options.get("--note-file")
+          },
+          cwd,
+          server,
+          dryRun
+        }
+      };
+    }
+    if (subcommand === "task-delete") {
+      const id = rest[1];
+      if (!id)
+        return { ok: false, error: "task-delete requires a task id" };
+      return {
+        ok: true,
+        args: { command: { kind: "task-delete", id }, cwd, server, dryRun }
+      };
+    }
+    return { ok: false, error: `unknown journal command: ${subcommand}` };
+  } catch (error) {
+    return {
+      ok: false,
+      error: error instanceof Error ? error.message : "invalid journal arguments"
+    };
+  }
+}
+async function textFromBody(command, required) {
+  if (command.body !== undefined && command.bodyFile !== undefined) {
+    console.error("use either --body or --body-file");
+    process.exit(1);
+  }
+  if (command.body !== undefined)
+    return command.body;
+  if (command.bodyFile !== undefined) {
+    try {
+      return readFileSync5(command.bodyFile, "utf8");
+    } catch {
+      console.error(`could not read --body-file: ${command.bodyFile}`);
+      process.exit(1);
+    }
+  }
+  const stdin = await readStdin();
+  if (stdin.trim())
+    return stdin;
+  if (required) {
+    console.error("body is empty. Pass --body, --body-file, or pipe stdin.");
+    process.exit(1);
+  }
+  return;
+}
+function textFromNote(command) {
+  if (command.note !== undefined && command.noteFile !== undefined) {
+    console.error("use either --note or --note-file");
+    process.exit(1);
+  }
+  if (command.note !== undefined)
+    return command.note;
+  if (command.noteFile !== undefined) {
+    try {
+      return readFileSync5(command.noteFile, "utf8");
+    } catch {
+      console.error(`could not read --note-file: ${command.noteFile}`);
+      process.exit(1);
+    }
+  }
+  return;
+}
+async function journalRequest(serverUrl, method, action, body) {
+  return requestJson(serverUrl, "/_journal", method, body, action);
+}
+function selectEntries(data, date, limit) {
+  const entries = date ? data.journal.entries.filter((entry) => entry.date === date) : data.journal.entries;
+  if (limit === undefined)
+    return entries;
+  return [...entries].sort((a, b) => b.date.localeCompare(a.date) || b.updated_at.localeCompare(a.updated_at) || b.created_at.localeCompare(a.created_at)).slice(0, limit);
+}
+function printEntries(data, date, limit) {
+  const entries = selectEntries(data, date, limit);
+  if (!entries.length) {
+    console.log("no journal entries");
+    return;
+  }
+  for (const entry of entries) {
+    const labels = entry.labels.length ? ` #${entry.labels.join(" #")}` : "";
+    const title = entry.title ? ` ${entry.title}` : "";
+    console.log(`${entry.date} [${entry.id}]${title}${labels}`);
+    console.log(`  ${entry.body.split(`
+`)[0].slice(0, 120)}`);
+  }
+}
+function printTasks(tasks) {
+  if (!tasks.length) {
+    console.log("no tasks");
+    return;
+  }
+  for (const task of tasks) {
+    const labels = task.labels.length ? ` #${task.labels.join(" #")}` : "";
+    console.log(`[${task.id}] ${task.status} ${task.priority} ${task.title}${labels}`);
+  }
+}
+function printGithubIssues(issues) {
+  if (!issues.length) {
+    console.log("no GitHub issues");
+    return;
+  }
+  for (const issue of issues) {
+    const labels = issue.labels.length ? ` #${issue.labels.join(" #")}` : "";
+    const url = issue.url ? ` ${issue.url}` : "";
+    console.log(`#${issue.number} ${issue.state} ${issue.title}${labels}${url}`);
+  }
+}
+function taskLinkIssuePayload(command, issue) {
+  return {
+    action: "link-github-issue",
+    issue_number: issue.number,
+    repo: command.repo,
+    title: issue.title,
+    url: issue.url,
+    memo_label: "Memo:",
+    status: command.status,
+    priority: command.priority,
+    labels: command.labels,
+    before_id: command.before,
+    after_id: command.after,
+    position: command.position
+  };
+}
+function writePayload(payload) {
+  console.log(JSON.stringify(payload, null, 2));
+}
+async function getJournalData(serverUrl) {
+  return await journalRequest(serverUrl, "GET", "journal list");
+}
+async function runJournalCli(argv) {
+  const parsed = parseJournalArgs(argv);
+  if (parsed.ok === false) {
+    console.error(parsed.error);
+    console.error('Run "code-viewer journal --help" for usage.');
+    process.exit(1);
+  }
+  const { command, cwd, server, commandOverrides = [], dryRun } = parsed.args;
+  if (command.kind === "help") {
+    console.log(JOURNAL_HELP);
+    return;
+  }
+  if (command.kind === "agent-help") {
+    console.log(JOURNAL_AGENT_HELP);
+    return;
+  }
+  const dryRunPayload = async (action, body) => {
+    if (!dryRun)
+      return false;
+    writePayload({ action, ...body });
+    return true;
+  };
+  if (dryRun) {
+    if (command.kind === "add") {
+      writePayload({
+        action: "add-entry",
+        date: command.date,
+        title: command.title,
+        labels: command.labels,
+        body: await textFromBody(command, true)
+      });
+      return;
+    }
+    if (command.kind === "edit") {
+      writePayload({
+        action: "update-entry",
+        id: command.id,
+        date: command.date,
+        title: command.title,
+        labels: command.labels,
+        body: await textFromBody(command, false)
+      });
+      return;
+    }
+    if (command.kind === "task-add") {
+      writePayload({
+        action: "add-task",
+        title: command.title,
+        status: command.status,
+        priority: command.priority,
+        labels: command.labels,
+        due_date: command.dueDate === "" ? null : command.dueDate,
+        source_date: command.sourceDate === "" ? null : command.sourceDate,
+        before_id: command.before,
+        after_id: command.after,
+        position: command.position,
+        body: await textFromBody(command, false)
+      });
+      return;
+    }
+    if (command.kind === "task-update") {
+      writePayload({
+        action: "update-task",
+        id: command.id,
+        title: command.title,
+        status: command.status,
+        priority: command.priority,
+        labels: command.clearLabels ? [] : command.labels,
+        due_date: command.dueDate === "" ? null : command.dueDate,
+        source_date: command.sourceDate === "" ? null : command.sourceDate,
+        body: await textFromBody(command, false)
+      });
+      return;
+    }
+    if (command.kind === "task-claim") {
+      writePayload({
+        action: "claim-task",
+        id: command.id,
+        by: command.by,
+        lease_minutes: command.leaseMinutes,
+        wip_limit: command.wipLimit
+      });
+      return;
+    }
+    if (command.kind === "task-done") {
+      writePayload({
+        action: "complete-task",
+        id: command.id,
+        by: command.by,
+        note: textFromNote(command)
+      });
+      return;
+    }
+    if (command.kind === "task-delete") {
+      writePayload({ action: "delete-task", id: command.id });
+      return;
+    }
+  }
+  const root = resolveRepoRoot(cwd);
+  if (command.kind === "github-issues") {
+    const commandConfig = configureExternalCommands({
+      cwd: root,
+      cliOverrides: commandOverrides,
+      allowedNames: ["gh"]
+    });
+    if (commandConfig.ok === false) {
+      console.error(commandConfig.error);
+      process.exit(1);
+    }
+    const issues = readGithubIssueList({
+      cwd: root,
+      repo: command.repo,
+      labels: command.ghLabels,
+      search: command.search,
+      state: command.ghState,
+      limit: command.limit
+    });
+    if (command.json)
+      console.log(JSON.stringify({ issues }, null, 2));
+    else
+      printGithubIssues(issues);
+    return;
+  }
+  if (command.kind === "task-link-issue") {
+    const commandConfig = configureExternalCommands({
+      cwd: root,
+      cliOverrides: commandOverrides,
+      allowedNames: ["gh"]
+    });
+    if (commandConfig.ok === false) {
+      console.error(commandConfig.error);
+      process.exit(1);
+    }
+    const issue = readGithubIssue({
+      cwd: root,
+      number: command.issueNumber,
+      repo: command.repo
+    });
+    if (dryRun) {
+      writePayload(taskLinkIssuePayload(command, issue));
+      return;
+    }
+    const serverUrl2 = await ensureServerUrl(root, server, "/_journal");
+    const result2 = await journalRequest(serverUrl2, "POST", "journal task-link-issue", taskLinkIssuePayload(command, issue));
+    if (command.json)
+      console.log(JSON.stringify({
+        issue,
+        task: result2.task,
+        action: result2.created ? "created" : result2.moved ? "moved" : "existing"
+      }, null, 2));
+    else if (result2.created)
+      console.log(`linked issue #${issue.number} to task ${result2.task.id}`);
+    else if (result2.moved)
+      console.log(`moved linked issue #${issue.number} task ${result2.task.id}`);
+    else
+      console.log(`issue #${issue.number} is linked to task ${result2.task.id}`);
+    return;
+  }
+  const serverUrl = await ensureServerUrl(root, server, "/_journal");
+  if (command.kind === "list") {
+    const data = await getJournalData(serverUrl);
+    const entries = selectEntries(data, command.date, command.limit);
+    if (command.json)
+      console.log(JSON.stringify({ version: data.journal.version, entries }, null, 2));
+    else
+      printEntries(data, command.date, command.limit);
+    return;
+  }
+  if (command.kind === "add") {
+    const body = await textFromBody(command, true);
+    const result2 = await journalRequest(serverUrl, "POST", "journal add", {
+      action: "add-entry",
+      date: command.date,
+      title: command.title,
+      labels: command.labels,
+      body
+    });
+    console.log(`added journal entry ${result2.entry.id} for ${result2.entry.date}`);
+    return;
+  }
+  if (command.kind === "edit") {
+    const body = await textFromBody(command, false);
+    const payload2 = {
+      action: "update-entry",
+      id: command.id,
+      date: command.date,
+      title: command.title,
+      labels: command.labels,
+      body
+    };
+    if (await dryRunPayload("update-entry", payload2))
+      return;
+    await journalRequest(serverUrl, "POST", "journal edit", payload2);
+    console.log(`updated journal entry ${command.id}`);
+    return;
+  }
+  if (command.kind === "tasks") {
+    const data = await getJournalData(serverUrl);
+    const tasks = filterJournalTasks(data.tasks, {
+      status: command.status,
+      labels: command.labels,
+      includeClaimed: true
+    });
+    if (command.json)
+      console.log(JSON.stringify({ version: 1, tasks }, null, 2));
+    else
+      printTasks(tasks);
+    return;
+  }
+  if (command.kind === "task-add") {
+    const body = await textFromBody(command, false);
+    const payload2 = {
+      action: "add-task",
+      title: command.title,
+      status: command.status,
+      priority: command.priority,
+      labels: command.labels,
+      due_date: command.dueDate === "" ? null : command.dueDate,
+      source_date: command.sourceDate === "" ? null : command.sourceDate,
+      before_id: command.before,
+      after_id: command.after,
+      position: command.position,
+      body
+    };
+    if (await dryRunPayload("add-task", payload2))
+      return;
+    const result2 = await journalRequest(serverUrl, "POST", "journal task-add", payload2);
+    console.log(`added task ${result2.task.id} ${result2.task.title}`);
+    return;
+  }
+  if (command.kind === "task-update") {
+    const body = await textFromBody(command, false);
+    const payload2 = {
+      action: "update-task",
+      id: command.id,
+      title: command.title,
+      status: command.status,
+      priority: command.priority,
+      labels: command.clearLabels ? [] : command.labels,
+      due_date: command.dueDate === "" ? null : command.dueDate,
+      source_date: command.sourceDate === "" ? null : command.sourceDate,
+      body
+    };
+    if (await dryRunPayload("update-task", payload2))
+      return;
+    await journalRequest(serverUrl, "POST", "journal task-update", payload2);
+    console.log(`updated task ${command.id}`);
+    return;
+  }
+  if (command.kind === "task-next") {
+    const data = await getJournalData(serverUrl);
+    const tasks = selectNextJournalTasks(data.tasks, {
+      status: command.status || "todo",
+      labels: command.labels
+    }, command.limit);
+    if (command.json)
+      console.log(JSON.stringify({ tasks }, null, 2));
+    else
+      printTasks(tasks);
+    return;
+  }
+  if (command.kind === "task-claim") {
+    const payload2 = {
+      action: "claim-task",
+      id: command.id,
+      by: command.by,
+      lease_minutes: command.leaseMinutes,
+      wip_limit: command.wipLimit
+    };
+    if (await dryRunPayload("claim-task", payload2))
+      return;
+    const result2 = await journalRequest(serverUrl, "POST", "journal task-claim", payload2);
+    console.log(`claimed task ${result2.task.id} until ${result2.task.claim?.lease_expires_at}`);
+    return;
+  }
+  if (command.kind === "task-done") {
+    const payload2 = {
+      action: "complete-task",
+      id: command.id,
+      by: command.by,
+      note: textFromNote(command)
+    };
+    if (await dryRunPayload("complete-task", payload2))
+      return;
+    await journalRequest(serverUrl, "POST", "journal task-done", payload2);
+    console.log(`completed task ${command.id}`);
+    return;
+  }
+  const payload = { action: "delete-task", id: command.id };
+  if (await dryRunPayload("delete-task", payload))
+    return;
+  const result = await journalRequest(serverUrl, "POST", "journal task-delete", payload);
+  if (!result.removed) {
+    console.error(`task not found: ${command.id}`);
+    process.exit(1);
+  }
+  console.log(`deleted task ${command.id}`);
+}
+var JOURNAL_HELP = `code-viewer journal — daily work journal and task queue
+
+The journal is stored in <repo>/.code-viewer/daily-journal.json and tasks are
+stored in <repo>/.code-viewer/tasks.json. A running code-viewer server for the
+repository is required unless you pass --dry-run for a write command.
+The github-issues command is read-only and runs gh directly without a server.
 
-  code-viewer file blame --path src/sample.ts --json
-  code-viewer file blame --path src/sample.ts --base HEAD --json
-  code-viewer file history --path src/sample.ts --limit 10 --json
-  code-viewer file history --path src/sample.ts --query "author:tester" --json
-  code-viewer file show --path src/sample.ts --json
-  code-viewer file show --path src/sample.ts --start 100 --end 150 --json
-  code-viewer file show --path src/sample.ts --ref main --json
-  code-viewer file diff --path src/sample.ts --json
-  code-viewer file diff --path src/sample.ts --from main --to HEAD --json
-  code-viewer file diff --path src/sample.ts --full --json
-  code-viewer file diff --path new_sample.ts --untracked --json
-  code-viewer file diff --path renamed.ts --old-path original.ts --from HEAD~1 --to HEAD --json
+Run "code-viewer journal agent-help" for an AI-agent oriented guide.
 
-## Output contract
+Usage:
+  code-viewer journal list [--date <YYYY-MM-DD|today>] [--limit <n>] [--json]
+  code-viewer journal add --date <YYYY-MM-DD|today> [--title <text>]
+      [--label <label>...] [--body <markdown> | --body-file <path>]
+  code-viewer journal edit <id> [--date <YYYY-MM-DD|today>] [--title <text>]
+      [--label <label>...] [--body <markdown> | --body-file <path>]
+  code-viewer journal tasks [--status <draft|todo|doing|blocked|done>]
+      [--label <label>...] [--json]
+  code-viewer journal task-add --title <text>
+      [--status <status>] [--priority <p0|p1|p2|p3>] [--label <label>...]
+      [--due <YYYY-MM-DD|none>] [--source-date <YYYY-MM-DD|today|none>]
+      [--before <id> | --after <id> | --position <n>]
+      [--body <markdown> | --body-file <path>]
+  code-viewer journal task-update <id> [--title <text>] [--status <status>]
+      [--priority <p0|p1|p2|p3>] [--label <label>...] [--clear-labels]
+      [--due <YYYY-MM-DD|none>] [--source-date <YYYY-MM-DD|today|none>]
+      [--body <markdown> | --body-file <path>]
+  code-viewer journal task-next [--label <label>...] [--status <status>]
+      [--limit <n>] [--json]
+  code-viewer journal github-issues [--repo <owner/repo>]
+      [--state <open|closed|all>] [--gh-label <label>...]
+      [--search <query>] [--limit <n>] [--json] [--bin gh=<path>]
+  code-viewer journal task-link-issue <number> [--repo <owner/repo>]
+      [--status <status>] [--priority <p0|p1|p2|p3>] [--label <label>...]
+      [--before <id> | --after <id> | --position <n>] [--json]
+      [--dry-run] [--bin gh=<path>]
+  code-viewer journal task-claim <id> [--by <agent>] [--lease-minutes <n>]
+      [--wip-limit <n>]
+  code-viewer journal task-done <id> --by <agent>
+      [--note <markdown> | --note-file <path>]
+  code-viewer journal task-delete <id>
 
---json shapes (mirroring git.ts DTOs verbatim where possible):
+Global options:
+  --cwd <dir>      repository root (default: current directory)
+  --server <url>   code-viewer server URL (default: auto-discovered)
+  --bin gh=<p>     override gh executable path for github-issues
+  --dry-run        print the write payload without sending it
+`, JOURNAL_AGENT_HELP = `code-viewer journal — agent guide
 
-  blame:
-    {
-      "path": string,
-      "ref": string,         // the literal ref the CLI resolved to
-      "base": "worktree"|"HEAD",
-      "result": GitBlameResult   // { lines, commits, isUntracked?, isSynthetic?, error? }
-    }
-  history:
-    {
-      "path": string,
-      "ref": string,
-      "limit": number,
-      "skip": number,
-      "query"?: string,
-      "result": { commits: GitHistoryCommit[], hasMore: boolean, error?: string }
-    }
-  show:
-    {
-      "path": string,
-      "ref": string,
-      "start"?: number,
-      "end"?: number,
-      "totalLines": number,    // total lines in the file at <ref>
-      "complete": boolean,     // true when the returned text covers the whole file
-      "text": string
-    }
-  diff:
-    {
-      "path": string,
-      "old_path"?: string,
-      "from": string,                  // "/dev/null" when untracked is true
-      "to": string,
-      "untracked": boolean,
-      "ignore_ws": boolean,
-      "ignore_blank": boolean,
-      "mode": "preview"|"full",
-      "max_hunks": number|null,        // null in full mode
-      "max_lines": number|null,        // null in full mode
-      "diff": string,                  // unified diff text
-      "hunk_count": number,            // total hunks before truncation
-      "rendered_hunk_count": number,   // hunks actually included in diff
-      "line_count": number,            // total newlines in the returned diff
-      "truncated": boolean,            // true when preview dropped hunks/lines
-      "binary": boolean,               // git emitted "Binary files ..."
-      "error"?: string                 // git stderr (also exits 1)
-    }
+You are an AI coding agent. Use this tool to write daily work notes and process
+explicit task queues without guessing from memory.
 
-Default (non --json) output:
+## Workflow
 
-  blame:    one line per source line  →  <line><TAB><shortSha or "worktree"><TAB><summary>
-            uncommitted edits show as "worktree" and "<uncommitted>".
-  history:  one line per commit       →  <shortSha><TAB><whenISO><TAB><author><TAB><subject>
-            0 commits prints "no history" to stderr, exit 0.
-  show:     the file (or sliced lines) as text. 0-byte files succeed (exit 0).
-  diff:     unified diff text (the same bytes the JSON "diff" field carries).
-            Empty (or worktree==worktree) returns nothing on stdout, exit 0.
+1. Check the queue before doing label-scoped work:
+     code-viewer journal task-next --label ai-ready --limit 5 --json
+2. Claim exactly one task before editing code:
+     code-viewer journal task-claim <task-id> --by agent --wip-limit 1
+3. When finished, mark it done with a short note:
+     code-viewer journal task-done <task-id> --by agent --note "Implemented and verified."
+4. Add a daily journal entry for work that is not already represented by a task:
+     code-viewer journal add --date today --label ai --body "..."
+5. Inspect GitHub issues read-only before deciding what local task to create:
+     code-viewer journal github-issues --repo owner/repo --json
+6. Link a GitHub issue to the local board without updating GitHub:
+     code-viewer journal task-link-issue 123 --repo owner/repo --status draft --label ai-ready
 
-## Tips
+## Rules
 
-- Prefer --json. blame DTO carries author / authorMail / authorTime per
-  commit; the plain-text format only shows summary.
-- For huge files, slice with --start/--end before piping to a model
-  context — "totalLines" / "complete" tell you what was dropped.
-- file show reads the worktree by default. Pass --ref HEAD / --ref <branch>
-  when you need a committed snapshot.
-- A non-fatal git failure (e.g. unknown ref, unsafe path) returns the
-  error string inside the JSON "result.error" / "error" field AND exits 1.
-- file diff defaults to preview mode (${FILE_DIFF_DEFAULT_MAX_HUNKS} hunks /
-  ${FILE_DIFF_DEFAULT_MAX_LINES} lines). Use --full only when you need every
-  hunk — preview matches the browser's initial paint and is almost always
-  enough context for an LLM. In full mode, max_hunks / max_lines are null in
-  JSON because no preview cap is applied. Worktree == Worktree range returns
-  "" instantly.
-- Use "code-viewer search code" to discover the path first, then drill
-  in with blame / history / show / diff.
+- Treat labels as filters, priority as importance, and card order as human order.
+- Do not process draft tasks unless the human asked for drafts.
+- Use task-next for ordering; do not sort the JSON yourself unless asked.
+- Use --dry-run before large generated entries.
+- GitHub issue listing is read-only. Create or update local tasks explicitly.
+- task-link-issue reads issue metadata only and stores a local task link plus
+  your local labels. It does not copy the issue body or update GitHub.
 `;
-  VALUE_FLAGS = new Set([
-    "--path",
-    "--ref",
-    "--base",
-    "--limit",
-    "--skip",
-    "--query",
-    "--start",
-    "--end",
-    "--from",
-    "--to",
-    "--old-path",
-    "--max-hunks",
-    "--max-lines"
-  ]);
-  BOOL_FLAGS = new Set([
-    "--json",
-    "--untracked",
-    "--ignore-ws",
-    "--ignore-blank",
-    "--full"
-  ]);
+var init_journal_cli = __esm(() => {
+  init_journal();
+  init_cli_helpers();
+  init_command_resolver();
+  init_github_issues();
 });
 
 // web-src/core/routes.ts
@@ -4214,6 +5385,19 @@ function buildRoute(route) {
       const qs = params.toString();
       return `/history${qs ? `?${qs}` : ""}`;
     }
+    case "journal": {
+      const params = new URLSearchParams;
+      if (route.tab && route.tab !== "journal")
+        params.set("tab", route.tab);
+      if (route.date)
+        params.set("date", route.date);
+      if (route.label)
+        params.set("label", route.label);
+      if (route.task)
+        params.set("task", route.task);
+      const qs = params.toString();
+      return `/journal${qs ? `?${qs}` : ""}`;
+    }
     case "database": {
       const params = new URLSearchParams;
       if (route.db)
@@ -4245,6 +5429,7 @@ var init_routes = __esm(() => {
     "/file",
     "/help",
     "/history",
+    "/journal",
     "/database",
     "/doctor"
   ];
@@ -7494,9 +8679,10 @@ missing bundled skills).
 ## What gets installed
 
 The bundled set covers code-viewer's own AI workflows (annotation
-walkthroughs, doctor introspection, query/snapshot inspection). After
-install, ask the AI to use \`code-viewer annotate\` and the related
-skills will guide it.
+walkthroughs, Work Log task queues, doctor introspection, and
+query/snapshot inspection). After install, ask the AI to use
+\`code-viewer annotate\`, \`code-viewer journal\`, or the related
+commands and the skills will guide it.
 `;
 var init_skill_cli = __esm(() => {
   init_root();
@@ -7954,6 +9140,7 @@ var AGENT_GUIDES;
 var init_agent_help = __esm(() => {
   init_annotate_cli();
   init_file_cli();
+  init_journal_cli();
   init_query_cli();
   init_search_cli();
   init_skill_cli();
@@ -7974,6 +9161,11 @@ var init_agent_help = __esm(() => {
       signature: firstLine(ANNOTATE_AGENT_HELP),
       rerun: "code-viewer annotate agent-help"
     },
+    {
+      name: "journal",
+      signature: firstLine(JOURNAL_AGENT_HELP),
+      rerun: "code-viewer journal agent-help"
+    },
     {
       name: "search",
       signature: firstLine(SEARCH_AGENT_HELP),
@@ -17135,7 +18327,7 @@ var init_handle = __esm(() => {
 });
 
 // web-src/server/doctor.ts
-import { accessSync as accessSync2, constants as constants2, readFileSync as readFileSync5, statSync as statSync5 } from "node:fs";
+import { accessSync as accessSync2, constants as constants2, readFileSync as readFileSync6, statSync as statSync5 } from "node:fs";
 import { dirname as dirname4, join as join14, relative as relative5 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function statusWorse(a, b) {
@@ -17232,7 +18424,7 @@ function findCodeViewerPackageJson() {
     for (let depth = 0;depth < 8; depth += 1) {
       const candidate = join14(cursor, "package.json");
       try {
-        const raw = readFileSync5(candidate, "utf8");
+        const raw = readFileSync6(candidate, "utf8");
         const pkg = JSON.parse(raw);
         if (pkg.name === "@youtyan/code-viewer") {
           return { version: pkg.version, path: candidate };
@@ -17439,6 +18631,36 @@ async function checkGit(cwd, signal) {
   }
   return { id: "git", title: "Git", rows };
 }
+async function checkGithubCli(signal) {
+  const versionRes = await runCached(versionCache, TTL.version, commandForExternal("gh"), ["--version"], TIMEOUT.version, signal);
+  if (!versionRes || versionRes.code !== 0) {
+    return {
+      id: "github",
+      title: "GitHub CLI",
+      rows: [
+        {
+          id: "github.gh",
+          title: "gh binary",
+          status: "warn",
+          detail: versionRes && isCommandNotFoundResult("gh", versionRes) ? commandNotFoundDetail("gh") : "gh --version failed",
+          hint: "GitHub issue listing and issue-to-task linking require gh. Install GitHub CLI or pass --bin gh=/absolute/path."
+        }
+      ]
+    };
+  }
+  return {
+    id: "github",
+    title: "GitHub CLI",
+    rows: [
+      {
+        id: "github.gh",
+        title: "gh binary",
+        status: "ok",
+        detail: firstLine2(versionRes.stdout)
+      }
+    ]
+  };
+}
 async function detectComposeBinary(signal) {
   const v2 = await runCached(versionCache, TTL.version, commandForExternal("docker"), ["compose", "version", "--short"], TIMEOUT.version, signal);
   if (v2 && v2.code === 0) {
@@ -18020,6 +19242,7 @@ async function buildDoctorReport(ctx) {
   const sqlite = await checkSqlite(ctx.cwd);
   const snapshot = checkSnapshotStore(ctx.cwd);
   const git = await checkGit(ctx.cwd, ctx.signal);
+  const github = await checkGithubCli(ctx.signal);
   const discovery = await checkDiscovery(ctx.cwd, ctx.scopeOmitDirNames, ctx.signal);
   const docker = await checkDocker(ctx.signal, discovery.dockerResult);
   const datastore = await checkDatastoreConnectivity(ctx.cwd, ctx.scopeOmitDirNames, ctx.signal);
@@ -18030,6 +19253,7 @@ async function buildDoctorReport(ctx) {
     sqlite,
     snapshot,
     git,
+    github,
     discovery.group,
     datastore,
     docker,
@@ -18139,7 +19363,8 @@ function parseDoctorCliArgs(argv) {
       }
       const parsed = parseExternalCommandOverride(next, "--bin", [
         "git",
-        "docker"
+        "docker",
+        "gh"
       ]);
       if (parsed.ok === false)
         return { kind: "error", message: parsed.error };
@@ -18225,7 +19450,7 @@ async function runDoctorCli(argv) {
   const commandConfig = configureExternalCommands({
     cwd,
     cliOverrides: commandOverrides,
-    allowedNames: ["git", "docker"]
+    allowedNames: ["git", "docker", "gh"]
   });
   if (commandConfig.ok === false) {
     process.stderr.write(`code-viewer doctor: ${commandConfig.error}
@@ -18251,13 +19476,13 @@ async function runDoctorCli(argv) {
 var DOCTOR_HELP = `code-viewer doctor — diagnose the current environment
 
 Usage:
-  code-viewer doctor [--cwd <path>] [--port <N>] [--json] [--bin <git|docker>=<path>]
+  code-viewer doctor [--cwd <path>] [--port <N>] [--json] [--bin <git|docker|gh>=<path>]
   code-viewer doctor agent-help
 
 Options:
   --cwd <path>   Working directory to inspect (default: process.cwd()).
   --port <N>     Listening port to mention in the report (default: 0 = no server).
-  --bin <n>=<p>  Override git/docker executable path. Repeatable.
+  --bin <n>=<p>  Override git/docker/gh executable path. Repeatable.
   --json         Print the full DoctorReport as JSON instead of a summary.
   --help, -h     Show this help.
 
@@ -18302,65 +19527,702 @@ import { join as join15 } from "node:path";
 function cacheFresh(cached, now = Date.now(), ttlMs = CACHE_TTL_MS) {
   return !!cached && now - cached.storedAt <= ttlMs;
 }
-function setTimedCacheEntry(cache, key, value, now = Date.now(), maxEntries = MAX_TIMED_CACHE_ENTRIES) {
-  cache.set(key, { ...value, storedAt: now });
-  while (cache.size > maxEntries) {
-    const oldest = cache.keys().next().value;
-    if (oldest === undefined)
+function setTimedCacheEntry(cache, key, value, now = Date.now(), maxEntries = MAX_TIMED_CACHE_ENTRIES) {
+  cache.set(key, { ...value, storedAt: now });
+  while (cache.size > maxEntries) {
+    const oldest = cache.keys().next().value;
+    if (oldest === undefined)
+      break;
+    cache.delete(oldest);
+  }
+}
+function worktreeFileSignature(path, cwd) {
+  try {
+    const stats = lstatSync3(join15(cwd, path));
+    const inode = "ino" in stats ? stats.ino : 0;
+    return `state:file|size:${stats.size}|mtime:${stats.mtimeMs}|ctime:${stats.ctimeMs}|ino:${inode}`;
+  } catch {
+    return "state:missing";
+  }
+}
+function fileDiffCacheKey(options) {
+  const worktreeTarget = options.range.from === "worktree" || !options.range.to || options.range.to === "worktree";
+  if (options.isUntracked && !worktreeTarget) {
+    throw new Error("untracked file diffs require a worktree range");
+  }
+  const signature = worktreeTarget ? `\x00${worktreeFileSignature(options.path, options.cwd)}` : "";
+  if (options.isUntracked) {
+    return `u\x00${options.path}${signature}\x00${options.extras.join("\x00")}`;
+  }
+  return `t\x00${options.path}\x00${options.oldPath || ""}${signature}\x00${[...options.extras, ...options.args].join("\x00")}`;
+}
+var CACHE_TTL_MS = 1500, MAX_TIMED_CACHE_ENTRIES = 200;
+var init_cache = () => {};
+
+// web-src/server/dev-assets.ts
+import { basename as basename2 } from "node:path";
+function startDevAssetReload(options) {
+  if (!options.enabled)
+    return false;
+  const watched = new Set(options.watchedFiles);
+  const setTimer = options.setTimeoutFn || setTimeout;
+  const clearTimer = options.clearTimeoutFn || clearTimeout;
+  const debounceMs = options.debounceMs ?? 150;
+  let timer = null;
+  options.watch(options.webRoot, { persistent: false }, (_event, filename) => {
+    if (!filename || !watched.has(basename2(filename.toString())))
+      return;
+    if (timer)
+      clearTimer(timer);
+    timer = setTimer(() => {
+      timer = null;
+      options.sendReload();
+    }, debounceMs);
+  });
+  return true;
+}
+var init_dev_assets = () => {};
+
+// web-src/server/journal.ts
+import { join as join16 } from "node:path";
+function dailyJournalFilePath(root) {
+  return join16(root, CODE_VIEWER_DIR, DAILY_JOURNAL_FILE_NAME);
+}
+function journalTasksFilePath(root) {
+  return join16(root, CODE_VIEWER_DIR, JOURNAL_TASKS_FILE_NAME);
+}
+function emptyDailyJournalState() {
+  return { version: 1, entries: [] };
+}
+function emptyJournalTaskState() {
+  return { version: 1, tasks: [] };
+}
+function makeJournalId(prefix) {
+  const random = Math.random().toString(36).slice(2, 8);
+  const time = Date.now().toString(36);
+  return `${prefix}-${time}${random}`;
+}
+function optionalString3(value, maxLen) {
+  if (typeof value !== "string")
+    return;
+  if (value.includes("\x00"))
+    return;
+  const trimmed = value.trim();
+  if (!trimmed)
+    return;
+  return trimmed.slice(0, maxLen);
+}
+function optionalBody(value, maxBytes) {
+  if (typeof value !== "string")
+    return;
+  if (value.includes("\x00"))
+    return;
+  if (Buffer.byteLength(value, "utf8") > maxBytes)
+    return;
+  return value;
+}
+function normalizeSource(value) {
+  return value === "ai" || value === "imported" ? value : "user";
+}
+function normalizeJournalEntry(raw) {
+  if (!raw || typeof raw !== "object")
+    return null;
+  const entry = raw;
+  const id = optionalString3(entry.id, 128);
+  const date = isIsoDate(entry.date) ? entry.date : undefined;
+  const body = optionalBody(entry.body, JOURNAL_ENTRY_BODY_MAX_BYTES);
+  if (!id || !date || body === undefined)
+    return null;
+  const title = optionalString3(entry.title, JOURNAL_TITLE_MAX_CHARS);
+  return {
+    id,
+    date,
+    ...title ? { title } : {},
+    body,
+    labels: normalizeJournalLabels(entry.labels),
+    source: normalizeSource(entry.source),
+    created_at: optionalString3(entry.created_at, 64) ?? new Date(0).toISOString(),
+    updated_at: optionalString3(entry.updated_at, 64) ?? new Date(0).toISOString()
+  };
+}
+function normalizeDailyJournalState(raw) {
+  if (!raw || typeof raw !== "object")
+    return emptyDailyJournalState();
+  const entriesRaw = raw.entries;
+  if (!Array.isArray(entriesRaw))
+    return emptyDailyJournalState();
+  const entries = [];
+  for (const rawEntry of entriesRaw) {
+    if (entries.length >= MAX_ENTRIES3)
+      break;
+    const entry = normalizeJournalEntry(rawEntry);
+    if (entry)
+      entries.push(entry);
+  }
+  entries.sort((a, b) => a.date.localeCompare(b.date));
+  return { version: 1, entries };
+}
+function normalizeTaskNote(raw) {
+  if (!raw || typeof raw !== "object")
+    return null;
+  const note = raw;
+  const id = optionalString3(note.id, 128);
+  const body = optionalBody(note.body, JOURNAL_TASK_NOTE_MAX_BYTES);
+  if (!id || body === undefined)
+    return null;
+  return {
+    id,
+    at: optionalString3(note.at, 64) ?? new Date(0).toISOString(),
+    body,
+    source: normalizeSource(note.source)
+  };
+}
+function normalizeTaskClaim(raw) {
+  if (!raw || typeof raw !== "object")
+    return;
+  const claim = raw;
+  const by = optionalString3(claim.by, 128);
+  const claimedAt = optionalString3(claim.claimed_at, 64);
+  const leaseExpiresAt = optionalString3(claim.lease_expires_at, 64);
+  if (!by || !claimedAt || !leaseExpiresAt)
+    return;
+  return {
+    by,
+    claimed_at: claimedAt,
+    lease_expires_at: leaseExpiresAt
+  };
+}
+function normalizeJournalTask(raw) {
+  if (!raw || typeof raw !== "object")
+    return null;
+  const task = raw;
+  const id = optionalString3(task.id, 128);
+  const title = optionalString3(task.title, JOURNAL_TITLE_MAX_CHARS);
+  if (!id || !title)
+    return null;
+  const status = isJournalTaskStatus(task.status) ? task.status : "todo";
+  const priority = isJournalTaskPriority(task.priority) ? task.priority : "p2";
+  const body = optionalBody(task.body, JOURNAL_TASK_BODY_MAX_BYTES) ?? "";
+  const dueDate = isIsoDate(task.due_date) ? task.due_date : undefined;
+  const sourceDate = isIsoDate(task.source_date) ? task.source_date : undefined;
+  const journalEntryId = optionalString3(task.journal_entry_id, 128);
+  const completedAt = optionalString3(task.completed_at, 64);
+  const notes = Array.isArray(task.notes) ? task.notes.slice(0, MAX_NOTES_PER_TASK).map(normalizeTaskNote).filter((note) => note !== null) : [];
+  const claim = normalizeTaskClaim(task.claim);
+  return {
+    id,
+    title,
+    body,
+    status,
+    priority,
+    labels: normalizeJournalLabels(task.labels),
+    created_at: optionalString3(task.created_at, 64) ?? new Date(0).toISOString(),
+    updated_at: optionalString3(task.updated_at, 64) ?? new Date(0).toISOString(),
+    ...dueDate ? { due_date: dueDate } : {},
+    ...sourceDate ? { source_date: sourceDate } : {},
+    ...journalEntryId ? { journal_entry_id: journalEntryId } : {},
+    ...completedAt ? { completed_at: completedAt } : {},
+    ...claim ? { claim } : {},
+    ...notes.length ? { notes } : {}
+  };
+}
+function normalizeJournalTaskState(raw) {
+  if (!raw || typeof raw !== "object")
+    return emptyJournalTaskState();
+  const tasksRaw = raw.tasks;
+  if (!Array.isArray(tasksRaw))
+    return emptyJournalTaskState();
+  const tasks = [];
+  for (const rawTask of tasksRaw) {
+    if (tasks.length >= MAX_TASKS)
       break;
-    cache.delete(oldest);
+    const task = normalizeJournalTask(rawTask);
+    if (task)
+      tasks.push(task);
   }
+  return { version: 1, tasks };
 }
-function worktreeFileSignature(path, cwd) {
-  try {
-    const stats = lstatSync3(join15(cwd, path));
-    const inode = "ino" in stats ? stats.ino : 0;
-    return `state:file|size:${stats.size}|mtime:${stats.mtimeMs}|ctime:${stats.ctimeMs}|ino:${inode}`;
-  } catch {
-    return "state:missing";
+async function loadDailyJournalState(root) {
+  return dailyJournalStore.load(root);
+}
+async function loadJournalTaskState(root) {
+  return journalTaskStore.load(root);
+}
+async function updateDailyJournalState(root, updater) {
+  return dailyJournalStore.update(root, updater);
+}
+async function updateJournalTaskState(root, updater) {
+  return journalTaskStore.update(root, updater);
+}
+function insertOptionCount2(input) {
+  return (input.before_id ? 1 : 0) + (input.after_id ? 1 : 0) + (input.position !== undefined ? 1 : 0);
+}
+function taskInsertIndex(tasks, status, input) {
+  if (insertOptionCount2(input) > 1)
+    return { ok: false, error: "use only one of before, after, or position" };
+  if (input.before_id || input.after_id) {
+    const anchorId = input.before_id || input.after_id || "";
+    const anchorIndex = tasks.findIndex((task) => task.id === anchorId);
+    const anchor = tasks[anchorIndex];
+    if (!anchor)
+      return { ok: false, error: "anchor task not found" };
+    if (anchor.status !== status)
+      return { ok: false, error: "anchor task belongs to another column" };
+    return {
+      ok: true,
+      index: input.before_id ? anchorIndex : anchorIndex + 1
+    };
   }
+  const statusIndexes = tasks.map((task, index) => ({ task, index })).filter((item) => item.task.status === status).map((item) => item.index);
+  if (input.position !== undefined) {
+    if (!Number.isInteger(input.position) || input.position < 1)
+      return { ok: false, error: "position must be a positive integer" };
+    if (input.position > statusIndexes.length + 1)
+      return { ok: false, error: "position is out of range" };
+    if (input.position <= statusIndexes.length)
+      return { ok: true, index: statusIndexes[input.position - 1] };
+  }
+  const last = statusIndexes[statusIndexes.length - 1];
+  return { ok: true, index: last === undefined ? tasks.length : last + 1 };
+}
+function validateEntryInput(input) {
+  if (!isIsoDate(input.date))
+    return { ok: false, error: "date must be YYYY-MM-DD" };
+  if (optionalBody(input.body, JOURNAL_ENTRY_BODY_MAX_BYTES) === undefined)
+    return { ok: false, error: "body is required or too large" };
+  if (!input.body.trim())
+    return { ok: false, error: "body is required" };
+  return { ok: true };
 }
-function fileDiffCacheKey(options) {
-  const worktreeTarget = options.range.from === "worktree" || !options.range.to || options.range.to === "worktree";
-  if (options.isUntracked && !worktreeTarget) {
-    throw new Error("untracked file diffs require a worktree range");
+function addDailyJournalEntry(state, input, now, makeId3 = makeJournalId) {
+  const valid = validateEntryInput(input);
+  if (valid.ok === false)
+    return valid;
+  const title = optionalString3(input.title, JOURNAL_TITLE_MAX_CHARS);
+  const entry = {
+    id: makeId3("j"),
+    date: input.date,
+    ...title ? { title } : {},
+    body: input.body,
+    labels: normalizeJournalLabels(input.labels),
+    source: input.source || "user",
+    created_at: now,
+    updated_at: now
+  };
+  return {
+    ok: true,
+    state: { version: 1, entries: [...state.entries, entry] },
+    entry
+  };
+}
+function updateDailyJournalEntry(state, id, patch, now) {
+  const entry = state.entries.find((item) => item.id === id);
+  if (!entry)
+    return { ok: false, error: "journal entry not found" };
+  const next = {
+    ...entry,
+    updated_at: now
+  };
+  if (patch.date !== undefined) {
+    if (!isIsoDate(patch.date))
+      return { ok: false, error: "date must be YYYY-MM-DD" };
+    next.date = patch.date;
+  }
+  if (patch.title !== undefined) {
+    const title = optionalString3(patch.title, JOURNAL_TITLE_MAX_CHARS);
+    if (title)
+      next.title = title;
+    else
+      delete next.title;
   }
-  const signature = worktreeTarget ? `\x00${worktreeFileSignature(options.path, options.cwd)}` : "";
-  if (options.isUntracked) {
-    return `u\x00${options.path}${signature}\x00${options.extras.join("\x00")}`;
+  if (patch.body !== undefined) {
+    const body = optionalBody(patch.body, JOURNAL_ENTRY_BODY_MAX_BYTES);
+    if (body === undefined || !body.trim())
+      return { ok: false, error: "body is required or too large" };
+    next.body = body;
+  }
+  if (patch.labels !== undefined)
+    next.labels = normalizeJournalLabels(patch.labels);
+  if (patch.source !== undefined)
+    next.source = patch.source;
+  return {
+    ok: true,
+    state: {
+      version: 1,
+      entries: state.entries.map((item) => item.id === id ? next : item)
+    },
+    entry: next
+  };
+}
+function deleteDailyJournalEntry(state, id) {
+  const entries = state.entries.filter((entry) => entry.id !== id);
+  return {
+    state: { version: 1, entries },
+    removed: entries.length !== state.entries.length
+  };
+}
+function validateTaskInput(input) {
+  if (!optionalString3(input.title, JOURNAL_TITLE_MAX_CHARS))
+    return { ok: false, error: "title is required" };
+  if (input.body !== undefined && optionalBody(input.body, JOURNAL_TASK_BODY_MAX_BYTES) === undefined)
+    return { ok: false, error: "body is too large" };
+  if (input.due_date !== undefined && !isIsoDate(input.due_date))
+    return { ok: false, error: "due date must be YYYY-MM-DD" };
+  if (input.source_date !== undefined && !isIsoDate(input.source_date))
+    return { ok: false, error: "source date must be YYYY-MM-DD" };
+  return { ok: true };
+}
+function completedAtForStatus(status, previous, now) {
+  return status === "done" ? previous || now : undefined;
+}
+function githubIssueTaskBody(issueNumber, issueUrl, memoLabel) {
+  return [
+    `GitHub issue #${issueNumber}`,
+    ...issueUrl ? [issueUrl] : [],
+    "",
+    memoLabel || "Memo:"
+  ].join(`
+`);
+}
+function githubIssueRequiredLabels(issueNumber, repo, labels) {
+  const repoLabel = journalIssueRepoLabel(repo);
+  return normalizeJournalLabels([
+    "github",
+    journalIssueLabel(issueNumber),
+    ...repoLabel ? [repoLabel] : [],
+    ...Array.isArray(labels) ? labels : []
+  ]);
+}
+function taskHasPlacement(input, currentStatus) {
+  return !!input.status && input.status !== currentStatus || !!input.before_id || !!input.after_id || input.position !== undefined;
+}
+function addJournalTask(state, input, now, makeId3 = makeJournalId) {
+  const valid = validateTaskInput(input);
+  if (valid.ok === false)
+    return valid;
+  const anchorId = input.before_id || input.after_id;
+  const anchor = anchorId ? state.tasks.find((task2) => task2.id === anchorId) : undefined;
+  if (anchorId && !anchor)
+    return { ok: false, error: "anchor task not found" };
+  const status = input.status || anchor?.status || "todo";
+  const task = {
+    id: makeId3("t"),
+    title: optionalString3(input.title, JOURNAL_TITLE_MAX_CHARS) || "Untitled task",
+    body: input.body || "",
+    status,
+    priority: input.priority || "p2",
+    labels: normalizeJournalLabels(input.labels),
+    created_at: now,
+    updated_at: now,
+    ...input.due_date ? { due_date: input.due_date } : {},
+    ...input.source_date ? { source_date: input.source_date } : {},
+    ...input.journal_entry_id ? { journal_entry_id: input.journal_entry_id } : {},
+    ...completedAtForStatus(status, undefined, now) ? { completed_at: now } : {}
+  };
+  const insertAt = taskInsertIndex(state.tasks, status, input);
+  if (insertAt.ok === false)
+    return insertAt;
+  const tasks = [...state.tasks];
+  tasks.splice(insertAt.index, 0, task);
+  return { ok: true, state: { version: 1, tasks }, task };
+}
+function updateJournalTask(state, id, patch, now) {
+  const task = state.tasks.find((item) => item.id === id);
+  if (!task)
+    return { ok: false, error: "task not found" };
+  const next = { ...task, updated_at: now };
+  if (patch.title !== undefined) {
+    const title = optionalString3(patch.title, JOURNAL_TITLE_MAX_CHARS);
+    if (!title)
+      return { ok: false, error: "title is required" };
+    next.title = title;
   }
-  return `t\x00${options.path}\x00${options.oldPath || ""}${signature}\x00${[...options.extras, ...options.args].join("\x00")}`;
+  if (patch.body !== undefined) {
+    const body = optionalBody(patch.body, JOURNAL_TASK_BODY_MAX_BYTES);
+    if (body === undefined)
+      return { ok: false, error: "body is too large" };
+    next.body = body;
+  }
+  if (patch.status !== undefined) {
+    next.status = patch.status;
+    const completedAt = completedAtForStatus(patch.status, next.completed_at, now);
+    if (completedAt)
+      next.completed_at = completedAt;
+    else
+      delete next.completed_at;
+    if (patch.status !== "doing")
+      delete next.claim;
+  }
+  if (patch.priority !== undefined)
+    next.priority = patch.priority;
+  if (patch.labels !== undefined)
+    next.labels = normalizeJournalLabels(patch.labels);
+  if (patch.due_date !== undefined) {
+    if (patch.due_date === null || patch.due_date === "")
+      delete next.due_date;
+    else if (isIsoDate(patch.due_date))
+      next.due_date = patch.due_date;
+    else
+      return { ok: false, error: "due date must be YYYY-MM-DD" };
+  }
+  if (patch.source_date !== undefined) {
+    if (patch.source_date === null || patch.source_date === "")
+      delete next.source_date;
+    else if (isIsoDate(patch.source_date))
+      next.source_date = patch.source_date;
+    else
+      return { ok: false, error: "source date must be YYYY-MM-DD" };
+  }
+  if (patch.journal_entry_id !== undefined) {
+    const journalEntryId = optionalString3(patch.journal_entry_id, 128);
+    if (journalEntryId)
+      next.journal_entry_id = journalEntryId;
+    else
+      delete next.journal_entry_id;
+  }
+  return {
+    ok: true,
+    state: {
+      version: 1,
+      tasks: state.tasks.map((item) => item.id === id ? next : item)
+    },
+    task: next
+  };
 }
-var CACHE_TTL_MS = 1500, MAX_TIMED_CACHE_ENTRIES = 200;
-var init_cache = () => {};
-
-// web-src/server/dev-assets.ts
-import { basename as basename2 } from "node:path";
-function startDevAssetReload(options) {
-  if (!options.enabled)
-    return false;
-  const watched = new Set(options.watchedFiles);
-  const setTimer = options.setTimeoutFn || setTimeout;
-  const clearTimer = options.clearTimeoutFn || clearTimeout;
-  const debounceMs = options.debounceMs ?? 150;
-  let timer = null;
-  options.watch(options.webRoot, { persistent: false }, (_event, filename) => {
-    if (!filename || !watched.has(basename2(filename.toString())))
-      return;
-    if (timer)
-      clearTimer(timer);
-    timer = setTimer(() => {
-      timer = null;
-      options.sendReload();
-    }, debounceMs);
+function moveJournalTask(state, id, input, now) {
+  const source = state.tasks.find((task) => task.id === id);
+  if (!source)
+    return { ok: false, error: "task not found" };
+  if (input.before_id === id || input.after_id === id)
+    return { ok: false, error: "cannot move task relative to itself" };
+  const tasksWithoutSource = state.tasks.filter((task) => task.id !== id);
+  const anchorId = input.before_id || input.after_id;
+  const anchor = anchorId ? tasksWithoutSource.find((task) => task.id === anchorId) : undefined;
+  if (anchorId && !anchor)
+    return { ok: false, error: "anchor task not found" };
+  const status = input.status || anchor?.status || source.status;
+  const moved = {
+    ...source,
+    status,
+    updated_at: now
+  };
+  const completedAt = completedAtForStatus(status, moved.completed_at, now);
+  if (completedAt)
+    moved.completed_at = completedAt;
+  else
+    delete moved.completed_at;
+  if (status !== "doing")
+    delete moved.claim;
+  const insertAt = taskInsertIndex(tasksWithoutSource, status, input);
+  if (insertAt.ok === false)
+    return insertAt;
+  const tasks = [...tasksWithoutSource];
+  tasks.splice(insertAt.index, 0, moved);
+  return { ok: true, state: { version: 1, tasks }, task: moved };
+}
+function linkGithubIssueTask(state, input, now, makeId3 = makeJournalId) {
+  if (!Number.isInteger(input.issue_number) || input.issue_number < 1) {
+    return { ok: false, error: "issue number must be a positive integer" };
+  }
+  const title = optionalString3(input.title, JOURNAL_TITLE_MAX_CHARS) || `GitHub issue #${input.issue_number}`;
+  const repo = optionalString3(input.repo, 120);
+  const issueUrl = optionalString3(input.url, 240);
+  const memoLabel = optionalString3(input.memo_label, 80);
+  const requiredLabels = githubIssueRequiredLabels(input.issue_number, repo, input.labels);
+  const linkLabel = journalIssueLabel(input.issue_number);
+  const repoLabel = journalIssueRepoLabel(repo);
+  const linked = state.tasks.find((task2) => {
+    if (!task2.labels.includes("github") || !task2.labels.includes(linkLabel)) {
+      return false;
+    }
+    if (repoLabel)
+      return task2.labels.includes(repoLabel);
+    return !task2.labels.some((label) => label.startsWith("repo-"));
   });
-  return true;
+  if (!linked) {
+    const hasAnchor = !!input.before_id || !!input.after_id;
+    const result = addJournalTask(state, {
+      title,
+      body: githubIssueTaskBody(input.issue_number, issueUrl, memoLabel),
+      status: input.status || (hasAnchor ? undefined : "draft"),
+      priority: input.priority || "p2",
+      labels: requiredLabels,
+      before_id: input.before_id,
+      after_id: input.after_id,
+      position: input.position
+    }, now, makeId3);
+    if (result.ok === false)
+      return result;
+    return {
+      ok: true,
+      state: result.state,
+      task: result.task,
+      created: true,
+      moved: false
+    };
+  }
+  let nextState = state;
+  let task = linked;
+  let moved = false;
+  const placement = {
+    status: input.status,
+    before_id: input.before_id,
+    after_id: input.after_id,
+    position: input.position
+  };
+  if (taskHasPlacement(placement, task.status)) {
+    const result = moveJournalTask(nextState, task.id, placement, now);
+    if (result.ok === false)
+      return result;
+    nextState = result.state;
+    task = result.task;
+    moved = true;
+  }
+  const labels = normalizeJournalLabels([...task.labels, ...requiredLabels]);
+  const shouldUpdateLabels = labels.length !== task.labels.length || labels.some((label, index) => label !== task.labels[index]);
+  if (input.priority || shouldUpdateLabels) {
+    const result = updateJournalTask(nextState, task.id, {
+      ...input.priority ? { priority: input.priority } : {},
+      ...shouldUpdateLabels ? { labels } : {}
+    }, now);
+    if (result.ok === false)
+      return result;
+    nextState = result.state;
+    task = result.task;
+  }
+  return { ok: true, state: nextState, task, created: false, moved };
+}
+function claimJournalTask(state, id, input, now) {
+  const task = state.tasks.find((item) => item.id === id);
+  if (!task)
+    return { ok: false, error: "task not found" };
+  const nowMs = Date.parse(now);
+  const activeClaim = task.claim && Number.isFinite(Date.parse(task.claim.lease_expires_at)) && Date.parse(task.claim.lease_expires_at) > nowMs;
+  if (activeClaim)
+    return { ok: false, error: "task is already claimed" };
+  if (task.status !== "todo" && task.status !== "doing")
+    return {
+      ok: false,
+      error: "only todo or expired doing tasks can be claimed"
+    };
+  const by = optionalString3(input.by, 128) || "ai";
+  const wipLimit = input.wip_limit;
+  if (wipLimit !== undefined && wipLimit > 0) {
+    const activeDoing = state.tasks.filter((item) => {
+      if (item.status !== "doing" || !item.claim)
+        return false;
+      if (item.claim.by !== by)
+        return false;
+      const expires = Date.parse(item.claim.lease_expires_at);
+      return Number.isFinite(expires) && expires > nowMs;
+    }).length;
+    if (activeDoing >= wipLimit)
+      return { ok: false, error: "WIP limit reached" };
+  }
+  const leaseMinutes = Number.isFinite(input.lease_minutes) && input.lease_minutes ? Math.min(1440, Math.max(1, Math.round(input.lease_minutes))) : 120;
+  const leaseExpiresAt = new Date(nowMs + leaseMinutes * 60000).toISOString();
+  const next = {
+    ...task,
+    status: "doing",
+    updated_at: now,
+    claim: {
+      by,
+      claimed_at: now,
+      lease_expires_at: leaseExpiresAt
+    }
+  };
+  return {
+    ok: true,
+    state: {
+      version: 1,
+      tasks: state.tasks.map((item) => item.id === id ? next : item)
+    },
+    task: next
+  };
 }
-var init_dev_assets = () => {};
+function completeJournalTask(state, id, input, now, makeId3 = makeJournalId) {
+  const task = state.tasks.find((item) => item.id === id);
+  if (!task)
+    return { ok: false, error: "task not found" };
+  if (task.status !== "doing")
+    return { ok: false, error: "only doing tasks can be completed" };
+  const nowMs = Date.parse(now);
+  const activeClaim = task.claim && Number.isFinite(Date.parse(task.claim.lease_expires_at)) && Date.parse(task.claim.lease_expires_at) > nowMs;
+  if (!activeClaim)
+    return { ok: false, error: "task must be claimed before completion" };
+  const by = optionalString3(input.by, 128);
+  if (!by)
+    return { ok: false, error: "task completion requires claim owner" };
+  if (task.claim?.by !== by)
+    return { ok: false, error: "task claim belongs to another agent" };
+  const notes = [...task.notes || []];
+  if (input.note?.trim()) {
+    const body = optionalBody(input.note, JOURNAL_TASK_NOTE_MAX_BYTES);
+    if (body === undefined)
+      return { ok: false, error: "note is too large" };
+    notes.push({
+      id: makeId3("n"),
+      at: now,
+      body,
+      source: input.source || "ai"
+    });
+    if (notes.length > MAX_NOTES_PER_TASK) {
+      notes.splice(0, notes.length - MAX_NOTES_PER_TASK);
+    }
+  }
+  const next = {
+    ...task,
+    status: "done",
+    updated_at: now,
+    completed_at: now,
+    ...notes.length ? { notes } : {}
+  };
+  delete next.claim;
+  return {
+    ok: true,
+    state: {
+      version: 1,
+      tasks: state.tasks.map((item) => item.id === id ? next : item)
+    },
+    task: next
+  };
+}
+function deleteJournalTask(state, id) {
+  const tasks = state.tasks.filter((task) => task.id !== id);
+  return {
+    state: { version: 1, tasks },
+    removed: tasks.length !== state.tasks.length
+  };
+}
+var DAILY_JOURNAL_FILE_NAME = "daily-journal.json", JOURNAL_TASKS_FILE_NAME = "tasks.json", JOURNAL_ENTRY_BODY_MAX_BYTES, JOURNAL_TASK_BODY_MAX_BYTES, JOURNAL_TASK_NOTE_MAX_BYTES, JOURNAL_TITLE_MAX_CHARS = 200, MAX_DAILY_JOURNAL_JSON_BYTES = 8000000, MAX_JOURNAL_TASKS_JSON_BYTES = 8000000, MAX_ENTRIES3 = 2000, MAX_TASKS = 2000, MAX_NOTES_PER_TASK = 100, dailyJournalStore, journalTaskStore;
+var init_journal2 = __esm(() => {
+  init_journal();
+  init_annotations();
+  init_json_store();
+  JOURNAL_ENTRY_BODY_MAX_BYTES = 128 * 1024;
+  JOURNAL_TASK_BODY_MAX_BYTES = 128 * 1024;
+  JOURNAL_TASK_NOTE_MAX_BYTES = 64 * 1024;
+  dailyJournalStore = createJsonFileStore({
+    filePath: dailyJournalFilePath,
+    empty: emptyDailyJournalState,
+    sanitize: normalizeDailyJournalState,
+    maxBytes: MAX_DAILY_JOURNAL_JSON_BYTES,
+    backupSuffix: "corrupt",
+    sizeErrorMessage: "daily journal state too large"
+  });
+  journalTaskStore = createJsonFileStore({
+    filePath: journalTasksFilePath,
+    empty: emptyJournalTaskState,
+    sanitize: normalizeJournalTaskState,
+    maxBytes: MAX_JOURNAL_TASKS_JSON_BYTES,
+    backupSuffix: "corrupt",
+    sizeErrorMessage: "journal task state too large"
+  });
+});
 
 // web-src/server/search-service.ts
-import { existsSync as existsSync7, lstatSync as lstatSync4, readFileSync as readFileSync6, realpathSync as realpathSync5 } from "node:fs";
-import { join as join16, relative as relative6 } from "node:path";
+import { existsSync as existsSync7, lstatSync as lstatSync4, readFileSync as readFileSync7, realpathSync as realpathSync5 } from "node:fs";
+import { join as join17, relative as relative6 } from "node:path";
 function rgAvailable(cwd) {
   if (rgAvailableCache !== null)
     return rgAvailableCache;
@@ -18381,7 +20243,7 @@ function safeWorktreePath(env, path) {
     return null;
   if (isGitInternalPath(path))
     return null;
-  const full = join16(env.cwd, path);
+  const full = join17(env.cwd, path);
   if (!existsSync7(full))
     return null;
   let realCwd;
@@ -18427,7 +20289,7 @@ function grepWorktreeFallback(env, query, max, paths) {
       continue;
     let data;
     try {
-      data = readFileSync6(full);
+      data = readFileSync7(full);
     } catch {
       continue;
     }
@@ -18560,8 +20422,8 @@ var init_search_service = __esm(() => {
 });
 
 // web-src/server/mcp.ts
-import { readFileSync as readFileSync7 } from "node:fs";
-import { join as join17 } from "node:path";
+import { readFileSync as readFileSync8 } from "node:fs";
+import { join as join18 } from "node:path";
 function defaultMcpTools(options = {}) {
   return [
     {
@@ -20035,7 +21897,7 @@ var init_mcp = __esm(() => {
   init_search_cli();
   init_search_service();
   init_status_cli();
-  PACKAGE_VERSION = JSON.parse(readFileSync7(join17(ROOT, "package.json"), "utf8")).version;
+  PACKAGE_VERSION = JSON.parse(readFileSync8(join18(ROOT, "package.json"), "utf8")).version;
   MCP_SERVER_INFO = {
     name: "code-viewer",
     title: "code-viewer",
@@ -20122,7 +21984,7 @@ import {
   lstatSync as lstatSync5,
   mkdirSync as mkdirSync4,
   openSync as openSync2,
-  readFileSync as readFileSync8,
+  readFileSync as readFileSync9,
   realpathSync as realpathSync6,
   renameSync,
   statSync as statSync6,
@@ -20131,7 +21993,7 @@ import {
   writeFileSync as writeFileSync2
 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { basename as basename3, dirname as dirname5, extname as extname2, join as join18, relative as relative7 } from "node:path";
+import { basename as basename3, dirname as dirname5, extname as extname2, join as join19, relative as relative7 } from "node:path";
 function parseCli() {
   const rest = [];
   for (let i = 2;i < process.argv.length; i++) {
@@ -20143,17 +22005,18 @@ Usage:
   code-viewer [--cwd <repo>] [--port <port>] [--open] [--bin <name>=<path>] [git-diff-args...]
   code-viewer status [--cwd <repo>] [--bin git=<path>] [--ref <ref>] [--limit <N>] [--json]
   code-viewer annotate <start|add|add-db|rename|edit|move|list|delete|clear> [options]
+  code-viewer journal <list|add|edit|tasks|task-add|task-update|task-next|github-issues|task-link-issue|task-claim|task-done|task-delete> [options]
   code-viewer query <sources|schemas|schema|columns|ddl|exec|list|clear|snapshot|diff|search|redis|elasticsearch|s3> [options] [--bin git=<path>]
   code-viewer search code --term <text> [--ref <ref>] [--path <p>...] [--regex] [--max <n>] [--json] [--bin git=<path>]
   code-viewer search files --term <pattern> [--ref <ref>] [--max <n>] [--json] [--bin git=<path>]
   code-viewer file <blame|history|show|diff> --path <p> [--ref <ref>] [...subcommand options] [--json] [--bin git=<path>]
   code-viewer skill install [--agent <list>] [--global]
-  code-viewer doctor [--cwd <path>] [--port <N>] [--json] [--bin <git|docker>=<path>]
+  code-viewer doctor [--cwd <path>] [--port <N>] [--json] [--bin <git|docker|gh>=<path>]
   code-viewer agent-help
   code-viewer help
 
 AI-agent index (start here):  code-viewer agent-help
-Subcommand guides (AI agents): code-viewer <status|annotate|query|search|file|skill|doctor> agent-help
+Subcommand guides (AI agents): code-viewer <status|annotate|journal|query|search|file|skill|doctor> agent-help
 
 Examples:
   code-viewer --open
@@ -20251,7 +22114,7 @@ Examples:
 }
 function warnIfLegacyConfigPresent() {
   try {
-    if (existsSync8(join18(cwd, ".code-viewer.json"))) {
+    if (existsSync8(join19(cwd, ".code-viewer.json"))) {
       console.warn("[code-viewer] .code-viewer.json is no longer used; configure scope and upload from Viewer Settings instead. The file can be safely removed.");
     }
   } catch {}
@@ -20358,10 +22221,10 @@ function staticFile(pathname) {
   const spec = map[pathname];
   if (!spec)
     return null;
-  const full = join18(WEB_ROOT, spec[0]);
+  const full = join19(WEB_ROOT, spec[0]);
   if (!existsSync8(full))
     return text("not found", 404);
-  return new Response(readFileSync8(full), {
+  return new Response(readFileSync9(full), {
     headers: { "Content-Type": spec[1], "Cache-Control": "no-store" }
   });
 }
@@ -20613,7 +22476,7 @@ function safeWorktreePath2(path) {
   return safeWorktreePath(currentSearchEnv(), path);
 }
 function worktreePath(path) {
-  return join18(cwd, path);
+  return join19(cwd, path);
 }
 function safeOpenWorktreePath(path) {
   if (path === "") {
@@ -20698,7 +22561,7 @@ function readReadme(target, dirPath) {
       if (!full)
         continue;
       try {
-        return { path, text: readFileSync8(full, "utf8") };
+        return { path, text: readFileSync9(full, "utf8") };
       } catch {
         continue;
       }
@@ -20884,7 +22747,7 @@ function handleLog(url) {
 }
 function blamePathKey(p) {
   try {
-    const st = statSync6(join18(cwd, p));
+    const st = statSync6(join19(cwd, p));
     return `${st.mtimeMs}:${st.size}`;
   } catch {
     return "missing";
@@ -21378,7 +23241,7 @@ async function handleUploadFiles(req) {
     total += file.size;
     if (total > MAX_UPLOAD_TOTAL_BYTES)
       return text("upload too large", 413);
-    const target = join18(realDir, safeName);
+    const target = join19(realDir, safeName);
     if (relative7(realDir, dirname5(target)) !== "")
       return text("invalid filename", 400);
     if (existsSync8(target))
@@ -21500,9 +23363,9 @@ function triggerUpdate(changedPaths) {
   sendSse("update", data);
 }
 function moveMacPathIntoTrash(path) {
-  const trashDir = join18(homedir3(), ".Trash");
+  const trashDir = join19(homedir3(), ".Trash");
   const base = basename3(path) || "code-viewer-trash-item";
-  const target = join18(trashDir, `${base}-${Date.now()}-${process.pid}-${Math.random().toString(36).slice(2, 8)}`);
+  const target = join19(trashDir, `${base}-${Date.now()}-${process.pid}-${Math.random().toString(36).slice(2, 8)}`);
   try {
     mkdirSync4(trashDir, { recursive: true });
     renameSync(path, target);
@@ -21544,7 +23407,7 @@ function restoreTrashPath(originalPath, trashPath) {
     if (!existsSync8(trashPath))
       return { ok: false, error: "trash item not found" };
     try {
-      const trashRoot = join18(homedir3(), ".Trash");
+      const trashRoot = join19(homedir3(), ".Trash");
       const trashRelative = relative7(trashRoot, trashPath);
       if (trashRelative === "" || trashRelative.startsWith("..") || trashRelative.startsWith("/") || trashRelative.startsWith("\\"))
         return { ok: false, error: "invalid trash handle" };
@@ -21694,7 +23557,7 @@ async function handleCreateDirectory(req) {
   const targetPath = dir ? `${dir}/${name}` : name;
   if (!safeRepoPath(targetPath) || isGitInternalPath(targetPath))
     return text("invalid target", 400);
-  const target = join18(parent, name);
+  const target = join19(parent, name);
   if (existsSync8(target))
     return text("already exists", 409);
   try {
@@ -21779,6 +23642,282 @@ async function handleMcp(req) {
   }
   return json2(dispatched.body);
 }
+function journalSse(kind, id) {
+  sendSse("journal", JSON.stringify({ kind, id }));
+}
+function bodyString(body, key) {
+  const value = body[key];
+  return typeof value === "string" ? value : undefined;
+}
+function bodyStringList(body, key) {
+  const value = body[key];
+  if (!Array.isArray(value))
+    return [];
+  return value.filter((item) => typeof item === "string");
+}
+function bodyTaskStatus(body, key) {
+  const value = body[key];
+  if (value === undefined)
+    return;
+  if (isJournalTaskStatus(value))
+    return value;
+  throw new JournalRequestError(`${key} must be draft, todo, doing, blocked, or done`);
+}
+function bodyTaskPriority(body, key) {
+  const value = body[key];
+  if (value === undefined)
+    return;
+  if (isJournalTaskPriority(value))
+    return value;
+  throw new JournalRequestError(`${key} must be p0, p1, p2, or p3`);
+}
+function bodyNumber(body, key) {
+  const value = body[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+async function handleJournal(req) {
+  if (req.method === "GET") {
+    const journal = await loadDailyJournalState(cwd);
+    const tasks = await loadJournalTaskState(cwd);
+    return json2({
+      generation,
+      journal,
+      tasks,
+      labels: collectJournalLabels(journal, tasks)
+    });
+  }
+  if (req.method !== "POST")
+    return text("method not allowed", 405);
+  if (!sideEffectRequestAllowed(req))
+    return text("forbidden", 403);
+  const contentType = req.headers.get("content-type") || "";
+  if (!/^application\/json(?:;|$)/i.test(contentType))
+    return text("unsupported media type", 415);
+  const maxBytes = Math.max(JOURNAL_ENTRY_BODY_MAX_BYTES, JOURNAL_TASK_BODY_MAX_BYTES) + 8192;
+  const length = Number(req.headers.get("content-length") || "0");
+  if (length > maxBytes)
+    return text("payload too large", 413);
+  let body = {};
+  try {
+    const raw = await req.text();
+    if (raw.length > maxBytes)
+      return text("payload too large", 413);
+    body = JSON.parse(raw);
+  } catch {
+    return text("invalid json", 400);
+  }
+  try {
+    const action = body.action;
+    const now = new Date().toISOString();
+    if (action === "add-entry") {
+      const entry = await updateDailyJournalState(cwd, (state) => {
+        const result = addDailyJournalEntry(state, {
+          date: bodyString(body, "date") || "",
+          title: bodyString(body, "title"),
+          body: bodyString(body, "body") || "",
+          labels: body.labels,
+          source: body.source === "ai" ? "ai" : "user"
+        }, now);
+        if (result.ok === false)
+          throw new JournalRequestError(result.error);
+        return { state: result.state, result: result.entry };
+      });
+      journalSse("add-entry", entry.id);
+      return json2({ ok: true, entry, generation });
+    }
+    if (action === "list-github-issues") {
+      const label = bodyString(body, "label");
+      const labels = bodyStringList(body, "labels");
+      if (label)
+        labels.push(label);
+      const issues = readGithubIssueList({
+        cwd,
+        repo: bodyString(body, "repo"),
+        labels,
+        search: bodyString(body, "search"),
+        state: normalizeGithubIssueListState(bodyString(body, "state")),
+        limit: normalizeGithubIssueListLimit(bodyNumber(body, "limit"))
+      });
+      return json2({ ok: true, issues, generation });
+    }
+    if (action === "update-entry") {
+      const id = bodyString(body, "id") || "";
+      if (!id)
+        return text("invalid id", 400);
+      const entry = await updateDailyJournalState(cwd, (state) => {
+        const result = updateDailyJournalEntry(state, id, {
+          date: bodyString(body, "date"),
+          title: bodyString(body, "title"),
+          body: bodyString(body, "body"),
+          labels: body.labels,
+          source: body.source === "ai" ? "ai" : undefined
+        }, now);
+        if (result.ok === false)
+          throw new JournalRequestError(result.error);
+        return { state: result.state, result: result.entry };
+      });
+      journalSse("update-entry", entry.id);
+      return json2({ ok: true, entry, generation });
+    }
+    if (action === "delete-entry") {
+      const id = bodyString(body, "id") || "";
+      if (!id)
+        return text("invalid id", 400);
+      const removed = await updateDailyJournalState(cwd, (state) => {
+        const result = deleteDailyJournalEntry(state, id);
+        return { state: result.state, result: result.removed };
+      });
+      if (removed)
+        journalSse("delete-entry", id);
+      return json2({ ok: true, removed, generation });
+    }
+    if (action === "link-github-issue") {
+      const result = await updateJournalTaskState(cwd, (state) => {
+        const linked = linkGithubIssueTask(state, {
+          issue_number: bodyNumber(body, "issue_number") || 0,
+          repo: bodyString(body, "repo"),
+          title: bodyString(body, "title"),
+          url: bodyString(body, "url"),
+          memo_label: bodyString(body, "memo_label"),
+          status: bodyTaskStatus(body, "status"),
+          priority: bodyTaskPriority(body, "priority"),
+          labels: body.labels,
+          before_id: bodyString(body, "before_id"),
+          after_id: bodyString(body, "after_id"),
+          position: bodyNumber(body, "position")
+        }, now);
+        if (linked.ok === false)
+          throw new JournalRequestError(linked.error);
+        return { state: linked.state, result: linked };
+      });
+      journalSse("link-github-issue", result.task.id);
+      return json2({
+        ok: true,
+        task: result.task,
+        created: result.created,
+        moved: result.moved,
+        generation
+      });
+    }
+    if (action === "add-task") {
+      const task = await updateJournalTaskState(cwd, (state) => {
+        const result = addJournalTask(state, {
+          title: bodyString(body, "title") || "",
+          body: bodyString(body, "body"),
+          status: bodyTaskStatus(body, "status"),
+          priority: bodyTaskPriority(body, "priority"),
+          labels: body.labels,
+          due_date: bodyString(body, "due_date"),
+          source_date: bodyString(body, "source_date"),
+          journal_entry_id: bodyString(body, "journal_entry_id"),
+          before_id: bodyString(body, "before_id"),
+          after_id: bodyString(body, "after_id"),
+          position: bodyNumber(body, "position")
+        }, now);
+        if (result.ok === false)
+          throw new JournalRequestError(result.error);
+        return { state: result.state, result: result.task };
+      });
+      journalSse("add-task", task.id);
+      return json2({ ok: true, task, generation });
+    }
+    if (action === "update-task") {
+      const id = bodyString(body, "id") || "";
+      if (!id)
+        return text("invalid id", 400);
+      const task = await updateJournalTaskState(cwd, (state) => {
+        const result = updateJournalTask(state, id, {
+          title: bodyString(body, "title"),
+          body: bodyString(body, "body"),
+          status: bodyTaskStatus(body, "status"),
+          priority: bodyTaskPriority(body, "priority"),
+          labels: body.labels,
+          due_date: body.due_date === null ? null : bodyString(body, "due_date"),
+          source_date: body.source_date === null ? null : bodyString(body, "source_date"),
+          journal_entry_id: body.journal_entry_id === null ? null : bodyString(body, "journal_entry_id")
+        }, now);
+        if (result.ok === false)
+          throw new JournalRequestError(result.error);
+        return { state: result.state, result: result.task };
+      });
+      journalSse("update-task", task.id);
+      return json2({ ok: true, task, generation });
+    }
+    if (action === "move-task") {
+      const id = bodyString(body, "id") || "";
+      if (!id)
+        return text("invalid id", 400);
+      const task = await updateJournalTaskState(cwd, (state) => {
+        const result = moveJournalTask(state, id, {
+          status: bodyTaskStatus(body, "status"),
+          before_id: bodyString(body, "before_id"),
+          after_id: bodyString(body, "after_id"),
+          position: bodyNumber(body, "position")
+        }, now);
+        if (result.ok === false)
+          throw new JournalRequestError(result.error);
+        return { state: result.state, result: result.task };
+      });
+      journalSse("move-task", task.id);
+      return json2({ ok: true, task, generation });
+    }
+    if (action === "claim-task") {
+      const id = bodyString(body, "id") || "";
+      if (!id)
+        return text("invalid id", 400);
+      const task = await updateJournalTaskState(cwd, (state) => {
+        const result = claimJournalTask(state, id, {
+          by: bodyString(body, "by"),
+          lease_minutes: bodyNumber(body, "lease_minutes"),
+          wip_limit: bodyNumber(body, "wip_limit")
+        }, now);
+        if (result.ok === false)
+          throw new JournalRequestError(result.error);
+        return { state: result.state, result: result.task };
+      });
+      journalSse("claim-task", task.id);
+      return json2({ ok: true, task, generation });
+    }
+    if (action === "complete-task") {
+      const id = bodyString(body, "id") || "";
+      if (!id)
+        return text("invalid id", 400);
+      const task = await updateJournalTaskState(cwd, (state) => {
+        const result = completeJournalTask(state, id, {
+          by: bodyString(body, "by"),
+          note: bodyString(body, "note"),
+          source: body.source === "user" ? "user" : "ai"
+        }, now);
+        if (result.ok === false)
+          throw new JournalRequestError(result.error);
+        return { state: result.state, result: result.task };
+      });
+      journalSse("complete-task", task.id);
+      return json2({ ok: true, task, generation });
+    }
+    if (action === "delete-task") {
+      const id = bodyString(body, "id") || "";
+      if (!id)
+        return text("invalid id", 400);
+      const removed = await updateJournalTaskState(cwd, (state) => {
+        const result = deleteJournalTask(state, id);
+        return { state: result.state, result: result.removed };
+      });
+      if (removed)
+        journalSse("delete-task", id);
+      return json2({ ok: true, removed, generation });
+    }
+  } catch (error) {
+    if (error instanceof GithubIssueListError) {
+      return text(error.message, error.status);
+    }
+    if (error instanceof JournalRequestError) {
+      return text(error.message, error.status);
+    }
+    throw error;
+  }
+  return text("invalid action", 400);
+}
 async function handleAnnotations(req) {
   if (req.method === "GET")
     return json2(await loadAnnotationsState(cwd));
@@ -21995,8 +24134,9 @@ function restartWorktreeWatch() {
   }
   worktreeWatch = startScopedWorktreeWatch();
 }
-var WEB_ROOT, VERSION, DEFAULT_ARGS, PREVIEW_HUNKS_DEFAULT = 3, PREVIEW_LINES_DEFAULT = 1200, WATCHED_ASSET_FILES, SIZE_SMALL = 2000, SIZE_MEDIUM = 8000, SIZE_LARGE = 20000, LINE_INDEX_MIN_START = 1e4, LINE_INDEX_MAX_FILE_BYTES, BLOB_LINE_CACHE_MAX_BYTES, MAX_UPLOAD_FILE_BYTES, MAX_UPLOAD_TOTAL_BYTES, MAX_UPLOAD_BODY_BYTES, MAX_UPLOAD_FILES = 50, SAFE_UPLOAD_EXTENSIONS, generation = 1, cwd, cliArgs, listenPort = 0, openAfterStart = false, commandOverrides, cwdWasExplicit = false, scopeOmitDirNames, scopeOmitDirCliOverride = null, scopeExcludeNames, scopeWatchLimit, uploadEnabled = true, enc, sseClients, sseKeepalives, fileCache, blameCache, BLAME_CACHE_MAX = 64, metaCache, fileListCache, lineIndexCache, blobLineIndexCache, blobBytesCache, blobLineCacheBytes = 0, safePath, MCP_MAX_BODY_BYTES = 1048576, MCP_INSTRUCTIONS, isCodeViewerInternalPath, watchLimitReached = null, server, worktreeWatch = null, shuttingDown = false;
+var WEB_ROOT, VERSION, DEFAULT_ARGS, PREVIEW_HUNKS_DEFAULT = 3, PREVIEW_LINES_DEFAULT = 1200, WATCHED_ASSET_FILES, SIZE_SMALL = 2000, SIZE_MEDIUM = 8000, SIZE_LARGE = 20000, LINE_INDEX_MIN_START = 1e4, LINE_INDEX_MAX_FILE_BYTES, BLOB_LINE_CACHE_MAX_BYTES, MAX_UPLOAD_FILE_BYTES, MAX_UPLOAD_TOTAL_BYTES, MAX_UPLOAD_BODY_BYTES, MAX_UPLOAD_FILES = 50, SAFE_UPLOAD_EXTENSIONS, generation = 1, cwd, cliArgs, listenPort = 0, openAfterStart = false, commandOverrides, cwdWasExplicit = false, scopeOmitDirNames, scopeOmitDirCliOverride = null, scopeExcludeNames, scopeWatchLimit, uploadEnabled = true, enc, sseClients, sseKeepalives, fileCache, blameCache, BLAME_CACHE_MAX = 64, metaCache, fileListCache, lineIndexCache, blobLineIndexCache, blobBytesCache, blobLineCacheBytes = 0, safePath, MCP_MAX_BODY_BYTES = 1048576, MCP_INSTRUCTIONS, JournalRequestError, isCodeViewerInternalPath, watchLimitReached = null, server, worktreeWatch = null, shuttingDown = false;
 var init_preview = __esm(async () => {
+  init_journal();
   init_routes();
   init_annotations();
   init_cache();
@@ -22004,6 +24144,8 @@ var init_preview = __esm(async () => {
   init_dev_assets();
   init_doctor();
   init_git();
+  init_github_issues();
+  init_journal2();
   init_mcp();
   init_raw_file_headers();
   init_root();
@@ -22013,8 +24155,8 @@ var init_preview = __esm(async () => {
   init_server_registry();
   init_state_store();
   init_worktree_watcher();
-  WEB_ROOT = join18(ROOT, "web");
-  VERSION = JSON.parse(readFileSync8(join18(ROOT, "package.json"), "utf8")).version;
+  WEB_ROOT = join19(ROOT, "web");
+  VERSION = JSON.parse(readFileSync9(join19(ROOT, "package.json"), "utf8")).version;
   DEFAULT_ARGS = ["HEAD"];
   WATCHED_ASSET_FILES = ["index.html", "style.css", "app.js"];
   LINE_INDEX_MAX_FILE_BYTES = 256 * 1024 * 1024;
@@ -22076,6 +24218,13 @@ var init_preview = __esm(async () => {
   blobBytesCache = new Map;
   safePath = isSafePath;
   MCP_INSTRUCTIONS = buildMcpInstructions();
+  JournalRequestError = class JournalRequestError extends Error {
+    status;
+    constructor(message, status = 400) {
+      super(message);
+      this.status = status;
+    }
+  };
   isCodeViewerInternalPath = isToolInternalPath;
   parseCli();
   applyPersistedSettings(await loadAppSettingsState(cwd));
@@ -22141,6 +24290,8 @@ var init_preview = __esm(async () => {
       }
       if (url.pathname === "/_mcp")
         return handleMcp(req);
+      if (url.pathname === "/_journal")
+        return handleJournal(req);
       if (url.pathname === "/_annotations")
         return handleAnnotations(req);
       if (url.pathname === "/_refs") {
@@ -22271,6 +24422,9 @@ if (process.argv[2] === "agent-help") {
 } else if (process.argv[2] === "annotate") {
   const { runAnnotateCli: runAnnotateCli2 } = await Promise.resolve().then(() => (init_annotate_cli(), exports_annotate_cli));
   await runAnnotateCli2(process.argv.slice(3));
+} else if (process.argv[2] === "journal") {
+  const { runJournalCli: runJournalCli2 } = await Promise.resolve().then(() => (init_journal_cli(), exports_journal_cli));
+  await runJournalCli2(process.argv.slice(3));
 } else if (process.argv[2] === "query") {
   const sub = process.argv[3];
   const helpOnly = !sub || sub === "help" || sub === "agent-help" || sub === "--help" || sub === "-h";