@lumoai/cli 1.6.0 → 1.8.0

package/assets/skill.md

@@ -1102,6 +1102,27 @@ across multiple tasks → consider `lumo memory promote`.
 
 ## Session Management
 
+### Auto-bind at session start (from local git)
+
+When a session starts **without** a bound task, the `session-start` hook tries to
+infer the task from local git before falling back to the "请告诉我任务编号" prompt:
+
+- It reads the **current branch name** first (e.g. `lumo/LUM-145-...`), then the
+  **most recent commit subjects** (e.g. `... [LUM-145]`), extracting the first
+  `LUM-<n>`.
+- On a hit it binds the session to that task automatically (same `bind-task`
+  endpoint as `session attach`) and prints a single line:
+  `已自动绑定 LUM-145 - <title>（依据分支名/最近 commit）。如果不对，回复"不是"我就帮你解绑。`
+  The freshly-bound task's memory is injected too.
+- No match (detached HEAD, a non-lumo branch with no tagged commits, not a git
+  repo) or a failed bind (unknown task) → it degrades silently to the normal
+  unbound prompt.
+
+**Agent guidance:** if the user responds "不是" / "不对" / "wrong task" to an
+auto-bind line, run `lumo session detach` to clear the binding (then `session
+attach <LUM-N>` if they name the right one). No detach is needed when the
+auto-bound task is correct.
+
 ### `lumo session attach <identifier>` — bind the current session to a task
 
 Use this whenever the user mentions a task ID. The command is the only way to bind a session to a task.

package/dist/cli/src/commands/task-context.js

@@ -5,6 +5,7 @@ exports.formatTaskContextMarkdown = formatTaskContextMarkdown;
 const config_1 = require("../lib/config");
 const api_1 = require("../lib/api");
 const sanitize_1 = require("../lib/sanitize");
+const format_1 = require("../lib/format");
 async function taskContext(identifier) {
     if (!identifier) {
         console.error('Error: missing <identifier>. Usage: lumo task context <LUM-42>');
@@ -115,8 +116,8 @@ function formatTaskContextMarkdown(data, now) {
     lines.push('');
     for (const s of data.sessions) {
         const shortId = s.id.slice(0, 8);
-        const ago = relativeTime(new Date(s.lastActivityAt), now);
-        const dur = formatDuration(s.durationMs);
+        const ago = (0, format_1.relativeTime)(new Date(s.lastActivityAt), now);
+        const dur = (0, format_1.formatDuration)(s.durationMs);
         lines.push(`### Session ${shortId} · ${ago} · ${dur}`);
         lines.push(`**Summary**: ${(0, sanitize_1.sanitizeField)(s.headline)}`);
         if (s.unresolved.length > 0) {
@@ -128,36 +129,3 @@ function formatTaskContextMarkdown(data, now) {
     }
     return lines.join('\n');
 }
-function formatDuration(ms) {
-    if (ms < 60_000) {
-        return `${Math.max(1, Math.round(ms / 1000))}s`;
-    }
-    const totalMinutes = Math.round(ms / 60_000);
-    if (totalMinutes < 60)
-        return `${totalMinutes}min`;
-    const hours = Math.floor(totalMinutes / 60);
-    const minutes = totalMinutes % 60;
-    return minutes === 0 ? `${hours}h` : `${hours}h ${minutes}min`;
-}
-function relativeTime(then, now) {
-    const diffMs = now.getTime() - then.getTime();
-    const seconds = Math.floor(diffMs / 1000);
-    if (seconds < 60)
-        return 'just now';
-    const minutes = Math.floor(seconds / 60);
-    if (minutes < 60)
-        return `${minutes}min ago`;
-    const hours = Math.floor(minutes / 60);
-    if (hours < 24)
-        return `${hours}h ago`;
-    const days = Math.floor(hours / 24);
-    if (days === 1)
-        return 'yesterday';
-    if (days < 7)
-        return `${days} days ago`;
-    const weeks = Math.floor(days / 7);
-    if (weeks < 5)
-        return `${weeks}w ago`;
-    const months = Math.floor(days / 30);
-    return `${months}mo ago`;
-}

package/dist/cli/src/lib/format.js

@@ -1,7 +1,46 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatDuration = formatDuration;
+exports.relativeTime = relativeTime;
 exports.formatTaskListTable = formatTaskListTable;
 const sanitize_1 = require("./sanitize");
+/**
+ * Shared CLI time/duration formatters. Extracted from task-context.ts so the
+ * session-start recovery card (hook-runner.ts) can reuse the exact same shape.
+ */
+function formatDuration(ms) {
+    if (ms < 60_000) {
+        return `${Math.max(1, Math.round(ms / 1000))}s`;
+    }
+    const totalMinutes = Math.round(ms / 60_000);
+    if (totalMinutes < 60)
+        return `${totalMinutes}min`;
+    const hours = Math.floor(totalMinutes / 60);
+    const minutes = totalMinutes % 60;
+    return minutes === 0 ? `${hours}h` : `${hours}h ${minutes}min`;
+}
+function relativeTime(then, now) {
+    const diffMs = now.getTime() - then.getTime();
+    const seconds = Math.floor(diffMs / 1000);
+    if (seconds < 60)
+        return 'just now';
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}min ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    if (days === 1)
+        return 'yesterday';
+    if (days < 7)
+        return `${days} days ago`;
+    const weeks = Math.floor(days / 7);
+    if (weeks < 5)
+        return `${weeks}w ago`;
+    const months = Math.floor(days / 30);
+    return `${months}mo ago`;
+}
 /**
  * Render a task list as a fixed-width table. Each row:
  *   LUM-42  IN_PROGRESS  HIGH    project-name   Title here

package/dist/cli/src/lib/git-task.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchTaskIdentifier = matchTaskIdentifier;
+exports.extractTaskFromGit = extractTaskFromGit;
+const child_process_1 = require("child_process");
+/**
+ * How many recent commit subjects to scan when the branch name carries no
+ * task id (e.g. on a generic feature branch or detached HEAD).
+ */
+const DEFAULT_COMMIT_DEPTH = 20;
+const TASK_RE = /LUM-(\d+)/i;
+/**
+ * Pull the first `LUM-<n>` token out of arbitrary text (a branch name or a
+ * commit subject) and normalize it to upper case. Returns null when no task
+ * id is present. The leading `-` in the pattern means the bare word `lumo`
+ * never matches.
+ */
+function matchTaskIdentifier(text) {
+    const m = text.match(TASK_RE);
+    return m ? `LUM-${m[1]}` : null;
+}
+/**
+ * Run a git subcommand and return trimmed stdout, or '' on any failure
+ * (non-zero exit, spawn error, not a repository, timeout). Never throws.
+ */
+function gitOutput(args, cwd) {
+    try {
+        const r = (0, child_process_1.spawnSync)('git', args, {
+            cwd,
+            encoding: 'utf8',
+            timeout: 2000,
+        });
+        if (r.error || r.status !== 0)
+            return '';
+        return (r.stdout ?? '').trim();
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * Infer the task to work on from local git: prefer the current branch name
+ * (e.g. `lumo/LUM-145-...`), then fall back to the most recent commit
+ * subjects (e.g. `... [LUM-145]`). Returns null when nothing matches —
+ * detached HEAD (branch reads `HEAD`), a non-lumo branch with no tagged
+ * commits, or a directory that is not a git repository all degrade to null.
+ */
+function extractTaskFromGit(cwd, commitDepth = DEFAULT_COMMIT_DEPTH) {
+    const branch = gitOutput(['rev-parse', '--abbrev-ref', 'HEAD'], cwd);
+    const fromBranch = matchTaskIdentifier(branch);
+    if (fromBranch)
+        return { identifier: fromBranch, source: 'branch' };
+    const log = gitOutput(['log', '-n', String(commitDepth), '--format=%s'], cwd);
+    const fromLog = matchTaskIdentifier(log);
+    if (fromLog)
+        return { identifier: fromLog, source: 'commit' };
+    return null;
+}

package/dist/cli/src/lib/hook-runner.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatHookStdoutLines = formatHookStdoutLines;
+exports.formatAutoBindLine = formatAutoBindLine;
+exports.resolveSessionStartStdout = resolveSessionStartStdout;
 exports.runHook = runHook;
 exports.runHookWithBody = runHookWithBody;
 const config_1 = require("./config");
@@ -8,6 +10,8 @@ const api_1 = require("./api");
 const hook_log_1 = require("./hook-log");
 const sanitize_1 = require("./sanitize");
 const agent_1 = require("./agent");
+const git_task_1 = require("./git-task");
+const format_1 = require("./format");
 /**
  * Hard timeout for the hook POST. On timeout the request is aborted,
  * logged, and `runHook` exits 0 — Claude Code is never blocked beyond
@@ -66,7 +70,7 @@ function readStdin() {
  * The JSON lines conform to Claude Code's hookSpecificOutput envelope so the
  * runtime injects additionalContext into the conversation automatically.
  */
-function formatHookStdoutLines(path, responseBody) {
+function formatHookStdoutLines(path, responseBody, now = new Date()) {
     if (path === 'pre-tool-use') {
         if (responseBody == null || typeof responseBody !== 'object')
             return [];
@@ -99,21 +103,160 @@ function formatHookStdoutLines(path, responseBody) {
         lines.push(`[Lumo] session_id=${sessionId} | 当前任务: ${tb.taskIdentifier} - ${(0, sanitize_1.sanitizeField)(tb.taskTitle ?? '')}`);
     }
     else if (tb && tb.bound === false) {
-        lines.push(`[Lumo] session_id=${sessionId} | 当前未绑定任务。请告诉我你要处理的任务编号（如 LUM-42），或说"跳过"。`);
+        lines.push(unboundPromptLine(sessionId));
     }
-    // Memory + PR-review todos share one additionalContext block so Claude Code
-    // injects a single coherent context payload at session start.
-    const contextParts = [body.memorySection, body.reviewTodosSection].filter((s) => typeof s === 'string' && s !== '');
-    if (contextParts.length > 0) {
-        lines.push(JSON.stringify({
-            hookSpecificOutput: {
-                hookEventName: 'SessionStart',
-                additionalContext: contextParts.join('\n\n'),
-            },
-        }));
+    // Recovery card + memory + PR-review todos share one additionalContext block
+    // so Claude Code injects a single coherent context payload at session start.
+    // The card slots in first so it's the first thing the model reads.
+    const card = renderRecoveryCard(body.previousSession, tb?.taskIdentifier ?? '', now);
+    const envelope = sessionContextEnvelope([
+        card,
+        body.memorySection,
+        body.reviewTodosSection,
+    ]);
+    if (envelope)
+        lines.push(envelope);
+    return lines;
+}
+/**
+ * The plain-text line shown when a session starts without a bound task and
+ * no task could be inferred from local git — the user is asked to name one.
+ */
+function unboundPromptLine(sessionId) {
+    return `[Lumo] session_id=${sessionId} | 当前未绑定任务。请告诉我你要处理的任务编号（如 LUM-42），或说"跳过"。`;
+}
+const MAX_UNRESOLVED = 5;
+/**
+ * Render the "续上次进度" recovery card from the structured previousSession
+ * payload. Returns undefined when there's nothing to show (null payload or an
+ * empty headline). Free text (headline / unresolved) is sanitized here — it's
+ * LLM-generated and routed to Claude Code stdout. unresolved is capped at
+ * MAX_UNRESOLVED with a "+M more" pointer to `lumo task context`.
+ */
+function renderRecoveryCard(prev, taskIdentifier, now) {
+    if (!prev || typeof prev.headline !== 'string' || prev.headline === '') {
+        return undefined;
     }
+    const ago = (0, format_1.relativeTime)(new Date(prev.lastActivityAt), now);
+    const dur = (0, format_1.formatDuration)(prev.durationMs);
+    const lines = [
+        `## 续上次进度 (上一段 session · ${ago} · ${dur})`,
+        `上次干到：${(0, sanitize_1.sanitizeField)(prev.headline)}`,
+    ];
+    const unresolved = Array.isArray(prev.unresolved) ? prev.unresolved : [];
+    if (unresolved.length > 0) {
+        lines.push('未完成：');
+        const shown = unresolved.slice(0, MAX_UNRESOLVED);
+        for (const u of shown)
+            lines.push(`- ${(0, sanitize_1.sanitizeField)(u)}`);
+        const extra = unresolved.length - shown.length;
+        if (extra > 0) {
+            lines.push(`- …(+${extra} more, 跑 lumo task context ${taskIdentifier} 查看全部)`);
+        }
+    }
+    return lines.join('\n');
+}
+/**
+ * Wrap any non-empty context parts into a single SessionStart
+ * hookSpecificOutput envelope so Claude Code injects one coherent
+ * additionalContext payload. Returns null when there is nothing to inject.
+ */
+function sessionContextEnvelope(parts) {
+    const filled = parts.filter((s) => typeof s === 'string' && s !== '');
+    if (filled.length === 0)
+        return null;
+    return JSON.stringify({
+        hookSpecificOutput: {
+            hookEventName: 'SessionStart',
+            additionalContext: filled.join('\n\n'),
+        },
+    });
+}
+/**
+ * The single status line printed after a successful auto-bind. Explains which
+ * git signal (branch name vs recent commit) it relied on and how to undo it.
+ */
+function formatAutoBindLine(sessionId, match, result) {
+    const basis = match.source === 'branch' ? '分支名' : '最近 commit';
+    const identifier = result.taskIdentifier ?? match.identifier;
+    return `[Lumo] session_id=${sessionId} | 已自动绑定 ${identifier} - ${(0, sanitize_1.sanitizeField)(result.taskTitle ?? '')}（依据${basis}）。如果不对，回复"不是"我就帮你解绑。`;
+}
+/**
+ * Build the stdout lines for a session-start response, including the LUM-145
+ * auto-bind behavior: when the server reports no binding, infer the task from
+ * local git and bind it; on a hit, print the auto-bind line (plus the freshly
+ * bound task's memory). Falls back to the unbound prompt when nothing matches
+ * or the bind fails. Bound sessions reuse the existing formatting.
+ */
+async function resolveSessionStartStdout(responseBody, deps, now = new Date()) {
+    if (responseBody == null || typeof responseBody !== 'object')
+        return [];
+    const body = responseBody;
+    if (!body.sessionId)
+        return [];
+    const sessionId = body.sessionId;
+    const tb = body.taskBinding;
+    if (tb && tb.bound === true) {
+        return formatHookStdoutLines('session-start', responseBody, now);
+    }
+    if (!tb || tb.bound !== false)
+        return [];
+    const match = deps.extractTask();
+    if (!match)
+        return [unboundPromptLine(sessionId)];
+    const result = await deps.bindTask(sessionId, match.identifier);
+    if (!result.ok)
+        return [unboundPromptLine(sessionId)];
+    const lines = [formatAutoBindLine(sessionId, match, result)];
+    const card = renderRecoveryCard(result.previousSession, result.taskIdentifier ?? match.identifier, now);
+    // bind-task only returns memory + previousSession (not reviewTodosSection) —
+    // the auto-bind endpoint never built PR-review todos. Keep that scope here;
+    // surfacing review todos on the auto-bind path is a separate change.
+    const envelope = sessionContextEnvelope([card, result.memorySection]);
+    if (envelope)
+        lines.push(envelope);
     return lines;
 }
+/**
+ * POST the inferred task binding to the same `bind-task` endpoint that
+ * `lumo session attach` uses. Guarded by the same short timeout as the hook
+ * POST so the extra round trip can never make session-start hang. Any
+ * failure (404 unknown task, network, timeout, non-2xx) returns
+ * `{ ok: false }`, which routes the caller back to the unbound prompt.
+ */
+async function postBindTask(sessionId, identifier, token, apiUrl) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), TIMEOUT_MS);
+    try {
+        const url = `${(0, api_1.trimTrailingSlash)(apiUrl)}/api/sessions/${encodeURIComponent(sessionId)}/bind-task`;
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${token}`,
+            },
+            body: JSON.stringify({ taskIdentifier: identifier }),
+            signal: controller.signal,
+        });
+        if (!res.ok)
+            return { ok: false };
+        const body = (await res.json());
+        return {
+            ok: true,
+            taskIdentifier: body.taskIdentifier,
+            taskTitle: body.taskTitle,
+            memorySection: body.memorySection,
+            previousSession: body.previousSession ?? undefined,
+        };
+    }
+    catch (err) {
+        (0, hook_log_1.logHookError)('[session-start] auto-bind', err);
+        return { ok: false };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
 /**
  * POST the hook body to /api/hooks/<path> with a short timeout. All errors
  * — credential missing, network failure, timeout, non-2xx — are routed to
@@ -174,12 +317,19 @@ async function runHookWithBody(path, body, agentToken) {
             }
             else if (path === 'session-start' || path === 'pre-tool-use') {
                 // Paths that turn the response body into stdout for Claude Code:
-                //   session-start → bind status + injected context
+                //   session-start → bind status + injected context (incl. LUM-145
+                //                   auto-bind from local git when unbound)
                 //   pre-tool-use  → parallel-edit collision warning (LUM-150 ③)
                 // Only after a 2xx so a transient server failure emits nothing.
                 try {
                     const responseBody = await res.json();
-                    for (const line of formatHookStdoutLines(path, responseBody)) {
+                    const lines = path === 'session-start'
+                        ? await resolveSessionStartStdout(responseBody, {
+                            extractTask: () => (0, git_task_1.extractTaskFromGit)(),
+                            bindTask: (sessionId, identifier) => postBindTask(sessionId, identifier, creds.token, apiUrl),
+                        })
+                        : formatHookStdoutLines(path, responseBody);
+                    for (const line of lines) {
                         process.stdout.write(line + '\n');
                     }
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumoai/cli",
-  "version": "1.6.0",
+  "version": "1.8.0",
   "description": "Lumo CLI — manage tasks and sessions from the terminal",
   "license": "MIT",
   "author": "cli@uselumo.ai",