teapot-coding-agent 0.29.19 → 0.29.21

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -12,6 +12,7 @@ import { EventLog, readEvents } from "../log/events.js";
12
12
  import { chat, chatStream } from "./llm.js";
13
13
  import { executeTool, toolSpecs, currentSkills, safeJoin, isContextOverflow, hasRunningBgShells, killBgShells } from "./tools.js";
14
14
  import { effortChoosable } from "./llm.js";
15
+ import { sessionTitleFrom } from "../session-title.js";
15
16
  import { skillRootsFingerprint, foreignSkillRoots } from "./skills.js";
16
17
  import { bus } from "../bus.js";
17
18
  /**
@@ -470,6 +471,11 @@ export class Agent {
470
471
  * Recovered from the log so the continuity survives a restart.
471
472
  */
472
473
  lastCompactSummary;
474
+ /**
475
+ * A short human title for this session (#155), derived from the operator's first
476
+ * prompt. Undefined until the log is read (or when there is no usable prompt).
477
+ */
478
+ sessionTitle;
473
479
  /** overflow recoveries used in the current turn; reset when a turn succeeds */
474
480
  overflowRecoveries = 0;
475
481
  /**
@@ -1004,6 +1010,13 @@ export class Agent {
1004
1010
  // the whole file (not just the current branch) to match what the runtime
1005
1011
  // panel showed before the restart.
1006
1012
  for (const e of own) {
1013
+ // #155: the title comes from the FIRST user prompt, which never changes, so
1014
+ // deriving it here is free — this loop already walks the whole log at
1015
+ // restore. Only the first one is taken; later prompts are a different
1016
+ // subject and would make the sidebar label churn under the reader.
1017
+ if (this.sessionTitle === undefined && e.type === "prompt" && e.data?.source === "user") {
1018
+ this.sessionTitle = sessionTitleFrom(e.data?.text) ?? undefined;
1019
+ }
1007
1020
  if (e.type === "state") {
1008
1021
  const d = e.data;
1009
1022
  if (d.detail === "llm turn start")
@@ -1374,6 +1387,10 @@ export class Agent {
1374
1387
  workspace: this.workspace,
1375
1388
  workspaceMissing: this.workspaceMissing,
1376
1389
  session: this.currentSession,
1390
+ // #155: a human label for this session, so the sidebar does not ask the
1391
+ // operator to read `teapot-10-16854917`. Absent when the first prompt had
1392
+ // no usable line — the UI then falls back to the id.
1393
+ ...(this.sessionTitle ? { sessionTitle: this.sessionTitle } : {}),
1377
1394
  branch: this.currentBranch,
1378
1395
  goal: {
1379
1396
  status: this.goal.status,
@@ -3745,6 +3762,29 @@ export class Agent {
3745
3762
  }
3746
3763
  sleepInterruptible(ms) {
3747
3764
  return new Promise((resolve) => {
3765
+ // #158-follow-up: a STOP that arrived before this sleep armed must end it.
3766
+ //
3767
+ // `stop()` releases the sleep through `this.wake`, which is a SINGLE slot
3768
+ // created when the sleep starts. So a stop issued during the `await` BEFORE
3769
+ // the sleep — the `log.append` of the retry note, which is a real disk write —
3770
+ // found `wake === null`, did nothing, and the sleep it was meant to cancel
3771
+ // then began on its own and ran to completion.
3772
+ //
3773
+ // MEASURED (stop injected while `log.append("error-retry")` was in flight):
3774
+ //
3775
+ // PRE : status=running live=true (the stop lands here)
3776
+ // POST: TIMEOUT after 6000ms status=error live=false
3777
+ //
3778
+ // — the operator's stop was swallowed and the agent sat in a 60s backoff,
3779
+ // which is the reported "LLM APIエラーリトライ中はstopが効かなかった".
3780
+ //
3781
+ // `stopRequested` is exactly the flag that means "do not continue", and it is
3782
+ // set SYNCHRONOUSLY by stop(), so testing it here closes the window without
3783
+ // caring how long the preceding await took. Every dialog through this helper
3784
+ // (the round backoff, the inner 5s/5s/30s staircase, the auto-continue delay)
3785
+ // inherits the fix.
3786
+ if (this.stopRequested)
3787
+ return resolve();
3748
3788
  const timer = setTimeout(() => {
3749
3789
  this.wake = null;
3750
3790
  resolve();
@@ -0,0 +1,183 @@
1
+ /**
2
+ * `.editorconfig` support (#109) — "edit_file の改行コードを .editorconfig に合わせて
3
+ * 正規化するとか?".
4
+ *
5
+ * ## What this DOES and deliberately does NOT do
6
+ *
7
+ * An EXISTING file already keeps its own line ending (#84, `detectEol`): the file's
8
+ * own bytes are the strongest possible evidence, and a `.editorconfig` that
9
+ * disagrees with the file on disk is nearly always stale relative to it. So this
10
+ * only supplies an answer where there was NONE:
11
+ *
12
+ * - a NEW file (nothing to detect), and
13
+ * - a MIXED-EOL file, where `detectEol` returns null on purpose because choosing
14
+ * a winner would be a silent whole-file rewrite.
15
+ *
16
+ * That keeps one rule: **the file's own content outranks configuration, which
17
+ * outranks the LF default.** `end_of_line = crlf` in a repo whose files are LF does
18
+ * not silently convert every file the agent touches.
19
+ *
20
+ * ## Why this is not a general editorconfig library
21
+ *
22
+ * The format has glob sections, brace expansion and a precedence order. Only the
23
+ * facts that change how a WRITE behaves are read — today that is `end_of_line`
24
+ * (plus `insert_final_newline`, which decides whether a new file ends in a
25
+ * newline). Anything else (`indent_style`, `charset`, …) has no in-repo consumer,
26
+ * and guessing at it would be untested surface.
27
+ */
28
+ import { readFileSync, existsSync } from "node:fs";
29
+ import path from "node:path";
30
+ const NONE = { eol: null };
31
+ /**
32
+ * Read the `.editorconfig` files that apply to `targetPath`, nearest-wins.
33
+ *
34
+ * Walks from the file's own directory up to the filesystem root so a nested
35
+ * `.editorconfig` overrides the repo root, which is the documented precedence.
36
+ * Sections are matched against the path RELATIVE to the file that declared them.
37
+ * A `root = true` stops the walk, as the format requires.
38
+ */
39
+ export function editorConfigFor(targetPath) {
40
+ const dirs = [];
41
+ let dir = path.dirname(path.resolve(targetPath));
42
+ for (;;) {
43
+ dirs.push(dir); // nearest first, which is also the precedence order
44
+ const parent = path.dirname(dir);
45
+ if (parent === dir)
46
+ break;
47
+ dir = parent;
48
+ }
49
+ // nearest-first, so the FIRST answer found wins; `root = true` truncates the walk
50
+ const applicable = [];
51
+ for (const d of dirs) {
52
+ const file = path.join(d, ".editorconfig");
53
+ if (!existsSync(file))
54
+ continue;
55
+ let text = "";
56
+ try {
57
+ text = readFileSync(file, "utf8");
58
+ }
59
+ catch {
60
+ continue;
61
+ }
62
+ applicable.push({ dir: d, text });
63
+ if (/^\s*root\s*=\s*true\s*$/im.test(text))
64
+ break; // this file is the root
65
+ }
66
+ // apply outermost -> innermost so the nearest file's value lands last
67
+ let out = NONE;
68
+ for (const { dir: declDir, text } of applicable.reverse()) {
69
+ const rel = path.relative(declDir, path.resolve(targetPath)).split(path.sep).join("/");
70
+ for (const section of parseSections(text)) {
71
+ if (!sectionMatches(section.pattern, rel))
72
+ continue;
73
+ const eol = section.props.get("end_of_line");
74
+ if (eol === "lf")
75
+ out = { ...out, eol: "\n" };
76
+ else if (eol === "crlf")
77
+ out = { ...out, eol: "\r\n" };
78
+ else if (eol === "cr")
79
+ out = { ...out, eol: "\r" };
80
+ const fn = section.props.get("insert_final_newline");
81
+ if (fn === "true")
82
+ out = { ...out, finalNewline: true };
83
+ else if (fn === "false")
84
+ out = { ...out, finalNewline: false };
85
+ }
86
+ }
87
+ return out;
88
+ }
89
+ /** `[section]` blocks with their `key = value` pairs. Comments and blanks ignored. */
90
+ function parseSections(text) {
91
+ const sections = [];
92
+ let current = null;
93
+ for (const raw of text.split(/\r\n|\r|\n/)) {
94
+ const line = raw.trim();
95
+ if (!line || line.startsWith("#") || line.startsWith(";"))
96
+ continue;
97
+ const header = line.match(/^\[(.+)\]$/);
98
+ if (header) {
99
+ current = { pattern: header[1].trim(), props: new Map() };
100
+ sections.push(current);
101
+ continue;
102
+ }
103
+ if (!current)
104
+ continue; // a property outside any section applies to nothing
105
+ const eq = line.indexOf("=");
106
+ if (eq === -1)
107
+ continue;
108
+ const key = line.slice(0, eq).trim().toLowerCase();
109
+ const value = line.slice(eq + 1).trim().toLowerCase();
110
+ // the FIRST value wins within a section (the format's rule)
111
+ if (key && value && !current.props.has(key))
112
+ current.props.set(key, value);
113
+ }
114
+ return sections;
115
+ }
116
+ /**
117
+ * Does an editorconfig glob match a POSIX-style relative path?
118
+ *
119
+ * Supports the parts that appear in real configs: `*` (within a segment), `**`
120
+ * (across segments), `?`, `{a,b}` alternation, and a `[abc]` class. A section with
121
+ * no `/` matches the BASENAME at any depth, which is the format's documented special
122
+ * case (and why `[*.md]` in a root file applies to `docs/x.md`).
123
+ */
124
+ export function sectionMatches(pattern, relPath) {
125
+ const anchored = pattern.includes("/");
126
+ const names = anchored ? [relPath] : [relPath.split("/").pop() ?? ""];
127
+ const body = anchored ? pattern.replace(/^\//, "") : pattern;
128
+ const re = globToRegExp(body, anchored);
129
+ return names.some((n) => re.test(n));
130
+ }
131
+ /** Translate an editorconfig glob into a RegExp. */
132
+ function globToRegExp(glob, anchored) {
133
+ let out = "";
134
+ for (let i = 0; i < glob.length; i++) {
135
+ const c = glob[i];
136
+ if (c === "*") {
137
+ if (glob[i + 1] === "*") {
138
+ // `**/` matches zero or more leading segments; a bare `**` is `.*`
139
+ if (glob[i + 2] === "/") {
140
+ out += "(?:.*/)?";
141
+ i += 2;
142
+ }
143
+ else {
144
+ out += ".*";
145
+ i += 1;
146
+ }
147
+ }
148
+ else {
149
+ out += "[^/]*"; // a single star never crosses a separator
150
+ }
151
+ continue;
152
+ }
153
+ if (c === "?") {
154
+ out += "[^/]";
155
+ continue;
156
+ }
157
+ if (c === "{") {
158
+ const close = glob.indexOf("}", i);
159
+ if (close !== -1) {
160
+ const alts = glob
161
+ .slice(i + 1, close)
162
+ .split(",")
163
+ .map((a) => a.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
164
+ out += `(?:${alts.join("|")})`;
165
+ i = close;
166
+ continue;
167
+ }
168
+ }
169
+ if (c === "[") {
170
+ const close = glob.indexOf("]", i);
171
+ if (close !== -1) {
172
+ // a character class is passed through as-is, minus any escaping surprises
173
+ out += glob.slice(i, close + 1).replace(/[\\^]/g, "\\$&");
174
+ i = close;
175
+ continue;
176
+ }
177
+ }
178
+ out += c.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
179
+ }
180
+ // anchored patterns are relative to the config's directory; a basename pattern
181
+ // already matched against the basename, so neither needs a prefix
182
+ return new RegExp(`^${out}$`, anchored ? "" : "");
183
+ }
@@ -8,6 +8,7 @@ import path from "node:path";
8
8
  import { discoverSkills, isValidSkillName, readSkillFile, saveSkill, SKILL_FILE, } from "./skills.js";
9
9
  import { isReasoningEffort } from "../model-meta.js";
10
10
  import { killTree, describeKill } from "./kill.js";
11
+ import { editorConfigFor } from "./editorconfig.js";
11
12
  const str = (v, fallback = "") => (typeof v === "string" ? v : fallback);
12
13
  const num = (v, fallback) => (typeof v === "number" ? v : fallback);
13
14
  function clip(s, max) {
@@ -18,6 +19,22 @@ function clip(s, max) {
18
19
  async function readText(p) {
19
20
  return fs.readFile(p, "utf8");
20
21
  }
22
+ /**
23
+ * Persist a `write_file` payload and report what line endings it used (#84/#109).
24
+ *
25
+ * Extracted so the two paths — a file whose own EOL was detected, and one decided
26
+ * by `.editorconfig` — share one write. The message names CRLF/CR only when a
27
+ * conversion actually happened, so an ordinary LF write stays quiet.
28
+ */
29
+ async function finishWrite(p, out, eol, original) {
30
+ await fs.writeFile(p, out, "utf8");
31
+ const converted = eol !== null && eol !== "\n" && out !== original;
32
+ return {
33
+ ok: true,
34
+ result: `wrote ${p} (${out.length} bytes)` +
35
+ (converted ? ` (kept ${eol === "\r\n" ? "CRLF" : "CR"} line endings)` : ""),
36
+ };
37
+ }
21
38
  /**
22
39
  * The file's dominant line ending, or null when it is mixed or empty.
23
40
  *
@@ -1177,16 +1194,21 @@ export const TOOLS = [
1177
1194
  // So an EXISTING file's dominant EOL is re-applied. detectEol returns null
1178
1195
  // for a mixed file, which is left untouched on purpose: choosing a winner
1179
1196
  // there would itself be the silent whole-file rewrite this prevents.
1197
+ //
1198
+ // #109: when the file CANNOT answer — it is new, or its EOL is mixed — ask
1199
+ // `.editorconfig` before falling back to LF. The order is deliberate: the
1200
+ // file's own bytes outrank configuration, which outranks the default. A
1201
+ // `end_of_line = crlf` in a repo whose files are all LF must not convert
1202
+ // every file the agent touches, so config is never consulted for a file that
1203
+ // already has an unambiguous ending.
1180
1204
  const before = await currentOrNull(p);
1181
- const eol = before === null ? null : detectEol(before);
1182
- const out = applyEol(args.content, eol);
1183
- await fs.writeFile(p, out, "utf8");
1184
- const converted = eol !== null && eol !== "\n" && out !== args.content;
1185
- return {
1186
- ok: true,
1187
- result: `wrote ${p} (${out.length} bytes)` +
1188
- (converted ? ` (kept ${eol === "\r\n" ? "CRLF" : "CR"} line endings)` : ""),
1189
- };
1205
+ const detected = before === null ? null : detectEol(before);
1206
+ if (detected !== null)
1207
+ return finishWrite(p, applyEol(args.content, detected), detected, args.content);
1208
+ const ec = editorConfigFor(p);
1209
+ const out = applyEol(args.content, ec.eol);
1210
+ const final = ec.finalNewline === true && out !== "" && !out.endsWith("\n") ? `${out}\n` : out;
1211
+ return finishWrite(p, final, ec.eol, args.content);
1190
1212
  },
1191
1213
  },
1192
1214
  {
package/dist/master.js CHANGED
@@ -3,8 +3,9 @@
3
3
  * Agents are in-process async loops (I/O bound only); all CPU-heavy work is
4
4
  * delegated to subprocesses managed by the bash tool with hard timeouts.
5
5
  */
6
- import { readFileSync, existsSync, mkdirSync, writeFileSync, readdirSync, statSync, lstatSync, renameSync, unlinkSync, openSync, closeSync, fsyncSync, } from "node:fs";
6
+ import { readFileSync, existsSync, mkdirSync, writeFileSync, readdirSync, statSync, lstatSync, renameSync, unlinkSync, openSync, closeSync, readSync, fsyncSync, } from "node:fs";
7
7
  import { randomUUID } from "node:crypto";
8
+ import { sessionTitleFrom } from "./session-title.js";
8
9
  import path from "node:path";
9
10
  import os from "node:os";
10
11
  import { expandTilde } from "./home.js";
@@ -1390,6 +1391,65 @@ When this task is done (or truly blocked), call finish() with a summary for @${p
1390
1391
  return null; // no log / unreadable head — cannot prove anything
1391
1392
  }
1392
1393
  }
1394
+ /**
1395
+ * A human title for a session dir, from its first user prompt (#155), or null.
1396
+ *
1397
+ * Reads in bounded chunks and stops at the FIRST prompt event of any source —
1398
+ * see the note in allSessions() for why that early exit is what makes this
1399
+ * affordable. A torn final line is skipped rather than parsed: a chunk boundary
1400
+ * can cut a JSON object in half, and that must not abort the scan.
1401
+ */
1402
+ sessionTitleOf(dirPath) {
1403
+ let fd;
1404
+ try {
1405
+ fd = openSync(path.join(dirPath, "chat.jsonl"), "r");
1406
+ const CHUNK = 16 * 1024;
1407
+ // cap per session so one enormous log cannot dominate boot
1408
+ const CAP = 256 * 1024;
1409
+ const buf = Buffer.alloc(CHUNK);
1410
+ let offset = 0;
1411
+ let carry = "";
1412
+ while (offset < CAP) {
1413
+ const n = readSync(fd, buf, 0, CHUNK, offset);
1414
+ if (n <= 0)
1415
+ break;
1416
+ offset += n;
1417
+ const lines = (carry + buf.subarray(0, n).toString("utf8")).split("\n");
1418
+ carry = lines.pop() ?? "";
1419
+ for (const l of lines) {
1420
+ if (!l)
1421
+ continue;
1422
+ let e;
1423
+ try {
1424
+ e = JSON.parse(l);
1425
+ }
1426
+ catch {
1427
+ continue; // torn line at a chunk boundary
1428
+ }
1429
+ if (e.type !== "prompt")
1430
+ continue;
1431
+ // a sub-agent session receives only harness prompts and is labelled from
1432
+ // its id, so a harness prompt is not a title
1433
+ if (e.data?.source !== "user")
1434
+ return null;
1435
+ return sessionTitleFrom(typeof e.data.text === "string" ? e.data.text : null);
1436
+ }
1437
+ }
1438
+ return null;
1439
+ }
1440
+ catch {
1441
+ return null; // no log / unreadable — fall back to the id
1442
+ }
1443
+ finally {
1444
+ if (fd !== undefined)
1445
+ try {
1446
+ closeSync(fd);
1447
+ }
1448
+ catch {
1449
+ /* already closed */
1450
+ }
1451
+ }
1452
+ }
1393
1453
  writeSessionManifest(dirPath, agentId) {
1394
1454
  try {
1395
1455
  const file = path.join(dirPath, "session.json");
@@ -1575,7 +1635,23 @@ When this task is done (or truly blocked), call finish() with a summary for @${p
1575
1635
  size = st.size;
1576
1636
  }
1577
1637
  catch { /* no log yet — still listable */ }
1578
- out.push({ id: d, agentId: owner, mtimeMs: m, sizeBytes: size });
1638
+ // #155: a title derived from the session's FIRST user prompt, so the
1639
+ // sidebar does not make the operator read `teapot-10-16854917`.
1640
+ //
1641
+ // Read here rather than from the live agent because boot leaves agents
1642
+ // STOPPED: their logs are not restored, so a title computed during restore
1643
+ // would be missing for every session the operator has not opened yet —
1644
+ // i.e. exactly the ones they need it for.
1645
+ //
1646
+ // BOUNDED and cheap: the scan stops at the FIRST `prompt` event of ANY
1647
+ // source, which is what makes it affordable. Measured over 817 real
1648
+ // sessions: 36 ms / 7.9 MB with the early exit, versus 804 ms / 169 MB
1649
+ // scanning to find a USER prompt specifically (sub-agents receive only
1650
+ // `harness` prompts, 758 of the 817, so they were what made it slow).
1651
+ // Those sub-sessions correctly produce no title — the sidebar already
1652
+ // labels them from their id via subAgentDisplayName().
1653
+ const title = this.sessionTitleOf(dirPath);
1654
+ out.push({ id: d, agentId: owner, mtimeMs: m, sizeBytes: size, ...(title ? { title } : {}) });
1579
1655
  }
1580
1656
  return out.sort((a, b) => b.mtimeMs - a.mtimeMs);
1581
1657
  }
@@ -1382,6 +1382,32 @@ export function buildApp(master) {
1382
1382
  });
1383
1383
  return app;
1384
1384
  }
1385
+ /**
1386
+ * Translate a wildcard bind address into the one `node:http` treats as dual-stack.
1387
+ *
1388
+ * MEASURED (node 26):
1389
+ *
1390
+ * listen({host: "0.0.0.0"}) -> bound 0.0.0.0 | family IPv4 ← IPv4 ONLY
1391
+ * listen({host: "::"}) -> bound :: | family IPv6 ← DUAL STACK
1392
+ * listen({}) -> bound :: ← DUAL STACK
1393
+ *
1394
+ * Over Tailscale that difference is decisive. The tailnet hands the host BOTH an
1395
+ * IPv4 address (100.x) and an IPv6 one (fd7a:…), and a client that resolves the
1396
+ * host to its IPv6 address CANNOT connect to an IPv4-only listener. Reported as
1397
+ * "0.0.0.0 にしても tailscale 越しに接続できない", with the tell that an IPv4-only
1398
+ * reverse proxy in front worked — exactly the asymmetry this produces:
1399
+ *
1400
+ * 0.0.0.0:7789 teapot LISTEN 0.0.0.0:7789 <- IPv4 only ✗ IPv6
1401
+ * *:7788 proxy LISTEN *:7788 <- dual stack ✓
1402
+ *
1403
+ * So `0.0.0.0` — the spelling every operator reaches for, and what `--help`
1404
+ * advertises — is translated to "no hostname" rather than passed through, because
1405
+ * a missing hostname is what makes Node bind `::` with `IPV6_V6ONLY` off.
1406
+ * `::` is passed through for the same reason.
1407
+ */
1408
+ export function dualStackHost(host) {
1409
+ return host === "0.0.0.0" || host === "::" ? undefined : host;
1410
+ }
1385
1411
  /**
1386
1412
  * Serve the app, returning a handle that can release the listening socket.
1387
1413
  *
@@ -1394,10 +1420,11 @@ export function buildApp(master) {
1394
1420
  */
1395
1421
  export function serveApp(app, port, host) {
1396
1422
  const wss = new WebSocketServer({ noServer: true });
1397
- const server = serve({ fetch: app.fetch, port, hostname: host, websocket: { server: wss } }, (info) => {
1423
+ const bindHost = dualStackHost(host);
1424
+ const server = serve({ fetch: app.fetch, port, hostname: bindHost, websocket: { server: wss } }, (info) => {
1398
1425
  const shown = host && host !== "0.0.0.0" && host !== "::"
1399
1426
  ? `http://${host}:${info.port}`
1400
- : `http://localhost:${info.port} (all interfaces)`;
1427
+ : `http://localhost:${info.port} (all interfaces, IPv4 + IPv6)`;
1401
1428
  console.log(`[teapot] master listening on ${shown}`);
1402
1429
  });
1403
1430
  return {
@@ -0,0 +1,79 @@
1
+ /**
2
+ * Session titles (#155) — "いろんなチャットアプリが実装してる、CodexやDSHとかも実装してそう /
3
+ * 自動生成とかサブエージェント名とかだとわかりにくい".
4
+ *
5
+ * The sidebar renders the raw session id, so `teapot-10-16854917` and
6
+ * `teapot-10-sub-trim-…` read as machinery: an operator with several sessions
7
+ * cannot tell which is which, and the timeline in front of them is the only clue.
8
+ *
9
+ * ## Why the FIRST USER PROMPT, and not a model call
10
+ *
11
+ * Every harness that does this derives the title from the opening request — it is
12
+ * already written by the human, it costs nothing, and it is stable (the first
13
+ * message of a session never changes, so the title never churns under the reader).
14
+ * A generated title would need an LLM call at exactly the moment the session starts,
15
+ * and would then drift as the session's real subject emerges.
16
+ *
17
+ * ## This is a DISPLAY rule, so it is deliberately lossy
18
+ *
19
+ * The input is arbitrary operator text: markdown, fenced code, URLs, a pasted
20
+ * 200-line log. A sidebar row is ~40 characters wide. So the rule takes the first
21
+ * MEANINGFUL line and trims it, rather than trying to summarise — a title that
22
+ * silently reorders what the operator wrote would be worse than a truncated one.
23
+ */
24
+ export function sessionTitleFrom(firstUserPrompt) {
25
+ if (typeof firstUserPrompt !== "string")
26
+ return null;
27
+ const lines = firstUserPrompt.split("\n");
28
+ // A fenced block is CONTENT, not a subject: the operator pasted a log or a diff
29
+ // and the prose follows it. Taking the first line inside the fence titled a
30
+ // session "log" (measured). So skip from an opening fence to its closing one.
31
+ let inFence = false;
32
+ let fence = "";
33
+ for (const raw of lines) {
34
+ const fenceOpen = raw.match(/^\s{0,3}(`{3,}|~{3,})/);
35
+ if (fenceOpen) {
36
+ const marker = fenceOpen[1];
37
+ if (!inFence) {
38
+ inFence = true;
39
+ fence = marker[0];
40
+ continue;
41
+ }
42
+ if (marker[0] === fence) {
43
+ inFence = false; // closing fence
44
+ continue;
45
+ }
46
+ }
47
+ if (inFence)
48
+ continue; // inside a block: its body is not a title
49
+ // strip the markdown that would otherwise eat the visible width: ATX headings,
50
+ // bullets/ordered markers, blockquotes, and emphasis characters
51
+ const line = raw
52
+ .replace(/^\s{0,3}#{1,6}\s*/, "")
53
+ .replace(/^\s{0,3}>\s?/, "")
54
+ .replace(/^\s*(?:[-*+]|\d+[.)])\s+/, "")
55
+ .replace(/[*_`~]/g, "")
56
+ .trim();
57
+ if (!line)
58
+ continue;
59
+ // a bare URL or a lone issue/PR reference carries no subject — the NEXT line
60
+ // usually does (a prompt may OPEN with "https://…" or a lone "2.")
61
+ if (/^https?:\/\/\S+$/.test(line))
62
+ continue;
63
+ if (/^#?\d+[.)]?$/.test(line))
64
+ continue;
65
+ return clip(line, 60);
66
+ }
67
+ return null;
68
+ }
69
+ /** Trim to `max` characters on a word boundary, with an ellipsis when cut. */
70
+ function clip(text, max) {
71
+ if (text.length <= max)
72
+ return text;
73
+ const cut = text.slice(0, max);
74
+ // prefer the last space so a word is not sliced in half; fall back to a hard cut
75
+ // when the line has no space at all (a single long token / CJK run)
76
+ const at = cut.lastIndexOf(" ");
77
+ const body = at > max * 0.6 ? cut.slice(0, at) : cut;
78
+ return `${body.trimEnd()}…`;
79
+ }
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "teapot-coding-agent",
3
- "version": "0.29.19",
3
+ "version": "0.29.21",
4
4
  "description": "A lightweight, always-on multi-agent harness for AI coding agents",
5
5
  "type": "module",
6
6
  "license": "AGPL-3.0-or-later",