kiro-telegram-bot 1.6.0 → 1.7.2

package/src/config.ts

@@ -7,34 +7,44 @@ import { homedir } from "node:os";
 import { dirname, isAbsolute, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
-loadDotenv();
-
 /** Absolute path to the installed bot code (one level above src/). For a global
  *  npm install this lives inside node_modules — code lives here, never user data. */
 export const PROJECT_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 
+/** Canonical, path-independent home for this bot's `.env`, `logs/`, `data/` and
+ *  the single-instance locks: `~/.kiro/tg`. Used whenever the bot is started
+ *  without an explicit instance dir and there's no `.env` in the current folder,
+ *  so the SAME configuration is found no matter which directory you launch from. */
+export const CANONICAL_DIR = join(homedir(), ".kiro", "tg");
+
 /**
- * Directory holding THIS instance's `.env`, `logs/` and `data/`. Resolution:
+ * Directory holding THIS instance's `.env`, `logs/` and `data/`. Resolution
+ * (first match wins):
  *   1. `--instance <dir>` argv — set by the installed background service,
- *   2. `KIRO_TG_CWD` env — set by the `kiro-tg` launcher to the user's cwd,
- *   3. the current working directory.
- * For a cloned/zip checkout run in place this equals PROJECT_ROOT (so behaviour
- * is unchanged), while a global `npm i -g` install keeps user data in the
- * user's folder rather than inside node_modules.
+ *   2. `KIRO_TG_DIR` env — an explicit override,
+ *   3. `KIRO_TG_CWD` env — the legacy launcher variable,
+ *   4. the current folder, IF it already contains a `.env` (an explicit
+ *      per-folder bot — keeps cloned/zip checkouts working in place),
+ *   5. the canonical `~/.kiro/tg` home — the path-independent default, so a
+ *      `.env` created once is loaded no matter where the bot is started from.
  */
 export const INSTANCE_DIR = resolveInstanceDir();
 
+/** Absolute path to the `.env` this instance loads (and that `setup` writes). */
+export const ENV_PATH = join(INSTANCE_DIR, ".env");
+
 function resolveInstanceDir(): string {
   const flag = process.argv.indexOf("--instance");
   if (flag !== -1 && process.argv[flag + 1]) return resolve(process.argv[flag + 1]!);
-  const env = process.env.KIRO_TG_CWD?.trim();
-  if (env) return resolve(expandHome(env));
-  return process.cwd();
+  const envDir = process.env.KIRO_TG_DIR?.trim() || process.env.KIRO_TG_CWD?.trim();
+  if (envDir) return resolve(expandHome(envDir));
+  if (existsSync(join(process.cwd(), ".env"))) return process.cwd();
+  return CANONICAL_DIR;
 }
 
-// Re-load .env from the instance directory (the first call above also primed
-// process.env from cwd, which is the same place for an in-place checkout).
-loadDotenv({ path: join(INSTANCE_DIR, ".env") });
+// Load .env from the resolved instance directory. dotenv does NOT override
+// variables already present in the environment (the launcher/service env wins).
+loadDotenv({ path: ENV_PATH });
 
 function expandHome(p: string): string {
   if (p === "~") return homedir();
@@ -112,6 +122,11 @@ export interface AppConfig {
   mcpProbeConcurrency: number;
   /** Show subagent (crew) activity while the main agent waits on them. */
   showSubagents: boolean;
+  /** Ask the agent to emit a `{progress: N%}` marker and render it as a bar. */
+  showProgress: boolean;
+  /** When the agent emits no `{progress}` marker, show a bot-computed fallback
+   *  bar derived from real activity (tool calls, streamed output, elapsed). */
+  progressFallback: boolean;
   /** Deliver a turn's "Done" summary to the chat even when that session is in
    *  the background (you've switched to another session). */
   notifyOtherSessions: boolean;
@@ -119,6 +134,10 @@ export interface AppConfig {
   autoUpdate: boolean;
   /** How often to check npm for a newer version (ms). */
   updateCheckMs: number;
+  /** Enforce a single running instance per bot token: on startup, a still-alive
+   *  ghost/duplicate holding the lock is terminated so the fresh process (with
+   *  the current `.env`) is the only Telegram getUpdates consumer. */
+  singleInstance: boolean;
 }
 
 export function loadConfig(): AppConfig {
@@ -182,9 +201,12 @@ export function loadConfig(): AppConfig {
     mcpProbeTimeoutMs: num(process.env.MCP_PROBE_TIMEOUT_MS, 8000),
     mcpProbeConcurrency: num(process.env.MCP_PROBE_CONCURRENCY, 6),
     showSubagents: bool(process.env.SHOW_SUBAGENTS, true),
+    showProgress: bool(process.env.SHOW_PROGRESS, true),
+    progressFallback: bool(process.env.PROGRESS_FALLBACK, true),
     notifyOtherSessions: bool(process.env.NOTIFY_OTHER_SESSIONS, true),
     autoUpdate: bool(process.env.AUTO_UPDATE, true),
     updateCheckMs: num(process.env.UPDATE_CHECK_MS, 3_600_000),
+    singleInstance: bool(process.env.KIRO_TG_SINGLE_INSTANCE, true),
   };
 
   return cfg;

package/src/index.ts

@@ -5,7 +5,9 @@
  */
 import { AcpClient } from "./acp/client.js";
 import { createBot } from "./bot/bot.js";
-import { loadConfig } from "./config.js";
+import { CANONICAL_DIR, loadConfig } from "./config.js";
+import { InstanceLock } from "./app/instance-lock.js";
+import { join } from "node:path";
 import { createLogger, enableFileLogging, setLogLevel } from "./logger.js";
 
 async function main(): Promise<void> {
@@ -17,6 +19,17 @@ async function main(): Promise<void> {
   enableFileLogging(cfg.logFile);
   const log = createLogger("main");
 
+  // Single-instance guard: kill any ghost/duplicate already polling this token
+  // (the usual cause of a stale "Not authorized" — an old process with an
+  // outdated .env). A plain manual start yields to a running background service.
+  const lock = new InstanceLock(cfg.token, join(CANONICAL_DIR, "locks"), process.env.KIRO_TG_SUPERVISED === "1");
+  if (cfg.singleInstance && !(await lock.acquire())) {
+    process.stdout.write(
+      "\u26D4 Another Kiro Telegram Bot is already running for this token (a background service). Use `kiro-tg restart`, or `kiro-tg stop` first.\n",
+    );
+    process.exit(0);
+  }
+
   log.info("starting Kiro Telegram Bot");
   log.info(`workspace: ${cfg.workspace}`);
   log.info(`kiro-cli:  ${cfg.kiroCliPath}`);
@@ -46,6 +59,7 @@ async function main(): Promise<void> {
     registry.disposeAll();
     void bot.stop().catch(() => {});
     acp.stop();
+    lock.release();
     setTimeout(() => process.exit(code), 500);
   };
 

package/src/render/device-flow.ts

@@ -0,0 +1,76 @@
+/**
+ * Parse the (noisy) stdout of `kiro-cli login --use-device-flow` into the few
+ * stable fields worth showing: the verification URL, the device code, and
+ * whether login completed.
+ *
+ * The CLI animates a spinner ("▰▱▱… Logging in…") by rewriting one terminal
+ * line with carriage returns. With stdio piped the `\r`s are stripped, so those
+ * frames pile up into one long string ("▰▱▱… Logging in…▰▰▱… Logging in…"). We
+ * discard that noise and surface only meaningful values, which the bot renders
+ * on a single, self-animated status line instead of echoing every frame.
+ */
+
+/** Block/braille glyphs the CLI uses to draw progress bars / spinners. */
+const BAR_CHARS = "▰▱▮▯■□▪▫●○◐◓◑◒⣾⣽⣻⢿⡿⣟⣯⣷⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏";
+const BAR_CLASS = `[${BAR_CHARS}]`;
+
+export interface DeviceFlow {
+  /** Verification URL, if the CLI printed one. */
+  url?: string;
+  /** Device/user code (e.g. `VKKH-PPMX`), if present. */
+  code?: string;
+  /** True once the CLI reports a completed login. */
+  loggedIn: boolean;
+  /** A short error line, if the output looks like a failure. */
+  error?: string;
+}
+
+/** Remove spinner frames, repeated "Logging in…" and stray bar glyphs. */
+export function stripSpinner(raw: string): string {
+  return raw
+    .replace(/\r/g, "")
+    .replace(new RegExp(`${BAR_CLASS}+\\s*Logging in[.\\u2026]*`, "gi"), "")
+    .replace(/Logging in[.\u2026]*/gi, "")
+    .replace(new RegExp(`${BAR_CLASS}+`, "g"), "")
+    .replace(/[ \t]+\n/g, "\n")
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+}
+
+const ERROR_RE = /error|failed|denied|expired|invalid|unable|timed out/i;
+
+export function parseDeviceFlow(raw: string): DeviceFlow {
+  const text = stripSpinner(raw);
+
+  // Collect every URL, then prefer the device-verification one (it embeds the
+  // user code, so it's directly clickable). `firstUrl` guards against two URLs
+  // run together with no separator (terminal echo), which would otherwise be
+  // matched as one giant token.
+  const urls = (text.match(/https?:\/\/[^\s'"<>)\]]+/gi) ?? []).map(firstUrl);
+  const url = urls.find((u) => /user_code=|\/device/i.test(u)) ?? urls[0];
+
+  // Prefer the unambiguous XXXX-XXXX shape; fall back to a "Code:" label.
+  const code =
+    text.match(/\b[A-Z0-9]{4}-[A-Z0-9]{4}\b/)?.[0] ??
+    text.match(/Code[:\s]+([A-Z0-9][A-Z0-9-]{3,})/)?.[1];
+
+  const loggedIn = /logged in|login successful|successfully logged in/i.test(text);
+
+  const error =
+    !loggedIn && ERROR_RE.test(text)
+      ? text
+          .split("\n")
+          .map((l) => l.trim())
+          .reverse()
+          .find((l) => ERROR_RE.test(l))
+      : undefined;
+
+  return { url, code, loggedIn, error };
+}
+
+/** Trim a token that accidentally contains two concatenated URLs down to the
+ *  first one (e.g. "https://x/starthttps://x/start" → "https://x/start"). */
+function firstUrl(u: string): string {
+  const second = u.indexOf("http", 4);
+  return second > 0 ? u.slice(0, second) : u;
+}

package/src/render/progress-estimate.ts

@@ -0,0 +1,63 @@
+/**
+ * Bot-side FALLBACK task-progress estimate.
+ *
+ * The primary progress signal is the `{progress: N%}` marker the agent is asked
+ * to emit (see PROGRESS_DIRECTIVE). But that marker is only an *instruction* the
+ * model can ignore — weaker/free models and long, tool-heavy turns frequently
+ * never emit one, leaving the bar empty for the whole turn. This module gives
+ * the bot a way to show a live, advancing bar anyway, derived ONLY from real,
+ * observable work signals (never random):
+ *
+ *   • completed tool calls   — each is concrete progress, weighted most
+ *   • streamed prose chars    — the agent explaining / answering
+ *   • streamed thinking chars — reasoning volume (weighted least)
+ *   • elapsed time            — a small, slow contribution so a quiet turn still creeps
+ *
+ * The estimate is monotonic by construction (every input only grows during a
+ * turn) and asymptotically capped well below 100 while running, so the bar never
+ * claims "done" on its own — the caller pushes 100 only when the turn actually
+ * completes. The agent's own marker, when present, always takes precedence.
+ */
+
+/** Observable, monotonically-increasing signals collected during one turn. */
+export interface ActivitySignals {
+  /** Number of tool calls / subagent transitions shown this turn. */
+  toolCalls: number;
+  /** Characters of agent prose streamed this turn. */
+  outputChars: number;
+  /** Characters of agent thinking streamed this turn. */
+  thoughtChars: number;
+  /** Milliseconds since the turn started. */
+  elapsedMs: number;
+}
+
+/** Hard ceiling for the fallback while a turn is still running. The agent (or
+ *  turn completion) is the only thing allowed to take the bar to 100. */
+export const FALLBACK_RUNNING_CAP = 90;
+
+/** Minimum shown once *any* work signal is present (so the bar never sits at 0
+ *  while the agent is clearly busy). */
+const FALLBACK_FLOOR = 5;
+
+/** Controls how quickly the asymptotic curve approaches the cap. Larger = slower. */
+const CURVE_K = 6;
+
+/**
+ * Map real work signals to a 0–FALLBACK_RUNNING_CAP estimate via a saturating
+ * curve `cap * (1 - e^(-units/K))`. Tool calls dominate because each is a
+ * discrete, completed step; text volume and elapsed time add gentle, diminishing
+ * contributions so a turn that's only thinking still advances slowly.
+ */
+export function estimateProgress(s: ActivitySignals): number {
+  const units =
+    Math.max(0, s.toolCalls) * 1.0 +
+    Math.max(0, s.outputChars) / 400 +
+    Math.max(0, s.thoughtChars) / 1500 +
+    Math.max(0, s.elapsedMs) / 30_000;
+
+  if (units <= 0) return 0;
+
+  const raw = FALLBACK_RUNNING_CAP * (1 - Math.exp(-units / CURVE_K));
+  const clamped = Math.min(FALLBACK_RUNNING_CAP, Math.max(FALLBACK_FLOOR, raw));
+  return Math.round(clamped);
+}

package/src/render/progress.ts

@@ -0,0 +1,80 @@
+/**
+ * Task-progress support: parse the `{progress: N%}` marker the agent appends to
+ * its messages, strip it from the visible text, and render a green loading bar.
+ *
+ * The agent is asked (see PROGRESS_DIRECTIVE) to end each message with a marker
+ * like `{progress: 65%}`. The bot extracts the latest value, removes the marker
+ * so it never shows raw, and renders a 0–100% bar (filled = 🟩, empty = ⬜) on
+ * the live message, in session cards, and in the pinned status panel.
+ */
+
+/** Matches a complete marker: `{progress: 65%}`, `{ progress:65 }`, etc. */
+const PROGRESS_RE = /\{\s*progress\s*:\s*(\d{1,3})\s*%?\s*\}/gi;
+/** Matches a trailing, not-yet-closed marker mid-stream (e.g. `…{progress: 6`). */
+const PARTIAL_TAIL_RE = /\{\s*progress\b[^}]*$/i;
+
+const FILLED = "\u{1F7E9}"; // 🟩
+const EMPTY = "\u2B1C"; // ⬜
+const SEGMENTS = 10;
+
+/**
+ * The instruction appended to prompts so the agent emits a progress marker.
+ *
+ * IMPORTANT for maintainers:
+ *  - The ONLY brace token may be the literal `{progress: N%}` with the letter
+ *    `N` (never a digit). A digit inside braces would be parsed by PROGRESS_RE
+ *    as a real value AND would break the exact-string strip in
+ *    `sessions/history.ts` (`cleanStoredText`).
+ *  - Keep this string "tidy-idempotent": no trailing spaces on any line, no run
+ *    of 3+ newlines, and no trailing whitespace at the end. `cleanStoredText`
+ *    runs `extractProgress` (which calls `tidy()`) before stripping the
+ *    directive by exact match, so any whitespace `tidy()` would rewrite must
+ *    not appear here, or the directive leaks into history/previews.
+ */
+export const PROGRESS_DIRECTIVE = [
+  "PROGRESS REPORTING IS MANDATORY ON EVERY SINGLE MESSAGE YOU SEND \u2014 NO EXCEPTIONS.",
+  "Rule 1 (format): finish EVERY message with a task-completion marker on its own final line, in EXACTLY this format, with nothing at all after it: {progress: N%}",
+  "N is a plain integer from 0 to 100 (no decimals, no ranges, no math). The marker is the very last thing in the message: no text, punctuation, spaces, emoji, backticks, or code fences may follow it, and it must NEVER be placed inside a code block or quote.",
+  "Rule 2 (frequency): emit the marker on your FIRST message, on EVERY intermediate message, after EVERY tool call or group of tool calls, around any subagent delegation, and on your FINAL message. Short replies, plans, questions, acknowledgements, clarifications, errors, and tool-only or status updates are NOT exempt \u2014 if you output any text at all, it ends with the marker. Do not batch it only into the last message.",
+  "Rule 3 (compute it for real, never random): before each message, decompose the overall task into the concrete steps it actually needs (understand the request, read the relevant files, each separate edit, run the build/tests, fix failures, verify) and set N = round(100 * completed_steps / total_steps), re-estimated fresh from the real current state each time.",
+  "Rule 4 (be granular and honest): start low (about 5 to 15 on your first message; use 0 only when literally nothing is started yet), then climb in realistic increments that mirror real progress. Do NOT jump from a low number straight to a high one, and do NOT keep repeating the same number across messages while work is clearly advancing.",
+  "Rule 5 (monotonic): within one task the number must NEVER decrease \u2014 each marker is greater than or equal to the previous one you emitted.",
+  "Rule 6 (terminal): report 100 ONLY when the entire task is fully complete and verified with nothing left to do. While ANY work, fix, verification, question, or follow-up remains, cap the number at 99.",
+  "The client parses this marker, removes it from the visible text, and renders it as a live progress bar, so its presence on every message and the accuracy of the number both matter.",
+].join("\n");
+
+export interface ProgressExtract {
+  /** Latest progress value found (0–100), or undefined if none. */
+  value?: number;
+  /** The input text with all progress markers removed. */
+  cleaned: string;
+}
+
+/** Pull the latest `{progress: N%}` value out of `text` and strip every marker
+ *  (plus any trailing half-streamed marker so it never flashes raw). */
+export function extractProgress(text: string): ProgressExtract {
+  let value: number | undefined;
+  let cleaned = text.replace(PROGRESS_RE, (_m, digits: string) => {
+    const v = Math.max(0, Math.min(100, Number.parseInt(digits, 10)));
+    if (Number.isFinite(v)) value = v; // keep the LAST occurrence (most recent)
+    return "";
+  });
+  cleaned = cleaned.replace(PARTIAL_TAIL_RE, "");
+  return { value, cleaned: tidy(cleaned) };
+}
+
+/** Tidy whitespace left behind by a removed marker. */
+function tidy(s: string): string {
+  return s
+    .replace(/[ \t]+\n/g, "\n") // trailing spaces on lines
+    .replace(/\n{3,}/g, "\n\n") // collapse blank-line runs
+    .replace(/\s+$/g, ""); // trailing whitespace/newlines
+}
+
+/** A 10-segment green progress bar, e.g. `🟩🟩🟩🟩🟩⬜⬜⬜⬜⬜ 50%` (✅ at 100%). */
+export function progressBar(pct: number): string {
+  const v = Math.max(0, Math.min(100, Math.round(pct)));
+  const filled = Math.round((v / 100) * SEGMENTS);
+  const bar = FILLED.repeat(filled) + EMPTY.repeat(SEGMENTS - filled);
+  return `${bar} ${v}%${v >= 100 ? " \u2705" : ""}`;
+}

package/src/service/windows.ts

@@ -1,23 +1,68 @@
 /**
- * Windows service controller — runs the bot at logon via a hidden Scheduled
- * Task. A small .vbs launcher starts node with no console window; the app logs
- * to a file. Stop precisely targets our node process by command line.
+ * Windows service controller — runs the bot at logon. Preferred mechanism is a
+ * hidden ONLOGON Scheduled Task, but registering a logon-triggered task needs
+ * admin, so from a normal (non-elevated) terminal we fall back to a launcher in
+ * the per-user Startup folder — both run a small .vbs that starts node with no
+ * console window; the app logs to a file. Stop precisely targets our node
+ * process by command line, so it works regardless of how it was launched.
  */
-import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { runSafe } from "./platform.js";
 import type { LaunchSpec, ServiceController, ServiceResult } from "./types.js";
 
 const TASK = "KiroTelegramBot";
+/** Launcher dropped in the per-user Startup folder when no admin is available. */
+const STARTUP_VBS = "KiroTelegramBot.vbs";
+
+/** The per-user Startup folder (runs at logon for the current user, no admin).
+ *  Undefined only if APPDATA is unset (e.g. running with no roaming profile). */
+function startupDir(): string | undefined {
+  const appData = process.env.APPDATA;
+  return appData ? join(appData, "Microsoft", "Windows", "Start Menu", "Programs", "Startup") : undefined;
+}
+
+function startupVbsPath(): string | undefined {
+  const dir = startupDir();
+  return dir ? join(dir, STARTUP_VBS) : undefined;
+}
+
+/** Remove a leftover Startup-folder launcher (e.g. from an earlier non-elevated
+ *  install) so a task-based install never double-launches the bot at logon. */
+function removeStartupLauncher(): void {
+  const p = startupVbsPath();
+  if (p) rmSync(p, { force: true });
+}
+
+/** Canonical launcher in the bot folder (the Scheduled Task points at it). */
+function vbsPath(spec: LaunchSpec): string {
+  return join(spec.cwd, "run-service.vbs");
+}
+
+/** True when our hidden Scheduled Task is registered. */
+function taskInstalled(): boolean {
+  return runSafe("schtasks", ["/Query", "/TN", TASK]).ok;
+}
+
+/** True when a bot process matching this spec is currently running. Launch
+ *  paths use this to avoid starting a second instance — two pollers on one
+ *  bot token make Telegram return 409 Conflict. */
+function isRunning(spec: LaunchSpec): boolean {
+  const proc = runSafe("powershell", ["-NoProfile", "-Command", countScript(entryOf(spec))]);
+  return proc.ok && /[1-9]\d*/.test(proc.out.trim());
+}
 
 export const windowsController: ServiceController = {
   platform: "windows",
 
   async install(spec) {
     mkdirSync(spec.logsDir, { recursive: true });
-    const vbs = join(spec.cwd, "run-service.vbs");
+    const vbs = vbsPath(spec);
     writeFileSync(vbs, vbsLauncher(spec), "utf-8");
 
+    // Preferred: a hidden ONLOGON Scheduled Task. Registering a *logon-triggered*
+    // task is a privileged operation, so /Create succeeds only from an elevated
+    // (admin) terminal. From a normal terminal it returns "Access is denied".
     runSafe("schtasks", ["/Delete", "/F", "/TN", TASK]); // replace if present
     const res = runSafe("schtasks", [
       "/Create",
@@ -29,37 +74,87 @@ export const windowsController: ServiceController = {
       "/TR",
       `wscript.exe "${vbs}"`,
     ]);
-    if (!res.ok) return fail(`schtasks create failed: ${res.out}`);
-    runSafe("schtasks", ["/Run", "/TN", TASK]);
-    return ok(`Installed scheduled task "${TASK}" (starts at logon) and launched it.`);
+    if (res.ok) {
+      removeStartupLauncher(); // avoid a leftover launcher double-starting the bot
+      if (!isRunning(spec)) runSafe("schtasks", ["/Run", "/TN", TASK]);
+      return ok(`Installed scheduled task "${TASK}" (starts at logon) and launched it.`);
+    }
+
+    // A task may still exist that we just couldn't overwrite (e.g. created by an
+    // earlier elevated install). Reuse it rather than ALSO adding a Startup
+    // launcher, which would double-launch the bot at logon (409 Conflict).
+    if (taskInstalled()) {
+      removeStartupLauncher();
+      if (!isRunning(spec)) runSafe("schtasks", ["/Run", "/TN", TASK]);
+      return ok(`Scheduled task "${TASK}" already exists; launched it. (Re-run elevated to recreate it.)`);
+    }
+
+    // Fallback (no admin — the common case): drop the launcher in the per-user
+    // Startup folder. It runs hidden at every logon with no elevation.
+    const startupVbs = startupVbsPath();
+    const dir = startupDir();
+    if (!startupVbs || !dir) {
+      return fail(
+        `Could not create the logon task (${res.out.trim()}) and no per-user Startup folder is available. ` +
+          `Re-run "kiro-tg install" from an elevated terminal (Run as administrator).`,
+      );
+    }
+    try {
+      mkdirSync(dir, { recursive: true });
+      writeFileSync(startupVbs, vbsLauncher(spec), "utf-8");
+    } catch (e) {
+      return fail(`Startup-folder install failed: ${(e as Error).message}`);
+    }
+    if (!isRunning(spec)) runSafe("wscript.exe", [startupVbs]); // launch now
+    return ok(
+      `Installed via the Startup folder — starts hidden at logon, no admin needed — and launched it.\n` +
+        `(Tip: run "kiro-tg install" from an elevated terminal to use a hidden Scheduled Task instead.)`,
+    );
   },
 
   async uninstall(spec) {
     await this.stop(spec);
-    const res = runSafe("schtasks", ["/Delete", "/F", "/TN", TASK]);
-    rmSync(join(spec.cwd, "run-service.vbs"), { force: true });
-    return res.ok ? ok(`Removed scheduled task "${TASK}".`) : fail(res.out);
+    runSafe("schtasks", ["/Delete", "/F", "/TN", TASK]); // best-effort (may not exist)
+    rmSync(vbsPath(spec), { force: true });
+    const startupVbs = startupVbsPath();
+    if (startupVbs) rmSync(startupVbs, { force: true });
+    return ok(`Removed "${TASK}" (scheduled task and/or Startup launcher).`);
   },
 
-  async start() {
-    const res = runSafe("schtasks", ["/Run", "/TN", TASK]);
-    return res.ok ? ok("Started.") : fail(res.out);
+  async start(spec) {
+    if (isRunning(spec)) return ok("Already running.");
+    if (taskInstalled()) {
+      const res = runSafe("schtasks", ["/Run", "/TN", TASK]);
+      return res.ok ? ok("Started.") : fail(res.out);
+    }
+    const startupVbs = startupVbsPath();
+    if (startupVbs && existsSync(startupVbs)) {
+      runSafe("wscript.exe", [startupVbs]);
+      return ok("Started.");
+    }
+    return fail(`Not installed. Run "kiro-tg install" first.`);
   },
 
   async stop(spec) {
-    runSafe("schtasks", ["/End", "/TN", TASK]);
+    runSafe("schtasks", ["/End", "/TN", TASK]); // best-effort if task-based
     const res = runSafe("powershell", ["-NoProfile", "-Command", killScript(entryOf(spec))]);
     return ok(`Stopped. ${res.out.trim()}`);
   },
 
   async status(spec) {
-    const task = runSafe("schtasks", ["/Query", "/TN", TASK, "/FO", "LIST"]);
-    const proc = runSafe("powershell", ["-NoProfile", "-Command", countScript(entryOf(spec))]);
-    const running = proc.ok && /[1-9]\d*/.test(proc.out.trim());
-    const installed = task.ok;
+    const installedTask = taskInstalled();
+    const startupVbs = startupVbsPath();
+    const installedStartup = !!startupVbs && existsSync(startupVbs);
+    const installed = installedTask || installedStartup;
+    const running = isRunning(spec);
+    const how = installedTask ? "scheduled task" : installedStartup ? "Startup folder" : "—";
+    const detail = installedTask
+      ? `\n${runSafe("schtasks", ["/Query", "/TN", TASK, "/FO", "LIST"]).out.trim()}`
+      : installedStartup
+        ? `\nLauncher: ${startupVbs}`
+        : "";
     return ok(
-      `Installed: ${installed ? "yes" : "no"} | Running: ${running ? "yes" : "no"}\n` +
-        (installed ? task.out.trim() : "Task not found."),
+      `Installed: ${installed ? `yes (${how})` : "no"} | Running: ${running ? "yes" : "no"}${detail}`,
     );
   },
 };

package/src/sessions/history.ts

@@ -3,6 +3,7 @@
  * Reads only the tail of large logs to stay fast.
  */
 import { closeSync, openSync, readSync, statSync } from "node:fs";
+import { extractProgress, PROGRESS_DIRECTIVE } from "../render/progress.js";
 import type { HistoryEntry, HistoryRole } from "./types.js";
 
 const TAIL_WINDOWS = [256 * 1024, 1024 * 1024, 4 * 1024 * 1024]; // grow until entries found
@@ -141,7 +142,7 @@ function toEntry(ev: RawEvent): HistoryEntry | undefined {
   const role = roleOf(ev.kind);
   if (!role) return undefined;
 
-  const text = extractText(ev.data?.content);
+  const text = cleanStoredText(extractText(ev.data?.content));
   const tool = ev.data?.tool_name || ev.data?.name;
   if (!text && !tool) return undefined;
 
@@ -153,6 +154,16 @@ function toEntry(ev: RawEvent): HistoryEntry | undefined {
   };
 }
 
+/** Strip the `{progress: N%}` markers (any role) and the appended progress
+ *  directive (user prompts) from persisted text so history / unread / previews
+ *  / fork-priming never surface the raw plumbing. */
+function cleanStoredText(text: string): string {
+  if (!text) return text;
+  let t = extractProgress(text).cleaned;
+  if (t.includes(PROGRESS_DIRECTIVE)) t = t.split(PROGRESS_DIRECTIVE).join("").trim();
+  return t;
+}
+
 function roleOf(kind?: string): HistoryRole | undefined {
   switch (kind) {
     case "Prompt":

package/src/sessions/process.ts

@@ -0,0 +1,30 @@
+/**
+ * Process control helpers for Kiro sessions: force-killing the process that
+ * holds a session's `.lock` (its `lockPid`). Shared by /killall and the
+ * per-session kill button so the behaviour stays identical.
+ */
+import { execFileSync } from "node:child_process";
+import { createLogger } from "../logger.js";
+
+const log = createLogger("sessions:process");
+
+/**
+ * Force-kill a process by PID — and its child tree on Windows (`taskkill /T`),
+ * which a `kiro-cli` session may have spawned (shells, tools). Returns whether
+ * the kill command was issued without throwing. A non-existent PID or one we
+ * may not signal counts as failure (callers report it).
+ */
+export function killPid(pid: number): boolean {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    if (process.platform === "win32") {
+      execFileSync("taskkill", ["/F", "/T", "/PID", String(pid)], { stdio: "ignore" });
+    } else {
+      process.kill(pid, "SIGKILL");
+    }
+    return true;
+  } catch (e) {
+    log.debug(`kill ${pid} failed:`, (e as Error).message);
+    return false;
+  }
+}