harness-bujang 0.5.10 → 0.6.1

package/dist/{chat-6VQQYMBV.js → chat-XVTJ3XM7.js}

@@ -45,6 +45,16 @@ async function runChat(args) {
     `INSERT INTO harness_messages (id, "from", "to", type, message, severity)
      VALUES (?, ?, ?, ?, ?, ?)`
   );
+  const readStateRowsStmt = db.prepare(
+    `SELECT room, last_seen_at FROM harness_read_state`
+  );
+  const readStateUpsertStmt = db.prepare(
+    `INSERT INTO harness_read_state (room, last_seen_at, updated_at)
+     VALUES (?, ?, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+     ON CONFLICT(room) DO UPDATE SET
+       last_seen_at = excluded.last_seen_at,
+       updated_at   = excluded.updated_at`
+  );
   const port = await findOpenPort(opts.port);
   const server = http.createServer(async (req, res) => {
     const url2 = new URL(req.url ?? "/", `http://localhost:${port}`);
@@ -89,6 +99,39 @@ async function runChat(args) {
       }
       return;
     }
+    if (req.method === "GET" && url2.pathname === "/api/read-state") {
+      try {
+        const rows = readStateRowsStmt.all();
+        const map = {};
+        for (const r of rows) map[r.room] = r.last_seen_at;
+        res.writeHead(200, { "content-type": "application/json" });
+        res.end(JSON.stringify({ data: map }));
+      } catch (err) {
+        res.writeHead(500, { "content-type": "application/json" });
+        res.end(JSON.stringify({ data: {}, error: String(err) }));
+      }
+      return;
+    }
+    if (req.method === "POST" && url2.pathname === "/api/read-state") {
+      try {
+        const body = await readBody(req);
+        const parsed = JSON.parse(body);
+        const room = (parsed.room ?? "").trim();
+        const lastSeenAt = (parsed.last_seen_at ?? "").trim();
+        if (!room || !lastSeenAt) {
+          res.writeHead(400, { "content-type": "application/json" });
+          res.end(JSON.stringify({ error: "room and last_seen_at are required" }));
+          return;
+        }
+        readStateUpsertStmt.run(room, lastSeenAt);
+        res.writeHead(200, { "content-type": "application/json" });
+        res.end(JSON.stringify({ data: { room, last_seen_at: lastSeenAt } }));
+      } catch (err) {
+        res.writeHead(500, { "content-type": "application/json" });
+        res.end(JSON.stringify({ error: String(err) }));
+      }
+      return;
+    }
     res.writeHead(404);
     res.end("not found");
   });
@@ -203,6 +246,14 @@ var SCHEMA_SQL = `
   );
   CREATE INDEX IF NOT EXISTS harness_messages_timestamp_idx ON harness_messages(timestamp DESC);
   CREATE INDEX IF NOT EXISTS harness_messages_from_to_idx ON harness_messages("from", "to");
+
+  -- 0.6.1: per-room read marker (chat.db is the single source of truth, so
+  -- read state survives port changes / server restarts / browsers).
+  CREATE TABLE IF NOT EXISTS harness_read_state (
+    room          TEXT PRIMARY KEY,
+    last_seen_at  TEXT NOT NULL,
+    updated_at    TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+  );
 `;
 function renderHtml() {
   return (
@@ -290,12 +341,16 @@ const ROOMS = [
   { id: '\uC678\uBD80\uD300\uC6D0',         name: '\uC678\uBD80\uD300\uC6D0',      icon: '\u{1F310}', members: ['\uBD80\uC7A5', '\uC678\uBD80\uD300\uC6D0', '\uACF5\uB3D9\uB300\uD45C'] },
 ];
 
-const STORAGE_KEY = 'harness-bujang-read';
 const FILTER_KEY = 'harness-bujang-filter';
+// 0.6.1: Read state moved server-side (chat.db harness_read_state table) so
+// it survives port changes / server restarts / different browsers. The
+// localStorage 'harness-bujang-read' key from 0.5.x\u20130.6.0 is now ignored
+// (no migration needed \u2014 server first-run auto-marks current state as read).
 const state = {
   messages: [],
   selectedRoom: null,
-  readCounts: JSON.parse(localStorage.getItem(STORAGE_KEY) || '{}'),
+  /** room id \u2192 last_seen_at ISO timestamp. Populated by GET /api/read-state. */
+  readByRoom: {},
   filter: localStorage.getItem(FILTER_KEY) || 'all',  // 'all' | 'unread'
   loading: true,
 };
@@ -374,11 +429,16 @@ function render() {
   const infos    = state.messages.filter((m) => m.severity === 'info').length;
 
   // Pre-compute unread per room (for the filter button + badges).
+  // 0.6.1: count messages newer than the per-room last_seen_at marker
+  // returned by the server. Survives port changes / server restarts.
   const unreadByRoom = {};
   let totalUnread = 0;
   for (const room of ROOMS) {
-    const count = filterMessages(state.messages, room.id).length;
-    const unread = Math.max(0, count - (state.readCounts[room.id] || 0));
+    const roomMsgs = filterMessages(state.messages, room.id);
+    const lastSeen = state.readByRoom[room.id];
+    const unread = lastSeen
+      ? roomMsgs.filter((m) => m.timestamp > lastSeen).length
+      : roomMsgs.length;
     unreadByRoom[room.id] = unread;
     totalUnread += unread;
   }
@@ -529,12 +589,24 @@ function render() {
   });
 
   // Re-bind room-click handlers (room list).
+  // 0.6.1: persist read marker via POST /api/read-state (server is SoT) and
+  // also update the in-memory map so the badge clears immediately without
+  // waiting for the next 2s poll.
   document.querySelectorAll('[data-room-id]').forEach((el) => {
     el.addEventListener('click', () => {
-      state.selectedRoom = el.getAttribute('data-room-id');
-      const count = filterMessages(state.messages, state.selectedRoom).length;
-      state.readCounts[state.selectedRoom] = count;
-      localStorage.setItem(STORAGE_KEY, JSON.stringify(state.readCounts));
+      const roomId = el.getAttribute('data-room-id');
+      state.selectedRoom = roomId;
+      const last = getLastMessage(state.messages, roomId);
+      if (last) {
+        state.readByRoom[roomId] = last.timestamp;
+        // Fire-and-forget; if it fails the next 2s poll re-syncs from the
+        // server. We don't block the UI on the round-trip.
+        fetch('/api/read-state', {
+          method: 'POST',
+          headers: { 'content-type': 'application/json' },
+          body: JSON.stringify({ room: roomId, last_seen_at: last.timestamp }),
+        }).catch(() => {});
+      }
       render();
       const conv = document.getElementById('conversation');
       if (conv) conv.scrollTop = conv.scrollHeight;
@@ -560,9 +632,15 @@ function render() {
 
 async function refresh() {
   try {
-    const res = await fetch('/api/messages?days=14');
-    const json = await res.json();
-    state.messages = (json.data || []).map((m) => ({
+    // 0.6.1: fetch messages + read-state in parallel. chat.db is SoT for
+    // read state, so port/server/browser changes don't reset it.
+    const [msgRes, readRes] = await Promise.all([
+      fetch('/api/messages?days=14'),
+      fetch('/api/read-state'),
+    ]);
+    const msgJson = await msgRes.json();
+    const readJson = await readRes.json();
+    state.messages = (msgJson.data || []).map((m) => ({
       id: m.id,
       timestamp: m.timestamp,
       from: m.from,
@@ -571,6 +649,32 @@ async function refresh() {
       message: m.message,
       severity: m.severity || undefined,
     }));
+    state.readByRoom = readJson.data || {};
+
+    // First-run auto-mark: if the server returned an empty read-state but we
+    // have messages, this is a fresh upgrade from 0.6.0. Mark every room's
+    // current last message as read so the user only sees genuinely-new
+    // messages flagged unread from here on.
+    if (
+      Object.keys(state.readByRoom).length === 0 &&
+      state.messages.length > 0
+    ) {
+      const initial = {};
+      for (const room of ROOMS) {
+        const last = getLastMessage(state.messages, room.id);
+        if (last) initial[room.id] = last.timestamp;
+      }
+      state.readByRoom = initial;
+      // Persist to server (fire-and-forget per room \u2014 small N, ~18 calls).
+      for (const [room, ts] of Object.entries(initial)) {
+        fetch('/api/read-state', {
+          method: 'POST',
+          headers: { 'content-type': 'application/json' },
+          body: JSON.stringify({ room, last_seen_at: ts }),
+        }).catch(() => {});
+      }
+    }
+
     state.loading = false;
     render();
   } catch (e) {

package/dist/{chunk-FE2GLGVF.js → chunk-6LROBVZM.js}

@@ -6,7 +6,7 @@ import {
 import * as fs2 from "fs/promises";
 import * as path2 from "path";
 import { fileURLToPath } from "url";
-import { select, confirm } from "@inquirer/prompts";
+import { select, confirm, checkbox } from "@inquirer/prompts";
 
 // src/scan.ts
 import * as fs from "fs/promises";
@@ -169,6 +169,27 @@ async function resolveAssetPaths() {
 If installed via npm, try reinstalling. If running from source, run "npm run build" in packages/cli first.`
   );
 }
+var ALL_ADAPTERS = ["cursor", "cline", "aider", "codex", "gemini"];
+var BALANCED_MAPPING = {
+  director: "opus",
+  cofounder: "opus",
+  "architect-team": "opus",
+  consultant: "opus",
+  "security-team": "opus",
+  "db-guard-team": "opus",
+  "dev-team": "sonnet",
+  "code-review-team": "sonnet",
+  "qa-team": "sonnet",
+  "doc-sync-team": "sonnet",
+  "research-team": "sonnet",
+  "analysis-team": "sonnet",
+  "script-team": "sonnet",
+  "verifier-team": "haiku",
+  "image-team": "haiku",
+  "voice-team": "haiku",
+  "edit-team": "haiku",
+  "content-qa-team": "haiku"
+};
 async function runInit(args) {
   let opts = parseArgs(args);
   const assets = await resolveAssetPaths();
@@ -211,6 +232,8 @@ async function runInit(args) {
   console.log(c.bold("\u{1F4CB} Configuration"));
   console.log(c.dim(`   Language:      ${opts.lang}`));
   console.log(c.dim(`   Chat backend:  ${opts.chatBackend}${opts.chatBackend === "sqlite" ? " (local file)" : " (cloud Postgres)"}`));
+  console.log(c.dim(`   Tools:         claude${opts.adapters.length > 0 ? ` + ${opts.adapters.join(", ")}` : " (only)"}`));
+  console.log(c.dim(`   Models:        ${describeModelMap(opts.modelMap)}`));
   if (scan.framework.startsWith("Next.js")) {
     console.log(c.dim(`   Chat-room UI:  ${opts.installTemplate ? "install" : "skip"}`));
   }
@@ -287,8 +310,12 @@ async function runInit(args) {
       continue;
     }
     const raw = await fs2.readFile(path2.join(agentsSrc, f), "utf8");
-    await fs2.writeFile(dst, renderTemplate(raw, context));
-    console.log(`   ${c.green("\u2713")}  ${f}`);
+    const slug = f.replace(/\.md$/, "");
+    const override = opts.modelMap[slug];
+    const rendered = renderTemplate(raw, context);
+    const final = override ? overrideModelFrontmatter(rendered, override) : rendered;
+    await fs2.writeFile(dst, final);
+    console.log(`   ${c.green("\u2713")}  ${f}${override ? c.dim(`  \u2192 model: ${override}`) : ""}`);
   }
   console.log();
   if (opts.editClaudeMd) {
@@ -380,6 +407,16 @@ async function runInit(args) {
       console.log();
     }
   }
+  if (opts.adapters.length > 0) {
+    console.log(c.bold("\u{1F501} Fanning out to extra tool adapters"));
+    console.log(c.dim(`   Targets: ${opts.adapters.join(", ")}`));
+    const { runAdapt } = await import("./adapt-VPWOYF6W.js");
+    await runAdapt([
+      `--to=${opts.adapters.join(",")}`,
+      `--target=${opts.target}`,
+      "--yes"
+    ]);
+  }
   console.log(c.bold(c.green("\u2705 Done.")));
   console.log();
   console.log("Next steps:");
@@ -431,6 +468,35 @@ async function promptInteractive(opts, scan) {
     ],
     default: opts.chatBackend
   });
+  const isPreset = (t) => opts.adapters.includes(t);
+  const adapters = await checkbox({
+    message: "Extra tool adapters? (Claude Code is always installed at .claude/agents/ \u2014 these add files for OTHER tools)",
+    choices: [
+      { name: "Cursor          (.cursor/rules/bujang-*.mdc)", value: "cursor", checked: isPreset("cursor") },
+      { name: "Codex / Copilot (AGENTS.md)", value: "codex", checked: isPreset("codex") },
+      { name: "Cline           (.clinerules/bujang-*.md)", value: "cline", checked: isPreset("cline") },
+      { name: "Aider           (CONVENTIONS.md + .aider.conf.yml)", value: "aider", checked: isPreset("aider") },
+      { name: "Gemini / Antigravity (GEMINI.md + .gemini/styleguide.md)", value: "gemini", checked: isPreset("gemini") }
+    ],
+    required: false
+  });
+  const preset = await select({
+    message: "Per-agent Claude model? (only affects .claude/agents/ \u2014 other tools manage models themselves)",
+    choices: [
+      { name: "balanced \u2014 opus / sonnet / haiku mix (recommended, ~60% cost cut)", value: "balanced" },
+      { name: "keep     \u2014 leave each agent's default model untouched", value: "keep" },
+      { name: "cost     \u2014 all haiku (cheapest, fastest)", value: "cost" },
+      { name: "quality  \u2014 all opus (most expensive, highest quality)", value: "quality" },
+      { name: "custom   \u2014 pick model per agent (18 prompts)", value: "custom" }
+    ],
+    default: "balanced"
+  });
+  let modelMap = {};
+  if (preset === "custom") {
+    modelMap = await promptCustomModelMap();
+  } else {
+    modelMap = resolvePreset(preset);
+  }
   let installTemplate = opts.installTemplate;
   if (scan.framework.startsWith("Next.js") && opts.installTemplate) {
     installTemplate = await confirm({
@@ -438,7 +504,26 @@ async function promptInteractive(opts, scan) {
       default: true
     });
   }
-  return { ...opts, lang, chatBackend, installTemplate };
+  return { ...opts, lang, chatBackend, installTemplate, adapters, modelMap };
+}
+async function promptCustomModelMap() {
+  const out = {};
+  const slugs = Object.keys(BALANCED_MAPPING);
+  console.log();
+  console.log(c.dim(`   Custom mapping \u2014 pick a model for each of ${slugs.length} agents.`));
+  for (const slug of slugs) {
+    const tier = await select({
+      message: `${slug.padEnd(20)}`,
+      choices: [
+        { name: "opus   (heaviest, smartest)", value: "opus" },
+        { name: "sonnet (balanced)", value: "sonnet" },
+        { name: "haiku  (lightest, fastest, cheap)", value: "haiku" }
+      ],
+      default: BALANCED_MAPPING[slug] ?? "sonnet"
+    });
+    out[slug] = tier;
+  }
+  return out;
 }
 function parseArgs(args) {
   const lang = getFlag(args, "--lang") ?? "ko";
@@ -450,6 +535,30 @@ function parseArgs(args) {
     throw new Error(`--chat must be "sqlite" or "supabase", got "${chatBackend}"`);
   }
   const targetRaw = getFlag(args, "--target") ?? ".";
+  const toolsRaw = getFlag(args, "--tools");
+  let adapters = [];
+  if (toolsRaw) {
+    const parts = toolsRaw === "all" ? ALL_ADAPTERS.slice() : toolsRaw.split(",").map((t) => t.trim()).filter(Boolean);
+    for (const t of parts) {
+      if (t === "claude" || t === "claude-code") continue;
+      if (!ALL_ADAPTERS.includes(t)) {
+        throw new Error(
+          `Unknown tool "${t}" in --tools. Allowed: claude, ${ALL_ADAPTERS.join(", ")}, all`
+        );
+      }
+      if (!adapters.includes(t)) adapters.push(t);
+    }
+  }
+  const modelsRaw = getFlag(args, "--models");
+  let modelMap = {};
+  if (modelsRaw) {
+    if (!["balanced", "cost", "quality", "keep"].includes(modelsRaw)) {
+      throw new Error(
+        `--models must be one of: balanced, cost, quality, keep (got "${modelsRaw}")`
+      );
+    }
+    modelMap = resolvePreset(modelsRaw);
+  }
   return {
     lang,
     target: path2.resolve(targetRaw),
@@ -460,9 +569,19 @@ function parseArgs(args) {
     installTemplate: !args.includes("--no-template"),
     editClaudeMd: !args.includes("--no-claude-md"),
     seedLearningLog: !args.includes("--no-learning-log"),
-    yes: args.includes("--yes") || args.includes("-y")
+    yes: args.includes("--yes") || args.includes("-y"),
+    adapters,
+    modelMap
   };
 }
+function resolvePreset(preset) {
+  if (preset === "keep") return {};
+  if (preset === "balanced") return { ...BALANCED_MAPPING };
+  const tier = preset === "cost" ? "haiku" : "opus";
+  const out = {};
+  for (const k of Object.keys(BALANCED_MAPPING)) out[k] = tier;
+  return out;
+}
 function getFlag(args, name) {
   for (const a of args) {
     if (a.startsWith(`${name}=`)) return a.slice(name.length + 1);
@@ -571,6 +690,26 @@ function printBackendInstructions(backend, commitChat) {
   }
   console.log();
 }
+function overrideModelFrontmatter(content, model) {
+  if (!content.startsWith("---\n")) return content;
+  const end = content.indexOf("\n---\n", 4);
+  if (end < 0) return content;
+  const fmRaw = content.slice(0, end);
+  const rest = content.slice(end);
+  const newFm = /^model:\s*\S+/m.test(fmRaw) ? fmRaw.replace(/^model:\s*\S+/m, `model: ${model}`) : fmRaw + `
+model: ${model}`;
+  return newFm + rest;
+}
+function describeModelMap(map) {
+  if (Object.keys(map).length === 0) return "keep (use each agent's default)";
+  const counts = { opus: 0, sonnet: 0, haiku: 0 };
+  for (const v of Object.values(map)) counts[v]++;
+  const parts = [];
+  for (const tier of ["opus", "sonnet", "haiku"]) {
+    if (counts[tier] > 0) parts.push(`${counts[tier]} ${tier}`);
+  }
+  return parts.join(" \xB7 ");
+}
 function stackReviewRules(framework) {
   if (framework.startsWith("Next.js")) {
     return `Next.js App Router rules:

package/dist/index.js

@@ -1,6 +1,19 @@
 #!/usr/bin/env node
 
 // src/index.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+async function readVersion() {
+  try {
+    const pkgRaw = await fs.readFile(path.resolve(__dirname, "..", "package.json"), "utf8");
+    return JSON.parse(pkgRaw).version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
 var c = {
   bold: (s) => `\x1B[1m${s}\x1B[22m`,
   dim: (s) => `\x1B[2m${s}\x1B[22m`,
@@ -25,6 +38,10 @@ ${c.bold("Options for init:")}
   --lang=<ko|en>           Agent language (default: ko \u2014 full \uBD80\uC7A5 persona)
   --chat=<sqlite|supabase> Chat-room backend (default: sqlite \u2014 local file, no setup)
   --commit-chat            Don't gitignore .harness/ (for solo cross-machine sync via git)
+  --tools=<list>           Extra tool adapters: cursor,cline,aider,codex,gemini,all
+                           (Claude Code is always installed at .claude/agents/)
+  --models=<preset>        Per-agent Claude model preset: balanced (recommended),
+                           keep (default), cost (all haiku), quality (all opus)
   --target=<path>          Project root (default: cwd)
   --framework=<name>       Override detected framework
   --db=<name>              Override detected project DB (separate from --chat)
@@ -90,26 +107,26 @@ async function main() {
   const command = args[0];
   switch (command) {
     case "init":
-      await (await import("./init-S3YF6RT4.js")).runInit(args.slice(1));
+      await (await import("./init-4G7R63DX.js")).runInit(args.slice(1));
       break;
     case "status":
       await (await import("./status-UE2TQQPU.js")).runStatus(args.slice(1));
       break;
     case "chat":
-      await (await import("./chat-6VQQYMBV.js")).runChat(args.slice(1));
+      await (await import("./chat-XVTJ3XM7.js")).runChat(args.slice(1));
       break;
     case "adapt":
       await (await import("./adapt-VPWOYF6W.js")).runAdapt(args.slice(1));
       break;
     case "update":
-      await (await import("./update-4WS42LXD.js")).runUpdate(args.slice(1));
+      await (await import("./update-KHDRQZQE.js")).runUpdate(args.slice(1));
       break;
     case "migrate":
       await (await import("./migrate-PISZFX6C.js")).runMigrate(args.slice(1));
       break;
     case "--version":
     case "-v":
-      console.log("0.5.9");
+      console.log(await readVersion());
       break;
     case "--help":
     case "-h":

package/dist/{init-S3YF6RT4.js → init-4G7R63DX.js}

@@ -1,7 +1,7 @@
 import {
   printRestartReminder,
   runInit
-} from "./chunk-FE2GLGVF.js";
+} from "./chunk-6LROBVZM.js";
 import "./chunk-7DAHO2GN.js";
 export {
   printRestartReminder,

package/dist/{update-4WS42LXD.js → update-KHDRQZQE.js}

@@ -1,7 +1,7 @@
 import {
   printRestartReminder,
   scanProject
-} from "./chunk-FE2GLGVF.js";
+} from "./chunk-6LROBVZM.js";
 import {
   renderTemplate
 } from "./chunk-7DAHO2GN.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "harness-bujang",
-  "version": "0.5.10",
+  "version": "0.6.1",
   "description": "Install the Harness-Bujang multi-agent harness into any project — Director, 7 specialist teams, real-time chat-room UI. Korean and English personas. Works with Claude Code, Cursor, Cline, Aider, or any tool that reads .claude/agents/.",
   "keywords": [
     "claude-code",