@eunjae/il 0.0.1

package/dist/lib/taskFactory.js

@@ -0,0 +1,19 @@
+import { generateStableRef, generateTaskId } from './id';
+import { nowIso } from './time';
+export const buildTask = (input) => {
+    const id = generateTaskId(input.type);
+    const ref = generateStableRef(input.type, id);
+    const timestamp = nowIso();
+    return {
+        id,
+        ref,
+        type: input.type,
+        title: input.title,
+        status: 'backlog',
+        created_at: timestamp,
+        updated_at: timestamp,
+        metadata: input.metadata ?? {},
+        logs: [],
+        day_assignments: []
+    };
+};

package/dist/lib/taskOperations.js

@@ -0,0 +1,57 @@
+import { getNextStatus } from './fsm';
+import { nowIso } from './time';
+const defaultMessages = {
+    start: 'Started task',
+    pause: 'Paused task',
+    complete: 'Completed task',
+    cancel: 'Cancelled task'
+};
+export const appendLog = (task, message, status) => {
+    const log = {
+        ts: nowIso(),
+        msg: message,
+        status
+    };
+    return {
+        ...task,
+        logs: [...task.logs, log],
+        updated_at: nowIso()
+    };
+};
+export const applyTransition = (task, action, message) => {
+    const nextStatus = getNextStatus(task.status, action);
+    const logMessage = message ?? defaultMessages[action];
+    const log = {
+        ts: nowIso(),
+        msg: logMessage,
+        status: nextStatus
+    };
+    const updated = {
+        ...task,
+        status: nextStatus,
+        updated_at: nowIso(),
+        logs: [...task.logs, log]
+    };
+    return { task: updated, nextStatus };
+};
+export const isAssignedOnDate = (task, date) => {
+    const events = task.day_assignments.filter((entry) => entry.date === date);
+    if (events.length === 0) {
+        return false;
+    }
+    const lastEvent = events[events.length - 1];
+    return lastEvent.action === 'assign';
+};
+export const appendDayAssignment = (task, date, action, msg) => {
+    const event = {
+        date,
+        action,
+        ts: nowIso(),
+        msg
+    };
+    return {
+        ...task,
+        day_assignments: [...task.day_assignments, event],
+        updated_at: nowIso()
+    };
+};

package/dist/lib/taskRepo.js

@@ -0,0 +1,67 @@
+import { access, readdir, rename } from 'node:fs/promises';
+import path from 'node:path';
+import { STATUS_ORDER, TASKS_DIR } from './constants';
+import { readJsonFile, writeJsonAtomic } from './json';
+import { taskSchema } from './schema';
+const taskFileName = (taskId) => `${taskId}.json`;
+const getStatusDir = (workspaceRoot, status) => path.join(workspaceRoot, TASKS_DIR, status);
+export const getTaskPath = (workspaceRoot, status, taskId) => {
+    return path.join(getStatusDir(workspaceRoot, status), taskFileName(taskId));
+};
+const fileExists = async (filePath) => {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+export const findTaskPathById = async (workspaceRoot, taskId) => {
+    for (const status of STATUS_ORDER) {
+        const candidate = getTaskPath(workspaceRoot, status, taskId);
+        if (await fileExists(candidate)) {
+            return { filePath: candidate, status };
+        }
+    }
+    return null;
+};
+export const loadTaskFromPath = async (filePath) => {
+    const parsed = await readJsonFile(filePath);
+    return taskSchema.parse(parsed);
+};
+export const loadTaskById = async (workspaceRoot, taskId) => {
+    const found = await findTaskPathById(workspaceRoot, taskId);
+    if (!found) {
+        throw new Error(`Task not found: ${taskId}`);
+    }
+    const task = await loadTaskFromPath(found.filePath);
+    return { task, status: found.status, filePath: found.filePath };
+};
+export const listTasksByStatus = async (workspaceRoot, status) => {
+    const statusDir = getStatusDir(workspaceRoot, status);
+    const entries = await readdir(statusDir, { withFileTypes: true });
+    const tasks = await Promise.all(entries
+        .filter((entry) => entry.isFile() && entry.name.endsWith('.json'))
+        .map(async (entry) => {
+        const filePath = path.join(statusDir, entry.name);
+        const task = await loadTaskFromPath(filePath);
+        return { task, status, filePath };
+    }));
+    return tasks;
+};
+export const listAllTasks = async (workspaceRoot) => {
+    const all = await Promise.all(STATUS_ORDER.map((status) => listTasksByStatus(workspaceRoot, status)));
+    return all.flat();
+};
+export const saveTask = async (workspaceRoot, status, task) => {
+    const filePath = getTaskPath(workspaceRoot, status, task.id);
+    await writeJsonAtomic(filePath, task);
+    return filePath;
+};
+export const moveTaskFile = async (workspaceRoot, taskId, fromStatus, toStatus) => {
+    const fromPath = getTaskPath(workspaceRoot, fromStatus, taskId);
+    const toPath = getTaskPath(workspaceRoot, toStatus, taskId);
+    await rename(fromPath, toPath);
+    return toPath;
+};

package/dist/lib/taskResolver.js

@@ -0,0 +1,31 @@
+import { resolveAlias } from './aliasRepo';
+import { findTaskPathById, listAllTasks, loadTaskFromPath } from './taskRepo';
+const stableRefPattern = /^[TR]-[A-Z0-9]{6}$/;
+export const resolveTaskId = async (workspaceRoot, identifier) => {
+    const aliasMatch = await resolveAlias(workspaceRoot, identifier);
+    if (aliasMatch) {
+        return aliasMatch;
+    }
+    if (stableRefPattern.test(identifier)) {
+        const tasks = await listAllTasks(workspaceRoot);
+        const match = tasks.find((stored) => stored.task.ref === identifier);
+        if (!match) {
+            throw new Error(`Task not found for ref: ${identifier}`);
+        }
+        return match.task.id;
+    }
+    const found = await findTaskPathById(workspaceRoot, identifier);
+    if (!found) {
+        throw new Error(`Task not found: ${identifier}`);
+    }
+    return identifier;
+};
+export const resolveTask = async (workspaceRoot, identifier) => {
+    const taskId = await resolveTaskId(workspaceRoot, identifier);
+    const found = await findTaskPathById(workspaceRoot, taskId);
+    if (!found) {
+        throw new Error(`Task not found: ${identifier}`);
+    }
+    const task = await loadTaskFromPath(found.filePath);
+    return { task, status: found.status, filePath: found.filePath };
+};

package/dist/lib/taskStore.js

@@ -0,0 +1,9 @@
+import { allocateAlias, writeAliases } from './aliasRepo';
+import { saveTask } from './taskRepo';
+export const createTaskInStore = async (workspaceRoot, task) => {
+    const prefix = task.type === 'pr_review' ? 'R' : 'T';
+    const { alias, aliases } = await allocateAlias(workspaceRoot, prefix, task.id);
+    await writeAliases(workspaceRoot, aliases);
+    await saveTask(workspaceRoot, task.status, task);
+    return { alias, task };
+};

package/dist/lib/time.js

@@ -0,0 +1,18 @@
+import { DateTime } from 'luxon';
+const DEFAULT_ZONE = 'Europe/Paris';
+export const nowIso = () => {
+    const value = DateTime.now().setZone(DEFAULT_ZONE).toISO();
+    if (!value) {
+        throw new Error('Failed to generate timestamp');
+    }
+    return value;
+};
+export const todayDate = (date) => {
+    const value = date
+        ? DateTime.fromISO(date, { zone: DEFAULT_ZONE }).toISODate()
+        : DateTime.now().setZone(DEFAULT_ZONE).toISODate();
+    if (!value) {
+        throw new Error('Failed to generate date');
+    }
+    return value;
+};

package/dist/lib/types.js

@@ -0,0 +1,3 @@
+export const taskStatuses = ['backlog', 'active', 'paused', 'completed', 'cancelled'];
+export const taskTypes = ['regular', 'pr_review'];
+export const taskActions = ['start', 'pause', 'complete', 'cancel'];

package/dist/lib/workspace.js

@@ -0,0 +1,58 @@
+import { access, mkdir } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { APP_DIR, APP_NAME, LOCK_DIR, STATUS_ORDER, TASKS_DIR } from './constants';
+const exists = async (filePath) => {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+export const findGitRoot = async (startDir) => {
+    let current = path.resolve(startDir);
+    while (true) {
+        if (await exists(path.join(current, '.git'))) {
+            return current;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            return null;
+        }
+        current = parent;
+    }
+};
+export const resolveGlobalWorkspaceRoot = () => {
+    const dataHome = process.env.XDG_DATA_HOME ?? path.join(homedir(), '.local', 'share');
+    return path.join(dataHome, APP_NAME);
+};
+export const resolveWorkspace = async (options) => {
+    if (options.store) {
+        return { root: path.resolve(options.store), kind: 'explicit' };
+    }
+    const cwd = options.cwd ?? process.cwd();
+    const repoRoot = await findGitRoot(cwd);
+    if (options.repo) {
+        if (!repoRoot) {
+            throw new Error('Not inside a git repository');
+        }
+        return { root: path.join(repoRoot, APP_DIR), kind: 'repo' };
+    }
+    if (options.global) {
+        return { root: resolveGlobalWorkspaceRoot(), kind: 'global' };
+    }
+    if (repoRoot) {
+        const repoWorkspace = path.join(repoRoot, APP_DIR);
+        if (await exists(repoWorkspace)) {
+            return { root: repoWorkspace, kind: 'repo' };
+        }
+    }
+    return { root: resolveGlobalWorkspaceRoot(), kind: 'global' };
+};
+export const ensureWorkspaceLayout = async (workspaceRoot) => {
+    await mkdir(path.join(workspaceRoot, TASKS_DIR), { recursive: true });
+    await mkdir(path.join(workspaceRoot, LOCK_DIR), { recursive: true });
+    await Promise.all(STATUS_ORDER.map((status) => mkdir(path.join(workspaceRoot, TASKS_DIR, status), { recursive: true })));
+};

package/dist/scripts/il.js

@@ -0,0 +1,396 @@
+#!/usr/bin/env node
+import path from 'node:path';
+import { Command } from 'commander';
+import { readAliases } from '../lib/aliasRepo';
+import { reconcileAliases } from '../lib/aliasReconcile';
+import { resolveGithubToken } from '../lib/config';
+import { APP_DIR } from '../lib/constants';
+import { applyTaskEdit } from '../lib/edit';
+import { formatTaskDetails, formatTaskListLine, buildAliasLookup } from '../lib/format';
+import { ensureLockIgnored } from '../lib/gitignore';
+import { withWorkspaceLock } from '../lib/lock';
+import { buildPrAttachment, fetchGitHubPr, parseGitHubPrUrl } from '../lib/pr';
+import { taskSchema } from '../lib/schema';
+import { taskMatchesQuery } from '../lib/search';
+import { buildTask } from '../lib/taskFactory';
+import { appendDayAssignment, appendLog, applyTransition, isAssignedOnDate } from '../lib/taskOperations';
+import { createTaskInStore } from '../lib/taskStore';
+import { listAllTasks, listTasksByStatus, moveTaskFile, saveTask } from '../lib/taskRepo';
+import { resolveTask } from '../lib/taskResolver';
+import { nowIso, todayDate } from '../lib/time';
+import { taskStatuses, taskTypes } from '../lib/types';
+import { ensureWorkspaceLayout, findGitRoot, resolveWorkspace } from '../lib/workspace';
+const program = new Command();
+const handleAction = (fn) => async (...args) => {
+    try {
+        await fn(...args);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`${message}\n`);
+        process.exitCode = 1;
+    }
+};
+const resolveWorkspaceFor = async (ensure) => {
+    const opts = program.opts();
+    const workspace = await resolveWorkspace({
+        store: opts.store,
+        global: opts.global,
+        repo: opts.repo
+    });
+    if (ensure) {
+        await ensureWorkspaceLayout(workspace.root);
+    }
+    return workspace.root;
+};
+const printLines = (lines) => {
+    if (lines.length === 0) {
+        process.stdout.write('No tasks.\n');
+        return;
+    }
+    process.stdout.write(`${lines.join('\n')}\n`);
+};
+const isTaskStatus = (value) => {
+    return taskStatuses.includes(value);
+};
+program
+    .name('il')
+    .description('Terminal task manager')
+    .option('--store <path>', 'explicit workspace path')
+    .option('--global', 'use global workspace')
+    .option('--repo', 'use repo workspace');
+program
+    .command('init')
+    .description('initialize repo workspace')
+    .action(handleAction(async () => {
+    const repoRoot = await findGitRoot(process.cwd());
+    if (!repoRoot) {
+        throw new Error('Not inside a git repository');
+    }
+    const workspaceRoot = path.join(repoRoot, APP_DIR);
+    await ensureWorkspaceLayout(workspaceRoot);
+    await ensureLockIgnored(repoRoot);
+    process.stdout.write(`Initialized workspace at ${workspaceRoot}\n`);
+}));
+program
+    .command('where')
+    .description('show resolved workspace')
+    .action(handleAction(async () => {
+    const opts = program.opts();
+    const workspace = await resolveWorkspace({
+        store: opts.store,
+        global: opts.global,
+        repo: opts.repo
+    });
+    process.stdout.write(`${workspace.root} (${workspace.kind})\n`);
+}));
+program
+    .command('add')
+    .description('add a task')
+    .argument('[title]', 'task title')
+    .option('--type <type>', 'regular|pr_review', 'regular')
+    .option('--url <url>', 'attach URL')
+    .option('--pr <url>', 'attach PR URL')
+    .action(handleAction(async (title, options, command) => {
+    const taskType = options.type;
+    if (!taskTypes.includes(taskType)) {
+        throw new Error(`Invalid type: ${taskType}`);
+    }
+    if (taskType === 'pr_review' && !options.pr) {
+        throw new Error('PR review tasks require --pr');
+    }
+    const workspaceRoot = await resolveWorkspaceFor(true);
+    await withWorkspaceLock(workspaceRoot, async () => {
+        let prAttachment;
+        let prTitle;
+        if (options.pr) {
+            const parsed = parseGitHubPrUrl(options.pr);
+            if (!parsed) {
+                throw new Error('Invalid PR URL');
+            }
+            const token = await resolveGithubToken(workspaceRoot);
+            const fetched = await fetchGitHubPr(parsed, token);
+            prAttachment = buildPrAttachment(parsed, fetched ?? undefined);
+            prTitle = fetched?.title ?? `PR #${parsed.number} ${parsed.repo.owner}/${parsed.repo.name}`;
+        }
+        const isExplicitTitle = Boolean(title);
+        let finalTitle = title ?? prTitle;
+        if (!finalTitle) {
+            throw new Error('Title is required when no PR URL is provided');
+        }
+        if (taskType === 'pr_review' && !isExplicitTitle) {
+            finalTitle = `Review: ${finalTitle}`;
+        }
+        const metadata = {
+            url: options.url,
+            pr: prAttachment
+        };
+        const task = buildTask({
+            type: taskType,
+            title: finalTitle,
+            metadata
+        });
+        taskSchema.parse(task);
+        const created = await createTaskInStore(workspaceRoot, task);
+        process.stdout.write(`Created ${created.alias} ${created.task.ref} ${created.task.title}\n`);
+    });
+}));
+program
+    .command('list')
+    .description('list tasks')
+    .argument('[status]', 'task status')
+    .action(handleAction(async (status, command) => {
+    const workspaceRoot = await resolveWorkspaceFor(true);
+    const aliases = await readAliases(workspaceRoot);
+    const aliasLookup = buildAliasLookup(aliases);
+    if (status && !isTaskStatus(status)) {
+        throw new Error(`Invalid status: ${status}`);
+    }
+    const statuses = status ? [status] : [...taskStatuses];
+    const lines = [];
+    for (const currentStatus of statuses) {
+        const stored = await listTasksByStatus(workspaceRoot, currentStatus);
+        for (const entry of stored) {
+            const alias = aliasLookup.get(entry.task.id);
+            let line = formatTaskListLine(entry.task, alias);
+            if (entry.task.metadata.pr?.fetched?.state) {
+                line += ` PR:${entry.task.metadata.pr.fetched.state}`;
+            }
+            lines.push(line);
+        }
+    }
+    printLines(lines);
+}));
+program
+    .command('show')
+    .description('show a task')
+    .argument('<id>', 'task identifier')
+    .action(handleAction(async (identifier, command) => {
+    const workspaceRoot = await resolveWorkspaceFor(true);
+    const stored = await resolveTask(workspaceRoot, identifier);
+    const aliases = await readAliases(workspaceRoot);
+    const aliasLookup = buildAliasLookup(aliases);
+    const alias = aliasLookup.get(stored.task.id);
+    process.stdout.write(`${formatTaskDetails(stored.task, alias)}\n`);
+}));
+const addTransitionCommand = (name) => {
+    program
+        .command(name)
+        .description(`${name} a task`)
+        .argument('<id>', 'task identifier')
+        .option('-m, --message <message>', 'custom log message')
+        .action(handleAction(async (identifier, options, command) => {
+        const workspaceRoot = await resolveWorkspaceFor(true);
+        await withWorkspaceLock(workspaceRoot, async () => {
+            const stored = await resolveTask(workspaceRoot, identifier);
+            const { task: updated, nextStatus } = applyTransition(stored.task, name, options.message);
+            await saveTask(workspaceRoot, stored.status, updated);
+            await moveTaskFile(workspaceRoot, updated.id, stored.status, nextStatus);
+            process.stdout.write(`Updated ${updated.ref} -> ${nextStatus}\n`);
+        });
+    }));
+};
+addTransitionCommand('start');
+addTransitionCommand('pause');
+addTransitionCommand('complete');
+addTransitionCommand('cancel');
+program
+    .command('log')
+    .description('append a log entry')
+    .argument('<id>', 'task identifier')
+    .argument('<message>', 'log message')
+    .option('--status <status>', 'include status in log entry')
+    .action(handleAction(async (identifier, message, options, command) => {
+    const workspaceRoot = await resolveWorkspaceFor(true);
+    const status = options.status;
+    if (status && !taskStatuses.includes(status)) {
+        throw new Error(`Invalid status: ${status}`);
+    }
+    await withWorkspaceLock(workspaceRoot, async () => {
+        const stored = await resolveTask(workspaceRoot, identifier);
+        const updated = appendLog(stored.task, message, status);
+        await saveTask(workspaceRoot, stored.status, updated);
+        process.stdout.write(`Logged on ${updated.ref}\n`);
+    });
+}));
+program
+    .command('edit')
+    .description('edit a task field')
+    .argument('<id>', 'task identifier')
+    .argument('<path>', 'dotted path')
+    .argument('<value>', 'new value')
+    .action(handleAction(async (identifier, dottedPath, value, command) => {
+    const workspaceRoot = await resolveWorkspaceFor(true);
+    await withWorkspaceLock(workspaceRoot, async () => {
+        const stored = await resolveTask(workspaceRoot, identifier);
+        const updated = applyTaskEdit(stored.task, dottedPath, value);
+        await saveTask(workspaceRoot, stored.status, updated);
+        process.stdout.write(`Updated ${updated.ref}\n`);
+    });
+}));
+program
+    .command('search')
+    .description('search tasks')
+    .argument('<query>', 'search query')
+    .action(handleAction(async (query, command) => {
+    const workspaceRoot = await resolveWorkspaceFor(true);
+    const aliases = await readAliases(workspaceRoot);
+    const aliasLookup = buildAliasLookup(aliases);
+    const tasks = await listAllTasks(workspaceRoot);
+    const lines = tasks
+        .filter((stored) => taskMatchesQuery(stored.task, query))
+        .map((stored) => {
+        const alias = aliasLookup.get(stored.task.id);
+        let line = formatTaskListLine(stored.task, alias);
+        if (stored.task.metadata.pr?.fetched?.state) {
+            line += ` PR:${stored.task.metadata.pr.fetched.state}`;
+        }
+        return line;
+    });
+    printLines(lines);
+}));
+program
+    .command('today')
+    .description('assign or list today tasks')
+    .argument('[id]', 'task identifier')
+    .option('--date <date>', 'YYYY-MM-DD')
+    .option('-m, --message <message>', 'assignment message')
+    .action(handleAction(async (identifier, options, command) => {
+    const workspaceRoot = await resolveWorkspaceFor(true);
+    const date = todayDate(options.date);
+    if (!identifier) {
+        const aliases = await readAliases(workspaceRoot);
+        const aliasLookup = buildAliasLookup(aliases);
+        const tasks = await listAllTasks(workspaceRoot);
+        const assigned = tasks.filter((stored) => isAssignedOnDate(stored.task, date));
+        const lines = assigned.map((stored) => formatTaskListLine(stored.task, aliasLookup.get(stored.task.id)));
+        printLines(lines);
+        return;
+    }
+    await withWorkspaceLock(workspaceRoot, async () => {
+        const stored = await resolveTask(workspaceRoot, identifier);
+        if (isAssignedOnDate(stored.task, date)) {
+            process.stdout.write(`Already assigned ${stored.task.ref} to ${date}\n`);
+            return;
+        }
+        const updated = appendDayAssignment(stored.task, date, 'assign', options.message);
+        await saveTask(workspaceRoot, stored.status, updated);
+        process.stdout.write(`Assigned ${updated.ref} to ${date}\n`);
+    });
+}));
+program
+    .command('untoday')
+    .description('unassign a task from today')
+    .argument('<id>', 'task identifier')
+    .option('--date <date>', 'YYYY-MM-DD')
+    .action(handleAction(async (identifier, options, command) => {
+    const workspaceRoot = await resolveWorkspaceFor(true);
+    const date = todayDate(options.date);
+    await withWorkspaceLock(workspaceRoot, async () => {
+        const stored = await resolveTask(workspaceRoot, identifier);
+        if (!isAssignedOnDate(stored.task, date)) {
+            process.stdout.write(`Already unassigned ${stored.task.ref} from ${date}\n`);
+            return;
+        }
+        const updated = appendDayAssignment(stored.task, date, 'unassign');
+        await saveTask(workspaceRoot, stored.status, updated);
+        process.stdout.write(`Unassigned ${updated.ref} from ${date}\n`);
+    });
+}));
+program
+    .command('attach-pr')
+    .description('attach PR metadata to a task')
+    .argument('<id>', 'task identifier')
+    .argument('<url>', 'PR URL')
+    .option('-m, --message <message>', 'log message')
+    .action(handleAction(async (identifier, url, options, command) => {
+    const workspaceRoot = await resolveWorkspaceFor(true);
+    await withWorkspaceLock(workspaceRoot, async () => {
+        const parsed = parseGitHubPrUrl(url);
+        if (!parsed) {
+            throw new Error('Invalid PR URL');
+        }
+        const token = await resolveGithubToken(workspaceRoot);
+        const fetched = await fetchGitHubPr(parsed, token);
+        const stored = await resolveTask(workspaceRoot, identifier);
+        const updated = {
+            ...stored.task,
+            metadata: {
+                ...stored.task.metadata,
+                pr: buildPrAttachment(parsed, fetched ?? stored.task.metadata.pr?.fetched)
+            },
+            updated_at: nowIso()
+        };
+        const logMessage = options.message ?? `Attached PR ${url}`;
+        const next = appendLog(updated, logMessage);
+        await saveTask(workspaceRoot, stored.status, next);
+        process.stdout.write(`Attached PR to ${next.ref}\n`);
+    });
+}));
+program
+    .command('refresh')
+    .description('refresh PR metadata')
+    .argument('<id>', 'task identifier')
+    .option('-m, --message <message>', 'log message')
+    .action(handleAction(async (identifier, options, command) => {
+    const workspaceRoot = await resolveWorkspaceFor(true);
+    await withWorkspaceLock(workspaceRoot, async () => {
+        const stored = await resolveTask(workspaceRoot, identifier);
+        const prUrl = stored.task.metadata.pr?.url;
+        if (!prUrl) {
+            process.stdout.write('No PR attached.\n');
+            return;
+        }
+        const parsed = parseGitHubPrUrl(prUrl);
+        if (!parsed) {
+            throw new Error('Invalid PR URL');
+        }
+        const token = await resolveGithubToken(workspaceRoot);
+        const fetched = await fetchGitHubPr(parsed, token);
+        if (!fetched) {
+            throw new Error('No GitHub token configured');
+        }
+        const baseUpdated = {
+            ...stored.task,
+            metadata: {
+                ...stored.task.metadata,
+                pr: buildPrAttachment(parsed, fetched)
+            },
+            updated_at: nowIso()
+        };
+        const previousState = stored.task.metadata.pr?.fetched?.state;
+        const nextState = fetched.state;
+        const isTerminal = stored.task.status === 'completed' || stored.task.status === 'cancelled';
+        let finalTask = baseUpdated;
+        let nextStatus = stored.status;
+        if (!isTerminal && previousState !== nextState) {
+            if (nextState === 'merged') {
+                const result = applyTransition(baseUpdated, 'complete', options.message ?? 'PR merged');
+                finalTask = result.task;
+                nextStatus = result.nextStatus;
+            }
+            else if (nextState === 'closed') {
+                const result = applyTransition(baseUpdated, 'cancel', options.message ?? 'PR closed without merge');
+                finalTask = result.task;
+                nextStatus = result.nextStatus;
+            }
+        }
+        await saveTask(workspaceRoot, stored.status, finalTask);
+        if (nextStatus !== stored.status) {
+            await moveTaskFile(workspaceRoot, finalTask.id, stored.status, nextStatus);
+        }
+        process.stdout.write(`Refreshed ${finalTask.ref}\n`);
+    });
+}));
+const aliasCommand = program.command('alias').description('alias helpers');
+aliasCommand
+    .command('reconcile')
+    .description('reconcile alias mapping')
+    .action(handleAction(async (command) => {
+    const workspaceRoot = await resolveWorkspaceFor(true);
+    await withWorkspaceLock(workspaceRoot, async () => {
+        await reconcileAliases(workspaceRoot);
+        process.stdout.write('Aliases reconciled.\n');
+    });
+}));
+program.parseAsync(process.argv);